Wav2Lip

Genaue Lippensynchronisation zu beliebigem Audio mit Wav2Lip auf Clore.ai GPUs

Synchronisiere Lippen mit beliebigem Audio mit Wav2Lip.

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

Mieten auf CLORE.AI

Besuchen Sie CLORE.AI Marketplace
Nach GPU-Typ, VRAM und Preis filtern
Wählen On-Demand (Festpreis) oder Spot (Gebotspreis)
Konfigurieren Sie Ihre Bestellung:
- Docker-Image auswählen
- Ports festlegen (TCP für SSH, HTTP für Web-UIs)
- Umgebungsvariablen bei Bedarf hinzufügen
- Startbefehl eingeben
Zahlung auswählen: CLORE, BTC, oder USDT/USDC
Bestellung erstellen und auf Bereitstellung warten

Zugriff auf Ihren Server

Verbindungsdetails finden Sie in Meine Bestellungen
Webschnittstellen: Verwenden Sie die HTTP-Port-URL
SSH: ssh -p <port> root@<proxy-address>

Was ist Wav2Lip?

Wav2Lip bietet:

Genaue Lippen-Synchronisation für jedes Gesicht
Funktioniert mit beliebigem Audio
Video- oder Bild-Eingabe
Echtzeitfähig

Anforderungen

Modus

VRAM

Schnelle Bereitstellung

Docker-Image:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Ports:

22/tcp
7860/http

Befehl:

cd /workspace && \
git clone https://github.com/Rudrabha/Wav2Lip.git && \
cd Wav2Lip && \
pip install -r requirements.txt && \
wget "https://huggingface.co/spaces/wav2lip/wav2lip/resolve/main/checkpoints/wav2lip_gan.pth" -P checkpoints/ && \
python app.py

Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre http_pub URL in Meine Bestellungen:

Gehen Sie zur Meine Bestellungen Seite
Klicken Sie auf Ihre Bestellung
Finden Sie die http_pub URL (z. B., abc123.clorecloud.net)

Verwenden Sie https://IHRE_HTTP_PUB_URL anstelle von localhost in den Beispielen unten.

Installation

git clone https://github.com/Rudrabha/Wav2Lip.git
cd Wav2Lip
pip install -r requirements.txt

# Vorgefertigte Modelle herunterladen
mkdir -p checkpoints
wget "https://huggingface.co/spaces/wav2lip/wav2lip/resolve/main/checkpoints/wav2lip.pth" -P checkpoints/
wget "https://huggingface.co/spaces/wav2lip/wav2lip/resolve/main/checkpoints/wav2lip_gan.pth" -P checkpoints/

Grundlegende Verwendung

Kommandozeile

python inference.py \
    --checkpoint_path checkpoints/wav2lip_gan.pth \
    --face input_video.mp4 \
    --audio audio.wav \
    --outfile output.mp4

Mit Bild-Eingabe

python inference.py \
    --checkpoint_path checkpoints/wav2lip_gan.pth \
    --face face_image.jpg \
    --audio speech.wav \
    --outfile talking.mp4

Python-API

import subprocess

def wav2lip_sync(face_path, audio_path, output_path, checkpoint="checkpoints/wav2lip_gan.pth"):
    cmd = [
        "python", "inference.py",
        "--checkpoint_path", checkpoint,
        "--face", face_path,
        "--audio", audio_path,
        "--outfile", output_path
    ]
    subprocess.run(cmd, check=True)
    return output_path

# Verwendung
result = wav2lip_sync(
    face_path="video.mp4",
    audio_path="new_audio.wav",
    output_path="synced.mp4"
)

Qualitätsoptionen

Standardqualität (schneller)

python inference.py \
    --checkpoint_path checkpoints/wav2lip.pth \
    --face input.mp4 \
    --audio audio.wav \
    --outfile output.mp4

Hohe Qualität (GAN)

python inference.py \
    --checkpoint_path checkpoints/wav2lip_gan.pth \
    --face input.mp4 \
    --audio audio.wav \
    --outfile output.mp4 \
    --pads 0 10 0 0 \
    --resize_factor 1

Parameter

python inference.py \
    --checkpoint_path checkpoints/wav2lip_gan.pth \
    --face video.mp4 \
    --audio audio.wav \
    --outfile result.mp4 \
    --pads 0 10 0 0 \      # Padding: top right bottom left
    --resize_factor 1 \    # Downscale factor
    --crop "0 -1 0 -1" \   # Crop region
    --box "-1 -1 -1 -1" \  # Face box (auto-detect)
    --nosmooth            # Disable temporal smoothing

Padding-Tipps

Gesichtsposition

Empfohlene Ränder

Zentriert

0 10 0 0

Nahaufnahme

0 15 0 0

Weit

0 5 0 0

Batch-Verarbeitung

import os
import subprocess

def batch_wav2lip(faces_dir, audio_path, output_dir):
    os.makedirs(output_dir, exist_ok=True)

    for filename in os.listdir(faces_dir):
        if filename.endswith(('.mp4', '.jpg', '.png')):
            face_path = os.path.join(faces_dir, filename)
            output_path = os.path.join(output_dir, f"synced_{filename}")

            if filename.endswith(('.jpg', '.png')):
                output_path = output_path.rsplit('.', 1)[0] + '.mp4'

            cmd = [
                "python", "inference.py",
                "--checkpoint_path", "checkpoints/wav2lip_gan.pth",
                "--face", face_path,
                "--audio", audio_path,
                "--outfile", output_path
            ]

            try:
                subprocess.run(cmd, check=True)
                print(f"Processed: {filename}")
            except subprocess.CalledProcessError as e:
                print(f"Error processing {filename}: {e}")

# Verwendung
batch_wav2lip("./faces", "speech.wav", "./outputs")

Gradio-Oberfläche

import gradio as gr
import subprocess
import tempfile
import os

def lip_sync(face_video, audio, quality):
    checkpoint = "checkpoints/wav2lip_gan.pth" if quality == "High (GAN)" else "checkpoints/wav2lip.pth"

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as out_file:
        output_path = out_file.name

    cmd = [
        "python", "inference.py",
        "--checkpoint_path", checkpoint,
        "--face", face_video,
        "--audio", audio,
        "--outfile", output_path
    ]

    subprocess.run(cmd, check=True)
    return output_path

demo = gr.Interface(
    fn=lip_sync,
    inputs=[
        gr.Video(label="Face Video/Image"),
        gr.Audio(type="filepath", label="Audio"),
        gr.Radio(["Standard", "High (GAN)"], value="High (GAN)", label="Quality")
    ],
    outputs=gr.Video(label="Lip-Synced Video"),
    title="Wav2Lip - Lip Sync"
)

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("/sync")
async def sync_lips(
    face: UploadFile = File(...),
    audio: UploadFile = File(...),
    quality: str = "gan"
):
    with tempfile.TemporaryDirectory() as tmpdir:
        # Uploads speichern
        face_ext = os.path.splitext(face.filename)[1]
        face_path = os.path.join(tmpdir, f"face{face_ext}")
        audio_path = os.path.join(tmpdir, "audio.wav")
        output_path = os.path.join(tmpdir, "output.mp4")

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

        # Run Wav2Lip
        checkpoint = "checkpoints/wav2lip_gan.pth" if quality == "gan" else "checkpoints/wav2lip.pth"

        cmd = [
            "python", "inference.py",
            "--checkpoint_path", checkpoint,
            "--face", face_path,
            "--audio", audio_path,
            "--outfile", output_path
        ]

        subprocess.run(cmd, check=True)

        return FileResponse(output_path, media_type="video/mp4")

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

TTS + Wav2Lip-Pipeline

Komplett von Text zu Video:

from TTS.api import TTS
import subprocess

def text_to_lipsync(text, face_path, output_path, language="en"):
    # Sprache generieren
    tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
    audio_path = "temp_speech.wav"
    tts.tts_to_file(text=text, file_path=audio_path, language=language)

    # Lippen-Synchronisation
    cmd = [
        "python", "inference.py",
        "--checkpoint_path", "checkpoints/wav2lip_gan.pth",
        "--face", face_path,
        "--audio", audio_path,
        "--outfile", output_path
    ]
    subprocess.run(cmd, check=True)

    return output_path

# Verwendung
text_to_lipsync(
    "Hello, welcome to our presentation.",
    "presenter.jpg",
    "talking_presenter.mp4"
)

Nachbearbeitung

Ergebnis hochskalieren

import subprocess

def upscale_video(input_path, output_path):
    cmd = [
        "python", "-m", "realesrgan",
        "--input", input_path,
        "--output", output_path,
        "--scale", "2"
    ]
    subprocess.run(cmd, check=True)

Audio wieder hinzufügen


# Falls Audio verloren ging, wieder hinzufügen
ffmpeg -i synced_video.mp4 -i original_audio.wav \
    -c:v copy -c:a aac \
    -map 0:v:0 -map 1:a:0 \
    final_output.mp4

Fehlerbehebung

Gesicht nicht erkannt

Stelle sicher, dass das Gesicht deutlich sichtbar ist
Gute Beleuchtung
Frontal bevorzugt
Höhere Auflösung der Eingabe

Schlechte Synchronisationsqualität

Verwende wav2lip_gan.pth
Passe Padding an
Überprüfe die Audioabtastrate (16 kHz empfohlen)

Ruckelige Ausgabe

Erhöhe resize_factor
Deaktiviere nosmooth
Verwende hochwertigeres Eingabevideo

Leistung

Eingabe

GPU

Verarbeitungszeit

10s Video

RTX 3060

~30s

10s Video

RTX 4090

~15s

30s Video

RTX 4090

~45s

Bild + 10s Audio

RTX 3090

~20s

Vergleich mit SadTalker

Funktion

Wav2Lip

SadTalker

Lippengenauigkeit

Ausgezeichnet

Gut

Kopfbewegung

Keine

Natürlich

Ausdruck

Keine

Kontrollierbar

Geschwindigkeit

Schneller

Langsamer

Am besten für

Dubbing

Avatare

Kostenabschätzung

Typische CLORE.AI-Marktplatztarife (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

Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie CLORE.AI Marketplace auf aktuelle Preise.

Geld sparen:

Verwenden Sie Spot Markt für flexible Workloads (oft 30–50% günstiger)
Bezahlen mit CLORE Token
Preise bei verschiedenen Anbietern vergleichen

Nächste Schritte

SadTalker - Kopfbewegung + Lippen
XTTS - Sprache erzeugen
RVC-Stimmenklon - Sprachkonversion

VorherigeSadTalker NächsteÜberblick

Zuletzt aktualisiert vor 1 Tag

War das hilfreich?

hashtagMieten auf CLORE.AI

hashtagZugriff auf Ihren Server

hashtagWas ist Wav2Lip?

hashtagAnforderungen

hashtagSchnelle Bereitstellung

hashtagZugriff auf Ihren Dienst

hashtagInstallation

hashtagGrundlegende Verwendung

hashtagKommandozeile

hashtagMit Bild-Eingabe

hashtagPython-API

hashtagQualitätsoptionen

hashtagStandardqualität (schneller)

hashtagHohe Qualität (GAN)

hashtagParameter

hashtagPadding-Tipps

hashtagBatch-Verarbeitung

hashtagGradio-Oberfläche

hashtagAPI-Server

hashtagTTS + Wav2Lip-Pipeline

hashtagNachbearbeitung

hashtagErgebnis hochskalieren

hashtagAudio wieder hinzufügen

hashtagFehlerbehebung

hashtagGesicht nicht erkannt

hashtagSchlechte Synchronisationsqualität

hashtagRuckelige Ausgabe

hashtagLeistung

hashtagVergleich mit SadTalker

hashtagKostenabschätzung

hashtagNächste Schritte

Mieten auf CLORE.AI

Zugriff auf Ihren Server

Was ist Wav2Lip?

Anforderungen

Schnelle Bereitstellung

Zugriff auf Ihren Dienst

Installation

Grundlegende Verwendung

Kommandozeile

Mit Bild-Eingabe

Python-API

Qualitätsoptionen

Standardqualität (schneller)

Hohe Qualität (GAN)

Parameter

Padding-Tipps

Batch-Verarbeitung

Gradio-Oberfläche

API-Server

TTS + Wav2Lip-Pipeline

Nachbearbeitung

Ergebnis hochskalieren

Audio wieder hinzufügen

Fehlerbehebung

Gesicht nicht erkannt

Schlechte Synchronisationsqualität

Ruckelige Ausgabe

Leistung

Vergleich mit SadTalker

Kostenabschätzung

Nächste Schritte