Quantization Aware Training: przewodnik po usprawnieniu lokalnej inferencji Gemma 4

Czym jest kwantyzacja?

Kwantyzacja to technika kompresji modeli, która obniża precyzję wag modelu. 

Duże modele językowe są zwykle przechowywane w formatach o wysokiej precyzji, takich jak BF16 czy FP16, które zachowują jakość, ale wymagają sporej pamięci. Kwantyzacja konwertuje te wagi do formatów o mniejszej liczbie bitów, np. 8‑bitowych lub 4‑bitowych, dzięki czemu model zużywa mniej VRAM-u i łatwiej działa lokalnie. Hugging Face podaje, że kwantyzacja 8‑bitowa może mniej więcej o połowę zmniejszyć zużycie pamięci, a 4‑bitowa zredukować je jeszcze bardziej.

Kompromisem jest to, że niższa precyzja może czasem obniżyć jakość wyjścia, zwłaszcza jeśli model nie był zoptymalizowany pod kątem kwantyzacji. Mówiąc prosto: BF16 i FP16 zwykle zapewniają najlepszą jakość kosztem pamięci; modele 8‑bitowe są mniejsze, a często utrzymują wysoką jakość, natomiast 4‑bitowe są dużo mniejsze, ale mogą tracić nieco dokładności lub stabilności. 

Dla lokalnej inferencji ten kompromis często się opłaca, bo pozwala uruchamiać większe modele na konsumenckich GPU zamiast na drogim sprzęcie centrów danych.

Czym jest Quantization Aware Training?

Quantization-Aware Training (QAT) to technika, w której model jest trenowany lub dostrajany z symulacją zachowania niskiej precyzji. Pomaga to utrzymać większą stabilność po kwantyzacji i może poprawić wydajność lokalnej inferencji przy małej liczbie bitów.

Co wyróżnia QAT?

Typowe podejście, czyli kwantyzacja po treningu, kompresuje model po zakończeniu uczenia. Jest to proste i praktyczne, ale model może stracić na jakości, bo nie był trenowany do pracy z wagami o niskiej precyzji. 

Według dokumentacji Google AI Edge, kwantyzacja po treningu to krok konwersji, który może zmniejszyć rozmiar modelu i poprawić opóźnienia, zazwyczaj przy niewielkiej utracie dokładności. Jednak ostateczna jakość wciąż zależy od modelu i poziomu kwantyzacji. 

Quantization-Aware Training, czyli QAT, podchodzi inaczej. Zamiast kwantyzować dopiero po treningu, QAT symuluje niską precyzję podczas treningu lub dostrajania. Dzięki temu model uczy się, jak zachować stabilność, gdy później zostanie przekonwertowany do mniejszego formatu. Minimalizuje to utratę jakości przy kompresji modelu.

Dlatego Gemma 4 QAT jest użyteczna dla lokalnego AI. Powstała z myślą o kwantyzacji, więc potrafi zachować więcej jakości modelu bazowego przy mniejszym zużyciu pamięci. Dla użytkowników uruchamiających modele na konsumenckich GPU może to oznaczać lepszą stabilność przy niskiej liczbie bitów, niższy pobór VRAM-u i bardziej praktyczną lokalną inferencję.

Krok 1: Zainstaluj zależności i zbuduj llama.cpp

Zanim pobierzesz modele, przygotujmy lokalne środowisko uruchomieniowe. Ten tutorial testowaliśmy na maszynie z GPU NVIDIA RTX 4090 i 24 GB VRAM-u. Użyjemy llama.cpp jako runtime’u inferencji, GGUF jako formatu modelu oraz plików modelu skwantyzowanych UD-Q4_K_XL.

Testowana konfiguracja:

• GPU: NVIDIA RTX 4090
• VRAM: 24 GB
• Runtime: llama.cpp
• Format modelu: GGUF
• Kwantyzacja: UD-Q4_K_XL

Porównamy następujące dwa modele GGUF od Unsloth:

• unsloth/gemma-4-12B-it-GGUF
• unsloth/gemma-4-12B-it-qat-GGUF

Najpierw sprawdź, czy twój GPU jest dostępny.

nvidia-smi

Następnie zainstaluj pakiety systemowe potrzebne do zbudowania llama.cpp.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y

Sklonuj oficjalne repozytorium llama.cpp.

git clone https://github.com/ggml-org/llama.cpp

Teraz zbuduj llama.cpp z włączoną obsługą CUDA. Pozwoli to uruchamiać warstwy modelu na GPU zamiast wyłącznie na CPU.

cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF \
    -DGGML_CUDA=ON

Skompiluj wymagane binaria.

cmake --build llama.cpp/build \
    --config Release \
    -j \
    --clean-first \
    --target llama-cli llama-mtmd-cli llama-server llama-gguf-split

Po zakończeniu budowy głównym binarium, którego użyjemy, jest llama-server. Pozwala on uruchomić lokalnie model GGUF i wystawia zgodny z OpenAI punkt API, który możemy odpytwać za pomocą curl. 

Krok 2: Pobierz modele Gemma 4 12B – bez QAT i z QAT 

Skoro llama.cpp jest gotowe, możemy pobrać z Hugging Face obie warianty modelu Gemma 4 12B. Pobierzemy zwykły model instruktażowy oraz wersję QAT w formacie GGUF.

Najpierw zainstaluj CLI Hugging Face Hub z obsługą szybszego pobierania.

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transfer

Włącz szybkie pobieranie Xet.

export HF_XET_HIGH_PERFORMANCE=1

Pobierz zwykły model instruktażowy Gemma 4 12B w formacie GGUF.

hf download unsloth/gemma-4-12B-it-GGUF \
  --local-dir models/gemma-4-12B-it-GGUF \
  --include "*mmproj-BF16*" \
  --include "*UD-Q4_K_XL*"

Następnie pobierz wersję QAT w tym samym formacie kwantyzacji.

hf download unsloth/gemma-4-12B-it-qat-GGUF \
  --local-dir models/gemma-4-12B-it-qat-GGUF \
  --include "*mmproj-BF16*" \
  --include "*UD-Q4_K_XL*"

Flagi --include zapewniają, że pobieramy tylko pliki potrzebne do tego tutorialu, zamiast całego repozytorium. Tutaj pobieramy pliki modelu GGUF UD-Q4_K_XL oraz pliki mmproj-BF16 używane przez paczkę modelu. 

Po zakończeniu pobierania upewnij się, że istnieją oba foldery modeli.

ls models

Oczekiwany wynik:

gemma-4-12B-it-GGUF
gemma-4-12B-it-qat-GGUF

W tym momencie oba modele — bez QAT i z QAT — są dostępne lokalnie i możemy zacząć je serwować za pomocą llama-server.

Krok 3: Uruchom model bez QAT z llama-server

Zaczniemy od uruchomienia zwykłego modelu instruktażowego Gemma 4 12B. Da nam to punkt odniesienia, by później porównać go z wersją QAT przy tych samych ustawieniach.

Uruchom model bez QAT za pomocą llama-server.

./llama.cpp/llama-server \
  -m models/gemma-4-12B-it-GGUF/*UD-Q4_K_XL*.gguf \
  --host 0.0.0.0 \
  --port 8001 \
  --ctx-size 8192 \
  --n-gpu-layers 99 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

To uruchamia lokalny, zgodny z OpenAI serwer pod adresem http://localhost:8001.

Otwórz drugi terminal i wyślij zapytanie do lokalnego serwera.

time curl http://localhost:8001/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "model": "gemma-4-12B-it",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful local AI assistant."
    },
    {
      "role": "user",
      "content": "Explain why quantization-aware training is useful for running LLMs on consumer GPUs."
    }
  ],
  "temperature": 1.0,
  "top_p": 0.95,
  "max_tokens": 512
}'

W tym poleceniu używamy lokalnego endpointu /v1/chat/completions, który jest zgodny z API OpenAI. Prompt prosi model o wyjaśnienie, dlaczego QAT jest przydatne, a max_tokens ustawiliśmy na 512, aby oba warianty modelu były testowane przy tej samej długości odpowiedzi. 

W naszym teście na RTX 4090 model bez QAT osiągnął następujące czasy:

• Tokeny promptu: 40
• Tokeny odpowiedzi: 512
• Szybkość przetwarzania promptu: 510,22 tokena/s
• Szybkość generacji: 94,65 tokena/s
• Łączny czas: 5,516 s

Zużycie pamięci GPU wyniosło:

9247 MiB / 24564 MiB

To daje nam punkt odniesienia dla zwykłego modelu Gemma 4 12B. W kolejnym kroku uruchomimy wersję QAT z tą samą konfiguracją i porównamy wyniki.

Krok 4: Uruchom i przetestuj model QAT

Teraz uruchomimy wersję QAT Gemma 4 12B z tymi samymi ustawieniami llama-server. Upewnij się, że zatrzymałeś poprzedni serwer bez QAT, zanim wystartujesz ten, ponieważ oba polecenia używają tego samego portu.

Uruchom model QAT.

./llama.cpp/llama-server \
  -m models/gemma-4-12B-it-qat-GGUF/*UD-Q4_K_XL*.gguf \
  --host 0.0.0.0 \
  --port 8001 \
  --ctx-size 8192 \
  --n-gpu-layers 99 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

To uruchamia model QAT pod tym samym lokalnym, zgodnym z OpenAI endpointem: http://localhost:8001.

Wyślij teraz ten sam testowy prompt do modelu QAT.

time curl http://localhost:8001/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "model": "gemma-4-12B-it-qat",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful local AI assistant."
    },
    {
      "role": "user",
      "content": "Explain why quantization-aware training is useful for running LLMs on consumer GPUs."
    }
  ],
  "temperature": 1.0,
  "top_p": 0.95,
  "max_tokens": 512
}'

W naszym teście na RTX 4090 model QAT osiągnął następujące czasy:

1. Tokeny promptu: 40
2. Tokeny odpowiedzi: 512
3. Szybkość przetwarzania promptu: 593,93 tokena/s
4. Szybkość generacji: 101,65 tokena/s
5. Łączny czas: 5,114 s

Zużycie pamięci GPU wyniosło:

8627 MiB / 24564 MiB

Możesz też skopiować adres lokalnego serwera (http://localhost:8001) i wkleić go w przeglądarce:

Otworzy się wbudowany interfejs webowy llama.cpp, który daje prosty, podobny do ChatGPT interfejs do testowania lokalnego modelu. Możesz w nim rozmawiać z modelem QAT bezpośrednio w przeglądarce, eksperymentować z promptami i używać modelu jako codziennego lokalnego asystenta AI. 

Porównanie QAT vs bez QAT

Po przetestowaniu obu modeli tym samym promptem i ustawieniami serwera możemy bezpośrednio porównać ich działanie na RTX 4090.

W tej próbie model QAT był zarówno szybszy, jak i lżejszy niż zwykły model bez QAT. Zużył 620 MiB mniej VRAM-u, redukując użycie pamięci o około 6,7%. To istotne dla lokalnej inferencji, bo każdy zaoszczędzony megabajt VRAM-u pomaga przy uruchamianiu dużych modeli na konsumenckich GPU.

Model QAT generował też tokeny szybciej — wzrost z 94,65 tokena/s do 101,65 tokena/s. To około 7,4% wzrostu szybkości generacji i skrócenie czasu ściennego z 5,516 s do 5,114 s.

W codziennym użyciu model QAT działał płynniej i szybciej reagował. Jakość odpowiedzi też wydawała się stabilniejsza w tym teście, co jest głównym powodem, dla którego QAT jest przydatne: pomaga modelowi radzić sobie z niskobitową kwantyzacją przy mniejszej utracie jakości, zachowując jednocześnie korzyści pamięciowe i szybkościowe skompresowanego modelu.

Na koniec

Google wykonuje świetną pracę dla społeczności lokalnego AI. Dzięki modelom takim jak Gemma 4 i technikom takim jak QAT, wizja uruchamiania potężnych modeli AI lokalnie, całkowicie offline, i to nawet na sprzęcie konsumenckim, staje się rzeczywistością. 

Najbardziej ekscytujące jest to, że nie chodzi tylko o zmniejszanie rozmiaru modeli. Dzięki QAT nie idziemy na kompromis z jakością tylko po to, by model się zmieścił. Dostajemy modele zaprojektowane tak, by lepiej działały w formatach niskobitowych, co poprawia ogólne doświadczenie lokalnego AI. W tym teście model QAT był szybszy, lżejszy i przyjemniejszy w użyciu niż wersja bez QAT.

Nie mogę się doczekać testów wersji MTP modelu, która może jeszcze bardziej zwiększyć szybkość, być może nawet dwukrotnie. To znacznie ułatwiłoby przeniesienie większej części mojego workflow do lokalnego AI. Mógłbym uruchamiać model lokalnie, połączyć go z narzędziami takimi jak OpenCode i zacząć edytować pliki projektów bezpośrednio z pomocą prywatnego, lokalnego asystenta.

Ta nowa fala lokalnego AI zmienia sposób myślenia o używaniu systemów AI. Zadania, które kiedyś wymagały rozbudowanych środowisk chmurowych — zwłaszcza multimodalne przepływy z tekstem, obrazem i wideo — powoli stają się możliwe na lokalnych maszynach. Dla deweloperów, badaczy i twórców, którym zależy na prywatności, szybkości i kontroli, to bardzo ekscytujący kierunek.