Clonage vocal RVC

Clonez et convertissez des voix avec RVC sur les GPU Clore.ai

Clonez et convertissez des voix à l’aide de la conversion vocale basée sur la récupération.

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

Location sur CLORE.AI

1. Visitez CLORE.AI Marketplace

2. Filtrez par type de GPU, VRAM et prix

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

4. Configurez votre commande :

   • Sélectionnez l'image Docker

   • Définissez les ports (TCP pour SSH, HTTP pour les interfaces Web)

   • Ajoutez des variables d'environnement si nécessaire

   • Entrez la commande de démarrage

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

6. Créez la commande et attendez le déploiement

Accès à votre serveur

• Trouvez les détails de connexion dans Mes commandes

• Interfaces Web : utilisez l'URL du port HTTP

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

Qu'est-ce que RVC ?

RVC (conversion vocale 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 vocale en temps réel

• Sortie de haute qualité

Exigences

Tâche	VRAM minimale	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.11.0-cuda12.8-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ès à votre service

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

1. Accédez à Mes commandes page

2. Cliquez sur votre commande

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

Utiliser https://YOUR_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 vocale (inférence)

Utilisation de l'interface Web

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

2. Allez à l'onglet "Inférence du modèle"

3. Téléversez le fichier audio

4. Sélectionnez le modèle vocal

5. Ajustez les paramètres

6. Cliquez sur "Convertir"

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,  # Décalage de 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. Collectez 10 à 30 minutes d'audio propre

2. Découpez en segments de 5 à 15 secondes

3. Supprimez le bruit/la musique de fond

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

Entraînement via l'interface Web

1. Allez à l'onglet "Entraînement"

2. Entrez le nom de l'expérience

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

4. Cliquez sur "Traiter les données"

5. Cliquez sur "Extraction des caractéristiques"

6. Cliquez sur "Entraîner"

Entraînement via la ligne de commande

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

# Étape 2 : extraire les 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îner
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 du lot	Lot d'entraînement	8-16
Époques	Itérations d'entraînement	200-500
Sauvegarder tous les	Fréquence des points de contrôle	20-50
Méthode f0	Extraction de la hauteur	rmvpe

Méthodes f0

Méthode	Qualité	Vitesse	Idéal pour
pm	Correct	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

# Initialisation
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 le silence

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 lots

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"Converti : {filename}")

Conversion de voix chantée

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

output = vc.convert(
    audio=audio,
    f0_method="rmvpe",  # Idéal pour le chant
    index_rate=0.5,     # Plus faible 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

• Utilisez une source audio de meilleure qualité

• Augmentez la valeur protect (0.4-0.5)

• Essayez une autre méthode f0

Problèmes de hauteur

• Ajustez f0_up_key

• Utilisez la méthode f0 rmvpe

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

Qualité audio

• Utilisez un taux d'échantillonnage de 48 kHz

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

• Entraînez pour davantage 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é

• Utilisez 20 minutes ou plus d'audio propre

• Supprimez tout bruit de fond

• Configuration cohérente du microphone et de l'enregistrement

• Incluez des expressions et des émotions variées

Pour un entraînement plus rapide

• Utilisez une taille de lot de 8 à 16

• Activez la précision mixte

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

Performances

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

Dépannage

Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 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 40 Go	~$0.17	~$4.00	~$0.70
A100 80 Go	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Consultez CLORE.AI Marketplace pour connaître les tarifs actuels.

Économisez de l'argent :

• Utilisez le Spot marché pour les tâches interrompables — environ un tiers des serveurs affichent un prix spot inférieur au prix à la demande (médiane ~13 % de remise), les autres s'alignent

• Payez avec CLORE des jetons

• Comparez les prix entre différents fournisseurs

Étapes suivantes

• Bark TTS - Synthèse vocale

• AudioCraft Music - Génération musicale

• Whisper Transcription - Reconnaissance vocale