Quantization Aware Training: Een gids om de lokale inferentie van Gemma 4 te verbeteren

Wat is quantization?

Quantization is een modelcompressietechniek die de precisie van modelgewichten verlaagt. 

Grote taalmodellen worden meestal opgeslagen in hoogprecisieformaten zoals BF16 of FP16, die de kwaliteit behouden maar veel geheugen vereisen. Quantization zet die gewichten om naar formaten met minder bits, zoals 8-bit of 4-bit, zodat het model minder VRAM gebruikt en makkelijker lokaal draait. Hugging Face merkt op dat 8-bit quantization het geheugenverbruik grofweg kan halveren, terwijl 4-bit het nog verder kan verminderen.

De keerzijde is dat lagere precisie soms de uitvoerkwaliteit kan verminderen, vooral als het model niet is geoptimaliseerd voor quantization. Simpel gezegd: BF16 en FP16 leveren meestal de beste kwaliteit maar gebruiken meer geheugen; 8-bit modellen zijn kleiner en behouden vaak sterke kwaliteit, en 4-bit modellen zijn veel kleiner maar kunnen wat nauwkeurigheid of stabiliteit verliezen. 

Voor lokale inferentie is deze trade-off vaak de moeite waard omdat het grotere modellen op consument-GPU’s mogelijk maakt, in plaats van dure datacenterhardware te vereisen.

Wat is Quantization Aware Training?

Quantization-Aware Training (QAT) is een trainingstechniek waarbij het model wordt getraind of fijngesteld terwijl laagprecisiegedrag wordt gesimuleerd. Dit helpt het model stabieler te blijven na quantization en kan de lokale inferentieprestaties verbeteren bij lage bitbreedtes.

Wat maakt QAT anders?

De gebruikelijke aanpak, post-training quantization, comprimeert een model nadat het al is getraind. Dit is eenvoudig en praktisch, maar het model kan wat kwaliteit verliezen omdat het niet is getraind om met laagprecisiegewichten om te gaan. 

Volgens de Google AI Edge-documentatie is post-training quantization een conversiestap die de modelgrootte kan verkleinen en de latentie kan verbeteren, meestal met weinig nauwkeurigheidsverlies. Toch kan de uiteindelijke kwaliteit afhangen van het model en het quantization-niveau. 

Quantization-Aware Training, of QAT, neemt een andere benadering. In plaats van pas na de training te quantizen, simuleert QAT laagprecisiegedrag tijdens training of fine-tuning. Dit helpt het model te leren hoe het stabiel blijft wanneer het later naar een kleiner formaat wordt geconverteerd. Zo wordt het kwaliteitsverlies bij compressie geminimaliseerd.

Daarom is Gemma 4 QAT nuttig voor lokale AI. Het is gebouwd met quantization in gedachten, zodat het meer van de oorspronkelijke modelkwaliteit behoudt terwijl het minder geheugen gebruikt. Voor gebruikers die modellen op consument-GPU’s draaien kan dit betekenen: betere low-bit stabiliteit, lager VRAM-gebruik en een praktischer lokale inferentie.

Stap 1: Installeer dependencies en bouw llama.cpp

Voordat we de modellen downloaden, moeten we eerst de lokale runtime voorbereiden. Deze tutorial is getest op een machine met een NVIDIA RTX 4090 GPU en 24 GB VRAM. We gebruiken llama.cpp als de inferentieruntime, GGUF als modelformaat en de UD-Q4_K_XL gequantiseerde modelbestanden.

Geteste setup:

• GPU: NVIDIA RTX 4090
• VRAM: 24 GB
• Runtime: llama.cpp
• Modelformaat: GGUF
• Quantization: UD-Q4_K_XL

We vergelijken de volgende twee Unsloth GGUF-modellen:

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

Controleer eerst of je GPU beschikbaar is.

nvidia-smi

Installeer vervolgens de systeempakketten die nodig zijn om llama.cpp te bouwen.

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

Kloon de officiële llama.cpp-repository.

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

Bouw nu llama.cpp met CUDA-ondersteuning ingeschakeld. Dit zorgt ervoor dat de modellagen op de GPU draaien in plaats van alleen op de CPU.

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

Compileer de vereiste binaries.

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

Na het bouwen is de belangrijkste binary die we gebruiken llama-server. Daarmee draaien we het GGUF-model lokaal en stellen we een OpenAI-compatibele API-endpoint bloot dat we met curl kunnen bevragen. 

Stap 2: Download de Gemma 4 12B Non-QAT- en QAT-modellen 

Nu llama.cpp klaar is, kunnen we beide Gemma 4 12B-modelvarianten van Hugging Face downloaden. We downloaden het reguliere instruction-tuned model en de QAT-versie in GGUF-formaat.

Installeer eerst de Hugging Face Hub CLI met ondersteuning voor snellere downloads.

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

Schakel high-performance Xet-downloads in.

export HF_XET_HIGH_PERFORMANCE=1

Download het reguliere Gemma 4 12B-instructiemodel in GGUF-formaat.

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

Download vervolgens de QAT-versie met hetzelfde quantization-formaat.

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*"

De --include vlaggen zorgen ervoor dat we alleen de bestanden downloaden die we voor deze tutorial nodig hebben, in plaats van de hele repository op te halen. Hier downloaden we de UD-Q4_K_XL GGUF-modelbestanden en de mmproj-BF16 bestanden die door het modelpakket worden gebruikt. 

Controleer na het downloaden of beide modelfolders bestaan.

ls models

Verwachte output:

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

Op dit punt zijn zowel het non-QAT- als het QAT-model lokaal beschikbaar en kunnen we ze gaan serveren met llama-server.

Stap 3: Draai het non-QAT-model met llama-server

We beginnen met het reguliere Gemma 4 12B-instructiemodel. Dit geeft ons een baseline zodat we het later met de QAT-versie kunnen vergelijken met dezelfde instellingen.

Start het non-QAT-model met 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

Dit start een lokale OpenAI-compatibele server op http://localhost:8001.

Open een andere terminal en stuur een request naar de lokale server.

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
}'

In dit commando gebruiken we het lokale /v1/chat/completions endpoint, dat het OpenAI-compatibele API-formaat volgt. De prompt vraagt het model om quantization-aware training uit te leggen, en max_tokens staat op 512 om ervoor te zorgen dat beide modelvarianten met dezelfde outputlengte worden getest. 

In onze RTX 4090-test leverde het non-QAT-model de volgende timingresultaten op:

• Prompt tokens: 40
• Completion tokens: 512
• Prompt-snelheid: 510,22 tokens/sec
• Generatiesnelheid: 94,65 tokens/sec
• Totale tijd: 5,516 sec

Het GPU-geheugengebruik was:

9247 MiB / 24564 MiB

Dit geeft ons de basisprestaties voor het reguliere Gemma 4 12B-model. In de volgende stap draaien we de QAT-versie met dezelfde configuratie en vergelijken we de resultaten.

Stap 4: Draai en test het QAT-model

Nu draaien we de QAT-versie van Gemma 4 12B met dezelfde llama-server instellingen. Zorg dat je de vorige non-QAT-server stopt voordat je deze start, omdat beide commando’s dezelfde poort gebruiken.

Start het QAT-model.

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

Dit start het QAT-model op hetzelfde lokale OpenAI-compatibele endpoint, http://localhost:8001.

Stuur nu dezelfde testprompt naar het QAT-model.

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
}'

In onze RTX 4090-test leverde het QAT-model de volgende timingresultaten op:

1. Prompt tokens: 40
2. Completion tokens: 512
3. Prompt-snelheid: 593,93 tokens/sec
4. Generatiesnelheid: 101,65 tokens/sec
5. Totale tijd: 5,114 sec

Het GPU-geheugengebruik was:

8627 MiB / 24564 MiB

Je kunt ook de lokale server-URL (http://localhost:8001) kopiëren en in je browser plakken:

Dit opent de ingebouwde llama.cpp web-UI, die je een eenvoudige ChatGPT-achtige interface geeft om het lokale model te testen. Je kunt er rechtstreeks in de browser mee chatten met het QAT-model, experimenteren met prompts en het model gebruiken als dagelijkse lokale AI-assistent. 

Vergelijk QAT vs non-QAT-resultaten

Na het testen van beide modellen met dezelfde prompt en serverinstellingen kunnen we hun prestaties op de RTX 4090 direct vergelijken.

In deze run was het QAT-model zowel sneller als lichter dan het reguliere non-QAT-model. Het gebruikte 620 MiB minder VRAM, wat het geheugenverbruik met ongeveer 6,7% verlaagde. Dat is nuttig voor lokale inferentie, omdat elke bespaarde MiB helpt bij het draaien van grote modellen op consument-GPU’s.

Het QAT-model genereerde ook sneller tokens, met een verbetering van 94,65 tokens/sec naar 101,65 tokens/sec. Dat is ongeveer een 7,4% toename in generatiesnelheid, waardoor de kloktijd daalde van 5,516 seconden naar 5,114 seconden.

In het dagelijks gebruik voelde het QAT-model soepeler en responsiever. De responskwaliteit leek in deze test ook stabieler, en dat is precies waarom QAT nuttig is: het helpt het model low-bit quantization beter aan te kunnen met minder kwaliteitsverlies, terwijl je toch de geheugen- en snelheidsvoordelen van een gecomprimeerd model behoudt.

Tot slot

Google levert fantastisch werk voor de lokale AI-community. Met modellen zoals Gemma 4 en technieken zoals QAT komt de droom om krachtige AI-modellen lokaal, volledig offline en zelfs op consumentenhardware te draaien steeds dichterbij. 

Het meest opwindende is dat het niet alleen gaat om het verkleinen van modellen. Met QAT leveren we niet simpelweg kwaliteit in om het model te laten passen. We krijgen modellen die ontworpen zijn om beter te draaien in low-bit formaten, wat de totale lokale AI-ervaring verbetert. In deze test was het QAT-model sneller, lichter en prettiger in gebruik dan de non-QAT-versie.

Ik kijk ernaar uit om de MTP-versie van het model te testen, die de snelheid mogelijk nog verder kan verhogen, misschien wel met 2x. Dat zou het veel gemakkelijker maken om meer van mijn workflow naar lokale AI te verplaatsen. Ik zou het model lokaal kunnen draaien, het koppelen aan tools zoals OpenCode en direct projectbestanden bewerken met een private lokale assistent.

Deze nieuwe golf van lokale AI verandert hoe we denken over het gebruik van AI-systemen. Taken die vroeger grote cloudopstellingen vereisten, vooral multimodale workflows met tekst-, beeld- en video-inputs, worden langzaam mogelijk op lokale machines. Voor developers, onderzoekers en makers die om privacy, snelheid en controle geven, is dit een heel spannende richting.