# Kokoro TTS

Kokoro es un modelo de texto a voz de 82 millones de parámetros que rinde mucho más de lo que su categoría sugiere. A pesar de su tamaño diminuto (menos de 2 GB de VRAM), produce un habla en inglés notablemente natural y se ejecuta a velocidades en tiempo real o superiores incluso en hardware económico. Con licencia Apache 2.0, múltiples estilos de voz incorporados y soporte de inferencia en CPU, Kokoro es ideal para aplicaciones en tiempo real, chatbots y despliegues en el edge.

**HuggingFace:** [hexgrad/Kokoro-82M](https://huggingface.co/hexgrad/Kokoro-82M) **PyPI:** [kokoro](https://pypi.org/project/kokoro/) **Licencia:** Apache 2.0

## Características clave

* **82M parámetros** — uno de los modelos TTS de alta calidad más pequeños disponibles
* **< 2 GB VRAM** — se ejecuta en prácticamente cualquier GPU e incluso en CPU
* **Múltiples estilos de voz** — inglés americano, inglés británico; voces masculinas y femeninas
* **En tiempo real o más rápido** — inferencia de baja latencia adecuada para streaming
* **Generación en streaming** — produce fragmentos de audio a medida que se generan
* **Soporte multilingüe** — inglés (principal), japonés (`misaki[ja]`), chino (`misaki[zh]`)
* **Apache 2.0** — gratis para uso personal y comercial

## Requisitos

| Componente | Mínimo                   | Recomendado |
| ---------- | ------------------------ | ----------- |
| GPU        | Cualquiera con 2 GB VRAM | RTX 3060    |
| VRAM       | 2 GB                     | 4 GB        |
| RAM        | 4 GB                     | 8 GB        |
| Disco      | 500 MB                   | 1 GB        |
| Python     | 3.9+                     | 3.11        |
| Sistema    | espeak-ng instalado      | —           |

**Recomendación de Clore.ai:** Una RTX 3060 (\~$0.15–0.30/día) es más que suficiente. Kokoro incluso puede ejecutarse en instancias solo con CPU para TTS extremadamente rentable.

## Instalación

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

# Instalar Kokoro y E/S de audio
pip install kokoro>=0.9.4 soundfile torch

# Para soporte de japonés (opcional)
pip install misaki[ja]

# Para soporte de chino (opcional)
pip install misaki[zh]

# Verificar
python -c "from kokoro import KPipeline; print('Kokoro listo')"
```

## Inicio rápido

```python
from kokoro import KPipeline
import soundfile as sf

# Inicializar pipeline
# 'a' = inglés americano, 'b' = inglés británico
pipeline = KPipeline(lang_code='a')

text = """
Kokoro es un modelo de texto a voz ligero con solo ochenta y dos millones
de parámetros. A pesar de su pequeño tamaño, produce un habla natural y expresiva.
"""

# Generar audio — opciones de voz: af_heart, af_bella, af_nicole, af_sarah, af_sky,
#                                  am_adam, am_michael, bf_emma, bf_isabella, bm_george, bm_lewis
generator = pipeline(text, voice='af_heart', speed=1.0)

for i, (graphemes, phonemes, audio) in enumerate(generator):
    sf.write(f'output_{i}.wav', audio, 24000)
    print(f"Fragmento {i}: {graphemes[:50]}...")

print("¡Hecho!")
```

## Ejemplos de uso

### Comparación de múltiples voces

Genera el mismo texto con diferentes voces para comparar:

```python
from kokoro import KPipeline
import soundfile as sf

pipeline = KPipeline(lang_code='a')

text = "Welcome to Clore.ai, the peer-to-peer GPU marketplace."

voices = ['af_heart', 'af_bella', 'am_adam', 'am_michael']

for voice in voices:
    generator = pipeline(text, voice=voice, speed=1.0)
    for i, (gs, ps, audio) in enumerate(generator):
        sf.write(f'{voice}_{i}.wav', audio, 24000)
    print(f"Generado: {voice}")
```

### Inglés británico con control de velocidad

```python
from kokoro import KPipeline
import soundfile as sf

# 'b' = inglés británico
pipeline = KPipeline(lang_code='b')

text = "Good afternoon. This is a demonstration of British English synthesis."

# speed < 1.0 = más lento, speed > 1.0 = más rápido
generator = pipeline(text, voice='bf_emma', speed=0.85)

all_audio = []
for gs, ps, audio in generator:
    all_audio.append(audio)

import numpy as np
combined = np.concatenate(all_audio)
sf.write('british_slow.wav', combined, 24000)
print(f"Duración total: {len(combined)/24000:.1f}s")
```

### Procesamiento por lotes de archivos

Procesa múltiples textos y concaténalos en un único archivo al estilo audiolibro:

```python
from kokoro import KPipeline
import soundfile as sf
import numpy as np

pipeline = KPipeline(lang_code='a')

chapters = [
    "Capítulo uno. El comienzo de nuestro viaje comienza aquí.",
    "El sol se elevó sobre las montañas, proyectando largas sombras a través del valle.",
    "Ella abrió la puerta y dio un paso hacia lo desconocido.",
]

all_audio = []
silence = np.zeros(int(24000 * 0.5))  # 0.5s de silencio entre capítulos

for idx, text in enumerate(chapters):
    for gs, ps, audio in pipeline(text, voice='af_bella', speed=1.0):
        all_audio.append(audio)
    all_audio.append(silence)
    print(f"Capítulo {idx+1} terminado")

combined = np.concatenate(all_audio)
sf.write('audiobook.wav', combined, 24000)
print(f"Total: {len(combined)/24000:.1f}s")
```

## Consejos para usuarios de Clore.ai

* **Inferencia en CPU** — Kokoro es lo suficientemente pequeño como para ejecutarse en CPU; útil para cargas de trabajo sensibles al costo o cuando no hay GPUs disponibles
* **Streaming** — el generador produce fragmentos de audio a medida que se generan, lo que permite la reproducción en tiempo real en aplicaciones web
* **Combinar con WhisperX** — usa WhisperX para transcripción y Kokoro para re-síntesis en pipelines de voz
* **Docker** — usar `pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime` y añade `apt-get install -y espeak-ng` a tu inicio
* **Consistencia de voz** — mantén un ID de voz por proyecto para una experiencia de narrador consistente
* **Eficiencia de costes** — a $0.15/día en una RTX 3060, Kokoro es una de las soluciones TTS más baratas para alojar uno mismo

## Solución de problemas

| Problema                      | Solución                                                                                                      |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `espeak-ng no encontrado`     | Ejecuta `apt-get install -y espeak-ng` (dependencia del sistema requerida)                                    |
| `ModuleNotFoundError: kokoro` | Instalar con `pip install kokoro>=0.9.4 soundfile`                                                            |
| El audio suena robótico       | Prueba una voz diferente (por ejemplo, `af_heart` tiende a sonar más natural)                                 |
| Japonés/Chino no funciona     | Instala los extras de idioma: `pip install misaki[ja]` o `misaki[zh]`                                         |
| Agotamiento de memoria en CPU | Reduce la longitud del texto por llamada; Kokoro transmite fragmentos para que la memoria se mantenga acotada |
| Primera ejecución lenta       | Descarga de pesos del modelo en el primer uso (\~200 MB); las ejecuciones posteriores son instantáneas        |