MeloTTS：7400+ 星标 — 多语言 TTS 与 Coqui TTS 基准对比

# Ubuntu/Debian
sudo apt-get update && sudo apt-get install -y espeak-ng libsndfile1 ffmpeg

# macOS
brew install espeak libsndfile ffmpeg

# Verify espeak-ng
espeak-ng --version

# Create a virtual environment
python -m venv melotts-env
source melotts-env/bin/activate

# Install MeloTTS
pip install melotts

# Download Japanese dictionary (required for JA support)
python -m unidic download

git clone https://github.com/myshell-ai/MeloTTS.git
cd MeloTTS
pip install -e .
python -m unidic download

git clone https://github.com/myshell-ai/MeloTTS.git
cd MeloTTS
docker build -t melotts .
docker run -it -p 8888:8888 melotts

docker run --gpus all -it -p 8888:8888 melotts

from melo.api import TTS

# Speed is adjustable
speed = 1.0
device = 'auto'  # auto-detects GPU, falls back to CPU

text = "MeloTTS is working correctly on this machine."
model = TTS(language='EN', device=device)
speaker_ids = model.hps.data.spk2id

output_path = 'test_output.wav'
model.tts_to_file(text, speaker_ids['EN-Default'], output_path, speed=speed)
print(f"Audio saved to {output_path}")

# CLI usage (after pip install)
melo "Hello, this is MeloTTS speaking." output.wav -l EN --speaker EN-US

# List available speakers
melo --list-speakers

from melo.api import TTS

speed = 1.0
device = 'auto'

text = "Did you ever hear a folk tale about a giant turtle?"
model = TTS(language='EN', device=device)
speaker_ids = model.hps.data.spk2id

# American accent
model.tts_to_file(text, speaker_ids['EN-US'], 'en-us.wav', speed=speed)

# British accent
model.tts_to_file(text, speaker_ids['EN-BR'], 'en-br.wav', speed=speed)

# Indian accent
model.tts_to_file(text, speaker_ids['EN_INDIA'], 'en-india.wav', speed=speed)

# Australian accent
model.tts_to_file(text, speaker_ids['EN-AU'], 'en-au.wav', speed=speed)

from melo.api import TTS

speed = 1.0
device = 'cpu'

# Chinese speaker handles English words seamlessly
text = "我最近在学习machine learning，希望能够在未来的artificial intelligence领域有所建树。"
model = TTS(language='ZH', device=device)
speaker_ids = model.hps.data.spk2id

output_path = 'zh-mixed.wav'
model.tts_to_file(text, speaker_ids['ZH'], output_path, speed=speed)

from melo.api import TTS

speed = 1.0
device = 'cpu'

text = "こんにちは、これは日本語の音声合成テストです。"
model = TTS(language='JA', device=device)
speaker_ids = model.hps.data.spk2id

output_path = 'ja.wav'
model.tts_to_file(text, speaker_ids['JA'], output_path, speed=speed)

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from melo.api import TTS
import tempfile
import os

app = FastAPI()

# Pre-load models for supported languages
models = {}
for lang in ['EN', 'ZH', 'ES', 'FR', 'JA', 'KO']:
    models[lang] = TTS(language=lang, device='auto')

class TTSRequest(BaseModel):
    text: str
    language: str = 'EN'
    speaker: str = 'EN-Default'
    speed: float = 1.0

@app.post("/tts")
async def text_to_speech(req: TTSRequest):
    if req.language not in models:
        raise HTTPException(status_code=400, detail=f"Language {req.language} not supported")
    
    model = models[req.language]
    speaker_ids = model.hps.data.spk2id
    
    if req.speaker not in speaker_ids:
        raise HTTPException(status_code=400, detail=f"Speaker {req.speaker} not found")
    
    output_path = tempfile.mktemp(suffix='.wav')
    model.tts_to_file(req.text, speaker_ids[req.speaker], output_path, speed=req.speed)
    
    return {"audio_file": output_path}

uvicorn tts_api:app --host 0.0.0.0 --port 8000 --workers 2

version: '3.8'

services:
  melotts:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8888:8888"
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8888"]
      interval: 30s
      timeout: 10s
      retries: 3

import asyncio
import websockets
import json
from melo.api import TTS
from melo.utils import get_streaming_tts

model = TTS(language='EN', device='auto')
speaker_ids = model.hps.data.spk2id

async def tts_stream(websocket, path):
    async for message in websocket:
        data = json.loads(message)
        text = data.get('text', '')
        speaker = data.get('speaker', 'EN-Default')
        speed = data.get('speed', 1.0)
        
        # Stream audio chunks
        for chunk in model.stream_tts(text, speaker_ids[speaker], speed=speed):
            await websocket.send(chunk)

start_server = websockets.serve(tts_stream, '0.0.0.0', 8765)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

import gradio as gr
from melo.api import TTS

model = TTS(language='EN', device='auto')
speaker_ids = model.hps.data.spk2id
speaker_names = list(speaker_ids.keys())

def synthesize(text, speaker, speed):
    output_path = '/tmp/gradio_output.wav'
    model.tts_to_file(text, speaker_ids[speaker], output_path, speed=float(speed))
    return output_path

iface = gr.Interface(
    fn=synthesize,
    inputs=[
        gr.Textbox(label="Text", value="Hello from MeloTTS!"),
        gr.Dropdown(choices=speaker_names, label="Speaker", value="EN-Default"),
        gr.Slider(0.5, 2.0, value=1.0, label="Speed")
    ],
    outputs=gr.Audio(label="Generated Audio"),
    title="MeloTTS Web UI",
    description="Real-time multi-lingual text-to-speech"
)

iface.launch(server_name='0.0.0.0', server_port=7860)

from melo.api import TTS
import functools

@functools.lru_cache(maxsize=6)
def get_model(language):
    """Cached model loader — models are loaded once and reused."""
    return TTS(language=language, device='auto')

# Pre-warm all languages at startup
for lang in ['EN', 'ZH', 'ES', 'FR', 'JA', 'KO']:
    get_model(lang)
print("All models loaded and ready.")

from melo.api import TTS
import concurrent.futures

model = TTS(language='EN', device='cuda:0')
speaker_ids = model.hps.data.spk2id

texts = [
    "First sentence to synthesize.",
    "Second sentence to synthesize.",
    "Third sentence to synthesize.",
]

def synth(text):
    output_path = f"batch_{hash(text)}.wav"
    model.tts_to_file(text, speaker_ids['EN-Default'], output_path)
    return output_path

# Parallel batch processing
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    results = list(executor.map(synth, texts))

# Install gunicorn with uvicorn workers
pip install gunicorn uvicorn

# Run with 4 workers
gunicorn tts_api:app -k uvicorn.workers.UvicornWorker \
  --bind 0.0.0.0:8000 \
  --workers 4 \
  --timeout 120 \
  --max-requests 1000 \
  --max-requests-jitter 100

[Unit]
Description=MeloTTS REST API
After=network.target

[Service]
Type=simple
User=melotts
Group=melotts
WorkingDirectory=/opt/melotts
Environment=PYTHONPATH=/opt/melotts
Environment=CUDA_VISIBLE_DEVICES=0
ExecStart=/opt/melotts/venv/bin/gunicorn tts_api:app -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000 --workers 4
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

sudo cp melotts.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable melotts
sudo systemctl start melotts
sudo systemctl status melotts

from prometheus_client import Counter, Histogram, generate_latest
from fastapi import Response

# Metrics
tts_requests = Counter('melotts_requests_total', 'Total TTS requests', ['language', 'speaker'])
tts_duration = Histogram('melotts_duration_seconds', 'TTS generation duration')

@app.get("/metrics")
async def metrics():
    return Response(content=generate_latest(), media_type="text/plain")

@app.post("/tts")
async def text_to_speech(req: TTSRequest):
    with tts_duration.time():
        # ... existing TTS logic ...
        tts_requests.labels(language=req.language, speaker=req.speaker).inc()

upstream melotts {
    server 127.0.0.1:8000;
    keepalive 32;
}

server {
    listen 80;
    server_name tts.yourdomain.com;

    location / {
        proxy_pass http://melotts;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_connect_timeout 30s;
        proxy_send_timeout 120s;
        proxy_read_timeout 120s;
        
        # Rate limiting
        limit_req zone=tts_zone burst=20 nodelay;
    }
}