Curso
Procesamiento del lenguaje hablado en Python
4 h
9.1K
El reconocimiento automático del habla ha mejorado muchísimo en los últimos años. Los modelos de voz a texto que antes necesitaban potentes GPU y ofrecían resultados irregulares ahora pueden generar transcripciones precisas en ordenadores de uso diario.
Al mismo tiempo, los modelos son más pequeños, la inferencia en CPU es más rápida y el soporte multilingüe se ha ampliado, ofreciendo una mejor combinación de calidad de transcripción, velocidad, accesibilidad y privacidad.
VibeVoice-ASR-BitNet de Microsoft es un buen ejemplo de este avance.
Su runtime optimizado VibeASR.cpp permite ejecutar voz a texto multilingüe en local en un ordenador con Windows, Linux o macOS sin depender de una GPU dedicada ni enviar grabaciones a la nube.
En esta guía aprenderás a instalar y compilar VibeASR.cpp, descargar el modelo cuantizado, transcribir archivos de audio desde la línea de comandos, ejecutar su servidor de streaming persistente y usar la interfaz web de Gradio para subir o grabar audio.
¿Qué es Microsoft VibeASR.cpp?
VibeASR.cpp es el runtime oficial de inferencia en C++ de Microsoft para VibeVoice-ASR-BitNet, un modelo multilingüe de reconocimiento automático del habla comprimido y diseñado para una inferencia eficiente en local sobre CPU.
Más que un modelo de voz independiente, VibeASR.cpp proporciona el motor optimizado necesario para ejecutarlo, habilitando la transcripción en tiempo real sin una GPU dedicada ni un servicio de voz en la nube.
Esto lo hace adecuado para portátiles, sobremesas, dispositivos edge y otros sistemas con recursos de cómputo limitados.
Fuente: microsoft/VibeVoice-ASR-BitNet
Para hacer viable el despliegue en CPU, Microsoft sustituyó el componente de modelo de lenguaje Qwen2.5-7B usado en la arquitectura original de VibeVoice-ASR por el mucho más pequeño Qwen2.5-1.5B.
También aplica distintos métodos de cuantización a los dos componentes principales:
I8_Spara el codificador de audio VAEI2_Spara el modelo de lenguaje, con embeddings de mayor precisión
Estas optimizaciones reducen el tamaño total del modelo de aproximadamente 4,62 GB a 1,58 GB, lo que permite ejecutarlo de forma práctica en portátiles y equipos de sobremesa.
A pesar de la reducción considerable de tamaño, el modelo comprimido muestra solo un aumento relativamente pequeño de alrededor del 1–4% en la tasa de error de palabra respecto a la arquitectura mayor.
VibeASR.cpp utiliza el framework ggml, instrucciones personalizadas de CPU y fusión de operadores para acelerar la inferencia.
Según las pruebas de Microsoft, puede ejecutarse entre 1,6 y 2,3 veces más rápido que Whisper.cpp con tamaños de modelo comparables y lograr transcripción más rápida que en tiempo real en CPUs compatibles cuando se usan suficientes hilos.
En los benchmarks de CPU de Microsoft, el modelo alcanzó un RTF de 0,63 con cuatro hilos y de 0,42 con ocho hilos, equivalente a aproximadamente 1,59× y 2,38× la velocidad en tiempo real.
Su WER reportado incluye 8,25% en MLC English, 21,36% en audio AMI con diadema, 25,87% en audio AMI con micrófono distante y 2,41% en LibriSpeech clean, mostrando un equilibrio sólido entre precisión de transcripción, tamaño de modelo y rendimiento en CPU.
1. Instala las herramientas de compilación necesarias
VibeASR.cpp se ejecuta íntegramente en la CPU, así que no necesitas una GPU dedicada. Solo te hace falta un ordenador compatible con Windows, Linux o macOS, Python 3.9 o superior, Git, un compilador C++ y aproximadamente 4 GB de espacio libre para el código fuente, los archivos de compilación y el modelo.
El proceso de compilación también requiere CMake y Ninja.
En Windows, la opción más sencilla es usar w64devkit, que proporciona el compilador y las herramientas de build en una terminal preconfigurada.
En Linux, los paquetes necesarios pueden instalarse directamente con el gestor de paquetes del sistema.
Windows
Descarga el último archivo .exe x64 desde la página de lanzamientos de w64devkit.
El archivo descargado es un ejecutable autoextraíble. Ejecútalo y extrae la carpeta en una ruta sencilla, por ejemplo:
C:\w64devkitLuego abre:
C:\w64devkit\w64devkit.exeEsto lanza una terminal lista para usar con GCC, CMake, Make y Ninja. Puedes usar esta terminal para el resto de pasos en Windows sin configurar variables de entorno manualmente.
Linux
En Ubuntu, Debian y distribuciones relacionadas, el compilador y las herramientas necesarias se instalan con un único comando:
sudo apt update
sudo apt install build-essential cmake ninja-build git python3 python3-venvEsto instala el compilador GCC, CMake, Ninja, Git, Python y el paquete necesario para crear un entorno virtual de Python.
macOS
En macOS, instala las herramientas de desarrollo de línea de comandos de Apple:
xcode-select --installTambién necesitarás Git, Python 3.9 o superior, CMake y Ninja. La forma más sencilla de instalar el resto de herramientas es con Homebrew:
brew install git python cmake ninja2. Clona VibeASR.cpp y prepara el entorno de Python
El siguiente proceso de configuración es el mismo en Windows, Linux y macOS.
El único paso específico del sistema operativo es el comando para activar el entorno virtual de Python.
Abre tu terminal, ve a la carpeta donde quieras guardar el proyecto y clona el repositorio de VibeASR.cpp:
git clone --recursive https://github.com/microsoft/VibeASR.cpp.git
cd VibeASR.cpp
La opción --recursive también descarga el submódulo requerido llama.cpp. Sin él, faltarían algunos archivos necesarios para compilar el runtime de inferencia.
Crea un entorno virtual de Python dentro de la carpeta del proyecto.
python -m venv .venvActívalo con el comando correspondiente a tu sistema operativo.
Windows usando la terminal de w64devkit:
. .venv/Scripts/activateLinux y macOS:
source .venv/bin/activateTras la activación, la terminal debería mostrar (.venv) antes del prompt. Comprueba que Python está disponible:
python --versionActualiza pip e instala las dependencias del proyecto:
python -m pip install --upgrade pip
pip install -r requirements.txtEstas dependencias incluyen los paquetes de Python usados por el script de configuración, la descarga del modelo y la interfaz web local de Gradio.
3. Compila VibeASR.cpp y descarga el modelo
VibeASR.cpp incluye un script de configuración que gestiona tanto la compilación en C++ como la descarga del modelo.
Compila los ejecutables de línea de comandos y de streaming, instala el paquete GGUF necesario y descarga los archivos del modelo pre-cuantizado en el directorio del proyecto.
Asegúrate de que el entorno virtual de Python esté activo antes de ejecutar el script.
En Linux y macOS, ejecuta:
python setup_env.pyEn Windows, ejecuta el siguiente comando dentro de la terminal w64devkit:
CMAKE_GENERATOR=Ninja python setup_env.pyEstablecer CMAKE_GENERATOR=Ninja garantiza que CMake use el sistema de compilación Ninja en lugar de intentar usar Microsoft Visual C++, que no está disponible en el entorno w64devkit.
El script de configuración:
- Instala el paquete de Python
ggufrequerido. - Configura y compila VibeASR.cpp.
- Genera los ejecutables de inferencia y streaming.
- Descarga los archivos del modelo VibeASR pre-cuantizados.
- Guarda los modelos descargados en
models/vibeasr.
Al finalizar, el ejecutable principal de inferencia estará disponible en la siguiente ubicación.
Windows:
build/bin/asr_infer.exeLinux y macOS:
build/bin/asr_inferVerifica que el ejecutable se haya generado correctamente mostrando sus opciones disponibles.
Windows:
./build/bin/asr_infer.exe --helpLinux y macOS:
./build/bin/asr_infer --help
4. Prueba la transcripción por archivo y en streaming
Ahora que el runtime y el modelo están listos, puedes probar dos métodos de transcripción.
El ejecutable estándar procesa un archivo de audio y devuelve la transcripción completa, mientras que el servidor de streaming mantiene el modelo cargado y va mostrando la transcripción de forma progresiva a medida que se generan los tokens.
Primero, descarga una grabación de ejemplo corta desde la carpeta del proyecto VibeASR.cpp:
curl -L "https://homepages.inf.ed.ac.uk/htang2/notes/speech-samples/103-1240-0000.wav" -o recording.wavEl archivo de audio se guardará como recording.wav en el directorio actual del proyecto.
Transcribe un archivo de audio
El comando estándar de inferencia carga el codificador de audio y el modelo de lenguaje, procesa la grabación e imprime la transcripción completa.
Windows:
./build/bin/asr_infer.exe \
--vae-model models/vibeasr/vibeasr-vae-encoder-i8_s.gguf \
--lm-model models/vibeasr/vibeasr-lm-i2_s-embed-q6_k.gguf \
--audio recording.wav \
-t 6 \
--greedyLinux y macOS: usa el mismo comando sin la extensión .exe:
./build/bin/asr_infer \
--vae-model models/vibeasr/vibeasr-vae-encoder-i8_s.gguf \
--lm-model models/vibeasr/vibeasr-lm-i2_s-embed-q6_k.gguf \
--audio recording.wav \
-t 6 \
--greedy
La opción -t 6 asigna seis hilos de CPU a la inferencia. Puedes aumentar o reducir este número según tu procesador.
La opción --greedy selecciona el token más probable en cada paso de decodificación, produciendo resultados consistentes.
En mi equipo, la grabación de 14,085 segundos tardó unos 13,7 segundos en procesarse:
RTF: 0.9726
Speed: approximately 1.03× real timeEl factor de tiempo real, o RTF, compara el tiempo de proceso con la duración del audio.
Un RTF por debajo de 1,0 significa que la transcripción fue más rápida que la reproducción real. El rendimiento variará según el procesador, el sistema operativo, el número de hilos y la duración de la grabación.
Prueba el streaming token a token
VibeASR.cpp también incluye un servidor de streaming persistente. Carga los dos archivos de modelo una vez y permanece activo, permitiéndote enviar varias grabaciones sin reiniciar ni recargar el modelo cada vez.
La salida funciona de forma similar al streaming de un modelo de lenguaje grande.
En lugar de esperar a que termine toda la transcripción, empiezas a ver el texto a medida que el decodificador genera cada token.
Algunos tokens representan palabras completas, otros partes de palabras o signos de puntuación, pero se muestran progresivamente hasta completar la transcripción.
Windows, inicia el servidor con:
./build/bin/asr_stream_server.exe \
--vae-model models/vibeasr/vibeasr-vae-encoder-i8_s.gguf \
--lm-model models/vibeasr/vibeasr-lm-i2_s-embed-q6_k.gguf \
-t 6 \
--greedyLinux y macOS, ejecuta:
./build/bin/asr_stream_server \
--vae-model models/vibeasr/vibeasr-vae-encoder-i8_s.gguf \
--lm-model models/vibeasr/vibeasr-lm-i2_s-embed-q6_k.gguf \
-t 6 \
--greedy
Espera a que el servidor termine de cargar los modelos y muestre:
---READY---Introduce la ruta del archivo de audio y pulsa Intro:
recording.wavLa transcripción empezará a aparecer token a token. Cuando termine de procesarse, el servidor mostrará:
---END---
A continuación, puedes introducir otra ruta de archivo sin recargar los modelos. Para detener el servidor, escribe:
exitEste flujo persistente es especialmente útil al transcribir varias grabaciones o al conectar VibeASR.cpp a otra aplicación que necesite salida de transcripción progresiva.
5. Inicia y prueba la interfaz web
VibeASR.cpp incluye una interfaz web local con Gradio para subir archivos de audio o grabar voz con tu micrófono. El proceso es el mismo en Windows, Linux y macOS, aunque en Windows los ejecutables terminan en .exe.
Las dependencias necesarias para la interfaz, incluidas Gradio, SoundFile y NumPy, ya se instalaron a través de requirements.txt.
Primero, asegúrate de que el entorno virtual esté activo.
Windows usando la terminal de w64devkit:
. .venv/Scripts/activateLinux y macOS:
source .venv/bin/activateEn Windows, inicia la interfaz con:
python demo/gradio_asr_demo.py \
--port 7860 \
--bin build/bin/asr_infer.exe \
--server-bin build/bin/asr_stream_server.exeEn Linux y macOS, las rutas por defecto de los ejecutables se detectan automáticamente:
python demo/gradio_asr_demo.py --port 7860Las rutas de los modelos ya están configuradas dentro del script de Gradio para todos los sistemas operativos, así que no necesitas incluirlas en el comando.
El script también permite indicar rutas separadas para el ejecutable estándar y el servidor de streaming.
Abre la siguiente dirección en tu navegador:
http://127.0.0.1:7860Explora la interfaz
La interfaz te permite:
- Seleccionar el modelo para CPU.
- Elegir el número de hilos de CPU.
- Cambiar entre procesamiento online y offline.
- Activar decodificación greedy o ajustar temperature y Top-p.
- Subir un archivo de audio o grabar directamente con tu micrófono.
- Añadir hotwords opcionales, como nombres o términos técnicos.
- Ver la transcripción, la duración del audio y el factor en tiempo real.
Aquí, modo online no significa que tu audio se envíe a un servicio externo.
Procesa grabaciones largas por partes de forma progresiva y usa asr_stream_server cuando está disponible.
El modo offline procesa el archivo completo antes de mostrar el resultado.
Prueba con una grabación corta
Para la primera prueba, grabé una frase corta directamente con el micrófono y seleccioné el modo Offline con cuatro hilos de CPU.
Un RTF de 0,9584 significa que el modelo necesitó unos 0,96 segundos para procesar cada segundo de audio.
Esto es aproximadamente 1,04× en tiempo real, por lo que la transcripción se completó ligeramente más rápido que la duración real de la grabación.
Prueba con una grabación más larga
También probé la interfaz con una grabación más larga de unos 109,7 segundos de voz. El modelo generó la transcripción completa y mostró:
RTF: 0.5305
Audio: 109.7s
Esto significa que el modelo necesitó aproximadamente 0,53 segundos para procesar cada segundo de audio. La transcripción completa tardó alrededor de 58 segundos, con una velocidad aproximada de 1,88× en tiempo real.
Conclusiones
Me ha sorprendido lo práctico que se ha vuelto el reconocimiento de voz en local.
Incluso en una CPU antigua, VibeASR.cpp puede transcribir audio cerca de o más rápido que en tiempo real sin exigir una GPU, mucha memoria ni gran almacenamiento.
El ejecutable compilado también puede integrarse en una aplicación de Python, envolverse en un endpoint de FastAPI o usarse como motor de transcripción en una herramienta local más amplia.
El ajuste principal a considerar es el número de hilos de CPU asignados al proceso.
También debes elegir entre el modo online, que muestra la transcripción progresivamente, y el modo offline, que devuelve el texto completo tras procesar el audio.
La configuración aún podría simplificarse, especialmente en Windows, Linux y macOS.
Como el proyecto sigue evolucionando, espero que la instalación y el soporte de binarios precompilados mejoren con el tiempo. Cuando haya un binario autónomo estable, me veo usando este modelo en muchos más proyectos locales de voz a texto.
También te recomiendo echar un vistazo a nuestro tutorial de la API GPT Live Transcribe.
