> 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

Zonos par [Zyphra](https://www.zyphra.com/) est un modèle de synthèse vocale text-to-speech en open-weight de 0,4 milliard de paramètres entraîné sur plus de 200 000 heures de voix multilingues. Il réalise un clonage vocal 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 de modèle sont disponibles : Transformer (meilleure qualité) et Hybrid/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

## Principales caractéristiques

* **Clonage vocal à partir de 2–30 secondes** — aucun fine-tuning requis
* **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 indépendant et fin
* **Entrées de préfixe audio** — permet le chuchotement et d'autres comportements difficiles à cloner
* **Multilingue** — anglais, japonais, chinois, français, allemand
* **Deux architectures** — Transformer (qualité) et Hybrid/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 GB     | RTX 4090 24 Go |
| VRAM      | 6 GB (Transformer) | 10 GB+         |
| RAM       | 16 Go              | 32 Go          |
| Disque    | 10 Go              | 20 Go          |
| Python    | 3.10+              | 3.11           |
| CUDA      | 11.8+              | 12.4           |
| Système   | espeak-ng          | —              |

**Recommandation Clore.ai :** RTX 3090 (\~\~0,30–1,00 $/jour) pour une marge confortable. RTX 4090 (\~\~0,50–2,00 $/jour) pour le modèle Hybrid 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 Hybrid (requiert un GPU Ampere+, c.-à-d. série RTX 3000 ou plus récent)
pip install -e ".[compile]"

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

## 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 au premier lancement)
model = Zonos.from_pretrained("Zyphra/Zonos-v0.1-transformer", device="cuda")

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

# Construire le conditionnement
cond_dict = make_cond_dict(
    text="Hello from Clore.ai! This is a voice cloning demonstration.",
    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"Saved output.wav at {model.autoencoder.sampling_rate} Hz")
```

## Exemples d'utilisation

### Contrôle de l'émotion

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 = "I can't believe what just happened today!"

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="Take your time. There is no rush at all.",
    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="Hurry up! We need to go right now!",
    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 le `http_pub` URL pour accéder à l'interface utilisateur.

## Conseils pour les utilisateurs de Clore.ai

* **Choix du modèle** — Transformer pour la meilleure qualité, Hybrid pour une inférence \~2× plus rapide (requiert GPU RTX 3000+)
* **Audio de référence** — 10–30 secondes de parole propre donnent les meilleurs résultats ; des extraits plus courts (2–5 s) fonctionnent mais avec une fidélité moindre
* **Configuration Docker** — utiliser `pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime`, ajouter `apt-get install -y espeak-ng` au démarrage
* **Mappage de 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 une sortie reproductible
* **Paramètre de qualité audio** — expérimentez avec le `audio_quality` champ de conditionnement 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)                                  |
| `CUDA out of memory`          | Utilisez le modèle Transformer (plus petit que Hybrid) ; réduisez la longueur du texte par appel        |
| Le modèle Hybrid échoue       | Requiert un GPU Ampere+ (série RTX 3000 ou plus récente) et `pip install -e ".[compile]"`               |
| La voix clonée sonne étrange  | Utilisez un extrait 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) ; Hybrid atteint \~2× temps réel sur RTX 4090               |
| `ModuleNotFoundError : zonos` | Assurez-vous d'avoir installé depuis la source : `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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/zonos-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.