> 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 Exécutez StyleTTS2, une synthèse vocale de niveau humain via diffusion de style sur les GPU Clore.ai StyleTTS2 atteint des scores de naturalité é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 référence). Il utilise **diffusion de style** et **apprentissage adversarial** pour modéliser les styles d’élocution comme une distribution de variables latentes, permettant une synthèse expressive et une adaptation zero-shot du locuteur à partir d’un court clip de référence. Contrairement aux systèmes TTS traditionnels, StyleTTS2 peut généraliser à des locuteurs inconnus avec un court clip audio de référence, produisant une parole qui rivalise avec celle de comédiens professionnels. Il a été benchmarké avec des scores de naturalité évalués par des humains supérieurs sur plusieurs jeux de données — une première pour un TTS open source. Fonctionnalités clés : * **Naturalité de niveau humain** — dépasse les scores MOS humains sur LJSpeech * **Adaptation zero-shot du locuteur** — clonez n’importe quelle voix à partir d’un court échantillon audio * **diffusion de style** — prosodie et style d’élocution expressifs et variés * **Prise en charge de plusieurs locuteurs** — entraîné sur LibriTTS (plus de 2 300 locuteurs) * **Inférence légère** — fonctionne efficacement sur les GPU grand public {% hint style="success" %} Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace). {% endhint %} *** ## Exigences du serveur | Paramètre | Minimum | Recommandé | | ---------------------- | ---------------------- | ----------------------- | | GPU | NVIDIA RTX 3070 (8 Go) | NVIDIA RTX 4090 (24 GB) | | VRAM | 6 Go | 12–24 Go | | RAM | 16 Go | 32 Go | | CPU | 4 cœurs | 8 cœurs ou plus | | Disque | 15 Go | 30 Go | | Système d'exploitation | 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 pour servir des utilisateurs simultanés, utilisez une 4090 ou une A100. {% endhint %} *** ## Déploiement rapide sur CLORE.AI StyleTTS2 nécessite une compilation Docker personnalisée, car il n’existe pas d’image officielle préconstruite. La configuration prend environ 10 minutes. ### 1. Trouvez un serveur adapté Accédez à [la place de marché CLORE.AI](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 (de 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éder à l’interface ``` http://:7860 ``` *** ## Configuration étape par étape ### Étape 1 : connectez-vous en SSH à votre serveur ```bash ssh root@ -p ``` ### Étape 2 : Installer 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 : Cloner le dépôt StyleTTS2 ```bash cd /workspace git clone https://github.com/yl4579/StyleTTS2.git cd StyleTTS2 ``` ### Étape 4 : Créer un environnement virtuel Python ```bash python3 -m venv venv source venv/bin/activate pip install --upgrade pip ``` ### Étape 5 : Installer 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écharger les modèles préentraînés ```bash # Télécharger le modèle LJSpeech (monovoix, 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 (multivoix, 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 : Construire et exécuter 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 : Lancer directement la démo Gradio ```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 le 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} Go") ``` *** ### Exemple 2 : Clonage vocal 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 fonctionnent le mieux) reference_audio, sr = torchaudio.load("reference_voice.wav") # Générer la parole dans la voix de référence text = "Clore.ai fournit une infrastructure GPU puissante pour les applications d’IA, y compris la synthèse vocale." 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 l’intensité 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 enregistrée !") ``` *** ### Exemple 3 : Contrôle de style expressif ```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 l’informatique GPU avec Clore.ai." # Expérimenter 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 (facultatif)", 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="Discours généré"), title="StyleTTS2 sur GPU Clore.ai", 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 d’audiobook par lots ```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" ) # Découper le texte en paragraphes book_text = """ Chapitre Un : La révolution du GPU L’histoire de l’intelligence artificielle ne peut être dissociée de l’évolution des unités de traitement graphique. Ce qui a commencé comme un matériel spécialisé pour rendre les pixels est devenu le moteur de la révolution moderne de l’IA. Chapitre Deux : Calcul distribué À mesure que les modèles grandissaient, l’entraînement sur un seul GPU a cédé la place aux systèmes distribués. Des plateformes comme Clore.ai ont émergé pour démocratiser l’accès à cette puissance de calcul, rendant l’infrastructure GPU de niveau entreprise accessible aux particuliers 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" ✓ Enregistré {segment_path}") # Concaténer tous les segments avec un bref silence silence = np.zeros(int(24000 * 0.5)) # 0,5 seconde de silence 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"\nAudiobook complet : {len(combined)/24000:.1f} secondes") ``` *** ## Configuration ### Paramètres clés de 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" entraînement : 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é/vitesse | | `alpha` | 0,0–1,0 | 0.3 | Poids du style acoustique issu de la référence | | `beta` | 0,0–1,0 | 0.7 | Poids du style prosodique issu 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 les 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. Regrouper plusieurs phrases Traitez plusieurs phrases ensemble lorsque c’est possible afin de maximiser l’utilisation du GPU et de réduire la surcharge. ### 5. Mettre en cache les embeddings du 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 : échec de Phonemizer ```bash pip install phonemizer # Test python3 -c "from phonemizer import phonemize; print(phonemize('hello world'))" ``` ### Problème : mémoire CUDA insuffisante ```bash # Réduire la taille du lot ou utiliser le déchargement vers le CPU export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256 # Ou passer en FP16 ``` ### Problème : qualité audio médiocre * Augmentez `diffusion_steps` à 15–20 * Assurez-vous que l’audio de référence est propre, au moins 16 kHz * Essayez d’ajuster les `alpha` et `beta` paramètres * Utilisez un clip audio 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 checkpoint LibriTTS fait environ 300 Mo, et 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,07–0,21 $/h | \~15× temps réel | API de production, clonage vocal | | RTX 4090 | 24 Go | 0,14–0,42 $/h | \~25× temps réel | API à forte concurrence | | A100 40 Go | 40 Go | [bare metal](https://clore.ai/bare-metal) | \~40× temps réel | Génération d’audiobooks par lots volumineux | {% hint style="info" %} **RTX 3090 à 0,07–0,21 $/h** 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 d’audiobooks ou les services de clonage vocal, c’est extrêmement rentable. {% endhint %} **Conseil de qualité pour le clonage vocal zero-shot :** Fournissez 15 à 30 secondes d’audio de référence propre en 22 kHz ou 24 kHz. Le module de diffusion de style a besoin d’assez d’audio pour capturer avec précision le style d’élocution, le rythme et la prosodie. Des références bruyantes ou trop courtes dégradent fortement la qualité de sortie. *** ## Liens * **GitHub**: * **Article (arXiv)**: * **Hugging Face (LJSpeech)**: * **Hugging Face (LibriTTS)**: * **Espace de démo**: * **la place de marché CLORE.AI**: --- # 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, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/styletss2.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. 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.