Quantization Aware Training: En guide till att förbättra Gemma 4:s lokala inferens

Vad är kvantisering?

Kvantisering är en modellkomprimeringsteknik som minskar precisionen på modellvikter. 

Stora språkmodeller lagras vanligtvis i högprecisionsformat som BF16 eller FP16, vilket bevarar kvaliteten men kräver mycket minne. Kvantisering konverterar dessa vikter till format med färre bitar, såsom 8-bit eller 4-bit, så att modellen använder mindre VRAM och enklare kan köras lokalt. Hugging Face noterar att 8-bitars kvantisering i grova drag kan halvera minnesanvändningen, medan 4-bitars kvantisering kan minska den ännu mer.

Kompromissen är att lägre precision ibland kan försämra utdata­kvaliteten, särskilt om modellen inte har optimerats för kvantisering. Enkelt uttryckt ger BF16 och FP16 oftast bäst kvalitet men använder mer minne; 8-bitarsmodeller är mindre och brukar behålla god kvalitet, och 4-bitarsmodeller är mycket mindre men kan tappa viss noggrannhet eller stabilitet. 

För lokal inferens är denna avvägning ofta värd det eftersom den gör att större modeller kan köras på konsument-GPU:er i stället för att kräva dyr datacenterhårdvara.

Vad är Quantization Aware Training?

Quantization-Aware Training (QAT) är en träningsteknik där modellen tränas eller fintrimmats samtidigt som lågprecisionsbeteende simuleras. Detta hjälper modellen att förbli mer stabil efter kvantisering och kan förbättra lokal inferensprestanda vid låga bitbredder.

Vad skiljer QAT?

Det vanliga tillvägagångssättet, efterträningskvantisering (post-training quantization), komprimerar en modell efter att den redan har tränats. Detta är enkelt och praktiskt, men modellen kan tappa viss kvalitet eftersom den inte tränades för att hantera lågprecisionsvikter. 

Enligt Google AI Edge-dokumentation är efterträningskvantisering ett konverteringssteg som kan minska modellstorlek och förbättra latens, vanligtvis med liten noggrannhetsförlust. Den slutliga kvaliteten kan dock fortfarande bero på modellen och kvantiseringsnivån. 

Quantization-Aware Training, eller QAT, tar en annan väg. I stället för att bara kvantisera efter träning simulerar QAT lågprecisionsbeteende under träning eller fintrimning. Detta hjälper modellen att lära sig att förbli stabil när den senare konverteras till ett mindre format. Det minimerar kvalitetsförlusten när modellen komprimeras.

Det är därför Gemma 4 QAT är användbart för lokal AI. Det är byggt med kvantisering i åtanke, så det kan behålla mer av originalmodellens kvalitet samtidigt som det använder mindre minne. För användare som kör modeller på konsument-GPU:er kan detta innebära bättre stabilitet i lågbitsläge, lägre VRAM-användning och mer praktisk lokal inferens.

Steg 1: Installera beroenden och bygg llama.cpp

Innan vi laddar ned modellerna behöver vi först förbereda den lokala körtiden. Den här handledningen testades på en maskin med ett NVIDIA RTX 4090-GPU och 24 GB VRAM. Vi kommer att använda llama.cpp som inferenskörning, GGUF som modellformat och de UD-Q4_K_XL-kvantiserade modelfilerna.

Testad miljö:

• GPU: NVIDIA RTX 4090
• VRAM: 24 GB
• Körtid: llama.cpp
• Modellformat: GGUF
• Kvantisering: UD-Q4_K_XL

Vi kommer att jämföra följande två Unsloth GGUF-modeller:

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

Börja med att kontrollera att din GPU är tillgänglig.

nvidia-smi

Installera sedan systempaketen som krävs för att bygga llama.cpp.

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

Klona det officiella lagret för llama.cpp.

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

Bygg nu llama.cpp med CUDA-stöd aktiverat. Detta gör att modellagren kan köras på GPU i stället för enbart på CPU.

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

Kompilera de nödvändiga binärerna.

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

När bygget är klart är huvudbinären vi kommer att använda llama-server. Den låter oss köra GGUF-modellen lokalt och exponerar en OpenAI-kompatibel API‑endpoint som vi kan anropa med curl. 

Steg 2: Ladda ned Gemma 4 12B utan QAT och med QAT 

Nu när llama.cpp är redo kan vi ladda ned båda varianterna av Gemma 4 12B från Hugging Face. Vi laddar ned den vanliga instruktionstrimmade modellen och QAT-versionen i GGUF-format.

Installera först Hugging Face Hub CLI med stöd för snabbare nedladdning.

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

Aktivera högpresterande Xet-nedladdningar.

export HF_XET_HIGH_PERFORMANCE=1

Ladda ned den vanliga Gemma 4 12B-instruktionsmodellen i GGUF-format.

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

Ladda sedan ned QAT-versionen med samma kvantiseringsformat.

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

Flaggorna --include säkerställer att vi bara laddar ned filerna som behövs för den här handledningen i stället för att hämta hela lagret. Här laddar vi ned UD-Q4_K_XL-GGUF-modellfilerna och mmproj-BF16-filerna som används av modellpaketet. 

När nedladdningarna är klara, bekräfta att båda modellers mappar finns.

ls models

Förväntad utdata:

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

Vid det här laget finns både modellen utan QAT och QAT-modellen lokalt, och vi kan börja exponera dem med llama-server.

Steg 3: Kör modellen utan QAT med llama-server

Vi börjar med att köra den vanliga Gemma 4 12B-instruktionsmodellen. Detta ger oss en baslinje så att vi senare kan jämföra med QAT-versionen med samma inställningar.

Starta modellen utan QAT med 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

Detta startar en lokal OpenAI-kompatibel server på http://localhost:8001.

Öppna en annan terminal och skicka en begäran till den lokala servern.

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

I det här kommandot använder vi den lokala /v1/chat/completions-endpointen, som följer OpenAI‑kompatibelt API-format. Prompten ber modellen att förklara kvantiseringsmedveten träning, och max_tokens är satt till 512 för att säkerställa att båda modellvarianterna testas med samma utdata­längd. 

I vårt RTX 4090-test gav modellen utan QAT följande tidsresultat:

• Prompttokens: 40
• Kompletteringstokens: 512
• Promptfart: 510,22 tokens/sek
• Genereringsfart: 94,65 tokens/sek
• Total tid: 5,516 sek

GPU‑minnesanvändningen var:

9247 MiB / 24564 MiB

Detta ger oss baslinjeprestanda för den vanliga Gemma 4 12B-modellen. I nästa steg kör vi QAT-versionen med samma konfiguration och jämför resultaten.

Steg 4: Kör och testa QAT-modellen

Nu kör vi QAT-versionen av Gemma 4 12B med samma llama-server‑inställningar. Se till att stoppa den tidigare servern utan QAT innan du startar denna, eftersom båda kommandona använder samma port.

Starta QAT-modellen.

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

Detta startar QAT-modellen på samma lokala OpenAI‑kompatibla endpoint, http://localhost:8001.

Skicka nu samma testprompt till QAT-modellen.

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

I vårt RTX 4090-test gav QAT-modellen följande tidsresultat:

1. Prompttokens: 40
2. Kompletteringstokens: 512
3. Promptfart: 593,93 tokens/sek
4. Genereringsfart: 101,65 tokens/sek
5. Total tid: 5,114 sek

GPU‑minnesanvändningen var:

8627 MiB / 24564 MiB

Du kan också kopiera den lokala server‑URL:en (http://localhost:8001) och klistra in den i din webbläsare:

Detta öppnar den inbyggda llama.cpp-webbgränssnittet, som ger dig ett enkelt ChatGPT‑liknande gränssnitt för att testa den lokala modellen. Du kan använda det för att chatta med QAT‑modellen direkt i webbläsaren, experimentera med promptar och använda modellen som en daglig lokal AI‑assistent. 

Jämför resultat: QAT vs utan QAT

Efter att ha testat båda modellerna med samma prompt och serverinställningar kan vi direkt jämföra deras prestanda på RTX 4090.

I denna körning var QAT‑modellen både snabbare och lättare än den vanliga modellen utan QAT. Den använde 620 MiB mindre VRAM, vilket minskade minnesanvändningen med cirka 6,7 %. Detta är användbart för lokal inferens eftersom varje sparad VRAM‑megabyte hjälper när man kör stora modeller på konsument‑GPU:er.

QAT‑modellen genererade också tokens snabbare, en förbättring från 94,65 tokens/sek till 101,65 tokens/sek. Det är ungefär en 7,4 % ökning i genereringshastighet, vilket minskade väggklocktiden från 5,516 sekunder till 5,114 sekunder.

I vardagsanvändning kändes QAT‑modellen mjukare och mer responsiv. Svarskvaliteten verkade också stabilare i detta test, vilket är huvudskälet till att QAT är användbart: det hjälper modellen att hantera lågbitskvantisering med mindre kvalitetsförlust samtidigt som man behåller minnes‑ och hastighetsfördelarna hos en komprimerad modell.

Avslutande tankar

Google gör ett fantastiskt jobb för den lokala AI‑gemenskapen. Med modeller som Gemma 4 och tekniker som QAT blir drömmen om att köra kraftfulla AI‑modeller lokalt, helt offline och till och med på konsumenthårdvara, verklighet. 

Det mest spännande är att detta inte bara handlar om att minska modellstorlek. Med QAT kompromissar vi inte bara med kvaliteten för att få modellen att passa. Vi får modeller som är designade för att köras bättre i lågbitsformat, vilket förbättrar den lokala AI‑upplevelsen. I detta test var QAT‑modellen snabbare, lättare och smidigare att använda än versionen utan QAT.

Jag ser nu fram emot att testa MTP‑versionen av modellen, som skulle kunna öka hastigheten ytterligare, möjligen med 2x. Det skulle göra det mycket enklare att flytta mer av mitt arbetsflöde till lokal AI. Jag skulle kunna köra modellen lokalt, koppla den till verktyg som OpenCode och börja redigera projektfiler direkt med en privat lokal assistent.

Denna nya våg av lokal AI förändrar hur vi ser på att använda AI‑system. Uppgifter som tidigare krävde stora molnuppsättningar, särskilt multimodala arbetsflöden med text-, bild‑ och videoinmatningar, blir sakta möjliga på lokala maskiner. För utvecklare, forskare och byggare som värdesätter integritet, hastighet och kontroll är detta en mycket spännande utveckling.