> 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/chatterbox-tts.md).

# Clonage vocal Chatterbox

Chatterbox est une famille de modèles de synthèse vocale texte-à-parole open source à la pointe par [Resemble AI](https://resemble.ai). Il effectue le clonage de voix en zero-shot à partir d'un court extrait de référence (\~10 secondes), prend en charge des balises paralinguistiques comme `[rire]` et `[toux]`, et propose une variante multilingue couvrant plus de 23 langues. Trois variantes de modèle sont disponibles : Turbo (350M, faible latence), Original (500M, contrôles créatifs) et Multilingual (500M, 23+ langues).

**GitHub :** [resemble-ai/chatterbox](https://github.com/resemble-ai/chatterbox) **PyPI :** [chatterbox-tts](https://pypi.org/project/chatterbox-tts/) **Licence :** MIT

## Principales caractéristiques

* **Clonage vocal zero-shot** — cloner n'importe quelle voix à partir d'environ 10 secondes d'audio de référence
* **Balises paralinguistiques** (Turbo) — `[rire]`, `[toux]`, `[gloussement]`, `[soupir]` pour une voix réaliste
* **23+ langues** (Multilingual) — arabe, chinois, français, allemand, japonais, coréen, russe, espagnol, et plus
* **Réglage CFG & Exagération** (Original) — contrôle créatif de l'expressivité
* **Trois tailles de modèle** — Turbo (350M), Original (500M), Multilingual (500M)
* **Licence MIT** — entièrement ouvert pour un usage commercial

## Exigences

| Composant | Minimum        | Recommandé          |
| --------- | -------------- | ------------------- |
| GPU       | RTX 3060 12 Go | RTX 3090 / RTX 4090 |
| VRAM      | 6 Go           | 10 GB+              |
| RAM       | 8 Go           | 16 Go               |
| Disque    | 5 Go           | 15 Go               |
| Python    | 3.10+          | 3.11                |
| CUDA      | 11.8+          | 12.1+               |

**Recommandation Clore.ai :** RTX 3090 (~~$0,30–1,00/jour) pour une marge de VRAM confortable. RTX 3060 convient pour le modèle Turbo. Pour le modèle Multilingual avec de longs textes, envisagez une RTX 4090 (~~$0,50–2,00/jour).

## Installation

```bash
# Installer depuis PyPI
pip install chatterbox-tts

# Ou installer depuis la source
git clone https://github.com/resemble-ai/chatterbox.git
cd chatterbox
pip install -e .

# Vérifier
python -c "from chatterbox.tts import ChatterboxTTS; print('Chatterbox ready')"
```

## Démarrage rapide

### Modèle Turbo (latence la plus faible)

```python
import torchaudio as ta
from chatterbox.tts_turbo import ChatterboxTurboTTS

model = ChatterboxTurboTTS.from_pretrained(device="cuda")

# TTS basique avec balises paralinguistiques
text = "Hey, welcome back! [chuckle] I've got some great news for you today."

# Clonage de voix — fournir un extrait de référence de 10+ secondes
wav = model.generate(text, audio_prompt_path="reference_voice.wav")

ta.save("output_turbo.wav", wav, model.sr)
print(f"Saved at {model.sr} Hz")
```

### Modèle Original (Anglais, contrôles créatifs)

```python
import torchaudio as ta
from chatterbox.tts import ChatterboxTTS

model = ChatterboxTTS.from_pretrained(device="cuda")

text = "The quick brown fox jumps over the lazy dog. It was a beautiful morning."

# Générer sans clonage de voix (utilise la voix par défaut)
wav = model.generate(text)
ta.save("output_default.wav", wav, model.sr)

# Générer avec clonage de voix
wav = model.generate(text, audio_prompt_path="my_voice_sample.wav")
ta.save("output_cloned.wav", wav, model.sr)
```

## Exemples d'utilisation

### Clonage de voix multilingue

```python
import torchaudio as ta
from chatterbox.mtl_tts import ChatterboxMultilingualTTS

model = ChatterboxMultilingualTTS.from_pretrained(device="cuda")

# Français
french_text = "Bonjour, comment allez-vous? Bienvenue dans notre démonstration."
wav_fr = model.generate(french_text, language_id="fr")
ta.save("output_french.wav", wav_fr, model.sr)

# Japonais
japanese_text = "こんにちは、テキスト読み上げのデモンストレーションです。"
wav_ja = model.generate(japanese_text, language_id="ja")
ta.save("output_japanese.wav", wav_ja, model.sr)

# Russe avec clonage de voix
russian_text = "Привет! Это демонстрация синтеза речи на русском языке."
wav_ru = model.generate(
    russian_text,
    language_id="ru",
    audio_prompt_path="russian_speaker.wav"
)
ta.save("output_russian.wav", wav_ru, model.sr)

print("Multilingual generation complete")
```

### Balises paralinguistiques (Turbo)

```python
import torchaudio as ta
from chatterbox.tts_turbo import ChatterboxTurboTTS

model = ChatterboxTurboTTS.from_pretrained(device="cuda")

samples = [
    ("greeting", "Hi there! [laugh] It's so good to see you again."),
    ("nervous", "Um, well [cough] I'm not really sure about that."),
    ("excited", "Oh my gosh! [chuckle] That's absolutely incredible news!"),
]

for name, text in samples:
    wav = model.generate(text, audio_prompt_path="speaker_ref.wav")
    ta.save(f"para_{name}.wav", wav, model.sr)
    print(f"Généré : {name}")
```

### Script de traitement par lot

```python
import torchaudio as ta
from chatterbox.tts import ChatterboxTTS
import os

model = ChatterboxTTS.from_pretrained(device="cuda")

# Traiter une liste de lignes (par ex., pour des chapitres de livre audio)
lines = [
    "Chapitre un. L'aventure commence.",
    "C'était une nuit noire et orageuse.",
    "Le héros se tenait au carrefour, incertain du chemin à suivre.",
]

os.makedirs("output_batch", exist_ok=True)

for i, line in enumerate(lines):
    wav = model.generate(line, audio_prompt_path="narrator_voice.wav")
    ta.save(f"output_batch/line_{i:03d}.wav", wav, model.sr)
    print(f"[{i+1}/{len(lines)}] {line[:40]}...")

print("Batch processing complete")
```

## Conseils pour les utilisateurs de Clore.ai

* **Choix du modèle** — utilisez Turbo pour des agents vocaux à faible latence, Original pour le travail créatif en anglais, Multilingual pour le contenu non anglais
* **Qualité de l'audio de référence** — utilisez un extrait propre et sans bruit de 10–30 secondes pour de meilleurs résultats de clonage de voix
* **Configuration Docker** — image de base `pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime`, exposer le port `7860/http` pour Gradio
* **Gestion de la mémoire** — appelez `torch.cuda.empty_cache()` entre de grands lots pour libérer de la VRAM
* **Langues prises en charge** — ar, da, de, el, en, es, fi, fr, he, hi, it, ja, ko, ms, nl, no, pl, pt, ru, sv, sw, tr, zh
* **Espace HuggingFace** — essayez avant de louer sur [huggingface.co/spaces/ResembleAI/Chatterbox](https://huggingface.co/spaces/ResembleAI/Chatterbox)

## Dépannage

| Problème                         | Solution                                                                                                                  |
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| `CUDA out of memory`             | Utilisez Turbo (350M) au lieu d'Original/Multilingual (500M), ou louez un GPU plus puissant                               |
| La voix clonée ne correspond pas | Utilisez un extrait de référence plus long (15–30 s), plus propre et avec un bruit de fond minimal                        |
| `numpy` conflit de version       | Exécutez `pip install numpy==1.26.4 --force-reinstall`                                                                    |
| Téléchargement lent du modèle    | Les modèles sont récupérés depuis HuggingFace lors du premier lancement (\~2 Go) ; pré-téléchargez avec `huggingface-cli` |
| L'audio contient des artefacts   | Réduisez la longueur du texte par génération ; des textes très longs peuvent dégrader la qualité                          |
| `ModuleNotFoundError`            | Assurez-vous que `pip install chatterbox-tts` terminé sans erreurs ; vérifiez la compatibilité avec Python 3.11           |


---

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

```
GET https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/chatterbox-tts.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.