Parole conversationnelle ChatTTS

Exécutez la synthèse vocale conversationnelle ChatTTS avec un 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 M 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 parole au son naturel avec des pauses réalistes, des rires, des mots de remplissage et une intonation — des caractéristiques que la plupart des systèmes de synthèse vocale peinent à reproduire. Le modèle prend en charge l’anglais et le chinois et génère de l’audio à 24 kHz.

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

Caractéristiques clés

• Prosodie conversationnelle — pauses naturelles, mots de remplissage et intonation adaptés au 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 plus de 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 — ~300 M 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	12.8+	12.8+

Recommandation de Clore.ai : Une RTX 3060 (0,03–0,07 $/h) gère ChatTTS confortablement. Pour la production par lot ou une latence plus faible, choisissez une RTX 3090 (0,07–0,21 $/h).

Installation

# Installer depuis PyPI
pip install ChatTTS torch torchaudio

# Ou installer depuis les sources pour obtenir 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 échauffement

texts = [
    "Salut ! Comment se passe ta journée jusqu’à présent ?",
    "Je travaille sur ce projet depuis ce matin. Il 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 dans plusieurs générations pour une voix cohérente :

import ChatTTS
import torch
import torchaudio

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

# Échantillonner 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 directement des balises de contrôle dans le texte pour une prosodie précise :

import ChatTTS
import torch
import torchaudio

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

# Balises : [uv_break] = courte pause, [laugh] = rire, [lbreak] = longue pause
text = 'Quel est [uv_break]ton 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 conserve 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 fourni 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 l’ 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 premiers tests — la compilation PyTorch ajoute du temps au démarrage mais accélère considérablement l’inférence répétée

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

• Image Docker — utiliser pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime comme base

• Persistance du locuteur — enregistrer rand_spk les chaînes dans un fichier afin de pouvoir réutiliser les 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 licence CC BY-NC 4.0 ; vérifiez les exigences de licence pour votre cas d’utilisation

Dépannage

Problème	Solution
Mémoire CUDA insuffisante	Réduisez la taille du lot ou utilisez un GPU avec ≥ 6 Go de VRAM
Le téléchargement du modèle est lent	Téléchargez à l’avance depuis HuggingFace : huggingface-cli download 2Noise/ChatTTS
L’audio contient des parasites/bruit	C’est intentionnel dans le modèle open source (mesure anti-abus) ; utilisez compile=True pour un rendu plus propre
torchaudio.save erreur de dimension	Assurez-vous que le tenseur est en 2D : audio.unsqueeze(0) si nécessaire
Sortie chinoise corrompue	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 lors du premier appel ; les appels suivants sont plus rapides