StyleTTS2

Führe StyleTTS2 mit menschenähnlichem Text-to-Speech über Style Diffusion auf Clore.ai-GPUs aus

StyleTTS2 erreicht bei den Benchmarks LJSpeech und LibriTTS von Menschen bewertete Natürlichkeitswerte über den Ground-Truth-Aufnahmen (MOS 4,55 vs. 4,23 Ground Truth). Es verwendet Style-Diffusion und adversariales Training um Sprechstile als latente Variablenverteilung zu modellieren, was expressive Synthese und Zero-Shot-Sprecheranpassung anhand eines kurzen Referenzclips ermöglicht.

Im Gegensatz zu traditionellen TTS-Systemen kann StyleTTS2 mit einem kurzen Referenz-Audioclip auf unbekannte Sprecher verallgemeinern und Sprache erzeugen, die mit professionellen Sprechern mithält. Es wurde als erstes Open-Source-TTS-System auf mehreren Datensätzen mit von Menschen bewerteten Natürlichkeitswerten übertroffen.

Wichtige Funktionen:

• Natürlichkeit auf Menschenniveau — übertrifft menschliche MOS-Werte auf LJSpeech

• Zero-Shot-Sprecheranpassung — klont jede Stimme aus einem kurzen Audiobeispiel

• Style-Diffusion — ausdrucksstarke, vielfältige Prosodie und Sprechweise

• Unterstützung für mehrere Sprecher — trainiert auf LibriTTS (über 2.300 Sprecher)

• Leichte Inferenz — läuft effizient auf Consumer-GPUs

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

---

Serveranforderungen

Parameter	Minimum	Empfohlen
GPU	NVIDIA RTX 3070 (8 GB)	NVIDIA RTX 4090 (24 GB)
VRAM	6 GB	12–24 GB
RAM	16 GB	32 GB
CPU	4 Kerne	8+ Kerne
Festplatte	15 GB	30 GB
Betriebssystem	Ubuntu 20.04+	Ubuntu 22.04
CUDA	11.7+	12.1+
Python	3.8+	3.10
Ports	22, 7860	22, 7860

StyleTTS2 ist relativ leichtgewichtig — eine RTX 3070 oder 3080 bewältigt Inferenz in Echtzeit problemlos. Für Batch-Verarbeitung oder den Betrieb mit gleichzeitigen Nutzern verwenden Sie eine 4090 oder A100.

---

Schnellbereitstellung auf CLORE.AI

StyleTTS2 erfordert einen benutzerdefinierten Docker-Build, da es kein offizielles vorgefertigtes Image gibt. Das Setup dauert etwa 10 Minuten.

1. Finden Sie einen geeigneten Server

Gehe zu CLORE.AI-Marktplatz und filtern nach:

• VRAM: ≥ 6 GB

• GPU: RTX 3070, 3080, 3090, 4080, 4090, A100

• Festplatte: ≥ 20 GB

2. Konfigurieren Sie Ihre Bereitstellung

Docker-Image (Basis):

nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04

Port-Zuordnungen:

22 → SSH-Zugriff
7860 → Gradio-Weboberfläche

Startbefehl:

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. Greifen Sie auf die Oberfläche zu

http://<your-clore-server-ip>:7860

---

Schritt-für-Schritt-Einrichtung

Schritt 1: Per SSH auf Ihren Server verbinden

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

Schritt 2: Systemabhängigkeiten installieren

apt-get update && apt-get install -y \\
  git \
  python3 \\
  python3-pip \\
  python3-venv \\
  ffmpeg \\
  espeak-ng \\
  libsndfile1 \\
  build-essential \
  wget \
  curl

Schritt 3: StyleTTS2-Repository klonen

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

Schritt 4: Python-virtuelle Umgebung erstellen

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

Schritt 5: Abhängigkeiten installieren

pip install -r requirements.txt

# Zusätzliche Abhängigkeiten bei Bedarf installieren
pip install phonemizer gruut

Schritt 6: Vortrainierte Modelle herunterladen

# LJSpeech-Modell herunterladen (Einzelsprecher, hohe Qualität)
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"

# LibriTTS-Modell herunterladen (Mehrsprecher, 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"

Schritt 7: Dockerfile erstellen und ausführen

# Dockerfile erstellen
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

Schritt 8: Gradio-Demo direkt starten

source venv/bin/activate
python app.py

Zugriff unter http://<server-ip>:7860

---

Anwendungsbeispiele

Beispiel 1: Einfaches TTS über die Python-API

import torch
import soundfile as sf
import numpy as np
from models import *
from utils import *
import yaml

# Konfiguration laden
config = yaml.safe_load(open("Models/LJSpeech/config.yml"))

# Modell initialisieren
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)

# Auf die GPU verschieben
device = "cuda" if torch.cuda.is_available() else "cpu"
for key in model:
    model[key] = model[key].to(device)

print(f"Modell geladen auf: {device}")
print(f"Verwendeter VRAM: {torch.cuda.memory_allocated()/1e9:.2f} GB")

---

Beispiel 2: Zero-Shot-Stimmenklonung

import torch
import torchaudio
import soundfile as sf
from inference import StyleTTS2Inference

# Inferenz-Engine initialisieren
tts = StyleTTS2Inference(
    model_path="Models/LibriTTS/epochs_2nd_00020.pth",
    config_path="Models/LibriTTS/config.yml",
    device="cuda"
)

# Referenz-Audio laden (10–30 Sekunden funktionieren am besten)
reference_audio, sr = torchaudio.load("reference_voice.wav")

# Sprache in der Referenzstimme erzeugen
text = "Clore.ai bietet leistungsstarke GPU-Infrastruktur für KI-Anwendungen, einschließlich Text-zu-Sprache-Synthese."

audio = tts.synthesize(
    text=text,
    reference_audio=reference_audio,
    reference_sr=sr,
    diffusion_steps=10,    # Höher = bessere Qualität, langsamer
    embedding_scale=1.5,   # Steuert die Stilstärke
    alpha=0.3,             # Gewicht des akustischen Stils
    beta=0.7,              # Gewicht des prosodischen Stils
)

sf.write("cloned_voice_output.wav", audio, 24000)
print("Klon-Ausgabe gespeichert!")

---

Beispiel 3: Ausdrucksstarke Stilsteuerung

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 = "Willkommen zu unserer Präsentation über GPU-Computing mit Clore.ai."

# Mit verschiedenen Stilparametern experimentieren
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"Generiert: {filename}")

---

Beispiel 4: Gradio-Weboberfläche

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
        # In das erwartete Format umwandeln
        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,
    )

    # In temporäre Datei speichern
    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="Eingabetext", lines=4),
        gr.Audio(label="Referenzstimme (optional)", type="numpy"),
        gr.Slider(1, 30, value=10, label="Diffusionsschritte"),
        gr.Slider(0.0, 1.0, value=0.3, label="Alpha (akustischer Stil)"),
        gr.Slider(0.0, 1.0, value=0.7, label="Beta (prosodischer Stil)"),
    ],
    outputs=gr.Audio(label="Generierte Sprache"),
    title="StyleTTS2 auf Clore.ai GPU",
    description="TTS auf Menschenniveau mit Style-Diffusion"
)

demo.launch(server_name="0.0.0.0", server_port=7860)

---

Beispiel 5: Batch-Hörbuchgenerierung

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"
)

# Text in Absätze aufteilen
book_text = """
Kapitel Eins: Die GPU-Revolution

Die Geschichte der künstlichen Intelligenz lässt sich nicht von der Entwicklung der 
Grafikprozessoren trennen. Was als spezialisierte Hardware zum Rendern von Pixeln begann, 
wurde zur Triebkraft der modernen KI-Revolution.

Kapitel Zwei: Verteiltes Rechnen

Als die Modelle größer wurden, wich das Training auf einer einzelnen GPU verteilten Systemen. 
Plattformen wie Clore.ai entstanden, um den Zugang zu dieser Rechenleistung zu demokratisieren, 
und Rechenzentrums-GPU-Infrastruktur für Einzelpersonen und Start-ups zugänglich zu machen.
""".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"Absatz {i+1}/{len(paragraphs)} wird verarbeitet...")
    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"  ✓ {segment_path} gespeichert")

# Alle Segmente mit kurzer Stille zusammenfügen
silence = np.zeros(int(24000 * 0.5))  # 0,5 Sekunden Stille
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"\nKomplettes Hörbuch: {len(combined)/24000:.1f} Sekunden")

---

Konfiguration

Wichtige Parameter in 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

Inferenz-Parameter

Parameter	Bereich	Standard	Effekt
diffusion_steps	1–30	10	Kompromiss zwischen Qualität und Geschwindigkeit
alpha	0,0–1,0	0.3	Gewicht des akustischen Stils aus der Referenz
beta	0,0–1,0	0.7	Gewicht des prosodischen Stils aus der Referenz
embedding_scale	1,0–3,0	1.5	Gesamtstärke des Stils
t	0,6–1,0	0.7	Rauschlevel (höher = mehr Variation)

---

Leistungstipps

1. Diffusionsschritte optimieren

Der Standardwert von 10 Schritten balanciert Qualität und Geschwindigkeit. Für Echtzeitanwendungen verwenden Sie 5 Schritte; für maximale Qualität 20–30.

# In Echtzeit (schnell)
audio = tts.synthesize(text, diffusion_steps=5)

# Hohe Qualität (langsam)
audio = tts.synthesize(text, diffusion_steps=20)

2. torch.compile verwenden (PyTorch 2.0+)

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

3. Inferenz mit gemischter Präzision

with torch.autocast(device_type="cuda", dtype=torch.float16):
    audio = tts.synthesize(text, diffusion_steps=10)

4. Mehrere Sätze in einem Batch verarbeiten

Verarbeiten Sie mehrere Sätze nach Möglichkeit gemeinsam, um die GPU-Auslastung zu maximieren und Overhead zu reduzieren.

5. Referenz-Sprecher-Embeddings zwischenspeichern

# Einmal berechnen, vielfach wiederverwenden
speaker_embedding = tts.compute_speaker_embedding(reference_audio, sr)

# Für mehrere Äußerungen wiederverwenden
for text in texts:
    audio = tts.synthesize_with_embedding(text, speaker_embedding)

---

Fehlerbehebung

Problem: espeak-ng nicht gefunden

apt-get install -y espeak-ng espeak-ng-data
# Installation überprüfen
espeak-ng --version

Problem: Phonemizer schlägt fehl

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

Problem: CUDA-Speicher voll

# Batch-Größe reduzieren oder CPU-Offloading verwenden
export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256
# Oder auf FP16 umstellen

Problem: Schlechte Audioqualität

• Erhöhen Sie diffusion_steps auf 15–20

• Stellen Sie sicher, dass das Referenzaudio sauber ist und mindestens 16 kHz hat

• Versuchen Sie, alpha und beta Parameter

• Verwenden Sie einen längeren Referenz-Audioclip (15–30 Sekunden)

Problem: Modell-Download von Hugging Face schlägt fehl

pip install huggingface_hub
python3 -c "
from huggingface_hub import snapshot_download
snapshot_download('yl4579/StyleTTS2-LibriTTS', local_dir='Models/LibriTTS')
"

---

GPU-Empfehlungen für Clore.ai

StyleTTS2 ist ein leichtgewichtiges Modell — der LibriTTS-Checkpoint ist etwa 300 MB groß, die Inferenz ist selbst auf bescheidenen GPUs schnell.

GPU	VRAM	Clore.ai-Preis	Inferenzgeschwindigkeit	Am besten geeignet für
Nur CPU	—	~$0,02/Stunde	~0,5× in Echtzeit	Entwicklung, Tests
RTX 3090	24 GB	ca. 0,07–0,21 $/h	~15× in Echtzeit	Produktions-API, Stimmenklonung
RTX 4090	24 GB	ca. 0,14–0,42 $/h	~25× in Echtzeit	API mit hoher Parallelität
A100 40GB	40 GB	Bare Metal	~40× in Echtzeit	Hörbuchgenerierung mit großen Batches

RTX 3090 für 0,07–0,21 $/Std. ist die optimale Wahl für StyleTTS2. Das Modell ist klein genug, dass Sie fast keine GPU-Zeit benötigen — eine volle Stunde synthetisierte Sprache kostet bei GPU-Miete unter 0,01 $. Für die Hörbuchproduktion oder Stimmenklonungsdienste ist das äußerst kosteneffizient.

Tipp zur Qualität der Zero-Shot-Stimmenklonung: Stellen Sie 15–30 Sekunden sauberes Referenz-Audio mit 22 kHz oder 24 kHz bereit. Das Style-Diffusion-Modul benötigt genügend Audio, um Sprechweise, Tempo und Prosodie genau zu erfassen. Rauschen oder zu kurze Referenzen verschlechtern die Ausgabequalität erheblich.

---

Links

• GitHub: https://github.com/yl4579/StyleTTS2

• Paper (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

• Demo Space: https://huggingface.co/spaces/styletts2/styletts2

• CLORE.AI-Marktplatz: https://clore.ai/marketplace