पाइपलाइन एक जटिल चेहरे की पहचान तकनीक से शुरू होती है जो किसी भी वीडियो फ़्रेम में वक्ताओं को ढूंढ सकती है। एक बार चेहरे की पहचान होने के बाद, सिस्टम सटीक चेहरे के लैंडमार्क निकालता है - मुँह, आँखों और अन्य चेहरे की विशेषताओं के चारों ओर 468 प्रमुख बिंदुओं को मैप करता है।

यह विस्तृत मैपिंग सिस्टम को किसी भी क्षण में वक्ता के मुँह के आकार और स्थिति को समझने की अनुमति देती है, जो सटीक लिप समन्वय के लिए आधार बनाती है। यह तकनीक विभिन्न प्रकाश स्थितियों, कोणों, और यहां तक कि फ़्रेम में कई लोगों के साथ भी विश्वसनीय रूप से काम करती है।

ऑडियो प्रोसेसिंग पाइपलाइन लक्षित भाषण को अस्थायी विशेषताओं में परिवर्तित करती है जो लिप-सिंक जनरेशन को चलाती हैं। सिस्टम मेल-स्पेक्ट्रोग्राम (80 मेल बिन, 1024 FFT, 160 हॉप), MFCCs, और Wav2Vec2 एम्बेडिंग (facebook/wav2vec2-base) और librosa प्रीप्रोसेसिंग के माध्यम से फ़ोनम संरेखण निकालता है। कार्यान्वयन लहरफॉर्म को librosa.load() के माध्यम से लोड करता है, librosa.feature.melspectrogram() को dB स्केल में परिवर्तित करता है, Wav2Vec2Processor/Wav2Vec2Model के माध्यम से संदर्भ एम्बेडिंग (last_hidden_state) के लिए प्रोसेस करता है, और सटीक विज़ेम समय के लिए मजबूर संरेखण (get_phoneme_alignment(audio_path, transcript)) लागू करता है। लौटाया गया डिक्ट मेल_spectrogram, ऑडियो_embeddings, और फ़ोनम_alignment को शामिल करता है—स्पेक्ट्रल एन्वेलप्स, अस्थायी फ़ोनम सीमाएँ, और अर्थपूर्ण भाषण पैटर्न जो सीधे आर्टिकुलेटरी मुँह की काइनेमेटिक्स से मेल खाते हैं।

मुख्य लिप सिंक जनरेशन जटिल न्यूरल आर्किटेक्चर का उपयोग करता है जो ऑडियो विशेषताओं को संबंधित मुँह की हरकतों से मैप करता है। आधुनिक सिस्टम अस्थायी संक्रामक नेटवर्क, ट्रांसफार्मर, और GANs के संयोजनों का उपयोग करते हैं ताकि लक्षित ऑडियो के साथ मेल खाने वाले यथार्थवादी लिप आकार उत्पन्न किए जा सकें जबकि वक्ता की पहचान को बनाए रखा जा सके।

तकनीकी कार्यान्वयन:

लिप मूवमेंट जनरेशन अस्थायी GAN का उपयोग करके

import torch
import torch.nn as nn

class LipSyncGenerator(nn.Module):
def __init__(self, audio_dim=80, landmark_dim=51, hidden_dim=512):
super().__init__()

# ऑडियो एन्कोडर
self.audio_encoder = nn.Sequential(
nn.Conv1d(audio_dim, hidden_dim, kernel_size=3, padding=1),
nn.ReLU(),
nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, padding=1),
nn.ReLU(),
)

# अनुक्रम मॉडलिंग के लिए अस्थायी ट्रांसफार्मर
self.temporal_transformer = nn.TransformerEncoder(
nn.TransformerEncoderLayer(
d_model=hidden_dim,
nhead=8,
dim_feedforward=hidden_dim * 4
),
num_layers=6
)

# लैंडमार्क डिकोडर
self.landmark_decoder = nn.Sequential(
nn.Linear(hidden_dim, hidden_dim),
nn.ReLU(),
nn.Linear(hidden_dim, landmark_dim),
nn.Tanh() # लैंडमार्क समन्वय को सामान्यीकृत करें
)

# पहचान संरक्षण परत
self.identity_encoder = nn.Sequential(
nn.Linear(landmark_dim * 2, hidden_dim), # वर्तमान + संदर्भ लैंडमार्क
nn.ReLU(),
nn.Linear(hidden_dim, hidden_dim)
)

def forward(self, audio_features, reference_landmarks):
# ऑडियो विशेषताओं को एन्कोड करें
audio_encoded = self.audio_encoder(audio_features)
audio_encoded = audio_encoded.transpose(1, 2) # (B, T, D)

# अस्थायी मॉडलिंग लागू करें
temporal_features = self.temporal_transformer(audio_encoded)

# लैंडमार्क मूवमेंट उत्पन्न करें
generated_landmarks = self.landmark_decoder(temporal_features)

# वक्ता की पहचान बनाए रखें
identity_features = self.identity_encoder(
torch.cat([generated_landmarks, reference_landmarks], dim=-1)
)

# पहचान संरक्षण के साथ उत्पन्न मूवमेंट को मिलाएं
final_landmarks = generated_landmarks + 0.1 * identity_features

return final_landmarks

जनरेटर को प्रारंभ करें और प्रशिक्षित करें

generator = LipSyncGenerator()
optimizer = torch.optim.Adam(generator.parameters(), lr=1e-4)

प्रतिकूल हानि के साथ प्रशिक्षण लूप

def train_lip_sync_model(generator, discriminator, dataloader, epochs=100):
for epoch in range(epochs):
for batch in dataloader:
audio_features, reference_landmarks, target_landmarks = batch

# नकली लैंडमार्क उत्पन्न करें
fake_landmarks = generator(audio_features, reference_landmarks)

# प्रतिकूल प्रशिक्षण
real_loss = discriminator(target_landmarks)
fake_loss = discriminator(fake_landmarks)

# जनरेटर हानि (प्रतिकूल + पुनर्निर्माण)
g_loss = -fake_loss.mean() + nn.MSELoss()(fake_landmarks, target_landmarks)

# बैकप्रोपगेशन
optimizer.zero_grad()
g_loss.backward()
optimizer.step()

जनरेटर ऑडियो विशेषताओं को संबंधित मुँह की हरकतों में मैप करना सीखता है जबकि भेदक यथार्थता सुनिश्चित करता है। पहचान संरक्षण घटक वक्ता की अद्वितीय चेहरे की विशेषताओं को बनाए रखता है।

चेहरे का पुनर्निर्माण उत्पन्न लिप मूवमेंट को मूल चेहरे की विशेषताओं के साथ मिलाता है, एक निर्बाध अंतिम परिणाम बनाता है। यह चरण छवि-आधारित रेंडरिंग, पॉइसन मिश्रण, और अस्थायी स्मूदिंग का उपयोग करता है ताकि नए मुँह के क्षेत्रों को मौजूदा भावनाओं के साथ मिलाया जा सके जबकि प्राकृतिक उपस्थिति बनाए रखी जा सके।

अंतिम चरण अस्थायी स्मूदिंग, रंग सुधार, और कलाकृतियों को हटाने को लागू करता है ताकि पेशेवर-गुणवत्ता आउटपुट सुनिश्चित किया जा सके। उन्नत सिस्टम स्थिरता जांच के लिए ऑप्टिकल फ्लो का उपयोग करते हैं और मानव समीक्षा से पहले संभावित मुद्दों का पता लगाने के लिए स्वचालित गुणवत्ता मैट्रिक्स का उपयोग करते हैं।