MeloTTS

Clore.ai GPUs पर तेज़ इनफेरेंस के साथ उच्च-गुणवत्ता बहुभाषी TTS MeloTTS चलाएँ

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

MeloTTS वर्तमान में निम्नलिखित का समर्थन करता है:

• अंग्रेज़ी (अमेरिकी, ब्रिटिश, भारतीय, ऑस्ट्रेलियाई, डिफ़ॉल्ट)

• चीनी (सरलीकृत और मिश्रित चीनी-अंग्रेज़ी)

• जापानी

• कोरियाई

• स्पैनिश

• फ्रेंच

मुख्य हाइलाइट्स:

• MLflow, Triton Inference Server, BentoML, ClearML तेज़ अनुमान (फास्ट इनफरेंस) — CPU पर वास्तविक-समय से तेज़, GPU पर बेहद तेज़

• 🌍 बहुभाषीय — अंग्रेज़ी के लिए उच्चारण वेरिएंट सहित 6 भाषाएँ

• 🐳 Docker-रेडी — आधिकारिक Docker इमेज उपलब्ध

• 🔌 REST API — किसी भी एप्लिकेशन में एकीकृत करने के लिए HTTP API

• 📱 उत्पादन-ग्रेड — MyShell के ग्राहक उत्पादों में उपयोग किया गया

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें के माध्यम से किराये पर लिया जा सकता है CLORE.AI मार्केटप्लेस.

---

सर्वर आवश्यकताएँ

पैरामीटर	न्यूनतम	अनुशंसित
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

MeloTTS अनूठी रूप से कुशल है — यह एकल अनुरोधों के लिए CPU पर अच्छी तरह चलती है और बैच प्रोसेसिंग के लिए GPU से बहुत लाभ प्राप्त करती है। यहां तक कि एक बजट GPU भी थ्रूपुट को नाटकीय रूप से दोगुना कर देता है।

---

CLORE.AI पर त्वरित तैनाती

नोट: MeloTTS का Docker Hub पर कोई आधिकारिक प्री-बिल्ट Docker इमेज नहीं है (myshell-ai/melotts अस्तित्व में नहीं है)। अनुशंसित तरीका यह है कि NVIDIA CUDA बेस इमेज का उपयोग करें और MeloTTS को आधिकारिक GitHub रिपॉजिटरी से pip के माध्यम से इंस्टॉल करें।

1. एक उपयुक्त सर्वर खोजें

जाएँ CLORE.AI मार्केटप्लेस और फ़िल्टर करें:

• 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 के बाद चलाएँ):

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://<your-clore-server-ip>:8888

यहाँ परीक्षण करें:

curl -X POST http://<server-ip>:8888/synthesize \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello from Clore.ai!", "language": "EN", "speaker_id": "EN-Default"}'

---

चरण-दर-चरण सेटअप

चरण 1: अपने सर्वर में SSH करें

ssh root@<your-clore-server-ip> -p <ssh-port>

चरण 2: कंटेनर बनाएँ और चलाएँ

चूँकि MeloTTS का कोई प्री-बिल्ट Docker Hub इमेज नहीं है, NVIDIA CUDA बेस का उपयोग करें और स्रोत से MeloTTS इंस्टॉल करें:

# एक 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 इमेज बनाएँ:

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: सेवा चल रही है क्या सत्यापित करें

# कंटेनर लॉग्स जाँचें
docker logs -f melotts

# स्टार्टअप का इंतज़ार करें, फिर परीक्षण करें
curl http://localhost:8888/health

चरण 4: वैकल्पिक — Jupyter Notebook इंटरफ़ेस

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://<server-ip>:8888

चरण 5: pip से इंस्टॉल करें (Docker के बिना)

# सिस्टम निर्भरताएँ इंस्टॉल करें
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)

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

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 उपयोग

import requests
import json

API_BASE = "http://<your-clore-server-ip>: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: उच्च-गति बैच प्रोसेसिंग

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

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 इंस्टॉल करें:

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, cpuUSDT 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. थ्रूपुट के लिए अनुकूलित करें

# अनुमान (इनफरेंस) के लिए ग्रेडिएंट गणना अक्षम करें
import torch

with torch.no_grad():
    tts.tts_to_file(text, speaker_id, output_path)

3. मॉडल को प्री-वॉर्म करें

# CUDA कर्नल लोड करने के लिए एक वॉर्मअप इनफरेंस चलाएँ
tts.tts_to_file(
    text="warmup",
    speaker_id=speaker_id,
    output_path="/dev/null"
)
print("मॉडल वार्म्ड अप हो गया है, तेज़ इनफरेंस के लिए तैयार")

4. ऑडियो गुणवत्ता बनाम गति समायोजित करें

# तेज़ (थोड़ी कम गुणवत्ता)
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. मेमोरी दक्षता

# बड़े बैचों के बीच GPU मेमोरी खाली करें
import gc
import torch

gc.collect()
torch.cuda.empty_cache()

---

समस्या निवारण

समस्या: espeak-ng नहीं मिला

apt-get install -y espeak-ng
python3 -c "import phonemizer; print('phonemizer OK')"

समस्या: NLTK डेटा गायब

python3 -c "
import nltk
nltk.download('averaged_perceptron_tagger_eng')
nltk.download('punkt')
"

समस्या: पोर्ट 8888 Jupyter से टकरा रहा है

MeloTTS डिफ़ॉल्ट रूप से पोर्ट 8888 उपयोग करता है, जो Jupyter Notebook के साथ टकराता है। समाधान:

# विकल्प 1: MeloTTS को किसी अलग पोर्ट पर चलाएँ
python -m melo.api_server --host 0.0.0.0 --port 8889

# विकल्प 2: Jupyter को किसी अलग पोर्ट पर चलाएँ
jupyter notebook --port 8890

समस्या: चीनी टेक्स्ट सही तरीके से रेंडर नहीं हो रहा है

# चीनी भाषा समर्थन इंस्टॉल करें
pip install jieba
apt-get install -y python3-opencc

# टेस्ट
python3 -c "from melo.api import TTS; t = TTS('ZH'); print('ZH OK')"

समस्या: Docker इमेज पुल विफल हो रही है

# इसके बजाय स्रोत से बनाएँ
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 पर इनफरेंस धीमा है

# सत्यापित करें कि 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

TTS वर्कलोड के लिए सर्वोत्तम मूल्य: RTX 3090 पर $0.12/घं पर 50× रियल-टाइम TTS गति प्रदान करता है। सैकड़ों उपयोगकर्ताओं को सेवा देने वाले उत्पादन API के लिए यह अधिक than पर्याप्त है। केवल CPU वाले उदाहरण ($0.02/घं) विकास और कम-ट्रैफ़िक डिप्लॉयमेंट के लिए ठीक काम करते हैं।

उत्पादन सिफारिश: 10–50 समकालिक उपयोगकर्ताओं को सेवा देने वाले बहुभाषीय TTS API के लिए, RTX 3090 सबसे उपयुक्त है। महंगे A100 पर अपग्रेड करने की बजाय क्षैतिज रूप से स्केल करें (कई उदाहरण) — MeloTTS उच्च-स्तरीय GPUs से समानुपातिक लाभ नहीं लेता।

---

लिंक

• GitHub: https://github.com/myshell-ai/MeloTTS

• Docker: कोई आधिकारिक Docker Hub इमेज नहीं — से इंस्टॉल करें GitHub स्रोत का उपयोग करते हुए nvidia/cuda:12.1.0-devel-ubuntu22.04 बेस इमेज

• पेपर: https://arxiv.org/abs/2406.06753

• Hugging Face: https://huggingface.co/myshell-ai/MeloTTS-English

• MyShell AI: https://myshell.ai

• CLORE.AI मार्केटप्लेस: https://clore.ai/marketplace