RVC: 35K+ Stars AI 음성 변환 구축 — 2026년 10분 훈련 설정 가이드

# 저장소 클론
git clone https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI.git
cd Retrieval-based-Voice-Conversion-WebUI

# Docker 이미지 빌드
docker build -t rvc-webui:latest .

# GPU 지원 및 볼륨 마운트로 실행
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

# docker-compose로 시작
docker-compose up -d

# 로그 확인
docker-compose logs -f rvc

# 저장소 클론
git clone https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI.git
cd Retrieval-based-Voice-Conversion-WebUI

# 가상 환경 생성
python3 -m venv venv
source venv/bin/activate

# 종속성 설치
pip install -r requirements.txt

# 사전 훈련된 모델 다운로드
python tools/download_models.py

# 또는 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/

# ROCm 종속성 설치(Ubuntu/Debian)
sudo apt install rocm-hip-sdk rocm-opencl-sdk

# 환경 변수 설정
export ROCM_PATH=/opt/rocm
export HSA_OVERRIDE_GFX_VERSION=10.3.0

# 사용자를 render 및 video 그룹에 추가
sudo usermod -aG render $USER
sudo usermod -aG video $USER

# AMD 전용 종속성 설치
pip install -r requirements-amd.txt

# Gradio 웹 인터페이스 시작
python infer-web.py

# WebUI는 http://localhost:7865 에서 사용 가능

# 배경 음악에서 보컬 분리
python tools/uvr5/uvr5_cli.py \
  --input_path ./raw_audio/song_with_music.wav \
  --output_path ./dataset/ \
  --model_name "HP2-人声vocals+非人声instrumentals"

# 1단계: 전처리(리샘플링, 슬라이싱, 침묵 제거)
python trainset_preprocess_pipeline_print.py \
  ./dataset/my_voice \
  40000 \
  8  # CPU 스레드 수

# 2단계: ContentVec으로 특징 추출
python extract_feature_print.py \
  --model_name my_voice_v2 \
  --sample_rate 40000 \
  --pitch_extractor rmvpe \
  --gpu 0

# 3단계: 모델 훈련
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

# 검색용 Faiss 인덱스 생성
python tools/infer/train_index.py \
  --model_name my_voice_v2 \
  --sample_rate 40000

# gpt_sovits_rvc_pipeline.py
import requests

def tts_then_convert(text: str, speaker_wav: str, rvc_model: str):
    """GPT-SoVITS TTS → RVC 음성 변환 파이프라인"""
    
    # 1단계: GPT-SoVITS로 음성 생성
    tts_response = requests.post("http://localhost:9880/tts", json={
        "text": text,
        "refer_wav_path": speaker_wav,
        "prompt_text": "참고 프롬프트 텍스트",
        "prompt_language": "ko",
        "text_language": "ko"
    })
    
    with open("/tmp/tts_output.wav", "wb") as f:
        f.write(tts_response.content)
    
    # 2단계: 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"]

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

def coqui_to_rvc(text: str, rvc_model: str, output_path: str):
    # 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="ko",
        file_path="/tmp/coqui_out.wav"
    )
    
    # 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

# demucs 설치
pip install demucs

# demucs로 보컬 분리(복잡한 믹스에서 UVR5보다 품질 우수)
demucs --two-stems=vocals --mp3 --mp3-bitrate 320 input_song.mp3

# 분리된 보컬 트랙을 RVC 훈련에 사용
mv separated/htdemucs/input_song/vocals.wav ./dataset/clean_voice.wav

# 실시간 GUI 시작
python gui_v1.py

# AMD/Intel GPU용 DirectML 사용
python gui_v1.py --dml

# 낮은 지연 시간을 위한 핵심 파라미터:
# - 블록 시간: 0.25s(낮을수록 지연 시간 감소, CPU 사용 증가)
# - 크로스페이드: 0.05s
# - 추가 시간: 2.5s
# - 피치 추출기: fcpe(가장 빠름) 또는 rmvpe(최상의 품질)

# gui_config.py 예시
config = {
    "block_time": 0.1,        # 낮은 지연 시간을 위한 100ms 블록
    "crossfade_time": 0.04,
    "extra_time": 2.0,
    "f0method": "fcpe",       # 가장 빠른 피치 추출기
    "rms_mix_rate": 0.25,
    "index_rate": 0.3,
    "pitch": 0,
    "I_noise_reduce": True,
    "O_noise_reduce": False
}

# API 서버 시작
python api_240604.py

# API는 http://localhost:7865 에서 사용 가능

# API 추론 클라이언트 예시
import requests

# 먼저 모델 로드
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"
})

# 음성 변환 수행
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 — 강화된 API 래퍼
from fastapi import FastAPI, HTTPException, Depends
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
import hashlib

security = HTTPBearer()

def verify_token(credentials: HTTPAuthorizationCredentials):
    """프로덕션 배포의 API 토큰 검증"""
    expected = hashlib.sha256(TOKEN.encode()).hexdigest()
    if credentials.credentials != expected:
        raise HTTPException(status_code=401, detail="유효하지 않은 토큰")
    return True

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

# 여러 음성 모델 조직
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

# 멀티 테넌트 배포를 위한 동적 모델 로더
import os
import glob

def list_available_models(models_dir="./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 호환 메트릭
from prometheus_client import Counter, Histogram, start_http_server
import time

conversion_count = Counter('rvc_conversions_total', '총 변환 횟수')
conversion_duration = Histogram('rvc_conversion_seconds', '변환 지연 시간')
error_count = Counter('rvc_errors_total', '총 오류 수', ['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_http_server(9090)

# 훈련된 모델을 ONNX로 낮출하여 CPU/GPU 독립적 추론
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