> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/styletss2.md). # StyleTTS2 StyleTTS2 obtient des scores de naturel évalués par des humains supérieurs aux enregistrements de référence sur les benchmarks LJSpeech et LibriTTS (MOS 4,55 contre 4,23 pour la vérité terrain). Il utilise **diffusion de style** et **entraînement adversarial** pour modéliser les styles de parole comme une distribution de variables latentes, permettant une synthèse expressive et une adaptation de locuteur en zero-shot à partir d'un court extrait de référence. Contrairement aux systèmes TTS traditionnels, StyleTTS2 peut généraliser à des locuteurs inconnus avec un court extrait audio de référence, produisant une parole rivalisant avec des acteurs vocaux professionnels. Il a été évalué et dépasse les scores de naturel évalués par des humains sur plusieurs jeux de données — une première pour un TTS open-source. Principales fonctionnalités : * **Naturel au niveau humain** — dépasse les scores MOS humains sur LJSpeech * **Adaptation de locuteur zero-shot** — cloner n'importe quelle voix à partir d'un court échantillon audio * **Diffusion de style** — prosodie et style de parole expressifs et variés * **Support multi-locuteurs** — entraîné sur LibriTTS (2 300+ locuteurs) * **Inférence légère** — fonctionne efficacement sur des GPU grand public {% hint style="success" %} Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace). {% endhint %} *** ## Exigences serveur | Paramètre | Minimum | Recommandé | | --------- | ---------------------- | ----------------------- | | GPU | NVIDIA RTX 3070 (8 Go) | NVIDIA RTX 4090 (24 Go) | | VRAM | 6 Go | 12–24 Go | | RAM | 16 Go | 32 Go | | CPU | 4 cœurs | 8+ cœurs | | Disque | 15 Go | 30 Go | | OS | Ubuntu 20.04+ | Ubuntu 22.04 | | CUDA | 11.7+ | 12.1+ | | Python | 3.8+ | 3.10 | | Ports | 22, 7860 | 22, 7860 | {% hint style="info" %} StyleTTS2 est relativement léger — une RTX 3070 ou 3080 gère confortablement l'inférence en temps réel. Pour le traitement par lots ou le service d'utilisateurs concurrents, utilisez une 4090 ou une A100. {% endhint %} *** ## Déploiement rapide sur CLORE.AI StyleTTS2 nécessite une construction Docker personnalisée car il n'existe pas d'image préconstruite officielle. La configuration prend \~10 minutes. ### 1. Trouvez un serveur adapté Aller à [CLORE.AI Marketplace](https://clore.ai/marketplace) et filtrez par : * **VRAM**: ≥ 6 Go * **GPU**: RTX 3070, 3080, 3090, 4080, 4090, A100 * **Disque**: ≥ 20 Go ### 2. Configurez votre déploiement **Image Docker (base) :** ``` nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04 ``` **Mappages de ports :** ``` 22 → Accès SSH 7860 → Interface Web Gradio ``` **Commande de démarrage :** ```bash bash -c "apt-get update && apt-get install -y git python3 python3-pip ffmpeg espeak-ng && \ git clone https://github.com/yl4579/StyleTTS2 /workspace/StyleTTS2 && \ cd /workspace/StyleTTS2 && pip install -r requirements.txt && \ python app.py" ``` ### 3. Accédez à l'interface ``` http://:7860 ``` *** ## Configuration étape par étape ### Étape 1 : Connectez-vous en SSH à votre serveur ```bash ssh root@ -p ``` ### Étape 2 : Installez les dépendances système ```bash apt-get update && apt-get install -y \ git \ python3 \ python3-pip \ python3-venv \ ffmpeg \ espeak-ng \ libsndfile1 \ build-essential \ wget \ curl ``` ### Étape 3 : Clonez le dépôt StyleTTS2 ```bash cd /workspace git clone https://github.com/yl4579/StyleTTS2.git cd StyleTTS2 ``` ### Étape 4 : Créez un environnement virtuel Python ```bash python3 -m venv venv source venv/bin/activate pip install --upgrade pip ``` ### Étape 5 : Installez les dépendances ```bash pip install -r requirements.txt # Installer des dépendances supplémentaires si nécessaire pip install phonemizer gruut ``` ### Étape 6 : Téléchargez les modèles pré-entraînés ```bash # Télécharger le modèle LJSpeech (locuteur unique, haute qualité) mkdir -p Models/LJSpeech wget -O Models/LJSpeech/epoch_2nd_00100.pth \ "https://huggingface.co/yl4579/StyleTTS2-LJSpeech/resolve/main/Models/LJSpeech/epoch_2nd_00100.pth" wget -O Models/LJSpeech/config.yml \ "https://huggingface.co/yl4579/StyleTTS2-LJSpeech/resolve/main/Models/LJSpeech/config.yml" # Télécharger le modèle LibriTTS (multi-locuteurs, zero-shot) mkdir -p Models/LibriTTS wget -O Models/LibriTTS/epochs_2nd_00020.pth \ "https://huggingface.co/yl4579/StyleTTS2-LibriTTS/resolve/main/Models/LibriTTS/epochs_2nd_00020.pth" wget -O Models/LibriTTS/config.yml \ "https://huggingface.co/yl4579/StyleTTS2-LibriTTS/resolve/main/Models/LibriTTS/config.yml" ``` ### Étape 7 : Construisez et exécutez le Dockerfile ```bash # Créer le Dockerfile cat > Dockerfile << 'EOF' FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04 ENV DEBIAN_FRONTEND=noninteractive RUN apt-get update && apt-get install -y \ git python3 python3-pip python3-venv \ ffmpeg espeak-ng libsndfile1 build-essential wget curl \ && rm -rf /var/lib/apt/lists/* WORKDIR /workspace RUN git clone https://github.com/yl4579/StyleTTS2.git WORKDIR /workspace/StyleTTS2 RUN pip install --no-cache-dir -r requirements.txt EXPOSE 7860 CMD ["python3", "app.py", "--share"] EOF docker build -t styletts2:local . docker run -d --name styletts2 --gpus all \ -p 7860:7860 \ -v /workspace/models:/workspace/StyleTTS2/Models \ styletts2:local ``` ### Étape 8 : Lancez la démo Gradio directement ```bash source venv/bin/activate python app.py ``` Accéder à `http://:7860` *** ## Exemples d’utilisation ### Exemple 1 : TTS de base via l'API Python ```python import torch import soundfile as sf import numpy as np from models import * from utils import * import yaml # Charger la configuration config = yaml.safe_load(open("Models/LJSpeech/config.yml")) # Initialiser le modèle model = build_model(recursive_munch(config['model_params']), "cpu") params = torch.load("Models/LJSpeech/epoch_2nd_00100.pth", map_location='cpu') model = load_F0_models(model) # Passer sur GPU device = "cuda" if torch.cuda.is_available() else "cpu" for key in model: model[key] = model[key].to(device) print(f"Modèle chargé sur : {device}") print(f"VRAM utilisée : {torch.cuda.memory_allocated()/1e9:.2f} GB") ``` *** ### Exemple 2 : Clonage de voix Zero-Shot ```python import torch import torchaudio import soundfile as sf from inference import StyleTTS2Inference # Initialiser le moteur d'inférence tts = StyleTTS2Inference( model_path="Models/LibriTTS/epochs_2nd_00020.pth", config_path="Models/LibriTTS/config.yml", device="cuda" ) # Charger l'audio de référence (10–30 secondes fonctionne le mieux) reference_audio, sr = torchaudio.load("reference_voice.wav") # Générer la parole avec la voix de référence text = "Clore.ai fournit une infrastructure GPU puissante pour les applications d'IA, y compris la synthèse texte-parole." audio = tts.synthesize( text=text, reference_audio=reference_audio, reference_sr=sr, diffusion_steps=10, # Plus élevé = meilleure qualité, plus lent embedding_scale=1.5, # Contrôle la force du style alpha=0.3, # Poids du style acoustique beta=0.7, # Poids du style prosodique ) sf.write("cloned_voice_output.wav", audio, 24000) print("Sortie de voix clonée sauvegardée !") ``` *** ### Exemple 3 : Contrôle expressif du style ```python from inference import StyleTTS2Inference import soundfile as sf tts = StyleTTS2Inference( model_path="Models/LibriTTS/epochs_2nd_00020.pth", config_path="Models/LibriTTS/config.yml", device="cuda" ) text = "Bienvenue à notre présentation sur le calcul GPU avec Clore.ai." # Expérimentez avec différents paramètres de style style_configs = [ {"name": "neutral", "alpha": 0.3, "beta": 0.7, "diffusion_steps": 5}, {"name": "expressive", "alpha": 0.5, "beta": 0.9, "diffusion_steps": 15}, {"name": "fast", "alpha": 0.1, "beta": 0.3, "diffusion_steps": 3}, {"name": "slow_deep", "alpha": 0.7, "beta": 0.5, "diffusion_steps": 20}, ] for cfg in style_configs: audio = tts.synthesize( text=text, diffusion_steps=cfg["diffusion_steps"], alpha=cfg["alpha"], beta=cfg["beta"], ) filename = f"style_{cfg['name']}.wav" sf.write(filename, audio, 24000) print(f"Généré : {filename}") ``` *** ### Exemple 4 : Interface Web Gradio ```python import gradio as gr import soundfile as sf import numpy as np from inference import StyleTTS2Inference import tempfile tts = StyleTTS2Inference( model_path="Models/LibriTTS/epochs_2nd_00020.pth", config_path="Models/LibriTTS/config.yml", device="cuda" ) def synthesize(text, reference_audio, diffusion_steps, alpha, beta): if reference_audio is not None: sr, audio_data = reference_audio # Convertir au format attendu ref_audio = audio_data.astype(np.float32) / 32768.0 else: ref_audio = None sr = None output = tts.synthesize( text=text, reference_audio=ref_audio, reference_sr=sr, diffusion_steps=int(diffusion_steps), alpha=alpha, beta=beta, ) # Enregistrer dans un fichier temporaire with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f: sf.write(f.name, output, 24000) return f.name demo = gr.Interface( fn=synthesize, inputs=[ gr.Textbox(label="Texte d'entrée", lines=4), gr.Audio(label="Voix de référence (optionnelle)", type="numpy"), gr.Slider(1, 30, value=10, label="Étapes de diffusion"), gr.Slider(0.0, 1.0, value=0.3, label="Alpha (Style acoustique)"), gr.Slider(0.0, 1.0, value=0.7, label="Beta (Style prosodique)"), ], outputs=gr.Audio(label="Parole générée"), title="StyleTTS2 sur Clore.ai GPU", description="TTS de niveau humain avec diffusion de style" ) demo.launch(server_name="0.0.0.0", server_port=7860) ``` *** ### Exemple 5 : Génération par lots de livres audio ```python import soundfile as sf import numpy as np from pathlib import Path from inference import StyleTTS2Inference tts = StyleTTS2Inference( model_path="Models/LibriTTS/epochs_2nd_00020.pth", config_path="Models/LibriTTS/config.yml", device="cuda" ) # Diviser le texte en paragraphes book_text = """ Chapitre Un : La révolution du GPU L'histoire de l'intelligence artificielle ne peut être séparée de l'évolution des unités de traitement graphique. Ce qui a commencé comme du matériel spécialisé pour le rendu des pixels est devenu le moteur de la révolution moderne de l'IA. Chapitre Deux : Calcul distribué À mesure que les modèles sont devenus plus grands, l'entraînement sur un seul GPU a laissé place à des systèmes distribués. Des plateformes comme Clore.ai ont émergé pour démocratiser l'accès à cette puissance de calcul, rendant une infrastructure GPU de qualité entreprise accessible aux individus et aux startups. """.strip() paragraphs = [p.strip() for p in book_text.split('\n\n') if p.strip()] output_dir = Path("audiobook_output") output_dir.mkdir(exist_ok=True) audio_segments = [] for i, paragraph in enumerate(paragraphs): print(f"Traitement du paragraphe {i+1}/{len(paragraphs)}...") audio = tts.synthesize( text=paragraph, diffusion_steps=10, alpha=0.3, beta=0.7, ) segment_path = output_dir / f"segment_{i+1:03d}.wav" sf.write(str(segment_path), audio, 24000) audio_segments.append(audio) print(f" ✓ Sauvegardé {segment_path}") # Concaténer tous les segments avec un bref silence silence = np.zeros(int(24000 * 0.5)) # silence de 0,5 seconde full_audio = [] for seg in audio_segments: full_audio.append(seg) full_audio.append(silence) combined = np.concatenate(full_audio) sf.write("audiobook_complete.wav", combined, 24000) print(f"\nLivre audio complet : {len(combined)/24000:.1f} secondes") ``` *** ## Configuration ### Paramètres clés du config.yml ```yaml model_params: dim_in: 64 hidden_dim: 512 max_conv_dim: 512 n_layer: 3 n_mels: 80 diffusion: timesteps: 1000 beta_schedule: "squaredcos_cap_v2" training: batch_size: 16 epochs: 100 save_freq: 10 ``` ### Paramètres d'inférence | Paramètre | Plage | Par défaut | Effet | | ----------------- | ------- | ---------- | --------------------------------------------------- | | `diffusion_steps` | 1–30 | 10 | Compromis qualité vs vitesse | | `alpha` | 0.0–1.0 | 0.3 | Poids du style acoustique provenant de la référence | | `beta` | 0.0–1.0 | 0.7 | Poids du style prosodique provenant de la référence | | `embedding_scale` | 1.0–3.0 | 1.5 | Intensité globale du style | | `t` | 0.6–1.0 | 0.7 | Niveau de bruit (plus élevé = plus de variation) | *** ## Conseils de performance ### 1. Optimiser les étapes de diffusion La valeur par défaut de 10 étapes équilibre qualité et vitesse. Pour des applications en temps réel, utilisez 5 étapes ; pour une qualité maximale, utilisez 20–30. ```python # Temps réel (rapide) audio = tts.synthesize(text, diffusion_steps=5) # Haute qualité (lent) audio = tts.synthesize(text, diffusion_steps=20) ``` ### 2. Utiliser torch.compile (PyTorch 2.0+) ```python import torch model = torch.compile(model, mode="reduce-overhead") ``` ### 3. Inférence en précision mixte ```python with torch.autocast(device_type="cuda", dtype=torch.float16): audio = tts.synthesize(text, diffusion_steps=10) ``` ### 4. Traiter plusieurs phrases par lot Traitez plusieurs phrases ensemble lorsque possible pour maximiser l'utilisation du GPU et réduire les surcoûts. ### 5. Mettre en cache les embeddings de locuteur de référence ```python # Calculer une fois, réutiliser plusieurs fois speaker_embedding = tts.compute_speaker_embedding(reference_audio, sr) # Réutiliser pour plusieurs énoncés for text in texts: audio = tts.synthesize_with_embedding(text, speaker_embedding) ``` *** ## Dépannage ### Problème : espeak-ng introuvable ```bash apt-get install -y espeak-ng espeak-ng-data # Vérifier l'installation espeak-ng --version ``` ### Problème : Phonemizer échoue ```bash pip install phonemizer # Test python3 -c "from phonemizer import phonemize; print(phonemize('hello world'))" ``` ### Problème : CUDA manque de mémoire ```bash # Réduire la taille du lot ou utiliser le déchargement sur CPU export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256 # Ou basculer en FP16 ``` ### Problème : Mauvaise qualité audio * Augmenter `diffusion_steps` à 15–20 * Assurez-vous que l'audio de référence est propre, minimum 16 kHz * Essayez d'ajuster `alpha` et `beta` paramètres * Utilisez un extrait de référence plus long (15–30 secondes) ### Problème : Échec du téléchargement du modèle depuis Hugging Face ```bash pip install huggingface_hub python3 -c " from huggingface_hub import snapshot_download snapshot_download('yl4579/StyleTTS2-LibriTTS', local_dir='Models/LibriTTS') " ``` *** ## Recommandations GPU Clore.ai StyleTTS2 est un modèle léger — le point de contrôle LibriTTS fait \~300 Mo, l'inférence est rapide même sur des GPU modestes. | GPU | VRAM | Prix Clore.ai | Vitesse d'inférence | Idéal pour | | -------------- | ----- | ------------- | ------------------- | --------------------------------------- | | CPU uniquement | — | \~0,02$/h | \~0,5× temps réel | Développement, tests | | RTX 3090 | 24 Go | \~0,12 $/h | \~15× temps réel | API de production, clonage de voix | | RTX 4090 | 24 Go | \~0,70 $/h | \~25× temps réel | API à haute concurrence | | A100 40GB | 40 Go | \~1,20 $/h | \~40× temps réel | Génération de livres audio en gros lots | {% hint style="info" %} **RTX 3090 à \~0,12 $/hr** est le choix optimal pour StyleTTS2. Le modèle est suffisamment petit pour que vous dépensiez presque rien en temps GPU — une heure complète d'audio synthétisé coûte moins de 0,01 $ en location GPU. Pour la production de livres audio ou les services de clonage de voix, c'est extrêmement rentable. {% endhint %} **Conseil qualité pour le clonage de voix zero-shot :** Fournissez 15–30 secondes d'audio de référence propre à 22 kHz ou 24 kHz. Le module de diffusion de style a besoin de suffisamment d'audio pour capturer avec précision le style de parole, le rythme et la prosodie. Des références courtes ou bruyantes dégradent significativement la qualité de sortie. *** ## Liens * **GitHub**: * **Article (arXiv)**: * **Hugging Face (LJSpeech)**: * **Hugging Face (LibriTTS)**: * **Espace démo**: * **CLORE.AI Marketplace**: --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/styletss2.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.