Kwantisatie

Wat is kwantisatie?

Kwantisatie maakt een AI-model kleiner door de getallen waaruit het bestaat op te slaan met minder bits. Een taalmodel is in de kern een gigantische verzameling parameters, en elke parameter is gewoon een getal. Bij een modern taalmodel neemt zo'n getal standaard 16 bits geheugen in. Kwantisatie rondt het af naar 8 of 4 bits.

Vergelijk het met een foto bewaren in een lagere kwaliteit. Kies je op je smartphone een compactere instelling, dan wordt het bestand drie tot vier keer kleiner en ziet bijna niemand het verschil. Bij een model werkt het net zo: de afgeronde getallen wijken een fractie af van de originele, maar het gedrag blijft grotendeels overeind.

Dat afronden werkt omdat het gedrag van een model in het samenspel van miljarden getallen zit, niet in de exacte waarde van elk getal apart. De kleine afrondingsfouten vallen in het eindresultaat amper op.

Wat levert kwantisatie op?

Minder geheugen
Van 16 naar 4 bits betekent grofweg vier keer minder geheugen. Google publiceerde de cijfers voor zijn Gemma 3-familie: de grootste versie van 27 miljard parameters zakt van 54 GB naar 14,1 GB. In plaats van dure serverhardware volstaat dan een enkele stevige GPU.

Meer snelheid
Bij het draaien van een model, de inferentie, is het geheugenverkeer vaak de bottleneck: voor elk gegenereerd woord moeten alle parameters van het geheugen naar de rekenkernen. Kleinere getallen betekent minder data verplaatsen, en dus snellere antwoorden.

Lokaal draaien
Voor veel KMO's is dit de echte winst. Een model dat na kwantisatie in 8 of 16 GB geheugen past, draait op een laptop of op een server in je eigen serverkast. Je data verlaat het gebouw niet en je betaalt geen kost per aanvraag, alleen je eigen hardware.

Kwantiseren na de training of tijdens de training

De meest gebruikte aanpak is kwantiseren nadat het model volledig getraind is. Dat heet post-training quantization. Er komt geen hertraining aan te pas, dus iedereen kan het toepassen op een bestaand model. Voor de meeste populaire open modellen vind je op Hugging Face varianten die zo gemaakt zijn, met methodes zoals GPTQ, AWQ en bitsandbytes.

De tweede aanpak bouwt de afronding al tijdens de training in. Dat heet quantization-aware training of QAT: het model oefent tijdens de training al met afgeronde getallen en verliest daardoor achteraf veel minder kwaliteit, zeker bij 4 bits. Google bracht van Gemma 3 aparte QAT-versies uit die speciaal getraind zijn om in 4 bits goed te blijven presteren.

Kwantisatie, distillatie of een kleiner model?

Wie een taalmodel op eigen hardware wil draaien, heeft drie routes. Ze sluiten elkaar niet uit.

Kwantisatie houdt hetzelfde model en maakt alleen de opslag compacter. Het model kent nog exact hetzelfde, met iets minder precisie. Dit is de snelste route, want er is geen nieuwe training nodig.

Distillatie traint een nieuw, kleiner model op de antwoorden van een groot model, zoals een leerling die van een leraar leert. Het resultaat is een ander model dat een flink deel van het gedrag erft, maar de training zelf vraagt tijd en expertise.

Een kleiner model kiezen is vaak de eenvoudigste route. Families zoals Gemma en Phi bestaan in meerdere maten, van enkele honderden miljoenen tot tientallen miljarden parameters. Kies de kleinste maat die je taak aankan.

In de praktijk worden de routes gecombineerd: een small language model in een handzame maat, gekwantiseerd naar 4 of 8 bits, vraagt van de drie opties het minste geheugen.

Waar kom je kwantisatie tegen?

Op Hugging Face staan populaire open modellen in meerdere kwantisatie-niveaus naast elkaar. Namen zoals Q4 of Q8 in de bestandsnaam verraden het aantal bits: hoe lager het cijfer, hoe kleiner het bestand.

Runtimes zoals llama.cpp, Ollama en LM Studio zijn gebouwd om die gekwantiseerde bestanden op gewone hardware te draaien, van een laptop tot een kleine server.

Microsoft verpakt hetzelfde idee in Foundry Local, een runtime met een catalogus van modellen die vooraf gekwantiseerd en gecomprimeerd zijn. Alles draait op het toestel zelf, op Windows, macOS of Linux, zonder Azure-abonnement.

Grote kans dus dat je al met een gekwantiseerd model werkt zonder het te beseffen: wie lokaal een taalmodel draait, gebruikt meestal een versie in 4 of 8 bits.

Waar moet je op letten bij het gebruik van kwantisatie

Het kwaliteitsverlies is klein maar niet nul. Bij 8 bits merk je er zelden iets van. Bij 4 bits wordt de afronding grover en zakt de kwaliteit zichtbaarder, en hoeveel dat uitmaakt verschilt per taak en per model.

Test daarom op je eigen taak, niet op de demo van de leverancier. Een vaste set voorbeelden met verwachte antwoorden, een keer door het originele model en een keer door de gekwantiseerde versie, toont snel of het verschil aanvaardbaar is.

Niet elk model verdraagt agressieve kwantisatie even goed. Kies waar mogelijk een versie die de maker zelf uitbracht of met QAT trainde, want die houdt bij 4 bits beter stand dan een variant die achteraf werd afgerond.

Geheugen is bovendien niet de enige factor. De snelheidswinst hangt af van je hardware, want niet elke chip rekent even vlot met 8-bits of 4-bits getallen. En naast het model zelf vraagt ook je gesprek of document werkgeheugen tijdens het draaien, dus hou marge over.

FAQ over kwantisatie

Merk ik het kwaliteitsverlies?
Bij 8 bits meestal niet. Bij 4 bits soms wel, afhankelijk van je taak en het model. De enige manier om het zeker te weten is testen op je eigen voorbeelden.

Moet ik zelf kwantiseren?
Zelden. Voor de meeste open modellen staan kant-en-klare gekwantiseerde versies op Hugging Face, en tools zoals Ollama en Foundry Local leveren ze rechtstreeks uit hun catalogus.

Hoeveel kleiner wordt mijn model?
Van 16 naar 4 bits maakt de parameters vier keer kleiner, van 16 naar 8 bits twee keer. Gemma 3 27B zakt zo van 54 GB naar 14,1 GB.

Kan ik een gekwantiseerd model nog fine-tunen?
Dat hangt af van de methode. Sommige, zoals bitsandbytes, ondersteunen bijtrainen op een gekwantiseerd model. Andere formaten zoals GGUF zijn puur bedoeld om een model te draaien.

Is een gekwantiseerd model hetzelfde als een small language model?
Nee. Een small language model is van bij de start klein getraind, kwantisatie comprimeert een bestaand model achteraf. Vaak zie je ze samen: een klein model dat daarna ook nog gekwantiseerd wordt.