Coqui TTS: 45.3K+ Stars — 深度学习语音合成工具包，对比 ChatTTS、MeloTTS、Bark 性能基准测试 2026

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

# 安装 Coqui TTS 及所有依赖
pip install coqui-tts

# 验证安装
tts --list_models | head -20

pip install coqui-tts --upgrade

# 或从源码安装
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

# 验证
espeak-ng --version

# 拉取官方 GPU 镜像
docker pull ghcr.io/coqui-ai/tts:latest

# CPU 专用镜像（更小，无需 GPU）
docker pull ghcr.io/coqui-ai/tts-cpu:latest

# 使用 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

# 列出所有可用模型
tts --list_models

# 使用预训练英文模型进行基础合成
tts --text "Hello world, this is Coqui TTS speaking." \
    --model_name tts_models/en/ljspeech/tacotron2-DDC \
    --out_path output.wav

# XTTS v2 多语言语音克隆
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

# 自动检测 GPU
device = "cuda" if torch.cuda.is_available() else "cpu"

# 使用 XTTS v2 初始化
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)

# 使用内置说话人合成
wav = tts.tts(
    text="Coqui TTS supports seventeen languages out of the box.",
    speaker="Ana Florence",
    language="en"
)

# 从 6 秒参考音频克隆语音
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"
)

# 批量克隆多个参考文件以提高质量
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"
)

# 启动内置服务（非生产级，生产环境使用 nginx 后的 gunicorn）
tts-server \
    --model_name tts_models/multilingual/multi-dataset/xtts_v2 \
    --port 5002 \
    --use_cuda true

# 调用默认端点
curl "http://localhost:5002/api/tts?text=Hello+world&speaker_id=Ana+Florence&language_id=en" \
    -o output.wav

# 调用 OpenAI 兼容端点
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)
    
    # 转换为 WAV 字节
    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

# 预下载 XTTS v2 模型到镜像中
RUN python3 -c "from TTS.api import TTS; \
    TTS('tts_models/multilingual/multi-dataset/xtts_v2')"

# 预热：构建时触发 CUDA 内核编译
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"]

# 将源说话人语音转换为目标说话人
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")

# 触发 JIT 编译
_ = tts.tts(text="warm up", speaker_wav=None, language="en")
print("[warmup] CUDA 内核已编译，模型就绪")

# 将 PyTorch 模型转换为 ONNX 以获得 2 倍加速
import torch
from TTS.api import TTS

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

# 导出为 ONNX（需要模型特定代码）
# 参考：https://github.com/coqui-ai/TTS/tree/dev/TTS/tts/layers

# 启用 FP16 推理
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):
    """以批处理方式处理文本以最大化 GPU 利用率。"""
    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:  # 批大小为 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 = []

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

# 以 LJSpeech 格式准备数据集：
# metadata.csv: audio_file|text|speaker_name
# wavs/*.wav: 22050 Hz, 单声道, 16 位

# 运行微调配方
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

# 预计训练时间：RTX 4090 上 1 小时数据需 12-24 小时

from prometheus_client import Counter, Histogram, generate_latest

# 指标
TTS_REQUESTS = Counter('tts_requests_total', '总 TTS 请求数', ['language'])
TTS_LATENCY = Histogram('tts_latency_seconds', '请求延迟')
TTS_ERRORS = Counter('tts_errors_total', '总错误数', ['error_type'])

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

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