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

# Kokoro TTS

Exécutez Kokoro TTS — un modèle de synthèse vocale ultra-léger de 82M de paramètres sur les GPU Clore.ai.

Kokoro est un modèle de synthèse vocale de 82 M de paramètres qui surpasse largement sa catégorie. Malgré sa très petite taille (moins de 2 Go de VRAM), il produit une voix anglaise remarquablement naturelle et fonctionne en temps réel, voire plus vite, même sur du matériel bon marché. Avec une licence Apache 2.0, plusieurs styles de voix intégrés et la prise en charge de l’inférence sur CPU, Kokoro est idéal pour les applications en temps réel, les chatbots et les déploiements en périphérie.

**HuggingFace :** [hexgrad/Kokoro-82M](https://huggingface.co/hexgrad/Kokoro-82M) **PyPI :** [kokoro](https://pypi.org/project/kokoro/) **Licence :** Apache 2.0

## Caractéristiques clés

* **82 M de paramètres** — l’un des plus petits modèles TTS de haute qualité disponibles
* **< 2 Go de VRAM** — fonctionne sur pratiquement n’importe quel GPU, et même sur CPU
* **Plusieurs styles de voix** — anglais américain, anglais britannique ; voix masculines et féminines
* **En temps réel ou plus rapide** — inférence à faible latence adaptée au streaming
* **Génération en streaming** — renvoie des segments audio au fur et à mesure de leur production
* **Prise en charge multilingue** — anglais (principal), japonais (`misaki[ja]`), chinois (`misaki[zh]`)
* **Apache 2.0** — gratuit pour un usage personnel et commercial

## Exigences

| Composant | Minimum                              | Recommandé |
| --------- | ------------------------------------ | ---------- |
| GPU       | N’importe quel GPU avec 2 Go de VRAM | RTX 3060   |
| VRAM      | 2 Go                                 | 4 Go       |
| RAM       | 4 Go                                 | 8 Go       |
| Disque    | 500 Mo                               | 1 Go       |
| Python    | 3.9+                                 | 3.11       |
| Système   | espeak-ng installé                   | —          |

**Recommandation de Clore.ai :** Une RTX 3060 (0,03 à 0,07 $/h) est largement suffisante. Kokoro peut même fonctionner sur des instances CPU uniquement pour une synthèse vocale très économique.

## Installation

```bash
# Installer la dépendance système
apt-get install -y espeak-ng

# Installer Kokoro et les E/S audio
pip install kokoro>=0.9.4 soundfile torch

# Pour la prise en charge du japonais (facultatif)
pip install misaki[ja]

# Pour la prise en charge du chinois (facultatif)
pip install misaki[zh]

# Vérifier
python -c "from kokoro import KPipeline; print('Kokoro prêt')"
```

## Démarrage rapide

```python
from kokoro import KPipeline
import soundfile as sf

# Initialiser le pipeline
# 'a' = anglais américain, 'b' = anglais britannique
pipeline = KPipeline(lang_code='a')

text = """
Kokoro est un modèle de synthèse vocale léger avec seulement quatre-vingt-deux millions
de paramètres. Malgré sa petite taille, il produit une voix naturelle et expressive.
"""

# Générer l’audio — options de voix : af_heart, af_bella, af_nicole, af_sarah, af_sky,
#                                  am_adam, am_michael, bf_emma, bf_isabella, bm_george, bm_lewis
generator = pipeline(text, voice='af_heart', speed=1.0)

for i, (graphemes, phonemes, audio) in enumerate(generator):
    sf.write(f'output_{i}.wav', audio, 24000)
    print(f"Segment {i} : {graphemes[:50]}...")

print("Terminé !")
```

## Exemples d'utilisation

### Comparaison de plusieurs voix

Générez le même texte avec différentes voix pour comparer :

```python
from kokoro import KPipeline
import soundfile as sf

pipeline = KPipeline(lang_code='a')

text = "Bienvenue sur Clore.ai, la place de marché GPU de pair à pair."

voices = ['af_heart', 'af_bella', 'am_adam', 'am_michael']

for voice in voices:
    generator = pipeline(text, voice=voice, speed=1.0)
    for i, (gs, ps, audio) in enumerate(generator):
        sf.write(f'{voice}_{i}.wav', audio, 24000)
    print(f"Généré : {voice}")
```

### Anglais britannique avec contrôle de la vitesse

```python
from kokoro import KPipeline
import soundfile as sf

# 'b' = anglais britannique
pipeline = KPipeline(lang_code='b')

text = "Bon après-midi. Ceci est une démonstration de synthèse en anglais britannique."

# speed < 1.0 = plus lent, speed > 1.0 = plus rapide
generator = pipeline(text, voice='bf_emma', speed=0.85)

all_audio = []
for gs, ps, audio in generator:
    all_audio.append(audio)

import numpy as np
combined = np.concatenate(all_audio)
sf.write('british_slow.wav', combined, 24000)
print(f"Durée totale : {len(combined)/24000:.1f}s")
```

### Traitement de fichiers par lots

Traitez plusieurs textes et concaténez-les en un seul fichier de type livre audio :

```python
from kokoro import KPipeline
import soundfile as sf
import numpy as np

pipeline = KPipeline(lang_code='a')

chapters = [
    "Chapitre un. Le début de notre voyage commence ici.",
    "Le soleil s’est levé au-dessus des montagnes, projetant de longues ombres sur la vallée.",
    "Elle ouvrit la porte et entra dans l’inconnu.",
]

all_audio = []
silence = np.zeros(int(24000 * 0.5))  # 0,5 s de silence entre les chapitres

for idx, text in enumerate(chapters):
    for gs, ps, audio in pipeline(text, voice='af_bella', speed=1.0):
        all_audio.append(audio)
    all_audio.append(silence)
    print(f"Chapitre {idx+1} terminé")

combined = np.concatenate(all_audio)
sf.write('audiobook.wav', combined, 24000)
print(f"Total : {len(combined)/24000:.1f}s")
```

## Conseils pour les utilisateurs de Clore.ai

* **Inférence sur CPU** — Kokoro est suffisamment petit pour fonctionner sur CPU ; utile pour les charges de travail sensibles au coût ou lorsque les GPU ne sont pas disponibles
* **Flux continu** — le générateur renvoie les segments audio au fur et à mesure de leur production, ce qui permet une lecture en temps réel dans les applications web
* **Combiner avec WhisperX** — utilisez WhisperX pour la transcription et Kokoro pour la resynthèse dans les pipelines vocaux
* **Docker** — utiliser `pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime` et ajoutez `apt-get install -y espeak-ng` à votre startup
* **Cohérence vocale** — conservez un seul identifiant de voix par projet pour une expérience de narrateur cohérente
* **Efficacité des coûts** — à 0,03 à 0,07 $/h sur une RTX 3060, Kokoro est l’une des solutions TTS auto-hébergées les moins chères

## Dépannage

| Problème                              | Solution                                                                                                                    |
| ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| `espeak-ng introuvable`               | Exécutez `apt-get install -y espeak-ng` (dépendance système requise)                                                        |
| `ModuleNotFoundError: kokoro`         | Installez avec `pip install kokoro>=0.9.4 soundfile`                                                                        |
| Le son de l’audio est robotique       | Essayez une autre voix (par ex. : `af_heart` a tendance à sonner le plus naturellement)                                     |
| Le japonais/chinois ne fonctionne pas | Installez les options linguistiques : `pip install misaki[ja]` ou `misaki[zh]`                                              |
| Manque de mémoire sur CPU             | Réduisez la longueur du texte par appel ; Kokoro diffuse les segments, donc la mémoire reste bornée                         |
| Premier lancement lent                | Les poids du modèle se téléchargent lors de la première utilisation (\~200 Mo) ; les exécutions suivantes sont instantanées |


---

# 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/kokoro-tts.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.