Je wil een taalmodel lokaal draaien. Je gaat naar Hugging Face, zoekt je model op en ziet een lijst van bestanden: Q4_K_M, Q5_K_S, Q8_0, IQ4_XS, Q3_K_L. Welke pak je? En maakt het eigenlijk uit?

Het antwoord is: ja, het maakt uit — maar minder dan je denkt. In dit artikel legt Hendrik Claeys uit wat al die letters en cijfers betekenen, hoe je perplexiteitsverlies interpreteert, en wanneer je gewoon Q4_K_M moet pakken en niet verder moet nadenken.

Wat GGUF eigenlijk is

GGUF is het bestandsformaat dat llama.cpp gebruikt om gecomprimeerde taalmodellen op te slaan en te laden. Het staat voor "GPT-Generated Unified Format" en verving het oudere GGML-formaat vanaf eind 2023. Het formaat bundelt modelgewichten, tokenizer, metadata en hyperparameters in één enkel bestand — handig voor distributie, makkelijk voor lokale tools als Ollama, LM Studio en Jan.

Quantisering is de techniek die de bestandsgrootte drastisch verkleint. Een model als Llama 3.1 8B heeft in volle precisie (BF16) een gewicht van zo'n 16 GB. Met GGUF-quantisering breng je dat terug naar 4–8 GB, afhankelijk van het gekozen niveau. Dat doe je door de floating-point gewichten te vervangen door integers met een lagere resolutie — minder bits, minder geheugen, minder rekenkracht.

De kern van het verhaal: een gewicht dat oorspronkelijk 16 bits nauwkeurig is, wordt teruggebracht naar 4 of 5 bits. Je verliest informatie, maar de meeste neurale netwerken zijn verrassend tolerant voor dat verlies — zeker als je slimme quantiseringstechnieken gebruikt.

De suffixen: wat K, S, M en het getal betekenen

De naam van een GGUF-quantisatieniveau bestaat uit drie onderdelen. Neem Q4_K_M als voorbeeld:

  • Q4 — het getal geeft het aantal bits per gewicht aan: 4 bits. Een Q5-formaat gebruikt 5 bits, Q8 gebruikt 8 bits.
  • K — dit geeft aan dat het een K-quant is: een modernere quantiseringsvariant die een tweelagige superblokstructuur gebruikt. K-quants verdelen de gewichten in blokken van 256 waarden, met per subblok extra schaal- en offsetparameters. Dat maakt de kwantisering nauwkeuriger dan de oudere "legacy" formaten (Q4_0, Q4_1, Q5_0).
  • M — de grootte-aanduiding: S (Small), M (Medium) of L (Large). Dit gaat niet over de modelgrootte, maar over hoe precies bepaalde lagen worden gequantiseerd. Een M-variant gebruikt hogere precisie voor de gevoeligste tensorlagen (embeddings, attentiongewichten), terwijl een S-variant overal dezelfde lage precisie toepast. L-varianten, beschikbaar bij Q3_K, zijn nog selectiever.

Het getal na de underscore (de "0" in Q8_0) heeft een andere betekenis: dat is een legacy-aanduiding. Q8_0 gebruikt symmetrische 8-bit quantisering met één schaalfactor per blok. De "0" staat voor type 0 — geen zero-point offset. Q4_1 heeft wel een offset (asymmetrisch), Q4_0 niet.

"Q4_K_M is niet de beste quantisering die bestaat — het is de beste die je bijna altijd kunt kiezen zonder erover na te hoeven denken."

Perplexiteitsverlies per quantiseringsniveau

De meest gebruikte maatstaf om quantiseringskwaliteit te meten is perplexiteit (ppl): hoe lager, hoe beter het model tekst voorspelt. Perplexiteitsverlies is het verschil tussen het gequantiseerde model en het origineel in volle precisie.

Onderstaande tabel geeft de officiële benchmarkcijfers van het llama.cpp-team voor een 7B-model, aangevuld met bits-per-gewicht (BPW) en richtbestandsgrootte:

Quantisering BPW Bestandsgrootte (7B) Ppl-verlies (Δ vs F16) Kwaliteit
Q2_K 2,97 2,78 GB +0,8698 Sterk gedegradeerd
Q3_K_S 3,16 2,95 GB +0,5626 Merkbaar verlies
Q3_K_M 3,64 3,41 GB +0,2803 Acceptabel voor eenvoudige taken
Q4_K_S 4,30 4,02 GB +0,1149 Goed
Q4_K_M 4,67 4,36 GB +0,0535 Aanbevolen standaard
IQ4_XS 4,30 4,05 GB ~+0,05 Goed (met goede imatrix)
Q5_K_S 5,57 5,21 GB +0,0353 Hoog
Q5_K_M 5,70 5,33 GB +0,0234 Hoog
Q6_K 6,56 6,14 GB +0,0044 Bijna verliesvrij
Q8_0 8,50 7,95 GB ~+0,001 Effectief verliesvrij

Een paar dingen vallen op. Ten eerste: het verschil tussen Q4_K_M (+0,054 ppl) en Q8_0 (+0,001 ppl) is in de praktijk nauwelijks merkbaar in conversaties of codetaken. Ten tweede: de sprong van Q3 naar Q4 is veel groter dan die van Q4 naar Q5 of Q6. Pas bij Q2_K degradeert de output echt zichtbaar.

Bovendien zeggen perplexiteitscijfers niet alles. Blind tests op llama.cpp-forums laten zien dat gebruikers Q4_K_M en Q5_K_M nauwelijks van elkaar kunnen onderscheiden in dagelijks gebruik. Redeneren, codesuggesties en feitelijke precisie veranderen pas merkbaar bij Q3 en lager.

Imatrix: de geheime variabele achter IQ-quants

Naast de K-quants bestaat er een nieuwere quantiseringsfamilie: de I-quants, zoals IQ4_XS, IQ3_M en IQ2_XXS. De I staat voor importance matrix, kortweg imatrix.

Het idee is eenvoudig maar krachtig: niet alle gewichten zijn even belangrijk. Een gewicht dat een grote invloed heeft op de modeloutput — bij kleine wijzigingen al grote gevolgen heeft — verdient meer precisie. De imatrix wordt berekend met kalibratiemateriaal: je voedt het model een paar honderd tekstfragmenten en meet de activatiepatronen per laag. Dat geeft een "importantiekaart" die llama.cpp gebruikt om precisiebits te herverdeelen.

Het resultaat: IQ4_XS heeft slechts 4,30 BPW (vs 4,67 voor Q4_K_M) maar heeft een vergelijkbare kwaliteit — zo'n 300 tot 400 MB kleiner voor een 7B-model. Voor een 70B-model loopt dat verschil op tot 3–4 GB, wat soms net het verschil maakt tussen passend en niet passend in VRAM.

Maar er is een valkuil: de kwaliteit van een IQ-quant hangt sterk af van hoe goed de imatrix is berekend. Een slecht gekalibreerde IQ4_XS kan slechter zijn dan Q4_K_M. Check bij Hugging Face-modellen altijd of de uploader vermeldt dat er een imatrix is gebruikt — serieuze quantiseerders zoals Unsloth of bartowski doen dit standaard.

Welke quantisering je moet kiezen

Een simpele beslisboom voor de meeste gevallen:

Je hebt minder dan 6 GB VRAM of RAM voor het model — gebruik Q4_K_M of IQ4_XS. Dat is de standaard. Het is goed genoeg voor chat, samenvatten, codeassistentie en instructietaken.

Je hebt 6–8 GB — Q5_K_M is haalbaar voor 7B-modellen en geeft een kwaliteitsboost die de extra 1 GB waard is. Het perplexiteitsverlies halveert ten opzichte van Q4_K_M.

Je hebt comfortabel meer dan 8 GB — Q6_K is bijna verliesvrij (+0,0044 ppl) en past voor een 7B-model nog steeds ruim in 16 GB. Q8_0 is voor benchmarkwerk of als je absoluut maximale fideliteit wil, maar voor dagelijks gebruik voeg je weinig toe ten opzichte van Q6_K.

Je vecht om elke gigabyte — overweeg IQ4_XS (van een betrouwbare bron met imatrix) of IQ3_M. IQ3_M met een goede imatrix presteert soms op Q4_K_M-niveau bij slechts 3,5 BPW, wat bij 13B-modellen al 1,5–2 GB scheelt.

Je wil een groter model draaien dan je VRAM eigenlijk toelaat — liever een grotere architectuur in Q4_K_M dan een kleiner model in Q8_0. Een Llama 3 70B in Q4_K_M wint het bijna altijd van een Llama 3 8B in Q8_0. Meer parameters, zelfs gequantiseerd, wegen zwaarder dan hogere precisie bij minder parameters.

Wat je moet vermijden: de legacy-formaten Q4_0 en Q5_0. Ze zijn ouder, nauwkeuriger noch sneller dan K-quants, en worden op Hugging Face steeds minder aangeboden. Als je ze ziet staan naast K-quants, kies dan altijd de K-variant.

FAQ

Is Q8_0 hetzelfde als het originele model?
Bijna. Q8_0 heeft een perplexiteitsverlies van minder dan 0,001 ten opzichte van FP16 — voor alle praktische doeleinden identiek. Het enige nadeel is de bestandsgrootte: een 7B-model weegt bijna 8 GB, versus 16 GB voor FP16.
Wat betekent BPW precies?
Bits per weight (BPW) is het gemiddeld aantal bits dat wordt gebruikt om elk gewichtsparameter op te slaan. Dat getal is niet altijd gelijk aan het kwantiseringsnummer: Q4_K_M heeft 4,67 BPW omdat de metadatalaag (schaalparameters) ook ruimte inneemt. IQ4_XS heeft 4,30 BPW door aggressievere compressie van minder-importante gewichten.
Werkt quantisering even goed voor alle modellen?
Nee. Grote modellen (70B+) zijn over het algemeen robuuster tegen quantisering dan kleine modellen (3B en minder). Een 3B-model in Q3_K_M kan merkbaar gebroken zijn, terwijl een 70B-model in Q3_K_M nog redelijk presteert. Houd bij kleine modellen altijd een hogere quantisering aan.
Maakt het uit voor welke taak ik het model gebruik?
Ja, enigszins. Creatief schrijven en conversatie zijn toleranter voor lagere quantisering. Redeneren, wiskunde en code zijn gevoeliger voor quantiseringsfouten. Als je model op codeertaken inzet, is Q5_K_M of hoger zeker de moeite waard.
Kan ik zelf quantiseren?
Ja, met llama.cpp's llama-quantize-tool. Je hebt een GGUF in F16 of BF16 nodig als startpunt. Voor IQ-quants moet je ook de imatrix berekenen met llama-imatrix en kalibratiemateriaal. In de praktijk download je gewoon de al gequantiseerde versie van Hugging Face — tenzij je een model quantiseert dat nog niet beschikbaar is.