Hoe groot moet een model zijn om een kinderverhaal te schrijven?

Kan een taalmodel van amper 279 kilobyte—kleiner dan een videofragment van twee seconden—een klein, coherent kinderverhaal schrijven met een duidelijke inleiding, een avontuurlijke uitdaging en een logische ontknoping?

Moderne AI kan tegenwoordig bijna alles, maar die veelzijdigheid heeft een prijs: modellen worden gigantisch en de behoefte aan energie en geheugen is zo groot dat er wereldwijd enorme datacenters gebouwd moeten worden.

Wat als we dat omdraaien? Wat als een model zo klein mogelijk gebouwd wordt dat het zijn specifieke taak precies kan uitvoeren?

In dit artikel staat het complete proces centraal van het ontwerpen en trainen van een ultracompact Nederlands taalmodel dat rechtstreeks in een webbrowser kan draaien. Je kunt het hier zelf uitproberen. De volgende onderwerpen komen aan bod:

1. Architectuur: Waar komt het idee vandaan en wat maakt het anders?

Wie vandaag de dag leest over AI-modellen zoals ChatGPT, Claude of Gemini, hoort al snel over honderden miljarden parameters. Technisch gezien zijn deze modellen te vergelijken met wolkenkrabbers: ze bestaan uit tientallen afzonderlijke verdiepingen (lagen) die bovenop elkaar gestapeld zijn.

Wanneer een gebruiker een vraag stelt, stapt elk woord binnen op de begane grond. Het reist langs honderden unieke kamers vol rekenformules, verdieping na verdieping omhoog, totdat het bovenop het dak als nieuw woord naar buiten rolt. Dat levert een indrukwekkende veelzijdigheid op, maar het vereist een immens gebouw voor soms een doodeenvoudige vraag. Deze wolkenkrabbers vergen tientallen gigabytes aan kostbaar servergeheugen en gigantische datacenters.

De werkplaats met de lift (Recurrente Loops)

Wat als het anders kan? Onderzoek zoals TinyStories (Microsoft Research) en recente experimenten met recurrent loop transformers (zoals Ouro) tonen aan dat een afgebakende taak geen wolkenkrabber vereist. De kernvraag luidt: moet elke verdieping per se een unieke kamer zijn?

In plaats van een wolkenkrabber met tientallen unieke verdiepingen gebruikt dit model een werkplaats met één enkele kamer en een lift:

In plaats van tientallen verschillende lagen bezit het netwerk slechts twee fysieke lagen, en de invoer loopt twee keer achter elkaar door elke laag (recurrentie): vier doorgangen in totaal.

Waarom kan recurrentie voor deze taak?

In een standaard large language model (LLM) leert elke laag iets anders: de onderste lagen herkennen grammatica en zinsbouw, terwijl hogere lagen verhaallijnen en abstracte redeneringen verwerken. Bij een strikt gestructureerd kinderverhaal van 70 woorden over een vaste handeling is die enorme diepte overbodig. Dezelfde berekening kan herhaaldelijk worden toegepast om de context stap voor stap te verfijnen.

Waarom genereert de lus niet vier keer hetzelfde woord?

Tijdens de vier lussen binnen de werkplaats wordt er nog helemaal geen woord gekozen of geprint. De tekstverbindingen worden enkel intern aangescherpt. Pas na de vierde en laatste doorgang stapt de bewerkte toestand uit de lift en berekent de uitgangslaag de kansverdeling voor het eerstvolgende woord. Net als bij een regulier taalmodel kiest het algoritme vervolgens één nieuw token (op basis van waarschijnlijkheid), plakt dat achter de zin, en begint het hele proces opnieuw voor het volgende woord.

Het L2-cache voordeel: Snelheid op de chip

Bij AI-inferentie zit de vertraging op een computer of telefoon vrijwel nooit in de pure rekenkracht van de processor, maar in de tijd die nodig is om de gigantische modellen vanuit het werkgeheugen (RAM) naar de processorchip te verplaatsen. Zelfs compacte modellen die specifiek ontworpen zijn om lokaal op apparaten (aan de edge) te draaien—zoals Google's recente Gemma 4 E2B—vragen nog altijd meerdere gigabytes aan geheugen.

Doordat dit model amper 71.000 parameters telt, bedraagt het totale bestand slechts 279 kilobyte:

Het complete model past daardoor moeiteloos in het allersnelste interne geheugen van een doorsnee processor: de L2-cache (die doorgaans 1 à 2 megabyte groot is). De processor hoeft de gewichten niet telkens over een trage geheugenbus op te halen; het model staat al klaar op de rekenkern zelf. Daardoor genereert het binnen een fractie van een seconde tekst in een gewone webbrowser.

2. Even vooraf: Hoe leert een taalmodel eigenlijk?

Om te begrijpen waar de begrippen tokenisatie en trainingsdata vandaan komen, is het nuttig om te zien hoe een model feitelijk getraind wordt.

Een neuraal netwerk begint als een leeg vel papier vol willekeurige getallen (parameters). Het weet niets van de wereld en begrijpt geen enkele taal. Het leerproces rust op twee onmisbare ingrediënten:

  1. Trainingsdata: Een grote verzameling voorbeelden van hoe goede tekst eruitziet. Voor dit model zijn dat duizenden eenvoudige Nederlandse kinderverhaaltjes.
  2. Tokenisatie: De vertaalbrug. Een computer kan niet rekenen met letters of woorden, maar uitsluitend met getallen. Tekst moet eerst systematisch worden omgezet in cijfers (tokens) voordat het netwerk ermee kan rekenen.

Tijdens de training krijgt het model een stukje tekst te zien en moet het steeds het eerstvolgende woordje voorspellen. Gokt het netwerk verkeerd, dan worden de interne getallen een minuscuul stukje bijgesteld richting het goede antwoord. Na miljoenen herhalingen ontstaat zo een model dat vloeiend zinnen kan afmaken.

3. Tokenisatie: Wat is het en welke valkuilen kwamen we tegen?

Tokenisatie is dus de vertaalmachine die tekst opknipt in herkenbare brokjes (tokens) en daar een uniek nummer aan toekent.

De Woordenboek-valkuil

Omdat het model zo klein mogelijk moest blijven, lag de keuze voor een vast woordenboek voor de hand. Er werd een proefset van 1.000 kinderverhaaltjes gegenereerd en daaruit werden de 800 meest voorkomende woorden geselecteerd. Elk woord kreeg een unieke index van 0 tot 799. Vervolgens moesten nieuwe verhalen uitsluitend met deze 800 woorden worden geschreven. Kwam een woord niet voor in de lijst? Dan werd het vervangen door <|unk|> (onbekend).

In het Engels werkt deze aanpak redelijk, omdat Engelse woorden over het algemeen kort en vormvast zijn (dog, walk, small).

In het Nederlands liep deze aanpak echter direct vast:

  1. Verkleinwoorden: Het woordenboek bevatte het woord vogel, maar in kinderteksten staat vrijwel altijd vogeltje. Het model kende vogeltje niet en liep vast.
  2. Verbuigingen: Het woordenboek bevatte droog, maar de tekst sprak over kurkdroge grond. Er was blij, maar het personage werd blijer.
  3. Samengestelde woorden: Typisch Nederlandse samenstellingen zoals zandpad, vogelhuisje of appelboom ontbraken in de top-800.

Het gevolg: ruim 90% van de gegenereerde verhalen werd afgekeurd omdat er onvermijdelijk onbekende woorden binnenslopen.

De oplossing: Legoblokjes (Byte-Pair Encoding)

Het rigide woordenboek werd daarop vervangen door Byte-Level BPE (Byte-Pair Encoding) met exact 800 tokens.

BPE deelt woorden op in logische lettergrepen en morfemische bouwstenen. Zie het als legoblokjes:

Het effect was doorslaggevend: met exact hetzelfde aantal parameters (800 getallen in de invoerlaag) daalde het percentage onbekende woorden naar 0,00%. Ieder denkbaar Nederlands woord kan nu foutloos samengesteld worden uit deze subwoord-bouwstenen.

De "Zadder"-Anekdote

Tijdens data-inspecties kwam een opmerkelijk fenomeen aan het licht. In verhaaltjes die zich afspeelden "op de zolder" met "een lange ladder", begon het ‘leraarmodel’ de twee woorden samen te smelten tot een niet-bestaand mengwoord: "de zadder":

"Daan zocht op de zadder. De hele zadder stond vol met oude dozen..."

Omdat vroege frequentietellingen blindelings op de ruwe data draaiden, belandde zadder prompt in de top-800 woordenlijst. Dit onderstreept een belangrijk principe: vertrouw nooit blind op geautomatiseerde filters zonder de data met eigen ogen te inspecteren.

4. Trainingsdata: Garbage in, Garbage out

Een AI-model is slechts zo goed als de data waarop het getraind wordt. Waar grote modellen getraind worden op een gigantische verzameling internetbronnen, was het doel hier specifiek: een kinderverhaal schrijven volgens een vaste vierdelige opzet:

  1. Inleiding / Doel
  2. Uitdaging
  3. Handeling
  4. Oplossing

Om trainingsdata van hoge kwaliteit te verkrijgen, genereerde een groot taalmodel (GLM 5.3 via GreenPT) duizenden verhalen volgens dit stramien. Om variatie aan te brengen, werden drie scenario-elementen in eerste instantie willekeurig gecombineerd:

Het mysterie van de verdwijnende emmer

Het model dat op deze dataset werd getraind, produceerde onsamenhangende verhaaltjes. Een verhaal begon met een rode emmer, maar halverwege loste een ladder plotseling het probleem op, of veranderde de emmer uit het niets in een hamer.

Een geautomatiseerde kwaliteitsmeting toonde aan dat 72,4% van de gegenereerde verhalen faalde op basale verhaallogica.

De oorzaak bleek niet in het kleine model te liggen, maar in de trainingsdata. Wanneer het grote ‘leraarmodel’ de opdracht kreeg: "Schrijf een verhaal met een rode emmer, waarin de vlieger vastzit in een hoge boom", kon het die situatie logischerwijs niet oplossen met een emmer. Het leraarmodel smokkelde daarom simpelweg een ladder naar binnen:

"Daan had een rode emmer. Maar de vlieger zat hoog in de boom. Daan pakte een lange ladder en klom naar boven. De vlieger was vrij!"

Het kleine model deed precies waar het voor ontworpen was: het leerde dat het volstrekt acceptabel is om bij tegenslag willekeurige nieuwe objecten op te voeren en het oorspronkelijke voorwerp te vergeten.

De oplossing: de compatibiliteitsmatrix

In plaats van een groter model te bouwen, werd de bron aangepakt met een strikte compatibiliteitsmatrix:

Zonder ook maar één parameter aan het model toe te voegen, steeg de logische consistentie van de verhalen direct van 0,45 naar 0,932.

Data is het fundament van elk AI-traject. Als de data tegenstrijdigheden bevat, leert het model van die fouten en neemt ze feilloos over.

5. Training: wat gebeurt er onder de motorkap?

In essentie is een taalmodel een bestand vol tabellen (matrices) met getallen. Bij het draaien van het model wordt de getokeniseerde tekst door deze tabellen geleid om te bepalen welk getal (woorddeel) het meest waarschijnlijke vervolg is.

Het principe: Next-Token Prediction

Het leermechanisme draait volledig om het voorspellen van het volgende stukje tekst. Krijgt het model de zin:

"Daan sloeg met de hamer op de losse..."

dan berekent het netwerk voor alle 800 tokens een waarschijnlijkheidsscore. In het begin zijn de getallen willekeurig en gokt het model bijvoorbeeld "aardbei".

Tijdens de training wordt die uitkomst vergeleken met de werkelijke tekst ("spijkers"). Het verschil tussen de voorspelling en de waarheid heet het verlies (loss). Via wiskundige optimalisatie (backpropagation) worden alle 71.000 getallen in de tabellen fractioneel bijgesteld, zodat de kans op het correcte woord de volgende keer groter is.

Waarom 1 laag vastliep en 2 lagen de doorbraak brachten

Toen het model getraind werd op 10.000 consistente verhalen, diende zich een nieuw knelpunt aan: het model bleef hangen in herhalingen ("de plank lag los en het hek zat vast en het hek zat vast...").

Dit fenomeen heet superpositie: in één enkele laag moesten dezelfde getallen tegelijkertijd Nederlandse grammatica waarborgen én de overgangen tussen inleiding, uitdaging, handeling en oplossing bijhouden. Die dubbele belasting oversteeg de wiskundige capaciteit van één laag.

De oplossing werd Model 2: het netwerk werd opgesplitst in twee fysieke lagen (elk twee keer herhaald):

Hierdoor daalde de perplexiteit (de statistische onzekerheid van het model) spectaculair van 11,4 naar 3,46, waardoor het model scherpe en logische verhaaltjes kon neerzetten.

Wat is hiervoor praktisch nodig?

Waar grote modellen enorme energiebudgetten vragen, bleef de benodigde rekenkracht hier opmerkelijk bescheiden:

6. Inference: slimme trucs om fouten te corrigeren

Inference is de fase waarin het model daadwerkelijk aan het werk wordt gezet. De training is voltooid, de getallen staan vast en het model genereert zelfstandig tekst op basis van een prompt:

[LOC: in de schuur] [OBJ: een oude hamer] [OBS: de houten plank lag scheef]
<|goal|>

Tijdens deze fase kwam een typische eigenschap van kleine modellen naar voren: niet weten wanneer het verhaal klaar is.

Het probleem: doorbabbelen na de ontknoping

Het model schreef een prima verhaaltje in vier zinnen:

"Daan was in de schuur met een oude hamer... Daan sloeg op de spijkers... De plank lag weer stevig en Daan ging blij zitten."

Vervolgens ging het model echter onverstoorbaar verder:

"...en Daan lachte blij en Sanne kwam binnen en Daan lachte en Daan ging blij..."

Dit is feitelijk ook weer te herleiden naar trainingsdata: een verhaaltje telt circa 80 woorden, terwijl het trainingsvenster 128 tokens lang was. Het stopsignaal (<|end_story|>) kwam daardoor in amper 1% van de data voor. Voor het model voelt een gangbaar voegwoord zoals "en" statistisch veiliger dan het beëindigen van de tekst.

Twee gerichte correcties tijdens de inferentie

In plaats van een groter model te trainen, werd deze actie direct gecorrigeerd in de aansturing tijdens het genereren:

  1. 3-Gram Repetition Penalty: Het systeem houdt bij welke twee opeenvolgende tokens al zijn gebruikt. Dreigt het model hetzelfde derde token opnieuw te kiezen? Dan wordt de kans op dat token per direct op nul gezet (−∞). Herhalingen en haperingen zijn daarmee uitgesloten.
  2. FSM (Finite State Machine) Decoding: Een lichtgewicht regelsysteem kijkt mee tijdens het genereren. Zodra het model het onderdeel <|outcome|> (de oplossing) bereikt en minimaal zes woorden heeft geschreven, stopt het algoritme exact bij de eerstvolgende punt (.) of het eerstvolgende uitroepteken (!). Eventuele achterblijvende voegwoorden ("en", "zodat") worden automatisch afgekapt.

Het eindresultaat is een strak, afgerond kinderverhaal:

"Daan was in de schuur met een oude hamer die van opa was geweest. De houten plank van het bankje lag scheef en de spijkers staken omhoog, zodat Daan er niet op kon zitten. Daan legde de plank recht en sloeg voorzichtig met de oude hamer op de losse spijkers, tik, tik, tik. De plank lag nu stevig en Daan ging blij op het bankje zitten."

7. Conclusie over het model: wat kan 71k parameters wel en niet?

Dit experiment toont aan dat een model van 71.000 parameters—slechts 279 kilobyte—uitstekend in staat is om:

Tegelijkertijd zijn de grenzen helder:

Het model is dus geen alleskunner, maar een uiterst scherpe specialist.

8. Praktische overwegingen: waar ligt de waarde van micro-modellen?

Een model dat uitsluitend kinderverhaaltjes van vier zinnen schrijft, is uiteraard een uitgesproken niche-toepassing. Niemand heeft een standalone neuraal netwerk nodig puur voor een verhaaltje over een hamer en een plank.

De achterliggende les is echter buitengewoon relevant voor organisaties en ontwikkelaars:

Veel bedrijfsprocessen draaien niet om brede creativiteit of wereldwijde encyclopedische kennis. Ze vragen om strikte, afgebakende taken:

Voor dat soort taken worden nu vaak zware, energieverslindende cloudmodellen aangeroepen. Een compact, gespecialiseerd model dat lokaal op het apparaat van de eindgebruiker draait biedt daarentegen:

Denk mee over gespecialiseerde AI

Dit project was een verkenning naar de uiterste ondergrens van taalmodellen: hoe klein kun je gaan voordat de logica breekt?

Ik ben bijzonder benieuwd waar volgens jou de grootste kansen liggen voor dit soort hyper-gespecialiseerde micro-modellen. Zie je binnen jouw organisatie processen waar een klein, lokaal model een zwaar cloud-LLM zou kunnen vervangen?

Wil je sparren over de praktische inzet van AI, loop je tegen een specifiek datavraagstuk aan, of wil je de volgende stappen in deze ontdekkingsreis volgen? Neem gerust contact met me op via LinkedIn of stuur een bericht—ik ga graag het gesprek aan.

Modellen en Datasets bekijken

Het model draait live op deze website: probeer MacroStories in je browser.

De getrainde modelgewichten en datasets zijn beschikbaar op Hugging Face:

Blijf op de hoogte

Ik mail je als het volgende experiment klaarstaat. Geen vaste frequentie, geen spam.

Meld je aan Volg me op LinkedIn

← Terug naar alle berichten