SadTalker

Créez des vidéos de tête parlante à partir d'audio et d'images sur Clore.ai

Animez les visages avec l'audio pour créer des vidéos réalistes de tête parlante.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Louer sur CLORE.AI

1. Visitez la place de marché CLORE.AI

2. Filtrez par type de GPU, VRAM et prix

3. Choisissez À la demande (tarif fixe) ou Spot (prix d'enchère)

4. 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

5. Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC

6. 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@<proxy-address>

Qu'est-ce que SadTalker ?

SadTalker génère des vidéos parlantes :

• Synchronisation labiale à partir de n'importe quel audio

• Mouvements naturels de la tête

• Fonctionne avec une seule image

• Contrôle des expressions

Exigences

Mode	VRAM	Recommandé
Basique	4 Go	RTX 3060
Haute qualité	6 Go	RTX 3080
Visage complet	8 Go	RTX 4080

Déploiement rapide

Image Docker :

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

Ports :

22/tcp
7860/http

Commande :

cd /workspace && \
git clone https://github.com/OpenTalker/SadTalker.git && \
cd SadTalker && \
pip install -r requirements.txt && \
bash scripts/download_models.sh && \
python app.py

Accéder à votre service

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

1. Accédez à Mes commandes la page

2. Cliquez sur votre commande

3. Trouvez le http_pub URL (par ex., abc123.clorecloud.net)

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

Installation

git clone https://github.com/OpenTalker/SadTalker.git
cd SadTalker

pip install torch torchvision torchaudio
pip install -r requirements.txt

# Télécharger les modèles préentraînés
bash scripts/download_models.sh

Utilisation de base

Ligne de commande

python inference.py \
    --driven_audio audio.wav \
    --source_image face.jpg \
    --result_dir ./results \
    --enhancer gfpgan

API Python

from src.facerender.animate import AnimateFromCoeff
from src.generate_batch import get_data
from src.generate_facerender_batch import get_facerender_data
import torch

class SadTalker:
    def __init__(self):
        self.device = "cuda"
        # Initialiser les modèles...

    def generate(self, source_image, driven_audio, **kwargs):
        # Traiter l'audio et l'image
        # Générer l'animation
        # Retourner le chemin de la vidéo
        pass

# Utilisation
sadtalker = SadTalker()
video_path = sadtalker.generate(
    source_image="face.jpg",
    driven_audio="speech.wav"
)

Avec amélioration du visage

# Utiliser GFPGAN pour améliorer le visage
python inference.py \
    --driven_audio audio.wav \
    --source_image face.jpg \
    --enhancer gfpgan \
    --result_dir ./results

# Utiliser Real-ESRGAN pour l'image entière
python inference.py \
    --driven_audio audio.wav \
    --source_image face.jpg \
    --enhancer realesrgan \
    --result_dir ./results

Paramètres

python inference.py \
    --driven_audio audio.wav \
    --source_image face.jpg \
    --pose_style 0 \           # 0-46 styles de mouvement de la tête
    --expression_scale 1.0 \   # Intensité de l'expression
    --still \                  # Mouvements minimaux de la tête
    --preprocess crop \        # rogner, redimensionner, complet
    --size 256 \               # Taille de sortie
    --enhancer gfpgan

Styles de pose

Plage	Effet
0-5	Mouvements subtils
6-20	Mouvements normaux
21-46	Mouvements expressifs

Traitement par lots

import os
import subprocess

def generate_talking_video(image_path, audio_path, output_dir):
    cmd = [
        "python", "inference.py",
        "--driven_audio", audio_path,
        "--source_image", image_path,
        "--result_dir", output_dir,
        "--enhancer", "gfpgan"
    ]
    subprocess.run(cmd, check=True)

# Traiter plusieurs images avec le même audio
images = ["person1.jpg", "person2.jpg", "person3.jpg"]
audio = "speech.wav"

for i, img in enumerate(images):
    output = f"./results/video_{i}"
    generate_talking_video(img, audio, output)

Interface Gradio

import gradio as gr
import subprocess
import tempfile
import os

def generate_video(image, audio, pose_style, expression_scale, enhancer):
    with tempfile.TemporaryDirectory() as tmpdir:
        # Enregistrer les entrées
        image_path = os.path.join(tmpdir, "input.jpg")
        audio_path = os.path.join(tmpdir, "audio.wav")
        image.save(image_path)

        # Enregistrer l'audio
        import soundfile as sf
        sf.write(audio_path, audio[1], audio[0])

        # Générer
        cmd = [
            "python", "inference.py",
            "--driven_audio", audio_path,
            "--source_image", image_path,
            "--result_dir", tmpdir,
            "--pose_style", str(pose_style),
            "--expression_scale", str(expression_scale),
            "--enhancer", enhancer
        ]
        subprocess.run(cmd, check=True)

        # Trouver la vidéo de sortie
        for f in os.listdir(tmpdir):
            if f.endswith(".mp4"):
                return os.path.join(tmpdir, f)

    return None

demo = gr.Interface(
    fn=generate_video,
    inputs=[
        gr.Image(type="pil", label="Visage source"),
        gr.Audio(label="Audio de commande"),
        gr.Slider(0, 46, value=0, step=1, label="Style de pose"),
        gr.Slider(0.5, 1.5, value=1.0, step=0.1, label="Échelle d'expression"),
        gr.Dropdown(["gfpgan", "realesrgan", "none"], value="gfpgan", label="Améliorateur")
    ],
    outputs=gr.Video(label="Vidéo générée"),
    title="SadTalker - Génération de tête parlante"
)

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("/generate")
async def generate(
    image: UploadFile = File(...),
    audio: UploadFile = File(...),
    pose_style: int = 0,
    expression_scale: float = 1.0
):
    with tempfile.TemporaryDirectory() as tmpdir:
        # Enregistrer les fichiers téléversés
        image_path = os.path.join(tmpdir, "input.jpg")
        audio_path = os.path.join(tmpdir, "audio.wav")

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

        # Générer
        cmd = [
            "python", "inference.py",
            "--driven_audio", audio_path,
            "--source_image", image_path,
            "--result_dir", tmpdir,
            "--pose_style", str(pose_style),
            "--expression_scale", str(expression_scale),
            "--enhancer", "gfpgan"
        ]
        subprocess.run(cmd, check=True)

        # Retourner la vidéo
        for f in os.listdir(tmpdir):
            if f.endswith(".mp4"):
                return FileResponse(os.path.join(tmpdir, f), media_type="video/mp4")

# Exécuter : uvicorn server:app --host 0.0.0.0 --port 8000

Synthèse vocale + SadTalker

Pipeline complet :

import subprocess
from TTS.api import TTS

def text_to_talking_video(text, image_path, output_path):
    # Générer la parole avec TTS
    tts = TTS("tts_models/en/ljspeech/tacotron2-DDC")
    audio_path = "temp_audio.wav"
    tts.tts_to_file(text=text, file_path=audio_path)

    # Générer la vidéo parlante
    cmd = [
        "python", "inference.py",
        "--driven_audio", audio_path,
        "--source_image", image_path,
        "--result_dir", output_path,
        "--enhancer", "gfpgan"
    ]
    subprocess.run(cmd, check=True)

# Utilisation
text_to_talking_video(
    "Bonjour, bienvenue à notre présentation. Aujourd'hui, nous parlerons de l'IA.",
    "presenter.jpg",
    "./output"
)

Contrôle des expressions

# Expression minimale (style présentateur de journal télévisé)
cmd = [
    "python", "inference.py",
    "--driven_audio", "audio.wav",
    "--source_image", "face.jpg",
    "--expression_scale", "0.5",
    "--still"  # Réduit les mouvements de la tête
]

# Expressif (personnage animé)
cmd = [
    "python", "inference.py",
    "--driven_audio", "audio.wav",
    "--source_image", "face.jpg",
    "--expression_scale", "1.5",
    "--pose_style", "30"
]

Paramètres de qualité

Paramètre	Vitesse	Qualité
Sans améliorateur, 256 px	Rapide	Basique
GFPGAN, 256 px	Moyen	Bon
GFPGAN, 512 px	Lent	Meilleur
RealESRGAN, 512 px	Le plus lent	Meilleur

Options de prétraitement

# Rogner - se concentrer sur le visage (recommandé)
--preprocess crop

# Redimensionner - redimensionner l'image entière
--preprocess resize

# Complet - utiliser l'image entière
--preprocess full

Dépannage

Visage non détecté

• Utilisez une image claire du visage de face

• Bon éclairage

• Évitez les occlusions (lunettes, cheveux)

Problèmes de synchronisation audio

• Utilisez des fichiers WAV 16 kHz

• Évitez la musique de fond

• Parole claire uniquement

Mouvements saccadés

• Augmentez légèrement expression_scale

• Essayez un autre pose_style

• Utilisez un audio plus long

Mémoire insuffisante

• Réduisez la taille de sortie

• Désactivez l'améliorateur

• Utilisez le prétraitement de rognage

Performances

Résolution	GPU	Temps (vidéo de 10 s)
256 px	RTX 3060	~30 s
256 px	RTX 4090	~15 s
512 px + GFPGAN	RTX 4090	~45 s

Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 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 40 Go	~$0.17	~$4.00	~$0.70
A100 80 Go	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez la place de marché CLORE.AI les tarifs actuels.

Économisez de l'argent :

• Utilisez le Spot marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane ~13 % de remise), les autres s'alignent dessus

• Payez avec CLORE jetons

• Comparez les prix entre différents fournisseurs

Étapes suivantes

• Wav2Lip - Synchronisation labiale alternative

• Bark TTS - Générer la parole

• XTTS - Clonage vocal + TTS