RVC Voice Clone

Klonen und konvertieren Sie Stimmen mit RVC auf Clore.ai-GPUs

Stimmen klonen und umwandeln mit Retrieval-basierter Sprachkonvertierung.

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

Mieten auf CLORE.AI

Besuchen CLORE.AI Marktplatz
Nach GPU-Typ, VRAM und Preis filtern
Wählen On-Demand (Festpreis) oder Spot (Gebotspreis)
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
Zahlung auswählen: CLORE, BTC, oder USDT/USDC
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

Schnelle Bereitstellung

Docker-Image:

pytorch/pytorch:2.5.1-cuda12.4-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

Zugriff auf Ihren Dienst

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

Gehen Sie zur Meine Bestellungen Seite
Klicken Sie auf Ihre Bestellung
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


# 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

Öffnen http://<proxy>:7865
Gehen Sie zum Reiter "Model Inference"
Audio-Datei hochladen
Stimmenmodell auswählen
Einstellungen anpassen
Auf "Convert" klicken

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

10–30 Minuten sauberes Audio sammeln
In 5–15 Sekunden lange Clips schneiden
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 Web UI

Gehen Sie zum Reiter "Train"
Experimentnamen eingeben
Pfad des Trainingsordners festlegen
Auf "Process data" klicken
Auf "Feature extraction" klicken
Auf "Train" klicken

Training über 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

F0-Methoden

Methode

Qualität

Geschwindigkeit

Am besten für

Schnell

Testen

harvest

Gut

Langsam

Allgemein

crepe

Großartig

Mittel

Gesang

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

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

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

Batch-Verarbeitung

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:

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

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 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 - Text-zu-Sprache
AudioCraft Music - Musikgenerierung
Whisper Transcription - Sprache-zu-Text

VorherigeOpenVoice NächsteDemucs Separation

Zuletzt aktualisiert vor 1 Monat

War das hilfreich?

hashtagMieten auf CLORE.AI

hashtagZugriff auf Ihren Server

hashtagWas ist RVC?

hashtagAnforderungen

hashtagSchnelle Bereitstellung

hashtagZugriff auf Ihren Dienst

hashtagInstallation

hashtagSprachkonvertierung (Inference)

hashtagVerwendung der Web-Oberfläche

hashtagPython-API

hashtagEigene Stimme trainieren

hashtagDatensatz vorbereiten

hashtagTraining über Web UI

hashtagTraining über Kommandozeile

hashtagTrainingsparameter

hashtagF0-Methoden

hashtagEchtzeit-Konvertierung

hashtagEinrichtung

hashtagModellformate

hashtagIn ONNX konvertieren

hashtagAudio-Vorverarbeitung

hashtagRauschreduzierung

hashtagLautstärke normalisieren

hashtagStille entfernen

hashtagBatch-Verarbeitung

hashtagGesangs-Stimmenkonvertierung

hashtagHäufige Probleme

hashtagStimme klingt robotic

hashtagTonhöhen-Probleme

hashtagAudio-Qualität

hashtagAPI-Server

hashtagTrainingstipps

hashtagFür bessere Qualität

hashtagFür schnelleres Training

hashtagLeistung

hashtagFehlerbehebung

hashtagKostenabschätzung

hashtagNächste Schritte

Mieten auf CLORE.AI

Zugriff auf Ihren Server

Was ist RVC?

Anforderungen

Schnelle Bereitstellung

Zugriff auf Ihren Dienst

Installation

Sprachkonvertierung (Inference)

Verwendung der Web-Oberfläche

Python-API

Eigene Stimme trainieren

Datensatz vorbereiten

Training über Web UI

Training über Kommandozeile

Trainingsparameter

F0-Methoden

Echtzeit-Konvertierung

Einrichtung

Modellformate

In ONNX konvertieren

Audio-Vorverarbeitung

Rauschreduzierung

Lautstärke normalisieren

Stille entfernen

Batch-Verarbeitung

Gesangs-Stimmenkonvertierung

Häufige Probleme

Stimme klingt robotic

Tonhöhen-Probleme

Audio-Qualität

API-Server

Trainingstipps

Für bessere Qualität

Für schnelleres Training

Leistung

Fehlerbehebung

Kostenabschätzung

Nächste Schritte