OpenVoice

Kopiere jede Stimme mit wenigen Sekunden Audio mit OpenVoice auf Clore.ai

Klonen Sie jede Stimme mit nur wenigen Sekunden Audio mit OpenVoice.

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

Mieten auf CLORE.AI

1. Besuchen CLORE.AI-Marktplatz

2. Filtern nach GPU-Typ, VRAM und Preis

3. Wähle 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)

   • Bei Bedarf Umgebungsvariablen hinzufügen

   • Startbefehl eingeben

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

6. Bestellung erstellen und auf die Bereitstellung warten

Greife auf deinen Server zu

• Verbindungsdetails finden in Meine Bestellungen

• Web-Oberflächen: Verwende die HTTP-Port-URL

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

Was ist OpenVoice?

OpenVoice von MyShell kann:

• Stimmen aus ~10 Sekunden Audio klonen

• Emotion, Akzent und Rhythmus steuern

• Sprachenübergreifendes Stimmklonen

• Zero-Shot-Stimmenkonvertierung

Anforderungen

Aufgabe	Min. VRAM	Empfohlen
Inferenz	4 GB	RTX 3060
Stapelverarbeitung	6 GB	RTX 3070

Schnell bereitstellen

Docker-Image:

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

Ports:

22/tcp
7860/http

Befehl:

pip install git+https://github.com/myshell-ai/OpenVoice.git gradio && \\
python -c "
import gradio as gr
from openvoice import se_extractor
from openvoice.api import ToneColorConverter
import torch

ckpt_converter = 'checkpoints_v2/converter'
device = 'cuda'
tone_color_converter = ToneColorConverter(f'{ckpt_converter}/config.json', device=device)
tone_color_converter.load_ckpt(f'{ckpt_converter}/checkpoint.pth')

def clone(source_audio, reference_audio):
    source_se, _ = se_extractor.get_se(source_audio, tone_color_converter, vad=False)
    target_se, _ = se_extractor.get_se(reference_audio, tone_color_converter, vad=False)

    output_path = 'output.wav'
    tone_color_converter.convert(
        audio_src_path=source_audio,
        src_se=source_se,
        tgt_se=target_se,
        output_path=output_path
    )
    return output_path

demo = gr.Interface(
    fn=clone,
    inputs=[gr.Audio(type='filepath', label='Quelle'), gr.Audio(type='filepath', label='Zielstimme')],
    outputs=gr.Audio(label='Geklont'),
    title='OpenVoice-Klon'
)
demo.launch(server_name='0.0.0.0', server_port=7860)
"

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

git clone https://github.com/myshell-ai/OpenVoice.git
cd OpenVoice
pip install -e .

# Checkpoints herunterladen
python -c "from huggingface_hub import snapshot_download; snapshot_download(repo_id='myshell-ai/OpenVoice', local_dir='checkpoints')"

Grundlegendes Stimmklonen

from openvoice import se_extractor
from openvoice.api import ToneColorConverter
import torch

# Initialisieren
device = "cuda" if torch.cuda.is_available() else "cpu"
ckpt_converter = 'checkpoints_v2/converter'

tone_color_converter = ToneColorConverter(
    f'{ckpt_converter}/config.json',
    device=device
)
tone_color_converter.load_ckpt(f'{ckpt_converter}/checkpoint.pth')

# Sprecher-Embeddings extrahieren
source_se, _ = se_extractor.get_se("source_audio.wav", tone_color_converter, vad=False)
target_se, _ = se_extractor.get_se("target_voice.wav", tone_color_converter, vad=False)

# Stimme konvertieren
tone_color_converter.convert(
    audio_src_path="source_audio.wav",
    src_se=source_se,
    tgt_se=target_se,
    output_path="output.wav"
)

Mit Text-to-Speech

Erzeugen Sie Sprache in jeder Stimme:

from openvoice import se_extractor
from openvoice.api import ToneColorConverter, BaseSpeakerTTS
from melo.api import TTS

# TTS initialisieren
tts = TTS(language='EN', device=device)
speaker_ids = tts.hps.data.spk2id

# Basissprache erzeugen
tts.tts_to_file("Hallo, dies ist ein Test.", speaker_ids['EN-US'], "base.wav")

# In Zielstimme klonen
source_se, _ = se_extractor.get_se("base.wav", tone_color_converter, vad=False)
target_se, _ = se_extractor.get_se("target_voice.wav", tone_color_converter, vad=False)

tone_color_converter.convert(
    audio_src_path="base.wav",
    src_se=source_se,
    tgt_se=target_se,
    output_path="cloned_speech.wav"
)

Unterstützung für mehrere Sprachen

from melo.api import TTS

# Verfügbare Sprachen
languages = ['EN', 'ES', 'FR', 'ZH', 'JP', 'KR']

# Englisch
tts_en = TTS(language='EN', device=device)
tts_en.tts_to_file("Hallo Welt", tts_en.hps.data.spk2id['EN-US'], "en.wav")

# Chinesisch
tts_zh = TTS(language='ZH', device=device)
tts_zh.tts_to_file("你好世界", tts_zh.hps.data.spk2id['ZH'], "zh.wav")

# Japanisch
tts_jp = TTS(language='JP', device=device)
tts_jp.tts_to_file("こんにちは", tts_jp.hps.data.spk2id['JP'], "jp.wav")

Emotionssteuerung

OpenVoice V2 unterstützt Emotions-/Stilsteuerung:

from openvoice.api import BaseSpeakerTTS

# Basis-TTS mit Stilen
base_speaker_tts = BaseSpeakerTTS(
    f'{ckpt_base}/config.json',
    device=device
)
base_speaker_tts.load_ckpt(f'{ckpt_base}/checkpoint.pth')

# Verfügbare Stile
styles = ['default', 'whispering', 'cheerful', 'terrified', 'angry', 'sad', 'friendly']

for style in styles:
    base_speaker_tts.tts(
        "Dies ist ein Testsatz.",
        f"output_{style}.wav",
        speaker='default',
        language='Englisch',
        style=style
    )

Batch-Verarbeitung

import os
from openvoice import se_extractor
from openvoice.api import ToneColorConverter

tone_color_converter = ToneColorConverter(
    f'{ckpt_converter}/config.json',
    device='cuda'
)
tone_color_converter.load_ckpt(f'{ckpt_converter}/checkpoint.pth')

# Zielstimmen-Embedding einmal abrufen
target_se, _ = se_extractor.get_se("target_voice.wav", tone_color_converter, vad=False)

input_dir = "./audio_files"
output_dir = "./cloned"
os.makedirs(output_dir, exist_ok=True)

for filename in os.listdir(input_dir):
    if filename.endswith(('.wav', '.mp3')):
        input_path = os.path.join(input_dir, filename)
        output_path = os.path.join(output_dir, f"cloned_{filename}")

        source_se, _ = se_extractor.get_se(input_path, tone_color_converter, vad=False)

        tone_color_converter.convert(
            audio_src_path=input_path,
            src_se=source_se,
            tgt_se=target_se,
            output_path=output_path
        )
        print(f"Geklont: {filename}")

API-Server

from fastapi import FastAPI, UploadFile
from fastapi.responses import FileResponse
from openvoice import se_extractor
from openvoice.api import ToneColorConverter
import tempfile
import shutil

app = FastAPI()

tone_color_converter = ToneColorConverter(
    'checkpoints_v2/converter/config.json',
    device='cuda'
)
tone_color_converter.load_ckpt('checkpoints_v2/converter/checkpoint.pth')

@app.post("/clone")
async def clone_voice(source: UploadFile, target: UploadFile):
    # Hochgeladene Dateien speichern
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as src_tmp:
        shutil.copyfileobj(source.file, src_tmp)
        src_path = src_tmp.name

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tgt_tmp:
        shutil.copyfileobj(target.file, tgt_tmp)
        tgt_path = tgt_tmp.name

    # Embeddings extrahieren
    source_se, _ = se_extractor.get_se(src_path, tone_color_converter, vad=False)
    target_se, _ = se_extractor.get_se(tgt_path, tone_color_converter, vad=False)

    # Konvertieren
    output_path = tempfile.mktemp(suffix=".wav")
    tone_color_converter.convert(
        audio_src_path=src_path,
        src_se=source_se,
        tgt_se=target_se,
        output_path=output_path
    )

    return FileResponse(output_path, media_type="audio/wav")

# Ausführen: uvicorn server:app --host 0.0.0.0 --port 8000

Qualitätstipps

Für beste Ergebnisse

• Verwenden Sie 10–30 Sekunden klares Referenz-Audio

• Hintergrundgeräusche vermeiden

• In der Referenz nur einen Sprecher verwenden

• Sprechtempo ungefähr anpassen

Audio-Vorverarbeitung

import librosa
import soundfile as sf

def preprocess_audio(input_path, output_path, target_sr=22050):
    audio, sr = librosa.load(input_path, sr=target_sr)

    # Stille kürzen
    audio, _ = librosa.effects.trim(audio, top_db=20)

    # Normalisieren
    audio = librosa.util.normalize(audio)

    sf.write(output_path, audio, target_sr)
    return output_path

preprocess_audio("raw_reference.wav", "clean_reference.wav")

Vergleich mit anderen Tools

Funktion	OpenVoice	RVC	Bark
Referenz-Audio	10–30 s	10+ Min.	k. A.
Training	Nicht erforderlich	Erforderlich	k. A.
Geschwindigkeit	Schnell	Mittel	Langsam
Qualität	Großartig	Am besten	Gut
Mehrsprachig	Ja	Begrenzt	Ja

Leistung

Aufgabe	GPU	Zeit
Embedding extrahieren	RTX 3090	~1 s
10 s Audio konvertieren	RTX 3090	~2s
1 Min. Audio konvertieren	RTX 3090	~8s

Fehlerbehebung

Schlechte Übereinstimmung der Stimme

• Längeres Referenz-Audio verwenden

• Für klare Audioqualität sorgen

• Auf Hintergrundgeräusche prüfen

Audio-Artefakte

• Geschwindigkeits-/Betonungseinstellungen reduzieren

• Einheitliches Audioformat verwenden

• Abgleich der Abtastrate prüfen

Speicher erschöpft

• Kürzere Clips verarbeiten

• Batch-Größe reduzieren

• CUDA-Cache leeren

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 für aktuelle Preise.

Geld sparen:

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

• Bezahlen Sie mit CLORE Tokens

• Vergleichen Sie Preise zwischen verschiedenen Anbietern

Nächste Schritte

• Bark TTS - Text-zu-Sprache

• RVC-Sprachklon - Trainingbasiertes Klonen

• Whisper-Transkription - Sprache-zu-Text