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

# Dia TTS (Nari Labs)

Genera diálogo multihablante con emoción usando Dia TTS de Nari Labs

Dia de Nari Labs es un modelo avanzado de texto a voz que se especializa en **diálogos realistas entre varios hablantes**. A diferencia del TTS tradicional que maneja un hablante a la vez, Dia genera conversaciones naturales entre múltiples hablantes con emoción, risa, vacilación y otras señales no verbales. Con 1.6 mil millones de parámetros, funciona en cualquier GPU de 8 GB o más.

## Características clave

* **Diálogo multihablante**: Genera conversaciones entre 2 o más hablantes en una sola pasada
* **Señales no verbales**: Risa `(ríe)`, vacilación `(suspira)`, pausas — integradas automáticamente
* **Habla emocional**: Entonación natural sin etiquetas de emoción explícitas
* **1.6 mil millones de parámetros**: Cabe en una RTX 3070/3080 (8-10 GB de VRAM)
* **licencia Apache 2.0**: Uso comercial completo
* **Integración con HuggingFace**: Funciona con la biblioteca Transformers

## Requisitos

| Componente | Mínimo         | Recomendado     |
| ---------- | -------------- | --------------- |
| GPU        | RTX 3070 (8GB) | RTX 3080 (10GB) |
| VRAM       | 8GB            | 10GB+           |
| RAM        | 16GB           | 32GB            |
| Disco      | 10GB           | 15 GB           |
| Python     | 3.9+           | 3.11            |

**GPU recomendada de Clore.ai**: RTX 3080 de 10 GB ($0.05–0.19/h)

## Instalación

```bash
# Opción 1: pip install
pip install dia-tts

# Opción 2: Desde el código fuente
git clone https://github.com/nari-labs/dia.git
cd dia
pip install -e .
```

## Inicio rápido

### Diálogo multihablante básico

```python
from dia import Dia

# Cargar modelo
model = Dia.from_pretrained("nari-labs/Dia-1.6B")

# Generar conversación entre varios hablantes
# [S1] = Hablante 1, [S2] = Hablante 2
text = """[S1] Oye, ¿has probado la nueva plataforma de alquiler de GPU?
[S2] ¿Te refieres a Clore? Sí, alquilé una RTX 4090 ayer.
[S1] ¿Qué tal estuvo?
[S2] (ríe) ¿Sinceramente? Mucho más barato de lo que esperaba. Como dos dólares al día.
[S1] No puede ser. Eso... eso es realmente una locura."""

audio = model.generate(text)

# Guardar en archivo
import soundfile as sf
sf.write("dialog.wav", audio, samplerate=24000)
```

### Con emoción y señales no verbales

```python
# Dia maneja automáticamente los patrones naturales del habla
text = """[S1] Acabo de recibir los resultados...
[S2] ¿Y? ¡No me tengas en vilo!
[S1] (suspira) Aprobamos. De verdad aprobamos todas las pruebas.
[S2] (ríe) ¡Te lo dije! ¡Te dije que lo lograríamos!
[S1] No me lo puedo creer... (ríe) vale, vale, vamos a celebrarlo."""

audio = model.generate(text, temperature=0.8)
sf.write("emotional_dialog.wav", audio, samplerate=24000)
```

### Un solo hablante

```python
# También funciona para un solo hablante
text = "[S1] Bienvenido a la documentación de Clore AI. En esta guía, veremos cómo configurar tu primer alquiler de GPU e implementar un modelo de aprendizaje automático."

audio = model.generate(text)
sf.write("narration.wav", audio, samplerate=24000)
```

## Interfaz web de Gradio

```python
# Iniciar demostración interactiva
python -m dia.app --port 7860 --share

# O manualmente:
import gradio as gr
from dia import Dia

model = Dia.from_pretrained("nari-labs/Dia-1.6B")

def generate_speech(text):
    audio = model.generate(text)
    return (24000, audio)

demo = gr.Interface(
    fn=generate_speech,
    inputs=gr.Textbox(label="Diálogo (usa las etiquetas [S1], [S2])", lines=10),
    outputs=gr.Audio(label="Audio generado"),
    title="Dia TTS — Diálogo multihablante"
)
demo.launch(server_port=7860)
```

## Casos de uso

* **Generación de pódcast**: Crea podcasts conversacionales a partir de guiones
* **Diálogos para audiolibros**: Genera conversaciones de personajes con voces distintas
* **Diálogo de videojuegos**: Conversaciones de NPC con patrones naturales del habla
* **Datos de entrenamiento**: Genera conjuntos de datos de voz diversos para entrenamiento de ASR
* **Voces de chatbot**: Diálogo de varios turnos con respuestas emocionales

## Consejos para usuarios de Clore.ai

* **La RTX 3080 es ideal**: 10 GB de VRAM manejan Dia fácilmente por $0.05–0.19/h
* **Generación por lotes**: Procesa varios diálogos en un bucle para maximizar tu tiempo de alquiler
* **Guarda los modelos en almacenamiento persistente**: Si tu instancia de Clore tiene disco persistente, almacena en caché el modelo para evitar volver a descargarlo
* **Temperatura 0.7–0.9**: Más baja = más consistente, más alta = más expresiva/variada
* **Solo inglés**: Dia actualmente se centra en inglés — para multilingüe, consulta la guía de Qwen3-TTS

## Solución de problemas

| Problema                           | Solución                                                                                            |
| ---------------------------------- | --------------------------------------------------------------------------------------------------- |
| CUDA sin memoria                   | Usa `model.to("cuda", torch_dtype=torch.float16)` para precisión media                              |
| Los hablantes suenan parecidos     | Añade más texto/contexto por hablante; prueba con una temperatura más alta                          |
| Se ignoran las señales no verbales | Asegúrate de que el formato sea correcto: `(ríe)`, `(suspira)` entre paréntesis                     |
| Calidad de audio baja              | Aumenta `num_steps` parámetro si está disponible; asegúrate de una frecuencia de muestreo de 24 kHz |

## Lecturas adicionales

* [GitHub de Nari Labs](https://github.com/nari-labs/dia)
* [Modelo de HuggingFace](https://huggingface.co/nari-labs/Dia-1.6B)
* [Comparación: Dia vs ElevenLabs](https://nari-labs.github.io/dia/) — página oficial de demostración


---

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