Clonación de Voz Kani-TTS-2

Ejecuta Kani-TTS-2 — un modelo de texto a voz ultraeficiente 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 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 GitHub: nineninesix-ai/kani-tts-2 PyPI: 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

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

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

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:

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:

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:

# 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="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). 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 — Paquete PyPI, docs 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 para la API TTS de OpenAI

• Modelo de incrustación de locutor — Incrustador de voz basado en WavLM

• Resumen de MarkTechPost — Cobertura comunitaria