Coqui TTS：45.3K+ 星

python -m venv coqui-env
source coqui-env/bin/activate

# Install Coqui TTS with all dependencies
pip install coqui-tts

# Verify installation
tts --list_models | head -20

pip install coqui-tts --upgrade

# Or install from source
git clone https://github.com/idiap/coqui-ai-TTS.git
cd coqui-ai-TTS
pip install -e .

# Ubuntu / Debian
sudo apt-get install espeak-ng

# macOS
brew install espeak

# Verify
espeak-ng --version

# Pull the official GPU image
docker pull ghcr.io/coqui-ai/tts:latest

# CPU-only image (smaller, no GPU needed)
docker pull ghcr.io/coqui-ai/tts-cpu:latest

# Start the server with XTTS v2
docker run -d --name coqui-tts \
  --gpus all \
  -p 5002:5002 \
  -v tts_models:/root/.local/share/tts \
  ghcr.io/coqui-ai/tts \
  --model_name tts_models/multilingual/multi-dataset/xtts_v2 \
  --use_cuda true

# List all available models
tts --list_models

# Basic synthesis with a pre-trained English model
tts --text "Hello world, this is Coqui TTS speaking." \
    --model_name tts_models/en/ljspeech/tacotron2-DDC \
    --out_path output.wav

# XTTS v2 multilingual with voice cloning
tts --model_name tts_models/multilingual/multi-dataset/xtts_v2 \
    --text "你好，欢迎使用 Coqui TTS 语音合成。" \
    --speaker_wav reference_voice.wav \
    --language_idx zh \
    --out_path chinese_output.wav

import torch
from TTS.api import TTS

# Auto-detect GPU
device = "cuda" if torch.cuda.is_available() else "cpu"

# Initialize with XTTS v2
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)

# Synthesize with a built-in speaker
wav = tts.tts(
    text="Coqui TTS supports seventeen languages out of the box.",
    speaker="Ana Florence",
    language="en"
)

# Clone a voice from 6 seconds of reference audio
tts.tts_to_file(
    text="This cloned voice will sound like your reference speaker.",
    speaker_wav="/path/to/reference_speaker.wav",
    language="en",
    file_path="cloned_output.wav"
)

# Batch clone with multiple reference files for better quality
tts.tts_to_file(
    text="Multiple references improve cloning consistency.",
    speaker_wav=["ref1.wav", "ref2.wav", "ref3.wav"],
    language="en",
    file_path="batch_cloned.wav"
)

# Start the built-in server (not production-grade, use gunicorn behind nginx)
tts-server \
    --model_name tts_models/multilingual/multi-dataset/xtts_v2 \
    --port 5002 \
    --use_cuda true

# Query the default endpoint
curl "http://localhost:5002/api/tts?text=Hello+world&speaker_id=Ana+Florence&language_id=en" \
    -o output.wav

# Query the OpenAI-compatible endpoint
curl -X POST "http://localhost:5002/v1/audio/speech" \
    -H "Content-Type: application/json" \
    -d '{
        "input": "This endpoint is compatible with OpenAI SDKs.",
        "voice": "Ana Florence",
        "response_format": "wav"
    }' \
    --output openai_compat.wav

from flask import Flask, request, send_file
from TTS.api import TTS
import torch
import io
import soundfile as sf

app = Flask(__name__)
device = "cuda" if torch.cuda.is_available() else "cpu"
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)

@app.route("/synthesize", methods=["POST"])
def synthesize():
    data = request.get_json()
    text = data.get("text", "")
    language = data.get("language", "en")
    speaker_wav = data.get("speaker_wav", None)
    
    wav = tts.tts(text=text, speaker_wav=speaker_wav, language=language)
    
    # Convert to WAV bytes
    buffer = io.BytesIO()
    sf.write(buffer, wav, samplerate=24000, format="WAV")
    buffer.seek(0)
    
    return send_file(buffer, mimetype="audio/wav")

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

# docker-compose.yml
version: '3.8'

services:
  coqui-tts:
    build: .
    container_name: coqui-tts-service
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    ports:
      - "5002:5002"
    volumes:
      - ./tts_models:/home/appuser/.local/share/tts
      - ./config:/app/config
      - ./audio_output:/app/audio_output
    environment:
      - CUDA_VISIBLE_DEVICES=0
      - PYTHONUNBUFFERED=1
      - TTS_HOME=/home/appuser/.local/share/tts
    shm_size: '2gb'
    command: >
      sh -c "python3 /app/config/server.py"

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - coqui-tts

FROM nvidia/cuda:12.1-runtime-ubuntu22.04

ENV DEBIAN_FRONTEND=noninteractive
RUN apt-get update && apt-get install -y \
    python3 python3-pip espeak-ng git \
    libsndfile1 ffmpeg \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
RUN pip install --no-cache-dir coqui-tts torch torchaudio \
    flask gunicorn soundfile

# Pre-download XTTS v2 model to bake into image
RUN python3 -c "from TTS.api import TTS; \
    TTS('tts_models/multilingual/multi-dataset/xtts_v2')"

# Warm-up: trigger CUDA kernel compilation at build time
COPY warm_up.py .
RUN python3 warm_up.py

EXPOSE 5002
CMD ["gunicorn", "-w", "1", "-b", "0.0.0.0:5002", "--timeout", "120", "server:app"]

# Convert voice from source to target speaker
tts = TTS("voice_conversion_models/multilingual/vctk/freevc24").to("cuda")

tts.voice_conversion_to_file(
    source_wav="source_speaker.wav",
    target_wav="target_voice.wav",
    file_path="converted_voice.wav"
)

# warm_up.py
import os
from TTS.api import TTS

MODEL = os.getenv("TTS_MODEL", "tts_models/multilingual/multi-dataset/xtts_v2")
tts = TTS(MODEL)
if torch.cuda.is_available():
    tts = tts.to("cuda")

# Trigger JIT compilation
_ = tts.tts(text="warm up", speaker_wav=None, language="en")
print("[warmup] CUDA kernels compiled, model ready")

# Convert PyTorch model to ONNX for 2x speedup
import torch
from TTS.api import TTS

tts = TTS("tts_models/en/ljspeech/tacotron2-DDC").to("cuda")

# Export to ONNX (requires model-specific code)
# See: https://github.com/coqui-ai/TTS/tree/dev/TTS/tts/layers

# Enable FP16 inference
torch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.benchmark = True

from concurrent.futures import ThreadPoolExecutor
import queue

def batch_worker(text_queue, result_queue):
    """Process texts in batches to maximise GPU utilisation."""
    tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")
    batch = []
    
    while True:
        try:
            item = text_queue.get(timeout=0.5)
            batch.append(item)
            
            if len(batch) >= 8:  # Batch size of 8
                for b in batch:
                    wav = tts.tts(text=b["text"], language=b["lang"])
                    result_queue.put({"id": b["id"], "wav": wav})
                batch = []
        except queue.Empty:
            if batch:
                for b in batch:
                    wav = tts.tts(text=b["text"], language=b["lang"])
                    result_queue.put({"id": b["id"], "wav": wav})
                batch = []

# Usage
with ThreadPoolExecutor(max_workers=2) as executor:
    executor.submit(batch_worker, text_q, result_q)

# Prepare dataset in LJSpeech format:
# metadata.csv: audio_file|text|speaker_name
# wavs/*.wav: 22050 Hz, mono, 16-bit

# Run fine-tuning recipe
python TTS/bin/train_tts.py \
    --config_path TTS/tts/recipes/xtts_v2/train_gpt_xtts.py \
    --restore_path /path/to/xtts_v2.pth \
    --output_path ./xtts_finetuned/ \
    --formatter ljspeech \
    --dataset_path /path/to/your_dataset \
    --batch_size 4 \
    --epochs 10

# Expected training time: 12-24 hours on RTX 4090 for 1 hour of data

from prometheus_client import Counter, Histogram, generate_latest

# Metrics
TTS_REQUESTS = Counter('tts_requests_total', 'Total TTS requests', ['language'])
TTS_LATENCY = Histogram('tts_latency_seconds', 'Request latency')
TTS_ERRORS = Counter('tts_errors_total', 'Total errors', ['error_type'])

@app.route("/metrics")
def metrics():
    return generate_latest()

@app.route("/synthesize", methods=["POST"])
def synthesize():
    with TTS_LATENCY.time():
        try:
            # ... synthesis logic
            TTS_REQUESTS.labels(language=lang).inc()
        except Exception as e:
            TTS_ERRORS.labels(error_type=type(e).__name__).inc()
            raise