Jak uruchomić lokalne rozpoznawanie mowy na CPU z VibeASR.cpp

Automatyczne rozpoznawanie mowy znacząco się rozwinęło w ostatnich latach. Modele speech-to-text, które kiedyś wymagały mocnych GPU i dawały niespójne wyniki, dziś potrafią dostarczać dokładne transkrypcje na zwykłych komputerach. 

Jednocześnie modele stały się mniejsze, wnioskowanie na CPU stało się szybsze, a wsparcie wielojęzyczne się rozszerzyło, dając użytkownikom lepsze połączenie jakości transkrypcji, szybkości, dostępności i prywatności.

VibeVoice-ASR-BitNet firmy Microsoft jest dobrym przykładem tego postępu. 

Jego zoptymalizowane środowisko uruchomieniowe VibeASR.cpp umożliwia lokalne działanie wielojęzycznego speech-to-text na komputerze z Windows, Linux lub macOS bez dedykowanego GPU i bez wysyłania nagrań do chmury.

W tym przewodniku nauczysz się, jak zainstalować i zbudować VibeASR.cpp, pobrać skwantowany model, transkrybować pliki audio z wiersza poleceń, uruchomić trwały serwer strumieniowania oraz korzystać z interfejsu webowego Gradio do wysyłania lub nagrywania mowy. 

Czym jest Microsoft VibeASR.cpp? 

VibeASR.cpp to oficjalne środowisko wnioskowania C++ firmy Microsoft dla VibeVoice-ASR-BitNet, skompresowanego, wielojęzycznego modelu automatycznego rozpoznawania mowy zaprojektowanego do wydajnego lokalnego wnioskowania na CPU. 

Zamiast być osobnym modelem mowy, VibeASR.cpp dostarcza zoptymalizowany silnik potrzebny do uruchomienia modelu, umożliwiając transkrypcję w czasie rzeczywistym bez dedykowanego GPU ani chmurowej usługi mowy. 

Dzięki temu nadaje się do laptopów, komputerów stacjonarnych, urządzeń brzegowych i innych systemów z ograniczonymi zasobami obliczeniowymi. 

Źródło: microsoft/VibeVoice-ASR-BitNet

Aby uczynić wdrożenie na CPU praktycznym, Microsoft zastąpił komponent modelu językowego Qwen2.5-7B użyty w oryginalnej architekturze VibeVoice-ASR znacznie mniejszym modelem Qwen2.5-1.5B. 

Zastosowano też różne metody kwantyzacji dla dwóch głównych komponentów:

• I8_S dla enkodera audio VAE
• I2_S dla modelu językowego, z osadzeniami o wyższej precyzji

Te optymalizacje zmniejszają łączny rozmiar modelu z około 4,62 GB do 1,58 GB, co czyni go praktycznym do uruchamiania na laptopach i komputerach stacjonarnych. 

Pomimo znacznej redukcji rozmiaru, skompresowany model wykazuje jedynie relatywnie niewielki wzrost o około 1–4 punkty procentowe w współczynniku błędu słownego w porównaniu z większą architekturą. 

VibeASR.cpp wykorzystuje framework ggml, niestandardowe instrukcje CPU oraz fuzję operatorów w celu przyspieszenia wnioskowania. 

Zgodnie z benchmarkami Microsoftu, może działać 1,6–2,3 razy szybciej niż Whisper.cpp przy porównywalnych rozmiarach modeli i osiągać prędkość szybszą niż rzeczywista na wspieranych CPU przy odpowiedniej liczbie wątków.

W benchmarkach CPU Microsoftu model osiągnął RTF 0,63 przy czterech wątkach oraz 0,42 przy ośmiu wątkach, co odpowiada mniej więcej 1,59× i 2,38× prędkości rzeczywistej. 

Zgłaszany WER obejmuje 8,25% na MLC English, 21,36% na nagraniach AMI z headsetu, 25,87% na nagraniach AMI z mikrofonu dalekiego pola oraz 2,41% na LibriSpeech clean, pokazując dobry balans między dokładnością, rozmiarem modelu a wydajnością CPU. 

1. Zainstaluj wymagane narzędzia kompilacyjne

VibeASR.cpp działa w całości na CPU, więc nie potrzebujesz dedykowanego GPU. Wystarczy wspierany komputer z Windows, Linux lub macOS, Python 3.9 lub nowszy, Git, kompilator C++ oraz ok. 4 GB wolnego miejsca na kod źródłowy, pliki kompilacji i model.

Proces budowania wymaga także CMake i Ninja. 

Na Windows najprościej użyć w64devkit, które dostarcza kompilator i narzędzia wstępnie skonfigurowane w terminalu. 

Na Linuksie wymagane pakiety można zainstalować bezpośrednio przez menedżer pakietów systemu.

Windows

Pobierz najnowszy plik x64 .exe ze strony wydań w64devkit releases.

Pobrany plik to samorozpakowujące się archiwum. Uruchom je i wypakuj folder w proste miejsce, np.:

C:\w64devkit

Następnie otwórz:

C:\w64devkit\w64devkit.exe

To uruchomi gotowy do użycia terminal zawierający GCC, CMake, Make i Ninja. Możesz używać tego terminala w kolejnych krokach dla Windows bez ręcznej konfiguracji zmiennych środowiskowych.

Linux

W Ubuntu, Debianie i pokrewnych dystrybucjach Linux wymagane narzędzia kompilacyjne można zainstalować jednym poleceniem:

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

To zainstaluje kompilator GCC, CMake, Ninja, Git, Pythona oraz pakiet potrzebny do tworzenia wirtualnego środowiska Pythona.

macOS

W macOS zainstaluj narzędzia deweloperskie wiersza poleceń Apple:

xcode-select --install

Będziesz też potrzebować Git, Pythona 3.9 lub nowszego, CMake i Ninja. Najłatwiej zainstalować pozostałe narzędzia przez Homebrew:

brew install git python cmake ninja

2. Sklonuj VibeASR.cpp i skonfiguruj środowisko Pythona

Poniższy proces konfiguracji jest taki sam dla Windows, Linux i macOS. 

Jedyny krok specyficzny dla systemu to polecenie używane do aktywacji wirtualnego środowiska Pythona.

Otwórz terminal, przejdź do folderu, w którym chcesz przechowywać projekt, i sklonuj repozytorium VibeASR.cpp:

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

Opcja --recursive pobiera też wymagany podmoduł llama.cpp. Bez niego brakowałoby części plików potrzebnych do zbudowania środowiska wnioskowania.

Utwórz wirtualne środowisko Pythona w folderze projektu. 

python -m venv .venv

Aktywuj je poleceniem odpowiednim dla twojego systemu operacyjnego.

Windows w terminalu w64devkit:

. .venv/Scripts/activate

Linux i macOS:

source .venv/bin/activate

Po aktywacji terminal powinien wyświetlać (.venv) przed wierszem poleceń. Potwierdź dostępność Pythona: 

python --version

Zaktualizuj pip i zainstaluj zależności projektu: 

python -m pip install --upgrade pip

pip install -r requirements.txt

Te zależności obejmują pakiety Pythona używane przez skrypt konfiguracji, proces pobierania modelu oraz lokalny interfejs webowy Gradio. 

3. Zbuduj VibeASR.cpp i pobierz model

VibeASR.cpp zawiera skrypt setup, który obsługuje zarówno proces budowania C++, jak i pobieranie modelu.

Kompiluje on programy wiersza poleceń i strumieniowania, instaluje wymagany pakiet GGUF i pobiera wstępnie skwantowane pliki modelu do katalogu projektu.

Upewnij się, że wirtualne środowisko Pythona jest aktywne przed uruchomieniem skryptu setup.

W Linux i macOS uruchom:

python setup_env.py

W Windows uruchom poniższe polecenie w terminalu w64devkit:

CMAKE_GENERATOR=Ninja python setup_env.py

Ustawienie CMAKE_GENERATOR=Ninja zapewnia, że CMake użyje systemu budowania Ninja zamiast próbować użyć Microsoft Visual C++, który nie jest dostępny w środowisku w64devkit.

Skrypt setup wykona:

• Instalację wymaganego pakietu Pythona gguf.
• Konfigurację i kompilację VibeASR.cpp.
• Budowę programów do wnioskowania i strumieniowania.
• Pobranie wstępnie skwantowanych plików modelu VibeASR.
• Zapis pobranych modeli w models/vibeasr.

Po zakończeniu procesu główny plik wykonywalny wnioskowania będzie dostępny w następującym miejscu.

Windows:

build/bin/asr_infer.exe

Linux i macOS:

build/bin/asr_infer

Sprawdź, czy plik wykonywalny został poprawnie zbudowany, wyświetlając dostępne opcje wiersza poleceń.

Windows:

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

Linux i macOS:

./build/bin/asr_infer --help

4. Przetestuj transkrypcję plikową i strumieniową

Skoro środowisko uruchomieniowe i model są gotowe, możesz przetestować dwie metody transkrypcji. 

Standardowy program wnioskowania przetwarza jeden plik audio i zwraca kompletną transkrypcję, natomiast serwer strumieniowy utrzymuje model w pamięci i wyświetla transkrypcję progresywnie wraz z generowaniem tokenów.

Najpierw pobierz krótką próbkę nagrania z poziomu folderu projektu VibeASR.cpp:

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

Plik audio zostanie zapisany jako recording.wav w bieżącym katalogu projektu.

Transkrybuj plik audio

Standardowe polecenie wnioskowania ładuje enkoder audio i model językowy, przetwarza nagranie i wypisuje kompletną transkrypcję.

W Windows uruchom:

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

W Linux i macOS użyj tego samego polecenia bez rozszerzenia .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

Opcja -t 6 przydziela sześć wątków CPU do wnioskowania. Możesz zwiększyć lub zmniejszyć tę liczbę w zależności od swojego procesora. 

Opcja --greedy wybiera najbardziej prawdopodobny token na każdym kroku dekodowania, dając spójne wyniki transkrypcji.

Na moim komputerze nagranie o długości 14,085 s zostało przetworzone w ok. 13,7 s:

RTF: 0.9726
Speed: approximately 1.03× real time

Współczynnik czasu rzeczywistego (RTF) porównuje czas przetwarzania z długością nagrania. 

RTF poniżej 1.0 oznacza, że nagranie zostało przetranskrybowane szybciej niż trwa jego odtwarzanie. Wydajność będzie się różnić w zależności od procesora, systemu operacyjnego, liczby wątków i długości nagrania.

Przetestuj strumieniowanie token po tokenie

VibeASR.cpp zawiera też trwały serwer strumieniowy. Ładuje on dwa pliki modelu raz i pozostaje aktywny, pozwalając przesyłać wiele nagrań bez ponownego uruchamiania i ładowania modelu za każdym razem.

Wyjście działa podobnie do strumieniowania z dużego modelu językowego. 

Zamiast czekać na zakończenie całej transkrypcji, zaczynasz widzieć tekst, gdy dekoder generuje kolejne tokeny. 

Niektóre tokeny mogą reprezentować całe słowa, inne fragmenty słów lub interpunkcję, ale są wyświetlane progresywnie, aż transkrypcja będzie kompletna.

Windows — uruchom serwer poleceniem:

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

Linux i macOS — uruchom:

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

Poczekaj, aż serwer zakończy ładowanie modeli i wyświetli:

---READY---

Wpisz ścieżkę do pliku audio i naciśnij Enter:

recording.wav

Transkrypcja zacznie się pojawiać token po tokenie. Po pełnym przetworzeniu nagrania serwer wyświetli:

---END---

Następnie możesz wpisać ścieżkę do kolejnego pliku audio bez ponownego ładowania modeli. Aby zatrzymać serwer, wpisz:

exit

Ten trwały tryb pracy jest szczególnie przydatny przy transkrybowaniu wielu nagrań lub łączeniu VibeASR.cpp z inną aplikacją, która potrzebuje progresywnego wyjścia transkrypcji.

5. Uruchom i przetestuj interfejs webowy

VibeASR.cpp zawiera lokalny interfejs webowy Gradio do wysyłania plików audio lub nagrywania mowy mikrofonem. Proces jest taki sam w Windows, Linux i macOS, choć w Windows używane są pliki wykonywalne z rozszerzeniem .exe.

Zależności potrzebne do interfejsu, w tym Gradio, SoundFile i NumPy, zostały już zainstalowane przez requirements.txt.

Najpierw upewnij się, że środowisko wirtualne jest aktywne.

Windows w terminalu w64devkit:

. .venv/Scripts/activate

Linux i macOS:

source .venv/bin/activate

W Windows uruchom interfejs poleceniem:

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

W Linux i macOS domyślne ścieżki do plików wykonywalnych są wykrywane automatycznie:

python demo/gradio_asr_demo.py --port 7860

Ścieżki modeli są już skonfigurowane w skrypcie Gradio dla wszystkich systemów operacyjnych, więc nie musisz dodawać ich do polecenia. 

Skrypt obsługuje też osobne ścieżki dla standardowego programu wnioskowania i serwera strumieniowego.

Otwórz w przeglądarce następujący adres:

http://127.0.0.1:7860

Poznaj interfejs

Interfejs pozwala ci:

• Wybrać model CPU.
• Określić liczbę wątków CPU.
• Przełączać między przetwarzaniem Online i Offline.
• Włączyć dekodowanie greedy lub dostroić temperaturę i Top-p.
• Wgrać plik audio lub nagrać bezpośrednio z mikrofonu.
• Dodać opcjonalne hotwordy, np. nazwy własne lub terminy techniczne.
• Zobaczyć transkrypcję, długość audio i współczynnik RTF.

Tutaj tryb Online nie oznacza wysyłania twojego audio do usługi online.

Przetwarza dłuższe nagrania progresywnie w kawałkach i używa asr_stream_server, gdy jest dostępny. 

Tryb Offline przetwarza cały plik audio przed wyświetleniem wyniku.

Przetestuj krótkie nagranie

Na pierwszy test nagrałem krótkie zdanie bezpośrednio przez mikrofon i wybrałem tryb Offline z czterema wątkami CPU.

RTF 0,9584 oznacza, że model potrzebował ok. 0,96 s na przetworzenie każdej sekundy audio. 

To około 1,04× prędkości rzeczywistej, więc transkrypcja zakończyła się nieco szybciej niż trwa samo nagranie.

Przetestuj dłuższe nagranie

Przetestowałem też interfejs na dłuższym nagraniu zawierającym ok. 109,7 s mowy. Model poprawnie wygenerował pełną transkrypcję i zgłosił:

RTF: 0.5305
Audio: 109.7s

Oznacza to, że model potrzebował około 0,53 s na przetworzenie każdej sekundy audio. Całe nagranie zajęło około 58 sekund, co daje prędkość około 1,88× prędkości rzeczywistej.

Końcowe uwagi

Imponuje, jak praktyczne stało się lokalne rozpoznawanie mowy. 

Nawet na starszym CPU VibeASR.cpp potrafi transkrybować audio w tempie zbliżonym do czasu rzeczywistego lub szybciej, bez potrzeby GPU, dużej ilości pamięci czy dużej przestrzeni dyskowej. 

Skompilowany program można też zintegrować z aplikacją w Pythonie, opakować w endpoint FastAPI lub użyć jako silnika transkrypcji w większym lokalnym narzędziu.

Głównym ustawieniem do rozważenia jest liczba wątków CPU przypisana do procesu. 

Musisz też wybrać między trybem online, który strumieniuje transkrypt progresywnie, a trybem offline, który zwraca kompletną transkrypcję po przetworzeniu audio.

Konfiguracja mogłaby być jeszcze prostsza, zwłaszcza w Windows, Linux i macOS. 

Ponieważ projekt wciąż się rozwija, spodziewam się, że instalacja i wsparcie dla gotowych binariów będą się z czasem poprawiać. Gdy będzie dostępny stabilny samodzielny plik binarny, widzę wiele zastosowań tego modelu w moich lokalnych projektach speech-to-text.

Polecam też nasz samouczek GPT Live Transcribe API.