Grote taalmodellen zijn opgebouwd uit veel technische onderdelen, maar het centrale idee is niet mysterieus. Een model krijgt een reeks tokens, zet die tokens om in vectoren, laat elke token informatie lezen uit andere tokens, verwerkt het resultaat met geleerde lagen en produceert scores voor welke token daarna waarschijnlijk komt. De transformerarchitectuur maakte dat proces uitzonderlijk schaalbaar omdat de belangrijkste communicatiestap self-attention is in plaats van recurrentie.

In oudere recurrente neurale netwerken werd tekst stap voor stap verwerkt. De representatie na woord 12 hing af van de representatie na woord 11, die weer afhing van woord 10, enzovoort. Die sequentiële afhankelijkheid maakte lange-afstandscontext moeilijker vast te houden en beperkte ook parallelisme tijdens training. Transformers veranderden de vorm van de berekening. In plaats van een verborgen toestand woord voor woord door de zin te schuiven, kan elke token zichzelf vergelijken met elke andere token in dezelfde laag. Die vergelijkingen produceren attention weights, en die gewichten bepalen hoeveel informatie van elke token naar elke andere token stroomt.

Dit artikel richt zich op het kernmechanisme achter die verschuiving. Het probeert niet elk detail van productie-LLM’s, trainingsinfrastructuur, tokenizers, reinforcement learning of retrieval te behandelen. Het doel is om het transformerblok zelf makkelijker te doorgronden: tokens worden vectoren, attention mengt informatie over posities heen, feed-forward-lagen verfijnen elke positie, en de laatste vector produceert next-token probabilities.

Tokens Worden Vectoren

Een transformer verwerkt woorden niet direct als strings. Hij verwerkt tokens, stukjes tekst uit een vocabulaire. Een token kan een heel woord zijn, een deel van een woord, interpunctie, een witruimte-achtige structuur of een ander geleerd tekstfragment, afhankelijk van de tokenizer. Voor een conceptuele uitleg is het prima om eerst te denken aan één woord per token, zolang je onthoudt dat echte LLM-tokenisatie fijner is.

Elke token wordt omgezet naar een embeddingvector. De embedding is een lijst getallen die tijdens training wordt geleerd. Nabije richtingen in deze vectorruimte komen vaak overeen met nuttige patronen: onderwerp, grammaticale rol, stijl, entiteitstype of andere eigenschappen die helpen om tekst te voorspellen. Het model bewaart niet één handgeschreven definitie per token. Het leert numerieke coördinaten die nuttig zijn voor de taak om de volgende token in veel contexten te voorspellen.

Dezelfde token kan in veel verschillende contexten voorkomen, dus de initiële embedding is alleen een startpunt. Het woord “bank” in “river bank” en “bank account” begint met dezelfde tokenembedding, maar kan na attention-lagen verschillende contextuele informatie dragen. Die contextualisering is een van de belangrijkste taken van de transformerstack.

Positie Moet Worden Toegevoegd

Self-attention vergelijkt tokens als een verzameling vectoren. Op zichzelf weet die vergelijking niet of een token eerst, laatst of ergens in het midden kwam. Taal hangt af van volgorde, dus transformers voegen positie-informatie toe aan de tokenrepresentatie.

Daarvoor bestaan verschillende methoden. Sommige modellen voegen geleerde positie-embeddings toe. Andere gebruiken sinusvormige patronen. Veel moderne architecturen gebruiken relatieve of rotary position-methoden die attention-vergelijkingen direct beïnvloeden. De details verschillen, maar de reden is hetzelfde: het model heeft een manier nodig om “the dog bit the man” te onderscheiden van “the man bit the dog.” De woorden zijn hetzelfde, maar de posities veranderen de betekenis.

Zodra token- en positie-informatie zijn gecombineerd, heeft elke positie een vector die ongeveer zegt: dit is de token, en dit is waar die token in de reeks staat. Die vector wordt de invoer voor attention.

Attention Laat Eén Token Andere Tokens Lezen

De eenvoudigste manier om attention te begrijpen is om één token te kiezen en te vragen uit welke andere tokens die moet lezen. Als de zin “The cat sat on the mat because it was warm” is, kan de token “it” informatie nodig hebben uit “mat” of “cat”, afhankelijk van de bedoelde betekenis. Attention geeft het model een flexibele manier om invloed te verdelen, in plaats van elke positie te dwingen dezelfde vaste buurt te gebruiken.

Klik in de visualisatie hieronder op een token in de zin. De gebogen lijnen laten zien hoe sterk die token uit de andere tokens leest. De gewichten hier zijn verklarend en komen niet uit een getrainde LLM, maar ze behouden de structuur die ertoe doet: voor één geselecteerde token tellen de gewichten over brontokens op tot één, en sterkere gewichten dragen meer bij aan de nieuwe representatie. Deze eerste diagram laat zien wat attention weights doen nadat ze zijn berekend. De volgende sectie legt uit hoe een echte attention head zulke gewichten produceert uit query-key-vergelijkingen.

Dit is de kernbewerking: elke token bouwt een gewogen mengsel van informatie uit de reeks. De geselecteerde token kopieert niet precies één andere token. Hij ontvangt een mengsel. Een deel van het gewicht kan op zichzelf blijven. Een deel kan naar naburige woorden gaan. Een deel kan naar een zelfstandig naamwoord, werkwoord, scheidingsteken of eerdere frase gaan die helpt om de huidige positie te interpreteren.

Dat maakt attention anders dan een vast lokaal filter. Convolutie, besproken in convolutie en filtering voor afbeeldingen en signalen, gebruikt een vast kernelpatroon dat over de invoer schuift. Attention berekent een nieuw patroon uit de inhoud van de tokens zelf. Beide zijn gewogen sommen, maar convolutie gebruikt meestal vaste lokale gewichten, terwijl attention data-afhankelijke gewichten gebruikt die verre posities direct kunnen verbinden.

Query-, Key- en Value-Vectoren

De termen query, key en value klinken abstracter dan de bewerking eigenlijk is. De vorige visualisatie liet een rij attention weights zien als zichtbaar resultaat. Ze gebruikte niet exact dezelfde numerieke gewichten als de geometrische visualisatie hieronder; beide diagrammen gebruiken aparte vereenvoudigde voorbeelden om hetzelfde mechanisme op verschillende niveaus te tonen. Voor elke token leert het model drie projecties van zijn huidige vector:

• de query vraagt waar deze positie naar zoekt
• de key beschrijft waarop deze positie gematcht kan worden
• de value bevat de informatie die deze positie bijdraagt als een andere token ernaar kijkt

Voor één token die uit de reeks leest, vergelijkt het model zijn query met elke key. Een grotere query-key-match geeft een grotere score. Die scores gaan door softmax, die ze omzet in attention weights. De gewichten worden daarna gebruikt om de value-vectoren te middelen.

Wiskundig ziet een veelvoorkomend single-head-attentionpatroon er zo uit:

$$\mathrm{Attention}(Q, K, V) = \mathrm{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$

De matrix $QK^T$ bevat query-key-dotproducten. De schaalterm $\sqrt{d_k}$ voorkomt dat de scores te groot worden wanneer de vectordimensies groeien. Softmax zet elke rij scores om in een kansachtige gewichtsverdeling. Vermenigvuldiging met $V$ vormt daarna het gewogen mengsel van value-vectoren.

De volgende visualisatie toont hetzelfde idee geometrisch. Sleep de querypijl en kijk hoe het dotproduct met elke key verandert. Keys die in een vergelijkbare richting wijzen krijgen grotere scores, en softmax zet die scores om in de attention weights rechts.

Het belangrijke onderscheid is dat keys en values verschillende taken hebben. Een key wordt gebruikt om te beslissen waar te lezen. Een value is wat wordt gelezen en gemengd nadat die beslissing is genomen. Die scheiding laat het model matchingkenmerken en meegedragen informatie onafhankelijk leren. Een token kan makkelijk te matchen zijn omdat hij een bepaalde grammaticale rol heeft, terwijl zijn value-vector semantische details draagt die later nodig zijn.

Multi-Head Attention Leest Meerdere Soorten Context

Een enkele attention head produceert één set gewichten. Dat is nuttig, maar taal heeft vaak meerdere relaties tegelijk nodig. Eén head kan focussen op nabije syntaxis. Een andere kan een voornaamwoord verbinden met een zelfstandig naamwoord. Weer een andere kan interpunctie, frasegrenzen of instructiestructuur volgen.

Multi-head attention doet dit door meerdere attention-mechanismen parallel uit te voeren. Elke head heeft zijn eigen geleerde query-, key- en value-projecties. De heads produceren verschillende value-mengsels, en die mengsels worden gecombineerd tot de volgende representatie.

Dit is niet alleen een visuele handigheid. Het is een reden waarom transformerlagen rijke relaties kunnen representeren. In plaats van één attention-verdeling te vragen om elke afhankelijkheid in een zin te vangen, kan het model het werk verdelen over heads. Heads komen niet gegarandeerd netjes overeen met menselijk leesbare categorieën, en echte modellen bevatten vaak heads waarvan het gedrag moeilijk samen te vatten is. Toch is het technische doel duidelijk: parallelle attention heads geven de laag meerdere geleerde manieren om informatie door de reeks te verplaatsen.

Attention Vervangt Recurrentie Door Parallelle Communicatie

Het oorspronkelijke transformerontwerp was belangrijk omdat het de recurrente bottleneck uit sequentiemodellering haalde. In een recurrent model hangt token 50 af van de verborgen toestand van token 49, waardoor training een onvermijdelijk sequentieel pad door de tijd heeft. In een transformerlaag kunnen alle token-naar-token-attentionscores voor een reeks worden berekend met grote matrixvermenigvuldigingen. Die matrixvermenigvuldigingen draaien efficiënt op GPU’s en andere acceleratorhardware.

Dat betekent niet dat transformers gratis zijn. Volledige self-attention over een reeks heeft kosten die grofweg kwadratisch groeien met de reekslengte, omdat elke token met elke andere token kan vergelijken. Long-context-modellen hebben daarom zorgvuldige engineering nodig, gespecialiseerde attention-varianten, caching tijdens generatie en geheugenefficiënte kernels. Maar de basistransformer was nog steeds een grote schaalverbetering omdat hij de dominante trainingsberekening sterk parallel maakte.

Het resultaat is een nuttige afweging: attention besteedt meer rekenwerk aan het direct vergelijken van posities, maar biedt die berekening aan in een vorm die hardware efficiënt kan verwerken. Die hardwarevriendelijke structuur is een reden waarom transformers de basis werden voor moderne LLM’s.

De Feed-Forward-Laag Verfijnt Elke Positie

Attention is de communicatiestap, maar niet het hele transformerblok. Nadat attention informatie over posities heen mengt, gaat elke positie meestal door een feed-forward-netwerk. Dit deel wordt onafhankelijk toegepast op elke tokenpositie. Het verplaatst informatie niet direct tussen tokens. In plaats daarvan transformeert het de representatie op elke positie nadat attention daar al relevante context naartoe heeft gebracht.

Een standaard transformerblok gebruikt ook residual connections en normalisatie. Een residual connection telt de blokinvoer op bij de blokuitvoer, wat optimalisatie makkelijker maakt en informatie door veel lagen helpt stromen. Normalisatie houdt activaties binnen een beheersbaar bereik. Die details zijn niet cosmetisch; diepe transformerstacks vertrouwen erop voor stabiele training. Maar conceptueel is het ritme van het blok eenvoudig: meng informatie tussen tokens met attention, en verwerk daarna elke positie met een geleerde feed-forward-transformatie.

Veel blokken stapelen herhaalt dat ritme. Vroege lagen kunnen lokale syntactische en lexicale kenmerken opbouwen. Middenlagen kunnen frases en entiteiten combineren. Latere lagen kunnen representaties vormen die direct nuttig zijn om de voortzetting te voorspellen. Dit is een ruwe intuïtie, geen strikte regel, maar het verklaart waarom een transformer meer is dan één attention map. Het model werkt elke tokenrepresentatie herhaaldelijk bij in context.

Van Laatste Vector Naar Next-Token Probabilities

Taalmodellen worden getraind om tokens te voorspellen. Tijdens generatie ontvangt het model de huidige context en produceert het een vector op de laatste positie. Die vector wordt geprojecteerd naar één score per token in het vocabulaire. Deze ruwe scores heten logits.

Logits zijn nog geen kansen. Een logit kan elk reëel getal zijn. Softmax zet logits om in probabilities door ze te exponentiëren en te normaliseren:

$$P(t_i) = \frac{e^{z_i / T}}{\sum_j e^{z_j / T}}$$

Hier is $z_i$ de logit voor token $t_i$, en $T$ is temperature. Een lagere temperature maakt de verdeling scherper, waardoor opties met de hoogste logit domineren. Een hogere temperature maakt de verdeling vlakker, waardoor minder waarschijnlijke tokens meer kans krijgen.

De stepper hieronder volgt het hele pad op vereenvoudigde schaal. Klik op elke stap om van tokenembeddings naar next-token probabilities te gaan. Het voorbeeld houdt één context vast, zodat de visualisatie kan focussen op hoe de representatie logits wordt en daarna probabilities.

Echte LLM’s gebruiken enorme vocabulaires en veel lagen, dus de weergegeven kandidatenlijst is klein vergeleken met productiemodellen. De structuur is wel hetzelfde. Het model zoekt niet in een database met voltooide antwoorden. Het berekent herhaaldelijk een kansverdeling voor de volgende token, kiest of samplet een token volgens een decodingregel, voegt die token toe aan de context en voert het proces opnieuw uit.

Deze herhaalde next-token prediction kan lange, coherente tekst opleveren omdat de context blijft groeien. Elke nieuwe token wordt onderdeel van de invoer voor de volgende stap. Attention geeft toekomstige posities vervolgens toegang tot eerdere woorden, instructies, namen, codesymbolen en gedeeltelijke redeneersporen binnen het contextvenster.

Causal Masking Tijdens Generatie

Eén detail is belangrijk voor taalgeneratie: bij het voorspellen van de volgende token mag het model niet in de toekomst kijken. Trainingsvoorbeelden bevatten volledige tekstreeksen, maar de voorspelling op positie 10 mag alleen afhangen van posities 1 tot en met 9. Transformers dwingen dit af met een causal mask. Het masker voorkomt dat een token tijdens taalmodeltraining en generatie naar latere tokens attendt.

Zonder dit masker zou het model tijdens training kunnen valsspelen door de antwoordtoken direct te lezen. Met het masker leert elke positie de volgende token te voorspellen uit de prefix die ervoor beschikbaar is. Daarom worden decoder-only transformers voor veel LLM’s vaak causal language models genoemd. Het attentionmechanisme blijft self-attention, maar de toegestane verbindingen zijn beperkt zodat informatie alleen van eerdere posities naar latere posities stroomt.

Encoderachtige transformers, zoals modellen voor sommige classificatie- of embeddingtaken, kunnen tokens bidirectioneel laten attendten omdat ze niet op dezelfde manier worden getraind om de volgende token te genereren. Het attentionmechanisme is hetzelfde, maar het masker en de doelstelling veranderen het gedrag.

Wat Attention Wel en Niet Verklaart

Attention is het centrale communicatiemechanisme, maar niet de volledige verklaring voor LLM-gedrag. Tokenisatie beïnvloedt wat het model ziet. Trainingsdata bepaalt welke patronen beschikbaar zijn om te leren. Optimalisatie, schaal, architectuurdetails, normalisatie, activatiefuncties, contextlengte, decodinginstellingen en post-training vormen allemaal het uiteindelijke systeem.

Toch is attention de juiste plek om te beginnen omdat het verklaart hoe het model contextuele representaties bouwt. Elke token begint als een vector. Positie-informatie geeft het model reeksvolgorde. Query-key-vergelijkingen bepalen hoe sterk elke token uit andere tokens leest. Value-vectoren dragen de informatie die wordt gemengd. Feed-forward-lagen verfijnen elke positie. Logits en softmax zetten de laatste representatie om in een next-token-verdeling.

Zodra die pipeline duidelijk is, worden veel verklaringen van LLM’s makkelijker te plaatsen. “Het model gebruikt context” betekent dat attention informatie uit eerdere tokens naar de huidige representatie kan verplaatsen. “Het model voorspelt de volgende token” betekent dat de laatste vector wordt omgezet in logits over het vocabulaire. “Het model schaalt goed” betekent deels dat de transformer een sequentieel recurrentiepad vervangt door parallelle matrixbewerkingen over de reeks.

Samenvatting

Transformers maakten moderne LLM’s praktisch omdat self-attention elke token een flexibele manier geeft om uit andere tokens te lezen, terwijl training sterk parallel blijft. Het mechanisme kan in een paar stappen worden samengevat:

1. Tekst wordt opgesplitst in tokens.
2. Tokens worden embeddingvectoren, en positie-informatie wordt toegevoegd.
3. Elke token vormt query-, key- en value-vectoren.
4. Query-key-scores worden attention weights.
5. Attention weights mengen value-vectoren tot contextuele representaties.
6. Feed-forward-lagen verfijnen elke positie.
7. De laatste positie produceert logits, en softmax zet die om in next-token probabilities.

Het essentiële mentale model is gewogen informatiestroom. Attention laat een token niet op magische wijze de hele zin begrijpen. Het geeft het model een geleerde, inhoudsafhankelijke manier om te bepalen welke andere tokens in elke laag belangrijk zijn. Stapel die bewerking vaak, train haar op grote tekstcorpora, en je krijgt de centrale architectuur achter de grote taalmodellen van vandaag.