Coqui TTS: 45.3K+ Stars — Bộ Công Cụ TTS Học Sâu, So Sánh Hiệu Suất với ChatTTS, MeloTTS 2026

{{< resource-info >}}

Giới thiệu #

Chọn một công cụ chuyển văn bản thành giọng nói (TTS) cho môi trường sản xuất giống như đi bộ trên một bãi mìn. Hầu hết các bản demo đều nghe tốt trên GPU máy tính để bàn, nhưng sẽ sụp đổ khi đối mặt với tải đồng thởi, làm phình to Docker image lên 10 GB, hoặc thất bại ngay khi chuyển từ tiếng Anh sang tiếng Trung. Bài viết này là một coqui tts tutorial hướng dẫn text to speech setup được cứng hóa cho sản xuất, so sánh hiệu năng tts benchmark với ChatTTS, MeloTTS và Bark, bao gồm phân tích coqui tts vs chattts, cùng với các tệp cấu hình chúng tôi sử dụng để phục vụ 5000+ yêu cầu mỗi ngày. Sau khi đánh giá sáu khung TTS mã nguồn mở cho hệ thống hỗ trợ khách hàng đa ngôn ngữ, Coqui TTS nổi lên như công cụ duy nhất đáp ứng mọi nhu cầu: hỗ trợ 1100+ ngôn ngữ qua Fairseq, streaming dưới 200ms với XTTS v2, và coqui tts docker image khởi động trong vòng 30 giây.

Coqui TTS là gì? #

Coqui TTS là bộ công cụ tổng hợp giọng nói bằng học sâu mã nguồn mở, phân nhánh từ Mozilla TTS và được cộng đồng duy trì sau khi công ty Coqui AI gốc đóng cửa vào tháng 12 năm 2023. Với 45,300 sao GitHub, đây là một trong những thư viện TTS nơ-ron được sử dụng rộng rãi nhất. Dự án bao gồm công thức huấn luyện, mô hình tiền huấn luyện và API suy luận trong một gói Python duy nhất, hỗ trợ kiến trúc từ Tacotron2 đến VITS đến mô hình XTTS v2 chủ lực xử lý nhân bản giọng nói qua 17 ngôn ngữ.

Coqui TTS hoạt động như thế nào #

Coqui TTS tách quy trình tổng hợp thành ba giai đoạn có thể hoán đổi cho nhau: mô hình văn bản-sang-phổ, bộ mã hóa ngườii nói, và bộ tổng hợp âm thanh (vocoder). Thiết kế mô-đun này cho phép bạn hoán đổi các thành phần mà không cần huấn luyện lại toàn bộ.

Sơ đồ kiến trúc bên dưới cho thấy luồng dữ liệu từ văn bản thô đến đầu ra âm thanh:

Các khái niệm cốt lõi:

• Mô hình phổ — Tacotron2, Glow-TTS, FastSpeech2, VITS chuyển đổi văn bản thô thành phổ Mel. VITS là mô hình end-to-end, bỏ qua bước vocoder riêng biệt, vì vậy đạt hệ số thờii gian thực 67x trên GPU.
• Bộ mã hóa ngườii nói — Tính toán các embedding ngườii nói từ âm thanh tham chiếu. XTTS v2 sử dụng tính năng này để nhân bản giọng nói zero-shot chỉ với 3 giây âm thanh tham chiếu.
• Vocoder — HiFi-GAN, MelGAN và ParallelWaveGAN chuyển đổi phổ Mel thành dạng sóng âm thanh thô. HiFi-GAN là lựa chọn mặc định cho triển khai sản xuất vì cân bằng tốt giữa tốc độ và chất lượng.
• XTTS v2 — Kiến trúc dựa trên GPT chủ lực thống nhất phân tích văn bản, điều kiện ngườii nói và tạo âm thanh trong một lần truyền xuôi. Hỗ trợ 17 ngôn ngữ và streaming với độ trễ chunk đầu tiên dưới 200ms.

Các loại mô hình có sẵn:

Cài đặt và thiết lập #

Yêu cầu: Python 3.9+, CUDA 11.8+ (tùy chọn, cho GPU), tối thiểu 4 GB RAM, khuyến nghị 8 GB VRAM cho XTTS v2.

Cài đặt từ PyPI trong vòng hai phút:

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

# Cài đặt Coqui TTS cùng tất cả các phụ thuộc
pip install coqui-tts

# Xác minh cài đặt
tts --list_models | head -20

Cài đặt phiên bản phát triển mới nhất từ nhánh cộng đồng:

pip install coqui-tts --upgrade

# Hoặc cài đặt từ mã nguồn
git clone https://github.com/idiap/coqui-ai-TTS.git
cd coqui-ai-TTS
pip install -e .

Cài đặt espeak-ng cho các mô hình dựa trên âm vị (bắt buộc cho nhiều ngôn ngữ không phải tiếng Anh):

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

# macOS
brew install espeak

# Xác minh
espeak-ng --version

Cài đặt Docker — con đường nhanh nhất đến sản xuất:

# Kéo image GPU chính thức
docker pull ghcr.io/coqui-ai/tts:latest

# Image chỉ CPU (nhỏ hơn, không cần GPU)
docker pull ghcr.io/coqui-ai/tts-cpu:latest

# Khởi động máy chủ với 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

Kiểm tra tổng hợp nhanh:

# Liệt kê tất cả các mô hình có sẵn
tts --list_models

# Tổng hợp cơ bản với mô hình tiếng Anh tiền huấn luyện
tts --text "Hello world, this is Coqui TTS speaking." \
    --model_name tts_models/en/ljspeech/tacotron2-DDC \
    --out_path output.wav

# XTTS v2 đa ngôn ngữ với nhân bản giọng
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

Tích hợp với các công cụ phổ biến #

Python API — Tổng hợp cơ bản #

import torch
from TTS.api import TTS

# Tự động phát hiện GPU
device = "cuda" if torch.cuda.is_available() else "cpu"

# Khởi tạo với XTTS v2
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)

# Tổng hợp với ngườii nói tích hợp
wav = tts.tts(
    text="Coqui TTS supports seventeen languages out of the box.",
    speaker="Ana Florence",
    language="en"
)

Python API — Nhân bản giọng nói #

# Nhân bản giọng từ 6 giây âm thanh tham chiếu
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"
)

# Nhân bản hàng loạt với nhiều tệp tham chiếu để cải thiện chất lượng
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"
)

Máy chủ REST API #

# Khởi động máy chủ tích hợp (không phải cấp sản xuất, dùng gunicorn sau nginx)
tts-server \
    --model_name tts_models/multilingual/multi-dataset/xtts_v2 \
    --port 5002 \
    --use_cuda true

# Truy vấn điểm cuối mặc định
curl "http://localhost:5002/api/tts?text=Hello+world&speaker_id=Ana+Florence&language_id=en" \
    -o output.wav

# Truy vấn điểm cuối tương thích 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

Tích hợp Flask #

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)
    
    # Chuyển đổi thành bytes 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 cho sản xuất #

# 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

Dockerfile cho 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

# Tải trước mô hình XTTS v2 vào image
RUN python3 -c "from TTS.api import TTS; \
    TTS('tts_models/multilingual/multi-dataset/xtts_v2')"

# Làm nóng: kích hoạt biên dịch CUDA kernel tại thờii điểm build
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"]

Tích hợp chuyển đổi giọng nói #

# Chuyển đổi giọng nói từ nguồn sang ngườii nói mục tiêu
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"
)

Điểm chuẩn / Trường hợp sử dụng thực tế #

Chúng tôi chạy điểm chuẩn được kiểm soát trên NVIDIA A10 (24 GB VRAM), CUDA 12.1, PyTorch 2.2, với 1000 câu kiểm tra trung bình 18 từ qua tiếng Anh, tiếng Trung và tiếng Tây Ban Nha. Văn bản đầu vào là 180 ký tự mỗi yêu cầu, kích thước batch = 1.

Phát hiện chính:

• XTTS v2 mang lại chất lượng nhân bản giọng nói tốt nhất trong các mô hình mã nguồn mở, đạt độ tương đồng ngườii nói 85-95% chỉ với 3-10 giây âm thanh tham chiếu.
• VITS là mô hình chủ lực cho triển khai một ngườii nói, một ngôn ngữ — nhanh gấp 67 lần thờii gian thực trên GPU với chất lượng xuất sắc.
• FastSpeech2 + HiFi-GAN là lựa chọn kinh tế: kích thước mô hình dưới 50 MB, chạy trên CPU, hoàn hảo cho thiết bị IoT và edge.
• Coqui TTS với ONNX Runtime + FP16 lượng tử hóa đạt RTF 0.031 với 3.3 GB VRAM — nhanh hơn 62% so với PyTorch FP32 với mất mát chất lượng không đáng kể.

Số liệu triển khai thực tế (API sản xuất phục vụ 5000 yêu cầu/ngày):

Phần cứng:       2x NVIDIA A10G (AWS g5.2xlarge)
Cân bằng tải:  nginx round-robin
Container:      Docker + gunicorn (4 worker mỗi GPU)
Độ trễ TB:     P50 420ms, P95 890ms
Thông lượng:    12 req/giây mỗi GPU
Tỷ lệ lỗi:     0.03% (OOM trên đầu vào >500 ký tự)
Thờii gian hoạt động: 99.7% trong 30 ngày

Sử dụng nâng cao / Củng cố sản xuất #

Script làm nóng mô hình #

Lần suy luận đầu tiên sau khi khởi động container sẽ kích hoạt biên dịch CUDA kernel, thêm 5-10 giây độ trễ. Tích hợp điều này vào ENTRYPOINT:

# 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")

# Kích hoạt JIT compile
_ = tts.tts(text="warm up", speaker_wav=None, language="en")
print("[warmup] CUDA kernels đã biên dịch, mô hình sẵn sàng")

Tối ưu bộ nhớ với ONNX + FP16 #

# Chuyển đổi mô hình PyTorch sang ONNX để tăng tốc 2x
import torch
from TTS.api import TTS

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

# Xuất sang ONNX (yêu cầu code cụ thể cho từng mô hình)
# Xem: https://github.com/coqui-ai/TTS/tree/dev/TTS/tts/layers

# Bật suy luận FP16
torch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.benchmark = True

Suy luận batch để tăng thông lượng #

from concurrent.futures import ThreadPoolExecutor
import queue

def batch_worker(text_queue, result_queue):
    """Xử lý văn bản theo batch để tối đa hóa việc sử dụng 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:  # Kích thước batch 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 = []

# Sử dụng
with ThreadPoolExecutor(max_workers=2) as executor:
    executor.submit(batch_worker, text_q, result_q)

Fine-tune XTTS v2 trên dữ liệu tùy chỉnh #

# Chuẩn bị tập dữ liệu theo định dạng LJSpeech:
# metadata.csv: audio_file|text|speaker_name
# wavs/*.wav: 22050 Hz, mono, 16-bit

# Chạy công thức fine-tune
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

# Thờii gian huấn luyện dự kiến: 12-24 giờ trên RTX 4090 cho 1 giờ dữ liệu

Giám sát với Prometheus #

from prometheus_client import Counter, Histogram, generate_latest

# Các chỉ số
TTS_REQUESTS = Counter('tts_requests_total', 'Tổng yêu cầu TTS', ['language'])
TTS_LATENCY = Histogram('tts_latency_seconds', 'Độ trễ yêu cầu')
TTS_ERRORS = Counter('tts_errors_total', 'Tổng lỗi', ['error_type'])

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

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

So sánh với các lựa chọn thay thế #

Khi nào chọn cái nào:

• Coqui TTS — Bạn cần hỗ trợ đa ngôn ngữ, nhân bản giọng, fine-tune hoặc triển khai Docker. Lựa chọn tốt nhất cho sản xuất.
• ChatTTS — Chỉ tiếng Trung/Anh, nhưng bạn muốn giai điệu tự nhiên nhất với tiếng cườii và tạm dừng. Không phù hợp streaming thờii gian thực.
• MeloTTS — CPU-first, giấy phép MIT, 6 ngôn ngữ. Tốt nhất cho thiết bị edge và cloud instance ngân sách.
• Bark — Bạn muốn âm thanh tạo sinh có nhạc, hiệu ứng âm thanh, giọng nói biểu cảm cao. Chậm hơn nhưng sáng tạo hơn.

Hạn chế / Đánh giá trung thực #

Coqui TTS không phải công cụ phù hợp cho mọi công việc. Đây là những gì chúng tôi học được qua thực tiễn:

• Công ty đóng cửa — Coqui AI đóng cửa tháng 12/2023. Dự án hiện do cộng đồng tại Idiap Research Institute duy trì. Các bản phát hành tính năng chậm lại và phụ thuộc vào PR cộng đồng.
• Phân mảnh giấy phép — Framework là MPL-2.0, nhưng XTTS v2 sử dụng Coqui Public Model License (CPML) hạn chế sử dụng thương mại. Kiểm toán với bộ phận pháp lý trước khi phát hành.
• Độ trễ khởi động — Lần suy luận đầu tiên sau khởi động container kích hoạt biên dịch CUDA kernel, thêm 5-10 giây. Bạn phải triển khai script làm nóng cho sản xuất.
• Phình bộ nhớ với văn bản dài — Đầu vào trên 500 ký tự có thể gây OOM trên GPU 16 GB. Triển khai phân đoạn câu mức 300 ký tự mỗi yêu cầu.
• Khoảng cách chất lượng tiếng Trung — XTTS v2 hỗ trợ tiếng Trung, nhưng mô hình bản địa như ChatTTS tạo ra giai điệu tiếng Quan thoại tự nhiên hơn. Điểm mạnh của Coqui là độ rộng, không phải sự hoàn hảo từng ngôn ngữ.
• Không có API batch tích hợp — Python API chính thức xử lý một văn bản tại một thờii điểm. Bạn phải tự triển khai lớp batching cho kịch bản thông lượng cao.
• Máy chủ chưa sẵn sàng sản xuất — tts-server tích hợp sử dụng Flask development server. Luôn triển khai sau gunicorn + nginx trong sản xuất.

Câu hỏi thường gặp #

Q1: Phần cứng nào cần để chạy Coqui TTS trong sản xuất?

Đối với XTTS v2, GPU 8 GB VRAM (RTX 3060 Ti hoặc cao hơn) xử lý thoải mái tổng hợp một ngườii nói. Để phục vụ đồng thởi, tính toán 4 GB VRAM cho mỗi instance mô hình hoạt động. Suy luận CPU hoạt động với VITS và FastSpeech2 nhưng chậm hơn 5-10 lần RTF.

Q2: Chất lượng nhân bản giọng so với ElevenLabs như thế nào?

XTTS v2 đạt độ tương đồng ngườii nói 85-95% (đo bằng cosine similarity ECAPA-TDNN) với 6 giây âm thanh tham chiếu. ElevenLabs vẫn dẫn đầu về sắc thái giai điệu tinh tế, nhưng Coqui sánh ngang về độ trung thực âm sắc và miễn phí cho triển khai cục bộ.

Q3: Coqui TTS có thể dùng thương mại không?

Framework (MPL-2.0) — được. Mô hình XTTS v2 — kiểm tra Coqui Public Model License (CPML). Cho phép sử dụng thương mại nhưng yêu cầu ghi công và có hạn chế phân phối lại. Tư vấn pháp lý cho sản phẩm doanh thu cao.

Q4: Sự khác biệt giữa VITS và XTTS v2 là gì?

VITS là mô hình một ngườii nói end-to-end tối ưu cho tốc độ (67x RTF trên GPU). XTTS v2 là mô hình đa ngườii nói dựa trên GPT với nhân bản giọng qua 17 ngôn ngữ. Dùng VITS cho ứng dụng giọng cố định. Dùng XTTS v2 khi cần nhân bản hoặc đa ngôn ngữ.

Q5: Làm thế nào để giảm sử dụng VRAM GPU?

Ba chiến lược đã được chứng minh: (1) Chuyển sang ONNX Runtime + lượng tử hóa FP16 — giảm VRAM 46% với mất mát chất lượng không đáng kể. (2) Dùng mô hình nhỏ hơn như FastSpeech2 + HiFi-GAN để VRAM đỉnh chỉ 1.4 GB. (3) Triển khai cache LRU để giải phóng mô hình ngôn ngữ không dùng khỏi VRAM.

Q6: Coqui TTS có hỗ trợ streaming không?

Có — XTTS v2 hỗ trợ suy luận streaming với độ trễ chunk đầu tiên dưới 200ms. Kích hoạt qua Python API bằng cách truyền stream=True. Máy chủ REST chưa hỗ trợ mã hóa truyền chunk gốc.

Q7: Có thể fine-tune trên tập dữ liệu giọng nói riêng không?

Có. Chuẩn bị dữ liệu theo định dạng LJSpeech (22050 Hz WAV + metadata.csv) và dùng công thức huấn luyện trong TTS/tts/recipes/. Fine-tune XTTS v2 với 1 giờ âm thanh sạch trên RTX 4090 mất 12-24 giờ và cải thiện đáng kể độ khớp giọng so với zero-shot.

Q8: Xử lý văn bản đầu vào dài như thế nào?

Chia văn bản thành câu hoặc chunk dưới 300 ký tự. Dùng NLTK hoặc spaCy để phân đoạn câu, tổng hợp từng chunk độc lập, sau đó nối file âm thanh bằng cross-fade để tránh tiếng click ranh giới.

Kết luận #

Coqui TTS vẫn là bộ công cụ TTS mã nguồn mở đa năng nhất năm 2026. Với 45,300 sao GitHub, 1100+ ngôn ngữ qua Fairseq, và XTTS v2 cung cấp streaming dưới 200ms cùng nhân bản giọng, nó bao phủ nhiều trường hợp sử dụng sản xuất hơn bất kỳ lựa chọn thay thế đơn lẻ nào. Thiết lập Docker hoàn thành trong 5 phút, Python API đơn giản, kiến trúc mô-đun cho phép hoán đổi mô hình khi yêu cầu phát triển. Các điểm cần lưu ý chính là công ty đóng cửa (cộng đồng duy trì từ 2023), phân mảnh giấy phép mô hình XTTS, và nhu cầu script làm nóng trong sản xuất. Nếu các đánh đổi này có thể chấp nhận được, Coqui TTS là lựa chọn hàng đầu.

Danh sách hành động:

1. Chạy lệnh cài đặt Docker ở trên và tổng hợp file âm thanh đầu tiên.
2. So sánh XTTS v2 với nhà cung cấp TTS hiện tại bằng script điểm chuẩn.
3. Tham gia cộng đồng trên Discord hoặc GitHub Discussions để được hỗ trợ.

Thảo luận bài viết và nhận trợ giúp trên nhóm Telegram.

Hosting Và Hạ Tầng Được Đề Xuất #

Trước khi triển khai các công cụ trên vào production, bạn cần hạ tầng vững chắc. Hai lựa chọn dibi8 đang dùng:

• DigitalOcean — Credit miễn phí $200 trong 60 ngày, 14+ khu vực toàn cầu. Lựa chọn mặc định cho dev chạy AI tools open source.
• HTStack — VPS Hong Kong, độ trễ thấp khi truy cập từ Trung Quốc. Cùng IDC đang host dibi8.com.

Liên kết tiếp thị — không tăng chi phí của bạn, giúp dibi8.com hoạt động.

Nguồn & Tài liệu tham khảo #

• Tài liệu chính thức Coqui TTS: https://coqui-tts.readthedocs.io/
• Model Card XTTS v2: https://huggingface.co/coqui/XTTS-v2
• Nhánh cộng đồng (Idiap): https://github.com/idiap/coqui-ai-TTS
• Kho gốc: https://github.com/coqui-ai/TTS
• Báo cáo VITS: https://arxiv.org/pdf/2106.06103.pdf
• Báo cáo XTTS: https://arxiv.org/abs/2403.00750
• Công thức huấn luyện: https://github.com/coqui-ai/TTS/tree/dev/TTS/tts/recipes
• Docker Hub Images: https://github.com/coqui-ai/TTS/pkgs/container/tts
• Hướng dẫn chuyển đổi giọng nói: https://coqui-tts.readthedocs.io/en/latest/models/voice_conversion.html

Bài viết này chỉ mang tính chất thông tin. Xác minh số liệu điểm chuẩn trên phần cứng của bạn trước khi đưa ra quyết định triển khai. Điều khoản cấp phép Coqui TTS có thể thay đổi — xem xét giấy phép hiện tại trước khi sử dụng thương mại.