Deel A · Module 02
De transformer
Hoe wordt het volgende token voorspeld?
Leerdoelen
Na deze module kun je:
- voorspellen wat er met rekenwerk en geheugen gebeurt als je de contextlengte verdubbelt, en uitleggen wat een KV-cache daaraan verandert;
- uitleggen waarom een token in een decoder-only model alleen naar links kijkt, en wat er zou misgaan zonder dat causal mask;
- in een attention-matrix aflezen waar een token naar kijkt, en
attention(Q, K, V)zelf in numpy schrijven.
Voorkennis-check
Twee vragen over eerdere modules. Fout? Lees die module eerst terug.
Waar zitten we?
Laag 1 van de stack: het model zelf. In deze module open je de doos: wat gebeurt er tussen “tokens erin” en “kansen eruit”. Alles hogerop (API, loop, harness) gebruikt dit als een functie die tokens naar een kansverdeling afbeeldt.
De stof in drie lagen
Kern ± 5 min
Een taalmodel heeft één taak: gegeven alle tokens tot nu toe, geef een kansverdeling over het volgende token. Vertalen, code schrijven en vragen beantwoorden zijn geen aparte functies; het zijn teksten die je laat doorschrijven. De architectuur die dit doet in vrijwel alle moderne taalmodellen is de transformer, in de decoder-only variant: een stapel identieke blokken die tokens in vectoren omzet, die vectoren steeds verder verwerkt en aan het eind scores per mogelijk volgend token oplevert.
1. De forward pass in vogelvlucht
Eén forward pass is één keer rekenen van invoertokens naar kansen. Doorloop hieronder de zin “De kat zat op de”. Klik op een stap in de tijdlijn (of gebruik de pijltjestoetsen) en let op drie dingen: wat de vorm van de data is, in welk onderdeel je zit, en dat de vorm door de blokken heen gelijk blijft.
Samengevat: tokens → embeddings + positie → N × [self-attention → MLP] → logits → softmax. Rond elk onderdeel in het blok zit een residual connection (de uitvoer wordt opgeteld bij de invoer) en een layernorm (normalisatie). De eerste vraag bij elk model is dus: hoe groot is d_model (de breedte van de vectoren), hoeveel blokken zijn er, en hoe groot is het vocabulaire.
2. Self-attention: elk token stelt een vraag
Attention is het enige onderdeel waar tokens elkaar “zien”. Het idee, zonder wiskunde: elk token maakt drie dingen van zijn vector.
- Een query (Q): “waar zoek ik naar?” Het token zat zoekt bijvoorbeeld een onderwerp.
- Een key (K): “waar kun je mij voor gebruiken?” Het token kat biedt zich aan als onderwerp.
- Een value (V): “dit is mijn inhoud als je mij kiest”.
De query van elk token wordt vergeleken met de key van elk zichtbaar token. Een hoge score betekent: dit token is nu relevant. Softmax maakt van die scores gewichten die optellen tot 1, en het resultaat is een gewogen gemiddelde van de values. Daarmee heeft zat informatie van kat in zijn vector gekregen. De gewichten zijn dus geen vaste regel; ze worden voor elke invoer opnieuw berekend.
3. Causal masking: alleen terugkijken
Bij het voorspellen van het volgende token mag een token alleen naar tokens vóór en op zijn eigen plek kijken. Dat gebeurt met een masker dat alle toekomstige plekken uitschakelt (hun score wordt min oneindig, dus gewicht 0). In de matrix is dat de bovendriehoek. Zet het masker hieronder uit om te zien wat er dan gebeurt.
Wat je kunt proberen: kies per head een rij en kijk waar die naartoe kijkt. Zet dan het masker uit en kijk naar het gearceerde “antwoord”-vak: het token kijkt nu naar het woord dat het juist moet voorspellen. Tijdens training zou het model daardoor spieken en niets leren; tijdens genereren bestaat dat volgende token nog niet eens.
Multi-head: in plaats van één attention-berekening doet het model er tientallen naast elkaar (heads), elk met eigen Q/K/V-projecties. Elke head kan een ander soort relatie oppikken, zoals “het vorige token” of “het onderwerp”. De uitkomsten worden samengevoegd. Let op: de gewichten in deze visual zijn verzonnen om het mechanisme te laten zien; echte heads zijn minder netjes en niet altijd zo goed te benoemen.
4. Genereren: token voor token
Na de forward pass heb je een kansverdeling over het volgende token. Een sampler kiest er één uit (module A4), dat token wordt aan de invoer toegevoegd, en de forward pass begint opnieuw. Dit heet autoregressief genereren: de uitvoer van stap n is invoer van stap n+1. Een antwoord van 200 tokens is daarom ongeveer 200 opeenvolgende forward passes.
De brug naar agents: lengte kost iets
Elk token dat je in de context stopt, moet in de attention-berekening worden meegenomen door elk later token. Daardoor groeit het rekenwerk van attention kwadratisch met de contextlengte, en slaat het model per token tussenresultaten (de KV-cache) op die geheugen kosten. Voor een agent betekent dat: elke tool-output die in de context blijft staan, kost bij elke volgende stap opnieuw. Dat is de achtergrond van B4 (context als schaars goed) en van D5 (kosten). De details staan in de Verdieping.
Verdieping mechanisme en bronnen
Decoder-only, en waarom dat er niet altijd was
Het oorspronkelijke transformer-paper (2017) was gebouwd voor vertalen en had een encoder (leest de bronzin) en een decoder (schrijft de vertaling). Veel moderne taalmodellen laten de encoder weg. Het Anthropic-paper over transformer circuits maakt die keuze expliciet:
We focus on autoregressive, decoder-only transformer language models, such as GPT-3.
En de GPT-3-paper zegt over de eigen architectuur dat die gelijk is aan die van GPT-2, met één wijziging in de attention-patronen:
We use the same model and architecture as GPT-2 [117], including the modified initialization, pre-normalization, and reversible tokenization described therein, with the exception that we use alternating dense and locally banded sparse attention patterns in the layers of the transformer
Wat we niet weten: hoe Claude intern is opgebouwd (aantal lagen, breedte, attention-variant, parameteraantal) is in de gebruikte bronnen niet beschreven. Alle getallen in deze module komen daarom van open modellen (GPT-2, GPT-3) of zijn als illustratie aangeduid.
De residual stream: een gedeeld werkgeheugen
Het is nuttig om het blok niet als een pijplijn te zien maar als een gedeelde vector per token waar elk onderdeel in leest en aan toevoegt.
Each residual block consists of an attention layer, followed by an MLP layer.
Daarom blijft de vorm door alle blokken gelijk ([n × d_model]): elk blok schrijft zijn bijdrage bij de bestaande vector op. Attention verplaatst informatie tussen tokens; de MLP verwerkt de vector van elk token afzonderlijk (in het origineel “position-wise”). In GPT-3 is de interne laag van de MLP viermaal zo breed als d_model (GPT-3-paper).
Positie
Attention zelf is blind voor volgorde: schud je de tokens, dan krijg je dezelfde scores in andere volgorde. Daarom moet positie in de vectoren worden gestopt.
Since our model contains no recurrence and no convolution, in order for the model to make use of the order of the sequence, we must inject some information about the relative or absolute position of the tokens in the sequence.
Het origineel gebruikt vaste sinusvormige patronen; GPT-2 leert een positie-vector per plek (vandaar een vaste maximale lengte, 1024 tokens in de GPT-2-config van Hugging Face). Nieuwere modellen gebruiken andere varianten; dat valt buiten deze module.
Multi-head attention
Multi-head attention allows the model to jointly attend to information from different representation subspaces at different positions.
Een head werkt op een kleinere deelruimte: GPT-2 small heeft 12 heads bij d_model = 768, dus 64 dimensies per head (768 / 12). Dat de heads “onafhankelijk en additief” werken, is het uitgangspunt van de circuit-analyse door Anthropic. Een voorbeeld uit hetzelfde onderzoek: kleine modellen hebben vaak heads die naar het vorige token kijken.
We often see heads whose attention pattern attends to the previous token, but not heads who attend two tokens back
Waarom kwadratisch?
Bij n tokens heeft elke head per laag een matrix van n × n scores: elk token vergelijkt zijn query met de key van elk (zichtbaar) token. Verdubbel je n, dan wordt dat viermaal zoveel scores. Het paper zet dit af tegen recurrente lagen en noemt de complexiteit per laag voor self-attention O(n² · d). Dat is de basisvorm. Er zijn varianten die het beperken: de GPT-3-paper noemt “locally banded sparse attention”, en de Hugging Face-documentatie noemt sliding window attention (genoemd bij Mistral en Gemma 2), waarbij de cache stopt met groeien als het venster vol is.
KV-cache: niet opnieuw uitrekenen wat je al hebt
Bij autoregressief genereren komt er elke stap één token bij. De keys en values van alle eerdere tokens veranderen niet (door het causal masker kijken ze alleen naar hun eigen verleden). Die kun je dus bewaren in plaats van opnieuw uitrekenen:
A KV cache stores these calculations so they can be reused without recomputing them.
De afweging is geheugen tegen rekentijd. Een rekenvoorbeeld voor GPT-2 small (12 blokken, d_model = 768, uit de HF-config), met 16-bit getallen (2 bytes):
2 (K en V) × 12 blokken × 768 × 2 bytes = 36.864 bytes ≈ 36 KiB per token. Bij de volle contextlengte van 1024 tokens is dat ongeveer 36 MiB per sequentie. Grote modellen hebben meer blokken en bredere vectoren, dus per token veel meer. Dit is een eigen berekening op basis van de config, geen gemeten waarde; de precieze cache-grootte hangt af van de implementatie (bijvoorbeeld het aantal key/value-heads en de precisie).
Dit verklaart twee dingen die je in de praktijk ziet. Ten eerste de prefill (de prompt wordt in één keer parallel verwerkt) tegenover de decode (daarna token voor token). Ten tweede dat lange contexten geheugen kosten, ook als het rekenwerk per token meevalt. Hoe API-aanbieders daar prijzen en caching omheen bouwen, komt in D5; het effect van lange contexten op gedrag in B4.
Alle posities voorspellen tegelijk
De logits hebben vorm [n × vocab]: elke positie voorspelt zijn eigen volgende token. De documentatie van GPT-2 geeft het zo weer: “Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax)”, met een vorm (batch_size, sequence_length, config.vocab_size). Bij training gebruik je alle rijen (elke positie levert een leersignaal, in één pass); bij genereren alleen de laatste.
Onder de motorkap formule en numpy-implementatie
De formule
Scaled dot-product attention uit het paper van 2017:
Attention(Q, K, V) = softmax(Q Kᵀ / √d_k) V
Q,K,V: matrices met één rij per token ([n × d_k],V:[n × d_v]).Q Kᵀ: een[n × n]-matrix met alle query-bij-key-scores (dot products)./ √d_k: schaling. Zonder deze deling worden de scores bij groted_kgroot, en komt softmax in een gebied met bijna nul gradiënt terecht (zo beargumenteert het paper het; dit gaat over trainbaarheid).- softmax per rij: gewichten die optellen tot 1.
- causal masker: voor je softmax zet je de scores van toekomstige tokens op
-inf.
Multi-head: projecteer Q, K, V met h verschillende geleerde matrices, doe attention per head, plak de resultaten achter elkaar en projecteer nog eens. Het totale rekenwerk is vergelijkbaar met één head op volle breedte (zo staat het in het paper, omdat elke head een kleinere dimensie heeft).
Numpy-implementatie
attention.py
import numpy as np
def softmax(x):
x = x - x.max(axis=-1, keepdims=True) # numeriek stabiel
e = np.exp(x)
return e / e.sum(axis=-1, keepdims=True)
def attention(Q, K, V, causal=True):
d_k = K.shape[-1]
scores = Q @ K.T / np.sqrt(d_k)
if causal:
toekomst = np.triu(np.ones_like(scores), k=1) == 1
scores = np.where(toekomst, -np.inf, scores)
weights = softmax(scores)
return weights @ V, weights
- Trek het maximum per rij af. Het resultaat van softmax verandert niet, maar
expkan zo niet overlopen bij grote scores. - Alle dot products in één matrixproduct. Dit is de
[n × n]-matrix die kwadratisch groeit met de contextlengte. np.triu(..., k=1)selecteert alles boven de diagonaal: de toekomst. Die plekken krijgen-inf, dus naexpprecies 0. De diagonaal blijft: een token mag naar zichzelf kijken.- Softmax over de laatste as: elke rij (elke query) telt op tot 1.
- Het gewogen gemiddelde van de values, voor alle tokens tegelijk.
Edge cases en valkuilen
- Maskeren gebeurt voor de softmax, niet erna. Als je de gewichten achteraf op 0 zet, tellen de rijen niet meer op tot 1.
- Een volledig gemaskeerde rij (alles
-inf) geeftnan. In causal attention gebeurt dat niet omdat de diagonaal altijd zichtbaar is; bij padding wel. - Schalen met
d_k, niet metn: de factor hangt af van de dimensie van de keys, niet van de contextlengte.
Uitgewerkt voorbeeld: vier tokens, zelf narekenen
We nemen vier tokens, De kat zat op, met d_k = 2. De getallen voor Q, K en V zijn met de hand gekozen (een echt model leert ze), zodat zat naar kat zoekt: Q[zat] = [0, 2] en K[kat] = [0, 2]. Eerst de rij van zat met de hand, dan de hele matrix met de code uit de motorkap.
rij “zat”, met de hand
Q[zat] = [0, 2] K = [[1,0], [0,2], [1,0], [1,1]]
scores = Q[zat]·K / √2
= [0, 4, 0, 2] / 1.414 = [0, 2.83, 0, 1.41]
masker = [0, 2.83, 0, -inf] (op komt ná zat)
exp = [1.00, 16.92, 1.00, 0.00] som = 18.92
weights = [0.05, 0.89, 0.05, 0.00]
output = 0.05·V[De] + 0.89·V[kat] + 0.05·V[zat]
= [0.11, 0.95]
uitvoer van attention.py (Q, K, V als hierboven; V = [[1,0],[0,1],[1,1],[2,0]])
causal
De 1.00 0.00 0.00 0.00 -> 1.00 0.00
kat 0.20 0.80 0.00 0.00 -> 0.20 0.80
zat 0.05 0.89 0.05 0.00 -> 0.11 0.95
op 0.17 0.33 0.17 0.33 -> 1.00 0.50
rijen tellen op tot 1: True
zonder masker
De 0.29 0.14 0.29 0.29 -> 1.15 0.43
kat 0.12 0.51 0.12 0.25 -> 0.74 0.63
zat 0.04 0.73 0.04 0.18 -> 0.44 0.78
op 0.17 0.33 0.17 0.33 -> 1.00 0.50
rijen tellen op tot 1: True
- De dot product van de query met elke key, gedeeld door
√d_k = √2. kat scoort het hoogst, omdat zijn key overeenkomt met de query. - De laatste plek is op: dat token komt na zat, dus
-inf. Zijn score van 1.41 doet niet mee. - Softmax: bijna alle gewicht gaat naar kat, de rest van de massa verdeelt zich over De en zat.
- Het resultaat is vrijwel de value van kat: zat heeft nu de informatie van zijn onderwerp in zijn vector.
Wat je ziet bij het uitzetten van het masker: de rij van zat wijzigt omdat het nu ook op ziet (0.18), en de rijen van De en kat veranderen sterker. De laatste rij (op) blijft gelijk, want die zag al alles. Daarom is een causal masker geen detail: het bepaalt voor elk token welke informatie het mag gebruiken.
Implementeer attention en kijk in GPT-2
Opdracht A (± 20 min): attention in numpy
- Zorg voor Python 3 met numpy (
pip install numpy). - Schrijf de functie
attention(Q, K, V, causal=True)zonder te kopiëren uit de motorkap-sectie. Teruggeven: de uitvoer en de gewichten. - Test met deze invoer. De verwachte uitvoer staat in het uitklapblok:
Q = np.array([[1, 0], [0, 1], [0, 2], [1, 1]]) K = np.array([[1, 0], [0, 2], [1, 0], [1, 1]]) V = np.array([[1, 0], [0, 1], [1, 1], [2, 0]]) - Controleer met
np.allclose(weights.sum(axis=-1), 1)dat elke rij optelt tot 1, met en zonder masker. - Voorspel eerst, controleer dan: wat verandert er in de laatste rij als je
causal=Falsezet? En in de eerste? - Uitbreiding: maak er multi-head van. Splits
d_modelin 2 heads, draaiattentionper head en plak de uitvoer achter elkaar metnp.concatenate(..., axis=-1).
Opdracht B (± 30 min, optioneel): echte GPT-2
- Installeer
pip install torch transformers(de eerste keer wordt GPT-2 gedownload). - Draai en pas de zin aan:
import torch from transformers import AutoTokenizer, AutoModelForCausalLM tok = AutoTokenizer.from_pretrained("gpt2") model = AutoModelForCausalLM.from_pretrained("gpt2", attn_implementation="eager") inputs = tok("The cat sat on the", return_tensors="pt") with torch.no_grad(): out = model(**inputs, output_attentions=True) probs = out.logits[0, -1].softmax(dim=-1) # laatste positie top = probs.topk(5) for p, i in zip(top.values, top.indices): print(f"{tok.decode(i.item())!r:>10} {p:.3f}") att = out.attentions[5][0, 3] # blok 6, head 4: [5 x 5] print(att.sum(dim=-1)) # elke rij ~ 1 print(att.round(decimals=2)) - Kijk naar de vorm van
out.logitsenout.attentions. Wat is de vorm, en hoeveel blokken en heads zie je? Vergelijk met de getallen in de Verdieping (12 blokken, 12 heads, vocabulaire van 50.257). - Probeer een zin waarvan je het volgende woord zeker weet, en een zin waarbij het open is. Hoe verschilt de top-5?
Verwacht resultaat
A: de uitvoer van attention(Q, K, V) is (afgerond op 2 decimalen) [[1.00, 0.00], [0.20, 0.80], [0.11, 0.95], [1.00, 0.50]]; zonder masker [[1.15, 0.43], [0.74, 0.63], [0.44, 0.78], [1.00, 0.50]]. De laatste rij blijft gelijk, de overige veranderen. Rijen tellen op tot 1.
B: out.logits heeft vorm [1, 5, 50257] (vijf tokens voor deze zin; " cat" en " sat" zijn tokens met een spatie ervoor). out.attentions is een tuple van 12 tensors (één per blok) van vorm [1, 12, 5, 5] (12 heads). De top-5 bestaat uit plausibele woorden voor plekken waar een kat kan zitten, zoals ' floor', ' couch' of ' bed'; de precieze volgorde en kansen kun je niet uit dit document afleiden, probeer ze zelf uit. De aandachtsmatrix is onder de diagonaal gevuld en erboven 0.
Als het niet werkt, kijk naar …
- Rijen tellen niet op tot 1: je maskeert na de softmax in plaats van ervoor, of je neemt de som over de verkeerde as (
axis=-1is per rij). nanin de uitvoer: een rij heeft alleen-inf. Controleer dat je de diagonaal niet maskeert (k=1innp.triu).- Antwoord klopt net niet: vergeet de
/ np.sqrt(d_k)niet;d_kis hier 2. - B:
out.attentionsisNone: laad het model metattn_implementation="eager"; de snelle varianten geven geen gewichten terug. - B: je top-5 verschilt van het voorbeeld: dat is geen fout. Tokenizers en modelversies verschillen, en een spatie voor een woord is onderdeel van het token.
- B:
ModuleNotFoundError:pip install torch transformersin dezelfde omgeving als waar je Python draait.