Como rodar reconhecimento de voz local (speech-to-text) na CPU com VibeASR.cpp

O reconhecimento automático de fala evoluiu muito nos últimos anos. Modelos de speech-to-text que antes exigiam GPUs potentes e entregavam resultados inconsistentes hoje já conseguem gerar transcrições precisas em computadores comuns. 

Ao mesmo tempo, os modelos ficaram menores, a inferência em CPU ficou mais rápida e o suporte multilíngue se expandiu — entregando uma combinação melhor de qualidade de transcrição, velocidade, acessibilidade e privacidade.

O VibeVoice-ASR-BitNet, da Microsoft, é um ótimo exemplo desse avanço. 

Seu runtime otimizado, VibeASR.cpp, torna possível rodar speech-to-text multilíngue localmente em computadores Windows, Linux ou macOS, sem depender de GPU dedicada ou enviar gravações para a nuvem.

Neste guia, você vai aprender a instalar e compilar o VibeASR.cpp, baixar o modelo quantizado, transcrever arquivos de áudio via linha de comando, rodar o servidor de streaming persistente e usar a interface web em Gradio para enviar ou gravar áudio. 

O que é o Microsoft VibeASR.cpp? 

VibeASR.cpp é o runtime oficial em C++ da Microsoft para o VibeVoice-ASR-BitNet, um modelo multilíngue de reconhecimento automático de fala comprimido, projetado para inferência local eficiente em CPUs. 

Em vez de ser um modelo de fala separado, o VibeASR.cpp fornece o mecanismo otimizado necessário para executar o modelo, permitindo transcrição em tempo real sem GPU dedicada ou serviços de fala na nuvem. 

Isso o torna adequado para notebooks, desktops, dispositivos de borda e outros sistemas com recursos computacionais limitados. 

Fonte: microsoft/VibeVoice-ASR-BitNet

Para viabilizar o uso em CPU, a Microsoft substituiu o componente de linguagem Qwen2.5-7B usado na arquitetura original do VibeVoice-ASR pelo modelo bem menor Qwen2.5-1.5B. 

Ela também aplica diferentes métodos de quantização aos dois componentes principais:

• I8_S para o codificador de áudio VAE
• I2_S para o modelo de linguagem, com embeddings de maior precisão

Essas otimizações reduzem o tamanho total do modelo de aproximadamente 4,62 GB para 1,58 GB, tornando prático rodá-lo em notebooks e desktops. 

Apesar da redução substancial, o modelo comprimido apresenta apenas um aumento relativamente pequeno, de cerca de 1–4 pontos percentuais na taxa de erro de palavras em comparação com a arquitetura maior. 

O VibeASR.cpp usa o framework ggml, instruções de CPU customizadas e fusão de operadores para aumentar a velocidade de inferência. 

Segundo os benchmarks da Microsoft, ele pode rodar entre 1,6 e 2,3 vezes mais rápido que o Whisper.cpp em tamanhos de modelo comparáveis e alcançar transcrição mais rápida que o tempo real em CPUs compatíveis quando há threads suficientes.

Nos testes em CPU da Microsoft, o modelo alcançou um RTF de 0,63 com quatro threads e 0,42 com oito threads, equivalentes a cerca de 1,59× e 2,38× a velocidade em tempo real. 

A WER informada inclui 8,25% no MLC English, 21,36% em áudio de headset AMI, 25,87% em áudio AMI com microfone distante e 2,41% no LibriSpeech clean, mostrando um bom equilíbrio entre acurácia, tamanho do modelo e desempenho em CPU. 

1. Instale as ferramentas de compilação necessárias

O VibeASR.cpp roda totalmente na CPU, então você não precisa de GPU dedicada. Você só precisa de um computador Windows, Linux ou macOS compatível, Python 3.9 ou superior, Git, um compilador C++ e cerca de 4 GB de espaço livre em disco para o código-fonte, arquivos de build e modelo.

O processo de build também requer CMake e Ninja. 

No Windows, a forma mais simples é usar o w64devkit, que fornece compilador e ferramentas de build em um terminal pré-configurado. 

No Linux, os pacotes necessários podem ser instalados diretamente pelo gerenciador de pacotes do sistema.

Windows

Baixe o arquivo .exe x64 mais recente na página de releases do w64devkit.

O arquivo baixado é um autoextrator. Execute-o e extraia a pasta em um local simples, como:

C:\w64devkit

Depois, abra:

C:\w64devkit\w64devkit.exe

Isso inicia um terminal pronto para uso com GCC, CMake, Make e Ninja. Você pode usar esse terminal para o restante dos passos no Windows sem precisar configurar variáveis de ambiente manualmente.

Linux

No Ubuntu, Debian e distribuições relacionadas, o compilador e as ferramentas de build necessárias podem ser instalados com um único comando:

sudo apt update
sudo apt install build-essential cmake ninja-build git python3 python3-venv

Isso instala o compilador GCC, CMake, Ninja, Git, Python e o pacote necessário para criar um ambiente virtual Python.

macOS

No macOS, instale as ferramentas de desenvolvimento via linha de comando da Apple:

xcode-select --install

Você também vai precisar de Git, Python 3.9 ou superior, CMake e Ninja. A forma mais simples de instalar o restante é via Homebrew:

brew install git python cmake ninja

2. Clone o VibeASR.cpp e configure o ambiente Python

O processo a seguir é o mesmo para Windows, Linux e macOS. 

A única diferença por sistema operacional é o comando para ativar o ambiente virtual do Python.

Abra o terminal, vá até a pasta onde quer armazenar o projeto e clone o repositório do VibeASR.cpp:

git clone --recursive https://github.com/microsoft/VibeASR.cpp.git
cd VibeASR.cpp

--recursive também baixa o submódulo llama.cpp necessário. Sem ele, faltariam arquivos para compilar o runtime de inferência.

Crie um ambiente virtual Python dentro da pasta do projeto. 

python -m venv .venv

Ative-o com o comando do seu sistema operacional.

Windows usando o terminal do w64devkit:

. .venv/Scripts/activate

Linux e macOS:

source .venv/bin/activate

Após ativar, o terminal deve exibir (.venv) antes do prompt. Confirme se o Python está disponível: 

python --version

Atualize o pip e instale as dependências do projeto: 

python -m pip install --upgrade pip

pip install -r requirements.txt

Elas incluem os pacotes Python usados pelo script de setup, pelo processo de download do modelo e pela interface web local em Gradio. 

3. Compile o VibeASR.cpp e baixe o modelo

O VibeASR.cpp inclui um script de configuração que realiza tanto a compilação em C++ quanto o download do modelo.

Ele compila os executáveis de linha de comando e de streaming, instala o pacote GGUF necessário e baixa os arquivos do modelo pré-quantizado para o diretório do projeto.

Antes de rodar o script, garanta que o ambiente virtual do Python esteja ativo.

No Linux e macOS, execute:

python setup_env.py

No Windows, rode o seguinte comando dentro do terminal do w64devkit:

CMAKE_GENERATOR=Ninja python setup_env.py

Definir CMAKE_GENERATOR=Ninja garante que o CMake use o Ninja em vez de tentar usar o Microsoft Visual C++, que não está disponível no ambiente do w64devkit.

O script fará:

• A instalação do pacote Python gguf.
• A configuração e compilação do VibeASR.cpp.
• A construção dos executáveis de inferência e streaming.
• O download dos arquivos do modelo VibeASR pré-quantizados.
• O salvamento dos modelos em models/vibeasr.

Depois que o processo terminar, o executável principal de inferência estará no seguinte local.

No Windows:

build/bin/asr_infer.exe

No Linux e macOS:

build/bin/asr_infer

Verifique se o executável foi criado com sucesso exibindo as opções disponíveis na linha de comando.

No Windows:

./build/bin/asr_infer.exe --help

No Linux e macOS:

./build/bin/asr_infer --help

4. Teste a transcrição de arquivo e por streaming

Com o runtime e o modelo prontos, você pode testar dois modos de transcrição. 

O executável padrão processa um arquivo de áudio e retorna a transcrição completa, enquanto o servidor de streaming mantém o modelo carregado e exibe a transcrição progressivamente conforme os tokens são gerados.

Primeiro, baixe uma gravação de exemplo curta dentro da pasta do projeto VibeASR.cpp:

curl -L "https://homepages.inf.ed.ac.uk/htang2/notes/speech-samples/103-1240-0000.wav" -o recording.wav

O arquivo de áudio será salvo como recording.wav no diretório atual do projeto.

Transcreva um arquivo de áudio

O comando de inferência padrão carrega o codificador de áudio e o modelo de linguagem, processa a gravação e imprime a transcrição completa.

No Windows, execute:

./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 \
  --greedy

No Linux e macOS, use o mesmo comando sem a extensão .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

A opção -t 6 atribui seis threads de CPU à inferência. Você pode aumentar ou reduzir esse número conforme o seu processador. 

A opção --greedy seleciona o token mais provável a cada etapa de decodificação, gerando resultados consistentes.

No meu computador, a gravação de 14,085 segundos levou cerca de 13,7 segundos para ser processada:

RTF: 0.9726
Speed: approximately 1.03× real time

O real-time factor (RTF) compara o tempo de processamento com a duração do áudio. 

Um RTF abaixo de 1,0 significa que a gravação foi transcrita mais rápido do que seu tempo de reprodução. O desempenho pode variar conforme processador, sistema operacional, número de threads e duração do áudio.

Teste o streaming token a token

O VibeASR.cpp também inclui um servidor de streaming persistente. Ele carrega os dois arquivos de modelo uma única vez e permanece ativo, permitindo enviar várias gravações sem reiniciar e recarregar o modelo a cada vez.

A saída funciona de forma semelhante ao streaming de um modelo de linguagem grande. 

Em vez de esperar toda a transcrição terminar, você começa a ver o texto conforme o decodificador gera cada token. 

Alguns tokens podem representar palavras completas; outros, partes de palavras ou pontuação — mas todos são exibidos progressivamente até concluir a transcrição.

No Windows, inicie o servidor com:

./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 \
  --greedy

No Linux e macOS, rode:

./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

Espere o servidor terminar de carregar os modelos e exibir:

---READY---

Digite o caminho do arquivo de áudio e pressione Enter:

recording.wav

A transcrição começará a aparecer token por token. Quando a gravação for totalmente processada, o servidor exibirá:

---END---

Você pode então informar outro caminho de arquivo de áudio sem recarregar os modelos. Para encerrar o servidor, digite:

exit

Esse fluxo persistente é especialmente útil ao transcrever várias gravações ou ao conectar o VibeASR.cpp a outro aplicativo que precise de saída progressiva.

5. Inicie e teste a interface web

O VibeASR.cpp inclui uma interface web local em Gradio para enviar arquivos de áudio ou gravar fala pelo microfone. O processo é o mesmo no Windows, Linux e macOS, embora o Windows use executáveis com extensão .exe.

As dependências necessárias para a interface — incluindo Gradio, SoundFile e NumPy — já foram instaladas via requirements.txt.

Primeiro, garanta que o ambiente virtual esteja ativo.

Windows usando o terminal do w64devkit:

. .venv/Scripts/activate

Linux e macOS:

source .venv/bin/activate

No Windows, inicie a interface com:

python demo/gradio_asr_demo.py \
  --port 7860 \
  --bin build/bin/asr_infer.exe \
  --server-bin build/bin/asr_stream_server.exe

No Linux e macOS, os caminhos padrão dos executáveis são detectados automaticamente:

python demo/gradio_asr_demo.py --port 7860

Os caminhos dos modelos já estão configurados no script do Gradio para todos os sistemas, então você não precisa incluí-los no comando. 

O script também suporta caminhos separados para o executável padrão de inferência e para o servidor de streaming.

Abra o seguinte endereço no seu navegador:

http://127.0.0.1:7860

Explore a interface

A interface permite:

• Selecionar o modelo para CPU.
• Definir o número de threads de CPU.
• Alternar entre processamento Online e Offline.
• Habilitar decodificação greedy ou ajustar temperatura e Top-p.
• Enviar um arquivo de áudio ou gravar direto do microfone.
• Adicionar hotwords opcionais, como nomes ou termos técnicos.
• Ver a transcrição, duração do áudio e o real-time factor.

Aqui, modo Online não significa que seu áudio é enviado para um serviço na internet.

Ele processa gravações longas progressivamente em blocos e usa o asr_stream_server quando disponível. 

O modo Offline processa o arquivo completo antes de exibir o resultado.

Teste uma gravação curta

No primeiro teste, gravei uma frase curta diretamente pelo microfone e selecionei o modo Offline com quatro threads de CPU.

Um RTF de 0,9584 indica que o modelo levou cerca de 0,96 s para processar cada segundo de áudio. 

Isso equivale a aproximadamente 1,04× o tempo real, então a transcrição terminou um pouco antes da duração da gravação.

Teste uma gravação mais longa

Também testei a interface com uma gravação mais longa, com cerca de 109,7 segundos de fala. O modelo gerou a transcrição completa e informou:

RTF: 0.5305
Audio: 109.7s

Ou seja, o modelo precisou de aproximadamente 0,53 s para processar cada segundo de áudio. A gravação completa levou cerca de 58 segundos para ser transcrita, com velocidade de aproximadamente 1,88× o tempo real.

Considerações finais

Fiquei impressionado com o quanto o reconhecimento de fala local se tornou viável. 

Mesmo em uma CPU mais antiga, o VibeASR.cpp consegue transcrever perto ou acima da velocidade em tempo real sem exigir GPU, muita memória ou grande espaço em disco. 

O executável compilado também pode ser integrado a uma aplicação Python, encapsulado em um endpoint FastAPI ou usado como motor de transcrição em uma ferramenta local maior.

A principal configuração a considerar é o número de threads de CPU atribuídas ao processo. 

Você também precisa escolher entre o modo online, que transmite a transcrição progressivamente, e o modo offline, que retorna o texto completo após processar o áudio.

A configuração ainda poderia ser mais simples, especialmente no Windows, Linux e macOS. 

Como o projeto ainda está evoluindo, espero que a instalação e o suporte a binários prontos melhorem com o tempo. Quando houver um binário standalone estável, me vejo usando este modelo em muitos outros projetos locais de speech-to-text.

Aproveite também para conferir nosso tutorial da GPT Live Transcribe API.