AIBit-Descubre proyectos de código abierto AIBit-Descubre proyectos de código abierto

KittenTTS: TTS de última generación en menos de 25MB que funciona en CPU

KittenTTS ofrece síntesis de voz de alta calidad en modelos de solo 25MB, funcionando completamente en CPU. Aprende a usarlo, su API y por qué es importante para la IA en el borde.

KittenTTS: TTS de última generación en menos de 25MB que funciona en CPU

La síntesis de voz (TTS) ha sido tradicionalmente una tarea pesada. La mayoría de los modelos de producción requieren GPU, cientos de megabytes de pesos y complejos pipelines de inferencia. Por eso KittenTTS es un soplo de aire fresco: es una biblioteca TTS de código abierto basada en ONNX que ofrece síntesis de voz de alta calidad en modelos de solo 25MB (cuantizados en int8) y funciona completamente en CPU. No se requiere GPU.

Con 15.3k estrellas en GitHub y una comunidad creciente, KittenTTS demuestra que el TTS desplegable en el borde no solo es posible, sino práctico. En esta publicación, profundizaremos en qué lo hace especial, cómo comenzar y cómo puedes integrarlo en tus propios proyectos.

Por qué el tamaño importa en TTS

La mayoría de los modelos TTS actuales son masivos. Por ejemplo, algunos sistemas TTS neuronales populares superan 1GB de tamaño y requieren una GPU compatible con CUDA para inferencia en tiempo real. Esto los hace poco prácticos para:

  • Dispositivos de borde como Raspberry Pi, puertas de enlace IoT o teléfonos móviles
  • Funciones serverless con límites de memoria estrictos
  • Aplicaciones de escritorio que necesitan ser ligeras
  • Aplicaciones en tiempo real donde la latencia y el uso de recursos importan

KittenTTS invierte esto ofreciendo modelos de 15M a 80M de parámetros, con tamaños en disco que van de 25MB a 80MB. La variante más pequeña, kitten-tts-nano int8, es de solo 25MB — lo suficientemente pequeña para incrustarse en casi cualquier aplicación.

Construido sobre ONNX para eficiencia en CPU

KittenTTS está construido sobre ONNX (Open Neural Network Exchange), lo que significa que los modelos están optimizados para inferencia en una variedad de hardware. La biblioteca utiliza ONNX Runtime, que está altamente optimizado para ejecución en CPU. Esta es una decisión de diseño clave: permite que KittenTTS funcione eficientemente en máquinas sin GPU, haciéndolo accesible a una audiencia mucho más amplia.

Incluso puedes ejecutarlo en GPU si lo deseas, instalando los requisitos de GPU y especificando backend="cuda". Pero la ruta predeterminada de CPU es impresionantemente rápida.

Modelos disponibles

KittenTTS v0.8 ofrece cuatro variantes de modelo:

Modelo Parámetros Tamaño ID de Hugging Face
kitten-tts-mini 80M 80 MB KittenML/kitten-tts-mini-0.8
kitten-tts-micro 40M 41 MB KittenML/kitten-tts-micro-0.8
kitten-tts-nano 15M 56 MB KittenML/kitten-tts-nano-0.8
kitten-tts-nano (int8) 15M 25 MB KittenML/kitten-tts-nano-0.8-int8

Nota: Algunos usuarios han informado problemas con la variante int8. Si encuentras problemas, los mantenedores piden que abras un issue en GitHub.

Inicio rápido

Comenzar es sencillo. Primero, instala la biblioteca con pip:

pip install https://github.com/KittenML/KittenTTS/releases/download/0.8.1/kittentts-0.8.1-py3-none-any.whl

Luego, genera tu primera muestra de voz:

from kittentts import KittenTTS

model = KittenTTS("KittenML/kitten-tts-mini-0.8")
audio = model.generate("Este modelo TTS de alta calidad funciona sin GPU.", voice="Jasper")

import soundfile as sf
sf.write("output.wav", audio, 24000)

Eso es todo. Ahora tienes un archivo WAV con voz de sonido natural, generado completamente en CPU.

Uso avanzado

KittenTTS te da control fino sobre la síntesis:

# Ajusta la velocidad del habla (predeterminado: 1.0)
audio = model.generate("Hola, mundo.", voice="Luna", speed=1.2)

# Guarda directamente en un archivo
model.generate_to_file("Hola, mundo.", "output.wav", voice="Bruno", speed=0.9)

# Lista las voces disponibles
print(model.available_voices)
# ['Bella', 'Jasper', 'Luna', 'Bruno', 'Rosie', 'Hugo', 'Kiki', 'Leo']

También puedes usar GPU si tienes una:

pip install -r requirements_gpu.txt

m = KittenTTS("KittenML/kitten-tts-mini-0.8", backend="cuda")

Normalización de texto: una joya oculta

Una de las características más subestimadas es el pipeline de normalización de texto integrado. Maneja números, monedas, unidades, fechas, horas y más. Esto es crucial para producir voz de sonido natural a partir de texto crudo.

from kittentts import normalize_text

normalized = normalize_text("El Dr. Rivera pagó $12.50 a las 3:05 p.m.")
# "El doctor Rivera pagó doce dólares con cincuenta centavos a las tres cero cinco p m."

También puedes obtener los spans de caracteres para los segmentos normalizados, lo cual es útil para alineación o resaltado:

result = normalize_text("Fig. 2", return_spans=True)
print(result.text)
print(result.spans)

Esto ahorra mucho tiempo, porque la normalización de texto suele ser un punto doloroso en los pipelines TTS.

Referencia de API

KittenTTS(model_name, cache_dir=None)

Carga un modelo desde Hugging Face Hub.

  • model_name (str): ID del repositorio en Hugging Face. Predeterminado: "KittenML/kitten-tts-nano-0.8"
  • cache_dir (str, opcional): Directorio local para almacenar en caché los archivos del modelo descargados.

model.generate(text, voice, speed, clean_text)

Sintetiza voz a partir de texto, devolviendo un array NumPy de muestras de audio a 24 kHz.

  • text (str): Texto de entrada a sintetizar
  • voice (str): Nombre de la voz (predeterminado: "expr-voice-5-m")
  • speed (float): Multiplicador de velocidad del habla (predeterminado: 1.0)
  • clean_text (bool): Preprocesar texto (expandir números, monedas, etc.) (predeterminado: False)

model.generate_to_file(text, output_path, voice, speed, sample_rate, clean_text)

Sintetiza voz y escribe directamente en un archivo de audio.

  • text (str): Texto de entrada a sintetizar
  • output_path (str): Ruta para guardar el archivo de audio
  • voice (str): Nombre de la voz
  • speed (float): Multiplicador de velocidad del habla (predeterminado: 1.0)
  • sample_rate (int): Frecuencia de muestreo de audio en Hz (predeterminado: 24000)
  • clean_text (bool): Preprocesar texto (predeterminado: True)

normalize_text(text, locale="en-US", return_spans=False)

Normaliza texto para TTS sin generar audio.

model.available_voices

Devuelve una lista de nombres de voces disponibles: ['Bella', 'Jasper', 'Luna', 'Bruno', 'Rosie', 'Hugo', 'Kiki', 'Leo']

Requisitos del sistema

  • SO: Linux, macOS o Windows
  • Python: 3.8 o posterior
  • Hardware: Solo CPU (GPU opcional)
  • Espacio en disco: 25-80 MB según la variante del modelo

Se recomienda un entorno virtual para evitar conflictos de dependencias.

Hoja de ruta y comunidad

El proyecto se desarrolla activamente. La hoja de ruta incluye:

  • Lanzar un motor de inferencia optimizado
  • Lanzar SDK móvil
  • Lanzar modelos TTS de mayor calidad
  • Lanzar TTS multilingüe
  • Lanzar KittenASR (reconocimiento automático de voz)

Puedes unirte a la comunidad en Discord o visitar kittenml.com. Para soporte comercial, incluyendo voces personalizadas y licencias empresariales, contacta a [email protected].

Licencia

KittenTTS está licenciado bajo la Apache License 2.0, que es permisiva tanto para uso personal como comercial.

Reflexiones finales

KittenTTS es un logro notable en el espacio TTS. Demuestra que no necesitas un clúster de GPU para generar voz de sonido natural. Con su pequeña huella, inferencia amigable con CPU y API limpia, es una excelente opción para aplicaciones de borde, software de escritorio y cualquier proyecto donde los recursos sean limitados.

Si estás construyendo un asistente de voz, una herramienta de accesibilidad, o simplemente quieres agregar voz a tu aplicación sin la sobrecarga, prueba KittenTTS. El modelo de 25MB es un cambio de juego.

Prueba la demo en vivo en Hugging Face Spaces y escúchalo por ti mismo.

Fuente

KittenML/KittenTTS: Modelo TTS de última generación en menos de 25MB 😻