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

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

---

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

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.

---

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 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 -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://<your-clore-server-ip>:7860

---

Configuration étape par étape

Étape 1 : connectez-vous en SSH à votre serveur

ssh root@<your-clore-server-ip> -p <ssh-port>

Étape 2 : Installer les dépendances système

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

cd /workspace
git clone https://github.com/yl4579/StyleTTS2.git
cd StyleTTS2

Étape 4 : Créer un environnement virtuel Python

python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip

Étape 5 : Installer les dépendances

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

# 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

# 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

source venv/bin/activate
python app.py

Accéder à http://<server-ip>:7860

---

Exemples d'utilisation

Exemple 1 : TTS de base via l’API 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

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

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

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

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

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.

# 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+)

import torch
model = torch.compile(model, mode="reduce-overhead")

3. Inférence en précision mixte

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

# 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

apt-get install -y espeak-ng espeak-ng-data
# Vérifier l'installation
espeak-ng --version

Problème : échec de Phonemizer

pip install phonemizer
# Test
python3 -c "from phonemizer import phonemize; print(phonemize('hello world'))"

Problème : mémoire CUDA insuffisante

# 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

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	~40× temps réel	Génération d’audiobooks par lots volumineux

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.

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: https://github.com/yl4579/StyleTTS2

• Article (arXiv): https://arxiv.org/abs/2306.07691

• Hugging Face (LJSpeech): https://huggingface.co/yl4579/StyleTTS2-LJSpeech

• Hugging Face (LibriTTS): https://huggingface.co/yl4579/StyleTTS2-LibriTTS

• Espace de démo: https://huggingface.co/spaces/styletts2/styletts2

• la place de marché CLORE.AI: https://clore.ai/marketplace