# ChatTTS Konversationssprache

ChatTTS ist ein generatives Sprachmodell mit 300 Millionen Parametern, optimiert für Dialogszenarien wie LLM-Assistenten, Chatbots und interaktive Sprachanwendungen. Es erzeugt natürlich klingende Sprache mit realistischen Pausen, Lachen, Füllwörtern und Intonation – Eigenschaften, die die meisten TTS-Systeme nur schwer nachbilden. Das Modell unterstützt Englisch und Chinesisch und generiert Audio mit 24 kHz.

**GitHub:** [2noise/ChatTTS](https://github.com/2noise/ChatTTS) (30K+ Sterne) **Lizenz:** AGPLv3+ (Code), CC BY-NC 4.0 (Modellgewichte – nicht kommerziell)

## Hauptmerkmale

* **Konversationelle Prosodie** — natürliche Pausen, Füllwörter und Intonation, abgestimmt auf Dialoge
* **Feinsteuerungs-Tags** — `[oral_0-9]`, `[laugh_0-2]`, `[break_0-7]`, `[uv_break]`, `[lbreak]`
* **Mehrere Sprecher** — zufällige Sprecher sampeln oder Sprecher-Embeddings wiederverwenden für Konsistenz
* **Temperature / top-P / top-K** — steuert die Vielfalt der Generierung
* **Batch-Inferenz** — mehrere Texte in einem Aufruf synthetisieren
* **Leichtgewichtig** — \~300M Parameter, läuft mit 4 GB VRAM

## Anforderungen

| Komponente | Minimum              | Empfohlen           |
| ---------- | -------------------- | ------------------- |
| GPU        | RTX 3060 (4 GB frei) | RTX 3090 / RTX 4090 |
| VRAM       | 4 GB                 | 8 GB+               |
| RAM        | 8 GB                 | 16 GB               |
| Festplatte | 5 GB                 | 10 GB               |
| Python     | 3.9+                 | 3.11                |
| CUDA       | 11.8+                | 12.1+               |

**Clore.ai-Empfehlung:** Eine RTX 3060 (~~$0.15–0.30/Tag) bewältigt ChatTTS problemlos. Für Batch-Produktion oder geringere Latenz wählen Sie eine RTX 3090 (~~$0.30–1.00/Tag).

## Installation

```bash
# Von PyPI installieren
pip install ChatTTS torch torchaudio

# Oder von der Quelle installieren für die neuesten Funktionen
git clone https://github.com/2noise/ChatTTS.git
cd ChatTTS
pip install -r requirements.txt

# GPU überprüfen
python -c "import torch; print(torch.cuda.get_device_name(0))"
```

## Schnellstart

```python
import ChatTTS
import torch
import torchaudio

# Modell initialisieren und laden (lädt Gewichte beim ersten Lauf herunter)
chat = ChatTTS.Chat()
chat.load(compile=False)  # Setze compile=True für schnellere Inferenz nach dem Aufwärmen

texts = [
    "Hey! Wie läuft dein Tag bisher?",
    "Ich arbeite den ganzen Morgen an diesem Projekt. Es kommt gut voran.",
]

wavs = chat.infer(texts)

for i, wav in enumerate(wavs):
    audio_tensor = torch.from_numpy(wav)
    if audio_tensor.dim() == 1:
        audio_tensor = audio_tensor.unsqueeze(0)
    torchaudio.save(f"output_{i}.wav", audio_tensor, 24000)
    print(f"Saved output_{i}.wav")
```

## Beispielanwendungen

### Konsistente Sprecherstimme

Sampeln Sie ein zufälliges Sprecher-Embedding und verwenden Sie es über mehrere Generierungen hinweg für eine konsistente Stimme:

```python
import ChatTTS
import torch
import torchaudio

chat = ChatTTS.Chat()
chat.load(compile=False)

# Einen Sprecher sampeln — speichern Sie diesen String, um ihn später wiederzuverwenden
rand_spk = chat.sample_random_speaker()

params_infer_code = ChatTTS.Chat.InferCodeParams(
    spk_emb=rand_spk,
    temperature=0.3,
    top_P=0.7,
    top_K=20,
)

params_refine_text = ChatTTS.Chat.RefineTextParams(
    prompt='[oral_2][laugh_0][break_4]',
)

texts = ["Willkommen zur heutigen Folge. Lassen Sie mich Ihnen etwas Spannendes erzählen."]

wavs = chat.infer(
    texts,
    params_refine_text=params_refine_text,
    params_infer_code=params_infer_code,
)

audio = torch.from_numpy(wavs[0])
if audio.dim() == 1:
    audio = audio.unsqueeze(0)
torchaudio.save("consistent_speaker.wav", audio, 24000)
```

### Wortbasierte Steuertags

Fügen Sie Steuertags direkt in den Text ein für präzise Prosodie:

```python
import ChatTTS
import torch
import torchaudio

chat = ChatTTS.Chat()
chat.load(compile=False)

# Tags: [uv_break] = kurze Pause, [laugh] = Lachen, [lbreak] = lange Pause
text = 'Was ist [uv_break]dein Lieblingsessen?[laugh][lbreak]'

rand_spk = chat.sample_random_speaker()
params = ChatTTS.Chat.InferCodeParams(spk_emb=rand_spk, temperature=0.3)

# skip_refine_text=True bewahrt Ihre manuellen Steuertags
wavs = chat.infer(text, skip_refine_text=True, params_infer_code=params)

audio = torch.from_numpy(wavs[0])
if audio.dim() == 1:
    audio = audio.unsqueeze(0)
torchaudio.save("controlled_output.wav", audio, 24000)
```

### Batch-Verarbeitung mit WebUI

ChatTTS wird mit einer Gradio-Weboberfläche für interaktive Nutzung geliefert:

```bash
cd ChatTTS
python examples/web/webui.py --server_name 0.0.0.0 --server_port 7860
```

Öffnen Sie die `http_pub` URL von Ihrem Clore.ai Bestelldashboard, um auf die UI zuzugreifen.

## Tipps für Clore.ai-Nutzer

* **Verwenden Sie `compile=True`** nach ersten Tests — PyTorch-Kompilierung fügt Startzeit hinzu, beschleunigt aber wiederholte Inferenz deutlich
* **Port-Weiterleitung** — Port freigeben `7860/http` bei Bereitstellung mit der WebUI
* **Docker-Image** — verwenden Sie `pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime` als Basis
* **Sprecher-Persistenz** — speichern `rand_spk` Strings in einer Datei, damit Sie Stimmen zwischen Sitzungen wiederverwenden können, ohne neu zu sampeln
* **Bündeln Sie Ihre Anfragen** — `chat.infer()` akzeptiert eine Liste von Texten und verarbeitet sie zusammen, was effizienter ist als Einzelaufrufe
* **Nicht-kommerzielle Lizenz** — die Modellgewichte sind CC BY-NC 4.0; prüfen Sie die Lizenzanforderungen für Ihren Anwendungsfall

## Fehlerbehebung

| Problem                            | Lösung                                                                                                                      |
| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| `CUDA out of memory`               | Reduzieren Sie die Batch-Größe oder verwenden Sie eine GPU mit ≥ 6 GB VRAM                                                  |
| Modell lädt langsam herunter       | Vorab herunterladen von HuggingFace: `huggingface-cli download 2Noise/ChatTTS`                                              |
| Audio hat Brummen/Rauschen         | Dies ist im Open-Source-Modell beabsichtigt (Maßnahme gegen Missbrauch); verwenden Sie `compile=True` für sauberere Ausgabe |
| `torchaudio.save` Dimensionsfehler | Stellen Sie sicher, dass der Tensor 2D ist: `audio.unsqueeze(0)` falls erforderlich                                         |
| Unleserliche chinesische Ausgabe   | Stellen Sie sicher, dass der Eingabetext UTF-8-codiert ist; installieren Sie `WeTextProcessing` für bessere Normalisierung  |
| Langsame erste Inferenz            | Normal — Modellkompilierung und Laden der Gewichte erfolgen beim ersten Aufruf; nachfolgende Aufrufe sind schneller         |


---

# Agent Instructions: 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/chattts.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.