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

# Chatterbox-Stimmklonung

Führe Chatterbox TTS von Resemble AI für Zero-Shot-Stimmklonung und mehrsprachige Sprachsynthese auf Clore.ai-GPUs aus.

Chatterbox ist eine Familie modernster Open-Source-Text-to-Speech-Modelle von [Resemble AI](https://resemble.ai). Es ermöglicht Zero-Shot-Stimmenklonen aus einem kurzen Referenzclip (\~10 Sekunden), unterstützt paralinguistische Tags wie `[laugh]` und `[cough]`, und bietet eine mehrsprachige Variante mit über 23 Sprachen. Es sind drei Modellvarianten verfügbar: Turbo (350M, geringe Latenz), Original (500M, kreative Steuerung) und Multilingual (500M, 23+ Sprachen).

{% hint style="info" %}
**Multilingual V3 ist jetzt der empfohlene mehrsprachige Checkpoint.** Gleiche 0,5B-Größe wie beim vorherigen Release, mit besserer Sprecherähnlichkeit, weniger Halluzinationen und natürlicherer Sprache in allen unterstützten Sprachen. Alles unten gilt unverändert — lade die aktuellen Gewichte und du erhältst V3.
{% endhint %}

**GitHub:** [resemble-ai/chatterbox](https://github.com/resemble-ai/chatterbox) **PyPI:** [chatterbox-tts](https://pypi.org/project/chatterbox-tts/) **Lizenz:** MIT

## Hauptfunktionen

* **Zero-Shot-Stimmenklonierung** — klone jede Stimme aus \~10 Sekunden Referenzaudio
* **Paralinguistische Tags** (Turbo) — `[laugh]`, `[cough]`, `[chuckle]`, `[sigh]` für realistische Sprache
* **23+ Sprachen** (Multilingual) — Arabisch, Chinesisch, Französisch, Deutsch, Japanisch, Koreanisch, Russisch, Spanisch und mehr
* **CFG- und Exaggeration-Tuning** (Original) — kreative Kontrolle über Ausdrucksstärke
* **Drei Modellgrößen** — Turbo (350M), Original (500M), Multilingual (500M)
* **MIT-Lizenz** — vollständig offen für die kommerzielle Nutzung

## Anforderungen

| Komponente | Minimum        | Empfohlen           |
| ---------- | -------------- | ------------------- |
| GPU        | RTX 3060 12 GB | RTX 3090 / RTX 4090 |
| VRAM       | 6 GB           | 10 GB+              |
| RAM        | 8 GB           | 16 GB               |
| Festplatte | 5 GB           | 15 GB               |
| Python     | 3.10+          | 3.11                |
| CUDA       | 12.8+          | 12.8+               |

**Clore.ai-Empfehlung:** RTX 3090 ($0.07–0.21/Stunde) für komfortable VRAM-Reserve. RTX 3060 funktioniert für das Turbo-Modell. Für das Multilingual-Modell mit langen Texten solltest du eine RTX 4090 ($0.14–0.42/Stunde) in Betracht ziehen.

## Installation

```bash
# Aus PyPI installieren
pip install chatterbox-tts

# Oder aus dem Quellcode installieren
git clone https://github.com/resemble-ai/chatterbox.git
cd chatterbox
pip install -e .

# Prüfen
python -c "from chatterbox.tts import ChatterboxTTS; print('Chatterbox bereit')"
```

## Schnellstart

### Turbo-Modell (geringste Latenz)

```python
import torchaudio as ta
from chatterbox.tts_turbo import ChatterboxTurboTTS

model = ChatterboxTurboTTS.from_pretrained(device="cuda")

# Einfache TTS mit paralinguistischen Tags
text = "Hey, willkommen zurück! [chuckle] Ich habe heute großartige Neuigkeiten für dich."

# Stimmenklonen — stelle einen Referenzclip von 10+ Sekunden bereit
wav = model.generate(text, audio_prompt_path="reference_voice.wav")

ta.save("output_turbo.wav", wav, model.sr)
print(f"Gespeichert bei {model.sr} Hz")
```

### Originalmodell (Englisch, kreative Steuerung)

```python
import torchaudio as ta
from chatterbox.tts import ChatterboxTTS

model = ChatterboxTTS.from_pretrained(device="cuda")

text = "Der flinke braune Fuchs springt über den faulen Hund. Es war ein wunderschöner Morgen."

# Ohne Stimmenklonen generieren (verwendet Standardstimme)
wav = model.generate(text)
ta.save("output_default.wav", wav, model.sr)

# Mit Stimmenklonen generieren
wav = model.generate(text, audio_prompt_path="my_voice_sample.wav")
ta.save("output_cloned.wav", wav, model.sr)
```

## Anwendungsbeispiele

### Mehrsprachiges Stimmenklonen

```python
import torchaudio as ta
from chatterbox.mtl_tts import ChatterboxMultilingualTTS

model = ChatterboxMultilingualTTS.from_pretrained(device="cuda")

# Französisch
Bonjour, comment allez-vous? Bienvenue dans notre démonstration.
wav_fr = model.generate(french_text, language_id="fr")
ta.save("output_french.wav", wav_fr, model.sr)

# Japanisch
こんにちは、テキスト読み上げのデモンストレーションです。
wav_ja = model.generate(japanese_text, language_id="ja")
ta.save("output_japanese.wav", wav_ja, model.sr)

# Mit Stimmenklonen auf Russisch
Привет! Это демонстрация синтеза речи на русском языке.
wav_ru = model.generate(
    russian_text,
    language_id="ru",
    audio_prompt_path="russian_speaker.wav"
)
ta.save("output_russian.wav", wav_ru, model.sr)

print("Mehrsprachige Generierung abgeschlossen")
```

### Paralinguistische Tags (Turbo)

```python
import torchaudio as ta
from chatterbox.tts_turbo import ChatterboxTurboTTS

model = ChatterboxTurboTTS.from_pretrained(device="cuda")

samples = [
    ("greeting", "Hi there! [laugh] Schön, dich wiederzusehen."),
    ("nervous", "Ähm, na ja [cough] ich bin mir da nicht wirklich sicher."),
    ("excited", "Oh mein Gott! [chuckle] Das sind wirklich unglaubliche Neuigkeiten!"),
]

for name, text in samples:
    wav = model.generate(text, audio_prompt_path="speaker_ref.wav")
    ta.save(f"para_{name}.wav", wav, model.sr)
    print(f"Generiert: {name}")
```

### Batch-Verarbeitungsskript

```python
import torchaudio as ta
from chatterbox.tts import ChatterboxTTS
import os

model = ChatterboxTTS.from_pretrained(device="cuda")

# Eine Liste von Zeilen verarbeiten (z. B. für Hörbuchkapitel)
lines = [
    "Kapitel eins. Das Abenteuer beginnt.",
    "Es war eine dunkle und stürmische Nacht.",
    "Der Held stand an der Kreuzung, unsicher, welchen Weg er einschlagen sollte.",
]

os.makedirs("output_batch", exist_ok=True)

for i, line in enumerate(lines):
    wav = model.generate(line, audio_prompt_path="narrator_voice.wav")
    ta.save(f"output_batch/line_{i:03d}.wav", wav, model.sr)
    print(f"[{i+1}/{len(lines)}] {line[:40]}...")

print("Batch-Verarbeitung abgeschlossen")
```

## Tipps für Clore.ai-Nutzer

* **Modellwahl** — verwende Turbo für Sprachagenten mit geringer Latenz, Original für kreative englische Inhalte, Multilingual für nicht-englische Inhalte
* **Qualität des Referenzaudios** — verwende einen sauberen, rauschfreien Clip von 10–30 Sekunden für die besten Ergebnisse beim Stimmenklonen
* **Docker-Setup** — Basis-Image `pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime`, Port freigeben `7860/http` für Gradio
* **Speicherverwaltung** — rufe `torch.cuda.empty_cache()` zwischen großen Stapeln auf, um VRAM freizugeben
* **Unterstützte Sprachen** — ar, da, de, el, en, es, fi, fr, he, hi, it, ja, ko, ms, nl, no, pl, pt, ru, sv, sw, tr, zh
* **HuggingFace Space** — vor dem Mieten ausprobieren unter [huggingface.co/spaces/ResembleAI/Chatterbox](https://huggingface.co/spaces/ResembleAI/Chatterbox)

## Fehlerbehebung

| Problem                              | Lösung                                                                                                         |
| ------------------------------------ | -------------------------------------------------------------------------------------------------------------- |
| `CUDA-Speicher erschöpft`            | Verwende Turbo (350M) statt Original/Multilingual (500M), oder miete eine größere GPU                          |
| Geklonte Stimme stimmt nicht überein | Verwende einen längeren (15–30 s), saubereren Referenzclip mit minimalem Hintergrundrauschen                   |
| `numpy` Versionskonflikt             | Ausführen `pip install numpy==1.26.4 --force-reinstall`                                                        |
| Langsamer Modell-Download            | Modelle werden beim ersten Lauf von HuggingFace abgerufen (\~2 GB); lade sie vorab mit `huggingface-cli`       |
| Audio weist Artefakte auf            | Reduziere die Textlänge pro Generierung; sehr lange Texte können die Qualität verschlechtern                   |
| `ModuleNotFoundError`                | Stelle sicher `pip install chatterbox-tts` ohne Fehler abgeschlossen; überprüfe die Python-3.11-Kompatibilität |


---

# 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/chatterbox-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.