Pocket‑TTS: Biblioteca ligera de Texto‑a‑Habla (TTS) exclusivamente para CPU
Pocket‑TTS: Biblioteca ligera de Texto‑a‑Habla (TTS) exclusivamente para CPU
El Texto‑a‑Habla (TTS) se ha convertido en un componente esencial en aplicaciones que van desde asistentes digitales hasta herramientas de accesibilidad. Las soluciones habituales requieren potentes GPUs o dependen de APIs web pagas, lo que las hace poco prácticas para dispositivos de borde o implementaciones sensibles a la privacidad. Pocket‑TTS resuelve este problema ofreciendo una experiencia TTS de alta calidad y baja latencia que se ejecuta completamente en la CPU.
TL;DR – Pocket‑TTS es un modelo de 100 M‑parámetros que realiza síntesis de voz en 2 núcleos de CPU, logrando una latencia de primer bloque de ~200 ms y un rendimiento ~6× en tiempo real en un MacBook Air M4. Installa con
pip install pocket-ttsouv add pocket-ttsy llama apocket-tts generatedesde la CLI oTTSModel.load_model()desde Python.
Tabla de Contenidos
- ¿Por qué Pocket‑TTS?
- Primeros Pasos
- Clonación de Voz
- CLI y Servidor HTTP
- Integración con API Python
- Rendimiento y Benchmark
- Extender y Contribuir
- Licencia y Notas de Uso
¿Por qué Pocket‑TTS?
| Característica | Pocket‑TTS | Competidor (Típico) |
|---|---|---|
| Tamaño del modelo | 100 M parámetros | 700 M–1 B+ |
| Tiempo de ejecución | 2 núcleos de CPU | GPU o TPU |
| Latencia | ~200 ms | 1–2 s |
| Despliegue | pip/uv install | Docker + GPU, API web |
| Biblioteca de voces | 8 voces pre‑construidas + entrada wav | Limitada o nula |
| Idioma | Solo inglés (próximamente multilingüe) | Multilingüe |
Pocket‑TTS se diseñó con la idea de un TTS que cabe en tu bolsillo. Los siguientes aspectos lo distinguen:
- Solo CPU – Se ejecuta en cualquier CPU moderna, no necesita CUDA ni GPU.
- Huella muy pequeña – Un modelo transformer de 100 M‑parámetros (~30 MB) mantiene el repositorio ligero.
- Streaming de audio – Puedes transmitir audio en tiempo real mientras el modelo sigue generando.
- Soporte de clonación de voz – Proporciona un archivo wav para generar un estado de voz adaptado a ese audio.
- CLI & API HTTP – Comandos de línea de comandos simples y un servidor local rápido para integración.
El resultado es una librería plug‑and‑play que funciona fuera de la caja en laptops, SBC tipo Raspberry Pi y chips de inferencia de borde.
Primeros Pasos
Pocket‑TTS es un paquete puro de Python que requiere PyTorch 2.5+. La forma más fácil de obtenerlo es con uv (recomendado para entornos aislados) o pip.
Instalación con uv
uv add pocket-tts
uvx pocket-tts generate "Hello World!"
uvxejecuta comandos en un entorno temporal; esto es perfecto para pruebas rápidas.
Instalación con pip
pip install --upgrade pocket-tts
pocket-tts generate "Hello World!"
El ejemplo anterior descargará la voz por defecto (alba) y generará un archivo tts_output.wav.
Ejemplo en Colab
!pip install pocket-tts
from pocket_tts import TTSModel
import scipy.io.wavfile as wav
model = TTSModel.load_model()
voice_state = model.get_state_for_audio_prompt("alba")
audio = model.generate_audio(voice_state, "Hello from Colab!")
wav.write("output.wav", model.sample_rate, audio.cpu().numpy())
La primera carga del modelo puede tardar ~30 s, pero las llamadas subsecuentes permanecen en memoria.
Clonación de Voz
Pocket‑TTS admite clonación de voz aceptando un archivo wav local o un wav alojado en Hugging Face.
pocket-tts generate "This is my cloned voice" --voice ./my_voice.wav
También puedes proporcionar una URL de Hugging Face:
pocket-tts generate "I love Hugging Face" \
--voice "hf://kyutai/tts-voices/expresso/ex01-ex02_default_001_channel2_198s.wav"
El archivo de voz debe ser ~16 kHz, 16‑bit PCM. En el repositorio encontrarás una lista de voces de ejemplo en el archivo
voice_catalog.md.
Gestión de Estados de Voz
Si necesitas usar múltiples voces en un corto lapso, mantén los estados de voz en memoria:
model = TTSModel.load_model()
voice_alba = model.get_state_for_audio_prompt("alba")
voice_marius = model.get_state_for_audio_prompt("marius")
# Reutilizar sin re‑inicializar el modelo
CLI y Servidor HTTP
CLI
Pocket‑TTS incluye dos comandos de alto nivel:
generate– Genera un archivo wav a partir de texto.serve– Ejecuta un servidor HTTP FastAPI local.
Ejecuta el servidor y visita la interfaz web:
uvx pocket-tts serve # o pocket-tts serve si usas pip
http://localhost:8000 – la interfaz web es responsiva y mantiene el modelo en memoria con ~6× velocidad en tiempo real.
API HTTP
La API expone un endpoint /generate que acepta un payload JSON POST:
{ "text": "Hello, world!", "voice": "alba" }
curl -X POST http://localhost:8000/generate \
-H "Content-Type: application/json" \
-d '{"text":"Hello","voice":"alba"}' \
--output out.wav
El servidor también transmite audio en bloques si estableces stream=true en la solicitud.
Integración con API Python
Al integrar TTS en un servicio, normalmente usas la librería directamente.
from pocket_tts import TTSModel
import torch
model = TTSModel.load_model()
voice_state = model.get_state_for_audio_prompt("alba")
text = "Complex sentence that may be very long ..."
# Audio es un tensor 1‑D de Torch
audio = model.generate_audio(voice_state, text)
# Guardar o transmitir
torch.save(audio, "demo.pt")
La API es deliberadamente ligera: el modelo y los estados de voz son objetos PyTorch normales. Manténlos en caché si re‑utilizas las mismas voces o trabajas en un entorno asíncrono.
Rendimiento y Benchmark
El archivo docs/tech_report.md del repositorio ofrece un análisis profundo, pero las conclusiones clave son:
- Latencia – Primer bloque ~200 ms en Apple M4; ~350 ms en Intel i7‑12700K.
- Velocidad – Genera 6× tiempo real en los mismos CPUs.
- Uso de CPU – Solo 2 núcleos; la memoria permanece por debajo de 2 GB.
- Tamaño del modelo – 100 M parámetros – 30 MB en disco, ~120 MB VRAM al cargar.
La naturaleza de streaming de audio significa que puedes iniciar la reproducción antes de que la síntesis termine, lo cual es crítico para aplicaciones interactivas.
Extender y Contribuir
Pocket‑TTS es código abierto bajo la licencia MIT. Se aceptan contribuciones en varias áreas:
- Nuevas voces – Haz un fork del modelo, ajusta el
voice_catalog.md, y envía un PR. - Soporte multilingüe – Porta el checkpoint actual de inglés.
- Cuantización – Añade variantes int8 o float16 para un runtime aún más pequeño.
- WebAssembly – Integra la versión Rust Candle para ejecutar en navegadores.
Guías de desarrollo:
- Ejecuta pruebas: pytest.
- Construye documentación: mkdocs build.
- El CI usa uv para instalar dependencias.
Para instrucciones detalladas, lee CONTRIBUTING.md.
Licencia y Notas de Uso
Pocket‑TTS se publica bajo la licencia MIT. Los activos de voz están sujetos a licencias individuales (ver voice_catalog.md).
Descargo de responsabilidad – El repositorio prohíbe explícitamente el uso indebido como suplantación, desinformación o contenido abusivo. Asegúrate siempre de usarlo de forma legal y ética.
TL;DR
Pocket‑TTS es una librería TTS ligera y CPU‑amigable que funciona en cualquier procesador moderno. Instálalo, genera audio o sirve vía HTTP en minutos. Para desarrolladores que buscan un TTS rápido, de código abierto y sin dependencias GPU, Pocket‑TTS es una excelente opción.