GPT-SoVITS：57.5K+ 星标

# Step 1: Create and activate environment
conda create -n GPTSoVits python=3.10 -y
conda activate GPTSoVits

# Step 2: Install FFmpeg
conda install ffmpeg -y

# Step 3: Clone repository
git clone https://github.com/RVC-Boss/GPT-SoVITS.git
cd GPT-SoVITS

# Step 4: Install dependencies
pip install -r extra-req.txt --no-deps
pip install -r requirements.txt

# Download the integrated package from HuggingFace
# Extract and run:
conda create -n GPTSoVits python=3.10
conda activate GPTSoVits
pwsh -F install.ps1 -Device CU126 -Source HF

# Clone and enter project directory
git clone https://github.com/RVC-Boss/GPT-SoVITS.git
cd GPT-SoVITS

# Pull latest code before building
git pull origin main

# Build Docker image (CUDA 12.8, full version)
bash docker_build.sh --cuda 12.8

# Or use pre-built images from Docker Hub
docker compose run --service-ports GPT-SoVITS-CU128

# docker-compose.override.yaml for 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]

# Download pretrained models (run once)
mkdir -p GPT_SoVITS/pretrained_models

# Download from HuggingFace (auto-download via install.sh)
# Or manually for v4:
# s2v4.pth, vocoder.pth → GPT_SoVITS/pretrained_models/gsv-v4-pretrained/

# Download G2PW model for Chinese TTS
# Unzip G2PWModel.zip and place in: GPT_SoVITS/text/G2PWModel/

# Download UVR5 weights for voice separation
# Place in: tools/uvr5/uvr5_weights/

# Standard launch (defaults to port 9874)
python webui.py

# Specify language explicitly
python webui.py en

# Launch inference-only API server
python api_v2.py

# Install ComfyUI-GPT-SoVITS nodes
cd ComfyUI/custom_nodes
git clone https://github.com/yaolidi/ComfyUI-GPT-SoVITS.git

# Install dependencies
pip install -r ComfyUI-GPT-SoVITS/requirements.txt

# Place your trained .pth and .ckpt models in:
# ComfyUI/models/GPT-SoVITS/

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

# Step 1: Generate speech with GPT-SoVITS API
tts_payload = {
    "text": "Hello, this is a cloned voice speaking.",
    "text_lang": "en",
    "ref_audio_path": "/path/to/reference.wav",
    "prompt_text": "Reference transcript text",
    "prompt_lang": "en",
    "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)

# Step 2: Convert through RVC (optional 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)

from melo.api import TTS
import requests

# Step 1: Preprocess text with MeloTTS for phonemes
tts_model = TTS(language="EN", device="auto")
phonemes = tts_model.text_to_phone("Hello world")

# Step 2: Feed processed text to GPT-SoVITS
response = requests.post("http://localhost:9880/tts", json={
    "text": phonemes,
    "text_lang": "en",
    "ref_audio_path": "/path/to/ref.wav",
    "prompt_text": "Original prompt",
    "prompt_lang": "en"
})

# Start the API server
python api_v2.py -a 0.0.0.0 -p 9880

# Check API documentation at http://localhost:9880/docs

# Python client example
import requests

def synthesize(text, ref_audio, prompt_text, output_path):
    payload = {
        "text": text,
        "text_lang": "en",
        "ref_audio_path": ref_audio,
        "prompt_text": prompt_text,
        "prompt_lang": "en",
        "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

# Usage
synthesize(
    "Deploying voice cloning at production scale is now trivial.",
    "/voices/speaker_ref.wav",
    "This is the reference transcription.",
    "/output/cloned.wav"
)

# Use the community OpenAI-compatible wrapper
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

# Set BACKEND_URL to your GPT-SoVITS API
# BACKEND_URL=http://host.docker.internal:9880

docker compose up -d
# Now serves at http://localhost:5000/v1/audio/speech

# Enable half-precision (fp16) for 50% VRAM reduction
export is_half=true

# For 6GB VRAM cards, use CPU offloading for text encoder
python webui.py --device cuda --half_precision --offload_text_encoder

# Use CPU inference version for low-VRAM setups
git clone https://github.com/baicai-1145/GPT-SoVITS-CPUFast.git

# Export to ONNX for faster inference
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/

# TensorRT optimization for NVIDIA deployment
/usr/src/tensorrt/bin/trtexec \
    --onnx=./onnx_models/gpt_model.onnx \
    --saveEngine=./trt_models/gpt_model.trt \
    --fp16

# api_v2.py production wrapper with rate limiting
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/min
        raise HTTPException(429, "Rate limit exceeded")
    
    rate_limits[client].append(now)
    return await call_next(request)

# Add CORS for web clients
app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://yourdomain.com"],
    allow_methods=["POST"],
    allow_headers=["*"],
)

#!/bin/bash
# batch_synthesize.sh — process text files in bulk

INPUT_DIR="./texts/"
REF_AUDIO="./references/narrator.wav"
REF_TEXT="The quick brown fox jumps over the lazy dog."
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\": \"en\",
            \"ref_audio_path\": \"$REF_AUDIO\",
            \"prompt_text\": \"$REF_TEXT\",
            \"prompt_lang\": \"en\",
            \"media_type\": \"wav\"
        }" \
        --output "$OUTPUT_DIR/${filename}.wav"
    
    echo "Generated: $OUTPUT_DIR/${filename}.wav"
done

# nginx reverse proxy configuration
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;
    }
}