> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/chattts.md).

# 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](https://github.com/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

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

```python
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 :

```python
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 :

```python
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 :

```bash
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 |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/chattts.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.