> 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-de/audio-and-stimme/styletss2.md). # 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 {% hint style="success" %} Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über [CLORE.AI-Marktplatz](https://clore.ai/marketplace). {% endhint %} *** ## 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 | {% hint style="info" %} 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. {% endhint %} *** ## 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](https://clore.ai/marketplace) 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 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://:7860 ``` *** ## Schritt-für-Schritt-Einrichtung ### Schritt 1: Per SSH auf Ihren Server verbinden ```bash ssh root@ -p ``` ### Schritt 2: Systemabhängigkeiten installieren ```bash 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 ```bash cd /workspace git clone https://github.com/yl4579/StyleTTS2.git cd StyleTTS2 ``` ### Schritt 4: Python-virtuelle Umgebung erstellen ```bash python3 -m venv venv source venv/bin/activate pip install --upgrade pip ``` ### Schritt 5: Abhängigkeiten installieren ```bash pip install -r requirements.txt # Zusätzliche Abhängigkeiten bei Bedarf installieren pip install phonemizer gruut ``` ### Schritt 6: Vortrainierte Modelle herunterladen ```bash # 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 ```bash # 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 ```bash source venv/bin/activate python app.py ``` Zugriff unter `http://:7860` *** ## Anwendungsbeispiele ### Beispiel 1: Einfaches TTS über die Python-API ```python 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 ```python 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 ```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 = "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 ```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 # 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 ```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" ) # 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 ```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 ``` ### 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. ```python # 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+) ```python import torch model = torch.compile(model, mode="reduce-overhead") ``` ### 3. Inferenz mit gemischter Präzision ```python 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 ```python # 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 ```bash apt-get install -y espeak-ng espeak-ng-data # Installation überprüfen espeak-ng --version ``` ### Problem: Phonemizer schlägt fehl ```bash pip install phonemizer # Test python3 -c "from phonemizer import phonemize; print(phonemize('hello world'))" ``` ### Problem: CUDA-Speicher voll ```bash # 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 ```bash 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](https://clore.ai/bare-metal) | \~40× in Echtzeit | Hörbuchgenerierung mit großen Batches | {% hint style="info" %} **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. {% endhint %} **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**: * **Paper (arXiv)**: * **Hugging Face (LJSpeech)**: * **Hugging Face (LibriTTS)**: * **Demo Space**: * **CLORE.AI-Marktplatz**: --- # 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-de/audio-and-stimme/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.