StyleTTS2

Clore.ai GPUs पर स्टाइल डिफ्यूज़न के माध्यम से मानव-स्तरीय टेक्स्ट-टू-स्पीच के लिए StyleTTS2 चलाएँ

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

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

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

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

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

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

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

• लाइटवेट इनफेरेंस — कंज्यूमर GPUs पर कुशलतापूर्वक चलाता है

सभी उदाहरण 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"Model loaded on: {device}")
print(f"VRAM used: {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 provides powerful GPU infrastructure for AI applications including text-to-speech synthesis."

audio = tts.synthesize(
    text=text,
    reference_audio=reference_audio,
    reference_sr=sr,
    diffusion_steps=10,    # Higher = better quality, slower
    embedding_scale=1.5,   # Controls style strength
    alpha=0.3,             # Acoustic style weight
    beta=0.7,              # Prosodic style weight
)

sf.write("cloned_voice_output.wav", audio, 24000)
print("Saved cloned voice output!")

---

उदाहरण 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 = "Welcome to our presentation on GPU computing with Clore.ai."

# विभिन्न स्टाइल पैरामीटर के साथ प्रयोग करें
style_configs = [
    {"name": "neutral",    "alpha": 0.3, "beta": 0.7, "diffusion_steps": 5},
    {"name": "expressive", "alpha": 0.5, "beta": 0.9, "diffusion_steps": 15},
    {"name": "fast",       "alpha": 0.1, "beta": 0.3, "diffusion_steps": 3},
    {"name": "slow_deep",  "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"Generated: {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="Input Text", lines=4),
        gr.Audio(label="Reference Voice (optional)", type="numpy"),
        gr.Slider(1, 30, value=10, label="Diffusion Steps"),
        gr.Slider(0.0, 1.0, value=0.3, label="Alpha (Acoustic Style)"),
        gr.Slider(0.0, 1.0, value=0.7, label="Beta (Prosodic Style)"),
    ],
    outputs=gr.Audio(label="Generated Speech"),
    title="StyleTTS2 on Clore.ai GPU",
    description="Human-level TTS with style diffusion"
)

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"Processing paragraph {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"  ✓ Saved {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"\nComplete audiobook: {len(combined)/24000:.1f} seconds")

---

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

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 to 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 है, मामूली GPUs पर भी इनफेरेंस तेज़ है।

GPU	VRAM	Clore.ai कीमत	इनफेरेंस स्पीड	माध्य/दिन
केवल CPU	आणविक गतिशीलता	~$0.02/घं	~0.5× वास्तविक-समय	डेवलपमेंट, परीक्षण
RTX 3090	24 GB	~$0.12/घंटा	~15× वास्तविक-समय	प्रोडक्शन API, वॉइस क्लोनिंग
RTX 4090	24 GB	~$0.70/घंटा	~25× वास्तविक-समय	उच्च समवर्तीता API
A100 40GB	40 GB	~$1.20/घंटा	~40× वास्तविक-समय	बड़े-बैच ऑडियोबुक जनरेशन

RTX 3090 at ~$0.12/hr 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