> 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/zonos-tts.md).

# Zonos TTS-Stimmklonung

Führe Zonos TTS von Zyphra zur Stimmklonung mit Emotions- und Tonhöhenkontrolle auf Clore.ai-GPUs aus.

Zonos von [Zyphra](https://www.zyphra.com/) ist ein Open-Weight-Text-to-Speech-Modell mit 0,4 Milliarden Parametern, das auf über 200.000 Stunden mehrsprachiger Sprache trainiert wurde. Es führt Zero-Shot-Stimmklonung mit nur 2–30 Sekunden Referenzaudio durch und bietet fein abgestimmte Kontrolle über Emotion, Sprechgeschwindigkeit, Tonhöhenvariation und Audioqualität. Die Ausgabe ist hochauflösendes 44-kHz-Audio. Es sind zwei Modellvarianten verfügbar: Transformer (beste Qualität) und Hybrid/Mamba (schnellere Inferenz).

**GitHub:** [Zyphra/Zonos](https://github.com/Zyphra/Zonos) **HuggingFace:** [Zyphra/Zonos-v0.1-transformer](https://huggingface.co/Zyphra/Zonos-v0.1-transformer) **Lizenz:** Apache 2.0

## Hauptfunktionen

* **Stimmklonung aus 2–30 Sekunden** — kein Fine-Tuning erforderlich
* **44 kHz High-Fidelity-Ausgabe** — Audioqualität in Studioqualität
* **Emotionskontrolle** — Freude, Trauer, Wut, Angst, Überraschung, Ekel über 8D-Vektor
* **Sprechgeschwindigkeit & Tonhöhe** — unabhängige feingranulare Steuerung
* **Audio-Präfixeingaben** — ermöglicht Flüstern und andere schwer zu klonende Verhaltensweisen
* **Mehrsprachig** — Englisch, Japanisch, Chinesisch, Französisch, Deutsch
* **Zwei Architekturen** — Transformer (Qualität) und Hybrid/Mamba (Geschwindigkeit, \~2× Echtzeit auf RTX 4090)
* **Apache 2.0** — kostenlos für private und kommerzielle Nutzung

## Anforderungen

| Komponente | Minimum            | Empfohlen      |
| ---------- | ------------------ | -------------- |
| GPU        | RTX 3080 10 GB     | RTX 4090 24 GB |
| VRAM       | 6 GB (Transformer) | 10 GB+         |
| RAM        | 16 GB              | 32 GB          |
| Festplatte | 10 GB              | 20 GB          |
| Python     | 3.10+              | 3.11           |
| CUDA       | 12.8+              | 12.8+          |
| System     | espeak-ng          | —              |

**Clore.ai-Empfehlung:** RTX 3090 ($0,07–0,21/Std.) für komfortable Reserven. RTX 4090 ($0,14–0,42/Std.) für das Hybrid-Modell und die schnellste Inferenz.

## Installation

```bash
# Systemabhängigkeit installieren
apt-get install -y espeak-ng

# Klonen und installieren
git clone https://github.com/Zyphra/Zonos.git
cd Zonos
pip install -e .

# Für das Hybrid-Modell (erfordert Ampere+-GPU, d. h. RTX-3000-Serie oder neuer)
pip install -e ".[compile]"

# Prüfen
python -c "from zonos.model import Zonos; print('Zonos bereit')"
```

## Schnellstart

```python
import torch
import torchaudio
from zonos.model import Zonos
from zonos.conditioning import make_cond_dict

# Modell laden (lädt beim ersten Ausführen Gewichte herunter)
model = Zonos.from_pretrained("Zyphra/Zonos-v0.1-transformer", device="cuda")

# Referenzaudio für Stimmklonung laden
wav, sr = torchaudio.load("reference_speaker.wav")
speaker = model.make_speaker_embedding(wav, sr)

# Konditionierung aufbauen
cond_dict = make_cond_dict(
    text="Hallo von Clore.ai! Dies ist eine Demonstration der Stimmklonung.",
    speaker=speaker,
    language="en-us",
)
conditioning = model.prepare_conditioning(cond_dict)

# Generieren
torch.manual_seed(42)
codes = model.generate(conditioning)
wavs = model.autoencoder.decode(codes).cpu()

torchaudio.save("output.wav", wavs[0], model.autoencoder.sampling_rate)
print(f"output.wav gespeichert mit {model.autoencoder.sampling_rate} Hz")
```

## Anwendungsbeispiele

### Emotionssteuerung

Zonos akzeptiert einen 8-dimensionalen Emotionsvektor: `[Freude, Trauer, Ekel, Angst, Überraschung, Wut, Sonstiges, Neutral]`.

```python
import torch
import torchaudio
from zonos.model import Zonos
from zonos.conditioning import make_cond_dict

model = Zonos.from_pretrained("Zyphra/Zonos-v0.1-transformer", device="cuda")

wav, sr = torchaudio.load("speaker_ref.wav")
speaker = model.make_speaker_embedding(wav, sr)

text = "Ich kann nicht glauben, was heute gerade passiert ist!"

emotions = {
    "happy":   [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
    "sad":     [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
    "angry":   [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
    "fearful": [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
    "neutral": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
}

for name, emo_vec in emotions.items():
    cond_dict = make_cond_dict(
        text=text,
        speaker=speaker,
        language="en-us",
        emotion=torch.tensor(emo_vec).unsqueeze(0),
    )
    conditioning = model.prepare_conditioning(cond_dict)
    codes = model.generate(conditioning)
    audio = model.autoencoder.decode(codes).cpu()
    torchaudio.save(f"emotion_{name}.wav", audio[0], model.autoencoder.sampling_rate)
    print(f"Generiert: {name}")
```

### Steuerung von Sprechgeschwindigkeit und Tonhöhe

```python
import torch
import torchaudio
from zonos.model import Zonos
from zonos.conditioning import make_cond_dict

model = Zonos.from_pretrained("Zyphra/Zonos-v0.1-transformer", device="cuda")

wav, sr = torchaudio.load("speaker_ref.wav")
speaker = model.make_speaker_embedding(wav, sr)

# Langsam und ruhig
cond_slow = make_cond_dict(
    text="Nimm dir Zeit. Es gibt überhaupt keinen Grund zur Eile.",
    speaker=speaker,
    language="en-us",
    speaking_rate=torch.tensor([8.0]),   # niedriger = langsamer
    pitch_std=torch.tensor([20.0]),      # niedriger = monotoner
)
codes = model.generate(model.prepare_conditioning(cond_slow))
audio = model.autoencoder.decode(codes).cpu()
torchaudio.save("slow_calm.wav", audio[0], model.autoencoder.sampling_rate)

# Schnell und energiegeladen
cond_fast = make_cond_dict(
    text="Beeil dich! Wir müssen sofort los!",
    speaker=speaker,
    language="en-us",
    speaking_rate=torch.tensor([22.0]),  # höher = schneller
    pitch_std=torch.tensor([80.0]),      # höher = ausdrucksstärker
)
codes = model.generate(model.prepare_conditioning(cond_fast))
audio = model.autoencoder.decode(codes).cpu()
torchaudio.save("fast_energetic.wav", audio[0], model.autoencoder.sampling_rate)
```

### Gradio-Weboberfläche

```bash
cd Zonos
python gradio_interface.py
# Oder mit uv:
# uv run gradio_interface.py
```

Port freigeben `7860/http` in Ihrer Clore.ai-Bestellung und öffnen Sie die `http_pub` URL, um auf die UI zuzugreifen.

## Tipps für Clore.ai-Nutzer

* **Modellauswahl** — Transformer für beste Qualität, Hybrid für \~2× schnellere Inferenz (erfordert RTX-3000+-GPU)
* **Referenzaudio** — 10–30 Sekunden saubere Sprache liefern die besten Ergebnisse; kürzere Clips (2–5 s) funktionieren, aber mit geringerer Wiedergabetreue
* **Docker-Einrichtung** — verwenden Sie `pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime`, hinzufügen `apt-get install -y espeak-ng` zum Start
* **Portzuordnung** — freigeben `7860/http` für die Gradio-UI, `8000/http` für den API-Server
* **Seed-Steuerung** — setzen Sie `torch.manual_seed()` vor der Generierung für reproduzierbare Ausgaben
* **Audioqualitätsparameter** — experimentieren Sie mit dem `audio_quality` Konditionierungsfeld für eine sauberere Ausgabe

## Fehlerbehebung

| Problem                       | Lösung                                                                                                    |
| ----------------------------- | --------------------------------------------------------------------------------------------------------- |
| `espeak-ng nicht gefunden`    | Ausführen `apt-get install -y espeak-ng` (erforderlich für die Phonemisierung)                            |
| `CUDA-Speicher erschöpft`     | Verwenden Sie das Transformer-Modell (kleiner als Hybrid); reduzieren Sie die Textlänge pro Aufruf        |
| Hybrid-Modell schlägt fehl    | Erfordert Ampere+-GPU (RTX-3000-Serie oder neuer) und `pip install -e ".[compile]"`                       |
| Geklonte Stimme klingt falsch | Verwenden Sie einen längeren Referenz-Clip (15–30 s) mit klarer Sprache und minimalem Hintergrundrauschen |
| Langsame Generierung          | Normal für Transformer (\~0,5× Echtzeit); Hybrid erreicht auf der RTX 4090 \~2× Echtzeit                  |
| `ModuleNotFoundError: zonos`  | Stellen Sie sicher, dass Sie aus dem Quellcode installiert haben: `cd Zonos && pip install -e .`          |


---

# 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/zonos-tts.md?ask=<question>&goal=<endgoal>
```

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