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

# Zonos TTS Voice Cloning

Zonos von [Zyphra](https://www.zyphra.com/) ist ein Open-Weight-Text-zu-Sprache-Modell mit 0,4 Mrd. Parametern, trainiert auf über 200.000 Stunden mehrsprachiger Sprache. Es führt Zero-Shot-Stimmenklonen bereits mit nur 2–30 Sekunden Referenzaudio durch und bietet feinkörnige Kontrolle über Emotion, Sprechgeschwindigkeit, Tonhöhenvariation und Audioqualität. Die Ausgabe ist hochauflösendes 44-kHz-Audio. Zwei Modellvarianten sind 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

## Hauptmerkmale

* **Stimmenklonen aus 2–30 Sekunden** — kein Fine-Tuning erforderlich
* **44 kHz Hochleistungs-Ausgabe** — Studioqualität-Audio
* **Emotionssteuerung** — Freude, Traurigkeit, Wut, Angst, Überraschung, Ekel via 8D-Vektor
* **Sprechgeschwindigkeit & Tonhöhe** — unabhängige feinkörnige Kontrolle
* **Audio-Präfix-Eingaben** — 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       | 11.8+              | 12.4           |
| System     | espeak-ng          | —              |

**Clore.ai-Empfehlung:** RTX 3090 (~~$0,30–1,00/Tag) für angenehme Reserven. RTX 4090 (~~$0,50–2,00/Tag) für das Hybrid-Modell und 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]"

# Verifizieren
python -c "from zonos.model import Zonos; print('Zonos ready')"
```

## Schnellstart

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

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

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

# Konditionierung erstellen
cond_dict = make_cond_dict(
    text="Hello from Clore.ai! This is a voice cloning demonstration.",
    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"Saved output.wav at {model.autoencoder.sampling_rate} Hz")
```

## Beispielanwendungen

### Emotionssteuerung

Zonos akzeptiert einen 8-dimensionalen Emotionsvektor: `[Freude, Traurigkeit, Ekel, Angst, Überraschung, Wut, anderes, 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 = "I can't believe what just happened today!"

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"Generated: {name}")
```

### Sprechgeschwindigkeit- und Tonhöhensteuerung

```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="Take your time. There is no rush at all.",
    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 energisch
cond_fast = make_cond_dict(
    text="Hurry up! We need to go right now!",
    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 Web-Oberflä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

* **Modellwahl** — Transformer für beste Qualität, Hybrid für \~2× schnellere Inferenz (erfordert RTX-3000+-GPU)
* **Referenzaudio** — 10–30 Sekunden sauberen Sprechens liefern die besten Ergebnisse; kürzere Clips (2–5 s) funktionieren, aber mit geringerer Qualität
* **Docker-Einrichtung** — verwenden Sie `pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime`, fügen Sie `apt-get install -y espeak-ng` zum Startup hinzu
* **Port-Weiterleitung** — freigeben `7860/http` für Gradio-UI, `8000/http` für API-Server
* **Seed-Kontrolle** — setze `torch.manual_seed()` vor der Generierung für reproduzierbare Ausgabe
* **Audioqualitätsparameter** — experimentieren Sie mit dem `audio_quality` Konditionierungsfeld für sauberere Ausgabe

## Fehlerbehebung

| Problem                       | Lösung                                                                                                       |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------ |
| `espeak-ng nicht gefunden`    | Ausführen `apt-get install -y espeak-ng` (erforderlich für Phonemisierung)                                   |
| `CUDA out of memory`          | 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 Referenzclip (15–30 s) mit deutlicher Sprache und minimalem Hintergrundgeräusch |
| Langsame Generierung          | Normal für Transformer (\~0,5× Echtzeit); Hybrid erreicht \~2× Echtzeit auf RTX 4090                         |
| `ModuleNotFoundError: zonos`  | Stellen Sie sicher, dass Sie von der Quelle 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:

```
GET https://docs.clore.ai/guides/guides_v2-de/audio-and-sprache/zonos-tts.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.