ChatTTS discours conversationnel

Exécutez la synthèse vocale conversationnelle ChatTTS avec contrôle fin de la prosodie sur les GPU Clore.ai.

ChatTTS est un modèle de synthèse vocale génératif de 300 millions de paramètres optimisé pour des scénarios de dialogue tels que les assistants LLM, les chatbots et les applications vocales interactives. Il produit une voix naturelle avec des pauses réalistes, des rires, des remplisseurs et une intonation — des caractéristiques que la plupart des systèmes TTS ont du mal à reproduire. Le modèle prend en charge l'anglais et le chinois et génère de l'audio à 24 kHz.

GitHub : 2noise/ChatTTS (30K+ étoiles) Licence : AGPLv3+ (code), CC BY-NC 4.0 (poids du modèle — non commercial)

Principales caractéristiques

• Prosodie conversationnelle — pauses naturelles, remplisseurs et intonation ajustés pour le dialogue

• Balises de contrôle fines — [oral_0-9], [laugh_0-2], [break_0-7], [uv_break], [lbreak]

• Multi-locuteur — échantillonnez des locuteurs aléatoires ou réutilisez des embeddings de locuteur pour la cohérence

• Température / top-P / top-K — contrôler la diversité de génération

• Inférence par lot — synthétiser plusieurs textes en un seul appel

• Léger — ~300M de paramètres, fonctionne avec 4 Go de VRAM

Exigences

Composant	Minimum	Recommandé
GPU	RTX 3060 (4 Go libres)	RTX 3090 / RTX 4090
VRAM	4 Go	8 Go+
RAM	8 Go	16 Go
Disque	5 Go	10 Go
Python	3.9+	3.11
CUDA	11.8+	12.1+

Recommandation Clore.ai : Un RTX 3060 (($0,15–0,30/jour) gère ChatTTS confortablement. Pour la production par lot ou une latence plus faible, choisissez une RTX 3090 ($0,30–1,00/jour).

Installation

# Installer depuis PyPI
pip install ChatTTS torch torchaudio

# Ou installez depuis la source pour les dernières fonctionnalités
git clone https://github.com/2noise/ChatTTS.git
cd ChatTTS
pip install -r requirements.txt

# Vérifier le GPU
python -c "import torch; print(torch.cuda.get_device_name(0))"

Démarrage rapide

import ChatTTS
import torch
import torchaudio

# Initialiser et charger le modèle (télécharge les poids au premier lancement)
chat = ChatTTS.Chat()
chat.load(compile=False)  # Définissez compile=True pour une inférence plus rapide après l'échauffement

texts = [
    "Salut ! Comment se passe ta journée jusqu'à présent ?",
    "J'ai travaillé sur ce projet toute la matinée. Ça avance bien.",
]

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")

Exemples d'utilisation

Voix de locuteur cohérente

Échantillonnez un embedding de locuteur aléatoire et réutilisez-le sur plusieurs générations pour une voix cohérente :

import ChatTTS
import torch
import torchaudio

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

# Échantillonnez un locuteur — enregistrez cette chaîne pour la réutiliser plus tard
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 = ["Bienvenue dans l'épisode d'aujourd'hui. Laissez-moi vous parler de quelque chose d'excitant."]

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)

Balises de contrôle au niveau des mots

Insérez des balises de contrôle directement dans le texte pour une prosodie précise :

import ChatTTS
import torch
import torchaudio

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

# Balises : [uv_break] = pause courte, [laugh] = rire, [lbreak] = pause longue
text = 'Quel est [uv_break]votre plat préféré ?[laugh][lbreak]'

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

# skip_refine_text=True préserve vos balises de contrôle manuelles
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)

Traitement par lot avec WebUI

ChatTTS est livré avec une interface web Gradio pour une utilisation interactive :

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

Ouvrez le http_pub URL depuis votre tableau de bord de commande Clore.ai pour accéder à l'interface.

Conseils pour les utilisateurs de Clore.ai

• Utilisez compile=True après les tests initiaux — la compilation PyTorch ajoute un temps de démarrage mais accélère considérablement les inférences répétées

• Mappage de ports — exposer le port 7860/http lors du déploiement avec la WebUI

• Image Docker — utiliser pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime comme base

• Persistance du locuteur — enregistrer rand_spk chaînes dans un fichier afin que vous puissiez réutiliser des voix entre les sessions sans rééchantillonnage

• Regroupez vos requêtes — chat.infer() accepte une liste de textes et les traite ensemble, ce qui est plus efficace que des appels un par un

• Licence non commerciale — les poids du modèle sont sous CC BY-NC 4.0 ; vérifiez les exigences de licence pour votre cas d'utilisation

Dépannage

Problème	Solution
CUDA out of memory	Réduisez la taille du lot ou utilisez un GPU avec ≥ 6 Go de VRAM
Le modèle se télécharge lentement	Pré-téléchargez depuis HuggingFace : huggingface-cli download 2Noise/ChatTTS
L'audio contient des crépitements/bruit	Ceci est intentionnel dans le modèle open-source (mesure anti-abus) ; utilisez compile=True pour une sortie plus propre
torchaudio.save erreur de dimension	Assurez-vous que le tenseur est 2D : audio.unsqueeze(0) si nécessaire
Sortie chinoise brouillée	Assurez-vous que le texte d'entrée est encodé en UTF-8 ; installez WeTextProcessing pour une meilleure normalisation
Première inférence lente	Normal — la compilation du modèle et le chargement des poids ont lieu au premier appel ; les appels suivants sont plus rapides