Deel A · Module 01

Tokens & embeddings

Wat “ziet” een model eigenlijk?

Zone: machine ± 15 min kern

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:

  1. 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.
  2. 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.
  3. 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:

EncodingEngelsNederlandsCode (27 tekens)Cijfers (16 tekens)
gpt21017147
cl100k_base1015116
o200k_base1013116

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_base voegt 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: 1234567 wordt 123|456|7, maar 234567 wordt 234|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

Mikolov, Chen, Corrado & Dean (2013), Efficient Estimation of Word Representations in Vector Space, arxiv.org/abs/1301.3781

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
  1. 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 ·het en niet het.
  2. We tellen per uniek woord en onthouden hoe vaak het voorkomt, zodat we niet de hele tekst hoeven te scannen.
  3. Een paar telt zo vaak mee als het woord waarin het voorkomt.
  4. Het vaakst voorkomende paar wint. Bij gelijkspel wint het paar dat het eerst werd gezien (max geeft het eerste maximum). Echte implementaties kiezen soms een andere regel; daarom is een tokenizer pas reproduceerbaar met zijn merge-lijst erbij.
  5. De gekozen merge wordt overal toegepast, daarna begint de volgende ronde met de nieuwe symbolen.
  6. 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']
  1. es wint als eerste omdat het paar in newest (6×) en widest (3×) zit: 9 keer. es + t volgt direct, ook 9 keer. Zo ontstaat het achtervoegsel est zonder dat iemand weet wat een achtervoegsel is.
  2. lo komt 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.
  3. Het woord lowest stond niet in het corpus, maar wordt toch netjes ·low + est: twee stukjes die de tokenizer kent. Dit is het open vocabulaire in het klein.
  4. Met alleen de eerste drie merges is low nog niet compleet: lo + w.
  5. 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.
Doe-opdracht

Meet zelf wat tokens kosten, en bouw een mini-BPE

Opdracht

  1. Maak een virtuele omgeving en installeer tiktoken (pip install tiktoken; de BPE-bestanden worden bij het eerste gebruik gedownload, je hebt dus internet nodig).
  2. 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)])
  3. 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?
  4. Schrijf zelf een mini-BPE. Begin met train(texts, n_merges) en encode(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.
  5. 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 tiktoken faalt: 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.

Zelftoets