# 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         |