MeloTTS

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

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

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

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

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

• जापानी

• कोरियाई

• स्पेनिश

• फ़्रेंच

मुख्य विशेषताएँ:

• ⚡ तेज़ इन्फ़रेंस — 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 बेस इमेज का उपयोग करें और आधिकारिक GitHub रिपॉज़िटरी से pip के माध्यम से MeloTTS इंस्टॉल करें।

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

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

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

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": "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.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 इमेज बनाएं:

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.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://<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)

# उपलब्ध स्पीकर 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

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

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 त्रुटि: {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: उच्च-गति बैच प्रोसेसिंग

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

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

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

# इन्फ़रेंस के लिए ग्रेडिएंट गणना निष्क्रिय करें
import torch

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

3. मॉडल को पहले से गर्म करें

# CUDA kernels लोड करने के लिए वॉर्मअप इन्फ़रेंस चलाएँ
tts.tts_to_file(
    text="वॉर्मअप",
    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/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	~0.005× (200× वास्तविक समय)	~400 req/min

TTS वर्कलोड्स के लिए सर्वोत्तम मूल्य: $0.07–0.21/घंटा पर RTX 3090, 50× वास्तविक-समय TTS गति प्रदान करता है। सैकड़ों उपयोगकर्ताओं को सेवा देने वाले प्रोडक्शन API के लिए यह पूरी तरह पर्याप्त है। केवल CPU वाले इंस्टेंस ($0.07–0.21/घंटा) विकास और कम-ट्रैफ़िक तैनाती के लिए ठीक काम करते हैं।

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

---

लिंक्स

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

• Docker: कोई आधिकारिक Docker Hub इमेज नहीं — इससे इंस्टॉल करें GitHub स्रोत का उपयोग करके nvidia/cuda:12.8.1-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