# Clonación de voz con Zonos TTS

Zonos por [Zyphra](https://www.zyphra.com/) es un modelo de texto a voz de pesos abiertos de 0,4B parámetros entrenado en más de 200K horas de habla multilingüe. Realiza clonación de voz en zero-shot con solo 2–30 segundos de audio de referencia y ofrece control fino sobre la emoción, la velocidad de habla, la variación de tono y la calidad de audio. La salida es audio de alta fidelidad a 44 kHz. Hay dos variantes de modelo disponibles: Transformer (mejor calidad) y 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 desde 2–30 segundos** — no se requiere ajuste fino
* **Salida de alta fidelidad a 44 kHz** — calidad de audio de nivel de estudio
* **Control de emoción** — felicidad, tristeza, ira, miedo, sorpresa, asco mediante vector 8D
* **Velocidad de habla y tono** — control fino e independiente
* **Entradas de prefijo de audio** — permite susurros 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 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       | 11.8+              | 12.4           |
| Sistema    | espeak-ng          | —              |

**Recomendación de Clore.ai:** RTX 3090 (~~$0.30–1.00/día) para margen cómodo. RTX 4090 (~~$0.50–2.00/día) para el modelo Hybrid y la inferencia más rápida.

## Instalación

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

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

# Para el modelo Hybrid (requiere GPU Ampere+, es decir, serie RTX 3000 o más reciente)
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 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)

# Construir 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"Saved output.wav at {model.autoencoder.sampling_rate} Hz")
```

## Ejemplos de uso

### Control de emoción

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 = {
    "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"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 prisa en absoluto.",
    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="¡Date prisa! ¡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 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.

## Consejos para usuarios de Clore.ai

* **Elección de modelo** — Transformer para la mejor calidad, Hybrid para \~2× inferencia más rápida (requiere GPU RTX 3000+)
* **Audio de referencia** — 10–30 segundos de habla limpia dan mejores resultados; clips más cortos (2–5s) funcionan pero con menor fidelidad
* **Configuración con Docker** — usar `pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime`, agrega `apt-get install -y espeak-ng` al inicio
* **Mapeo de puertos** — exponer `7860/http` para la interfaz Gradio, `8000/http` para el servidor API
* **Control de semilla** — establece `torch.manual_seed()` antes de la generación para 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 fuera de memoria`      | Usa el modelo Transformer (más pequeño que Hybrid); reduce la longitud de texto por llamada     |
| El modelo Hybrid falla       | Requiere GPU Ampere+ (serie RTX 3000 o más reciente) y `pip install -e ".[compile]"`            |
| La voz clonada suena extraña | Usa un clip de referencia más largo (15–30s) con habla 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 RTX 4090 |
| `ModuleNotFoundError: zonos` | Asegúrate de haber instalado desde la fuente: `cd Zonos && pip install -e .`                    |


---

# Agent Instructions: 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-es/audio-y-voz/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.