> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/rvc-voice-clone.md).

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

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

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://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 :**

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

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

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

```bash

# 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

```bash

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

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

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

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

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

## Conversion de voix chantée

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

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

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

* 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*](https://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](/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 musicale
* [Whisper Transcription](/guides/guides_v2-fr/audio-et-voix/whisper-transcription.md) - Reconnaissance vocale


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.