RVC-Sprachklon

Kopiere und konvertiere Stimmen mit RVC auf Clore.ai-GPUs

Klone und konvertiere Stimmen mit Retrieval-based Voice Conversion.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die über CLORE.AI-Marktplatz.

Mieten auf CLORE.AI

1. Besuche CLORE.AI-Marktplatz

2. Nach GPU-Typ, VRAM und Preis filtern

3. Wählen Sie On-Demand (Festpreis) oder Spot (Gebotspreis)

4. Konfiguriere deine Bestellung:

   • Docker-Image auswählen

   • Ports festlegen (TCP für SSH, HTTP für Web-UIs)

   • Umgebungsvariablen hinzufügen, falls nötig

   • Startbefehl eingeben

5. Zahlung auswählen: CLORE, BTC, oder USDT/USDC

6. Bestellung erstellen und auf die Bereitstellung warten

Auf deinen Server zugreifen

• Verbindungsdetails finden in Meine Bestellungen

• Weboberflächen: Verwende die HTTP-Port-URL

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

Was ist RVC?

RVC (Retrieval-based Voice Conversion) kann:

• Jede Stimme mit minimalem Training klonen

• Sing- und Sprechstimmen konvertieren

• Echtzeit-Stimmenkonvertierung

• Hochwertige Ausgabe

Anforderungen

Aufgabe	Min. VRAM	Empfohlen
Inferenz	4 GB	RTX 3060
Training	8 GB	RTX 3090
Echtzeit	6 GB	RTX 3070

Schnell bereitstellen

Docker-Image:

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

Ports:

22/tcp
7865/http

Befehl:

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

Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine http_pub URL in Meine Bestellungen:

1. Gehe zu Meine Bestellungen Seite

2. Klicke auf deine Bestellung

3. Finde die http_pub URL (z. B. abc123.clorecloud.net)

Verwende https://YOUR_HTTP_PUB_URL anstelle von localhost in den folgenden Beispielen.

Installation

# 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

Stimmenkonvertierung (Inferenz)

Mit der Web-UI

1. Öffnen http://<proxy>:7865

2. Gehe zum Tab "Modell-Inferenz"

3. Audiodatei hochladen

4. Stimmenmodell auswählen

5. Einstellungen anpassen

6. Klicke auf "Konvertieren"

Python-API

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öhenermittlung
    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. Sammle 10-30 Minuten sauberes Audio

2. In 5-15-Sekunden-Clips schneiden

3. Hintergrundgeräusche/Musik entfernen

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

Training über die Web-UI

1. Gehe zum Tab "Train"

2. Experimentnamen eingeben

3. Pfad des Trainingsordners festlegen

4. Klicke auf "Daten verarbeiten"

5. Klicke auf "Feature-Extraktion"

6. Klicke auf "Trainieren"

Training über die Kommandozeile

# 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
Batchgröße	Trainings-Batch	8-16
Epochen	Trainingsiterationen	200-500
Speichern alle	Checkpoint-Häufigkeit	20-50
f0-Methode	Tonhöhenermittlung	rmvpe

F0-Methoden

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

Echtzeit-Konvertierung

Einrichtung

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

# Echtzeit-Schleife
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

import torch

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

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

Audio-Vorverarbeitung

Rauschen entfernen

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

from pydub import AudioSegment

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

Stille entfernen

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

Stapelverarbeitung

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

Stimmenkonvertierung beim Singen

Für Songs die passenden Einstellungen verwenden:

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, damit sie passt
    protect=0.5         # Konsonanten schützen
)

Häufige Probleme

Stimme klingt roboterhaft

• Verwende Quellaudio höherer Qualität

• Erhöhe den protect-Wert (0.4-0.5)

• Versuche eine andere f0-Methode

Tonhöhenprobleme

• f0_up_key anpassen

• Verwende die rmvpe-f0-Methode

• Achte auf konsistente Tonhöhe in den Trainingsdaten

Audioqualität

• Verwende 48 kHz Abtastrate

• Entferne Hintergrundgeräusche aus den Trainingsdaten

• Trainiere über mehr Epochen

API-Server

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

• Verwende 20+ Minuten sauberes Audio

• Entferne alle Hintergrundgeräusche

• Einheitliches Mikrofon-/Aufnahme-Setup

• Verschiedene Ausdrücke/Emotionen einbeziehen

Für schnelleres Training

• Verwende eine Batchgröße von 8-16

• Aktiviere Mixed Precision

• Verwende eine NVMe-SSD für den Datensatz

Leistung

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

Fehlerbehebung

Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise (Stand 2024):

GPU	Stundensatz	Tagessatz	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

Die Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie CLORE.AI-Marktplatz die aktuellen Preise.

Sparen Sie Geld:

• Nutzen Sie den Spot Markt für unterbrechbare Arbeit — etwa ein Drittel der Server bietet Spot-Preise unter On-Demand (Median ca. 13 % Rabatt), der Rest ist gleich teuer

• Bezahlen Sie mit CLORE Token

• Preise verschiedener Anbieter vergleichen

Nächste Schritte

• Bark TTS - Text-zu-Sprache

• AudioCraft Music - Musikerzeugung

• Whisper-Transkription - Sprache-zu-Text