# Clonage vocal RVC

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

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [Place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Location sur CLORE.AI

1. Visitez [Place de marché CLORE.AI](https://clore.ai/marketplace)
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 :**

```bash
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

```bash

# 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

```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

```bash

# 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

```bash

# É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

```python
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

```python
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

```python
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

```python
from pydub import AudioSegment

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

### Supprimer les silences

```python
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

```python
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 :

```python
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

```python
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*](https://clore.ai/marketplace) *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](/guides/guides_v2-fr/audio-et-voix/bark-tts.md) - Synthèse vocale
* [AudioCraft Music](/guides/guides_v2-fr/audio-et-voix/audiocraft-music.md) - Génération de musique
* [Whisper Transcription](/guides/guides_v2-fr/audio-et-voix/whisper-transcription.md) - Reconnaissance vocale (speech-to-text)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/rvc-voice-clone.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.