OpenVoice

Clonez n'importe quelle voix avec quelques secondes d'audio grâce à OpenVoice sur Clore.ai

Clonez n'importe quelle voix avec seulement quelques secondes d'audio grâce à OpenVoice.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Louer sur CLORE.AI

1. Visitez la place de marché CLORE.AI

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édez à 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 qu'OpenVoice ?

OpenVoice de MyShell peut :

• Cloner des voix à partir d'environ 10 secondes d'audio

• Contrôler l'émotion, l'accent et le rythme

• Clonage vocal multilingue

• Conversion vocale zéro-shot

Exigences

Tâche	VRAM minimale	Recommandé
Inférence	4 Go	RTX 3060
Traitement par lot	6 Go	RTX 3070

Déploiement rapide

Image Docker :

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

Ports :

22/tcp
7860/http

Commande :

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='Source'), gr.Audio(type='filepath', label='Voix cible')],
    outputs=gr.Audio(label='Cloné'),
    title='Clonage OpenVoice'
)
demo.launch(server_name='0.0.0.0', server_port=7860)
"

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

1. Accédez à Mes commandes la page

2. Cliquez sur votre commande

3. Trouvez le http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://YOUR_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Installation

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

# Télécharger les points de contrôle
python -c "from huggingface_hub import snapshot_download; snapshot_download(repo_id='myshell-ai/OpenVoice', local_dir='checkpoints')"

Clonage vocal de base

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

# Initialisation
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')

# Extraire les embeddings du locuteur
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)

# Convertir la voix
tone_color_converter.convert(
    audio_src_path="source_audio.wav",
    src_se=source_se,
    tgt_se=target_se,
    output_path="output.wav"
)

Avec la synthèse vocale

Générez de la parole dans n'importe quelle voix :

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

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

# Générer la voix de base
tts.tts_to_file("Bonjour, ceci est un test.", speaker_ids['EN-US'], "base.wav")

# Cloner vers la voix cible
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"
)

Prise en charge multilingue

from melo.api import TTS

# Langues disponibles
languages = ['EN', 'ES', 'FR', 'ZH', 'JP', 'KR']

# Anglais
tts_en = TTS(language='EN', device=device)
tts_en.tts_to_file("Hello world", tts_en.hps.data.spk2id['EN-US'], "en.wav")

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

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

Contrôle des émotions

OpenVoice V2 prend en charge le contrôle des émotions et du style :

from openvoice.api import BaseSpeakerTTS

# TTS de base avec des styles
base_speaker_tts = BaseSpeakerTTS(
    f'{ckpt_base}/config.json',
    device=device
)
base_speaker_tts.load_ckpt(f'{ckpt_base}/checkpoint.pth')

# Styles disponibles
styles = ['par défaut', 'chuchotement', 'joyeux', 'terrorisé', 'en colère', 'triste', 'amical']

for style in styles:
    base_speaker_tts.tts(
        "Ceci est une phrase de test.",
        f"output_{style}.wav",
        speaker='par défaut',
        language='Anglais',
        style=style
    )

Traitement par lots

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

# Obtenir une fois l'embedding de la voix cible
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"Cloné : {filename}")

Serveur API

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):
    # Enregistrer les fichiers téléversés
    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

    # Extraire les embeddings
    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)

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

# Exécuter : uvicorn server:app --host 0.0.0.0 --port 8000

Conseils de qualité

Pour de meilleurs résultats

• Utilisez 10 à 30 secondes d'audio de référence clair

• Évitez le bruit de fond

• Un seul locuteur dans la référence

• Faites correspondre approximativement le débit de parole

Prétraitement audio

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)

    # Couper le silence
    audio, _ = librosa.effects.trim(audio, top_db=20)

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

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

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

Comparaison avec d'autres outils

Fonctionnalité	OpenVoice	RVC	Bark
Audio de référence	10 à 30 s	10 min et plus	N/A
Entraînement	Non nécessaire	Requis	N/A
Vitesse	Rapide	Moyen	Lent
Qualité	Excellent	Meilleur	Bon
Multilingue	Oui	Limité	Oui

Performances

Tâche	GPU	Temps
Extraire l'embedding	RTX 3090	~1 s
Convertir 10 s d'audio	RTX 3090	~2 s
Convertir 1 min d'audio	RTX 3090	~8 s

Dépannage

Mauvaise correspondance de la voix

• Utiliser un audio de référence plus long

• Assurez-vous d'une qualité audio claire

• Vérifier le bruit de fond

Artefacts audio

• Réduire les réglages de vitesse et d'emphase

• Utiliser un format audio cohérent

• Vérifier la correspondance du taux d'échantillonnage

Mémoire insuffisante

• Traiter des extraits plus courts

• Réduire la taille du lot

• Vider le cache CUDA

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. Vérifiez la place de marché CLORE.AI les tarifs actuels.

Économisez de l'argent :

• Utilisez le Spot marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane ~13 % de remise), les autres s'alignent dessus

• Payez avec CLORE jetons

• Comparez les prix entre différents fournisseurs

Étapes suivantes

• Bark TTS - Synthèse vocale

• Clonage vocal RVC - Clonage basé sur l'entraînement

• Whisper Transcription - Reconnaissance vocale