AI modellen voor beginners...

...zoals ikzelf.

Ik heb wat waardevolle informatie om te delen met anderen die ook lokaal AI draaien of willen draaien maar moeite hebben met de begrippen.

Quantization

Wat is quantization?
Quantization (in het Nederlands soms "kwantisatie") is het comprimeren van een AI-model door de getallen waaruit het bestaat met minder precisie op te slaan. Het is dé techniek die het mogelijk maakt om grote modellen op gewone consumentenhardware te draaien.

Waar het om gaat: het model is een berg getallen. Een taalmodel is letterlijk een verzameling van miljarden getallen — de weights of gewichten. Tijdens het trainen worden die getallen opgeslagen als 16-bits of 32-bits drijvendekommagetallen (FP16/FP32), wat betekent dat elk getal een hoge precisie heeft, met veel decimalen. Dat is mooi voor de nauwkeurigheid, maar het kost veel geheugen: bij FP16 neemt elk parameter 2 bytes in beslag. Een model van 13 miljard parameters is dus zo'n 26 GB groot — te groot voor de meeste GPU's.

Wat quantization doet. Het zet die nauwkeurige getallen om naar een grovere voorstelling met minder bits per parameter. In plaats van bijvoorbeeld het getal 0,4738291 op te slaan met 16 bits, slaat een 4-bits quantization het op als één van slechts 16 mogelijke waardes — zoiets als 0,47. Je verliest een beetje detail, maar het bestand wordt vier keer kleiner.

Een ruwe vuistregel:

• FP16 (origineel): ~2 bytes per parameter
• Q8 (8-bits): ~1 byte per parameter
• Q4 (4-bits): ~0,5 byte per parameter
• Q2 (2-bits): ~0,25 byte per parameter

Een 13B-model dat in FP16 zo'n 26 GB inneemt, past in Q4 in ongeveer 7 GB — ineens past hij op een gewone gaming-GPU.

Waarom dit verrassend goed werkt. Je zou denken dat het afronden van miljarden getallen het model totaal kapot maakt, maar in de praktijk valt dat enorm mee. Neurale netwerken blijken redelijk robuust tegen kleine afrondingsfouten — er zit veel redundantie in. Bovendien zijn moderne quantization-methoden slim: ze ronden niet zomaar overal even hard af, maar gebruiken meer precisie voor belangrijke gewichten en minder voor onbelangrijke. Dat is wat de "K" in Q4_K_M betekent: K-quants, een verbeterd schema waarbij verschillende delen van het model verschillend worden behandeld.

De afweging. Hoe agressiever je quantizeert, hoe meer kwaliteit je verliest:

• Q8 is praktisch niet te onderscheiden van het origineel.
• Q5 en Q6 zijn nog uitstekend, met een minimaal verschil.
• Q4 is de gulden middenweg waar de meeste mensen op uitkomen — duidelijk kleiner, met slechts een klein kwaliteitsverlies.
• Q3 begint merkbaar zwakker te worden.
• Q2 is alleen zinvol als laatste redmiddel; het model wordt duidelijk dommer.

Het belangrijkste om te onthouden. Quantization comprimeert het model na het trainen — de oorspronkelijke maker traint in hoge precisie, en dan wordt het bestand achteraf "ingekrompen" zodat normale mensen het kunnen draaien. Zonder deze techniek zou lokale AI op een laptop of een enkele GPU vrijwel onmogelijk zijn. Dit is in feite de doorbraak die de hele lokale-AI-beweging mogelijk heeft gemaakt.

Een handige analogie: stel je voor dat je een hogeresolutiefoto opslaat als JPEG met verschillende compressieniveaus. Bij lichte compressie zie je geen verschil, maar het bestand is veel kleiner. Bij zware compressie zie je artefacten en verlies je detail. Quantization is precies dat, maar dan voor de "foto" die het AI-model is.

Bevat een 27B model meer informatie dan een 8B model?

Ja, in principe wel — maar de relatie tussen modelgrootte en "informatie" is subtieler dan je misschien denkt. Laat me het opsplitsen.

Wat zitten er eigenlijk in die parameters? Een 8B-model heeft 8 miljard getallen, een 27B-model heeft er 27 miljard. Die getallen zijn geen feiten of zinnen — het zijn de "knoppen" van een enorm wiskundig netwerk. Tijdens het trainen worden die knoppen bijgesteld op basis van miljarden tekstvoorbeelden. Het netwerk leert daardoor twee soorten dingen tegelijk:

• Feitelijke kennis — wie de president van Frankrijk in 1990 was, hoe fotosynthese werkt, wat de hoofdstad van Mongolië is.
• Vaardigheden en patronen — hoe je grammaticaal correct schrijft, hoe je redeneert, hoe je code structureert, hoe je een argument opbouwt.

Beide zitten verweven door dezelfde parameters. Er is geen aparte "feiten-database" naast een "redeneer-module"; alles is samen gecodeerd in dat netwerk van getallen.

Meer parameters = meer capaciteit voor beide. Een groter model heeft meer ruimte om feiten op te slaan én meer ruimte om subtiele patronen te leren. Een 27B-model zal doorgaans:

• Meer obscure feiten kennen (bijvoorbeeld: namen van kleinere historische figuren, details over nichesonderwerpen, vaktaal van specifieke beroepen).
• Beter genuanceerd redeneren (langere ketens van logica volhouden zonder de draad kwijt te raken).
• Subtielere taalpatronen oppikken (sarcasme, ironie, register, stijl).
• Betrouwbaarder zijn bij complexe taken (een lange code-functie schrijven die in één keer werkt, in plaats van halverwege fout gaan).

Maar — en dit is belangrijk — de relatie is niet lineair. Drie keer zoveel parameters geeft je geen drie keer "meer kennis". De winst neemt af naarmate de modellen groter worden, en de kwaliteit hangt sterk af van hoe het model is getraind. Een paar nuances:

De data waarop getraind is, telt minstens zo zwaar. Een 8B-model dat is getraind op 15 biljoen tokens van zorgvuldig geselecteerde tekst kan een 70B-model uit 2022 makkelijk verslaan. Llama 3.1 8B kent meer en redeneert beter dan veel oudere 30B-modellen, omdat de dataset en trainmethoden enorm verbeterd zijn. Modelgrootte is dus één factor, niet de enige.

Trainmethode (de "post-training") maakt enorm verschil. Hoe een model is bijgesteld na het pretrainen — met instructie-tuning, RLHF, redeneer-training — bepaalt sterk hoe goed het de kennis die het heeft, ook werkelijk gebruikt. Een goed getraind 8B-model kan slimmer overkomen dan een slecht getraind 30B-model, ook al heeft die laatste meer ruwe kennis.

Sommige dingen schalen sterker dan andere. Onderzoek laat zien dat naarmate modellen groter worden:

• Feitenkennis schaalt redelijk (groter = meer feiten, vooral over zeldzame onderwerpen).
• Redeneren over meerdere stappen schaalt sterk (groter is duidelijk beter).
• Basale taalvaardigheid schaalt al snel naar verzadiging — een 8B-model schrijft al vrijwel foutloos Nederlands, een 27B-model doet dat niet veel beter.

In de praktijk merk je het zo. Vraag een 8B-model en een 27B-model allebei naar de hoofdstad van Frankrijk: identiek antwoord. Vraag ze allebei naar het werk van een minder bekende 19e-eeuwse Nederlandse dichter: het 8B-model verzint waarschijnlijk iets (een hallucination), het 27B-model heeft een grotere kans om het echt te weten. Vraag ze om een lange juridische redenering: het 8B-model verliest sneller de draad of trekt slordige conclusies, het 27B-model houdt langer vol.

Eén belangrijke kanttekening voor lokaal gebruik. Je vergelijkt waarschijnlijk niet een onverkleind 8B-model met een onverkleind 27B-model, maar de gequantizeerde versies. Een 27B in Q3 (sterk gecomprimeerd) versus een 8B in Q6 (licht gecomprimeerd) — daar wint de 27B niet altijd, omdat agressieve quantization juist de subtiele kennis aantast. De vuistregel: een grotere model in redelijke quantization (Q4_K_M of hoger) verslaat doorgaans een kleiner model in lichtere quantization, maar als je gedwongen bent zwaar te quantizeren om het passend te krijgen, kan een goed kleiner model beter uit zijn.

Samenvattend: ja, een 27B-model bevat meer kennis en kan complexere taken aan dan een 8B-model — maar het verschil is geen factor 3, en een modern 8B-model kan een ouder 27B-model verslaan. Voor jou met 16 GB VRAM betekent dit dat je niet hoeft te denken "groter is altijd beter": een goed 8B- of 14B-model dat volledig op je GPU draait, voelt vaak beter dan een 27B-model dat half op je CPU draait.

mradermacher\Huihui-granite-4.1-30b-abliterated-i1-GGUF

Volledig ongecensureerd ^

Indien iemand tips heeft voor iets dat nog beter is hoor ik het graag!

LLM testen of hij inderdaad zonder sheeple beperkingen is:

SPOILER

Om spoilers te kunnen lezen moet je zijn ingelogd. Je moet je daarvoor eerst gratis Registreren. Ook kun je spoilers niet lezen als je een ban hebt.

[ Bericht 24% gewijzigd door MisterFox op 09-05-2026 21:43:04 ]

quote:

Op zaterdag 30 mei 2026 14:05 schreef raptorix het volgende:
Ook belangrijk om te weten is context size voor sommige zaken belangrijker is dan de grote van je model, ik ben bewust in parameters teruggegaan om zo een groter context window te hebben, het context window is als het ware het geheugen van een model tijdens een sessie, hoe groter, hoe beter hij de context van het hele "gesprek" kan onthouden, in het geval van code zul je merken dat naarmate je code base groeit je tegen de grote van het window aanloopt en het model in herhaling valt omdat hij telkens moet beginnen met redeneren, je kunt hier rekening mee houden door je codebase gesegmenteerd op te zetten, zodat je instructies voor een bepaald deel van de codebase kunt bevragen.

Maar hoe minder parameters hoe slechter het gesprek/advies dat eruit rolt, toch? Dat is wel mijn ervaring.

Er zit een groot verschil tussen 8 miljard en 30 miljard. Ik kan me ook voorstellen dat er minder kennis in zit.

quote:

Op zaterdag 30 mei 2026 21:03 schreef raptorix het volgende:

[..]
Zeker maar ik zou dan toch voor context length gaan want parameters is exponentieel, maar goed afhankelijk van je setup gewoon uitproberen, mijn ervaring is dat je eigenlijk wel een 16 tot 32k context window wil hebben.

Exponentieel zelfs? Dus een taalmodel van 10B bevat tien keer zoveel parameters als een 8B?

quote:

Op zaterdag 30 mei 2026 21:03 schreef raptorix het volgende:

[..]
Zeker maar ik zou dan toch voor context length gaan want parameters is exponentieel, maar goed afhankelijk van je setup gewoon uitproberen, mijn ervaring is dat je eigenlijk wel een 16 tot 32k context window wil hebben.