Voor wie is dit artikel?Voor iedereen die ChatGPT of Claude dagelijks gebruikt en wil begrijpen wat er eigenlijk achter de schermen gebeurt — zonder code te hoeven schrijven of wiskundige formules te hoeven ontcijferen. We gebruiken analogieën en concrete voorbeelden. Aan het einde kom je de technische termen wél tegen, zodat je ze herkent als je ze verder tegenkomt.
Je hebt het misschien zelf al geprobeerd: een taalmodel een moeilijke vraag stellen en kijken wat er terugkomt. Soms verbluffend goed. Soms overtuigend fout. En altijd met die vreemde zekerheid van iemand die niet weet dat hij het mis heeft. Dat gedrag is geen bug en geen mysterie — het volgt rechtstreeks uit hoe de architectuur werkt. Als je dat begrijpt, gebruik je deze tools anders.
Van woorden naar getallen
Het eerste waar een taalmodel mee begint, is een probleem: tekst is voor mensen leesbaar, maar computers kunnen er niet mee rekenen. Daarom is er een stap die altijd vooraf gaat aan alles: de tokenizer splitst de tekst op in tokens — stukjes van woorden — en zet elk token om in een getal.
“Jij vraagt dit aan ChatGPT” wordt iets als [12, 4832, 19, 1234, 8841]. Elk getal verwijst naar een positie in een woordenboek van de tokenizer. Dat woordenboek bevat tienduizenden tokens: veelgebruikte woorden als geheel, zeldzame woorden opgesplitst in stukjes. Het model rekent uitsluitend met die getallen — het heeft geen ‘begrip’ van taal in de zin die wij kennen.
Beginner-tip:Dat een taalmodel werkt met getallen is ook waarom het soms vreemde fouten maakt op eenvoudige rekensommen. Het model heeft geleerd welk getal-als-token in tekst typisch volgt op een bepaalde berekening — maar het rekent niet echt. Een 4+4=9 is statistisch zeldzaam, maar voor een bepaald model met een specifiek rekensompatroon kan het voorkomen.
Vervolgens worden die getallen omgezet in embeddings: lange vectoren (lijsten van honderden of duizenden getallen) die coördinaten zijn in een wiskundige ruimte. Woorden die semantisch verwant zijn — “koning”, “koningin”, “vorst” — liggen in die ruimte dicht bij elkaar. De relaties in taal worden wiskundige afstanden.
Het attention-mechanisme: de kern van alles
Vóór 2017 werkten de beste taalmodellen sequentieel: woord voor woord, waarbij het model alleen een beperkt “geheugen” naar achteren had. Lange zinnen waren een probleem — het begin raakte verloren tegen de tijd dat het einde verwerkt werd.
De transformer-architectuur, beschreven in de paper Attention is All You Need (Google, 2017), veranderde dat (Bron: Inspireren met AI). Het centrale idee: self-attention. Bij het verwerken van elk token in de invoer berekent het model hoe relevant elk ander token is voor dat moment. Verwerkt het het woord “hij” in een zin, dan “kijkt” het model terug naar alle eerdere woorden om te bepalen naar wie “hij” verwijst — ook als dat tien woorden eerder staat.
Dat klinkt eenvoudig. De implementatie is dat niet. Elk attention-hoofd berekent drie matrices voor elk token: een query (wat zoek ik?), een key (wat bied ik aan?) en een value (wat geef ik mee als ik relevant ben?). Het model heeft meerdere van deze “hoofden” tegelijk, elk met andere gewichten — zodat het parallel verschillende soorten relaties (grammaticaal, thematisch, coreference) kan leggen.
Gevorderden:Moderne architecturen zoals die van Llama 3 en Qwen 3 gebruikenGrouped Query Attention(GQA): key- en value-hoofden worden gedeeld over meerdere query-hoofden. Dat scheelt aanzienlijk in geheugen tijdens inference, waardoor grotere context-vensters haalbaar worden op betaalbare hardware. Het is een van de redenen waarom Llama 3.3 70B met 128K context-venster lokaal op high-end consumer-hardware draait.
Wat er verder in een transformer-blok zit
Een volledig transformer-blok — de bouwsteen die in moderne modellen tientallen tot honderden keren gestapeld wordt — bestaat naast attention nog uit drie componenten:
Layer normalisatie zet de outputwaarden van elk token terug naar een gestandaardiseerde schaal na elke berekening. Zonder dit zouden de getallen na honderden rekenlagen ofwel exploderen naar astronomische waarden of instorten naar nul. Normalisatie houdt het model stabiel tijdens training.
Het feedforward-netwerk is een klein neuraal netwerk dat na de attention-laag op elk token afzonderlijk wordt toegepast. Waar attention relaties tussen tokens legt, werkt het feedforward-netwerk de individuele token-representatie verder uit — het verrijkt de embedding met meer abstracte, taak-specifieke patronen. In modellen zoals GPT-4 zijn de feedforward-lagen de grootste component qua geheugen.
Residual connections zijn korte “snelwegen” die de oorspronkelijke invoer van een blok optellen bij de uitvoer. Dat klinkt triviaal maar is cruciaal: in een diepe stapel van tientallen blokken zorgen die verbindingen ervoor dat leerbare signalen niet verdwijnen. Zonder ze was training van diepe netwerken vrijwel onmogelijk.
Beginner-tip:Je hoeft de wiskunde achter deze onderdelen niet te kennen om er gebruik van te maken. Maar als je de namen herkent — “attention”, “feedforward”, “normalisatie” — begrijp je ook wat documentatie bedoelt als het zegt dat “een model X attention-lagen heeft”. Meer lagen = meer capaciteit om complexe relaties te leren, maar ook meer geheugen en rekentijd.
Hoe een model leert — training in twee stappen
Een ongetraind taalmodel is een lege structuur: de gewichten zijn willekeurig en de output is ruis. Training vult die gewichten met patronen.
Stap 1 — pre-training: het model ziet biljoenen tokens tekst van het internet, boeken en andere bronnen. De opgave is simpel: voorspel het volgende token. Als de voorspelling fout is, worden de gewichten een klein beetje aangepast. Na genoeg herhalingen — miljarden — convergeert het model naar gewichten die taal statistisch goed beschrijven. Dit is het meest kostbare deel: GPT-4 trainen kostte naar schatting tientallen miljoenen dollars aan rekenkracht.
Stap 2 — RLHF (Reinforcement Learning from Human Feedback): mensen beoordelen paren van modelantwoorden op kwaliteit. Op basis van die beoordelingen leert het model welke antwoorden als “goed” worden gezien. Dit is de stap die een ruw taalmodel verandert in een bruikbare assistent — het maakt het model behulpzamer, minder geneigd te hallucineren, en veiliger.
Wie een taalmodel van scratch bouwt in PyTorch doorloopt exact dezelfde structuur: embedding → attention → feedforward → normalisatie, gestapeld en getraind op een kleine dataset (Bron: Towards AI). De schaal is anders, het principe identiek.
Wat dit betekent voor hoe je een taalmodel gebruikt
Als je de architectuur kent, vallen een aantal dingen op hun plek.
Context-vensters zijn echt beperkend. Een model met 128.000 tokens context kan grofweg 100.000 woorden “in oog houden” — maar aan de rand van dat venster neemt de aandacht voor het begin af. Werk je met hele lange documenten, splits ze dan logisch op of gebruik retrieval-augmented generation (RAG) waarbij het model alleen de relevante stukken binnenhaalt.
Herhalen helpt niet. Als een model een fout maakt en je dezelfde vraag opnieuw stelt, genereert het statistisch vrijwel hetzelfde antwoord. Verandering van aanpak werkt beter: vraag het model om stap voor stap te redeneren, geef meer context, of stel de vraag anders.
Taalmodellen zijn geen databases. Ze bevatten geen feiten in de zin van opgeslagen records — ze bevatten gewichten die bepaalde patronen reproduceren. Verifieer altijd claims met een primaire bron als het er echt op aankomt. Voor wie meer wil lezen over lokaal draaien van taalmodellen: onze uitleg over Ollama legt uit hoe je dezelfde architectuur op je eigen machine draait.