Deel A · Module 01
Tokens & embeddings
Wat “ziet” een model eigenlijk?
Leerdoelen
Na deze module kun je:
- voorspellen hoeveel tokens een stuk tekst ongeveer kost (Nederlands tegenover Engels, code, getallen, witruimte) en wat dat betekent voor je contextvenster en je rekening;
- uitleggen waarom tokenizers subwoorden gebruiken (BPE) en wat een groter of kleiner vocabulaire verandert;
- uitleggen waarom een model letters slecht telt, en wat een embedding wel en niet is: een geleerde vector per token, opgezocht uit een tabel.
Voorkennis-check
Dit is de eerste module; de twee vragen gaan over algemene programmeerkennis die we gebruiken.
Waar zitten we?
Laag 1 van de stack: het model. Alles erboven (de API, de loop, de harness) stuurt tekst naar dit model en krijgt tekst terug. Deze module gaat over de eerste stap daarbinnen: hoe tekst een rij getallen wordt.
De stof in drie lagen
Kern ± 5 min
Een taalmodel is een functie op getallen. Tekst gaat er niet rechtstreeks in; er zit altijd een vertaalstap voor en na. Voor het model begint, gebeurt dit:
- Tokenisatie. De tekst wordt in stukjes geknipt, tokens genoemd. Een token is vaak een heel woord, soms een deel van een woord, soms één teken of een spatie plus een woord.
- Token-id's. Elk stukje staat in een vaste lijst (het vocabulaire) en heeft daarin een nummer: het token-id. De zin wordt een rij gehele getallen.
- Embeddings. Elk id is een rijnummer in een grote tabel. Die rij is een vector: een lijst van bijvoorbeeld 768 kommagetallen. Dat is wat de rest van het model daadwerkelijk te zien krijgt.
Language models don't see text like you and I, instead they see a sequence of numbers (known as tokens).
Waarom geen woorden of losse tekens? Woorden als eenheid geven een gigantisch vocabulaire en geen antwoord op een woord dat je nooit eerder zag. Losse tekens geven een klein vocabulaire maar erg lange rijen, en een enkel teken zegt het model weinig. Byte pair encoding (BPE) zit ertussenin: begin met losse tekens en smelt het paar dat het vaakst voorkomt steeds samen tot één nieuw stukje. Veelvoorkomende woorden worden één token, zeldzame woorden vallen uiteen in bekende brokken. Er bestaat dus geen woord dat niet te tokeniseren is.
Probeer het zelf. Deel a is een kleine BPE-tokenizer die in je browser getraind wordt. Sleep het aantal merges van 0 omhoog en kijk hoe losse tekens samensmelten. Vergelijk daarna het Nederlandse en het Engelse voorbeeld. Deel b toont embeddings: woorden als punten, waarbij klikken de buren laat zien.
Waarom dit voor een agent-bouwer telt. Alles wat je aan een model meegeeft of uit een tool terugkrijgt, wordt in tokens gemeten, niet in tekens of woorden. Het contextvenster (hoeveel het model in één keer kan lezen), de kosten per request en de rate limits zijn allemaal tokens. Een prompt in het Nederlands, een JSON-blob met veel witruimte of een log vol hexadecimale id's kan flink meer tokens kosten dan je op het oog schat. Hoe die ruimte vervolgens vol raakt en wat je eraan doet, staat in module B4; het geld komt terug in module D5.
Claude's eigen tokenizer is niet openbaar. In de Anthropic-documentatie vind ik geen downloadbare tokenizer, wel een count_tokens-endpoint dat je een prompt laat tellen voor een bepaald model. De getallen die je met open tokenizers (zoals tiktoken) meet, zijn dus een goede indicatie van het verschijnsel, maar geen exacte telling voor Claude.
Verdieping mechanisme en bronnen
Het probleem dat BPE oploste: een open vocabulaire
Sennrich et al. (2016) pasten een oude compressietechniek toe op vertaalmodellen. Hun uitgangspunt:
Neural machine translation (NMT) models typically operate with a fixed vocabulary, but translation is an open-vocabulary problem.
Een vaste lijst woorden is eindig, taal niet: samenstellingen, namen, typefouten, nieuwe woorden. Met subwoorden kan een vast vocabulaire toch elke tekst weergeven. Het algoritme is eenvoudig:
Byte Pair Encoding (BPE) [Gage (1994] is a simple data compression technique that iteratively replaces the most frequent pair of bytes in a sequence with a single, unused byte.
Training is dus tellen en samenvoegen, geen neuraal netwerk: tel alle naburige paren in het corpus, voeg het meest voorkomende paar overal samen tot een nieuw symbool, en herhaal. De volgorde van de merges is het hele “model” van de tokenizer. Tokeniseren is die merges in dezelfde volgorde afspelen op nieuwe tekst. Dat is wat de werkbank hierboven doet, en ook waarom hij per woord werkt: een merge gaat nooit over een woordgrens heen.
Vocabulairegrootte: een afweging
The final symbol vocabulary size is equal to the size of the initial vocabulary, plus the number of merge operations – the latter is the only hyperparameter of the algorithm.
Het aantal merges is dus een ontwerpkeuze, en je ziet de afweging aan de teller in de werkbank: meer merges geven minder tokens per tekst, maar een groter vocabulaire.
- Klein vocabulaire: lange rijen. Elk token kost rekenwerk en ruimte in het contextvenster, en het model moet over meer posities verbanden leggen (hoe dat werkt: A2).
- Groot vocabulaire: kortere rijen, maar een grotere embedding-tabel en een grotere uitvoerlaag (het model geeft aan het eind een score voor elk token in het vocabulaire). Zeldzame tokens komen in de trainingsdata zo weinig voor dat hun vectoren meestal slechter geleerd worden.
Concrete cijfers van drie open tokenizers uit het tiktoken-pakket (zelf gemeten met enc.n_vocab): GPT-2 50.257 tokens, cl100k_base 100.277, o200k_base 200.019. De trend in OpenAI's eigen encodings is dus: steeds groter. Voor GPT-2 small is de tabel zelf 50257 × 768 = 38.597.376 getallen (bron: de modelconfig), alleen om id's naar vectoren te vertalen. Wat Claude gebruikt is niet openbaar.
Bytes in plaats van tekens
Een tekenvocabulaire dat alle Unicode-tekens moet bevatten is groot. GPT-2 begon daarom met bytes:
This means you need a large # of unicode characters in your vocab if you want to avoid UNKs.
Als de basis 256 bytes zijn, kan elke tekst (ook emoji, Chinees of een kapotte bestandsinhoud) worden weergegeven zonder “onbekend”-token. De prijs: een teken buiten ASCII telt als 2 tot 4 bytes en dus kan meer tokens kosten, tenzij de merges het weer samenvoegen. Onze werkbank werkt voor de eenvoud op tekens; vandaar het gestippelde token met ? bij onbekende tekens.
Tokens zijn geen woorden
On average, in practice, each token corresponds to about 4 bytes.
“Ongeveer 4 bytes” geldt gemiddeld; de spreiding is groot, en dat is het punt. Gemeten met tiktoken, hetzelfde (vertaalde) zinnetje, 44 tekens Engels tegenover 47 tekens Nederlands:
| Encoding | Engels | Nederlands | Code (27 tekens) | Cijfers (16 tekens) |
|---|---|---|---|---|
gpt2 | 10 | 17 | 14 | 7 |
cl100k_base | 10 | 15 | 11 | 6 |
o200k_base | 10 | 13 | 11 | 6 |
Aantal tokens voor The quick brown fox jumps over the lazy dog., De snelle bruine vos springt over de luie hond., def f(x):\n return x + 1\n en 1234567890123456. Wat je eruit leest:
- Nederlands kost meer, omdat tokenizers vooral op Engelstalige data zijn gebouwd: Engelse woorden zijn vaker hele tokens, Nederlandse samenstellingen vallen in stukken. De kloof wordt kleiner met een groter vocabulaire (17, 15, 13 hierboven) maar verdwijnt niet in alle gevallen. Dit is één zin; meet je eigen teksten.
- Code is zuinig of duur afhankelijk van de tokenizer. De oude GPT-2-encoding betaalt voor elke spatie van een inspringing;
cl100k_basevoegt witruimte samen (11 tokens in plaats van 14). Witruimte in tool-output is dus niet gratis. - Getallen worden in blokken van maximaal drie cijfers geknipt, van links af (cl100k:
1234567wordt123|456|7, maar234567wordt234|567). Dezelfde cijfers kunnen dus in verschillende stukken vallen, wat rekenen met lange getallen lastig maakt.
Wat dit voor Claude betekent. De Anthropic-docs geven twee dingen aan die hierop aansluiten. Eerst dat de tokenizer per modelgeneratie kan verschillen:
Claude 4.7 and later models and Claude Mythos Preview use a newer tokenizer. The same input text produces approximately 30 percent more tokens than on earlier models.
Een prompt van 100.000 tokens op een oud model is dus niet 100.000 tokens op een nieuw model. De docs adviseren om te hertellen met het model dat je gaat gebruiken. Ten tweede: het count_tokens-endpoint is gratis (met eigen rate limits) en het getal is een schatting die bij het echte request een klein beetje kan afwijken. Gebruik het vóór je een grote prompt, een lange CLAUDE.md of een tool-resultaat in de context stopt.
Embeddings: een geleerde tabel, geen woordenboek
De embedding-tabel is een matrix met één rij per token. Opzoeken is rijen kiezen. De getallen in de tabel zijn parameters, net als de gewichten verderop in het netwerk: ze beginnen willekeurig en worden tijdens de training bijgesteld (A3) totdat tokens die in vergelijkbare contexten voorkomen vergelijkbare vectoren hebben. Er is geen mens die “koning” en “prins” als verwant heeft gemarkeerd.
Dat idee kwam niet van LLM's. Mikolov et al. (2013) trainden een eenvoudig netwerk op het voorspellen van buurwoorden en vonden structuur in de vectoren:
Using a word offset technique where simple algebraic operations are performed on the word vectors, it was shown for example that vector(”King”) - vector(”Man”) + vector(”Woman”) results in a vector that is closest to the vector representation of the word Queen
Probeer dat in deel b van de visual, met echte GloVe-vectoren. Drie kanttekeningen horen erbij en de visual laat ze zien:
- Nabijheid is gemeten in de volle ruimte. Die heeft hier 50 dimensies (in modellen honderden tot duizenden). Het 2D-plaatje is een projectie die veel informatie weggooit; buren op het scherm zijn niet altijd buren in de echte ruimte. Klik op king en zie het zelf.
- De som werkt voor sommige relaties, niet voor alle. Zonder de invoerwoorden uit te sluiten, wint in onze data bij king − man + woman king zelf: de som blijft dicht bij het beginpunt. Het voorbeeld is bovendien het beroemdste en daarom ook een beetje uitgezocht.
- Een vector per woord is een vereenvoudiging. Bij word2vec en GloVe heeft “apple” precies één vector, voor het bedrijf en voor de vrucht. Bij een LLM is de embedding-tabel ook zo’n vaste opzoeking per token. De betekenis die van de context afhangt, ontstaat pas in de lagen daarna (A2).
Positie: de embedding weet niet waar het token staat
Dezelfde token-id geeft altijd dezelfde vector, ongeacht waar in de zin hij staat. Volgorde moet er daarom apart bij: GPT-2 telt een tweede, geleerde tabel op (de modelconfig geeft n_positions = 1024: maximaal 1024 posities). Moderne modellen coderen positie op andere manieren, hoe precies is voor Claude niet openbaar. Het mechanisme, en waarom het ertoe doet voor de lengte van je context, volgt in A2.
Waarom een model letters slecht telt
Het woord strawberry wordt met cl100k_base drie tokens: str | aw | berry. Met een spatie ervoor ( strawberry) is het één token. Het model krijgt id's, geen letters. Hoeveel r’s zitten er in aw? Dat staat nergens in de invoer; het moet uit de trainingsdata zijn afgeleid, bijvoorbeeld uit tekst waarin mensen woorden spellen. Dat lukt vaak voor korte, gewone woorden en faalt bij lange, zeldzame of anders gesplitste woorden. De les voor agents: laat letters tellen, spellen, tekenreeksen vergelijken en rekenen met lange getallen over aan code (een tool), niet aan het model. Dat is precies de reden dat tools bestaan (B2).
Onder de motorkap code en rekenwerk
Een complete BPE in 35 regels
Dit is dezelfde tokenizer als in de werkbank, in Python (alleen standaardbibliotheek). Dezelfde training op hetzelfde corpus (300 merges) geeft in JavaScript en Python identieke merge-lijsten; dat is gecontroleerd.
minibpe.py
import re, collections
# pre-tokenisatie: woord (met voorafgaande spatie), getal, leestekens, witruimte
PAT = re.compile(r" ?[^\W\d_]+| ?\d+| ?(?:[^\s\w]|_)+|\s+(?!\S)|\s+")
def merge(syms, a, b):
out, i = [], 0
while i < len(syms):
if i < len(syms) - 1 and syms[i] == a and syms[i + 1] == b:
out.append(a + b); i += 2
else:
out.append(syms[i]); i += 1
return out
def train(texts, n_merges, min_count=2):
woorden = collections.Counter()
for t in texts:
woorden.update(PAT.findall(t))
staat = [(list(w), n) for w, n in woorden.items()]
merges = []
while len(merges) < n_merges:
paren = collections.Counter()
for syms, n in staat:
for p in zip(syms, syms[1:]):
paren[p] += n
if not paren:
break
beste, n = max(paren.items(), key=lambda kv: kv[1])
if n < min_count:
break
merges.append((beste[0], beste[1], n))
staat = [(merge(s, *beste), c) for s, c in staat]
return merges
def encode(text, merges):
uit = []
for brok in PAT.findall(text):
syms = list(brok)
for a, b, _ in merges:
syms = merge(syms, a, b)
uit += syms
return uit
- Pre-tokenisatie: een merge mag nooit over zo'n brok heen. De spatie hoort bij het woord erna (zoals bij GPT-2), daarom zie je in de werkbank
·heten niethet. - We tellen per uniek woord en onthouden hoe vaak het voorkomt, zodat we niet de hele tekst hoeven te scannen.
- Een paar telt zo vaak mee als het woord waarin het voorkomt.
- Het vaakst voorkomende paar wint. Bij gelijkspel wint het paar dat het eerst werd gezien (
maxgeeft het eerste maximum). Echte implementaties kiezen soms een andere regel; daarom is een tokenizer pas reproduceerbaar met zijn merge-lijst erbij. - De gekozen merge wordt overal toegepast, daarna begint de volgende ronde met de nieuwe symbolen.
- Tokeniseren speelt de merges in trainingsvolgorde af. Het aantal merges dat je meegeeft is wat de schuif in de werkbank doet.
Token-id naar vector
emb_lookup.py (numpy)
import numpy as np
rng = np.random.default_rng(0)
E = rng.normal(size=(6, 4)) # vocabulaire van 6 tokens, 4 getallen per token
ids = [3, 0, 3]
x = E[ids] # opzoeken = rijen kiezen
print(x.shape) # (3, 4)
print(np.array_equal(x[0], x[2])) # True
Uitvoer: (3, 4) en True. Zelfde id, zelfde vector, waar het ook staat. In een echt model is E gevormd (vocabulaire × n_embd) en worden de getallen getraind.
Cosinus-gelijkenis en vectorrekenkunde
“Nabij” meet je meestal met de cosinus van de hoek tussen twee vectoren: cos(a, b) = (a · b) / (|a| · |b|). Dezelfde richting geeft 1, loodrecht 0. De lengte doet er dan niet toe, alleen de richting. Op speelgoed-vectoren (niet geleerd, met de hand gemaakt zodat de som zichtbaar klopt):
emb_toy.py
import numpy as np
v = {
"king": np.array([0.9, 0.8, 0.1]),
"queen": np.array([0.9, 0.1, 0.8]),
"man": np.array([0.1, 0.8, 0.1]),
"woman": np.array([0.1, 0.1, 0.8]),
}
def cosine(a, b):
return a @ b / (np.linalg.norm(a) * np.linalg.norm(b))
q = v["king"] - v["man"] + v["woman"]
print(q) # [0.9 0.1 0.8]
for woord, vec in v.items():
print(f"{woord:6} {cosine(q, vec):.3f}")
Uitvoer: [0.9 0.1 0.8], daarna cosinus 0,664 (king), 1,000 (queen), 0,255 (man) en 0,754 (woman). Dit klopt zo netjes omdat de vectoren ervoor gemaakt zijn. Echte GloVe-vectoren (50 dimensies, in de visual) geven king − man + woman als dichtstbijzijnde woord king zelf (cosinus 0,89) en daarna queen (0,86); sluit je de invoerwoorden uit, dan wint queen.
Tokens tellen met de Claude API
count.py (uit de Anthropic-docs, ingekort)
import anthropic
client = anthropic.Anthropic()
response = client.messages.count_tokens(
model="claude-sonnet-5-5",
system="Je bent een assistent.",
messages=[{"role": "user", "content": "De snelle bruine vos springt over de luie hond."}],
)
print(response) # input_tokens: ...
Dit is niet in deze omgeving gedraaid (geen API-key); het volgt het voorbeeld uit de docs. Het endpoint telt alles wat in het request zit (system prompt, tools, berichten), niet alleen je tekst.
Uitgewerkt voorbeeld: BPE op een piepklein corpus
Corpus: low vijf keer, lower twee keer, newest zes keer en widest drie keer. Wat doet BPE hiermee, en hoe tokeniseert het daarna een woord dat er nooit in stond?
voorbeeld.py (gebruikt minibpe.py uit Onder de motorkap)
corpus = ["low " * 5 + "lower " * 2 + "newest " * 6 + "widest " * 3]
merges = train(corpus, 10)
for i, (a, b, n) in enumerate(merges, 1):
print(i, repr(a), "+", repr(b), "->", repr(a + b), f"({n}x)")
print(encode(" lowest", merges))
print(encode(" lowest", merges[:3]))
print(encode(" lowest", []))
uitvoer (gedraaid)
1 'e' + 's' -> 'es' (9x)
2 'es' + 't' -> 'est' (9x)
3 'l' + 'o' -> 'lo' (7x)
4 'lo' + 'w' -> 'low' (7x)
5 ' ' + 'low' -> ' low' (6x)
6 ' ' + 'n' -> ' n' (6x)
7 ' n' + 'e' -> ' ne' (6x)
8 ' ne' + 'w' -> ' new' (6x)
9 ' new' + 'est' -> ' newest' (6x)
10 ' ' + 'w' -> ' w' (3x)
[' low', 'est']
[' ', 'lo', 'w', 'est']
[' ', 'l', 'o', 'w', 'e', 's', 't']
eswint als eerste omdat het paar in newest (6×) en widest (3×) zit: 9 keer.es+tvolgt direct, ook 9 keer. Zo ontstaat het achtervoegselestzonder dat iemand weet wat een achtervoegsel is.lokomt uit low (5×) en lower (2×): 7. Het woord newest groeit stap voor stap (merge 6 tot en met 9); pas bij merge 9 is het één token.- Het woord
loweststond niet in het corpus, maar wordt toch netjes·low+est: twee stukjes die de tokenizer kent. Dit is het open vocabulaire in het klein. - Met alleen de eerste drie merges is
lownog niet compleet:lo+w. - Zonder merges blijft het een rij losse tekens: zeven tokens voor een woord van zes letters plus een spatie. Meer merges, minder tokens, groter vocabulaire.
Meet zelf wat tokens kosten, en bouw een mini-BPE
Opdracht
- Maak een virtuele omgeving en installeer
tiktoken(pip install tiktoken; de BPE-bestanden worden bij het eerste gebruik gedownload, je hebt dus internet nodig). - Draai dit script en bekijk de uitvoer:
import tiktoken zinnen = { "en": "The quick brown fox jumps over the lazy dog.", "nl": "De snelle bruine vos springt over de luie hond.", "code": "def f(x):\n return x + 1\n", "getal": "1234567890123456", } for naam in ["gpt2", "cl100k_base", "o200k_base"]: enc = tiktoken.get_encoding(naam) print(f"{naam}: vocabulaire {enc.n_vocab}") for soort, tekst in zinnen.items(): ids = enc.encode(tekst) print(f" {soort:5} {len(tekst):3} tekens -> {len(ids):3} tokens") enc = tiktoken.get_encoding("cl100k_base") for woord in ["strawberry", " strawberry"]: print(repr(woord), [enc.decode([i]) for i in enc.encode(woord)]) - Neem een echt bestand uit je eigen werk (een README of een stuk Nederlandse documentatie, 1 tot 2 pagina's) en meet tekens, woorden en tokens met
cl100k_base. Vertaal (of laat vertalen) dezelfde tekst naar het Engels en meet opnieuw. Wat is de verhouding tokens per woord in beide talen? - Schrijf zelf een mini-BPE. Begin met
train(texts, n_merges)enencode(text, merges)uit de motorkap-sectie, maar zonder te kopiëren. Train op een paar tekstbestanden van jezelf met 50, 200 en 1000 merges en meet hoeveel tokens je README dan kost. - Optioneel, als je een API-key hebt: tel dezelfde tekst met het
count_tokens-endpoint en vergelijk met tiktoken.
Verwacht resultaat
Stap 2 geeft deze aantallen tokens (gedraaid met tiktoken 0.14.0), per encoding in de volgorde en, nl, code, getal: gpt2 (vocabulaire 50257): 10, 17, 14, 7; cl100k_base (100277): 10, 15, 11, 6; o200k_base (200019): 10, 13, 11, 6. Daarna 'strawberry' ['str', 'aw', 'berry'] en ' strawberry' [' strawberry']. Stap 3: de Nederlandse tekst heeft bij dezelfde inhoud meestal meer tokens dan de Engelse; de exacte verhouding hangt van je tekst en encoding af. Stap 4: meer merges geeft steeds minder tokens, met afnemende winst; bij een klein trainingscorpus (een paar kB) stopt de training eerder omdat er geen paren meer zijn die twee keer voorkomen.
Als het niet werkt, kijk naar …
- Fout bij
get_encoding: het downloaden van de encoding-bestanden mislukt (proxy of geen internet). Probeer het later of via een andere verbinding. - Installeren van
tiktokenfaalt: een heel nieuwe Python-versie heeft soms nog geen kant-en-klare wheel; gebruik een iets oudere Python in je virtuele omgeving. - Mini-BPE geeft andere merges dan de werkbank: controleer de pre-tokenisatie (de spatie hoort bij het volgende woord) en de gelijkspel-regel (eerst gezien wint).
- Je tokens komen niet overeen met de tekst terug:
"".join(encode(text, merges))moet exact de tekst geven. Zo niet, dan raakt een stap tekens kwijt, vaak bij witruimte aan het eind. - Training duurt eeuwig: werk per uniek woord (met aantal), niet per teken van de hele tekst.