SadTalker

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

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

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

Location sur CLORE.AI

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

Accéder à 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 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 de l'expression

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.5.1-cuda12.4-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:

Aller à 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/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


# Utilisation de GFPGAN pour l'amélioration du visage
python inference.py \
    --driven_audio audio.wav \
    --source_image face.jpg \
    --enhancer gfpgan \
    --result_dir ./results

# Utilisation de Real-ESRGAN pour l'image complète
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 tête
    --expression_scale 1.0 \   # Intensité de l'expression
    --still \                  # Mouvement minimal de la tête
    --preprocess crop \        # crop, resize, full
    --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 lot

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="Source Face"),
        gr.Audio(label="Driving Audio"),
        gr.Slider(0, 46, value=0, step=1, label="Pose Style"),
        gr.Slider(0.5, 1.5, value=1.0, step=0.1, label="Expression Scale"),
        gr.Dropdown(["gfpgan", "realesrgan", "none"], value="gfpgan", label="Enhancer")
    ],
    outputs=gr.Video(label="Generated Video"),
    title="SadTalker - Talking Head Generation"
)

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 envoyé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")

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

Text-to-Speech + 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(
    "Hello, welcome to our presentation. Today we'll discuss AI.",
    "presenter.jpg",
    "./output"
)

Contrôle de l'expression


# Expression minimale (style présentateur de journal)
cmd = [
    "python", "inference.py",
    "--driven_audio", "audio.wav",
    "--source_image", "face.jpg",
    "--expression_scale", "0.5",
    "--still"  # Réduit le mouvement 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é

Pas d'améliorateur, 256px

Rapide

Basique

GFPGAN, 256px

Moyen

Bon

GFPGAN, 512px

Lent

Meilleur

RealESRGAN, 512px

Le plus lent

Meilleur

Options de prétraitement


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

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

# Full - utiliser l'image complète
--preprocess full

Dépannage

Visage non détecté

Utilisez une image de visage nette et frontale
Bonne é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

Mouvement saccadé

Augmentez légèrement expression_scale
Essayez un pose_style différent
Utilisez un audio plus long

Mémoire insuffisante

Réduisez la taille de sortie
Désactivez l'améliorateur
Utilisez le prétraitement crop

Performances

Résolution

GPU

Temps (vidéo de 10s)

256px

RTX 3060

~30s

256px

RTX 4090

~15s

512px + GFPGAN

RTX 4090

~45s

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 Place de marché CLORE.AI 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 tokens
Comparer les prix entre différents fournisseurs

Étapes suivantes

Wav2Lip - Synchronisation labiale alternative
Bark TTS - Générer la parole
XTTS - Clonage de voix + TTS

PrécédentLivePortrait SuivantWav2Lip

Mis à jour il y a 1 jour

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

hashtagLocation sur CLORE.AI

hashtagAccéder à votre serveur

hashtagQu'est-ce que SadTalker ?

hashtagExigences

hashtagDéploiement rapide

hashtagAccéder à votre service

hashtagInstallation

hashtagUtilisation de base

hashtagLigne de commande

hashtagAPI Python

hashtagAvec amélioration du visage

hashtagParamètres

hashtagStyles de pose

hashtagTraitement par lot

hashtagInterface Gradio

hashtagServeur API

hashtagText-to-Speech + SadTalker

hashtagContrôle de l'expression

hashtagParamètres de qualité

hashtagOptions de prétraitement

hashtagDépannage

hashtagVisage non détecté

hashtagProblèmes de synchronisation audio

hashtagMouvement saccadé

hashtagMémoire insuffisante

hashtagPerformances

hashtagEstimation des coûts

hashtagÉtapes suivantes

Location sur CLORE.AI

Accéder à votre serveur

Qu'est-ce que SadTalker ?

Exigences

Déploiement rapide

Accéder à votre service

Installation

Utilisation de base

Ligne de commande

API Python

Avec amélioration du visage

Paramètres

Styles de pose

Traitement par lot

Interface Gradio

Serveur API

Text-to-Speech + SadTalker

Contrôle de l'expression

Paramètres de qualité

Options de prétraitement

Dépannage

Visage non détecté

Problèmes de synchronisation audio

Mouvement saccadé

Mémoire insuffisante

Performances

Estimation des coûts

Étapes suivantes