Wav2Lip

Synchronisation labiale précise sur n'importe quel audio avec Wav2Lip sur les GPU Clore.ai

Synchronisez les lèvres avec n'importe quel audio avec Wav2Lip.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Location sur CLORE.AI

Visitez CLORE.AI Marketplace
Filtrer par type de GPU, VRAM et prix
Choisir À la demande (tarif fixe) ou Spot (prix d'enchère)
Configurez votre commande :
- Sélectionnez l'image Docker
- Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
- Ajoutez des variables d'environnement si nécessaire
- Entrez la commande de démarrage
Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC
Créez la commande et attendez le déploiement

Accédez à votre serveur

Trouvez les détails de connexion dans Mes commandes
Interfaces Web : utilisez l'URL du port HTTP
SSH : ssh -p <port> root@<adresse-proxy>

Qu'est-ce que Wav2Lip ?

Wav2Lip fournit :

Synchronisation labiale précise pour n'importe quel visage
Fonctionne avec n'importe quel audio
Entrée vidéo ou image
Capable de fonctionner en temps réel

Exigences

Mode

VRAM

Recommandé

Basique

4 Go

RTX 3060

Haute qualité

6 Go

RTX 3080

8 Go

RTX 4080

Déploiement rapide

Image Docker :

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Ports :

22/tcp
7860/http

Commande :

cd /workspace && \
git clone https://github.com/Rudrabha/Wav2Lip.git && \
cd Wav2Lip && \
pip install -r requirements.txt && \
wget "https://huggingface.co/spaces/wav2lip/wav2lip/resolve/main/checkpoints/wav2lip_gan.pth" -P checkpoints/ && \
python app.py

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

Aller à la Mes commandes page
Cliquez sur votre commande
Trouvez l' http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://VOTRE_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Installation

git clone https://github.com/Rudrabha/Wav2Lip.git
cd Wav2Lip
pip install -r requirements.txt

# Télécharger les modèles pré-entraînés
mkdir -p checkpoints
wget "https://huggingface.co/spaces/wav2lip/wav2lip/resolve/main/checkpoints/wav2lip.pth" -P checkpoints/
wget "https://huggingface.co/spaces/wav2lip/wav2lip/resolve/main/checkpoints/wav2lip_gan.pth" -P checkpoints/

Utilisation de base

Ligne de commande

python inference.py \
    --checkpoint_path checkpoints/wav2lip_gan.pth \
    --face input_video.mp4 \
    --audio audio.wav \
    --outfile output.mp4

Avec entrée image

python inference.py \
    --checkpoint_path checkpoints/wav2lip_gan.pth \
    --face face_image.jpg \
    --audio speech.wav \
    --outfile talking.mp4

API Python

import subprocess

def wav2lip_sync(face_path, audio_path, output_path, checkpoint="checkpoints/wav2lip_gan.pth"):
    cmd = [
        "python", "inference.py",
        "--checkpoint_path", checkpoint,
        "--face", face_path,
        "--audio", audio_path,
        "--outfile", output_path
    ]
    subprocess.run(cmd, check=True)
    return output_path

# Utilisation
result = wav2lip_sync(
    face_path="video.mp4",
    audio_path="new_audio.wav",
    output_path="synced.mp4"
)

Options de qualité

Qualité standard (plus rapide)

python inference.py \
    --checkpoint_path checkpoints/wav2lip.pth \
    --face input.mp4 \
    --audio audio.wav \
    --outfile output.mp4

Haute qualité (GAN)

python inference.py \
    --checkpoint_path checkpoints/wav2lip_gan.pth \
    --face input.mp4 \
    --audio audio.wav \
    --outfile output.mp4 \
    --pads 0 10 0 0 \
    --resize_factor 1

Paramètres

python inference.py \
    --checkpoint_path checkpoints/wav2lip_gan.pth \
    --face video.mp4 \
    --audio audio.wav \
    --outfile result.mp4 \
    --pads 0 10 0 0 \      # Padding: top right bottom left
    --resize_factor 1 \    # Downscale factor
    --crop "0 -1 0 -1" \   # Crop region
    --box "-1 -1 -1 -1" \  # Face box (auto-detect)
    --nosmooth            # Disable temporal smoothing

Conseils pour le padding

Position du visage

Pads recommandés

Centré

0 10 0 0

Gros plan

0 15 0 0

Loin

0 5 0 0

Traitement par lots

import os
import subprocess

def batch_wav2lip(faces_dir, audio_path, output_dir):
    os.makedirs(output_dir, exist_ok=True)

    for filename in os.listdir(faces_dir):
        if filename.endswith(('.mp4', '.jpg', '.png')):
            face_path = os.path.join(faces_dir, filename)
            output_path = os.path.join(output_dir, f"synced_{filename}")

            if filename.endswith(('.jpg', '.png')):
                output_path = output_path.rsplit('.', 1)[0] + '.mp4'

            cmd = [
                "python", "inference.py",
                "--checkpoint_path", "checkpoints/wav2lip_gan.pth",
                "--face", face_path,
                "--audio", audio_path,
                "--outfile", output_path
            ]

            try:
                subprocess.run(cmd, check=True)
                print(f"Traité : {filename}")
            except subprocess.CalledProcessError as e:
                print(f"Error processing {filename}: {e}")

# Utilisation
batch_wav2lip("./faces", "speech.wav", "./outputs")

Interface Gradio

import gradio as gr
import subprocess
import tempfile
import os

def lip_sync(face_video, audio, quality):
    checkpoint = "checkpoints/wav2lip_gan.pth" if quality == "High (GAN)" else "checkpoints/wav2lip.pth"

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as out_file:
        output_path = out_file.name

    cmd = [
        "python", "inference.py",
        "--checkpoint_path", checkpoint,
        "--face", face_video,
        "--audio", audio,
        "--outfile", output_path
    ]

    subprocess.run(cmd, check=True)
    return output_path

demo = gr.Interface(
    fn=lip_sync,
    inputs=[
        gr.Video(label="Face Video/Image"),
        gr.Audio(type="filepath", label="Audio"),
        gr.Radio(["Standard", "High (GAN)"], value="High (GAN)", label="Quality")
    ],
    outputs=gr.Video(label="Lip-Synced Video"),
    title="Wav2Lip - Lip Sync"
)

demo.launch(server_name="0.0.0.0", server_port=7860)

Serveur API

from fastapi import FastAPI, UploadFile, File
from fastapi.responses import FileResponse
import tempfile
import subprocess
import os

app = FastAPI()

@app.post("/sync")
async def sync_lips(
    face: UploadFile = File(...),
    audio: UploadFile = File(...),
    quality: str = "gan"
):
    with tempfile.TemporaryDirectory() as tmpdir:
        # Enregistrer les fichiers envoyés
        face_ext = os.path.splitext(face.filename)[1]
        face_path = os.path.join(tmpdir, f"face{face_ext}")
        audio_path = os.path.join(tmpdir, "audio.wav")
        output_path = os.path.join(tmpdir, "output.mp4")

        with open(face_path, "wb") as f:
            f.write(await face.read())
        with open(audio_path, "wb") as f:
            f.write(await audio.read())

        # Run Wav2Lip
        checkpoint = "checkpoints/wav2lip_gan.pth" if quality == "gan" else "checkpoints/wav2lip.pth"

        cmd = [
            "python", "inference.py",
            "--checkpoint_path", checkpoint,
            "--face", face_path,
            "--audio", audio_path,
            "--outfile", output_path
        ]

        subprocess.run(cmd, check=True)

        return FileResponse(output_path, media_type="video/mp4")

# Lancer : uvicorn server:app --host 0.0.0.0 --port 8000

Pipeline TTS + Wav2Lip

Texte complet en vidéo :

from TTS.api import TTS
import subprocess

def text_to_lipsync(text, face_path, output_path, language="en"):
    # Générer la parole
    tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
    audio_path = "temp_speech.wav"
    tts.tts_to_file(text=text, file_path=audio_path, language=language)

    # Synchronisation labiale
    cmd = [
        "python", "inference.py",
        "--checkpoint_path", "checkpoints/wav2lip_gan.pth",
        "--face", face_path,
        "--audio", audio_path,
        "--outfile", output_path
    ]
    subprocess.run(cmd, check=True)

    return output_path

# Utilisation
text_to_lipsync(
    "Hello, welcome to our presentation.",
    "presenter.jpg",
    "talking_presenter.mp4"
)

Post-traitement

Augmenter la résolution du résultat

import subprocess

def upscale_video(input_path, output_path):
    cmd = [
        "python", "-m", "realesrgan",
        "--input", input_path,
        "--output", output_path,
        "--scale", "2"
    ]
    subprocess.run(cmd, check=True)

Ajouter l'audio


# Si l'audio a été perdu, le réajouter
ffmpeg -i synced_video.mp4 -i original_audio.wav \
    -c:v copy -c:a aac \
    -map 0:v:0 -map 1:a:0 \
    final_output.mp4

Dépannage

Visage non détecté

Assurez-vous que le visage est clairement visible
Bonne éclairage
De face de préférence
Entrée en résolution plus élevée

Mauvaise qualité de synchronisation

Utilisez wav2lip_gan.pth
Ajustez le padding
Vérifiez la fréquence d'échantillonnage audio (16 kHz recommandé)

Sortie saccadée

Augmentez le resize_factor
Désactivez nosmooth
Utilisez une vidéo d'entrée de meilleure qualité

Performances

Entrée

GPU

Temps de traitement

vidéo de 10 s

RTX 3060

~30s

vidéo de 10 s

RTX 4090

~15s

vidéo de 30 s

RTX 4090

~45s

Image + audio de 10 s

RTX 3090

~20s

Comparaison avec SadTalker

Fonction

Wav2Lip

SadTalker

Précision des lèvres

Excellent

Bon

Mouvement de la tête

Aucune

Naturel

Expression

Aucune

Contrôlable

Vitesse

Plus rapide

Plus lent

Meilleur pour

Doublage

Avatar

Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

GPU

Tarif horaire

Tarif journalier

Session de 4 heures

RTX 3060

~$0.03

~$0.70

~$0.12

RTX 3090

~$0.06

~$1.50

~$0.25

RTX 4090

~$0.10

~$2.30

~$0.40

A100 40GB

~$0.17

~$4.00

~$0.70

A100 80GB

~$0.25

~$6.00

~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez CLORE.AI Marketplace pour les tarifs actuels.

Économisez de l'argent :

Utilisez Spot market pour les charges de travail flexibles (souvent 30-50 % moins cher)
Payer avec CLORE jetons
Comparer les prix entre différents fournisseurs

Prochaines étapes

SadTalker - Mouvement de la tête + lèvres
XTTS - Générer la parole
RVC Voice Clone - Conversion de voix

PrécédentSadTalker SuivantAperçu

Mis à jour il y a 1 jour

Ce contenu vous a-t-il été utile ?

hashtagLocation sur CLORE.AI

hashtagAccédez à votre serveur

hashtagQu'est-ce que Wav2Lip ?

hashtagExigences

hashtagDéploiement rapide

hashtagAccéder à votre service

hashtagInstallation

hashtagUtilisation de base

hashtagLigne de commande

hashtagAvec entrée image

hashtagAPI Python

hashtagOptions de qualité

hashtagQualité standard (plus rapide)

hashtagHaute qualité (GAN)

hashtagParamètres

hashtagConseils pour le padding

hashtagTraitement par lots

hashtagInterface Gradio

hashtagServeur API

hashtagPipeline TTS + Wav2Lip

hashtagPost-traitement

hashtagAugmenter la résolution du résultat

hashtagAjouter l'audio

hashtagDépannage

hashtagVisage non détecté

hashtagMauvaise qualité de synchronisation

hashtagSortie saccadée

hashtagPerformances

hashtagComparaison avec SadTalker

hashtagEstimation des coûts

hashtagProchaines étapes

Location sur CLORE.AI

Accédez à votre serveur

Qu'est-ce que Wav2Lip ?

Exigences

Déploiement rapide

Accéder à votre service

Installation

Utilisation de base

Ligne de commande

Avec entrée image

API Python

Options de qualité

Qualité standard (plus rapide)

Haute qualité (GAN)

Paramètres

Conseils pour le padding

Traitement par lots

Interface Gradio

Serveur API

Pipeline TTS + Wav2Lip

Post-traitement

Augmenter la résolution du résultat

Ajouter l'audio

Dépannage

Visage non détecté

Mauvaise qualité de synchronisation

Sortie saccadée

Performances

Comparaison avec SadTalker

Estimation des coûts

Prochaines étapes