FP16 versus INT8: hoe AI-precisie snelheid, geheugen en kwaliteit bepaalt

Van een GeForce RTX voor lokale LLM’s tot de NPU in een laptop: wie zich verdiept in AI-hardware stuit op termen als FP16, INT8 en FP8. Deze getalformaten bepalen geheugengebruik, snelheid en kwaliteit van AI-modellen. Dit artikel legt uit wat de formaten inhouden, hoe quantization werkt en welke precisie bij welke workload past.

Waarom precisie ertoe doet: bits, bandbreedte en doorvoer

AI-inferentie draait grotendeels om matrixvermenigvuldigingen. Elke parameter en elke activering moet uit het geheugen worden gelezen en door de rekeneenheden worden gehaald. Het getalformaat bepaalt hoeveel bits elk getal kost, en daarmee drie dingen tegelijk: geheugengebruik (hoeveel VRAM een model nodig heeft), bandbreedte (hoe snel data naar de rekenkernen stroomt) en doorvoer (hoeveel bewerkingen per seconde de hardware aankan).

Een rekenvoorbeeld: een 7B-model kost bij FP32 28 GB, bij FP16 14 GB, bij INT8 7 GB en bij INT4 slechts circa 3,5 GB. Halveer je de precisie, dan halveer je grofweg het geheugen én verdubbel je de effectieve bandbreedte — terwijl moderne GPU’s lage precisie bovendien sneller uitvoeren. De keerzijde: minder bits betekent grovere getallen en dus mogelijke afrondingsfouten.

Van FP32 tot INT8: de formaten op een rij

FP32 is het klassieke 32-bits formaat waarmee modellen worden getraind. Voor inferentie is het zelden nog nodig: twee keer het geheugen van FP16 zonder meetbaar betere resultaten. FP16 is de kwaliteitsbasislijn voor inferentie, al heeft het een relatief smal exponentbereik met risico op onder- en overstroom. BF16 combineert het exponentbereik van FP32 met een kleinere mantissa en is daarom de de-facto standaard voor training en veel inferentie-workloads.

INT8 gebruikt 8-bits gehele getallen en is het werkpaard van efficiënte inferentie: de helft van het geheugen van FP16, tot twee keer hogere doorvoer, en doorgaans minder dan 1 procent kwaliteitsverlies. FP8 is het nieuwe 8-bits drijvendekommaformaat in twee varianten — E4M3 (meer precisie) en E5M2 (groter bereik) — en sinds Hopper de 2026-standaard op moderne GPU’s. INT4 perst alles in 4 bits: met goede methodes (GPTQ, AWQ, Q4_K_M) blijft het verlies beperkt tot 1 à 3 procent, terwijl een 70B-model van 140 GB naar circa 35 GB krimpt. Onder de 4 bits begint de “accuracy cliff”: de kwaliteit stort in.

Formaat	Bits	Geheugen (7B)	Tempo	Kwaliteitsverlies	Hardware
FP32	32	28 GB	1×	0%	Alles
FP16 / BF16	16	14 GB	Tot 2×	Vrijwel 0%	Tensor Cores, AI-accelerators
INT8	8	7 GB	Tot 2–3×	<1%	Tensor Cores, NPU’s, XDNA
FP8 (E4M3/E5M2)	8	7 GB	Tot 2× vs FP16	<0,1%	Hopper, Blackwell, AMD CDNA
INT4	4	~3,5 GB	Tot 3–4×	1–3%	Blackwell, NPU’s, lokale LLM’s

Quantization: hoe modellen krimpen zonder in te storten

Het omzetten van een hoog-precisiemodel naar een laag-precisieformaat heet quantization: parameters worden afgerond naar een beperkt aantal niveaus (bij INT8 zijn dat er 256), elk met een schaalfactor die de oorspronkelijke range aangeeft. De eenvoudigste vorm — post-training quantization (PTQ) — doet dit achteraf zonder opnieuw te trainen: je voert het model één keer uit op een kleine kalibratiedataset, meet per laag de minimale en maximale waarden, en bepaalt zo de optimale schaalfactoren.

De grootste vijand is de outlier: een enkele activeringswaarde die ordes van grootte groter is dan de rest en de schaalfactor dwingt het volledige bereik te dekken. Slimme methodes lossen dit op: LLM.int8() houdt outliers in FP16 en quantiseert alleen de rest (mixed precision), terwijl FP8 op Blackwell microscaling (MXFP8) gebruikt — blokken van 32 elementen delen elk een eigen schaalfactor. Quantization-aware training (QAT) gaat nog verder: het model leert tijdens training al omgaan met afrondingsfouten, voor de beste kwaliteit per bit, maar vereist het oorspronkelijke trainingspijplijn.

Nauwkeurigheidsafwegingen: wat je echt verliest

Kwaliteitsverlies door quantization is niet uniform: INT8 is praktisch verliesvrij, goede INT4-methodes verliezen 1 tot 3 procent, en daaronder begint de afgrond. Chatten, samenvatten en vertalen zijn lage-gevoeligheidstaken die INT4 moeiteloos doorstaan; complexe wiskunde, codegeneratie en meerstaps-agentic-taken zijn hoge-gevoeligstaken waar het verschil tussen INT8 en INT4 duidelijk merkbaar wordt. Quantiseer dus niet blind zo ver mogelijk omlaag, maar meet per workload.

Hardware-ondersteuning: Tensor Cores, XDNA en NPU’s

Lage precisie levert pas echt snelheid op als de hardware het native ondersteunt. NVIDIA Tensor Cores zijn de referentie: gespecialiseerde matrixeenheden die FP16, BF16, INT8 en — sinds Hopper — FP8 native uitvoeren. Blackwell voegt daar FP4 en FP6 aan toe, inclusief NVFP4 met tweelaagse blokschaalverdeling op de vijfde generatie Tensor Cores, wat de doorvoer effectief verdubbelt ten opzichte van FP8.

AMD volgt een vergelijkbaar pad: CDNA-datacenterchips ondersteunen FP8 en FP4 native, en de XDNA AI-engine in Ryzen-AI-processors is geoptimaliseerd voor INT8- en INT4-inferentie. Ook NPU’s van Intel (Core Ultra) en Apple (Neural Engine) zijn gebouwd rond lage precisie — INT8 halveert daar niet alleen het geheugen, maar reduceert ook het energieverbruik per inferentie met circa 60 procent ten opzichte van FP32. Op oudere consumenten-GPU’s levert quantization vooral geheugenbesparing op en weinig snelheidswinst zonder native versnelling.

Welke precisie voor welke workload?

Voor datacenter-inferentie is het advies helder: gebruik FP8 op hardware die het ondersteunt — de no-brainer met 30 tot 50 procent snelheidswinst en minder dan 0,1 procent kwaliteitsverlies. Op oudere hardware is INT8 het veilige alternatief, met INT4 (AWQ) als keuze voor maximale doorvoer per GPU. Voor lokale LLM’s is Q4_K_M de beproefde standaard: de beste balans tussen kwaliteit, snelheid en geheugen; schaal voor veeleisende taken op naar Q5_K_M of INT8. Voor edge, mobiel en vision: begin bij FP16 (praktisch verliesvrij, direct de helft van het geheugen) en schakel pas naar INT8 als latentie- of energiebudgetten dat eisen.

Oordeel: praktisch koopadvies

FP16 versus INT8 is geen echte strijd meer: het is een spectrum geworden waarop FP8 en INT4 de nieuwe mijlpalen zijn. De vuistregels zijn simpel. Eén: draai nooit FP32 voor inferentie — FP16 of BF16 is de kwaliteitsbasislijn zonder nadelen. Twee: INT8 is de veilige standaard voor vrijwel elke workload: de helft van het geheugen, tot twee keer zo snel, minder dan 1 procent verlies. Drie: heb je moderne hardware (Hopper/Blackwell, AMD CDNA, een recente NPU), gebruik dan FP8 — sneller, zuiniger en vrijwel verliesvrij. Vier: is geheugen de harde grens, ga dan naar INT4 met een goede methode zoals AWQ of Q4_K_M. Vijf: investeer bij hardware-aankopen in native ondersteuning voor lage precisie — Tensor Cores, XDNA of een NPU bepalen uiteindelijk hoeveel model je per euro en per watt kunt draaien.