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.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Mieten auf CLORE.AI

1. Besuchen CLORE.AI-Marktplatz

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:

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

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

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

Python-API

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

# 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

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

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

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

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:

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

# 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

# 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 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 - Alternative Lippensynchronisation

• Bark TTS - Sprache erzeugen

• XTTS - Stimmenklonen + TTS