# StyleTTS2 StyleTTS2 LJSpeech और LibriTTS बेंचमार्क्स पर ग्राउंड-ट्रुथ रिकॉर्डिंग्स से ऊपर मानव-मूल्यांकित प्राकृतिकता स्कोर प्राप्त करता है (MOS 4.55 बनाम 4.23 ग्राउंड-ट्रुथ). यह उपयोग करता है **स्टाइल डिफ्यूजन** और **विरोधी प्रशिक्षण** बोलने की शैलियों को एक लातेंट वेरिएबल वितरण के रूप में मॉडल करने के लिए, जिससे अभिव्यक्तिपूर्ण संश्लेषण और एक छोटे संदर्भ क्लिप से ज़ीरो-शॉट स्पीकर अनुकूलन सक्षम होता है। पारंपरिक TTS प्रणालियों के विपरीत, StyleTTS2 एक छोटे संदर्भ ऑडियो क्लिप के साथ अनदेखे वक्ताओं पर सामान्यीकरण कर सकता है, और ऐसा भाषण उत्पन्न करता है जो पेशेवर वॉइस एक्टर्स के समकक्ष है। इसे कई डेटासेट्स पर मानव-मूल्यांकित नैचुरलनेस स्कोर से अधिक प्रदर्शित करने के लिए बेंचमार्क किया गया है — ओपन-सोर्स TTS के लिए यह एक प्रथम उपलब्धि है। मुख्य विशेषताएँ: * **मानव-स्तरीय प्राकृतिकता** — LJSpeech पर मानव MOS स्कोर से आगे * **ज़ीरो-शॉट स्पीकर अनुकूलन** — किसी भी आवाज़ को एक छोटे ऑडियो नमूने से क्लोन करें * **स्टाइल डिफ्यूजन** — अभिव्यक्तिपूर्ण, विविध प्रोसोडी और बोलने की शैली * **मल्टि-स्पीकर समर्थन** — LibriTTS (2,300+ स्पीकर्स) पर प्रशिक्षित * **लाइटवेट इनफेरेंस** — कंज्यूमर GPUs पर कुशलतापूर्वक चलाता है {% hint style="success" %} सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें के माध्यम से किराये पर लिया जा सकता है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace). {% endhint %} *** ## सर्वर आवश्यकताएँ | पैरामीटर | न्यूनतम | अनुशंसित | | --------------- | ---------------------- | ----------------------- | | 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 | {% hint style="info" %} StyleTTS2 अपेक्षाकृत हल्का है — एक RTX 3070 या 3080 वास्तविक-समय इनफेरेंस को आराम से संभालता है। बैच प्रोसेसिंग या समवर्ती उपयोगकर्ताओं की सेवा के लिए, 4090 या A100 का उपयोग करें। {% endhint %} *** ## CLORE.AI पर त्वरित तैनाती StyleTTS2 को एक कस्टम Docker बिल्ड की आवश्यकता है क्योंकि कोई आधिकारिक प्री-बिल्ट इमेज उपलब्ध नहीं है। सेटअप में लगभग 10 मिनट लगते हैं। ### 1. एक उपयुक्त सर्वर खोजें जाएँ [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace) और फ़िल्टर करें: * **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 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://:7860 ``` *** ## चरण-दर-चरण सेटअप ### चरण 1: अपने सर्वर में SSH करें ```bash ssh root@ -p ``` ### चरण 2: सिस्टम निर्भरताएँ इंस्टॉल करें ```bash apt-get update && apt-get install -y \ git \ python3 \ python3-pip \ python3-venv \ ffmpeg \ espeak-ng \ libsndfile1 \ build-essential \ wget \ curl ``` ### चरण 3: StyleTTS2 रिपॉज़िटरी क्लोन करें ```bash cd /workspace git clone https://github.com/yl4579/StyleTTS2.git cd StyleTTS2 ``` ### चरण 4: Python वर्चुअल एन्वायरनमेंट बनाएं ```bash python3 -m venv venv source venv/bin/activate pip install --upgrade pip ``` ### चरण 5: निर्भरताएँ इंस्टॉल करें ```bash pip install -r requirements.txt # यदि आवश्यक हो तो अतिरिक्त निर्भरताएँ इंस्टॉल करें pip install phonemizer gruut ``` ### चरण 6: प्री-ट्रेंड मॉडल डाउनलोड करें ```bash # 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 बनाएं और चलाएं ```bash # 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 डेमो सीधे लॉन्च करें ```bash source venv/bin/activate python app.py ``` पहुँच: `http://:7860` *** ## उपयोग के उदाहरण ### उदाहरण 1: Python API के माध्यम से बेसिक TTS ```python 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: ज़ीरो-शॉट वॉइस क्लोनिंग ```python 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: अभिव्यक्त स्टाइल नियंत्रण ```python 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 वेब इंटरफ़ेस ```python 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: बैच ऑडियोबुक जनरेशन ```python 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 प्रमुख पैरामीटर ```yaml 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 का उपयोग करें। ```python # रीयल-टाइम (तेज़) audio = tts.synthesize(text, diffusion_steps=5) # उच्च गुणवत्ता (धीमा) audio = tts.synthesize(text, diffusion_steps=20) ``` ### 2. torch.compile का उपयोग करें (PyTorch 2.0+) ```python import torch model = torch.compile(model, mode="reduce-overhead") ``` ### 3. मिक्स्ड प्रिसिशन इनफेरेंस ```python with torch.autocast(device_type="cuda", dtype=torch.float16): audio = tts.synthesize(text, diffusion_steps=10) ``` ### 4. एक साथ कई वाक्यों का बैच प्रोसेसिंग GPU उपयोगिता अधिकतम करने और ओवरहेड कम करने के लिए संभव हो तो कई वाक्यों को एक साथ प्रोसेस करें। ### 5. संदर्भ स्पीकर एम्बेडिंग्स को कैश करें ```python # एक बार गणना करें, कई बार पुन: उपयोग करें speaker_embedding = tts.compute_speaker_embedding(reference_audio, sr) # कई उचारणों के लिए पुन: उपयोग करें for text in texts: audio = tts.synthesize_with_embedding(text, speaker_embedding) ``` *** ## समस्या निवारण ### समस्या: espeak-ng नहीं मिला ```bash apt-get install -y espeak-ng espeak-ng-data # स्थापना सत्यापित करें espeak-ng --version ``` ### समस्या: Phonemizer असफल है ```bash pip install phonemizer # टेस्ट python3 -c "from phonemizer import phonemize; print(phonemize('hello world'))" ``` ### समस्या: CUDA मेमोरी खत्म हो गई ```bash # बैच साइज कम करें या CPU ऑफलोडिंग का उपयोग करें export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256 # या FP16 पर स्विच करें ``` ### समस्या: कम ऑडियो गुणवत्ता * बढ़ाएँ `diffusion_steps` to 15–20 * सुनिश्चित करें कि संदर्भ ऑडियो साफ़ हो, न्यूनतम 16kHz * समायोजित करने का प्रयास करें `alpha` और `beta` पैरामीटर * लंबा संदर्भ ऑडियो क्लिप उपयोग करें (15–30 सेकंड) ### समस्या: Hugging Face से मॉडल डाउनलोड विफल ```bash 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× वास्तविक-समय | बड़े-बैच ऑडियोबुक जनरेशन | {% hint style="info" %} **RTX 3090 at \~$0.12/hr** StyleTTS2 के लिए यह इष्टतम विकल्प है। मॉडल इतना छोटा है कि आप GPU समय पर लगभग कुछ भी खर्च नहीं करते — एक घंटे की संश्लिष्ट ऑडियो की लागत GPU किराये में $0.01 से कम आती है। ऑडियोबुक उत्पादन या वॉइस क्लोनिंग सेवाओं के लिए यह अत्यंत लागत-कुशल है। {% endhint %} **ज़ीरो-शॉट वॉइस क्लोनिंग गुणवत्ता सुझाव:** 22kHz या 24kHz पर 15–30 सेकंड का साफ़ संदर्भ ऑडियो प्रदान करें। स्टाइल डिफ्यूजन मॉड्यूल को बोलने की शैली, गति और प्रोसोडी को सटीक रूप से पकड़ने के लिए पर्याप्त ऑडियो की आवश्यकता होती है। शोरयुक्त या छोटे संदर्भ आउटपुट गुणवत्ता को काफी घटाते हैं। *** ## लिंक * **GitHub**: * **पेपर (arXiv)**: * **Hugging Face (LJSpeech)**: * **Hugging Face (LibriTTS)**: * **डेमो स्पेस**: * **CLORE.AI मार्केटप्लेस**: