Orpheus-TTS : un outil de synthèse vocale pour générer un discours chinois naturel

Dernières ressources sur l'IAPosté il y a 5 mois Cercle de partage de l'IA

Introduction générale

Orpheus-TTS est un système de synthèse vocale open source développé sur l'architecture Llama-3b, dont l'objectif est de générer un son proche de la parole humaine naturelle. Il a été lancé par l'équipe Canopy AI et prend en charge plusieurs langues telles que l'anglais, l'espagnol, le français, l'allemand, l'italien, le portugais et le chinois. Le système génère de la parole avec intonation, émotion et rythme à partir d'un texte, et prend en charge les expressions non verbales telles que le rire et les soupirs, ce qui le rend adapté aux conversations en temps réel, à la production de livres audio et au développement d'assistants intelligents.Orpheus-TTS fournit des modèles pré-entraînés et affinés, permettant aux développeurs de personnaliser la parole ou la langue en fonction de leurs besoins.

Liste des fonctions

La génération d'une parole quasi-humaine : transformer un texte en audio avec une intonation, une émotion et un rythme naturels surpasse les modèles à source partiellement fermée.
Clonage de la parole à zéro échantillon : imite le timbre de la parole cible sans formation supplémentaire.
Contrôle des émotions et de l'intonation : par l'étiquetage (par ex. <laugh>,<sigh>) Ajuster l'expression de la voix pour améliorer le réalisme.
Flux de sortie à faible latence : latence de génération de la parole en temps réel d'environ 200 ms, optimisée à 100 ms.
Prise en charge multilingue : anglais, espagnol, français, allemand, italien, portugais, chinois et autres langues.
Ajustement du modèle : des scripts de traitement des données et des ensembles de données d'exemple sont fournis pour aider les développeurs à personnaliser les styles vocaux ou les langues.
Exécution locale et dans le nuage : Prise en charge via LM Studio, llama.cpp ou vLLM Exécution locale ou dans le nuage.
Filigrane audio : protégez les droits d'auteur en filigranant les fichiers audio générés à l'aide de la technologie Silent Cipher.

Utiliser l'aide

Processus d'installation

Orpheus-TTS nécessite un environnement Python et un support matériel de base (GPU recommandé). Voici les étapes détaillées de l'installation :

Clonage de la base de code
Téléchargez le projet Orpheus-TTS en utilisant Git :
```
git clone https://github.com/canopyai/Orpheus-TTS.git
cd Orpheus-TTS
```
Installation des dépendances
Installation des paquets de base orpheus-speechIl s'appuie sur la vLLM pour un raisonnement rapide :
```
pip install orpheus-speech
```
Note : La version 18 mars 2025 de vLLM peut présenter des bogues et il est recommandé d'installer la version stable :
```
pip install vllm==0.7.3
```
Les autres dépendances sont les suivantes transformers,datasets répondre en chantant torchL'installation peut être effectuée sur demande :
```
pip install transformers datasets torch
```
Vérifier la configuration matérielle requise
- Version de Python : 3.8-3.11 (la version 3.12 n'est pas prise en charge).
- GPU : le pilote NVIDIA CUDA est recommandé, avec plus de 12 Go de mémoire vidéo pour garantir un fonctionnement fluide.
- CPU : prise en charge par orpheus-cpp mais avec des performances moindres pour les tests plus légers.
- Réseau : la première exécution nécessite le téléchargement du modèle, une connexion internet stable est recommandée.
Télécharger les modèles
Orpheus-TTS propose les modèles suivants hébergés sur Hugging Face :
- Affiner le modèle (canopylabs/orpheus-tts-0.1-finetune-prod) : convient pour les tâches quotidiennes de génération vocale.
- Modèles pré-entraînés (canopylabs/orpheus-tts-0.1-pretrained) : basé sur 100 000 heures de formation aux données vocales anglaises, il convient aux tâches avancées telles que le clonage de la parole.
- Modélisation multilingue (canopylabs/orpheus-multilingual-research-release) : contient 7 ensembles de modèles pré-entraînés et affinés pour soutenir les études multilingues.
  Méthode de téléchargement :
```
huggingface-cli download canopylabs/orpheus-tts-0.1-finetune-prod
```

test d'installation
Exécutez le script Python suivant pour vérifier que l'installation a réussi :

from orpheus_tts import OrpheusModel
model = OrpheusModel(model_name="canopylabs/orpheus-tts-0.1-finetune-prod")
prompt = "tara: 你好，这是一个测试！"
audio = model.generate_speech(prompt)
with wave.open("test_output.wav", "wb") as file:
file.setnchannels(1)
file.setsampwidth(2)
file.setframerate(24000)
file.writeframes(audio)

Après une exécution réussie, un fichier WAV contenant la voix du texte saisi est généré.

Principales fonctions

1. la génération d'une parole quasi humaine

La fonction principale d'Orpheus-TTS est de convertir le texte en un son proche de la parole humaine naturelle. Le système prend en charge une large gamme de caractères vocaux, dans le modèle de la langue anglaise tara le sens le plus naturel de la parole, les autres personnages comprennent leah,jess,leo,dan,mia,zac répondre en chantant zoe. Les rôles du modèle multilingue doivent se référer à la documentation officielle. La procédure :

Préparer des messages-guides au format {角色名}: {文本}Par exemple tara: 你好，今天天气很好！.

Appeler la fonction de génération :

audio = model.generate_speech(prompt="tara: 你好，今天天气很好！")

La sortie est un son au format WAV avec une fréquence d'échantillonnage de 24000 Hz en mono.

2. contrôle des émotions et de la tonalité

Les utilisateurs peuvent contrôler l'expression émotionnelle de la voix à l'aide de balises afin d'améliorer le réalisme de la voix. Les balises prises en charge sont les suivantes :

<laugh>: Rires.
<sigh>: Soupir.
<cough>: Toux.
<sniffle>Les enfants de moins de 18 ans : reniflements.
<groan>:groan.
<yawn>: Baillez.
<gasp>: Surprise.
Exemple :

prompt = "tara: 这个消息太震撼了！<gasp> 你听说了吗？"
audio = model.generate_speech(prompt)

L'audio généré inclura des effets de surprise aux endroits appropriés. Voir la documentation de Hugging Face pour la prise en charge de la balise de modèle multilingue.

3. clonage vocal à zéro échantillon

Orpheus-TTS prend en charge le clonage de la parole à zéro échantillon, ce qui permet d'imiter directement la parole cible sans pré-entraînement. Étapes de l'opération :

Préparez un fichier WAV du discours cible d'une durée recommandée de 10 à 30 secondes et d'une fréquence d'échantillonnage de 24 000 Hz.

Utilisez le script suivant :

audio_ref = "path/to/reference.wav"
prompt = "tara: 这段话会模仿你的声音！"
audio = model.generate_with_voice_clone(prompt, audio_ref)

Le son de sortie sera proche du timbre de la parole de référence. Le modèle pré-entraîné est plus performant dans la tâche de clonage.

4. sortie en flux continu à faible latence

Orpheus-TTS permet de générer de la parole en continu pour des scénarios de dialogue en temps réel, avec une latence d'environ 200 ms, optimisée à 100 ms. exemple opérationnel :

from flask import Flask, Response
from orpheus_tts import OrpheusModel
app = Flask(__name__)
[1]
model = OrpheusModel(model_name="canopylabs/orpheus-tts-0.1-finetune-prod")
@app.route("/stream")
def stream_audio():
def generate():
prompt = "tara: 这是实时语音测试！"
for chunk in model.stream_generate(prompt):
yield chunk
return Response(generate(), mimetype="audio/wav")

Après avoir lancé le service Flask, accédez à la page http://localhost:5000/stream La voix en temps réel peut être entendue. L'optimisation de la latence nécessite l'activation de la mise en cache KV et du streaming d'entrée.

5. la mise au point du modèle

Les développeurs peuvent affiner le modèle pour prendre en charge de nouvelles langues ou de nouveaux styles de discours. Les étapes sont les suivantes :

Préparer l'ensemble de données : se référer à l'exemple de l'ensemble de données "Hugging Face" pour le format (canopylabs/zac-sample-dataset). Il est recommandé d'inclure de 50 à 300 échantillons/caractères, 300 échantillons pour de meilleurs résultats.
Prétraitement des données : utilisation des carnets Colab officiellement fournis (1wg_CPCA-MzsWtsujwy-1Ovhv-tn8Q1nDLes données sont traitées en environ 1 minute par millier d'entrées.
Formation à la configuration : modifications finetune/config.yaml, définir le chemin d'accès au jeu de données et les paramètres.

Entraînement à la course à pied :

huggingface-cli login
wandb login
accelerate launch train.py

Le modèle affiné peut être utilisé pour des tâches spécifiques telles que l'optimisation de la parole en chinois.

6. filigrane audio

Orpheus-TTS prend en charge le filigrane audio avec la technologie Silent Cipher pour la protection des droits d'auteur. Mode de fonctionnement :

Se référer au script de mise en œuvre officiel (additional_inference_options/watermark_audio).

Exemple :

from orpheus_tts import add_watermark
audio = model.generate_speech(prompt)
watermarked_audio = add_watermark(audio, watermark_id="user123")

7. pas de raisonnement GPU

Les utilisateurs ne disposant pas d'un GPU peuvent utiliser la fonction orpheus-cpp Exécution sur une unité centrale, étape par étape :

montage llama.cpp L'environnement.
Se référer à la documentation officielle (additional_inference_options/no_gpu/README.md).
Performances inférieures à celles des GPU pour les tâches plus légères.

mise en garde

Sélection du modèleLes modèles finement ajustés conviennent aux tâches quotidiennes et les modèles pré-entraînés conviennent aux tâches avancées telles que le clonage de la parole.
limitation du matérielLa mémoire vidéo peut être insuffisante si elle est inférieure à 12 Go. Il est recommandé de vérifier la configuration matérielle.
Prise en charge multilingueLes langues autres que l'anglais doivent se référer à la documentation du modèle multilingue, certaines langues peuvent nécessiter des ajustements.
ajuster les composants pendant les essaisSi vLLM signale une erreur (par ex. vllm._C), essayez une autre version ou vérifiez la compatibilité avec CUDA.

Fonctions complémentaires : extension communautaire

La nature open source d'Orpheus-TTS a attiré les contributions de la communauté, et l'implémentation suivante (qui n'a pas été entièrement vérifiée) est officiellement recommandée :

LM Studio Local ClientLancement d'Orpheus-TTS via l'API LM Studio (isaiahbjork/orpheus-tts-local).
FastAPI compatible avec Open AI: Fournit une interface API de type Open AI (Lex-au/Orpheus-FastAPI).
Gradio WebUIL'interface web WSL et CUDA (Saganaki22/OrpheusTTS-WebUI).
Espace d'étreinte: Une expérience en ligne construite par l'utilisateur de la communauté MohamedRashad (MohamedRashad/Orpheus-TTS).

scénario d'application

Robot intelligent de service à la clientèle
Orpheus-TTS génère une parole naturelle pour les systèmes de service à la clientèle, permettant un dialogue en temps réel et l'expression d'émotions pour améliorer l'expérience de l'utilisateur.
Par exemple, les plateformes de commerce électronique peuvent intégrer Orpheus-TTS pour ajouter un ton amical lorsqu'elles répondent aux demandes des clients.
Production de livres audio et de podcasts
Les éditeurs peuvent transformer des romans ou des articles en livres audio, ce qui permet d'étiqueter plusieurs personnages et émotions et de réduire les coûts liés aux voix off.
Les créateurs de podcasts peuvent créer des lignes d'ouverture dynamiques pour accroître l'attrait de leur émission.
Outils d'apprentissage des langues
L'application éducative génère des sons standard pour aider les élèves à s'entraîner à écouter et à parler.
Par exemple, les apprenants chinois peuvent utiliser le modèle chinois pour s'entraîner à la prononciation du mandarin.
Voix off d'un personnage de jeu
Les développeurs de jeux peuvent générer des dialogues dynamiques pour les PNJ, en prenant en charge le multilinguisme et l'expression des émotions pour une meilleure immersion.
Par exemple, les jeux de rôle peuvent générer des tonalités uniques pour différents personnages.
Aides à l'accessibilité
Orpheus-TTS fournit une aide à la lecture en temps réel pour les utilisateurs malvoyants en convertissant le texte en parole.
Par exemple, l'intégration dans un lecteur de livres électroniques pour lire de longs articles à haute voix.

QA

Quelles sont les langues supportées par Orpheus-TTS ?
L'anglais, l'espagnol, le français, l'allemand, l'italien, le portugais et le chinois sont pris en charge. Le modèle multilingue couvre davantage de langues, comme décrit dans la documentation Hugging Face.
Comment optimiser la latence de la voix en temps réel ?
Activez la mise en cache KV et le streaming d'entrée pour réduire la latence de 200 ms à 100 ms. Assurez-vous que les performances du GPU sont suffisantes avec au moins 12 Go de mémoire vidéo.
Quelle préparation est nécessaire pour le clonage de la voix de l'échantillon zéro ?
Fournit 10 à 30 secondes d'audio de référence au format WAV avec un taux d'échantillonnage de 24000 Hz pour un meilleur pré-entraînement du modèle.
L'unité centrale peut-elle faire fonctionner Orpheus-TTS ?
Oui, utiliser orpheus-cppLes GPU ne sont pas aussi puissants, mais leurs performances sont inférieures à celles des GPU, ce qui les rend adaptés aux tests ou aux tâches légères.
Comment ajouter un filigrane à mon fichier audio ?
Grâce à la technologie du chiffrement silencieux, les appels add_watermark vous devez vous référer au script officiel pour la mettre en œuvre.
Combien de données sont nécessaires pour le réglage fin ?
50 échantillons pour les premiers résultats, 300 échantillons/caractère pour une meilleure qualité. Les données doivent être au format "Hugging Face".