Quantization-verlies gemeten: AWQ versus GGUF en EXL2

Het comprimeren van open-weight taalmodellen van 16-bit floating-point representaties naar lagere precisies zoals 4-bit, 3-bit of zelfs 2-bit integers vormt het fundament van self-hosted inferentie. Zonder precisiereductie past een modern open model met tientallen miljarden parameters simpelweg niet in het videogeheugen van betaalbare grafische kaarten of compacte servers. Post-training kwantisatie is echter nooit gratis. Het verkleinen van het aantal bits per gewicht introduceert afrondingsruis, vervormt aandachtsvectoren en kan in het slechtste geval leiden tot subtiele redeneerfouten, syntaxfouten in code-uitvoer of hardnekkige hallucinaties in geautomatiseerde pipelines.

In dit signaalrapport vergelijken we de drie dominante quantisatie-architecturen die ontwikkelaars inzetten op eigen hardware: Activation-aware Weight Quantization (AWQ), GPT-Generated Unified Format (GGUF) binnen het llama.cpp-ecosysteem, en ExLlamaV2 (EXL2). Voor wie eerst de theoretische grondbeginselen van numerieke precisie en afrondingsfouten wil verkennen, biedt de uitlegpagina kwantisatie uitgelegd een helder vertrekpunt over het omzetten van continue tensors naar discrete gehele getallen. We richten ons hier specifiek op de wiskundige mechanismen achter kwaliteitsdegradatie, de verschillen in geheugenarchitectuur en de praktische afwegingen bij het selecteren van het juiste runtime-formaat.

De meetmethodiek: Perplexity versus taakspecifieke downstream evaluatie

Om te bepalen hoeveel modelkwaliteit verloren gaat tijdens het kwantisatieproces, hanteren evaluatietools in de praktijk twee complementaire invalshoeken: probabilistische perplexity-metingen op gestandaardiseerde corpora en deterministische evaluaties op specifieke taken. Perplexity berekent de cross-entropy loss over een ongeziene tekstreeks, zoals WikiText-2 of C4. Het getal geeft aan in welke mate het gecomprimeerde model nog in staat is om de natuurlijke kansverdeling van opeenvolgende tokens accuraat te voorspellen. Een stijging in de perplexity-score ten opzichte van het ongecomprimeerde FP16- of BF16-basismodel fungeert als een betrouwbare eerste indicatie van algemeen taalgevoelsverlies.

Perplexity alleen is echter een onvolledige graadmeter. Een model kan een nagenoeg identieke perplexity-score behouden op vloeiend proza, maar tegelijkertijd structureel falen wanneer een taak strikte deterministische afhankelijkheden vereist. Daarom worden gequantiseerde artefacten parallel getoetst op downstream benchmarks zoals meervoudige wiskundige afleidingen, programmacode-generatie en feitelijke vraagstukken. Bij dergelijke logische taken blijkt dat compressieruis zich niet gelijkmatig over alle netwerklagen manifesteert; met name de diepere MLP-lagen (multi-layer perceptrons) en aandachtsmechanismen vertonen bij te agressieve reductie een plotselinge terugval in abstract deductievermogen.

Het structureel inrichten van evaluaties vereist bovendien een constante vergelijking tussen de operationele kosten en de geleverde nauwkeurigheid; wie die balans dieper wil analyseren kan de methodologie in kwaliteit versus kosten raadplegen om te zien hoe evaluatietests worden opgebouwd. Een zuivere vergelijking vereist altijd dat het gecomprimeerde model draait met een temperatuur van nul, vaste prompt-templates en een identieke contextbuffer, zodat niet-deterministische sampling de vergelijkingsdata niet vertroebelt.

Het wiskundige degradatiemechanisme bij precisiereductie

Wanneer de gewichtenmatrix van een neuraal netwerk wordt teruggebracht van 16 bits naar bijvoorbeeld 4 bits, wordt het continue waardenbereik verdeeld over slechts 16 discrete niveaus. Bij een naïeve uniforme afronding leidt dit onvermijdelijk tot een aanzienlijke kwantisatiefout. In transformer-architecturen is deze fout niet willekeurig verdeeld. Onderzoek toont aan dat de activatievectoren tijdens de voorwaartse doorgang (forward pass) extreme uitschieters bevatten: een fractie van de hidden dimensions vertoont activatiewaarden die een veelvoud zijn van de gemiddelde magnitude.

Wanneer deze extreme activaties vermenigvuldigd worden met gewichten die door afronding zelfs maar licht vervormd zijn, explodeert de absolute afwijking aan de uitgang van de lineaire laag. Dit sneeuwbaleffect verstoort de zogeheten LayerNorm-stabiliteit en plant zich voort door opeenvolgende transformer-blokken. Het kwaliteitsverlies bij lage bitdieptes wordt daardoor primair veroorzaakt door het onvermogen om deze activatie-uitschieters foutloos te representeren. De drie formaten lossen dit wiskundige probleem elk op een fundamenteel andere wijze op.

AWQ: Bescherming van saillante gewichten via activatieschaling

Activation-aware Weight Quantization kiest voor een elegante wiskundige omweg om matrixfouten te minimaliseren. In plaats van alle gewichten gelijk te behandelen of een klein percentage in het dure FP16-formaat te bewaren (wat de parallelle rekensnelheid op GPU's zwaar belemmert), analyseert AWQ de activatiestatistieken via een kleine kalibratieset. Hieruit blijkt dat gewichten die corresponderen met kanalen met grote activaties — de zogeheten saillante gewichten — cruciaal zijn voor het behoud van de modelfunctionaliteit.

AWQ berekent per kanaal een optimale schaalfactor waarmee de saillante gewichten worden vermenigvuldigd, terwijl de bijbehorende inputs invers worden geschaald. Omdat de vermenigvuldiging wiskundig neutraal blijft voor de uiteindelijke uitkomst, wordt de relatieve afrondingsfout op de belangrijkste kanalen drastisch verkleind wanneer de matrix vervolgens uniform naar INT4 wordt afgerond. Alle gewichten blijven hierdoor netjes 4-bit integers, wat hardwarematige uitlijning met NVIDIA Tensor Cores optimaal intact laat.

Het praktische resultaat is dat AWQ bij 4-bit inferentie een uitzonderlijk hoge stabiliteit levert zonder dat er sprake is van snelheidsverlies door gemengde instructiesets. Het nadeel van deze benadering is het gebrek aan granulariteit. AWQ biedt geen flexibele tussenstappen tussen 4-bit en 8-bit, waardoor beheerders gebonden zijn aan vaste VRAM-sprongen. Wie zelf modellen wil converteren en verschillende formaten wil testen, kan de praktische handleiding in quantisatie in de praktijk: zelf een model comprimeren gebruiken om kalibratiesets correct toe te passen.

GGUF: Bloksgewijze kwantisatie en modulaire layer-offloading

GGUF is ontworpen als het universele containerformaat voor llama.cpp en legt de nadruk op heterogene hardware-inzetbaarheid. In plaats van te vertrouwen op uniforme matrixcompressie, introduceerde GGUF het concept van k-quants (zoals Q4_K_M, Q5_K_S of Q3_K_L). Binnen een k-quant worden gewichten opgedeeld in kleine super-blokken van bijvoorbeeld 256 gewichten, die op hun beurt weer zijn onderverdeeld in sub-blokken met eigen schaalfactoren en offsets.

Het grote voordeel van deze bloksgewijze opzet is de mogelijkheid tot 'mixed-precision quantization' binnen hetzelfde modelbestand. Bij een configuratie zoals Q4_K_M worden de aandachtslagen (attention layers) en gate-tensoren — die uiterst gevoelig zijn voor kwantisatieruis — opgeslagen in 5-bit of 6-bit precisie, terwijl minder kritieke feed-forward lagen naar 4-bit worden teruggebracht. Hierdoor wordt de totale geheugenvoetafdruk beperkt, terwijl de kwetsbare knooppunten in het netwerk beschermd blijven tegen degradatie.

GGUF blinkt daarnaast uit in geheugenfrequentiebeheer via layer-offloading. Wanneer een model niet volledig in het videogeheugen van de GPU past, kunnen lagen naadloos worden verdeeld tussen VRAM en regulier systeem-RAM. In eerdere overzichten over lokale hardware zagen we hoe deze flexibiliteit de standaard werd voor lokale ontwikkelaars; zie de analyse in lokale LLM's en Ollama: signalen van juli 2026 over het efficiënt combineren van gedeeld geheugen op compacte werkstations. De prijs voor deze flexibiliteit is de doorvoersnelheid: zodra lagen over de PCI-express-bus naar de CPU worden verplaatst, zakt de verwerkingssnelheid naar de bandbreedte van het systeemgeheugen.

EXL2: Traploze bitrates en tweede-orde foutcorrectie

ExLlamaV2 hanteert een fundamenteel andere filosofie die specifiek gericht is op pure GPU-acceleratie. Waar GGUF werkt met discrete stappen (3-bit, 4-bit, 5-bit), introduceert EXL2 een traploze bitrate-architectuur. Een beheerder kan een gewichtsmatrix kwantiseren naar exact 4.25, 3.85 of 5.12 bits per gewicht (bpw). Hierdoor kan een model exact worden afgestemd op de fysieke VRAM-capaciteit van een specifieke grafische kaart (zoals 16 GB, 24 GB of 48 GB) zonder dat er kostbaar geheugen onbenut blijft.

Wiskundig leunt EXL2 op een geavanceerde variant van tweede-orde foutoptimalisatie. Tijdens de compressie berekent het algoritme de inverse Hessiaan-matrix van de reconstructiefout over een kalibratiecorpus. Wanneer een gewicht wordt afgerond naar een discrete bitwaarde, worden de overige, nog niet gequantiseerde gewichten in dezelfde laag direct numeriek bijgestuurd om de totale afwijking aan de matrixuitgang te compenseren. Bovendien wijst EXL2 automatisch verschillende bitdieptes toe aan individuele matrices op basis van een gemeten gevoeligheidsanalyse: projecties met een hoge impact op de coherentie krijgen een hogere precisie (bijv. 6-bit), terwijl brede tussenlagen zwaarder worden gecomprimeerd (bijv. 3-bit).

Voor homelab-omgevingen waar modelservers draaien onder gevirtualiseerde hypervisors biedt EXL2 een ongeëvenaarde doorvoersnelheid per stream. Wie een dergelijke hostomgeving met GPU-toewijzing bouwt, vindt in het stappenplan GPU-passthrough op Proxmox voor lokale modelservers de configuraties om hardwarematige PCIe-toegang in te richten voor ExLlamaV2 en vLLM containers.

Modelomvang als bepalende factor: Het schaalverschil tussen 8B en 70B

Een cruciale wetmatigheid in kwantisatie-architectuur is dat de gevoeligheid voor precisiereductie omgekeerd evenredig is met de omvang van het model. Grote taalmodellen met 70 miljard parameters of meer bezitten een hoge interne parameter-redundantie. De kennis en logische patronen liggen verspreid over duizenden brede aandachts- en projectielagen, waardoor het verlies van individuele numerieke precisie relatief eenvoudig door het omliggende netwerk wordt geabsorbeerd.

Bij compacte modellen van 7 miljard tot 9 miljard parameters is die redundantie daarentegen minimaal. Elke gewichtsmatrix bevat een compacte representatie van vaardigheden, waardoor afrondingsfouten direct meetbare gevolgen hebben. Waar een 70B model bij een agressieve 4-bit quantisatie nagenoeg zijn volledige redeneercapaciteit op MMLU of GSM8K behoudt, vertoont een 8B model op hetzelfde bitlevel al een duidelijke kwetsbaarheid bij complexe logische prompts of meertalige vertalingen.

Hieronder staat een kwalitatieve vergelijking van het verwachte gedrag en de degradatierisico's over verschillende schaalniveaus en compressielagen:

VRAM-allocatie, KV-cache kwantisatie en inferentiesnelheid

Bij het dimensioneren van een lokale inferentiestack is het statische gewichtsgeheugen slechts één onderdeel van de vergelijking. Het totale VRAM-beslag wordt bepaald door de som van drie factoren: de geladen modelgewichten, de contextuele KV-cache (Key-Value cache) en de dynamische runtime-overhead van de CUDA-kernels. Met name bij lange contextvensters kan de KV-cache het gewichtsgeheugen in omvang overstijgen.

# Starten van een vLLM server met AWQ en FP8 KV-cache optimalisatie
vllm serve meta-llama/Meta-Llama-3-70B-Instruct \
  --quantization awq \
  --kv-cache-dtype fp8 \
  --gpu-memory-utilization 0.90 \
  --max-model-len 16384 \
  --tensor-parallel-size 2

In productiescenario's met hoge gelijktijdigheid schaalt AWQ onder engines zoals vLLM superieur dankzij PagedAttention. Het geheugen voor contexttokens wordt gefragmenteerd beheerd in virtuele pagina's, waardoor geheugenverspilling door reserveringen vooraf wordt geëlimineerd. In combinatie met FP8-kwantisatie van de KV-cache kunnen servers tientallen gelijktijdige gebruikers bedienen zonder geheugentekorten. Dit sluit aan bij bredere strategieën voor efficiënt tokenbeheer; zie de methodes in token-besparing: bewezen trucs uit de community waarin contextcompressie en cacheoptimalisatie centraal staan.

ExLlamaV2 richt zich primair op de single-stream latentie en biedt native 4-bit (INT4) en 8-bit (FP8) KV-cache compressie direct binnen de kernel. Hierdoor kan een lokale bouwer op een enkele videokaart een context van 32.000 tokens laden, waar een ongecomprimeerde FP16-cache direct tot geheugenfouten zou leiden. GGUF biedt via llama.cpp eveneens opties voor -ctk q8_0 en -ctv q4_0 voor het comprimeren van de contextcache, wat met name op Apple Silicon Unified Memory aanzienlijke schaalvoordelen oplevert.

Beslisboom voor modelbouwers en infrastructurele keuzes

Om te bepalen welke quantisatie-architectuur optimaal aansluit bij een specifieke homelab- of serveropstelling, hanteren we drie duidelijke infrastructurele criteria:

1. Kies voor AWQ bij gecentraliseerde inferentie-servers: Draait de infrastructuur op vLLM, SGLang of TensorRT-LLM met als doel het ontsluiten van een API voor meerdere gelijktijdige gebruikers of agents? AWQ biedt gestandaardiseerde INT4-gewichten die naadloos samenwerken met enterprise-schedulers en geavanceerde paged-caching architecturen.

2. Kies voor EXL2 bij interactieve single-user pipelines op NVIDIA-hardware: Draait het model lokaal op één of meerdere NVIDIA RTX-videokaarten voor interactief gebruik, snelle coding-assistentie of lokale agent-loops waarbij minimale wachttijd per token doorslaggevend is? EXL2 haalt de hoogste generatiesnelheid en stelt beheerders in staat om via fractionele bitrates het model tot op de laatste megabyte exact in het beschikbare VRAM te passen.

3. Kies voor GGUF bij platformonafhankelijkheid en heterogeen geheugen: Moet het model functioneren op macOS (Apple Silicon M-chips), CPU-gebaseerde servers, compacte minicomputers of systemen waarbij layer-offloading naar systeem-RAM onvermijdelijk is? GGUF via llama.cpp biedt de breedste ondersteuning en de meest fijnmazige controle over hybride geheugentoewijzing.

Deze infrastructurele afweging vormt een integraal onderdeel van private hostingstrategieën; zie ook het bredere overzicht in homelab en self-hosted AI: signalen van juli 2026 over hardwarekeuzes en energie-efficiëntie bij lokale modelservers.

Conclusie en implementatierichtlijnen

Post-training kwantisatie is geëvolueerd van een eenvoudige afrondingsoperatie naar een geavanceerd vakgebied van foutcompensatie en activatieschaling. De technische mechanismen achter AWQ, GGUF en EXL2 tonen aan dat het comprimeren van foundation models naar 4 bits per gewicht een volwassen standaard is geworden, mits de modelomvang voldoende groot is om de afrondingsruis te absorberen.

Voor compacte modellen blijft terughoudendheid geboden: het verlies aan structurele precisie bij sub-4-bit compressie vertaalt zich direct in hogere foutpercentages bij logische taken en code-generatie. Door het quantisatie-formaat af te stemmen op de specifieke runtime-omgeving en de hardwarecapaciteit — AWQ voor multi-user throughput, EXL2 voor dedicated GPU-snelheid, en GGUF voor flexibele cross-platform inzetbaarheid — bouwen ontwikkelaars een lokaal AI-fundament dat zowel qua rekenkracht als qua outputkwaliteit optimaal presteert.