RVC Voice Clone

Cloner et convertir des voix avec RVC sur les GPU Clore.ai

Cloner et convertir des voix en utilisant la Conversion de Voix basée sur la Récupération.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via Place de marché CLORE.AI.

Location sur CLORE.AI

1. Visitez Place de marché CLORE.AI

2. Filtrer par type de GPU, VRAM et prix

3. Choisir À la demande (tarif fixe) ou Spot (prix d'enchère)

4. Configurez votre commande :

   • Sélectionner l'image Docker

   • Définir les ports (TCP pour SSH, HTTP pour les interfaces web)

   • Ajouter des variables d'environnement si nécessaire

   • Entrer la commande de démarrage

5. Sélectionner le paiement : CLORE, BTC, ou USDT/USDC

6. Créer la commande et attendre le déploiement

Accéder à votre serveur

• Trouvez les détails de connexion dans Mes commandes

• Interfaces web : utilisez l'URL du port HTTP

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

Qu'est-ce que RVC ?

RVC (Conversion de Voix basée sur la Récupération) peut :

• Cloner n'importe quelle voix avec un entraînement minimal

• Convertir des voix chantées/parlées

• Conversion de voix en temps réel

• Sortie de haute qualité

Exigences

Tâche	VRAM min	Recommandé
Inférence	4 Go	RTX 3060
Entraînement	8 Go	RTX 3090
Temps réel	6 Go	RTX 3070

Déploiement rapide

Image Docker :

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

Ports :

22/tcp
7865/http

Commande :

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

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

1. Aller à Mes commandes page

2. Cliquez sur votre commande

3. Trouvez l' http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://VOTRE_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Installation

# Cloner le dépôt
git clone https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI.git
cd Retrieval-based-Voice-Conversion-WebUI

# Installer les dépendances
pip install -r requirements.txt

# Télécharger les modèles
python tools/download_models.py

Conversion de voix (Inférence)

Utilisation de l'interface Web

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

2. Aller à l'onglet « Model Inference »

3. Téléverser un fichier audio

4. Sélectionner le modèle de voix

5. Ajuster les paramètres

6. Cliquer sur « Convert »

API Python

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

# Charger le modèle
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 l'audio
audio, sr = sf.read("input.wav")
output = vc.convert(
    audio=audio,
    f0_method="rmvpe",  # Méthode d'extraction de la hauteur
    index_path=index_path,
    index_rate=0.75,
    f0_up_key=0,  # Transposition en hauteur (demi-tons)
    protect=0.33
)

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

Entraîner une voix personnalisée

Préparer le jeu de données

1. Collecter 10-30 minutes d'audio propre

2. Découper en clips de 5 à 15 secondes

3. Supprimer le bruit de fond/la musique

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

Entraînement via l'interface Web

1. Aller à l'onglet « Train »

2. Entrer le nom de l'expérience

3. Définir le chemin du dossier d'entraînement

4. Cliquer sur « Process data »

5. Cliquer sur « Feature extraction »

6. Cliquer sur « Train »

Entraînement via la ligne de commande

# Étape 1 : Traitement de l'audio
python trainset_preprocess_pipeline_print.py \
    "./dataset" \
    48000 \
    8 \
    "./logs/experiment" \
    False

# Étape 2 : Extraction des caractéristiques
python extract_f0_print.py \
    "./logs/experiment" \
    8 \
    "rmvpe"

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

# Étape 3 : Entraînement
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"

Paramètres d'entraînement

Paramètre	Description	Recommandé
Taux d'échantillonnage	Qualité audio	48000
Taille de lot	Lot d'entraînement	8-16
Époques	Itérations d'entraînement	200-500
Sauvegarder chaque	Fréquence des checkpoints	20-50
Méthode f0	Extraction de la hauteur	rmvpe

Méthodes f0

Méthode	Qualité	Vitesse	Idéal pour
pm	OK	Rapide	Test
harvest	Bon	Lent	Général
crepe	Excellent	Moyen	Chant
rmvpe	Meilleur	Moyen	Tous

Conversion en temps réel

Configuration

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

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

# Configuration 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)

# Boucle en temps réel
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())

Formats de modèle

Convertir en ONNX

import torch

# Charger le modèle PyTorch
model = torch.load("model.pth")

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

Prétraitement audio

Supprimer le bruit

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)

Normaliser le volume

from pydub import AudioSegment

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

Supprimer les silences

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")

Traitement par lot

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}")

Conversion de voix chantée

Pour les chansons, utilisez les paramètres appropriés :

output = vc.convert(
    audio=audio,
    f0_method="rmvpe",  # Meilleur pour le chant
    index_rate=0.5,     # Plus bas pour le chant
    f0_up_key=-2,       # Ajuster la hauteur pour correspondre
    protect=0.5         # Protéger les consonnes
)

Problèmes courants

La voix sonne robotique

• Utiliser une source audio de meilleure qualité

• Augmenter la valeur de protect (0.4-0.5)

• Essayer une autre méthode f0

Problèmes de hauteur

• Ajuster f0_up_key

• Utiliser la méthode f0 rmvpe

• Assurer une hauteur cohérente dans les données d'entraînement

Qualité audio

• Utiliser un taux d'échantillonnage de 48 kHz

• Supprimer le bruit de fond des données d'entraînement

• S'entraîner pendant plus d'époques

Serveur 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")

Conseils d'entraînement

Pour une meilleure qualité

• Utiliser plus de 20 minutes d'audio propre

• Supprimer tout bruit de fond

• Configuration de microphone/enregistrement cohérente

• Inclure des expressions/émotions variées

Pour un entraînement plus rapide

• Utiliser une taille de lot de 8-16

• Activer la précision mixte

• Utiliser un SSD NVMe pour le jeu de données

Performances

Tâche	GPU	Temps
Inférence (1 min d'audio)	RTX 3090	~5s
Entraînement (jeu de données 30 min)	RTX 3090	~2 heures
Conversion en temps réel	RTX 3070	<50ms de latence

Dépannage

Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

GPU	Tarif horaire	Tarif journalier	Session de 4 heures
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

Les prix varient selon le fournisseur et la demande. Vérifiez Place de marché CLORE.AI pour les tarifs actuels.

Économisez de l'argent :

• Utilisez Spot market pour les charges de travail flexibles (souvent 30-50% moins cher)

• Payer avec CLORE tokens

• Comparer les prix entre différents fournisseurs

Étapes suivantes

• Bark TTS - Synthèse vocale

• AudioCraft Music - Génération de musique

• Whisper Transcription - Reconnaissance vocale (speech-to-text)