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

# Clonage vocal Zonos TTS

Exécutez Zonos TTS de Zyphra pour le clonage de voix avec contrôle de l'émotion et de la hauteur sur les GPU Clore.ai.

Zonos par [Zyphra](https://www.zyphra.com/) est un modèle de synthèse vocale à poids ouverts de 0,4 milliard de paramètres, entraîné sur plus de 200 000 heures de parole multilingue. Il réalise un clonage de voix en zéro-shot à partir de seulement 2 à 30 secondes d’audio de référence et offre un contrôle fin de l’émotion, du débit de parole, de la variation de hauteur et de la qualité audio. La sortie est un audio haute fidélité à 44 kHz. Deux variantes du modèle sont disponibles : Transformer (meilleure qualité) et Hybride/Mamba (inférence plus rapide).

**GitHub :** [Zyphra/Zonos](https://github.com/Zyphra/Zonos) **HuggingFace :** [Zyphra/Zonos-v0.1-transformer](https://huggingface.co/Zyphra/Zonos-v0.1-transformer) **Licence :** Apache 2.0

## Caractéristiques clés

* **Clonage de voix à partir de 2 à 30 secondes** — aucune fine-tuning requise
* **Sortie haute fidélité à 44 kHz** — qualité audio de niveau studio
* **Contrôle des émotions** — bonheur, tristesse, colère, peur, surprise, dégoût via un vecteur 8D
* **Débit de parole et hauteur** — contrôle fin indépendant
* **Entrées de préfixe audio** — permet le chuchotement et d’autres comportements difficiles à reproduire
* **Multilingue** — anglais, japonais, chinois, français, allemand
* **Deux architectures** — Transformer (qualité) et Hybride/Mamba (vitesse, \~2× temps réel sur RTX 4090)
* **Apache 2.0** — gratuit pour un usage personnel et commercial

## Exigences

| Composant | Minimum            | Recommandé     |
| --------- | ------------------ | -------------- |
| GPU       | RTX 3080 10 Go     | RTX 4090 24 Go |
| VRAM      | 6 Go (Transformer) | 10 Go+         |
| RAM       | 16 Go              | 32 Go          |
| Disque    | 10 Go              | 20 Go          |
| Python    | 3.10+              | 3.11           |
| CUDA      | 12.8+              | 12.8+          |
| Système   | espeak-ng          | —              |

**Recommandation de Clore.ai :** RTX 3090 (0,07–0,21 $/h) pour une marge confortable. RTX 4090 (0,14–0,42 $/h) pour le modèle Hybride et l’inférence la plus rapide.

## Installation

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

# Cloner et installer
git clone https://github.com/Zyphra/Zonos.git
cd Zonos
pip install -e .

# Pour le modèle Hybride (nécessite un GPU Ampere+, c’est-à-dire une série RTX 3000 ou plus récente)
pip install -e ".[compile]"

# Vérifier
python -c "from zonos.model import Zonos; print('Zonos prêt')"
```

## Démarrage rapide

```python
import torch
import torchaudio
from zonos.model import Zonos
from zonos.conditioning import make_cond_dict

# Charger le modèle (télécharge les poids lors de la première exécution)
model = Zonos.from_pretrained("Zyphra/Zonos-v0.1-transformer", device="cuda")

# Charger l’audio de référence pour le clonage de voix
wav, sr = torchaudio.load("reference_speaker.wav")
speaker = model.make_speaker_embedding(wav, sr)

# Construire le conditionnement
cond_dict = make_cond_dict(
    text="Bonjour depuis Clore.ai ! Ceci est une démonstration de clonage de voix.",
    speaker=speaker,
    language="en-us",
)
conditioning = model.prepare_conditioning(cond_dict)

# Générer
torch.manual_seed(42)
codes = model.generate(conditioning)
wavs = model.autoencoder.decode(codes).cpu()

torchaudio.save("output.wav", wavs[0], model.autoencoder.sampling_rate)
print(f"output.wav enregistré à {model.autoencoder.sampling_rate} Hz")
```

## Exemples d'utilisation

### Contrôle des émotions

Zonos accepte un vecteur d’émotion à 8 dimensions : `[bonheur, tristesse, dégoût, peur, surprise, colère, autre, neutre]`.

```python
import torch
import torchaudio
from zonos.model import Zonos
from zonos.conditioning import make_cond_dict

model = Zonos.from_pretrained("Zyphra/Zonos-v0.1-transformer", device="cuda")

wav, sr = torchaudio.load("speaker_ref.wav")
speaker = model.make_speaker_embedding(wav, sr)

text = "Je n’arrive pas à croire ce qui vient de se passer aujourd’hui !"

emotions = {
    "happy":   [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
    "sad":     [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
    "angry":   [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
    "fearful": [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
    "neutral": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
}

for name, emo_vec in emotions.items():
    cond_dict = make_cond_dict(
        text=text,
        speaker=speaker,
        language="en-us",
        emotion=torch.tensor(emo_vec).unsqueeze(0),
    )
    conditioning = model.prepare_conditioning(cond_dict)
    codes = model.generate(conditioning)
    audio = model.autoencoder.decode(codes).cpu()
    torchaudio.save(f"emotion_{name}.wav", audio[0], model.autoencoder.sampling_rate)
    print(f"Généré : {name}")
```

### Contrôle du débit de parole et de la hauteur

```python
import torch
import torchaudio
from zonos.model import Zonos
from zonos.conditioning import make_cond_dict

model = Zonos.from_pretrained("Zyphra/Zonos-v0.1-transformer", device="cuda")

wav, sr = torchaudio.load("speaker_ref.wav")
speaker = model.make_speaker_embedding(wav, sr)

# Lent et calme
cond_slow = make_cond_dict(
    text="Prenez votre temps. Il n’y a absolument aucune urgence.",
    speaker=speaker,
    language="en-us",
    speaking_rate=torch.tensor([8.0]),   # plus bas = plus lent
    pitch_std=torch.tensor([20.0]),      # plus bas = plus monotone
)
codes = model.generate(model.prepare_conditioning(cond_slow))
audio = model.autoencoder.decode(codes).cpu()
torchaudio.save("slow_calm.wav", audio[0], model.autoencoder.sampling_rate)

# Rapide et énergique
cond_fast = make_cond_dict(
    text="Dépêchez-vous ! Nous devons partir tout de suite !",
    speaker=speaker,
    language="en-us",
    speaking_rate=torch.tensor([22.0]),  # plus haut = plus rapide
    pitch_std=torch.tensor([80.0]),      # plus haut = plus expressif
)
codes = model.generate(model.prepare_conditioning(cond_fast))
audio = model.autoencoder.decode(codes).cpu()
torchaudio.save("fast_energetic.wav", audio[0], model.autoencoder.sampling_rate)
```

### Interface web Gradio

```bash
cd Zonos
python gradio_interface.py
# Ou avec uv :
# uv run gradio_interface.py
```

Exposer le port `7860/http` dans votre commande Clore.ai et ouvrez l’ `http_pub` URL pour accéder à l’interface.

## Conseils pour les utilisateurs de Clore.ai

* **Choix du modèle** — Transformer pour la meilleure qualité, Hybride pour une inférence \~2× plus rapide (nécessite un GPU RTX 3000+)
* **Audio de référence** — 10 à 30 secondes de parole propre donnent les meilleurs résultats ; des clips plus courts (2 à 5 s) fonctionnent, mais avec une fidélité moindre
* **Configuration Docker** — utiliser `pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime` , ajouter `apt-get install -y espeak-ng` au démarrage
* **Mappage des ports** — exposer `7860/http` pour l’interface Gradio, `8000/http` pour le serveur API
* **Contrôle de la graine** — définissez `torch.manual_seed()` avant la génération pour un résultat reproductible
* **Paramètre de qualité audio** — expérimentez avec le champ de conditionnement `audio_quality` pour une sortie plus propre

## Dépannage

| Problème                      | Solution                                                                                               |
| ----------------------------- | ------------------------------------------------------------------------------------------------------ |
| `espeak-ng introuvable`       | Exécutez `apt-get install -y espeak-ng` (requis pour la phonémisation)                                 |
| `Mémoire CUDA insuffisante`   | Utilisez le modèle Transformer (plus petit que Hybride) ; réduisez la longueur du texte par appel      |
| Échec du modèle Hybride       | Nécessite un GPU Ampere+ (série RTX 3000 ou plus récente) et `pip install -e ".[compile]"`             |
| La voix clonée sonne mal      | Utilisez un clip de référence plus long (15 à 30 s) avec une parole claire et un bruit de fond minimal |
| Génération lente              | Normal pour Transformer (\~0,5× temps réel) ; Hybride atteint \~2× temps réel sur une RTX 4090         |
| `ModuleNotFoundError : zonos` | Assurez-vous de l’avoir installé depuis les sources : `cd Zonos && pip install -e .`                   |


---

# 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/zonos-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.