> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/styletss2.md). # StyleTTS2 Clore.ai GPUs पर Style diffusion के ज़रिए StyleTTS2 मानव-स्तर टेक्स्ट-टू-स्पीच चलाएँ StyleTTS2 LJSpeech और LibriTTS बेंचमार्क पर ग्राउंड-ट्रुथ रिकॉर्डिंग्स से ऊपर मानव-मूल्यांकित स्वाभाविकता स्कोर प्राप्त करता है (MOS 4.55 बनाम 4.23 ग्राउंड ट्रुथ)। यह उपयोग करता है **स्टाइल डिफ्यूज़न** और **प्रतिकूल प्रशिक्षण** बोलने की शैलियों को एक गुप्त चर वितरण के रूप में मॉडल करने के लिए, जिससे एक छोटे संदर्भ क्लिप से अभिव्यक्तिपूर्ण सिंथेसिस और ज़ीरो-शॉट स्पीकर अनुकूलन संभव होता है। पारंपरिक TTS प्रणालियों के विपरीत, StyleTTS2 एक छोटे संदर्भ ऑडियो क्लिप के साथ अनदेखे स्पीकर्स पर सामान्यीकरण कर सकता है, और ऐसा भाषण उत्पन्न करता है जो पेशेवर वॉयस कलाकारों को टक्कर देता है। इसे कई डेटासेट्स पर मानव-मूल्यांकित स्वाभाविकता स्कोर से अधिक प्रदर्शन करने के लिए बेंचमार्क किया गया है — ओपन-सोर्स TTS के लिए यह पहली बार है। मुख्य विशेषताएँ: * **मानव-स्तरीय स्वाभाविकता** — LJSpeech पर मानव MOS स्कोर से आगे * **ज़ीरो-शॉट स्पीकर अनुकूलन** — किसी भी आवाज़ को एक छोटे ऑडियो नमूने से क्लोन करें * **स्टाइल डिफ्यूज़न** — अभिव्यंजक, विविध प्रोसोडी और बोलने की शैली * **मल्टी-स्पीकर समर्थन** — LibriTTS (2,300+ स्पीकर्स) पर प्रशिक्षित * **हल्का इन्फ़रेंस** — उपभोक्ता GPU पर कुशलतापूर्वक चलता है {% 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"मॉडल यहाँ लोड हुआ: {device}") print(f"उपयोग की गई VRAM: {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 टेक्स्ट-टू-स्पीच सिंथेसिस सहित 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: अभिव्यंजक शैली नियंत्रण ```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 = "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 वेब इंटरफ़ेस ```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="इनपुट पाठ", 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: बैच ऑडियोबुक जनरेशन ```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"अनुच्छेद {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 के मुख्य पैरामीटर ```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` 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 का है, और साधारण 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](https://clore.ai/bare-metal) | \~40× रीयल-टाइम | बड़े-प्रमाण पर बैच ऑडियोबुक जनरेशन | {% hint style="info" %} **$0.07–0.21/घंटा पर RTX 3090** StyleTTS2 के लिए सबसे उपयुक्त विकल्प है। मॉडल इतना छोटा है कि GPU समय पर आपका खर्च लगभग नगण्य होता है — सिंथेसाइज़ किए गए ऑडियो का पूरा एक घंटा GPU किराये में $0.01 से कम पड़ता है। ऑडियोबुक उत्पादन या वॉयस क्लोनिंग सेवाओं के लिए, यह बेहद किफायती है। {% endhint %} **ज़ीरो-शॉट वॉयस क्लोनिंग गुणवत्ता सुझाव:** 22kHz या 24kHz पर 15–30 सेकंड का साफ़ संदर्भ ऑडियो दें। स्टाइल डिफ्यूज़न मॉड्यूल को बोलने की शैली, गति और प्रोसोडी को सही तरह कैप्चर करने के लिए पर्याप्त ऑडियो की आवश्यकता होती है। शोरयुक्त या छोटे संदर्भ आउटपुट गुणवत्ता को काफ़ी घटा देते हैं। *** ## लिंक्स * **GitHub**: * **पेपर (arXiv)**: * **Hugging Face (LJSpeech)**: * **Hugging Face (LibriTTS)**: * **डेमो स्पेस**: * **CLORE.AI मार्केटप्लेस**: --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/styletss2.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.