# Quantization in productie: van 16-bit naar 4-bit precisie [Naar de inhoud](#lm-inhoud)Netwerk/NL[EN](/en/quantization-in-productie-van-16-bit-naar-4-bit-precisie)[Hubhub.llmnet.nlModellen vergelijken op taak, taal, kosten en licentie.](https://hub.llmnet.nl/)[Communitycommunity.llmnet.nlPrompttechnieken, patronen en systeemprompts.](https://community.llmnet.nl/)[APIapi.llmnet.nlLLM's robuust in software: rate limits, routing, structured output.](https://api.llmnet.nl/)[Consultancyconsultancy.llmnet.nlAI invoeren in een organisatie, van pilot tot productie.](https://consultancy.llmnet.nl/)[Nieuwsnieuws.llmnet.nlOntwikkelingen in AI, geduid voor Nederland.](https://nieuws.llmnet.nl/)[Benchmarkbenchmark.llmnet.nlZelf meten wat AI-kwaliteit is, voor jouw taken.](https://benchmark.llmnet.nl/)[Vacaturesvacatures.llmnet.nlAI-rollen, salarissen en carrièrepaden in Nederland.](https://vacatures.llmnet.nl/)[Lerenleren.llmnet.nlAI-concepten in gewoon Nederlands, van beginner tot bouwer.](https://leren.llmnet.nl/)[Gidsgids.llmnet.nlAI privé draaien op eigen Mac, pc, NAS of thuisserver.](https://gids.llmnet.nl/)[Directorydirectory.llmnet.nlHet AI-ecosysteem in kaart: tools, modellen, bedrijven.](https://directory.llmnet.nl/)[Radarradar.llmnet.nlSignalen uit X, onderzoek en communities voor indie developers.](https://radar.llmnet.nl/)[Appsapps.llmnet.nlReviews van AI-apps en open-source repo's, met tips voor wie zelf bouwt.](https://apps.llmnet.nl/)[llmnet.nl — hoofdsite](https://llmnet.nl/)[](https://x.com/intent/post?url=https%3A%2F%2Fnieuws.llmnet.nl%2Fquantization-in-productie-van-16-bit-naar-4-bit-precisie&text=Quantization%20in%20productie%3A%20van%2016-bit%20naar%204-bit%20precisie)[](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fnieuws.llmnet.nl%2Fquantization-in-productie-van-16-bit-naar-4-bit-precisie)[](https://www.reddit.com/submit?url=https%3A%2F%2Fnieuws.llmnet.nl%2Fquantization-in-productie-van-16-bit-naar-4-bit-precisie&title=Quantization%20in%20productie%3A%20van%2016-bit%20naar%204-bit%20precisie)[](#)[](https://x.com/intent/post?url=https%3A%2F%2Fnieuws.llmnet.nl%2Fquantization-in-productie-van-16-bit-naar-4-bit-precisie&text=Quantization%20in%20productie%3A%20van%2016-bit%20naar%204-bit%20precisie)[](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fnieuws.llmnet.nl%2Fquantization-in-productie-van-16-bit-naar-4-bit-precisie)[](https://www.reddit.com/submit?url=https%3A%2F%2Fnieuws.llmnet.nl%2Fquantization-in-productie-van-16-bit-naar-4-bit-precisie&title=Quantization%20in%20productie%3A%20van%2016-bit%20naar%204-bit%20precisie)[](#) # Quantization in productie: van 16-bit naar 4-bit precisie Door Ivo Donker — samengesteld met AI-ondersteuning (Claude & Gemini) In het canon-hoofdartikel over de verschuiving naar compacte architecturen, [de analyse over kleine taalmodellen en efficiënte inferentie](https://nieuws.llmnet.nl/kleine-taalmodellen), werd al duidelijk dat compactere parameters de exploitatiekosten van AI structureel verlagen. Waar modeldistillatie en pruning ingrijpen op de architectuur zelf, grijpt quantization direct in op de numerieke representatie van de gewichten en activaties. In moderne productielijnen is het draaien van onversneden 16-bit floating-point formaten (FP16 of BF16) voor grootschalige LLM-workloads economisch en operationeel zelden meer te verdedigen. Door gewichten terug te brengen naar 8-bit of 4-bit precisie halveert of verviervoudigt de dichtheid per grafische processor. Toch is het reduceren van numerieke precisie geen gratis optimalisatie. Naarmate we afdalen van 16-bit floating point naar 8-bit integers en vervolgens 4-bit quantisatiemethoden, ontstaat er een fundamenteel spanningsveld tussen geheugenbesparing, rekendoorvoer, wiskundige afrondingsfouten en taalspecifieke degradatie. Dit artikel fileert de exacte werking van moderne post-training quantisatietechnieken (PTQ), de interactie met hardware-architecturen, de implicaties voor de KV-cache, en de methodologieën die nodig zijn om kwaliteitsverlies in productieomgevingen meetbaar te beheersen. ## De wiskundige basis: lineaire transformaties en afrondingsruis Quantization transformeert een continue of hoog-precieze verzameling getallen naar een discrete, laag-precieze getallenruimte. In een standaard neuraal netwerk worden gewichten doorgaans opgeslagen in 16-bit floating point (IEEE 754 FP16 of Brain Floating Point BF16). Een FP16-waarde bestaat uit 1 tekenbit, 5 exponentbits en 10 mantissebits, waarmee een breed dynamisch bereik wordt afgedekt. Bij een uniforme affine kwantisatie naar bijvoorbeeld 8-bit integer (INT8) projecteren we dit dynamische bereik op een schaal van 256 gehele getallen (-128 tot 127 voor signed integers, of 0 tot 255 voor unsigned integers). De wiskundige standaardformule voor uniforme kwantisatie rust op twee cruciale parameters: een schaalfactor (scale, $S$) en een nulpuntcorrectie (zero-point, $Z$). De transformatie van een reëel gewicht $x$ naar een integerwaarde $q$ luidt: q = clip(round(x / S) + Z, q_min, q_max) Om de oorspronkelijke waarde tijdens matrixvermenigvuldigingen te benaderen (dekwantisatie), hanteren we de omgekeerde transformatie: x_approx = S * (q - Z) Wanneer het nulpunt $Z$ gelijk is aan nul, spreken we van symmetrische kwantisatie. Dit vereenvoudigt de hardwarematige vermenigvuldigingen aanzienlijk, omdat er geen extra optelterm verwerkt hoeft te worden tijdens het berekenen van tensordotproducten. Asymmetrische kwantisatie daarentegen gebruikt een dynamisch nulpunt ($Z \neq 0$), wat waardevol is wanneer gewichtsverdelingen scheefgetrokken zijn rondom nul, zoals vaak het geval is bij activaties na een ReLU- of GeLU-laag. Het verlies aan representatievermogen, ook wel de quantization noise of afrondingsruis genoemd, wordt bepaald door de afstand tussen opeenvolgende kwantisatiestappen ($\Delta = S$). Hoe minder bits beschikbaar zijn, hoe groter $\Delta$ wordt en hoe meer informatie verloren gaat in de fijnmazige staarten van de gewichtsdistributie. ## Gewichtsverdelingen en de uitdaging van 'outlier features' Bij taalmodellen tot 7 miljard parameters vertonen de gewichtsmatrices meestal een min of meer voorspelbare Gaussische klokvormige verdeling. Zodra modellen echter groter worden (met name voorbij de 6,7B- en 13B-grenzen), treedt er een opmerkelijk emergent fenomeen op: het ontstaan van systematische numerieke uitschieters (emergent outlier features). In specifieke transformatielagen vertoont een fractie van de hidden dimensions (vaak minder dan 0,1% van de kanalen) activatiewaarden die tot wel 100 keer groter zijn dan de gemiddelde activatieomvang. Wanneer we een uniforme matrixbrede schaalfactor $S$ toepassen op een laag met extreme uitschieters, forceert die enkele uitschieter een enorm grote stapgrootte $\Delta$. Hierdoor worden alle overige 99,9% van de normale gewichten gecomprimeerd tot slechts een handvol discrete waarden rondom het nulpunt, wat leidt tot een catastrofale ineenstorting van de taalvaardigheid en de contextuele coherentie van het model. Om dit fenomeen te neutraliseren zonder overmatig geheugengebruik, splitsen moderne kwantisatiemethoden de tensors op in fijnmazigere structuren: - Per-tensor quantization: Eén schaalfactor voor de gehele matrix. Zeer zuinig qua metadata, maar extreem kwetsbaar voor uitschieters. - Per-channel / Per-row quantization: Iedere rij of kolom in de gewichtsmatrix krijgt een eigen schaalfactor. Dit vangt variatie tussen verschillende aandachts- en projectiekoppen uitstekend op. - Block-wise / Group-wise quantization: Gewichten worden opgedeeld in kleine subblokken (veelal blokgroottes van 32, 64 of 128 elementen). Elk subblok heeft zijn eigen $S$- en $Z$-parameters. Dit is de de facto standaard voor robuuste 4-bit reconstructie. ## PTQ versus QAT: twee verschillende paden naar compressie Er bestaan twee fundamenteel verschillende routes om een model terug te brengen in precisie: Post-Training Quantization (PTQ) en Quantization-Aware Training (QAT). Post-Training Quantization (PTQ) wordt toegepast op een reeds volledig getraind basis- of instructiemodel. Hierbij worden de gewichten bevroren en geconverteerd met behulp van een representatieve kalibratieset van tekstdata (meestal 128 tot 512 contextblokken). De kalibratieset dient om de dynamische bereiken van de activaties door de lagen heen te observeren en de optimale schaalfactoren te bepalen met technieken zoals Mean Squared Error (MSE) minimalisatie of Hessiaanse krommingsberekeningen. PTQ vereist relatief weinig rekenkracht en kan binnen enkele minuten tot enkele uren op een enkele GPU worden voltooid. Quantization-Aware Training (QAT) integreert de afrondingsfouten direct in het trainingsproces of de fine-tuningfase. Omdat de discrete afrondingsfunctie $\text{round}(x)$ een afgeleide van nul heeft en gradiëntafdaling via backpropagation blokkeert, maakt QAT gebruik van een Straight-Through Estimator (STE). Tijdens de forward pass worden de gewichten virtueel gekwantiseerd om de ruis te simuleren, terwijl tijdens de backward pass de onafgeronde reële gradiënten doorstromen naar de FP32-meestergewichten. QAT levert bij extreem lage bitrates (zoals 2-bit en 3-bit) significant betere perplexity-scores op dan PTQ, maar brengt substantiële trainingskosten en datavereisten met zich mee. ## De 4-bit revolutie: AWQ, GPTQ en bitsandbytes ontleed In moderne productieclusters domineert 4-bit PTQ het landschap. Drie specifieke implementaties hebben de markt de afgelopen jaren vormgegeven: Methode | Type optimalisatie | Doelwit | Snelheid inferentie | VRAM-reconstructie | GPTQ (Layer-wise) | Tweede-orde Taylor / Inverse Hessian | Gewichten (W4A16) | Hoog (met custom GEMM kernels) | Geen reconstructie-overhead | AWQ (Activation-aware) | Salience-behoud op activatiedata | Gewichten (W4A16) | Zeer hoog (geoptimaliseerd voor throughput) | Geen reconstructie-overhead | NF4 / QLoRA (bitsandbytes) | Informatie-theoretisch kwantielformaat | Gewichten (W4A16) | Matig (hoge dekwantisatie-overhead) | FP32/BF16 adaptercombinatie | SmoothQuant / FP8 | Migratie van schaal van activatie naar gewicht | Gewicht + Activatie (W8A8 / FP8) | Maximaal (native tensor core support) | Minimale compute-overhead | GPTQ bouwt voort op het klassieke Optimal Brain Surgeon-algoritme. Het verwerkt een gewichtsmatrix laag voor laag en actualiseert de resterende niet-gekwantiseerde gewichten telkens wanneer een rij wordt afgerond, gebruikmakend van de inverse Hessiaan van de activaties. Dit compenseert actief voor de introductie van afrondingsfouten in eerdere kolommen. AWQ (Activation-aware Weight Quantization) realiseert zich dat niet alle gewichten gelijkwaardig zijn. Door de activatie-omvang te observeren tijdens kalibratie, identificeert AWQ de top 1% meest kritieke gewichten ('salient weights'). In plaats van deze gewichten in 16-bit te laten staan (wat geheugenfragmentatie zou veroorzaken), berekent AWQ per kanaal een wiskundige schaalfactor die de activatiegrootte dempt en het gewicht proportioneel vergroot. Hierdoor vallen de belangrijkste signaaldragers binnen het meest representatieve deel van het 4-bit raster zonder dat de matrixstructuur breekt. NF4 (NormalFloat 4), geïntroduceerd met QLoRA, verlaat het uniforme lineaire raster. Omdat neurale netwerkgewichten na normalisatie nagenoeg exact een standaardnormale verdeling volgen met gemiddelde 0 en variantie $\sigma$, verdeelt NF4 de 16 beschikbare 4-bit discrete toestandspunten zodanig dat elk kwantiel exact evenveel waarschijnlijkheidsmassa bevat. Dit minimaliseert het theoretische informatieve verlies per parameter. ## Hardware-mechanica en inferentie-engines in de praktijk Een hardnekkig misverstand over quantization is dat het automatisch de rekentijd halveert. Op moderne hardware is de werkelijkheid complexer. Om te begrijpen waar de winst zit, moeten we kijken naar de bottleneck van LLM-generatie: Memory Bandwidth Bound vs. Compute Bound. Tijdens de generatiefase (het autoregressief token voor token uitsturen) moet de GPU voor elk gegenereerd token de volledige set modelparameters vanuit het langzamere High Bandwidth Memory (HBM/VRAM) laden naar de snelle on-chip Static RAM (SRAM) registers. Omdat de rekenkundige bewerking per gewicht minimaal is bij batchgrootte 1 (één vermenigvuldiging per getal), staat de Tensor Core grotendeels te wachten op data-overdracht. We noemen dit memory bandwidth bound. Een 4-bit model (W4A16) reduceert de vereiste datatransfer over de geheugenbus met een factor vier. De GPU laadt 4-bit integers in zijn registers, dekwantiseert deze 'on-the-fly' naar FP16/BF16 met een handvol eenvoudige rekenkundige klokcycli, en voert vervolgens de standaard dotproduct-berekening uit. Omdat de geheugenbus de absolute bottleneck was, resulteert deze techniek in een spectaculaire toename van het aantal tokens per seconde per stream. Voor wie dieper in de hardwarematige componenten wil duiken, biedt [het achtergronddossier over AI-chips en hardware-ontwikkelingen](https://nieuws.llmnet.nl/chips-en-hardware-race) inzicht in hoe moderne processoren omgaan met transistordichtheid en geheugenbandbreedtes. Op softwareniveau vereist dit een gespecialiseerde serverarchitectuur; in [de review van vLLM versus Ollama voor productieomgevingen](https://radar.llmnet.nl/review-vllm-versus-ollama-voor-productie-op-eigen-servers) worden de prestatieverschillen van dergelijke inferentie-engines tot op kernelniveau ontleed. ## Het overgeslagen knelpunt: KV-cache kwantisatie Bij het schalen van productiesystemen naar tienduizenden gelijktijdige gebruikers of bij het verwerken van lange documenten (32k tot 128k context) vormt niet het gewichtsgeheugen, maar de Key-Value (KV) cache het primaire expansierisico voor het GPU-geheugen. Voor elke token in de context moet het model de aandachtsvectoren van alle voorgaande lagen vasthouden in VRAM. Het geheugengebruik van de standaard FP16 KV-cache laat zich exact berekenen met de formule: Geheugen_KV (bytes) = 2 * n_layers * n_heads * d_head * n_ctx * batch_size * 2_bytes Voor een standaard 70B parameter model met 80 lagen, Grouped-Query Attention (8 key-value heads van dimensie 128) en een context van 16.384 tokens, consumeert de KV-cache van één enkele aanvraag circa 5,37 GB VRAM. Bij een bescheiden batch van 16 gelijktijdige verzoeken slokt de KV-cache alleen al 85 GB geheugen op — meer dan de capaciteit van een volledige 80GB enterprise-GPU. Hier biedt KV-cache quantization (FP8, INT8 of INT4) soelaas. Door de sleutel- en waarde-vectoren asymmetrisch per token te kwantiseren naar 8-bit of 4-bit, kan de geheugenvoetprint van actieve sessies met 50% tot 75% worden ingekrompen zonder merkbaar verlies aan aandachtsscherpte. Om de interactie tussen contextgrootte en geheugenbeheer verder te optimaliseren, loont het om te bestuderen [hoe context caching geheugen en tokenkosten reduceert](https://nieuws.llmnet.nl/context-caching-hoe-slimme-opslag-de-tokenkosten-halveert), aangezien dit direct combineert met KV-cachecompressie. ## Doorvoer versnellen: de synergie met Speculative Decoding Quantization kan tevens strategisch worden ingezet in geavanceerde inferentie-pipelines. Een sprekend voorbeeld is Speculative Decoding. Hierbij genereert een klein, gecomprimeerd 'draft model' (bijvoorbeeld een 4-bit gekwantiseerd compact model) razendsnel een serie van 4 tot 8 kandidaat-tokens. Vervolgens valideert het grote, ongekwantiseerde basismodel (het 'target model') al deze tokens parallel in één enkele forward pass over de batch. Omdat het draft model gekwantiseerd is, past het moeiteloos op dezelfde GPU naast het hoofdmodel en voert het zijn stappen uit met minimale latency. Hoe dit mechanisme wiskundig garandeert dat de uiteindelijke token-distributie volkomen identiek blijft aan die van het doelleadermodel, staat uitgebreid beschreven in de gids over [speculative decoding en de versnelling van LLM-inferentie](https://nieuws.llmnet.nl/speculative-decoding-versnelling-van-llm-inferentie). ## VRAM-calculatie: theoretisch model vs. productierealiteit Een veelgemaakte ontwerpfout bij capaciteitsplanning is het verwarren van de kale parameteromvang met de totale geheugenbehoefte van een draaiend inferentiesysteem. De totale VRAM-voetprint ($M_{\text{totaal}}$) bestaat uit vier componenten: M_totaal = M_parameters + M_kv_cache + M_activaties + M_runtime_overhead Parameters | Formaat | Gewichtsgeheugen | KV-Cache (8k ctx, b=4) | CUDA / Runtime Buffer | Minimale GPU-omvang | 8B | FP16 (16-bit) | 16,0 GB | 2,1 GB | ~2,5 GB | 1x 24 GB (bijv. RTX 4090 / A10G) | 8B | W4A16 (4-bit) | 4,8 GB | 2,1 GB | ~2,0 GB | 1x 12 GB / 1x 16 GB | 70B | FP16 (16-bit) | 140,0 GB | 5,4 GB | ~5,0 GB | 2x 80 GB (H100 / A100) | 70B | W4A16 (4-bit) | 38,5 GB | 5,4 GB | ~4,0 GB | 1x 48 GB (A40 / RTX 6000) of 2x 24 GB | 70B | W4A4 / FP8 | 38,5 GB | 2,7 GB (FP8 KV) | ~3,5 GB | 1x 48 GB (hoge batchconcurrency) | Zoals de tabel aantoont, transformeert 4-bit kwantisatie de hardwarevereisten van een 70B parameter model van een multi-node of multi-GPU H100 cluster naar één enkele enterprise-kaart met 48 GB VRAM. De kostenbesparing op infrastructuur bedraagt hierdoor vaak 60% tot 80% per verwerkte miljoen tokens. ## Degradatiemeting en kwaliteitsbewaking: hoe meet je verlies? De centrale operationele vraag luidt: wat leveren we in aan intelligentie? Het blindelings vertrouwen op geaggregeerde academische benchmarks (zoals MMLU of GSM8k) maskeert vaak substantiële kwaliteitsvalkuilen in specifieke productietaken. De standaard wiskundige meetlat voor kwantisatiekwaliteit is Perplexity (PPL) op een gestandaardiseerde dataset zoals WikiText-2 of C4. Perplexity meet hoe goed het model in staat is het volgende token in een representatieve tekstreeks te voorspellen. Een stijging van de perplexity met minder dan 0,1 punt duidt over het algemeen op een nagenoeg verliesvrije compressie. PPL = exp( - (1 / N) * sum( log P(x_i | x_