> 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-es/audio-y-voz/zonos-tts.md).

# Clonación de voz Zonos TTS

Ejecuta Zonos TTS de Zyphra para clonación de voz con control de emoción y tono en GPUs de Clore.ai.

Zonos de [Zyphra](https://www.zyphra.com/) es un modelo de texto a voz de peso abierto con 0.4B de parámetros, entrenado con más de 200 mil horas de voz multilingüe. Realiza clonación de voz zero-shot a partir de solo 2–30 segundos de audio de referencia y ofrece un control detallado sobre la emoción, la velocidad de habla, la variación del tono y la calidad del audio. La salida es audio de alta fidelidad de 44 kHz. Hay dos variantes del modelo disponibles: Transformer (mejor calidad) e Hybrid/Mamba (inferencia más rápida).

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

## Características clave

* **Clonación de voz a partir de 2–30 segundos** — no requiere ajuste fino
* **salida de alta fidelidad de 44 kHz** — calidad de audio de nivel de estudio
* **Control de emociones** — felicidad, tristeza, ira, miedo, sorpresa, asco mediante un vector 8D
* **Velocidad de habla y tono** — control granular independiente
* **Entradas de prefijo de audio** — permite susurrar y otros comportamientos difíciles de clonar
* **Multilingüe** — inglés, japonés, chino, francés, alemán
* **Dos arquitecturas** — Transformer (calidad) y Hybrid/Mamba (velocidad, \~2× en tiempo real en una RTX 4090)
* **Apache 2.0** — gratis para uso personal y comercial

## Requisitos

| Componente | Mínimo             | Recomendado    |
| ---------- | ------------------ | -------------- |
| GPU        | RTX 3080 10 GB     | RTX 4090 24 GB |
| VRAM       | 6 GB (Transformer) | 10 GB+         |
| RAM        | 16 GB              | 32 GB          |
| Disco      | 10 GB              | 20 GB          |
| Python     | 3.10+              | 3.11           |
| CUDA       | 12.8+              | 12.8+          |
| Sistema    | espeak-ng          | —              |

**Recomendación de Clore.ai:** RTX 3090 ($0.07–0.21/h) para un margen cómodo. RTX 4090 ($0.14–0.42/h) para el modelo Hybrid y la inferencia más rápida.

## Instalación

```bash
# Instalar dependencia del sistema
apt-get install -y espeak-ng

# Clonar e instalar
git clone https://github.com/Zyphra/Zonos.git
cd Zonos
pip install -e .

# Para el modelo Hybrid (requiere una GPU Ampere+; es decir, serie RTX 3000 o más nueva)
pip install -e ".[compile]"

# Verificar
python -c "from zonos.model import Zonos; print('Zonos listo')"
```

## Inicio rápido

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

# Cargar el modelo (descarga los pesos en la primera ejecución)
model = Zonos.from_pretrained("Zyphra/Zonos-v0.1-transformer", device="cuda")

# Cargar audio de referencia para la clonación de voz
wav, sr = torchaudio.load("reference_speaker.wav")
speaker = model.make_speaker_embedding(wav, sr)

# Crear el condicionamiento
cond_dict = make_cond_dict(
    text="¡Hola desde Clore.ai! Esta es una demostración de clonación de voz.",
    speaker=speaker,
    language="en-us",
)
conditioning = model.prepare_conditioning(cond_dict)

# Generar
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"Guardado output.wav a {model.autoencoder.sampling_rate} Hz")
```

## Ejemplos de uso

### Control de emociones

Zonos acepta un vector de emoción de 8 dimensiones: `[felicidad, tristeza, asco, miedo, sorpresa, ira, otro, neutral]`.

```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 = "¡No puedo creer lo que acaba de pasar hoy!"

emotions = {
    "feliz":   [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
    "triste":     [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
    "enojado":   [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
    "temeroso": [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"Generado: {name}")
```

### Control de velocidad de habla y tono

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

# Lento y tranquilo
cond_slow = make_cond_dict(
    text="Tómate tu tiempo. No hay ninguna prisa.",
    speaker=speaker,
    language="en-us",
    speaking_rate=torch.tensor([8.0]),   # menor = más lento
    pitch_std=torch.tensor([20.0]),      # menor = más monótono
)
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)

# Rápido y enérgico
cond_fast = make_cond_dict(
    text="¡Apúrate! ¡Tenemos que irnos ahora mismo!",
    speaker=speaker,
    language="en-us",
    speaking_rate=torch.tensor([22.0]),  # mayor = más rápido
    pitch_std=torch.tensor([80.0]),      # mayor = más expresivo
)
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)
```

### Interfaz web de Gradio

```bash
cd Zonos
python gradio_interface.py
# O con uv:
# uv run gradio_interface.py
```

Exponer puerto `7860/http` en tu pedido de Clore.ai y abre la `http_pub` URL para acceder a la interfaz de usuario.

## Consejos para usuarios de Clore.ai

* **Elección del modelo** — Transformer para la mejor calidad, Hybrid para una inferencia \~2× más rápida (requiere GPU RTX 3000+)
* **Audio de referencia** — 10–30 segundos de voz limpia ofrecen los mejores resultados; fragmentos más cortos (2–5 s) funcionan, pero con menor fidelidad
* **Configuración de Docker** — usa `pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime`, añade `apt-get install -y espeak-ng` al inicio
* **Mapeo de puertos** — expone `7860/http` para la interfaz de Gradio, `8000/http` para el servidor API
* **Control de semilla** — establece `torch.manual_seed()` antes de la generación para una salida reproducible
* **Parámetro de calidad de audio** — experimenta con el `audio_quality` campo de condicionamiento para una salida más limpia

## Solución de problemas

| Problema                     | Solución                                                                                            |
| ---------------------------- | --------------------------------------------------------------------------------------------------- |
| `espeak-ng no encontrado`    | Ejecuta `apt-get install -y espeak-ng` (requerido para la fonemización)                             |
| `CUDA sin memoria`           | Usa el modelo Transformer (más pequeño que Hybrid); reduce la longitud del texto por llamada        |
| El modelo Hybrid falla       | Requiere una GPU Ampere+ (serie RTX 3000 o más nueva) y `pip install -e ".[compile]"`               |
| La voz clonada suena rara    | Usa un fragmento de referencia más largo (15–30 s) con voz clara y ruido de fondo mínimo            |
| Generación lenta             | Normal para Transformer (\~0.5× en tiempo real); Hybrid alcanza \~2× en tiempo real en una RTX 4090 |
| `ModuleNotFoundError: zonos` | Asegúrate de haberlo instalado desde el código fuente: `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-es/audio-y-voz/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.