StyleTTS2

Clore.ai GPUs पर Style diffusion के ज़रिए StyleTTS2 मानव-स्तर टेक्स्ट-टू-स्पीच चलाएँ

StyleTTS2 LJSpeech और LibriTTS बेंचमार्क पर ग्राउंड-ट्रुथ रिकॉर्डिंग्स से ऊपर मानव-मूल्यांकित स्वाभाविकता स्कोर प्राप्त करता है (MOS 4.55 बनाम 4.23 ग्राउंड ट्रुथ)। यह उपयोग करता है स्टाइल डिफ्यूज़न और प्रतिकूल प्रशिक्षण बोलने की शैलियों को एक गुप्त चर वितरण के रूप में मॉडल करने के लिए, जिससे एक छोटे संदर्भ क्लिप से अभिव्यक्तिपूर्ण सिंथेसिस और ज़ीरो-शॉट स्पीकर अनुकूलन संभव होता है।

पारंपरिक TTS प्रणालियों के विपरीत, StyleTTS2 एक छोटे संदर्भ ऑडियो क्लिप के साथ अनदेखे स्पीकर्स पर सामान्यीकरण कर सकता है, और ऐसा भाषण उत्पन्न करता है जो पेशेवर वॉयस कलाकारों को टक्कर देता है। इसे कई डेटासेट्स पर मानव-मूल्यांकित स्वाभाविकता स्कोर से अधिक प्रदर्शन करने के लिए बेंचमार्क किया गया है — ओपन-सोर्स TTS के लिए यह पहली बार है।

मुख्य विशेषताएँ:

• मानव-स्तरीय स्वाभाविकता — LJSpeech पर मानव MOS स्कोर से आगे

• ज़ीरो-शॉट स्पीकर अनुकूलन — किसी भी आवाज़ को एक छोटे ऑडियो नमूने से क्लोन करें

• स्टाइल डिफ्यूज़न — अभिव्यंजक, विविध प्रोसोडी और बोलने की शैली

• मल्टी-स्पीकर समर्थन — LibriTTS (2,300+ स्पीकर्स) पर प्रशिक्षित

• हल्का इन्फ़रेंस — उपभोक्ता GPU पर कुशलतापूर्वक चलता है

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

---

सर्वर आवश्यकताएँ

पैरामीटर	न्यूनतम	अनुशंसित
GPU	NVIDIA RTX 3070 (8 GB)	NVIDIA RTX 4090 (24 GB)
VRAM	6 GB	12–24 GB
RAM	16 GB	32 GB
CPU	4 कोर	8+ कोर
डिस्क	15 GB	30 GB
ओएस	Ubuntu 20.04+	Ubuntu 22.04
CUDA	11.7+	12.1+
Python	3.8+	3.10
पोर्ट्स	22, 7860	22, 7860

StyleTTS2 अपेक्षाकृत हल्का है — RTX 3070 या 3080 रीयल-टाइम इन्फ़रेंस को आराम से संभाल लेते हैं। बैच प्रोसेसिंग या एक साथ कई उपयोगकर्ताओं को सेवा देने के लिए, 4090 या A100 का उपयोग करें।

---

CLORE.AI पर त्वरित परिनियोजन

StyleTTS2 के लिए एक कस्टम Docker बिल्ड की आवश्यकता होती है क्योंकि कोई आधिकारिक पूर्व-निर्मित इमेज उपलब्ध नहीं है। सेटअप में लगभग 10 मिनट लगते हैं।

1. एक उपयुक्त सर्वर खोजें

पर जाएँ CLORE.AI मार्केटप्लेस और इनके अनुसार फ़िल्टर करें:

• VRAM: ≥ 6 GB

• GPU: RTX 3070, 3080, 3090, 4080, 4090, A100

• डिस्क: ≥ 20 GB

2. अपना परिनियोजन कॉन्फ़िगर करें

Docker इमेज (बेस):

nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04

पोर्ट मैपिंग:

22 → SSH पहुँच
7860 → Gradio वेब UI

स्टार्टअप कमांड:

bash -c "apt-get update && apt-get install -y git python3 python3-pip ffmpeg espeak-ng && \\
  git clone https://github.com/yl4579/StyleTTS2 /workspace/StyleTTS2 && \\
  cd /workspace/StyleTTS2 && pip install -r requirements.txt && \\
  python app.py"

3. इंटरफ़ेस तक पहुँचें

http://<your-clore-server-ip>:7860

---

चरण-दर-चरण सेटअप

चरण 1: अपने सर्वर में SSH करें

ssh root@<your-clore-server-ip> -p <ssh-port>

चरण 2: सिस्टम निर्भरताएँ इंस्टॉल करें

apt-get update && apt-get install -y \\
  git \\
  python3 \\
  python3-pip \\
  python3-venv \\
  ffmpeg \\
  espeak-ng \\
  libsndfile1 \\
  build-essential \\
  wget \\
  curl

चरण 3: StyleTTS2 रिपॉज़िटरी क्लोन करें

cd /workspace
git clone https://github.com/yl4579/StyleTTS2.git
cd StyleTTS2

चरण 4: Python वर्चुअल वातावरण बनाएं

python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip

चरण 5: निर्भरताएँ इंस्टॉल करें

pip install -r requirements.txt

# यदि आवश्यक हो तो अतिरिक्त निर्भरताएँ इंस्टॉल करें
pip install phonemizer gruut

चरण 6: पूर्व-प्रशिक्षित मॉडल डाउनलोड करें

# LJSpeech मॉडल डाउनलोड करें (एकल स्पीकर, उच्च गुणवत्ता)
mkdir -p Models/LJSpeech
wget -O Models/LJSpeech/epoch_2nd_00100.pth \\
  "https://huggingface.co/yl4579/StyleTTS2-LJSpeech/resolve/main/Models/LJSpeech/epoch_2nd_00100.pth"

wget -O Models/LJSpeech/config.yml \\
  "https://huggingface.co/yl4579/StyleTTS2-LJSpeech/resolve/main/Models/LJSpeech/config.yml"

# LibriTTS मॉडल डाउनलोड करें (मल्टी-स्पीकर, ज़ीरो-शॉट)
mkdir -p Models/LibriTTS
wget -O Models/LibriTTS/epochs_2nd_00020.pth \\
  "https://huggingface.co/yl4579/StyleTTS2-LibriTTS/resolve/main/Models/LibriTTS/epochs_2nd_00020.pth"

wget -O Models/LibriTTS/config.yml \\
  "https://huggingface.co/yl4579/StyleTTS2-LibriTTS/resolve/main/Models/LibriTTS/config.yml"

चरण 7: Dockerfile बनाएं और चलाएँ

# Dockerfile बनाएं
cat > Dockerfile << 'EOF'
FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04

ENV DEBIAN_FRONTEND=noninteractive
RUN apt-get update && apt-get install -y \\
    git python3 python3-pip python3-venv \\
    ffmpeg espeak-ng libsndfile1 build-essential wget curl \\
    && rm -rf /var/lib/apt/lists/*

WORKDIR /workspace
RUN git clone https://github.com/yl4579/StyleTTS2.git
WORKDIR /workspace/StyleTTS2
RUN pip install --no-cache-dir -r requirements.txt

EXPOSE 7860
CMD ["python3", "app.py", "--share"]
EOF

docker build -t styletts2:local .
docker run -d --name styletts2 --gpus all \\
  -p 7860:7860 \
  -v /workspace/models:/workspace/StyleTTS2/Models \\
  styletts2:local

चरण 8: Gradio डेमो सीधे लॉन्च करें

source venv/bin/activate
python app.py

इस पर पहुँचें http://<server-ip>:7860

---

उपयोग के उदाहरण

उदाहरण 1: Python API के माध्यम से बुनियादी TTS

import torch
import soundfile as sf
import numpy as np
from models import *
from utils import *
import yaml

# कॉन्फ़िग लोड करें
config = yaml.safe_load(open("Models/LJSpeech/config.yml"))

# मॉडल आरंभ करें
model = build_model(recursive_munch(config['model_params']), "cpu")
params = torch.load("Models/LJSpeech/epoch_2nd_00100.pth", map_location='cpu')
model = load_F0_models(model)

# GPU पर ले जाएँ
device = "cuda" if torch.cuda.is_available() else "cpu"
for key in model:
    model[key] = model[key].to(device)

print(f"मॉडल यहाँ लोड हुआ: {device}")
print(f"उपयोग की गई VRAM: {torch.cuda.memory_allocated()/1e9:.2f} GB")

---

उदाहरण 2: ज़ीरो-शॉट वॉयस क्लोनिंग

import torch
import torchaudio
import soundfile as sf
from inference import StyleTTS2Inference

# इन्फ़रेंस इंजन आरंभ करें
tts = StyleTTS2Inference(
    model_path="Models/LibriTTS/epochs_2nd_00020.pth",
    config_path="Models/LibriTTS/config.yml",
    device="cuda"
)

# संदर्भ ऑडियो लोड करें (10-30 सेकंड सबसे अच्छा काम करते हैं)
reference_audio, sr = torchaudio.load("reference_voice.wav")

# संदर्भ आवाज़ में भाषण उत्पन्न करें
text = "Clore.ai टेक्स्ट-टू-स्पीच सिंथेसिस सहित AI अनुप्रयोगों के लिए शक्तिशाली GPU इंफ्रास्ट्रक्चर प्रदान करता है।"

audio = tts.synthesize(
    text=text,
    reference_audio=reference_audio,
    reference_sr=sr,
    diffusion_steps=10,    # अधिक = बेहतर गुणवत्ता, धीमा
    embedding_scale=1.5,   # शैली की ताकत नियंत्रित करता है
    alpha=0.3,             # ध्वनिक शैली भार
    beta=0.7,              # प्रोसोडिक शैली भार
)

sf.write("cloned_voice_output.wav", audio, 24000)
print("क्लोन की गई आवाज़ का आउटपुट सहेजा गया!")

---

उदाहरण 3: अभिव्यंजक शैली नियंत्रण

from inference import StyleTTS2Inference
import soundfile as sf

tts = StyleTTS2Inference(
    model_path="Models/LibriTTS/epochs_2nd_00020.pth",
    config_path="Models/LibriTTS/config.yml",
    device="cuda"
)

text = "Clore.ai के साथ GPU कंप्यूटिंग पर हमारी प्रस्तुति में आपका स्वागत है।"

# विभिन्न शैली पैरामीटरों के साथ प्रयोग करें
style_configs = [
    {"name": "तटस्थ",    "alpha": 0.3, "beta": 0.7, "diffusion_steps": 5},
    {"name": "अभिव्यंजक", "alpha": 0.5, "beta": 0.9, "diffusion_steps": 15},
    {"name": "तेज़",       "alpha": 0.1, "beta": 0.3, "diffusion_steps": 3},
    {"name": "धीमा_गहरा",  "alpha": 0.7, "beta": 0.5, "diffusion_steps": 20},
]

for cfg in style_configs:
    audio = tts.synthesize(
        text=text,
        diffusion_steps=cfg["diffusion_steps"],
        alpha=cfg["alpha"],
        beta=cfg["beta"],
    )
    filename = f"style_{cfg['name']}.wav"
    sf.write(filename, audio, 24000)
    print(f"उत्पन्न किया गया: {filename}")

---

उदाहरण 4: Gradio वेब इंटरफ़ेस

import gradio as gr
import soundfile as sf
import numpy as np
from inference import StyleTTS2Inference
import tempfile

tts = StyleTTS2Inference(
    model_path="Models/LibriTTS/epochs_2nd_00020.pth",
    config_path="Models/LibriTTS/config.yml",
    device="cuda"
)

def synthesize(text, reference_audio, diffusion_steps, alpha, beta):
    if reference_audio is not None:
        sr, audio_data = reference_audio
        # अपेक्षित प्रारूप में परिवर्तित करें
        ref_audio = audio_data.astype(np.float32) / 32768.0
    else:
        ref_audio = None
        sr = None

    output = tts.synthesize(
        text=text,
        reference_audio=ref_audio,
        reference_sr=sr,
        diffusion_steps=int(diffusion_steps),
        alpha=alpha,
        beta=beta,
    )

    # अस्थायी फ़ाइल में सहेजें
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        sf.write(f.name, output, 24000)
        return f.name

demo = gr.Interface(
    fn=synthesize,
    inputs=[
        gr.Textbox(label="इनपुट पाठ", lines=4),
        gr.Audio(label="संदर्भ आवाज़ (वैकल्पिक)", type="numpy"),
        gr.Slider(1, 30, value=10, label="डिफ्यूज़न चरण"),
        gr.Slider(0.0, 1.0, value=0.3, label="अल्फ़ा (ध्वनिक शैली)"),
        gr.Slider(0.0, 1.0, value=0.7, label="बीटा (प्रोसोडिक शैली)"),
    ],
    outputs=gr.Audio(label="जनरेट किया गया भाषण"),
    title="Clore.ai GPU पर StyleTTS2",
    description="शैली डिफ्यूज़न के साथ मानव-स्तरीय TTS"
)

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

---

उदाहरण 5: बैच ऑडियोबुक जनरेशन

import soundfile as sf
import numpy as np
from pathlib import Path
from inference import StyleTTS2Inference

tts = StyleTTS2Inference(
    model_path="Models/LibriTTS/epochs_2nd_00020.pth",
    config_path="Models/LibriTTS/config.yml",
    device="cuda"
)

# पाठ को अनुच्छेदों में विभाजित करें
book_text = """
अध्याय एक: GPU क्रांति

कृत्रिम बुद्धिमत्ता का इतिहास 
ग्राफ़िक्स प्रोसेसिंग यूनिट्स के विकास से अलग नहीं किया जा सकता। जो पिक्सेल रेंडर करने के लिए विशेष हार्डवेयर के रूप में शुरू हुआ था 
वह आधुनिक AI क्रांति का इंजन बन गया।

अध्याय दो: वितरित कंप्यूटिंग

जैसे-जैसे मॉडल बड़े होते गए, सिंगल-GPU प्रशिक्षण की जगह वितरित प्रणालियों ने ले ली। 
Clore.ai जैसी प्लेटफ़ॉर्म्स ने इस गणनात्मक शक्ति तक पहुँच को लोकतांत्रिक बनाने के लिए उभरना शुरू किया, 
जिससे उद्यम-स्तर का GPU इंफ्रास्ट्रक्चर व्यक्तियों और स्टार्टअप्स के लिए सुलभ हो गया।
""".strip()

paragraphs = [p.strip() for p in book_text.split('\n\n') if p.strip()]
output_dir = Path("audiobook_output")
output_dir.mkdir(exist_ok=True)

audio_segments = []
for i, paragraph in enumerate(paragraphs):
    print(f"अनुच्छेद {i+1}/{len(paragraphs)} संसाधित किया जा रहा है...")
    audio = tts.synthesize(
        text=paragraph,
        diffusion_steps=10,
        alpha=0.3,
        beta=0.7,
    )
    segment_path = output_dir / f"segment_{i+1:03d}.wav"
    sf.write(str(segment_path), audio, 24000)
    audio_segments.append(audio)
    print(f"  ✓ सहेजा गया {segment_path}")

# सभी खंडों को थोड़ी मौन अवधि के साथ जोड़ें
silence = np.zeros(int(24000 * 0.5))  # 0.5 सेकंड का मौन
full_audio = []
for seg in audio_segments:
    full_audio.append(seg)
    full_audio.append(silence)

combined = np.concatenate(full_audio)
sf.write("audiobook_complete.wav", combined, 24000)
print(f"\nपूर्ण ऑडियोबुक: {len(combined)/24000:.1f} सेकंड")

---

कॉन्फ़िगरेशन

config.yml के मुख्य पैरामीटर

model_params:
  dim_in: 64
  hidden_dim: 512
  max_conv_dim: 512
  n_layer: 3
  n_mels: 80

diffusion:
  timesteps: 1000
  beta_schedule: "squaredcos_cap_v2"

training:
  batch_size: 16
  epochs: 100
  save_freq: 10

इन्फ़रेंस पैरामीटर

पैरामीटर	सीमा	डिफ़ॉल्ट	प्रभाव
diffusion_steps	1–30	10	गुणवत्ता बनाम गति समझौता
alpha	0.0–1.0	0.3	संदर्भ से ध्वनिक शैली का भार
beta	0.0–1.0	0.7	संदर्भ से प्रोसोडिक शैली का भार
embedding_scale	1.0–3.0	1.5	कुल शैली तीव्रता
t	0.6–1.0	0.7	शोर स्तर (अधिक = अधिक विविधता)

---

प्रदर्शन सुझाव

1. डिफ्यूज़न चरणों का अनुकूलन करें

10 चरणों का डिफ़ॉल्ट गुणवत्ता और गति के बीच संतुलन बनाता है। रीयल-टाइम अनुप्रयोगों के लिए 5 चरणों का उपयोग करें; अधिकतम गुणवत्ता के लिए 20–30 का उपयोग करें।

# रीयल-टाइम (तेज़)
audio = tts.synthesize(text, diffusion_steps=5)

# उच्च गुणवत्ता (धीमा)
audio = tts.synthesize(text, diffusion_steps=20)

2. torch.compile का उपयोग करें (PyTorch 2.0+)

import torch
model = torch.compile(model, mode="reduce-overhead")

3. मिश्रित-सटीकता इन्फ़रेंस

with torch.autocast(device_type="cuda", dtype=torch.float16):
    audio = tts.synthesize(text, diffusion_steps=10)

4. कई वाक्यों को बैच करें

जहाँ संभव हो, GPU उपयोग को अधिकतम करने और ओवरहेड कम करने के लिए कई वाक्यों को एक साथ संसाधित करें।

5. संदर्भ स्पीकर एम्बेडिंग कैश करें

# एक बार गणना करें, कई बार पुनः उपयोग करें
speaker_embedding = tts.compute_speaker_embedding(reference_audio, sr)

# कई उच्चारणों के लिए पुनः उपयोग करें
for text in texts:
    audio = tts.synthesize_with_embedding(text, speaker_embedding)

---

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

समस्या: espeak-ng नहीं मिला

apt-get install -y espeak-ng espeak-ng-data
# इंस्टॉलेशन सत्यापित करें
espeak-ng --version

समस्या: Phonemizer विफल होता है

pip install phonemizer
# परीक्षण
python3 -c "from phonemizer import phonemize; print(phonemize('hello world'))"

समस्या: CUDA मेमोरी समाप्त

# बैच आकार घटाएँ या CPU ऑफलोडिंग उपयोग करें
export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256
# या FP16 पर स्विच करें

समस्या: ऑडियो गुणवत्ता खराब

• बढ़ाएँ diffusion_steps 15–20 तक

• सुनिश्चित करें कि संदर्भ ऑडियो साफ़ हो, कम से कम 16kHz

• समायोजित करने का प्रयास करें alpha और beta पैरामीटर

• एक लंबा संदर्भ ऑडियो क्लिप उपयोग करें (15–30 सेकंड)

समस्या: Hugging Face से मॉडल डाउनलोड विफल होता है

pip install huggingface_hub
python3 -c "
from huggingface_hub import snapshot_download
snapshot_download('yl4579/StyleTTS2-LibriTTS', local_dir='Models/LibriTTS')
"

---

Clore.ai GPU अनुशंसाएँ

StyleTTS2 एक हल्का मॉडल है — LibriTTS चेकपॉइंट लगभग 300MB का है, और साधारण GPU पर भी इन्फ़रेंस तेज़ है।

GPU	VRAM	Clore.ai मूल्य	इन्फ़रेंस गति	किसके लिए सर्वोत्तम
केवल CPU	—	~$0.02/hr	~0.5× रीयल-टाइम	विकास, परीक्षण
RTX 3090	24 GB	$0.07–0.21/hr	~15× रीयल-टाइम	प्रोडक्शन API, वॉयस क्लोनिंग
RTX 4090	24 GB	$0.14–0.42/hr	~25× रीयल-टाइम	उच्च-सहवर्ती API
A100 40GB	40 GB	bare metal	~40× रीयल-टाइम	बड़े-प्रमाण पर बैच ऑडियोबुक जनरेशन

$0.07–0.21/घंटा पर RTX 3090 StyleTTS2 के लिए सबसे उपयुक्त विकल्प है। मॉडल इतना छोटा है कि GPU समय पर आपका खर्च लगभग नगण्य होता है — सिंथेसाइज़ किए गए ऑडियो का पूरा एक घंटा GPU किराये में $0.01 से कम पड़ता है। ऑडियोबुक उत्पादन या वॉयस क्लोनिंग सेवाओं के लिए, यह बेहद किफायती है।

ज़ीरो-शॉट वॉयस क्लोनिंग गुणवत्ता सुझाव: 22kHz या 24kHz पर 15–30 सेकंड का साफ़ संदर्भ ऑडियो दें। स्टाइल डिफ्यूज़न मॉड्यूल को बोलने की शैली, गति और प्रोसोडी को सही तरह कैप्चर करने के लिए पर्याप्त ऑडियो की आवश्यकता होती है। शोरयुक्त या छोटे संदर्भ आउटपुट गुणवत्ता को काफ़ी घटा देते हैं।

---

लिंक्स

• GitHub: https://github.com/yl4579/StyleTTS2

• पेपर (arXiv): https://arxiv.org/abs/2306.07691

• Hugging Face (LJSpeech): https://huggingface.co/yl4579/StyleTTS2-LJSpeech

• Hugging Face (LibriTTS): https://huggingface.co/yl4579/StyleTTS2-LibriTTS

• डेमो स्पेस: https://huggingface.co/spaces/styletts2/styletts2

• CLORE.AI मार्केटप्लेस: https://clore.ai/marketplace