Clon de voz RVC

Clona y convierte voces con RVC en GPUs de Clore.ai

Clona y convierte voces usando Conversion de Voz basada en Recuperación.

Todos los ejemplos pueden ejecutarse en servidores GPU alquilados a través de CLORE.AI Marketplace.

Alquiler en CLORE.AI

1. Visitar CLORE.AI Marketplace

2. Filtrar por tipo de GPU, VRAM y precio

3. Elegir Bajo demanda (tarifa fija) o Spot (precio de oferta)

4. Configura tu pedido:

   • Selecciona la imagen de Docker

   • Configura los puertos (TCP para SSH, HTTP para interfaces web)

   • Agrega variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona el pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera el despliegue

Accede a tu servidor

• Encuentra los detalles de conexión en Mis Pedidos

• Interfaces web: Usa la URL del puerto HTTP

• SSH: ssh -p <port> root@<proxy-address>

¿Qué es RVC?

RVC (Conversion de Voz basada en Recuperación) puede:

• Clonar cualquier voz con entrenamiento mínimo

• Convertir voces cantadas/habladas

• Conversión de voz en tiempo real

• Salida de alta calidad

Requisitos

Tarea	VRAM mínima	Recomendado
Inferencia	4GB	RTX 3060
Entrenamiento	8GB	RTX 3090
Tiempo real	6GB	RTX 3070

Despliegue rápido

Imagen de Docker:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Puertos:

22/tcp
7865/http

Comando:

apt-get update && apt-get install -y ffmpeg git && \
cd /workspace && \
git clone https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI.git && \
cd Retrieval-based-Voice-Conversion-WebUI && \
pip install -r requirements.txt && \
python infer-web.py --host 0.0.0.0 --port 7865

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis Pedidos:

1. Ir a Mis Pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://YOUR_HTTP_PUB_URL en lugar de localhost en los ejemplos a continuación.

Instalación

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

# Instalar dependencias
pip install -r requirements.txt

# Descargar modelos
python tools/download_models.py

Conversión de Voz (Inferencia)

Usando la interfaz web

1. Abrir http://<proxy>:7865

2. Ir a la pestaña "Model Inference"

3. Subir archivo de audio

4. Seleccionar modelo de voz

5. Ajustar configuraciones

6. Hacer clic en "Convert"

API de Python

from infer_pack.models import SynthesizerTrnMs256NSFsid, SynthesizerTrnMs768NSFsid
from vc_infer_pipeline import VC
import torch
import soundfile as sf

# Cargar modelo
model_path = "./models/my_voice.pth"
index_path = "./models/my_voice.index"

vc = VC(
    model_path=model_path,
    config_path="./configs/v2/48k.json",
    device="cuda"
)

# Convertir audio
audio, sr = sf.read("input.wav")
output = vc.convert(
    audio=audio,
    f0_method="rmvpe",  # Método de extracción de tono
    index_path=index_path,
    index_rate=0.75,
    f0_up_key=0,  # Cambio de tono (semitonos)
    protect=0.33
)

sf.write("output.wav", output, sr)

Entrenamiento de Voz Personalizada

Preparar conjunto de datos

1. Recopila 10-30 minutos de audio limpio

2. Corta en clips de 5-15 segundos

3. Elimina ruido de fondo/música

# Dividir audio en clips
ffmpeg -i full_audio.mp3 -f segment -segment_time 10 -c copy clips/clip_%03d.mp3

Entrenar vía interfaz web

1. Ir a la pestaña "Train"

2. Introduce el nombre del experimento

3. Configura la ruta de la carpeta de entrenamiento

4. Haz clic en "Process data"

5. Haz clic en "Feature extraction"

6. Haz clic en "Train"

Entrenar vía línea de comandos

# Paso 1: Procesar audio
python trainset_preprocess_pipeline_print.py \
    "./dataset" \
    48000 \
    8 \
    "./logs/experiment" \
    False

# Paso 2: Extraer características
python extract_f0_print.py \
    "./logs/experiment" \
    8 \
    "rmvpe"

python extract_feature_print.py \
    "cuda:0" \
    "1" \
    "0" \
    "0" \
    "./logs/experiment" \
    "v2"

# Paso 3: Entrenar
python train_nsf_sim_cache_sid_load_pretrain.py \
    -e "experiment" \
    -sr "48k" \
    -f0 1 \
    -bs 8 \
    -g 0 \
    -te 200 \
    -se 20 \
    -pg "./pretrained/f0G48k.pth" \
    -pd "./pretrained/f0D48k.pth" \
    -l 0 \
    -c 1 \
    -sw 0 \
    -v "v2"

Parámetros de Entrenamiento

Parámetro	Descripción	Recomendado
Frecuencia de muestreo	Calidad de audio	48000
Tamaño de lote	Lote de entrenamiento	8-16
Épocas	Iteraciones de entrenamiento	200-500
Guardar cada	Frecuencia de checkpoints	20-50
Método f0	Extracción de tono	rmvpe

Métodos F0

Método	Calidad	Velocidad	Mejor para
pm	OK	Rápido	Pruebas
harvest	Bueno	Lento	General
crepe	Genial	Medio	Canto
rmvpe	Mejor	Medio	Todo

Conversión en tiempo real

Configuración

import pyaudio
import numpy as np
from infer_pack.models import SynthesizerTrnMs256NSFsid
from vc_infer_pipeline import VC

# Inicializar
vc = VC(model_path="./models/voice.pth", device="cuda")

# Configuración de audio
CHUNK = 1024
FORMAT = pyaudio.paFloat32
CHANNELS = 1
RATE = 48000

p = pyaudio.PyAudio()
stream_in = p.open(format=FORMAT, channels=CHANNELS, rate=RATE,
                   input=True, frames_per_buffer=CHUNK)
stream_out = p.open(format=FORMAT, channels=CHANNELS, rate=RATE,
                    output=True, frames_per_buffer=CHUNK)

# Bucle en tiempo real
while True:
    audio_in = np.frombuffer(stream_in.read(CHUNK), dtype=np.float32)
    audio_out = vc.convert(audio_in)
    stream_out.write(audio_out.tobytes())

Formatos de modelo

Convertir a ONNX

import torch

# Cargar modelo de PyTorch
model = torch.load("model.pth")

# Exportar a ONNX
torch.onnx.export(
    model,
    dummy_input,
    "model.onnx",
    input_names=["audio"],
    output_names=["converted"],
    dynamic_axes={"audio": {0: "length"}}
)

Preprocesamiento de audio

Eliminar ruido

import noisereduce as nr
import soundfile as sf

audio, sr = sf.read("noisy.wav")
reduced_noise = nr.reduce_noise(y=audio, sr=sr)
sf.write("clean.wav", reduced_noise, sr)

Normalizar volumen

from pydub import AudioSegment

audio = AudioSegment.from_wav("input.wav")
normalized = audio.normalize()
normalized.export("normalized.wav", format="wav")

Eliminar silencio

from pydub import AudioSegment
from pydub.silence import split_on_silence

audio = AudioSegment.from_wav("input.wav")
chunks = split_on_silence(audio, min_silence_len=500, silence_thresh=-40)
combined = sum(chunks)
combined.export("no_silence.wav", format="wav")

Procesamiento por lotes

import os
from vc_infer_pipeline import VC
import soundfile as sf

vc = VC(model_path="./models/voice.pth", device="cuda")

input_dir = "./inputs"
output_dir = "./outputs"
os.makedirs(output_dir, exist_ok=True)

for filename in os.listdir(input_dir):
    if filename.endswith(('.wav', '.mp3', '.flac')):
        input_path = os.path.join(input_dir, filename)
        output_path = os.path.join(output_dir, f"converted_{filename}")

        audio, sr = sf.read(input_path)
        converted = vc.convert(audio)
        sf.write(output_path, converted, sr)

        print(f"Converted: {filename}")

Conversión de voz para canto

Para canciones, usa configuraciones apropiadas:

output = vc.convert(
    audio=audio,
    f0_method="rmvpe",  # Mejor para canto
    index_rate=0.5,     # Más bajo para canto
    f0_up_key=-2,       # Ajustar el tono para que coincida
    protect=0.5         # Proteger consonantes
)

Problemas comunes

La voz suena robótica

• Usa audio fuente de mayor calidad

• Aumenta el valor de protect (0.4-0.5)

• Prueba un método f0 diferente

Problemas de tono

• Ajusta f0_up_key

• Usa el método f0 rmvpe

• Asegura un tono consistente en los datos de entrenamiento

Calidad de audio

• Usa frecuencia de muestreo de 48 kHz

• Elimina ruido de fondo de los datos de entrenamiento

• Entrena por más épocas

Servidor API

from fastapi import FastAPI, UploadFile
from fastapi.responses import FileResponse
from vc_infer_pipeline import VC
import soundfile as sf
import tempfile

app = FastAPI()
vc = VC(model_path="./models/voice.pth", device="cuda")

@app.post("/convert")
async def convert_voice(file: UploadFile, pitch: int = 0):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_in:
        content = await file.read()
        tmp_in.write(content)
        tmp_in_path = tmp_in.name

    audio, sr = sf.read(tmp_in_path)
    converted = vc.convert(audio, f0_up_key=pitch)

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_out:
        sf.write(tmp_out.name, converted, sr)
        return FileResponse(tmp_out.name, media_type="audio/wav")

Consejos de entrenamiento

Para mejor calidad

• Usa más de 20 minutos de audio limpio

• Elimina todo el ruido de fondo

• Configuración de micrófono/grabación consistente

• Incluye expresiones/emociones variadas

Para entrenamiento más rápido

• Usa tamaño de lote 8-16

• Habilita precisión mixta

• Usa SSD NVMe para el conjunto de datos

Rendimiento

Tarea	GPU	Tiempo
Inferencia (1 min de audio)	RTX 3090	~5s
Entrenamiento (conjunto de 30 min)	RTX 3090	~2 horas
Conversión en tiempo real	RTX 3070	latencia <50ms

Solución de problemas

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

GPU	Tarifa por hora	Tarifa diaria	Sesión de 4 horas
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

Los precios varían según el proveedor y la demanda. Consulta CLORE.AI Marketplace para tarifas actuales.

Ahorra dinero:

• Usa Spot mercado para cargas de trabajo flexibles (a menudo 30-50% más barato)

• Paga con CLORE tokens

• Compara precios entre distintos proveedores

Próximos pasos

• Bark TTS - Texto a voz

• AudioCraft Music - Generación de música

• Whisper Transcription - Voz a texto