# RVC Stimmenklon

Stimmen klonen und umwandeln mit Retrieval-basierter Sprachkonvertierung.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über gemietet werden können [CLORE.AI Marktplatz](https://clore.ai/marketplace).
{% endhint %}

## Mieten auf CLORE.AI

1. Besuchen [CLORE.AI Marktplatz](https://clore.ai/marketplace)
2. Nach GPU-Typ, VRAM und Preis filtern
3. Wählen **On-Demand** (Festpreis) oder **Spot** (Gebotspreis)
4. Konfigurieren Sie Ihre Bestellung:
   * Docker-Image auswählen
   * Ports festlegen (TCP für SSH, HTTP für Web-UIs)
   * Umgebungsvariablen bei Bedarf hinzufügen
   * Startbefehl eingeben
5. Zahlung auswählen: **CLORE**, **BTC**, oder **USDT/USDC**
6. Bestellung erstellen und auf Bereitstellung warten

### Zugriff auf Ihren Server

* Verbindungsdetails finden in **Meine Bestellungen**
* Web-Oberflächen: Verwenden Sie die HTTP-Port-URL
* SSH: `ssh -p <port> root@<proxy-address>`

## Was ist RVC?

RVC (Retrieval-basierte Sprachkonvertierung) kann:

* Jede Stimme mit minimalem Training klonen
* Gesangs- und Sprechstimmen konvertieren
* Echtzeit-Sprachkonvertierung
* Ausgabe in hoher Qualität

## Anforderungen

| Aufgabe   | Min. VRAM | Empfohlen |
| --------- | --------- | --------- |
| Inference | 4GB       | RTX 3060  |
| Training  | 8GB       | RTX 3090  |
| Echtzeit  | 6GB       | RTX 3070  |

## Schnelle Bereitstellung

**Docker-Image:**

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

**Ports:**

```
22/tcp
7865/http
```

**Befehl:**

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

## Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre `http_pub` URL in **Meine Bestellungen**:

1. Gehen Sie zur **Meine Bestellungen** Seite
2. Klicken Sie auf Ihre Bestellung
3. Finden Sie die `http_pub` URL (z. B., `abc123.clorecloud.net`)

Verwenden Sie `https://YOUR_HTTP_PUB_URL` anstelle von `localhost` in den folgenden Beispielen.

## Installation

```bash

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

# Abhängigkeiten installieren
pip install -r requirements.txt

# Modelle herunterladen
python tools/download_models.py
```

## Sprachkonvertierung (Inference)

### Verwendung der Web-Oberfläche

1. Öffnen `http://<proxy>:7865`
2. Gehen Sie zum Reiter "Model Inference"
3. Audio-Datei hochladen
4. Stimmenmodell auswählen
5. Einstellungen anpassen
6. Auf "Convert" klicken

### Python-API

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

# Modell laden
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"
)

# Audio konvertieren
audio, sr = sf.read("input.wav")
output = vc.convert(
    audio=audio,
    f0_method="rmvpe",  # Methode zur Tonhöhenerkennung
    index_path=index_path,
    index_rate=0.75,
    f0_up_key=0,  # Tonhöhenverschiebung (Halbtöne)
    protect=0.33
)

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

## Eigene Stimme trainieren

### Datensatz vorbereiten

1. 10–30 Minuten sauberes Audio sammeln
2. In 5–15 Sekunden lange Clips schneiden
3. Hintergrundgeräusche/Musik entfernen

```bash

# Audio in Clips aufteilen
ffmpeg -i full_audio.mp3 -f segment -segment_time 10 -c copy clips/clip_%03d.mp3
```

### Training über Web UI

1. Gehen Sie zum Reiter "Train"
2. Experimentnamen eingeben
3. Pfad des Trainingsordners festlegen
4. Auf "Process data" klicken
5. Auf "Feature extraction" klicken
6. Auf "Train" klicken

### Training über Kommandozeile

```bash

# Schritt 1: Audio verarbeiten
python trainset_preprocess_pipeline_print.py \
    "./dataset" \
    48000 \
    8 \
    "./logs/experiment" \
    False

# Schritt 2: Merkmale extrahieren
python extract_f0_print.py \
    "./logs/experiment" \
    8 \
    "rmvpe"

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

# Schritt 3: Trainieren
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"
```

## Trainingsparameter

| Parameter      | Beschreibung               | Empfohlen |
| -------------- | -------------------------- | --------- |
| Abtastrate     | Audioqualität              | 48000     |
| Batch-Größe    | Trainingseinheit (Batch)   | 8-16      |
| Epochen        | Trainingsdurchläufe        | 200-500   |
| Speichere alle | Häufigkeit der Checkpoints | 20-50     |
| f0-Methode     | Tonhöhenerkennung          | rmvpe     |

## F0-Methoden

| Methode | Qualität  | Geschwindigkeit | Am besten für |
| ------- | --------- | --------------- | ------------- |
| pm      | OK        | Schnell         | Testen        |
| harvest | Gut       | Langsam         | Allgemein     |
| crepe   | Großartig | Mittel          | Gesang        |
| rmvpe   | Am besten | Mittel          | Alle          |

## Echtzeit-Konvertierung

### Einrichtung

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

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

# Audio-Einrichtung
CHUNK = 1024
FORMAT = pyaudio.paFloat32
KANÄLE = 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)

# Echtzeitschleife
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())
```

## Modellformate

### In ONNX konvertieren

```python
import torch

# PyTorch-Modell laden
model = torch.load("model.pth")

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

## Audio-Vorverarbeitung

### Rauschreduzierung

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

### Lautstärke normalisieren

```python
from pydub import AudioSegment

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

### Stille entfernen

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

## Batch-Verarbeitung

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

## Gesangs-Stimmenkonvertierung

Für Lieder geeignete Einstellungen verwenden:

```python
output = vc.convert(
    audio=audio,
    f0_method="rmvpe",  # Am besten für Gesang
    index_rate=0.5,     # Niedriger für Gesang
    f0_up_key=-2,       # Tonhöhe anpassen
    protect=0.5         # Konsonanten schützen
)
```

## Häufige Probleme

### Stimme klingt robotic

* Quell-Audio in höherer Qualität verwenden
* Protect-Wert erhöhen (0,4–0,5)
* Andere f0-Methode ausprobieren

### Tonhöhen-Probleme

* f0\_up\_key anpassen
* rmvpe als f0-Methode verwenden
* Für konsistente Tonhöhe in den Trainingsdaten sorgen

### Audio-Qualität

* 48 kHz Abtastrate verwenden
* Hintergrundgeräusche aus den Trainingsdaten entfernen
* Mehr Epochen trainieren

## API-Server

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

## Trainingstipps

### Für bessere Qualität

* Verwenden Sie 20+ Minuten sauberes Audio
* Alle Hintergrundgeräusche entfernen
* Konsistente Mikrofon-/Aufnahme-Einstellungen
* Verschiedene Ausdrücke/Emotionen einbeziehen

### Für schnelleres Training

* Batch-Größe 8–16 verwenden
* Mixed Precision aktivieren
* NVMe-SSD für den Datensatz verwenden

## Leistung

| Aufgabe                      | GPU      | Zeit          |
| ---------------------------- | -------- | ------------- |
| Inference (1 Min. Audio)     | RTX 3090 | \~5s          |
| Training (30 Min. Datensatz) | RTX 3090 | \~2 Stunden   |
| Echtzeit-Konvertierung       | RTX 3070 | <50 ms Latenz |

## Fehlerbehebung

## Kostenabschätzung

Typische CLORE.AI-Marktplatzpreise (Stand 2024):

| GPU       | Stundenpreis | Tagespreis | 4-Stunden-Sitzung |
| --------- | ------------ | ---------- | ----------------- |
| 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           |

*Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie* [*CLORE.AI Marktplatz*](https://clore.ai/marketplace) *für aktuelle Preise.*

**Geld sparen:**

* Verwenden Sie **Spot** Markt für flexible Workloads (oft 30–50% günstiger)
* Mit bezahlen **CLORE** Tokens
* Preise verschiedener Anbieter vergleichen

## Nächste Schritte

* [Bark TTS](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/bark-tts) - Text-zu-Sprache
* [AudioCraft Music](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/audiocraft-music) - Musikgenerierung
* [Whisper Transcription](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/whisper-transcription) - Sprache-zu-Text