Clonación de voz Kani-TTS-2

Ejecuta Kani-TTS-2: un modelo de texto a voz ultrar eficiente de 400M parámetros con clonación de voz en GPUs de Clore.ai

Kani-TTS-2 de nineninesix.ai (lanzado el 15 de febrero de 2026) es un modelo de texto a voz de código abierto con 400 millones de parámetros que logra 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 — generando 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 los 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 GitHub: nineninesix-ai/kani-tts-2 PyPI: kani-tts-2 Licencia: Apache 2.0

Características clave

• 400 millones de parámetros, 3 GB de VRAM — funciona en prácticamente cualquier GPU moderna, incluida la RTX 3060

• Clonación de voz zero-shot — clona cualquier voz a partir de una muestra de audio de referencia de 3 a 30 segundos

• Embeddings del hablante — representaciones del hablante de 128 dimensiones basadas en WavLM para un 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 GPU 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	2 GB	❌ Voces preestablecidas	EN, JP, CN	Apache 2.0
Zonos	400M	8GB	✅	Varias	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	✅	Varias	MPL 2.0
F5-TTS	335M	4GB	✅	Varias	CC-BY-NC 4.0

Requisitos

Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai. Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como bare metal bajo pedido. Consulta Precios y disponibilidad de GPU antes de dimensionar un despliegue.

Componente	Mínimo	Recomendado
GPU	Cualquiera con 3 GB de VRAM	RTX 3060 o superior
VRAM	3GB	6GB
RAM	8GB	16GB
Disco	2 GB	5GB
Python	3.9+	3.11+
CUDA	12.8+	12.8+

Recomendación de Clore.ai: Una RTX 3060 ($0.03–0.07/h) es más que suficiente. Incluso las instancias de GPU más baratas en Clore.ai ejecutarán Kani-TTS-2 con comodidad. Para el procesamiento por lotes (audiolibros, conjuntos de datos), una RTX 4090 ($0.14–0.42/h) proporciona un rendimiento excelente.

Instalación

# Instala el paquete
pip install kani-tts-2

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

# Opcional: instala soundfile para guardar audio
pip install soundfile

Inicio rápido

Tres líneas para generar voz:

from kani_tts import KaniTTS

# Inicializa 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

from kani_tts import KaniTTS

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

# Genera con parámetros personalizados
audio, text = model(
    "El rápido zorro marrón salta sobre el perro perezoso. "
    "Esta oración contiene cada letra del alfabeto inglés.",
    temperature=0.7,
    top_p=0.9,
    repetition_penalty=1.1
)

model.save_audio(audio, "pangram.wav")
print(f"Se generaron {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:

from kani_tts import KaniTTS, SpeakerEmbedder

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

# Extrae el embedding del hablante del audio de referencia (se recomiendan de 3 a 30 segundos)
speaker_embedding = embedder.embed_audio_file("reference_voice.wav")

# Genera voz con la voz clonada
audio, text = model(
    "Esta es una demostración de clonación de voz con Kani TTS 2. "
    "La voz que escuches debería coincidir con la muestra de audio de referencia.",
    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:

from kani_tts import KaniTTS, SpeakerEmbedder
import soundfile as sf

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

# Usa 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 viejos felpudos.",
    "Capítulo tres. Afuera, incluso a través del cristal de la ventana cerrada, el mundo parecí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"Capítulo {i+1} generado")

4. API de streaming compatible con OpenAI

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

# 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:

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="¡Hola desde el servidor Kani TTS compatible con OpenAI!"
)

response.stream_to_file("streamed_output.wav")

Consejos para usuarios de Clore.ai

1. Este es el modelo más económico de ejecutar — Con 3 GB de VRAM, Kani-TTS-2 se ejecuta literalmente en cualquier instancia de GPU en Clore.ai. Una RTX 3060 a $0.03–0.07/h es más que suficiente para TTS en producción.

2. Combínalo con un modelo de lenguaje — Alquila una instancia de GPU y ejecuta simultáneamente un LLM pequeño (p. ej., Mistral 3 8B) y Kani-TTS-2 para tener un asistente de voz completo. Compartirán la GPU con margen de sobra.

3. Precalcula los embeddings del hablante — Extrae los embeddings del hablante una sola vez y guárdalos. Así evitas cargar el modelo embebedor WavLM en cada solicitud.

4. Usa el servidor compatible con OpenAI — El kani-tts-2-openai-server proporciona un reemplazo directo de la API TTS de OpenAI, lo que facilita la integración con aplicaciones existentes.

5. Entrena en idiomas personalizados — Kani-TTS-2 incluye un marco completo de preentrenamiento (kani-tts-2-pretrain). Ajusta el modelo con tu propio conjunto de datos de idioma — solo se necesitan 8× H100 durante unas 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 mala / robótica	Aumenta 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 de 5 a 15 segundos de audio claro de un solo hablante. Evita música o ruido de fondo en la referencia
CUDA sin memoria	No debería ocurrir con el modelo de 3 GB — comprueba si otros procesos están usando memoria de la GPU (nvidia-smi)
El audio se corta a mitad de la oración	Kani-TTS-2 admite hasta ~40 segundos. Divide los 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 a 50 veces más rápida que la CPU

Lecturas adicionales

• GitHub — kani-tts-2 — paquete de PyPI, documentación de uso, ejemplos avanzados

• HuggingFace — kani-tts-2-en — pesos del modelo en inglés

• Marco de preentrenamiento — Entrena tu propio modelo TTS desde cero

• Servidor compatible con OpenAI — Reemplazo directo de la API TTS de OpenAI

• Modelo de embeddings del hablante — embebedor de voz basado en WavLM

• Resumen de MarkTechPost — Cobertura de la comunidad