ChatTTS-konversationelle Sprache

Führe ChatTTS-konversationelles Text-to-Speech mit fein abgestimmter Prosodiekontrolle auf Clore.ai-GPUs aus.

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

GitHub: 2noise/ChatTTS (30K+ Sterne) Lizenz: AGPLv3+ (Code), CC BY-NC 4.0 (Modellgewichte — nicht kommerziell)

Hauptfunktionen

• Gesprächsprosodie — natürliche Pausen, Fülllaute und Intonation, auf Dialoge abgestimmt

• Fein abgestimmte Steuerungstags — [oral_0-9], [laugh_0-2], [break_0-7], [uv_break], [lbreak]

• Mehrere Sprecher — zufällige Sprecher sampeln oder Sprecher-Embeddings zur Konsistenz wiederverwenden

• Temperatur / top-P / top-K — die Vielfalt der Generierung steuern

• Batch-Inferenz — mehrere Texte in einem einzigen Aufruf synthetisieren

• Leichtgewichtig — ~300 Mio. Parameter, läuft auf 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	12.8+	12.8+

Clore.ai-Empfehlung: Eine RTX 3060 ($0.03–0.07/Stunde) bewältigt ChatTTS problemlos. Für Batch-Produktion oder geringere Latenz wähle eine RTX 3090 ($0.07–0.21/Stunde).

Installation

# Aus PyPI installieren
pip install ChatTTS torch torchaudio

# Oder aus dem Quellcode installieren, um die neuesten Funktionen zu erhalten
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

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 Warmlauf

texts = [
    "Hey, wie läuft dein Tag bisher?",
    "Ich arbeite den ganzen Morgen schon an diesem Projekt. Es macht gute Fortschritte.",
]

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"output_{i}.wav gespeichert")

Anwendungsbeispiele

Konsistente Sprecherstimme

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

import ChatTTS
import torch
import torchaudio

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

# Einen Sprecher sampeln — speichere 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 Episode. Ich möchte dir von etwas Aufregendem 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)

Steuerungstags auf Wortebene

Füge Steuerungstags direkt in den Text ein, um eine präzise Prosodie zu erhalten:

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 deine manuellen Steuerungstags
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 die interaktive Nutzung ausgeliefert:

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

Öffne die http_pub URL aus deinem Clore.ai-Bestell-Dashboard, um auf die UI zuzugreifen.

Tipps für Clore.ai-Nutzer

• Verwende compile=True nach dem ersten Testen — PyTorch-Kompilierung erhöht die Startzeit, beschleunigt aber wiederholte Inferenz erheblich

• Portzuordnung — Port freigeben 7860/http beim Bereitstellen mit der WebUI

• Docker-Image — verwenden Sie pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime als Basis

• Sprecher-Persistenz — speichern rand_spk Strings in eine Datei, damit du Stimmen über Sitzungen hinweg ohne erneutes Sampeln wiederverwenden kannst

• Stapel deine Anfragen — chat.infer() akzeptiert eine Liste von Texten und verarbeitet sie gemeinsam, was effizienter ist als Aufrufe einzeln

• Nicht-kommerzielle Lizenz — die Modellgewichte sind CC BY-NC 4.0; prüfe die Lizenzanforderungen für deinen Anwendungsfall

Fehlerbehebung

Problem	Lösung
CUDA-Speicher erschöpft	Verringere die Batchgröße oder verwende eine GPU mit ≥ 6 GB VRAM
Modell lädt langsam	Vorab von HuggingFace herunterladen: huggingface-cli download 2Noise/ChatTTS
Audio hat statisches Rauschen	Das ist im Open-Source-Modell absichtlich so vorgesehen (Anti-Missbrauchsmaßnahme); verwende compile=True für sauberere Ausgabe
torchaudio.save Dimensionsfehler	Stelle sicher, dass der Tensor 2D ist: audio.unsqueeze(0) falls nötig
Verstümmelte chinesische Ausgabe	Stelle sicher, dass der Eingabetext als UTF-8 kodiert ist; installiere WeTextProcessing für bessere Normalisierung
Langsame erste Inferenz	Normal — Modellkompilierung und Gewichts laden erfolgen beim ersten Aufruf; nachfolgende Aufrufe sind schneller