> 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-de/sprechende-kopfe/sadtalker.md).

# SadTalker

Erstelle Videos mit sprechenden Köpfen aus Audio und Bildern auf Clore.ai

Animieren Sie Gesichter mit Audio, um realistische Talking-Head-Videos zu erstellen.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über [CLORE.AI-Marktplatz](https://clore.ai/marketplace).
{% endhint %}

## Mieten auf CLORE.AI

1. Besuchen [CLORE.AI-Marktplatz](https://clore.ai/marketplace)
2. Filtern nach GPU-Typ, VRAM und Preis
3. Wähle **On-Demand** (Festpreis) oder **Spot** (Gebotspreis)
4. Konfiguriere deine Bestellung:
   * Docker-Image auswählen
   * Ports festlegen (TCP für SSH, HTTP für Web-UIs)
   * Bei Bedarf Umgebungsvariablen hinzufügen
   * Startbefehl eingeben
5. Zahlung auswählen: **CLORE**, **BTC**, oder **USDT/USDC**
6. Bestellung erstellen und auf die Bereitstellung warten

### Greife auf deinen Server zu

* Verbindungsdetails finden in **Meine Bestellungen**
* Web-Oberflächen: Verwende die HTTP-Port-URL
* SSH: `ssh -p <port> root@<proxy-address>`

## Was ist SadTalker?

SadTalker erzeugt Talking-Head-Videos:

* Lippensynchronisation mit beliebigem Audio
* Natürliche Kopfbewegungen
* Funktioniert mit einem einzelnen Bild
* Ausdruckskontrolle

## Anforderungen

| Modus          | VRAM | Empfohlen |
| -------------- | ---- | --------- |
| Einfach        | 4 GB | RTX 3060  |
| Hohe Qualität  | 6 GB | RTX 3080  |
| Ganzes Gesicht | 8 GB | RTX 4080  |

## Schnell bereitstellen

**Docker-Image:**

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

**Ports:**

```
22/tcp
7860/http
```

**Befehl:**

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

## Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine `http_pub` URL in **Meine Bestellungen**:

1. Gehe zu **Meine Bestellungen** Seite
2. Klicke auf deine Bestellung
3. Finde die `http_pub` URL (z. B. `abc123.clorecloud.net`)

Verwende `https://YOUR_HTTP_PUB_URL` anstelle von `localhost` in den folgenden Beispielen.

## Installation

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

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

# Vorgetrainierte Modelle herunterladen
bash scripts/download_models.sh
```

## Grundlegende Verwendung

### Kommandozeile

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

### Python-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"
        # Modelle initialisieren...

    def generate(self, source_image, driven_audio, **kwargs):
        # Audio und Bild verarbeiten
        # Animation erzeugen
        # Videopfad zurückgeben
        pass

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

## Mit Gesichtsverbesserung

```bash

# GFPGAN für die Gesichtsverbesserung verwenden
python inference.py \
    --driven_audio audio.wav \
    --source_image face.jpg \
    --enhancer gfpgan \
    --result_dir ./results

# Real-ESRGAN für das gesamte Bild verwenden
python inference.py \
    --driven_audio audio.wav \
    --source_image face.jpg \
    --enhancer realesrgan \
    --result_dir ./results
```

## Parameter

```bash
python inference.py \
    --driven_audio audio.wav \
    --source_image face.jpg \
    --pose_style 0 \           # 0-46 Kopfbewegungsstile
    --expression_scale 1.0 \   # Ausdrucksintensität
    --still \                  # Minimale Kopfbewegung
    --preprocess crop \        # zuschneiden, skalieren, vollständig
    --size 256 \               # Ausgabegröße
    --enhancer gfpgan
```

### Posenstile

| Bereich | Effekt                     |
| ------- | -------------------------- |
| 0-5     | Unauffällige Bewegungen    |
| 6-20    | Normale Bewegungen         |
| 21-46   | Ausdrucksstarke Bewegungen |

## Batch-Verarbeitung

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

# Mehrere Bilder mit demselben Audio verarbeiten
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)
```

## Gradio-Oberfläche

```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:
        # Eingaben speichern
        image_path = os.path.join(tmpdir, "input.jpg")
        audio_path = os.path.join(tmpdir, "audio.wav")
        image.save(image_path)

        # Audio speichern
        import soundfile as sf
        sf.write(audio_path, audio[1], audio[0])

        # Generieren
        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)

        # Ausgabefideo finden
        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="Quellgesicht"),
        gr.Audio(label="Steuer-Audio"),
        gr.Slider(0, 46, value=0, step=1, label="Posenstil"),
        gr.Slider(0.5, 1.5, value=1.0, step=0.1, label="Ausdrucksskala"),
        gr.Dropdown(["gfpgan", "realesrgan", "none"], value="gfpgan", label="Verbesserer")
    ],
    outputs=gr.Video(label="Generiertes Video"),
    title="SadTalker – Talking-Head-Generierung"
)

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

## API-Server

```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:
        # Uploads speichern
        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())

        # Generieren
        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)

        # Video zurückgeben
        for f in os.listdir(tmpdir):
            if f.endswith(".mp4"):
                return FileResponse(os.path.join(tmpdir, f), media_type="video/mp4")

# Ausführen: uvicorn server:app --host 0.0.0.0 --port 8000
```

## Text-zu-Sprache + SadTalker

Gesamte Pipeline:

```python
import subprocess
from TTS.api import TTS

def text_to_talking_video(text, image_path, output_path):
    # Sprache mit TTS erzeugen
    tts = TTS("tts_models/en/ljspeech/tacotron2-DDC")
    audio_path = "temp_audio.wav"
    tts.tts_to_file(text=text, file_path=audio_path)

    # Talking-Head-Video erzeugen
    cmd = [
        "python", "inference.py",
        "--driven_audio", audio_path,
        "--source_image", image_path,
        "--result_dir", output_path,
        "--enhancer", "gfpgan"
    ]
    subprocess.run(cmd, check=True)

# Verwendung
text_to_talking_video(
    "Hello, welcome to our presentation. Today we'll discuss AI.",
    "presenter.jpg",
    "./output"
)
```

## Ausdruckskontrolle

```python

# Minimale Mimik (Nachrichtensprecher-Stil)
cmd = [
    "python", "inference.py",
    "--driven_audio", "audio.wav",
    "--source_image", "face.jpg",
    "--expression_scale", "0.5",
    "--still"  # Reduziert Kopfbewegungen
]

# Ausdrucksstark (animierte Figur)
cmd = [
    "python", "inference.py",
    "--driven_audio", "audio.wav",
    "--source_image", "face.jpg",
    "--expression_scale", "1.5",
    "--pose_style", "30"
]
```

## Qualitätseinstellungen

| Einstellung           | Geschwindigkeit | Qualität  |
| --------------------- | --------------- | --------- |
| Ohne Enhancer, 256 px | Schnell         | Einfach   |
| GFPGAN, 256 px        | Mittel          | Gut       |
| GFPGAN, 512 px        | Langsam         | Besser    |
| RealESRGAN, 512 px    | Am langsamsten  | Am besten |

## Vorverarbeitungsoptionen

```bash

# Zuschneiden – Fokus auf das Gesicht (empfohlen)
--preprocess crop

# Größe ändern – gesamtes Bild skalieren
--preprocess resize

# Vollständig – gesamtes Bild verwenden
--preprocess full
```

## Fehlerbehebung

### Gesicht nicht erkannt

* Verwenden Sie ein klares, frontales Gesichtsbild
* Gute Beleuchtung
* Verdeckungen vermeiden (Brille, Haare)

### Probleme mit der Audiosynchronisation

* Verwenden Sie 16-kHz-WAV-Dateien
* Hintergrundmusik vermeiden
* Nur klare Sprache

### Ruckelige Bewegungen

* expression\_scale leicht erhöhen
* Anderen pose\_style ausprobieren
* Längeres Audio verwenden

### Speicher erschöpft

* Ausgabegröße reduzieren
* Enhancer deaktivieren
* Zuschneide-Vorverarbeitung verwenden

## Leistung

| Auflösung       | GPU      | Zeit (10-Sek.-Video) |
| --------------- | -------- | -------------------- |
| 256 px          | RTX 3060 | \~30s                |
| 256 px          | RTX 4090 | \~15s                |
| 512 px + GFPGAN | RTX 4090 | \~45s                |

## Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise (Stand 2024):

| GPU       | Stundensatz | Tagessatz | 4-Stunden-Sitzung |
| --------- | ----------- | --------- | ----------------- |
| 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           |

*Die Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie* [*CLORE.AI-Marktplatz*](https://clore.ai/marketplace) *für aktuelle Preise.*

**Geld sparen:**

* Nutzen Sie den **Spot** Markt für unterbrechbare Arbeit — etwa ein Drittel der Server bietet Spot-Preise unter dem On-Demand-Preis (Median ca. 13 % Rabatt), der Rest ist gleichauf
* Bezahlen Sie mit **CLORE** Tokens
* Vergleichen Sie Preise zwischen verschiedenen Anbietern

## Nächste Schritte

* [Wav2Lip](/guides/guides_v2-de/sprechende-kopfe/wav2lip.md) - Alternative Lippensynchronisation
* [Bark TTS](/guides/guides_v2-de/audio-and-stimme/bark-tts.md) - Sprache erzeugen
* [XTTS](/guides/guides_v2-de/audio-and-stimme/xtts-coqui.md) - Stimmenklonen + 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-de/sprechende-kopfe/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.