Comment cloner une voix et synchroniser les lèvres dans une vidéo comme un professionnel en utilisant des outils open-source

Maîtrisez l'art du clonage vocal et de la synchronisation labiale dans une vidéo, tel un professionnel, en utilisant des outils open-source

Introduction

La clonage vocal basé sur l’IA a fait sensation sur les réseaux sociaux. Il a ouvert un monde de possibilités créatives. Vous avez sûrement vu des mèmes ou des doublages de voix basés sur l’IA de personnalités célèbres sur les réseaux sociaux. Vous vous demandez peut-être comment cela est fait ? Certes, de nombreuses plateformes proposent des API comme Eleven Labs, mais pouvons-nous le faire gratuitement en utilisant des logiciels open source ? La réponse courte est OUI. L’open-source dispose de modèles TTS et d’outils de synchronisation labiale pour réaliser une synthèse vocale. Ainsi, dans cet article, nous explorerons les outils open source et les modèles de clonage vocal et de synchronisation labiale.

Objectifs d’apprentissage

  • Explorer les outils open source pour le clonage vocal basé sur l’IA et la synchronisation labiale.
  • Utiliser FFmpeg et Whisper pour transcrire des vidéos.
  • Utiliser le modèle xTTS de Coqui-AI pour cloner des voix.
  • Utiliser Wav2Lip pour la synchronisation labiale des vidéos.
  • Explorer des cas d’utilisation réels de cette technologie.

Cet article a été publié dans le cadre du Data Science Blogathon.

Stack Open Source

Comme vous le savez déjà, nous utiliserons Whisper d’OpenAI, FFmpeg, le modèle xTTS de Coqui-ai et Wav2lip comme notre pile technologique. Mais avant de plonger dans les codes, discutons brièvement de ces outils. Et aussi merci aux auteurs de ces projets.

Whisper : Whisper est le modèle ASR (Automatic Speech Recognition) d’OpenAI. Il s’agit d’un modèle transformateur encodeur-décodeur entraîné sur plus de 650 000 heures de données audio diverses et de leurs transcriptions correspondantes. Il est donc très efficace pour la transcription multilingue à partir de l’audio.

Les encodeurs reçoivent le spectrogramme en log-mel de tronçons audio de 30 secondes. Chaque bloc encodeur utilise l’auto-attention pour comprendre les différentes parties des signaux audio. Le décodeur reçoit ensuite des informations d’état caché des encodeurs et des encodages de position appris. Le décodeur utilise l’auto-attention et la cross-attention pour prédire le jeton suivant. À la fin du processus, il produit une séquence de jetons représentant le texte reconnu. Pour plus d’informations sur Whisper, consultez le référentiel officiel.

Coqui TTS : TTS est une bibliothèque open source de Coqui-ai. Elle héberge plusieurs modèles de synthèse vocale à partir du texte. Elle dispose de modèles de bout en bout comme Bark, Tortoise et xTTS, de modèles de spectrogramme comme Glow-TTS, FastSpeech, etc., et de vocoder comme Hifi-GAN, MelGAN, etc. De plus, elle fournit une API unifiée pour l’inférence, l’adaptation fine et l’entraînement de modèles de synthèse vocale à partir du texte. Dans ce projet, nous utiliserons xTTS, un modèle de clonage vocal multilingue de bout en bout. Il prend en charge 16 langues, dont l’anglais, le japonais, l’hindi, le mandarin, etc. Pour plus d’informations sur TTS, consultez le référentiel officiel TTS.

Wav2Lip : Wav2Lip est un référentiel Python pour le document “A Lip Sync Expert Is All You Need for Speech to Lip Generation In the Wild”. Il utilise un discriminateur de synchronisation labiale pour reconnaître les mouvements du visage et des lèvres. Cela fonctionne très bien pour le doublage de voix. Pour plus d’informations, reportez-vous au référentiel officiel. Nous utiliserons cette version forkée de Wav2Lip.

Flux de travail

Maintenant que nous sommes familiers avec les outils et les modèles que nous allons utiliser, comprenons le flux de travail. Il s’agit d’un flux de travail simple. Voici donc ce que nous allons faire.

  • Uploader une vidéo dans l’environnement d’exécution Colab et la redimensionner en format 720p pour une meilleure synchronisation labiale.
  • Utiliser FFmpeg pour extraire un audio 24 bits de la vidéo et utiliser Whisper pour transcrire le fichier audio.
  • Utiliser Google Translate ou LLM pour traduire le script transcrit dans une autre langue.
  • Charger le modèle xTTS multi-lingue avec la bibliothèque TTS et transmettre le script ainsi que le modèle audio de référence pour la synthèse vocale.
  • Cloner le référentiel Wav2lip et télécharger les points de contrôle du modèle. Exécuter le fichier inference.py pour synchroniser la vidéo originale avec l’audio synthétisé.

Maintenant, plongeons dans les codes.

Étape 1 : Installer les dépendances

Ce projet nécessite une consommation importante de RAM et de GPU, il est donc judicieux d’utiliser un environnement d’exécution Colab. La version gratuite de Colab fournit 12 Go de RAM et 15 Go de GPU T4, ce qui devrait être suffisant pour ce projet. Allez donc sur votre Colab et connectez-vous à un environnement d’exécution avec GPU.

Maintenant, installez TTS et Whisper.

!pip install TTS!pip install git+https://github.com/openai/whisper.git 

Étape 2 : Télécharger des vidéos sur Colab

Maintenant, nous allons télécharger une vidéo et la redimensionner au format 720p. Wav2lip a tendance à mieux fonctionner lorsque les vidéos sont au format 720p. Cela peut être fait à l’aide de FFmpeg.

#@title Télécharger la vidéofrom google.colab import filesimport osimport subprocessuploaded = Noneresize_to_720p = Falsedef upload_video():  global uploaded  global video_path  # Déclare video_path en tant que global pour le modifier  uploaded = files.upload()  for filename in uploaded.keys():    print(f'Vidéo téléchargée : {filename}')    if resize_to_720p:        filename = resize_video(filename)  # Obtenir le nom de la vidéo redimensionnée    video_path = filename  # Mettre à jour video_path avec le nom de fichier d'origine ou redimensionné    return filenamedef resize_video(filename):    output_filename = f"resized_{filename}"    cmd = f"ffmpeg -i {filename} -vf 'scale=-1:720' {output_filename}"    subprocess.run(cmd, shell=True)    print(f'Vidéo redimensionnée enregistrée sous {output_filename}')    return output_filename# Créer un bouton de formulaire qui appelle upload_video lorsqu'il est cliqué et une case à cocher pour le redimensionnementimport ipywidgets as widgetsfrom IPython.display import displaybutton = widgets.Button(description="Télécharger la vidéo")checkbox = widgets.Checkbox(value=False, description='Redimensionner en 720p (meilleurs résultats)')output = widgets.Output()def on_button_clicked(b):  with output:    global video_path    global resize_to_720p    resize_to_720p = checkbox.value    video_path = upload_video()button.on_click(on_button_clicked)display(checkbox, button, output)

Cela affichera un bouton de formulaire pour télécharger des vidéos à partir d’un appareil local et une case à cocher pour activer le redimensionnement en 720p. Vous pouvez également télécharger manuellement une vidéo dans la session Colab actuelle et la redimensionner à l’aide d’un sous-processus.

Étape 3 : Extraction audio et transcription Whisper

Maintenant que nous avons notre vidéo, la prochaine chose que nous ferons est d’extraire l’audio à l’aide de FFmpeg, puis d’utiliser Whisper pour le transcrire.

# @title Extraction audio (24 bits) et conversion Whisperimport subprocess# Assurez-vous que la variable video_path existe et n'est pas Nonesi 'video_path' in globals() and video_path is not None:    ffmpeg_command = f"ffmpeg -i '{video_path}' -acodec pcm_s24le -ar 48000 -q:a 0 -map a\                       -y 'output_audio.wav'"    subprocess.run(ffmpeg_command, shell=True)else:    print("Aucune vidéo téléchargée. Veuillez d'abord télécharger une vidéo.")import whispermodel = whisper.load_model("base")result = model.transcribe("output_audio.wav")whisper_text = result["text"]whisper_language = result['language']print("Texte Whisper :", whisper_text)

Cela extraira l’audio de la vidéo au format 24 bits et utilisera le modèle Whisper Base pour le transcrire. Pour une meilleure transcription, utilisez les modèles Whisper small ou VoAGI.

Étape 4 : Synthèse vocale

Maintenant, passons à la partie de clonage vocal. Comme je l’ai mentionné précédemment, nous utiliserons le modèle xTTS de Coqui-ai. Il s’agit de l’un des meilleurs modèles open-source pour la synthèse vocale. Coqui-ai propose également de nombreux modèles TTS pour différents usages ; n’hésitez pas à les consulter. Pour notre cas d’utilisation, qui est le clonage vocal, nous utiliserons le modèle xTTS v2.

Chargez le modèle xTTS. Il s’agit d’un gros modèle d’une taille de 1,87 Go. Cela prendra donc un certain temps.

# @title Synthèse vocalefrom TTS.api import TTSimport torchfrom IPython.display import Audio, display  # Importation des modules Audio et displaydevice = "cuda" if torch.cuda.is_available() else "cpu"# Initialiser TTStts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)

XTTS prend actuellement en charge 16 langues. Voici les codes ISO des langues supportées par le modèle xTTS.

print(tts.languages)['en','es','fr','de','it','pt','pl','tr','ru','nl','cs','ar','zh-cn','hu','ko','ja','hi']

Remarque : Les langues comme l’anglais et le français n’ont pas de limite de caractères, tandis que le hindi a une limite de 250 caractères. D’autres langues peuvent également avoir une limite.

Pour ce projet, nous utiliserons la langue hindi, mais vous pouvez également expérimenter avec d’autres.

Donc, la première chose dont nous avons maintenant besoin est de traduire le texte transcrit en hindi. Cela peut être fait soit avec le package Google Translate, soit en utilisant un modèle de LLM. D’après mes observations, GPT-3.5-Turbo fonctionne beaucoup mieux que Google Translate. Nous pouvons utiliser l’API OpenAI pour obtenir notre traduction.

import openaiclient = openai.OpenAI(api_key = "api_key")completion = client.chat.completions.create(  model="gpt-3.5-turbo",  messages=[    {"role": "system", "content": "Vous êtes un assistant utile."},    {"role": "user", "content": f"traduisez les textes en hindi {whisper_text}"}  ])translated_text = completion.choices[0].messageprint(translated_text)

Comme nous le savons, le hindi a une limite de caractères, nous devons donc effectuer un prétraitement du texte avant de le passer au modèle TTS. Nous devons diviser le texte en morceaux de moins de 250 caractères.

text_chunks = translated_text.split(sep = "।")final_chunks = [""]for chunk in text_chunks:  if not final_chunks[-1] or len(final_chunks[-1])+len(chunk)<250:    chunk += "।"    final_chunks[-1]+=chunk.strip()  else:    final_chunks.append(chunk+"।".strip())final_chunks

Ceci est un diviseur très simple. Vous pouvez en créer un différent ou utiliser le diviseur de texte récursif de Langchain. Maintenant, nous allons passer chaque morceau au modèle TTS. Les fichiers audio résultants seront fusionnés à l’aide de FFmpeg.

def audio_synthesis(text, file_name):  tts.tts_to_file(      text,      speaker_wav='output_audio.wav',      file_path=file_name,      language="hi"  )  return file_namefile_names = []for i in range(len(final_chunks)):    file_name = audio_synthesis(final_chunks[i], f"output_synth_audio_{i}.wav")    file_names.append(file_name)

Comme tous les fichiers ont le même codec, nous pouvons les fusionner facilement avec FFmpeg. Pour ce faire, créez un fichier Txt et ajoutez les chemins des fichiers.

# this is a commentfile 'output_synth_audio_0.wav'file 'output_synth_audio_1.wav'file 'output_synth_audio_2.wav'

Ensuite, exécutez le code ci-dessous pour fusionner les fichiers.

import subprocesscmd = "ffmpeg -f concat -safe 0 -i my_files.txt -c copy final_output_synth_audio_hi.wav"subprocess.run(cmd, shell=True)

Cela générera le fichier audio final concaténé. Vous pouvez également lire l’audio dans Colab.

from IPython.display import Audio, displaydisplay(Audio(filename="final_output_synth_audio_hi.wav", autoplay=False))

Étape 5 : Lip-Syncing

Maintenant, passons à la partie lip-syncing. Pour synchroniser notre audio synthétique avec la vidéo originale, nous utiliserons le référentiel Wav2lip. Pour utiliser Wav2lip pour la synchronisation audio, nous devons installer les checkpoints du modèle. Mais avant cela, si vous êtes en exécution T4 GPU, supprimez les modèles xTTS et Whisper de la session Colab en cours ou redémarrez la session.

import torchtry:    del ttsexcept NameError:    print("Modèle vocal déjà supprimé")try:    del modelexcept NameError:    print("Modèle Whisper supprimé")torch.cuda.empty_cache()

Maintenant, clonez le référentiel Wav2lip et installez les checkpoints.

# @title Dépendances%cd /content/!git clone https://github.com/justinjohn0306/Wav2Lip!cd Wav2Lip && pip install -r requirements_colab.txt%cd /content/Wav2Lip!wget 'https://github.com/justinjohn0306/Wav2Lip/releases \/download/models/wav2lip.pth' -O 'checkpoints/wav2lip.pth'!wget 'https://github.com/justinjohn0306/Wav2Lip/releases \/download/models/wav2lip_gan.pth' -O 'checkpoints/wav2lip_gan.pth'!wget 'https://github.com/justinjohn0306/Wav2Lip/releases \/download/models/mobilenet.pth' -O 'checkpoints/mobilenet.pth'!pip install batch-face

Le Wav2lip possède deux modèles pour la synchronisation labiale : wav2lip et wav2lip_gan. Selon les auteurs des modèles, le modèle GAN nécessite moins d’effort dans la détection du visage mais produit des résultats légèrement inférieurs. En revanche, le modèle non-GAN peut produire de meilleurs résultats avec un bourrage manuel supplémentaire et un redimensionnement de la boîte de détection. Vous pouvez essayer les deux et voir lequel donne de meilleurs résultats.

Exécutez l’inférence avec le chemin du point de contrôle du modèle, les fichiers vidéo et audio.

%cd /content/Wav2Lip#Il s'agit du bourrage de la boîte de détection, ajustez-le en cas de mauvais résultats. #Généralement, le problème le plus important est en baspad_top =  0pad_bottom =  15pad_left =  0pad_right =  0rescaleFactor =  1video_path_fix = f"'../{video_path}'"!python inference.py --checkpoint_path 'checkpoints/wav2lip_gan.pth' \--face $video_path_fix --audio "/content/final_output_synth_audio_hi.wav" \--pads $pad_top $pad_bottom $pad_left $pad_right --resize_factor $rescaleFactor --nosmooth \ --outfile '/content/output_video.mp4'

Cela produira une vidéo synchronisée avec les lèvres. Si la vidéo ne semble pas bonne, ajustez les paramètres et réessayez.

Donc, voici le référentiel pour le notebook et quelques échantillons.

Référentiel GitHub : sunilkumardash9/voice-clone-and-lip-sync

Cas d’utilisation réels

La technologie de clonage vocal et de synchronisation labiale présente de nombreux cas d’utilisation dans différents secteurs. Voici quelques exemples où cela peut être bénéfique.

Divertissement : L’industrie du divertissement sera l’industrie la plus touchée de toutes. Nous assistons déjà au changement. Les voix de célébrités des époques actuelles et passées peuvent être synthétisées et réutilisées. Cela pose également des défis éthiques. L’utilisation de voix synthétisées doit être effectuée de manière responsable et dans le respect des lois.

Marketing : Des campagnes publicitaires personnalisées avec des voix familières et identifiables peuvent grandement améliorer l’attrait d’une marque.

Communication : La langue a toujours été un obstacle à toutes sortes d’activités. La communication inter-langues est encore un défi. La traduction en temps réel de bout en bout tout en conservant l’accent et la voix de chacun révolutionnera notre façon de communiquer. Cela pourrait devenir une réalité dans quelques années.

Création de contenu : Les créateurs de contenu ne dépendront plus des traducteurs pour toucher un public plus large. Avec le clonage vocal et la synchronisation labiale efficaces, la création de contenu inter-langues sera plus facile. L’expérience de narration de podcasts et de livres audio peut être améliorée grâce à la synthèse vocale.

Conclusion

La synthèse vocale est l’un des cas d’utilisation les plus recherchés de l’IA générative. Elle a le potentiel de révolutionner notre manière de communiquer. Depuis la création des civilisations, la barrière linguistique entre les communautés a été un obstacle pour établir des relations plus profondes, tant sur le plan culturel que commercial. Grâce à la synthèse vocale basée sur l’IA, cet écart peut être comblé. Ainsi, dans cet article, nous avons exploré la méthode open-source de clonage vocal et de synchronisation labiale.

Points clés

  • TTS, une bibliothèque Python développée par Coqui-ai, fournit et maintient des modèles de synthèse de la parole populaires.
  • Le xTTS est un modèle de clonage vocal multi-langues capable de cloner la voix dans 16 langues différentes.
  • Whisper est un modèle ASR d’OpenAI pour la transcription et la traduction en anglais efficaces.
  • Wav2lip est un outil open-source pour la synchronisation labiale des vidéos.
  • Le clonage vocal est l’une des frontières les plus actives de l’IA générative, avec un impact potentiel significatif sur des industries allant du divertissement au marketing.

Foire aux questions

Les médias présentés dans cet article n’appartiennent pas à Analytics Vidhya et sont utilisés à la discrétion de l’auteur.

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!

Share:

Was this article helpful?

93 out of 132 found this helpful

Discover more

Recherche en IA

Former les machines pour apprendre plus comme le font les humains

Les chercheurs identifient une propriété qui aide les modèles de vision par ordinateur à apprendre à représenter le m...

AI

Des horizons aux paysages urbains Comment SHoP Architects donne vie à des designs innovants

À SHoP Architects, une entreprise d’architecture basée à New York, Mengyi Fan et son équipe visent à inspirer l...

AI

Rendre l'empathie artificielle

Les scientifiques s'efforcent d'ajouter la capacité de comprendre ce que les autres ressentent à l'intelligence artif...

AI

Le motto de cette sous-culture basée sur l'IA Allez, allez, allez

Le mouvement excentrique pro-tech connu sous le nom d'« Accélérationnisme efficace » veut libérer l'intelligence arti...

AI

15+ Outils d'IA pour les développeurs (décembre 2023)

GitHub Copilot GitHub Copilot se positionne comme un assistant de codage alimenté par l’IA de premier plan sur ...