GPT-SoVITS: 57.5K+ Stars — Hướng Dẫn Triển Khai AI Voice Cloning 2026

{{< resource-info >}}

Nhân bản bất kỳ giọng nói nào với 5 giây audio. Tinh chỉnh với 1 phút dữ liệu. Triển khai production trong vòng 20 phút. Hướng dẫn này đi qua toàn bộ quy trình cấu hình.

Giới thiệu #

Xây dựng pipeline nhân bản giọng nói từng đòi hỏi phòng thu, nhiều tuần thu thập dữ liệu và ngân sách 6 chữ số. Năm 2026, một repository open-source với 57,500+ sao GitHub đã thay đổi phương trình đó. GPT-SoVITS cho phép nhà phát triển nhân bản giọng nói từ mẫu 5 giây và tinh chỉnh mô hình TTS production-chất lượng chỉ với 1 phút dữ liệu huấn luyện. Dù bạn xây dựng công cụ sách nói, lồng tiếng nhân vật game, hay voice agent thờigian thực, hướng dẫn này bao quát toàn bộ lộ trình triển khai production — từ cài đặt đầu tiên đến dịch vụ API được harden. Nếu bạn đang tìm hướng dẫn gpt-sovits hay thiết lập voice cloning có thể mở rộng, đây là tài liệu tham khảo dành cho bạn. Chúng tôi cũng đề cập chi tiết đến ai voice synthesis và gpt-sovits tutorial, voice cloning setup, đồng thờii cung cấp bảng so sánh gpt-sovits vs coqui chi tiết bên dưới.

GPT-SoVITS là gì? #

GPT-SoVITS là framework chuyển đổi giọng nói few-shot và text-to-speech (TTS) kết hợp bộ dự đoán semantic token dựa trên GPT với neural vocoder SoVITS (Speech Synthesis via VITS). Được phát hành theo giấy phép MIT bởi maintainer RVC-Boss, đã thu hút 96+ contributor và hỗ trợ inference zero-shot (5 giây tham chiếu), fine-tuning few-shot (1 phút), và tổng hợp đa ngôn ngữ qua tiếng Anh, Nhật, Hàn, Quảng Đông, và Trung. Bản phát hành V4 mới nhất sửa lỗi hiện tượng âm kim loại và xuất audio 48kHz gốc.

GPT-SoVITS hoạt động như thế nào #

Tổng quan kiến trúc #

GPT-SoVITS sử dụng pipeline 2 giai đoạn tách biệt hiểu ngôn ngữ và tạo sóng âm thanh:

Input văn bản → BERT Text Encoder → Mô hình GPT (330M tham số) → Semantic Token
                                                              ↓
Audio tham chiếu → HuBERT Encoder → Mô hình SoVITS (77M tham số) → Vocoder → 48kHz Audio

Giai đoạn 1 — GPT (Text-to-Semantic): Mô hình GPT 330M tham số chuyển đổi chuỗi âm vị thành token semantic rờii rạc. BERT embeddings cung cấp ngữ cảnh ngôn ngữ để dự đoán phát âm và ngữ điệu chính xác.

Giai đoạn 2 — SoVITS (Semantic-to-Voice): Module SoVITS 77M tham số biến đổi token semantic thành sóng âm thanh. Sử dụng generator dựa trên GAN với flow network cho ánh xạ tiềm ẩn hai chiều, được điều kiện hóa bởi audio tham chiếu embedding trích xuất qua HuBERT.

Các thành phần cốt lõi #

Tiến hóa phiên bản #

Luồng dữ liệu Pipeline #

Pipeline huấn luyện và inference đầy đủ tuân theo luồng sau:

Audio thô → UVR5 Tách → Audio Slicer → ASR Transcription → Text Labeling
                                                                                ↓
Pretrained GPT + SoVITS ← Fine-tuning (1 phút dữ liệu) ← Formatted Dataset
                                                                                ↓
Inference: Audio tham chiếu + Văn bản → GPT (Semantic Tokens) → SoVITS → 48kHz Audio

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

Yêu cầu phần cứng #

Phương án A: Cài đặt Conda (Linux / macOS) #

# Bước 1: Tạo và kích hoạt môi trường
conda create -n GPTSoVits python=3.10 -y
conda activate GPTSoVits

# Bước 2: Cài đặt FFmpeg
conda install ffmpeg -y

# Bước 3: Clone repository
git clone https://github.com/RVC-Boss/GPT-SoVITS.git
cd GPT-SoVITS

# Bước 4: Cài đặt dependency
pip install -r extra-req.txt --no-deps
pip install -r requirements.txt

Phương án B: Gói tích hợp Windows #

# Tải gói tích hợp từ HuggingFace
# Giải nén và chạy:
conda create -n GPTSoVits python=3.10
conda activate GPTSoVits
pwsh -F install.ps1 -Device CU126 -Source HF

Phương án C: Triển khai Docker (Đề xuất cho Production) #

# Clone và vào thư mục dự án
git clone https://github.com/RVC-Boss/GPT-SoVITS.git
cd GPT-SoVITS

# Pull code mới nhất trước khi build
git pull origin main

# Build image Docker (CUDA 12.8, bản đầy đủ)
bash docker_build.sh --cuda 12.8

# Hoặc dùng image pre-built từ Docker Hub
docker compose run --service-ports GPT-SoVITS-CU128

Cấu hình Docker Compose #

# docker-compose.override.yaml cho production
services:
  GPT-SoVITS-CU128:
    shm_size: '16g'
    environment:
      - is_half=true
    ports:
      - "9874:9874"
      - "9880:9880"
    volumes:
      - ./models:/workspace/models
      - ./outputs:/workspace/outputs
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

Thiết lập mô hình pre-trained #

# Tải mô hình pre-trained (chạy một lần)
mkdir -p GPT_SoVITS/pretrained_models

# Tải tự động qua install.sh từ HuggingFace
# Hoặc thủ công cho V4:
# s2v4.pth, vocoder.pth → GPT_SoVITS/pretrained_models/gsv-v4-pretrained/

# Tải mô hình G2PW cho TTS tiếng Trung
# Giải nén G2PWModel.zip vào: GPT_SoVITS/text/G2PWModel/

# Tải weights UVR5 để tách giọng
# Đặt vào: tools/uvr5/uvr5_weights/

Khởi chạy WebUI #

# Khởi chạy chuẩn (mặc định cổng 9874)
python webui.py

# Chỉ định ngôn ngữ
python webui.py vi

# Khởi chạy chỉ API server
python api_v2.py

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

Tích hợp với ComfyUI #

Nodes ComfyUI cho GPT-SoVITS cho phép tạo giọng nói trong workflow hình ảnh:

# Cài đặt nodes ComfyUI-GPT-SoVITS
cd ComfyUI/custom_nodes
git clone https://github.com/yaolidi/ComfyUI-GPT-SoVITS.git

# Cài đặt dependency
pip install -r ComfyUI-GPT-SoVITS/requirements.txt

# Đặt mô hình .pth và .ckpt đã train vào:
# ComfyUI/models/GPT-SoVITS/

Tích hợp với RVC (Retrieval-based Voice Conversion) #

RVC và GPT-SoVITS chia sẻ cùng hệ sinh thái. Dùng RVC cho chuyển đổi giọng thờigian thực, GPT-SoVITS cho TTS chất lượng cao:

# Pipeline: GPT-SoVITS TTS → RVC Voice Conversion
import requests
import subprocess

# Bước 1: Tạo giọng với API GPT-SoVITS
tts_payload = {
    "text": "Xin chào, đây là giọng nói đã nhân bản.",
    "text_lang": "vi",
    "ref_audio_path": "/path/to/reference.wav",
    "prompt_text": "Bản ghi tham chiếu",
    "prompt_lang": "vi",
    "media_type": "wav"
}

response = requests.post("http://localhost:9880/tts", json=tts_payload)
with open("tts_output.wav", "wb") as f:
    f.write(response.content)

# Bước 2: Chuyển đổi qua RVC (tùy chọn real-time VC)
rvc_cmd = [
    "python", "RVC/infer_cli.py",
    "--input", "tts_output.wav",
    "--model", "models/rvc_model.pth",
    "--output", "final_output.wav"
]
subprocess.run(rvc_cmd)

Tích hợp với MeloTTS #

MeloTTS xử lý tiền xử lý văn bản đa ngôn ngữ trước khi tổng hợp GPT-SoVITS:

from melo.api import TTS
import requests

# Bước 1: Tiền xử lý văn bản với MeloTTS để lấy âm vị
tts_model = TTS(language="EN", device="auto")
phonemes = tts_model.text_to_phone("Hello world")

# Bước 2: Đưa văn bản đã xử lý vào GPT-SoVITS
response = requests.post("http://localhost:9880/tts", json={
    "text": phonemes,
    "text_lang": "en",
    "ref_audio_path": "/path/to/ref.wav",
    "prompt_text": "Prompt gốc",
    "prompt_lang": "en"
})

Tích hợp REST API #

api_v2.py tích hợp cung cấp đầy đủ REST API cho production:

# Khởi động API server
python api_v2.py -a 0.0.0.0 -p 9880

# Xem tài liệu API tại http://localhost:9880/docs

# Ví dụ client Python
import requests

def synthesize(text, ref_audio, prompt_text, output_path):
    payload = {
        "text": text,
        "text_lang": "vi",
        "ref_audio_path": ref_audio,
        "prompt_text": prompt_text,
        "prompt_lang": "vi",
        "top_k": 15,
        "top_p": 1.0,
        "temperature": 1.0,
        "speed_factor": 1.0,
        "media_type": "wav"
    }
    
    response = requests.post(
        "http://localhost:9880/tts",
        json=payload,
        timeout=60
    )
    
    if response.status_code == 200:
        with open(output_path, "wb") as f:
            f.write(response.content)
        return True
    return False

# Sử dụng
synthesize(
    "Triển khai voice cloning production đơn giản hơn bao giờ hết.",
    "/voices/speaker_ref.wav",
    "Đây là bản ghi tham chiếu.",
    "/output/cloned.wav"
)

OpenAI-Compatible API Wrapper #

# Sử dụng wrapper tương thích OpenAI của cộng đồng
git clone https://github.com/enihsyou/GPT-SoVITS-2-OpenAI.git
cd GPT-SoVITS-2-OpenAI
cp .env.example .env
cp config.yaml.example config.yaml

# Đặt BACKEND_URL đến API GPT-SoVITS của bạn
# BACKEND_URL=http://host.docker.internal:9880

docker compose up -d
# Giờ phục vụ tại http://localhost:5000/v1/audio/speech

Benchmark / Use cases thực tế #

Benchmark tốc độ inference #

RTF < 1 có nghĩa là tạo nhanh hơn thờigian thực. GPT-SoVITS V2 ProPlus trên RTX 4090 tạo 4 phút giọng trong 3.36 giây — nhanh hơn 70 lần so với thờigian thực.

Benchmark chất lượng giọng #

Use case production #

1. Nền tảng sách nói: Clone giọng ngườii đọc từ mẫu 1 phút. Tạo 10 giờ sách nói trong 30 phút trên một GPU.

2. Phát triển game: Bản địa hóa giọng nhân vật sang 5 ngôn ngữ với cùng audio tham chiếu. Hỗ trợ đa ngôn ngữ bảo toàn danh tính ngườii nói.

3. Voice agent: Triển khai phản hồi giọng nói thờigian thực cho bot chăm sóc khách hàng. RTF 0.014 trên GPU consumer có nghĩa là độ trễ dưới 1 giây cho phản hồi ngắn.

4. Công cụ hỗ trợ tiếp cận: Tạo giọng trình đọc màn hình cá nhân hóa. Giấy phép MIT cho phép triển khai thương mại không hạn chế.

5. Sáng tạo nội dung: Sản xuất hàng loạt voiceover cho nội dung video. Tích hợp API cho phép tự động hóa pipeline với xử lý sau ffmpeg.

Benchmark thờigian huấn luyện #

Sử dụng nâng cao / Production hardening #

Tối ưu hóa bộ nhớ GPU #

# Bật half-precision (fp16) giảm 50% VRAM
export is_half=true

# Dùng CPU offloading cho text encoder với card 6GB VRAM
python webui.py --device cuda --half_precision --offload_text_encoder

# Dùng phiên bản CPU inference cho thiết lập VRAM thấp
git clone https://github.com/baicai-1145/GPT-SoVITS-CPUFast.git

Quantization mô hình cho edge deployment #

# Export sang ONNX để inference nhanh hơn
python GPT_SoVITS/onnx_export.py \
    --gpt_model GPT_SoVITS/GPT_weights/your_model.ckpt \
    --sovits_model GPT_SoVITS/SoVITS_weights/your_model.pth \
    --output_dir ./onnx_models/

# Tối ưu TensorRT cho triển khai NVIDIA
/usr/src/tensorrt/bin/trtexec \
    --onnx=./onnx_models/gpt_model.onnx \
    --saveEngine=./trt_models/gpt_model.trt \
    --fp16

Giới hạn tốc độ API và giám sát #

# Wrapper production cho api_v2.py với giới hạn tốc độ
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
import asyncio
from collections import defaultdict
import time

app = FastAPI()
rate_limits = defaultdict(list)

@app.middleware("http")
async def rate_limit(request, call_next):
    client = request.client.host
    now = time.time()
    rate_limits[client] = [t for t in rate_limits[client] if now - t < 60]
    
    if len(rate_limits[client]) >= 10:  # 10 req/phút
        raise HTTPException(429, "Vượt quá giới hạn tốc độ")
    
    rate_limits[client].append(now)
    return await call_next(request)

# Thêm CORS cho web client
app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://yourdomain.com"],
    allow_methods=["POST"],
    allow_headers=["*"],
)

Pipeline xử lý hàng loạt #

#!/bin/bash
# batch_synthesize.sh — xử lý file văn bản hàng loạt

INPUT_DIR="./texts/"
REF_AUDIO="./references/narrator.wav"
REF_TEXT="Con cáo nâu nhanh nhảy qua con chó lườii."
OUTPUT_DIR="./outputs/"
mkdir -p "$OUTPUT_DIR"

for txt_file in "$INPUT_DIR"/*.txt; do
    filename=$(basename "$txt_file" .txt)
    
    curl -X POST http://localhost:9880/tts \
        -H "Content-Type: application/json" \
        -d "{
            \"text\": $(jq -Rs . < "$txt_file"),
            \"text_lang\": \"vi\",
            \"ref_audio_path\": \"$REF_AUDIO\",
            \"prompt_text\": \"$REF_TEXT\",
            \"prompt_lang\": \"vi\",
            \"media_type\": \"wav\"
        }" \
        --output "$OUTPUT_DIR/${filename}.wav"
    
    echo "Đã tạo: $OUTPUT_DIR/${filename}.wav"
done

Checklist bảo mật cho production #

1. Xác thực API: API tích hợp không có auth. Đặt sau nginx reverse proxy với xác thực API key.
2. Kiểm tra đầu vào: Xác thực ref_audio_path để ngăn tấn công path traversal.
3. Giới hạn tài nguyên: Đặt ulimit và giới hạn bộ nhớ Docker để ngăn crash OOM.
4. Kiểm soát truy cập mô hình: Lưu mô hình đã train trong volume riêng với quyền hạn chế.
5. Kết thúc HTTPS: Dùng reverse proxy cho TLS — không bao giờ expose trực tiếp API server ra internet.

# Cấu hình nginx reverse proxy
server {
    listen 443 ssl;
    server_name tts.yourdomain.com;
    
    ssl_certificate /etc/ssl/certs/tts.crt;
    ssl_certificate_key /etc/ssl/private/tts.key;
    
    location / {
        auth_request /auth;
        proxy_pass http://127.0.0.1:9880;
        proxy_set_header Host $host;
        client_max_body_size 50M;
    }
    
    location = /auth {
        internal;
        proxy_pass http://127.0.0.1:5000/verify;
        proxy_pass_request_body off;
    }
}

So sánh với các giải pháp thay thế #

Hướng dẫn chọn lựa:

• GPT-SoVITS: Gói tốt nhất cho voice cloning với dữ liệu tối thiểu. Giấy phép MIT cho phép dùng thương mại. Bao gồm toolchain WebUI đầy đủ.
• XTTS v2: Tốt cho prototype nhanh, nhưng giấy phép CPML hạn chế triển khai thương mại.
• Bark: Chọn cho audio sáng tạo (nhạc, hiệu ứng âm thanh, cườii). Chậm hơn nhưng phạm vi biểu cảm rộng hơn.
• F5-TTS: Kết quả học thuật mạnh, nhưng giấy phép phi thương mại hạn chế sử dụng production.

Hạn chế / Đánh giá khách quan #

GPT-SoVITS không phù hợp cho:

1. Streaming thờigian thực dưới 100ms: Mô hình cần xử lý audio tham chiếu qua HuBERT và tạo semantic token trước khi vocoding. Streaming dưới 100ms không khả thi trên phần cứng consumer.

2. Tổng hợp hát không có RVC: GPT-SoVITS xử lý giọng nói tốt, nhưng nhân bản giọng hát chất lượng cao cần kết hợp với RVC hoặc dùng mô hình chuyên biệt như DiffSinger.

3. Kiểm soát thờigian chính xác từng từ: Không giống một số API TTS thương mại, GPT-SoVITS không cung cấp SSML hay kiểm soát thờigian cấp âm vị.

4. Inference production không GPU: CPU inference (RTF 0.526 trên M4) dùng được cho prototype nhưng quá chậm cho workload production. Thực tế cần GPU.

5. Phạm vi cảm xúc không có dữ liệu: Mô hình cơ sở bắt được biến thể cảm xúc vừa phải, nhưng diễn xuất cảm xúc mãnh liệt (thì thầm, hét, khóc) cần dữ liệu huấn luyện thể hiện cảm xúc đó.

6. Trường hợp đặc biệt xử lý đường dẫn Windows: Codebase ưu tiên Linux. Ngườii dùng Windows thỉnh thoảng gặp vấn đề encoding với ký tự không ASCII trong đường dẫn file.

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

Q1: Cần bao nhiêu dữ liệu huấn luyện để clone giọng tốt? Inference zero-shot (không huấn luyện) chỉ cần clip tham chiếu 5 giây sạch. Fine-tuning cá nhân hóa với 1 phút giọng nói đa dạng cho kết quả tốt. Nhiều dữ liệu hơn (5-10 phút) cải thiện tính nhất quán khi tạo dài nhưng lợi tức giảm dần.

Q2: Có thể dùng GPT-SoVITS thương mại không? Có. GPT-SoVITS phát hành theo giấy phép MIT, cho phép sử dụng thương mại, sửa đổi và phân phối. Tuy nhiên, một số mô hình pre-trained (ví dụ BigVGAN) có thể có điều khoản riêng. Luôn xác minh weights cụ thể bạn sử dụng.

Q3: GPU tốt nhất để chạy GPT-SoVITS là gì? RTX 4060 Ti (8GB) là điểm ngọt cho hầu hết ngườii dùng — inference RTF 0.028 và hỗ trợ fine-tune fp16. Cho production serving, RTX 4090 (RTF 0.014) hoặc GPU server A100/H100 tối đa hóa throughput. Tránh card dưới 6GB VRAM.

Q4: Làm sao chuyển đổi giữa các phiên bản mô hình (V2, V3, V4)? Chọn qua dropdown WebUI hoặc cấu hình API. Để dùng phiên bản mới, cập nhật codebase bằng git pull, tải pretrained models tương ứng từ HuggingFace và đặt vào GPT_SoVITS/pretrained_models/. File tts_infer.yaml điều khiển chọn phiên bản.

Q5: Tại sao giọng tạo ra nghe có vẻ kim loại hay bị bịt? Đây là vấn đề đã biết trong V3 do upsampling bội số không nguyên. Nâng cấp lên V4, sửa hiện tượng âm kim loại và xuất audio 48kHz gốc. Cũng kiểm tra audio tham chiếu sạch — nhiễu nền và artifact nén lan sang output.

Q6: Làm sao triển khai GPT-SoVITS sau load balancer? Chạy nhiều instance API sau nginx hoặc HAProxy. Mỗi instance bind cổng khác nhau. Dùng shared network volume cho models. Cho auto-scaling, containerize với Kubernetes và dùng GPU node pools.

Q7: Có thể chạy GPT-SoVITS không cần Docker không? Có. Lộ trình cài Conda được hỗ trợ đầy đủ. Đảm bảo FFmpeg đã cài và đáp ứng mọi dependency Python từ requirements.txt. WebUI và API hoạt động như nhau bên ngoài Docker.

Kết luận #

GPT-SoVITS mang lại voice cloning production-chất lượng với yêu cầu dữ liệu tối thiểu, giấy phép MIT và hệ sinh thái triển khai trưởng thành. RTF 0.014 trên GPU consumer làm ứng dụng thờigian thực khả thi, trong khi toolchain WebUI đầy đủ hạ thấp rào cản cho ngườii mới. Cho các team xây dựng sản phẩm âm thanh năm 2026, đây là nền tảng open-source thực tiễn nhất hiện có.

Hành động triển khai ngay hôm nay:

1. Clone https://github.com/RVC-Boss/GPT-SoVITS và chạy thiết lập Docker
2. Tải model pre-trained (bắt đầu với V2 ProPlus cho tốc độ tốt nhất)
3. Ghi lại clip tham chiếu 5 giây và test inference zero-shot qua WebUI
4. Wrap endpoint api_v2.py với lớp xác thực
5. Tham gia nhóm Telegram dibi8.com để hỗ trợ triển khai và thảo luận cộng đồng

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 và Tài liệu tham khảo #

• GPT-SoVITS GitHub Repository
• GPT-SoVITS Docker Hub Images
• GPT-SoVITS HuggingFace Demo
• GPT-SoVITS User Guide (English)
• Coqui XTTS v2 Repository
• Bark (Suno) Repository
• F5-TTS Repository
• Open Source TTS Comparison Guide
• GPT-SoVITS DeepWiki Architecture Guide
• GPT-SoVITS v3 Technical Paper Reference