> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/tetes-parlantes/sadtalker.md).

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

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Louer sur CLORE.AI

1. Visitez [la place de marché CLORE.AI](https://clore.ai/marketplace)
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 :**

```bash
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

```bash
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

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

### API Python

```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

```bash

# 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

```bash
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

```python
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

```python
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

```python
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 :

```python
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

```python

# 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

```bash

# 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*](https://clore.ai/marketplace) *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](/guides/guides_v2-fr/tetes-parlantes/wav2lip.md) - Synchronisation labiale alternative
* [Bark TTS](/guides/guides_v2-fr/audio-et-voix/bark-tts.md) - Générer la parole
* [XTTS](/guides/guides_v2-fr/audio-et-voix/xtts-coqui.md) - Clonage vocal + TTS


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/tetes-parlantes/sadtalker.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.