Hoe werkt een taalmodel? De bouwblokken van ChatGPT uitgelegd

Een taalmodel zoals ChatGPT of Claude knipt tekst op in stukjes (tokens), zet die om in getallen en voorspelt dan steeds welk stukje het waarschijnlijkst volgt. Een mechanisme dat attention heet bepaalt welke eerdere woorden voor die voorspelling tellen, en training op enorme hoeveelheden tekst levert de patronen waarop het model voorspelt. Alles hieronder is uitgelegd met analogieën, zonder code of formules.

Update 25 september 2026Enkele passages zijn preciezer gemaakt: de vuistregel van 0,75 woord per token geldt voor Engels, niet voor Nederlands; GPT-4 trainen kostte volgens OpenAI-topman Sam Altman meer dan 100 miljoen dollar (Wired); en training bestaat na de pre-training uit meer dan alleen RLHF. Ook de tip over het herhalen van een vraag is gecorrigeerd.

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. Zoek je eerst het grote plaatje, begin dan bij Kunstmatige intelligentie: wat AI wel en niet is. Een beschouwende versie van dit verhaal staat in Geen geest in de machine.

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 tot honderdduizenden 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-tipDat 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: arXiv). 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.

GevorderdenModerne 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 een klassiek transformer-blok bevatten de feedforward-lagen ongeveer twee derde van de parameters.

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-tipJe 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 volgens OpenAI-topman Sam Altman meer dan 100 miljoen dollar (Bron: Wired). Hoe zo’n training over duizenden chips tegelijk wordt verdeeld, lees je in Hoe train je een AI-model op duizenden GPU’s tegelijk?

Stap 2: bijschaven tot assistent. Eerst krijgt het model voorbeeldgesprekken te zien van hoe een goed antwoord eruitziet (supervised fine-tuning). Daarna volgt RLHF (Reinforcement Learning from Human Feedback): mensen beoordelen paren van modelantwoorden op kwaliteit, en het model leert welke antwoorden als “goed” worden gezien. Nieuwere modellen krijgen daarnaast extra training op taken met een controleerbaar antwoord, zoals rekensommen en code. Deze stap verandert een ruw taalmodel in een bruikbare assistent: behulpzamer en veiliger.

Wie een taalmodel van scratch bouwt in PyTorch doorloopt dezelfde structuur: embedding → attention → feedforward → normalisatie, gestapeld en getraind op een kleine dataset (Bron: Towards AI; LLMs-from-scratch). 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 Engelse woorden “in het oog houden”, maar hoe voller dat venster, hoe groter de kans dat informatie ertussenin over het hoofd wordt gezien. 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 lost weinig op. Stel je na een fout dezelfde vraag opnieuw, dan krijg je door het ingebouwde toeval wel een iets andere formulering, maar de onderliggende fout komt vaak terug. 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.

Stand van zaken — bijgewerkt 2026-09-25

De uitleg hierboven verandert niet met elk nieuw model. De getallen hieronder wel.