SadTalker

Clore.ai पर ऑडियो और छवियों से टॉकिंग-हेड वीडियो बनाएँ

ऑडियो के साथ चेहरों को एनिमेट करें, ताकि यथार्थवादी टॉकिंग-हेड वीडियो बनाए जा सकें।

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है CLORE.AI मार्केटप्लेस.

CLORE.AI पर किराए पर लेना

1. विज़िट करें CLORE.AI मार्केटप्लेस

2. GPU प्रकार, VRAM और कीमत के अनुसार फ़िल्टर करें

3. चुनें ऑन-डिमांड (स्थिर दर) या स्पॉट (बोली मूल्य)

4. अपना ऑर्डर कॉन्फ़िगर करें:

   • Docker इमेज चुनें

   • पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)

   • यदि आवश्यक हो तो environment variables जोड़ें

   • स्टार्टअप कमांड दर्ज करें

5. भुगतान चुनें: CLORE, BTCया USDT/USDC

6. ऑर्डर बनाएं और डिप्लॉयमेंट की प्रतीक्षा करें

अपने सर्वर तक पहुँचें

• कनेक्शन विवरण यहाँ खोजें मेरे ऑर्डर

• वेब इंटरफ़ेस: HTTP पोर्ट URL का उपयोग करें

• SSH: ssh -p <port> root@<proxy-address>

SadTalker क्या है?

SadTalker टॉकिंग वीडियो बनाता है:

• किसी भी ऑडियो के साथ लिप-सिंक

• प्राकृतिक सिर की हरकतें

• एकल छवि के साथ काम करता है

• अभिव्यक्ति नियंत्रण

आवश्यकताएँ

मोड	VRAM	अनुशंसित
बेसिक	4GB	RTX 3060
उच्च गुणवत्ता	6GB	RTX 3080
पूरा चेहरा	8GB	RTX 4080

त्वरित डिप्लॉय

Docker इमेज:

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

पोर्ट:

22/tcp
7860/http

कमांड:

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

अपनी सेवा तक पहुँचना

डिप्लॉयमेंट के बाद, अपना http_pub URL यहाँ मेरे ऑर्डर:

1. पर जाएँ मेरे ऑर्डर पेज

2. अपने ऑर्डर पर क्लिक करें

3. खोजें http_pub URL (उदा., abc123.clorecloud.net)

उपयोग करें https://YOUR_HTTP_PUB_URL की बजाय localhost नीचे दिए गए उदाहरणों में।

इंस्टॉलेशन

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

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

# पूर्व-प्रशिक्षित मॉडल डाउनलोड करें
bash scripts/download_models.sh

मूल उपयोग

कमांड लाइन

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"
        # मॉडल प्रारंभ करें...

    def generate(self, source_image, driven_audio, **kwargs):
        # ऑडियो और छवि को प्रोसेस करें
        # ऐनिमेशन बनाएं
        # वीडियो पथ लौटाएँ
        pass

# उपयोग
sadtalker = SadTalker()
video_path = sadtalker.generate(
    source_image="face.jpg",
    driven_audio="speech.wav"
)

चेहरे के संवर्धन के साथ

# चेहरे के संवर्धन के लिए GFPGAN का उपयोग
python inference.py \
    --driven_audio audio.wav \
    --source_image face.jpg \
    --enhancer gfpgan \
    --result_dir ./results

# पूरी छवि के लिए Real-ESRGAN का उपयोग
python inference.py \
    --driven_audio audio.wav \
    --source_image face.jpg \
    --enhancer realesrgan \
    --result_dir ./results

पैरामीटर

python inference.py \
    --driven_audio audio.wav \
    --source_image face.jpg \
    --pose_style 0 \           # 0-46 सिर की हरकतों की शैलियाँ
    --expression_scale 1.0 \   # अभिव्यक्ति की तीव्रता
    --still \                  # न्यूनतम सिर की हरकत
    --preprocess crop \        # क्रॉप, रिसाइज़, फुल
    --size 256 \               # आउटपुट आकार
    --enhancer gfpgan

पोज़ शैलियाँ

सीमा	प्रभाव
0-5	सूक्ष्म हरकतें
6-20	सामान्य हरकतें
21-46	अभिव्यंजक हरकतें

बैच प्रोसेसिंग

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)

# एक ही ऑडियो के साथ कई छवियों को प्रोसेस करें
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 इंटरफ़ेस

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:
        # इनपुट सहेजें
        image_path = os.path.join(tmpdir, "input.jpg")
        audio_path = os.path.join(tmpdir, "audio.wav")
        image.save(image_path)

        # ऑडियो सहेजें
        import soundfile as sf
        sf.write(audio_path, audio[1], audio[0])

        # जनरेट करें
        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)

        # आउटपुट वीडियो खोजें
        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="स्रोत चेहरा"),
        gr.Audio(label="इनपुट ऑडियो"),
        gr.Slider(0, 46, value=0, step=1, label="पोज़ शैली"),
        gr.Slider(0.5, 1.5, value=1.0, step=0.1, label="अभिव्यक्ति स्केल"),
        gr.Dropdown(["gfpgan", "realesrgan", "none"], value="gfpgan", label="संवर्धक")
    ],
    outputs=gr.Video(label="जनरेट किया गया वीडियो"),
    title="SadTalker - टॉकिंग-हेड जनरेशन"
)

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

एपीआई सर्वर

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:
        # अपलोड सहेजें
        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())

        # जनरेट करें
        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)

        # वीडियो लौटाएँ
        for f in os.listdir(tmpdir):
            if f.endswith(".mp4"):
                return FileResponse(os.path.join(tmpdir, f), media_type="video/mp4")

# चलाएँ: uvicorn server:app --host 0.0.0.0 --port 8000

टेक्स्ट-टू-स्पीच + SadTalker

संपूर्ण पाइपलाइन:

import subprocess
from TTS.api import TTS

def text_to_talking_video(text, image_path, output_path):
    # TTS के साथ भाषण उत्पन्न करें
    tts = TTS("tts_models/en/ljspeech/tacotron2-DDC")
    audio_path = "temp_audio.wav"
    tts.tts_to_file(text=text, file_path=audio_path)

    # टॉकिंग वीडियो बनाएं
    cmd = [
        "python", "inference.py",
        "--driven_audio", audio_path,
        "--source_image", image_path,
        "--result_dir", output_path,
        "--enhancer", "gfpgan"
    ]
    subprocess.run(cmd, check=True)

# उपयोग
text_to_talking_video(
    "नमस्ते, हमारे प्रस्तुतीकरण में आपका स्वागत है। आज हम AI पर चर्चा करेंगे।",
    "presenter.jpg",
    "./output"
)

अभिव्यक्ति नियंत्रण

# न्यूनतम अभिव्यक्ति (समाचार वाचक शैली)
cmd = [
    "python", "inference.py",
    "--driven_audio", "audio.wav",
    "--source_image", "face.jpg",
    "--expression_scale", "0.5",
    "--still"  # सिर की हरकत कम करता है
]

# अभिव्यंजक (एनिमेटेड चरित्र)
cmd = [
    "python", "inference.py",
    "--driven_audio", "audio.wav",
    "--source_image", "face.jpg",
    "--expression_scale", "1.5",
    "--pose_style", "30"
]

गुणवत्ता सेटिंग्स

सेटिंग	गति	गुणवत्ता
कोई संवर्धक नहीं, 256px	तेज़	बेसिक
GFPGAN, 256px	मध्यम	अच्छा
GFPGAN, 512px	धीमा	बेहतर
RealESRGAN, 512px	सबसे धीमा	सर्वोत्तम

प्रीप्रोसेसिंग विकल्प

# क्रॉप - चेहरे पर ध्यान दें (अनुशंसित)
--preprocess crop

# रिसाइज़ - पूरी छवि का आकार बदलें
--preprocess resize

# फुल - पूरी छवि का उपयोग करें
--preprocess full

समस्या निवारण

चेहरा नहीं मिला

• स्पष्ट, सामने से ली गई चेहरे की छवि का उपयोग करें

• अच्छी रोशनी

• अवरोधों से बचें (चश्मा, बाल)

ऑडियो सिंक समस्याएँ

• 16kHz WAV फ़ाइलों का उपयोग करें

• बैकग्राउंड संगीत से बचें

• केवल स्पष्ट भाषण

रुक-रुक कर होने वाली हरकतें

• expression_scale को थोड़ा बढ़ाएँ

• अलग pose_style आज़माएँ

• लंबा ऑडियो उपयोग करें

मेमोरी समाप्त

• आउटपुट आकार कम करें

• संवर्धक बंद करें

• क्रॉप प्रीप्रोसेसिंग का उपयोग करें

प्रदर्शन

रिज़ॉल्यूशन	GPU	समय (10 सेकंड का वीडियो)
256px	RTX 3060	~30 सेकंड
256px	RTX 4090	~15 सेकंड
512px + GFPGAN	RTX 4090	~45 सेकंड

लागत का अनुमान

CLORE.AI मार्केटप्लेस की सामान्य दरें (2024 तक):

GPU	प्रति घंटा दर	प्रति दिन दर	4-घंटे का सत्र
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

मूल्य प्रदाता और मांग के अनुसार बदलते हैं। देखें CLORE.AI मार्केटप्लेस वर्तमान दरों के लिए।

पैसे बचाएँ:

• का उपयोग करें स्पॉट बाधित किए जा सकने वाले कार्य के लिए मार्केट — लगभग एक-तिहाई सर्वरों की स्पॉट कीमत ऑन-डिमांड से कम होती है (मध्य ~13% छूट), बाकी उससे मेल खाते हैं

• से भुगतान करें CLORE टोकन

• विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

अगले चरण

• Wav2Lip - वैकल्पिक लिप-सिंक

• Bark TTS - भाषण उत्पन्न करें

• XTTS - वॉयस क्लोनिंग + TTS