> 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/melotts.md). # MeloTTS Clore.ai GPUs पर MeloTTS उच्च-गुणवत्ता बहुभाषी TTS को तेज़ इन्फ़रेंस के साथ चलाएँ MeloTTS एक उच्च-गुणवत्ता वाली, बहुभाषी टेक्स्ट-टू-स्पीच लाइब्रेरी है, जिसे विकसित किया गया है **MyShell AI**. यह कई भाषाओं और अंग्रेज़ी उच्चारणों में तेज़, प्राकृतिक-ध्वनि वाली स्पीच सिंथेसिस प्रदान करता है, जिसे शोध और प्रोडक्शन तैनाती दोनों के लिए डिज़ाइन किया गया है। MeloTTS को गति के लिए अनुकूलित किया गया है — यह CPU पर भी वास्तविक समय से काफ़ी तेज़ स्पीच जनरेट कर सकता है — जबकि व्यावसायिक उपयोग के लिए उपयुक्त उच्च ऑडियो गुणवत्ता बनाए रखता है। MeloTTS वर्तमान में समर्थन करता है: * **अंग्रेज़ी** (अमेरिकी, ब्रिटिश, भारतीय, ऑस्ट्रेलियाई, डिफ़ॉल्ट) * **चीनी (सरलीकृत एवं मिश्रित चीनी-अंग्रेज़ी)** * **जापानी** * **कोरियाई** * **स्पेनिश** * **फ़्रेंच** मुख्य विशेषताएँ: * ⚡ **तेज़ इन्फ़रेंस** — 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 बेस इमेज का उपयोग करें और आधिकारिक GitHub रिपॉज़िटरी से pip के माध्यम से MeloTTS इंस्टॉल करें। {% 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.8.1-devel-ubuntu22.04 ``` **पोर्ट मैपिंग:** ``` 22 → SSH पहुँच 8888 → MeloTTS API सर्वर ``` **Environment Variables:** ``` 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": "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.8.1-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.8.1-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) # उपलब्ध स्पीकर IDs प्राप्त करें 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="Clore.ai में आपका स्वागत है, AI वर्कलोड्स के लिए आपका GPU क्लाउड मार्केटप्लेस। शक्तिशाली GPUs मिनटों में किराए पर लें।", speaker_id=speaker_ids['EN-Default'], output_path=output_path, speed=speed ) print(f"यहाँ सहेजा गया: {output_path}") ``` *** ### उदाहरण 2: बहुभाषी TTS ```python from melo.api import TTS device = 'cuda' # भाषा-पाठ युग्म परिभाषित करें language_texts = [ ('EN', 'EN-US', "GPU कंप्यूटिंग ने कृत्रिम बुद्धिमत्ता के शोध और विकास को बदल दिया है."), ('EN', 'EN-GB', "यूनाइटेड किंगडम AI निवेश और नवाचार में यूरोप का नेतृत्व करता है."), ('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 त्रुटि: {response.status_code} - {response.text}") # नमूने जनरेट करें samples = [ ("नमस्ते, यह Clore.ai GPU सर्वरों पर चल रहा MeloTTS है।", "EN", "EN-US"), ("यह ब्रिटिश अंग्रेज़ी उच्चारण वैरिएंट है।", "EN", "EN-GB"), ("मैं भारतीय अंग्रेज़ी उच्चारण का प्रदर्शन करता हूँ।", "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"यह वाक्य संख्या {i} है। यह Clore.ai GPU अवसंरचना पर MeloTTS के साथ तेज़ बैच प्रोसेसिंग का प्रदर्शन करता है." for i in range(1, 51) # 50 वाक्य ] 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"प्रगति: {i+1}/50 | समय: {elapsed:.1f}s | दर: {(i+1)/elapsed:.1f} वाक्य/सेकंड") total_time = time.time() - start_time print(f"\nबैच पूरा: {len(texts)} वाक्य {total_time:.1f}s में") print(f"औसत: प्रति वाक्य {total_time/len(texts)*1000:.0f}ms") ``` *** ### उदाहरण 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需要GPU资源来训练我们的deep learning模型。", "Clore.ai提供了非常competitive的价格，比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"जनरेट किया गया: {output_file}") print(f" पाठ: {text[:60]}...") ``` *** ## कॉन्फ़िगरेशन ### Docker Compose सेटअप चूँकि MeloTTS की कोई आधिकारिक Docker Hub इमेज नहीं है, इसलिए NVIDIA CUDA बेस इमेज का उपयोग करें और स्टार्टअप पर MeloTTS को स्रोत से इंस्टॉल करें: ```yaml version: '3.8' services: melotts: image: nvidia/cuda:12.8.1-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`या `auto` | ### समर्थित भाषाएँ और स्पीकर | भाषा | कोड | स्पीकर IDs | | --------- | ---- | ----------------------------------------------------------------------- | | अंग्रेज़ी | `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 = Real-Time Factor, कम बेहतर है): | डिवाइस | RTF | नोट्स | | ----------- | ------- | ----------------------------- | | CPU (8 कोर) | \~0.3x | तेज़, कम लोड के लिए बढ़िया | | RTX 3080 | \~0.05x | वास्तविक समय से 20 गुना तेज़ | | RTX 4090 | \~0.02x | वास्तविक समय से 50 गुना तेज़ | | A100 | \~0.01x | वास्तविक समय से 100 गुना तेज़ | ### 2. थ्रूपुट के लिए अनुकूलित करें ```python # इन्फ़रेंस के लिए ग्रेडिएंट गणना निष्क्रिय करें import torch with torch.no_grad(): tts.tts_to_file(text, speaker_id, output_path) ``` ### 3. मॉडल को पहले से गर्म करें ```python # CUDA kernels लोड करने के लिए वॉर्मअप इन्फ़रेंस चलाएँ tts.tts_to_file( text="वॉर्मअप", 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/hr | \~0.3× | \~3 req/min | | RTX 3090 | 24 GB | $0.07–0.21/hr | \~0.02× (50× वास्तविक समय) | \~100 req/min | | RTX 4090 | 24 GB | $0.14–0.42/hr | \~0.01× (100× वास्तविक समय) | \~200 req/min | | A100 40GB | 40 GB | [bare metal](https://clore.ai/bare-metal) | \~0.005× (200× वास्तविक समय) | \~400 req/min | {% hint style="info" %} **TTS वर्कलोड्स के लिए सर्वोत्तम मूल्य:** $0.07–0.21/घंटा पर RTX 3090, 50× वास्तविक-समय TTS गति प्रदान करता है। सैकड़ों उपयोगकर्ताओं को सेवा देने वाले प्रोडक्शन API के लिए यह पूरी तरह पर्याप्त है। केवल CPU वाले इंस्टेंस ($0.07–0.21/घंटा) विकास और कम-ट्रैफ़िक तैनाती के लिए ठीक काम करते हैं। {% endhint %} **प्रोडक्शन अनुशंसा:** 10–50 समकालिक उपयोगकर्ताओं को सेवा देने वाले बहुभाषी TTS API के लिए RTX 3090 सबसे उपयुक्त विकल्प है। महंगे A100 में अपग्रेड करने के बजाय क्षैतिज रूप से (कई इंस्टेंस) स्केल करें — MeloTTS को उच्च-स्तरीय GPUs से अनुपातिक लाभ नहीं मिलता। *** ## लिंक्स * **GitHub**: * **Docker**: कोई आधिकारिक Docker Hub इमेज नहीं — इससे इंस्टॉल करें [GitHub स्रोत](https://github.com/myshell-ai/MeloTTS) का उपयोग करके `nvidia/cuda:12.8.1-devel-ubuntu22.04` बेस इमेज * **पेपर**: * **Hugging Face**: * **MyShell AI**: * **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/melotts.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.