RVC：部署拥有 3.5 万+ 星标的 AI 语音转换工具

# Clone the repository
git clone https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI.git
cd Retrieval-based-Voice-Conversion-WebUI

# Build the Docker image
docker build -t rvc-webui:latest .

# Run with GPU support and volume mounts
docker run -d --name rvc \
  --gpus all \
  -p 7865:7865 \
  -v $(pwd)/weights:/app/weights \
  -v $(pwd)/opt:/app/opt \
  rvc-webui:latest

version: '3.8'

services:
  rvc:
    build: .
    container_name: rvc-webui
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
    ports:
      - "7865:7865"
    volumes:
      - ./weights:/app/weights
      - ./opt:/app/opt
      - ./assets:/app/assets
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    restart: unless-stopped

# Start with docker-compose
docker-compose up -d

# Check logs
docker-compose logs -f rvc

# Clone repository
git clone https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI.git
cd Retrieval-based-Voice-Conversion-WebUI

# Create virtual environment
python3 -m venv venv
source venv/bin/activate

# Install dependencies
pip install -r requirements.txt

# Download pretrained models
python tools/download_models.py

# Or manually download from HuggingFace
wget https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/D40k.pth -P assets/pretrained_v2/
wget https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/G40k.pth -P assets/pretrained_v2/
wget https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/f0D40k.pth -P assets/pretrained_v2/
wget https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/f0G40k.pth -P assets/pretrained_v2/
wget https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/hubert_base.pt -P assets/hubert/
wget https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/rmvpe.pt -P assets/rmvpe/

# Install ROCm dependencies (Ubuntu/Debian)
sudo apt install rocm-hip-sdk rocm-opencl-sdk

# Set environment variables
export ROCM_PATH=/opt/rocm
export HSA_OVERRIDE_GFX_VERSION=10.3.0

# Add user to render and video groups
sudo usermod -aG render $USER
sudo usermod -aG video $USER

# Install AMD-specific requirements
pip install -r requirements-amd.txt

# Start the Gradio web interface
python infer-web.py

# The WebUI will be available at http://localhost:7865

# Separate vocals from background music
python tools/uvr5/uvr5_cli.py \
  --input_path ./raw_audio/song_with_music.wav \
  --output_path ./dataset/ \
  --model_name "HP2-人声vocals+非人声instrumentals"

# Step 1: Preprocess (resample, slice, remove silence)
python trainset_preprocess_pipeline_print.py \
  ./dataset/my_voice \
  40000 \
  8  # number of CPU threads

# Step 2: Extract features with ContentVec
python extract_feature_print.py \
  --model_name my_voice_v2 \
  --sample_rate 40000 \
  --pitch_extractor rmvpe \
  --gpu 0

# Step 3: Train the model
python train_nsf_sim_cache_sid_load_pretrain.py \
  --model_name my_voice_v2 \
  --sample_rate 40000 \
  --batch_size 8 \
  --total_epoch 200 \
  --save_every_epoch 5 \
  --pretrained_G assets/pretrained_v2/f0G40k.pth \
  --pretrained_D assets/pretrained_v2/f0D40k.pth \
  --gpu 0

# Generate the Faiss index for retrieval
python tools/infer/train_index.py \
  --model_name my_voice_v2 \
  --sample_rate 40000

# gpt_sovits_rvc_pipeline.py
import subprocess
import requests
import os

def tts_then_convert(text: str, speaker_wav: str, rvc_model: str):
    """GPT-SoVITS TTS → RVC voice conversion pipeline"""
    
    # Step 1: Generate speech with GPT-SoVITS
    tts_response = requests.post("http://localhost:9880/tts", json={
        "text": text,
        "refer_wav_path": speaker_wav,
        "prompt_text": "Reference prompt text",
        "prompt_language": "en",
        "text_language": "en"
    })
    
    with open("/tmp/tts_output.wav", "wb") as f:
        f.write(tts_response.content)
    
    # Step 2: Convert voice with RVC API
    rvc_response = requests.post("http://localhost:7865/voice_conversion", json={
        "input_audio": "/tmp/tts_output.wav",
        "model_name": rvc_model,
        "pitch_shift": 0,
        "index_rate": 0.75,
        "filter_radius": 3,
        "volume_envelope": 0.25
    })
    
    return rvc_response.json()["output_path"]

result = tts_then_convert(
    text="Hello, this is a cloned voice speaking.",
    speaker_wav="./reference.wav",
    rvc_model="my_voice_v2"
)
print(f"Converted audio saved to: {result}")

# coqui_rvc_bridge.py
from TTS.api import TTS
import requests

def coqui_to_rvc(text: str, rvc_model: str, output_path: str):
    # Generate with Coqui XTTS v2
    tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2", gpu=True)
    tts.tts_to_file(
        text=text,
        speaker_wav="reference.wav",
        language="en",
        file_path="/tmp/coqui_out.wav"
    )
    
    # Convert through RVC
    with open("/tmp/coqui_out.wav", "rb") as f:
        files = {"file": f}
        data = {
            "model_name": rvc_model,
            "pitch": 0,
            "index_rate": 0.5
        }
        response = requests.post(
            "http://localhost:7865/api/voice_conversion",
            files=files,
            data=data
        )
    
    with open(output_path, "wb") as f:
        f.write(response.content)
    return output_path

# Install demucs
pip install demucs

# Separate vocals with demucs (better quality than UVR5 for complex mixes)
demucs --two-stems=vocals --mp3 --mp3-bitrate 320 input_song.mp3

# Use the separated vocal track for RVC training
mv separated/htdemucs/input_song/vocals.wav ./dataset/clean_voice.wav

# Start the real-time GUI
python gui_v1.py

# Or with DirectML for AMD/Intel GPUs
python gui_v1.py --dml

# Key parameters for low latency:
# - Block time: 0.25s (lower = less latency, more CPU)
# - Crossfade: 0.05s
# - Extra time: 2.5s
# - Pitch extractor: fcpe (fastest) or rmvpe (best quality)

# gui_config.py example
config = {
    "block_time": 0.1,        # 100ms blocks for lower latency
    "crossfade_time": 0.04,
    "extra_time": 2.0,
    "f0method": "fcpe",       # Fastest pitch extractor
    "rms_mix_rate": 0.25,
    "index_rate": 0.3,
    "pitch": 0,
    "I_noise_reduce": True,
    "O_noise_reduce": False
}

# Start the API server
python api_240604.py

# The API will be available at http://localhost:7865

# Client example for API inference
import requests

# Load model first
requests.post("http://localhost:7865/load_model", json={
    "pth_path": "./weights/my_voice_v2.pth",
    "index_path": "./logs/my_voice_v2/added_IVF512_Flat_nprobe_1.index"
})

# Perform voice conversion
with open("input_audio.wav", "rb") as f:
    response = requests.post(
        "http://localhost:7865/voice_conversion",
        files={"file": f},
        data={
            "pitch": 0,
            "index_rate": 0.75,
            "filter_radius": 3,
            "volume_envelope": 0.25,
            "protect": 0.33
        }
    )

with open("converted_output.wav", "wb") as f:
    f.write(response.content)

# api_production.py — Hardened API wrapper
from fastapi import FastAPI, HTTPException, Depends
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
import hashlib

security = HTTPBearer()

def verify_token(credentials: HTTPAuthorizationCredentials):
    """Verify API token for production deployments"""
    expected = hashlib.sha256(TOKEN.encode()).hexdigest()
    if credentials.credentials != expected:
        raise HTTPException(status_code=401, detail="Invalid token")
    return True

@app.post("/voice_conversion")
async def secure_convert(
    file: UploadFile,
    credentials: HTTPAuthorizationCredentials = Depends(security)
):
    verify_token(credentials)
    # ... conversion logic
    return {"output_url": signed_url}

# Organize multiple voice models
models/
├── celeb_voice_a/
│   ├── model.pth
│   ├── index.faiss
│   └── config.json
├── celeb_voice_b/
│   ├── model.pth
│   ├── index.faiss
│   └── config.json
└── custom_brand_voice/
    ├── model.pth
    ├── index.faiss
    └── config.json

# Dynamic model loader for multi-tenant deployments
import os
import glob

def list_available_models(models_dir="./models"):
    """List all available voice models"""
    models = []
    for model_dir in glob.glob(os.path.join(models_dir, "*/")):
        name = os.path.basename(os.path.dirname(model_dir))
        pth_files = glob.glob(os.path.join(model_dir, "*.pth"))
        index_files = glob.glob(os.path.join(model_dir, "*.faiss")) + \
                      glob.glob(os.path.join(model_dir, "*.index"))
        if pth_files and index_files:
            models.append({
                "name": name,
                "pth": pth_files[0],
                "index": index_files[0]
            })
    return models

# monitoring.py — Prometheus-compatible metrics
from prometheus_client import Counter, Histogram, start_http_server
import time

conversion_count = Counter('rvc_conversions_total', 'Total conversions')
conversion_duration = Histogram('rvc_conversion_seconds', 'Conversion latency')
error_count = Counter('rvc_errors_total', 'Total errors', ['error_type'])

def monitored_convert(audio_path, model_name):
    start = time.time()
    try:
        result = perform_conversion(audio_path, model_name)
        conversion_count.inc()
        return result
    except Exception as e:
        error_count.labels(error_type=type(e).__name__).inc()
        raise
    finally:
        conversion_duration.observe(time.time() - start)

# Start metrics endpoint
start_http_server(9090)

# Export trained model to ONNX for CPU/GPU-agnostic inference
python tools/export_onnx.py \
  --checkpoint_path ./logs/my_voice_v2/G_12000.pth \
  --output_path ./models/my_voice_v2/model.onnx \
  --sample_rate 40000