# Zonos TTS Stimmenklonung

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