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