StyleTTS2

Exécuter StyleTTS2 synthèse vocale de niveau humain via diffusion de style sur les GPU Clore.ai

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

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

---

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

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.

---

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 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 -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://<votre-ip-serveur-clore>:7860

---

Configuration étape par étape

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

ssh root@<votre-ip-serveur-clore> -p <port-ssh>

Étape 2 : Installez 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 : Clonez le dépôt StyleTTS2

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

Étape 4 : Créez un environnement virtuel Python

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

Étape 5 : Installez 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échargez les modèles pré-entraînés

# 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

# 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

source venv/bin/activate
python app.py

Accéder à http://<ip-serveur>: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 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

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

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

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

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

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.

# 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. 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

# 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 : Phonemizer échoue

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

Problème : CUDA manque de mémoire

# 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

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

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.

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: 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 démo: https://huggingface.co/spaces/styletts2/styletts2

• CLORE.AI Marketplace: https://clore.ai/marketplace