# Clonación de voz Kani-TTS-2

Kani-TTS-2 de nineninesix.ai (lanzado el 15 de febrero de 2026) es un modelo de texto a voz de código abierto de 400 millones de parámetros que consigue síntesis de voz de alta fidelidad usando solo **3 GB de VRAM**. Construido sobre la arquitectura LFM2 de LiquidAI con NVIDIA NanoCodec, trata el audio como un lenguaje: genera voz de sonido natural con clonación de voz zero-shot a partir de un breve clip de audio de referencia. Con menos de la mitad del tamaño de modelos competidores y una fracción del cómputo, Kani-TTS-2 es perfecto para IA conversacional en tiempo real, generación de audiolibros y clonación de voz en hardware económico.

**HuggingFace:** [nineninesix/kani-tts-2-en](https://huggingface.co/nineninesix/kani-tts-2-en) **GitHub:** [nineninesix-ai/kani-tts-2](https://github.com/nineninesix-ai/kani-tts-2) **PyPI:** [kani-tts-2](https://pypi.org/project/kani-tts-2/) **Licencia:** Apache 2.0

## Características clave

* **400M parámetros, 3GB VRAM** — funciona en prácticamente cualquier GPU moderna, incluida la RTX 3060
* **Clonación de voz zero-shot** — clona cualquier voz desde una muestra de audio de referencia de 3–30 segundos
* **Incrustaciones de locutor** — representaciones de locutor de 128 dimensiones basadas en WavLM para control preciso de la voz
* **Hasta 40 segundos de audio continuo** — adecuado para pasajes más largos y diálogos
* **En tiempo real o más rápido** — RTF \~0.2 en RTX 5080, en tiempo real incluso en GPUs económicas
* **Apache 2.0** — totalmente abierto para uso personal y comercial
* **Marco de preentrenamiento incluido** — entrena tu propio modelo TTS desde cero en cualquier idioma

## Comparación con otros modelos TTS

| Modelo         | Parámetros | VRAM mínima | Clonación de voz      | Idioma              | Licencia     |
| -------------- | ---------- | ----------- | --------------------- | ------------------- | ------------ |
| **Kani-TTS-2** | 400M       | 3GB         | ✅ Zero-shot           | Inglés (extensible) | Apache 2.0   |
| Kokoro         | 82M        | 2GB         | ❌ Voces predefinidas  | EN, JP, CN          | Apache 2.0   |
| Zonos          | 400M       | 8GB         | ✅                     | Multi               | Apache 2.0   |
| ChatTTS        | 300M       | 4GB         | ❌ Semillas aleatorias | Chino, Inglés       | AGPL 3.0     |
| Chatterbox     | 500M       | 6GB         | ✅                     | Inglés              | Apache 2.0   |
| XTTS (Coqui)   | 467M       | 6GB         | ✅                     | Multi               | MPL 2.0      |
| F5-TTS         | 335M       | 4GB         | ✅                     | Multi               | CC-BY-NC 4.0 |

## Requisitos

| Componente | Mínimo                     | Recomendado      |
| ---------- | -------------------------- | ---------------- |
| GPU        | Cualquiera con 3GB de VRAM | RTX 3060 o mejor |
| VRAM       | 3GB                        | 6GB              |
| RAM        | 8GB                        | 16GB             |
| Disco      | 2GB                        | 5GB              |
| Python     | 3.9+                       | 3.11+            |
| CUDA       | 11.8+                      | 12.0+            |

**Recomendación de Clore.ai:** Una RTX 3060 (~~$0.15–0.30/día) es más que suficiente. Incluso las instancias GPU más baratas en Clore.ai ejecutarán Kani-TTS-2 sin problemas. Para procesamiento por lotes (audiolibros, conjuntos de datos), una RTX 4090 (~~$0.5–2/día) proporciona un rendimiento excelente.

## Instalación

```bash
# Instalar el paquete
pip install kani-tts-2

# IMPORTANTE: Instalar la versión compatible de transformers (requerida para la arquitectura LFM2)
pip install -U "transformers==4.56.0"

# Opcional: Instalar soundfile para guardar audio
pip install soundfile
```

## Inicio rápido

Tres líneas para generar voz:

```python
from kani_tts import KaniTTS

# Inicializar con el modelo en inglés
model = KaniTTS('nineninesix/kani-tts-2-en')

# Generar voz
audio, text = model("¡Hola! Bienvenido a Kani TTS 2, la próxima generación de texto a voz eficiente.")

# Guardar en archivo
model.save_audio(audio, "output.wav")
```

## Ejemplos de uso

### 1. Texto-a-voz básico

```python
from kani_tts import KaniTTS

model = KaniTTS('nineninesix/kani-tts-2-en')

# Generar con parámetros personalizados
audio, text = model(
    "The quick brown fox jumps over the lazy dog. "
    "This sentence contains every letter of the English alphabet.",
    temperature=0.7,
    top_p=0.9,
    repetition_penalty=1.1
)

model.save_audio(audio, "pangram.wav")
print(f"Generados {len(audio) / 22000:.1f} segundos de audio")
```

### 2. Clonación de voz

Clona cualquier voz a partir de una breve muestra de audio de referencia:

```python
from kani_tts import KaniTTS, SpeakerEmbedder

# Inicializar modelos
model = KaniTTS('nineninesix/kani-tts-2-en')
embedder = SpeakerEmbedder()

# Extraer la incrustación del locutor desde el audio de referencia (se recomiendan 3-30 segundos)
speaker_embedding = embedder.embed_audio_file("reference_voice.wav")

# Generar voz con la voz clonada
audio, text = model(
    "This is a demonstration of voice cloning with Kani TTS 2. "
    "The voice you hear should match the reference audio sample.",
    speaker_emb=speaker_embedding
)

model.save_audio(audio, "cloned_output.wav")
```

### 3. Generación por lotes para audiolibros

Genera múltiples capítulos de forma eficiente:

```python
from kani_tts import KaniTTS, SpeakerEmbedder
import soundfile as sf

model = KaniTTS('nineninesix/kani-tts-2-en')
embedder = SpeakerEmbedder()

# Usar una voz de narrador
narrator_emb = embedder.embed_audio_file("narrator_sample.wav")

chapters = [
    "Capítulo Uno. Era un día brillante y frío de abril, y los relojes daban las trece.",
    "Capítulo Dos. El pasillo olía a col hervida y a viejas esteras de trapo.",
    "Capítulo Tres. Afuera, incluso a través del cristal de la ventana cerrada, el mundo se veía frío.",
]

for i, chapter_text in enumerate(chapters):
    audio, _ = model(chapter_text, speaker_emb=narrator_emb)
    model.save_audio(audio, f"chapter_{i+1}.wav")
    print(f"Generado el capítulo {i+1}")
```

### 4. API de streaming compatible con OpenAI

Para aplicaciones en tiempo real, usa el servidor compatible con OpenAI:

```bash
# Clona el servidor
git clone https://github.com/nineninesix-ai/kani-tts-2-openai-server.git
cd kani-tts-2-openai-server

# Instalar dependencias
pip install -r requirements.txt

# Iniciar el servidor
python server.py --model nineninesix/kani-tts-2-en --host 0.0.0.0 --port 8080
```

Luego úsalo con cualquier cliente TTS de OpenAI:

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8080/v1", api_key="not-needed")

response = client.audio.speech.create(
    model="kani-tts-2-en",
    voice="default",
    input="Hello from the OpenAI-compatible Kani TTS server!"
)

response.stream_to_file("streamed_output.wav")
```

## Consejos para usuarios de Clore.ai

1. **Este es el modelo más barato para ejecutar** — Con 3GB de VRAM, Kani-TTS-2 funciona literalmente en cualquier instancia GPU en Clore.ai. Una RTX 3060 a $0.15/día es más que suficiente para TTS en producción.
2. **Combinar con un modelo de lenguaje** — Alquila una instancia GPU y ejecuta simultáneamente un LLM pequeño (por ejemplo, Mistral 3 8B) y Kani-TTS-2 para un asistente de voz completo. Compartirán la GPU con margen disponible.
3. **Precalcular incrustaciones de locutor** — Extrae las incrustaciones de los locutores una vez y guárdalas. Esto evita cargar el modelo incrustador WavLM en cada solicitud.
4. **Usar el servidor compatible con OpenAI** — El `kani-tts-2-openai-server` proporciona un reemplazo directo para la API TTS de OpenAI, lo que facilita la integración con aplicaciones existentes.
5. **Entrenar en idiomas personalizados** — Kani-TTS-2 incluye un marco completo de preentrenamiento ([kani-tts-2-pretrain](https://github.com/nineninesix-ai/kani-tts-2-pretrain)). Ajusta el modelo en tu propio conjunto de datos de idioma: solo requiere 8× H100 durante \~6 horas.

## Solución de problemas

| Problema                                        | Solución                                                                                                                    |
| ----------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| `ImportError: no se puede importar LFM2`        | Instala la versión correcta de transformers: `pip install -U "transformers==4.56.0"`                                        |
| La calidad de audio es pobre / robótica         | Aumente `temperature` a 0.8–0.9; asegúrate de que el audio de referencia para la clonación esté limpio (sin ruido de fondo) |
| La clonación de voz no suena como la referencia | Usa 5–15 segundos de audio claro de un solo hablante. Evita música o ruido de fondo en la referencia                        |
| `CUDA fuera de memoria`                         | No debería ocurrir con el modelo de 3GB — verifica si otros procesos están usando memoria GPU (`nvidia-smi`)                |
| El audio se corta a mitad de frase              | Kani-TTS-2 admite hasta \~40 segundos. Divide textos más largos en oraciones y concatena las salidas                        |
| Lento en CPU                                    | Se recomienda encarecidamente la inferencia en GPU. Incluso una GPU básica es de 10–50× más rápida que la CPU               |

## Lecturas adicionales

* [GitHub — kani-tts-2](https://github.com/nineninesix-ai/kani-tts-2) — Paquete PyPI, docs de uso, ejemplos avanzados
* [HuggingFace — kani-tts-2-en](https://huggingface.co/nineninesix/kani-tts-2-en) — Pesos del modelo en inglés
* [Marco de preentrenamiento](https://github.com/nineninesix-ai/kani-tts-2-pretrain) — Entrena tu propio modelo TTS desde cero
* [Servidor compatible con OpenAI](https://github.com/nineninesix-ai/kani-tts-2-openai-server) — Reemplazo directo para la API TTS de OpenAI
* [Modelo de incrustación de locutor](https://huggingface.co/nineninesix/speaker-emb-tbr) — Incrustador de voz basado en WavLM
* [Resumen de MarkTechPost](https://www.marktechpost.com/2026/02/15/meet-kani-tts-2-a-400m-param-open-source-text-to-speech-model-that-runs-in-3gb-vram-with-voice-cloning-support/) — Cobertura comunitaria