# MeloTTS MeloTTS एक उच्च-गुणवत्ता, बहुभाषीय टेक्स्ट-टू-स्पीच पुस्तकालय है जिसे विकसित किया गया है **MyShell AI**। यह कई भाषाओं और अंग्रेज़ी उच्चारणों में तेज़, प्राकृतिक-शब्दों जैसा स्पीच सिंथेसिस प्रदान करता है, जिसे अनुसंधान और उत्पादन डिप्लॉयमेंट दोनों के लिए डिज़ाइन किया गया है। MeloTTS गति के लिए अनुकूलित है — यह CPU पर भी वास्तविक-समय से काफी तेज़ी से स्पीच जेनरेट कर सकता है — जबकि व्यावसायिक उपयोग के लिए उपयुक्त उच्च ऑडियो गुणवत्ता बनाए रखता है। MeloTTS वर्तमान में निम्नलिखित का समर्थन करता है: * **अंग्रेज़ी** (अमेरिकी, ब्रिटिश, भारतीय, ऑस्ट्रेलियाई, डिफ़ॉल्ट) * **चीनी (सरलीकृत और मिश्रित चीनी-अंग्रेज़ी)** * **जापानी** * **कोरियाई** * **स्पैनिश** * **फ्रेंच** मुख्य हाइलाइट्स: * MLflow, Triton Inference Server, BentoML, ClearML **तेज़ अनुमान (फास्ट इनफरेंस)** — CPU पर वास्तविक-समय से तेज़, GPU पर बेहद तेज़ * 🌍 **बहुभाषीय** — अंग्रेज़ी के लिए उच्चारण वेरिएंट सहित 6 भाषाएँ * 🐳 **Docker-रेडी** — आधिकारिक Docker इमेज उपलब्ध * 🔌 **REST API** — किसी भी एप्लिकेशन में एकीकृत करने के लिए HTTP API * 📱 **उत्पादन-ग्रेड** — MyShell के ग्राहक उत्पादों में उपयोग किया गया {% hint style="success" %} सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें के माध्यम से किराये पर लिया जा सकता है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace). {% endhint %} *** ## सर्वर आवश्यकताएँ | पैरामीटर | न्यूनतम | अनुशंसित | | --------------- | ---------------------- | ----------------------- | | GPU | NVIDIA GTX 1080 (8 GB) | NVIDIA RTX 3090 (24 GB) | | VRAM | 4 GB | 8–16 GB | | RAM | 8 GB | 16 GB | | CPU | 4 कोर | 8 कोर | | डिस्क | 10 GB | 20 GB | | ऑपरेटिंग सिस्टम | Ubuntu 20.04+ | Ubuntu 22.04 | | CUDA | 11.7+ (वैकल्पिक) | 12.1+ | | Python | 3.8+ | 3.10 | | पोर्ट्स | 22, 8888 | 22, 8888 | {% hint style="info" %} MeloTTS अनूठी रूप से कुशल है — यह एकल अनुरोधों के लिए CPU पर अच्छी तरह चलती है और बैच प्रोसेसिंग के लिए GPU से बहुत लाभ प्राप्त करती है। यहां तक कि एक बजट GPU भी थ्रूपुट को नाटकीय रूप से दोगुना कर देता है। {% endhint %} *** ## CLORE.AI पर त्वरित तैनाती {% hint style="warning" %} **नोट:** MeloTTS का Docker Hub पर कोई आधिकारिक प्री-बिल्ट Docker इमेज नहीं है (`myshell-ai/melotts` अस्तित्व में नहीं है)। अनुशंसित तरीका यह है कि NVIDIA CUDA बेस इमेज का उपयोग करें और MeloTTS को आधिकारिक GitHub रिपॉजिटरी से pip के माध्यम से इंस्टॉल करें। {% endhint %} ### 1. एक उपयुक्त सर्वर खोजें जाएँ [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace) और फ़िल्टर करें: * **VRAM**: ≥ 4 GB (या कम मात्रा के लिए केवल CPU) * **GPU**: कोई भी NVIDIA GPU (GTX 1080+, RTX सीरीज़, A100) * **डिस्क**: ≥ 10 GB ### 2. अपनी तैनाती कॉन्फ़िगर करें **Docker इमेज:** ``` nvidia/cuda:12.1.0-devel-ubuntu22.04 ``` **पोर्ट मैपिंग्स:** ``` 22 → SSH एक्सेस 8888 → MeloTTS API सर्वर ``` **पर्यावरण चर:** ``` NVIDIA_VISIBLE_DEVICES=all ``` **स्टार्टअप कमांड** (सर्वर में SSH के बाद चलाएँ): ```bash apt-get update && apt-get install -y python3-pip ffmpeg espeak-ng git && \ git clone https://github.com/myshell-ai/MeloTTS.git && \ cd MeloTTS && pip install -e . && \ python -m unidic download && \ python3 -c "import nltk; nltk.download('averaged_perceptron_tagger_eng')" && \ python -m melo.api_server --host 0.0.0.0 --port 8888 ``` ### 3. API तक पहुँचें ``` http://:8888 ``` यहाँ परीक्षण करें: ```bash curl -X POST http://:8888/synthesize \ -H "Content-Type: application/json" \ -d '{"text": "Hello from Clore.ai!", "language": "EN", "speaker_id": "EN-Default"}' ``` *** ## चरण-दर-चरण सेटअप ### चरण 1: अपने सर्वर में SSH करें ```bash ssh root@ -p ``` ### चरण 2: कंटेनर बनाएँ और चलाएँ चूँकि MeloTTS का कोई प्री-बिल्ट Docker Hub इमेज नहीं है, NVIDIA CUDA बेस का उपयोग करें और स्रोत से MeloTTS इंस्टॉल करें: ```bash # एक CUDA कंटेनर चलाएँ और उसके अंदर MeloTTS इंस्टॉल करें docker run -d \ --name melotts \ --gpus all \ -p 8888:8888 \ -v /workspace/melotts/outputs:/app/outputs \ -e NVIDIA_VISIBLE_DEVICES=all \ nvidia/cuda:12.1.0-devel-ubuntu22.04 \ bash -c "apt-get update && apt-get install -y python3-pip ffmpeg espeak-ng git && \ git clone https://github.com/myshell-ai/MeloTTS.git /app/MeloTTS && \ cd /app/MeloTTS && pip install -e . && \ python -m unidic download && \ python3 -c \"import nltk; nltk.download('averaged_perceptron_tagger_eng')\" && \ python -m melo.api_server --host 0.0.0.0 --port 8888" ``` वैकल्पिक रूप से, स्रोत से एक कस्टम Docker इमेज बनाएँ: ```bash git clone https://github.com/myshell-ai/MeloTTS.git cd MeloTTS docker build -t melotts:local . docker run -d \ --name melotts \ --gpus all \ -p 8888:8888 \ melotts:local ``` ### चरण 3: सेवा चल रही है क्या सत्यापित करें ```bash # कंटेनर लॉग्स जाँचें docker logs -f melotts # स्टार्टअप का इंतज़ार करें, फिर परीक्षण करें curl http://localhost:8888/health ``` ### चरण 4: वैकल्पिक — Jupyter Notebook इंटरफ़ेस ```bash docker run -d \ --name melotts-jupyter \ --gpus all \ -p 8888:8888 \ nvidia/cuda:12.1.0-devel-ubuntu22.04 \ bash -c "pip install jupyter melo-tts && \ jupyter notebook --ip=0.0.0.0 --port=8888 --no-browser --allow-root" ``` एक्सेस करें इस पर: `http://:8888` ### चरण 5: pip से इंस्टॉल करें (Docker के बिना) ```bash # सिस्टम निर्भरताएँ इंस्टॉल करें apt-get install -y python3-pip ffmpeg espeak-ng # MeloTTS इंस्टॉल करें pip install melo-tts # आवश्यक NLTK डेटा डाउनलोड करें python3 -c "import nltk; nltk.download('averaged_perceptron_tagger_eng')" ``` *** ## उपयोग के उदाहरण ### उदाहरण 1: बुनियादी अंग्रेज़ी TTS (Python) ```python from melo.api import TTS # अंग्रेज़ी TTS इनिशियलाइज़ करें speed = 1.0 # स्पीच की गति समायोजित करें (0.5 = धीमी, 2.0 = तेज़) device = 'cuda' # यदि GPU उपलब्ध न हो तो 'cpu' का उपयोग करें tts = TTS(language='EN', device=device) # उपलब्ध स्पीकर आईडी प्राप्त करें speakers = tts.hps.data.spk2id print("उपलब्ध स्पीकर:", list(speakers.keys())) # आउटपुट: ['EN-Default', 'EN-US', 'EN-GB', 'EN-India', 'EN-Australia', 'EN-Brazil'] # स्पीच जेनरेट करें speaker_ids = tts.hps.data.spk2id output_path = "output_english.wav" tts.tts_to_file( text="Welcome to Clore.ai, your GPU cloud marketplace for AI workloads. Rent powerful GPUs in minutes.", speaker_id=speaker_ids['EN-Default'], output_path=output_path, speed=speed ) print(f"Saved to: {output_path}") ``` *** ### उदाहरण 2: बहुभाषीय TTS ```python from melo.api import TTS device = 'cuda' # भाषा-टेक्स्ट जोड़े परिभाषित करें language_texts = [ ('EN', 'EN-US', "GPU computing has transformed artificial intelligence research and development."), ('EN', 'EN-GB', "The United Kingdom leads Europe in AI investment and innovation."), ('ZH', 'ZH', "Clore.ai是一个去中心化的GPU云计算市场，为AI开发者提供算力服务。"), ('JP', 'JP', "人工知能の発展には大規模な計算資源が必要です。"), ('KR', 'KR', "Clore.ai는 AI 연구자를 위한 GPU 클라우드 마켓플레이스입니다."), ('SP', 'SP', "La inteligencia artificial está transformando todas las industrias del mundo."), ('FR', 'FR', "L'intelligence artificielle révolutionne la façon dont nous travaillons et vivons."), ] for lang, speaker, text in language_texts: try: tts = TTS(language=lang, device=device) speaker_id = tts.hps.data.spk2id[speaker] output_file = f"output_{lang}_{speaker}.wav" tts.tts_to_file(text=text, speaker_id=speaker_id, output_path=output_file) print(f"✓ Generated [{lang}]: {output_file}") except Exception as e: print(f"✗ Error [{lang}]: {e}") ``` *** ### उदाहरण 3: REST API उपयोग ```python import requests import json API_BASE = "http://:8888" # उपलब्ध आवाज़ों की जाँच करें response = requests.get(f"{API_BASE}/voices") print("उपलब्ध आवाज़ें:", json.dumps(response.json(), indent=2)) # स्पीच सिंथेसाइज़ करें def synthesize(text, language="EN", speaker="EN-Default", speed=1.0): payload = { "text": text, "language": language, "speaker_id": speaker, "speed": speed, "format": "wav" } response = requests.post( f"{API_BASE}/synthesize", json=payload, timeout=30 ) if response.status_code == 200: return response.content else: raise Exception(f"API error: {response.status_code} - {response.text}") # सैंपल जेनरेट करें samples = [ ("Hello, this is MeloTTS running on Clore.ai GPU servers.", "EN", "EN-US"), ("This is the British English accent variant.", "EN", "EN-GB"), ("Let me demonstrate the Indian English accent.", "EN", "EN-India"), ] for text, lang, speaker in samples: audio_bytes = synthesize(text, lang, speaker) filename = f"api_output_{speaker.replace('-', '_')}.wav" with open(filename, "wb") as f: f.write(audio_bytes) print(f"Saved: {filename}") ``` *** ### उदाहरण 4: उच्च-गति बैच प्रोसेसिंग ```python from melo.api import TTS from concurrent.futures import ThreadPoolExecutor import soundfile as sf import time import numpy as np from pathlib import Path device = 'cuda' tts = TTS(language='EN', device=device) speaker_id = tts.hps.data.spk2id['EN-US'] # टेक्स्ट का बड़ा बैच texts = [ f"This is sentence number {i}. It demonstrates fast batch processing with MeloTTS on Clore.ai GPU infrastructure." for i in range(1, 51) # 50 sentences ] output_dir = Path("batch_output") output_dir.mkdir(exist_ok=True) start_time = time.time() # बैच प्रोसेस करें for i, text in enumerate(texts): output_path = str(output_dir / f"batch_{i+1:03d}.wav") tts.tts_to_file( text=text, speaker_id=speaker_id, output_path=output_path, speed=1.0, quiet=True ) if (i + 1) % 10 == 0: elapsed = time.time() - start_time print(f"Progress: {i+1}/50 | Time: {elapsed:.1f}s | Rate: {(i+1)/elapsed:.1f} sentences/sec") total_time = time.time() - start_time print(f"\nBatch complete: {len(texts)} sentences in {total_time:.1f}s") print(f"Average: {total_time/len(texts)*1000:.0f}ms per sentence") ``` *** ### उदाहरण 5: मिश्रित चीनी-अंग्रेज़ी TTS ```python from melo.api import TTS device = 'cuda' tts = TTS(language='ZH', device=device) speaker_id = tts.hps.data.spk2id['ZH'] # मिश्रित भाषा टेक्स्ट (चीनी + अंग्रेज़ी) mixed_texts = [ "हम Clore.ai के GPU सर्वरों का उपयोग machine learning workloads चलाने के लिए करते हैं।", "आज की AI conference में large language models और speech synthesis तकनीक पर चर्चा हुई।", "मेरी startup को हमारे deep learning मॉडल को ट्रेन करने के लिए GPU संसाधनों की आवश्यकता है।", "Clore.ai बहुत प्रतिस्पर्धी कीमतें प्रदान करता है, जो AWS और GCP की तुलना में काफी सस्ती हैं।", ] for i, text in enumerate(mixed_texts): output_file = f"mixed_zh_en_{i+1}.wav" tts.tts_to_file( text=text, speaker_id=speaker_id, output_path=output_file, speed=0.9 # स्पष्टता के लिए थोड़ा धीमा ) print(f"Generated: {output_file}") print(f" Text: {text[:60]}...") ``` *** ## कॉन्फ़िगरेशन ### Docker Compose सेटअप चूँकि MeloTTS का कोई आधिकारिक Docker Hub इमेज नहीं है, स्टार्टअप पर NVIDIA CUDA बेस इमेज का उपयोग करें और स्रोत से MeloTTS इंस्टॉल करें: ```yaml version: '3.8' services: melotts: image: nvidia/cuda:12.1.0-devel-ubuntu22.04 container_name: melotts runtime: nvidia environment: - NVIDIA_VISIBLE_DEVICES=all - PYTHONDONTWRITEBYTECODE=1 ports: - "8888:8888" volumes: - ./outputs:/app/outputs - ./cache:/root/.cache command: > bash -c "apt-get update && apt-get install -y python3-pip ffmpeg espeak-ng git && git clone https://github.com/myshell-ai/MeloTTS.git /app/MeloTTS && cd /app/MeloTTS && pip install -e . && python -m unidic download && python3 -c 'import nltk; nltk.download(\"averaged_perceptron_tagger_eng\")' && python -m melo.api_server --host 0.0.0.0 --port 8888" restart: unless-stopped healthcheck: test: ["CMD", "curl", "-f", "http://localhost:8888/health"] interval: 30s timeout: 10s retries: 3 deploy: resources: reservations: devices: - driver: nvidia count: 1 capabilities: [gpu] ``` ### API कॉन्फ़िगरेशन विकल्प | पैरामीटर | डिफ़ॉल्ट | विवरण | | ----------- | ----------- | ---------------------------------------------------------- | | `--host` | `127.0.0.1` | बाँधने वाला पता (इस्तेमाल करें `0.0.0.0` सार्वजनिक के लिए) | | `--port` | `8888` | API सर्वर पोर्ट | | `--workers` | `1` | वर्कर प्रक्रियाओं की संख्या | | `--device` | `auto` | `cuda`, `cpu`USDT `auto` | ### समर्थित भाषाएँ और स्पीकर्स | भाषा | कोड | स्पीकर आईडी | | --------- | ---- | ----------------------------------------------------------------------- | | अंग्रेज़ी | `EN` | `EN-Default`, `EN-US`, `EN-GB`, `EN-India`, `EN-Australia`, `EN-Brazil` | | चीनी | `ZH` | `ZH` | | जापानी | `JP` | `JP` | | कोरियाई | `KR` | `KR` | | स्पैनिश | `SP` | `SP` | | फ्रेंच | `FR` | `FR` | *** ## प्रदर्शन सुझाव ### 1. GPU बनाम CPU बेंचमार्क MeloTTS प्रदर्शन (RTF = रियल-टाइम फैक्टर, कम बेहतर): | डिवाइस | RTF | नोट्स | | ----------- | ------- | ------------------------- | | CPU (8 कोर) | \~0.3x | तेज़, कम लोड के लिए अच्छा | | RTX 3080 | \~0.05x | रियल-टाइम से 20x तेज़ | | RTX 4090 | \~0.02x | रियल-टाइम से 50x तेज़ | | A100 | \~0.01x | रियल-टाइम से 100x तेज़ | ### 2. थ्रूपुट के लिए अनुकूलित करें ```python # अनुमान (इनफरेंस) के लिए ग्रेडिएंट गणना अक्षम करें import torch with torch.no_grad(): tts.tts_to_file(text, speaker_id, output_path) ``` ### 3. मॉडल को प्री-वॉर्म करें ```python # CUDA कर्नल लोड करने के लिए एक वॉर्मअप इनफरेंस चलाएँ tts.tts_to_file( text="warmup", speaker_id=speaker_id, output_path="/dev/null" ) print("मॉडल वार्म्ड अप हो गया है, तेज़ इनफरेंस के लिए तैयार") ``` ### 4. ऑडियो गुणवत्ता बनाम गति समायोजित करें ```python # तेज़ (थोड़ी कम गुणवत्ता) tts.tts_to_file(text, speaker_id, output_path, speed=1.2) # धीमी स्पीच (बेहतर उच्चारण) tts.tts_to_file(text, speaker_id, output_path, speed=0.8) ``` ### 5. मेमोरी दक्षता ```python # बड़े बैचों के बीच GPU मेमोरी खाली करें import gc import torch gc.collect() torch.cuda.empty_cache() ``` *** ## समस्या निवारण ### समस्या: `espeak-ng` नहीं मिला ```bash apt-get install -y espeak-ng python3 -c "import phonemizer; print('phonemizer OK')" ``` ### समस्या: NLTK डेटा गायब ```bash python3 -c " import nltk nltk.download('averaged_perceptron_tagger_eng') nltk.download('punkt') " ``` ### समस्या: पोर्ट 8888 Jupyter से टकरा रहा है MeloTTS डिफ़ॉल्ट रूप से पोर्ट 8888 उपयोग करता है, जो Jupyter Notebook के साथ टकराता है। समाधान: ```bash # विकल्प 1: MeloTTS को किसी अलग पोर्ट पर चलाएँ python -m melo.api_server --host 0.0.0.0 --port 8889 # विकल्प 2: Jupyter को किसी अलग पोर्ट पर चलाएँ jupyter notebook --port 8890 ``` ### समस्या: चीनी टेक्स्ट सही तरीके से रेंडर नहीं हो रहा है ```bash # चीनी भाषा समर्थन इंस्टॉल करें pip install jieba apt-get install -y python3-opencc # टेस्ट python3 -c "from melo.api import TTS; t = TTS('ZH'); print('ZH OK')" ``` ### समस्या: Docker इमेज पुल विफल हो रही है ```bash # इसके बजाय स्रोत से बनाएँ git clone https://github.com/myshell-ai/MeloTTS.git cd MeloTTS pip install -e . python3 -c "import nltk; nltk.download('averaged_perceptron_tagger_eng')" ``` ### समस्या: GPU पर इनफरेंस धीमा है ```bash # सत्यापित करें कि GPU उपयोग हो रहा है python3 -c " import torch from melo.api import TTS tts = TTS('EN', device='cuda') print(f'Device: {next(tts.model.parameters()).device}') print(f'CUDA उपलब्ध: {torch.cuda.is_available()}') " ``` *** ## Clore.ai GPU सिफारिशें MeloTTS हल्का है — यह कम वॉल्यूम के लिए CPU पर अच्छी तरह चलता है और GPU कंप्यूट के साथ रैखिक रूप से स्केल करता है। आपको महंगे हार्डवेयर की आवश्यकता नहीं है। | GPU | VRAM | Clore.ai कीमत | RTF (रियल-टाइम फैक्टर) | क्षमता | | --------- | -------------- | ------------- | ------------------------- | ------------- | | केवल CPU | आणविक गतिशीलता | \~$0.02/घं | \~0.3× | \~3 req/min | | RTX 3090 | 24 GB | \~$0.12/घंटा | \~0.02× (50× रियल-टाइम) | \~100 req/min | | RTX 4090 | 24 GB | \~$0.70/घंटा | \~0.01× (100× रियल-टाइम) | \~200 req/min | | A100 40GB | 40 GB | \~$1.20/घंटा | \~0.005× (200× रियल-टाइम) | \~400 req/min | {% hint style="info" %} **TTS वर्कलोड के लिए सर्वोत्तम मूल्य:** RTX 3090 पर ~~$0.12/घं पर 50× रियल-टाइम TTS गति प्रदान करता है। सैकड़ों उपयोगकर्ताओं को सेवा देने वाले उत्पादन API के लिए यह अधिक than पर्याप्त है। केवल CPU वाले उदाहरण (~~$0.02/घं) विकास और कम-ट्रैफ़िक डिप्लॉयमेंट के लिए ठीक काम करते हैं। {% endhint %} **उत्पादन सिफारिश:** 10–50 समकालिक उपयोगकर्ताओं को सेवा देने वाले बहुभाषीय TTS API के लिए, RTX 3090 सबसे उपयुक्त है। महंगे A100 पर अपग्रेड करने की बजाय क्षैतिज रूप से स्केल करें (कई उदाहरण) — MeloTTS उच्च-स्तरीय GPUs से समानुपातिक लाभ नहीं लेता। *** ## लिंक * **GitHub**: * **Docker**: कोई आधिकारिक Docker Hub इमेज नहीं — से इंस्टॉल करें [GitHub स्रोत](https://github.com/myshell-ai/MeloTTS) का उपयोग करते हुए `nvidia/cuda:12.1.0-devel-ubuntu22.04` बेस इमेज * **पेपर**: * **Hugging Face**: * **MyShell AI**: * **CLORE.AI मार्केटप्लेस**: