Tokens in AI zijn stukjes tekst waarin een taalmodel tekst opdeelt. Een model kan namelijk geen letters lezen. Het model leest of schrijft geen losse letters en ook geen hele woorden, maar iets daartussenin: fragmenten die meestal overeenkomen met een kort woord, een deel van een woord, zoals een lettergreep of een leesteken. Kort gezegd is een token dus een klein stukje tekst dat een AI-systeem gebruikt om je tekst voor zichzelf begrijpelijk te maken. In onderstaande video legt Antal de Waij, auteur van het Handboek AI-geletterdheid, tokens kort en bondig uit.
Waarom werkt een AI-model met tokens?
Als het model met losse letters zou werken, zou elke zin honderden stappen kosten om te verwerken. Dat is natuurlijk heel traag en superinefficiënt. Werken met hele woorden lukt ook niet: de woordenschat zou eindeloos worden, en nieuwe of zeldzame woorden (“Hilversum”, “gpt-achtig”, typefouten) zou het model niet kennen. Tokens zijn de pragmatische middenweg: veelgebruikte stukjes tekst krijgen een eigen token, zeldzame woorden worden samengesteld uit kleinere stukjes.
Hoe wordt een token gemaakt?
Een token wordt gemaakt met een zogenaamde tokenizer, die tekst omzet in tokens en omgekeerd. Het is letterlijk de vertaler tussen de menselijke wereld (letters en woorden) en de wiskundige wereld waarin het taalmodel werkt (getallen). Zonder tokenizer kan een model letterlijk geen tekst lezen of schrijven.
Tokenizers worden getraind op heel veel tekst, meestal met een algoritme genaamd Byte Pair Encoding (BPE) of een variant daarop. Een tokenizer werkt als volgt: hij begint met losse tekens, kijkt vervolgens welke combinaties het vaakst naast elkaar voorkomen en voegt die samen tot een nieuw token. Herhaal dat een paar honderdduizend keer. Het resultaat is een “woordenboek” van 30.000 tot 200.000 tokens, waarin de meest voorkomende patronen in de tekst elk hun eigen nummer hebben gekregen. Veelvoorkomende woorden zoals “ik” of “graag” worden zo één enkele token. Zeldzame woorden, bijvoorbeeld de meeste samengestelde woorden zoals “Amsterdam” of “arbeidsongeschiktheidsverzekering”, worden samensgesteld uit meerdere kleinere tokens die vaak voorkomen. Op deze manier kan een taalmodel dus woorden die het niet kent samenstellen.
Een tokenizer is dus verantwoordelijk voor de efficiëntie van het taalmodel en bepaalt wat het model als het ware “ziet”. Elk model heeft z’n eigen “woordenboek”. Daarom is de energie-efficiëntie van het ene taalmodel niet hetzelfde als die van het andere taalmodel. Daarover hieronder meer.
Van tokens naar betekenis
Tot nu toe hebben we het gehad over tokens als stukjes tekst met een nummer. Maar een nummer op zich zegt natuurlijk niets. Het token voor “kat” is bijvoorbeeld 4842 en voor “poes” 9921. Voor het model zijn dat in eerste instantie gewoon twee willekeurige getallen. Hier komen embeddings in beeld. Een embedding is een lijst van honderden of duizenden getallen die elk token een ‘plaats’ geeft in een wiskundige ruimte. Je kunt je dat voorstellen als een woordenwolk met heel veel dimensies, waarin woorden met een vergelijkbare betekenis dicht bij elkaar liggen. “Kat” en “poes” staan in die woordenwolk vlak naast elkaar, “hond” iets verderop, en “vrachtwagen” aan de andere kant van de woordenwolk.
Door deze embeddings krijgt een taalmodel grip op de betekenis van taal. Het model leert tijdens de training dat woorden die in vergelijkbare contexten voorkomen, ook dicht bij elkaar in de woordenwolk moeten staan. Daarom kan een taalmodel begrijpen dat “de dokter schreef een recept” en “de arts gaf een voorschrift” ongeveer hetzelfde betekenen, ook al worden er compleet andere tokens gebruikt.
Een token is dus de bouwsteen, maar een embedding is wat die bouwsteen betekenis geeft. Zonder tokenizer kan een model geen tekst lezen, zonder embeddings kan het geen taal begrijpen.
Waarom zijn tokens belangrijk?
Naast de technische werking van tokens zijn tokens de rekeneenheid van taalmodellen. Telkens wanneer je een vraag stelt aan je AI-taalmodel, gebruik je tokens. En die betaal je. Of je nu een taalmodel gratis en voor niks gebruikt, een abonnement hebt of een taalmodel handig koppelt met software die je veel gebruikt. Voor elke interactie is er tokengebruik. Wanneer je je taalmodel verbindt met software door middel van een API, dan verbruik je continu tokens.
Daarnaast worden tokens gebruikt voor de omvang van het contextvenster van je taalmodel. (de Engelse term is: context window). Dit is het werkgeheugen van een taalmodel: alles wat het model op één moment “ziet” en kan meenemen in zijn antwoord. Dat venster wordt gemeten in tokens, niet in woorden, niet in het aantal pagina’s, maar in tokens. Een model als Claude heeft bijvoorbeeld een contextvenster van 200.000 tokens. Dat is de bovengrens van wat er in één gesprek aan tekst kan zitten op het moment dat het model antwoord geeft. Dat zijn ruim 150.000 woorden Engelse tekst of zo’n 500 pagina’s. Genoeg om een heel jaarverslag, een wetboek of een doctoraalscriptie in één keer te laten analyseren. Wil jij een analyse maken en je input is meer dan 200.000 tokens, dan is de kans groot dat je taalmodel een deel van de informatie niet ‘ziet’. Immers, een taalmodel ziet alleen zijn contextvenster. Voor huis-tuin-en-keuken-prompts is dit geen probleem, maar wanneer je uitgebreide analyses maakt, is het iets om rekening mee te houden.
Hoeveel tokens gebruik ik?
Voor de Engelse taal geldt ongeveer: 1 token ≈ 4 tekens of 100 tokens ≈ 75 woorden. Voor het Nederlands ligt het iets ongunstiger. Nederlandse samengestelde woorden zoals “ziektekostenverzekering” worden vaker opgeknipt, dus je gebruikt per zin gemiddeld wat meer tokens dan in het Engels. Een voorbeeld: Engels: “The children played in the garden yesterday.” → 7 woorden, ongeveer 9 tokens, In het Nederlands: “De kinderen speelden gisteren in de tuin.” → 7 woorden, ongeveer 11 of 12 tokens. Dezelfde betekenis, vergelijkbare zinslengte, maar het Nederlands kost 25 tot 30% meer tokens dan in het Engels.
Het Nederlands en Engels zijn “westerse talen”. Bij andere talen, zoals Chinees, Japans, Arabisch of Hindi is het tokengebruik weer anders. Daar kan een gelijkwaardige zin twee tot vijf keer zoveel tokens kosten.
Tokens en de Nederlandse taal
De Nederlandse taal gebruikt dus meer tokens. Dat komt omdat de tokenizers van de meeste grote modellen geoptimaliseerd zijn op Engelstalige trainingsdata, dus Engelse veelvoorkomende woorden krijgen vaak hun eigen token, terwijl Nederlandse woorden vaker opgeknipt worden. Het Nederlands “plakt” woorden aan elkaar (“arbeidsongeschiktheidsverzekering”), waar het Engels spaties gebruikt. De lange samenstellingen worden gesplitst in meerdere subtokens. Tot slot heeft het Nederlands meer verbuigingen en uitgangen (-en, -de, -te, -lijk), wat zorgt voor meer unieke woordvormen. Dat betekent dus meer woordvarianten en dus een hoger tokenverbruik.
Tokens als rekeneenheid
Bij de meeste mensen zit het tokenverbruik in je abonnement. Dat geldt ook voor de gratis varianten. Wanneer je je taalmodel koppelt aan je bedrijfssoftware via een API, betaal je een bepaald bedrag per miljoen tokens voor dat API-gebruik. Ook contextvensters worden uitgedrukt in tokens (bijvoorbeeld “200.000 tokens context”), en de snelheid van een model wordt gemeten in tokens per seconde. Voor een taalmodel is een token wat een kilowattuur is voor stroom: de eenheid waarin alles wordt afgerekend.
Jevons-paradox: goedkopere tokens betekent meer verbruik
De prijs van een token, is de afgelopen jaren hard gedaald. Logisch zou je denken dat je AI-kosten daardoor dalen. Het tegenovergestelde gebeurt. Dit heet de Jevons-paradox. De Engelse econoom William Stanley Jevons zag in 1865 dat zuinigere stoommachines niet minder steenkool verbruikten, maar juist meer. Goedkoper verbruik maakte nieuwe toepassingen mogelijk, en het totale steenkoolverbruik schoot omhoog. Met AI gebeurt precies hetzelfde.
Verwacht wordt dat de tokenkosten voor de grootste modellen de komende vijf jaar met meer dan 90% dalen. En tegelijk gebruiken agents, AI die zelfstandig taken uitvoert, 5 tot 30 keer zoveel tokens per taak als een gewone chatbot. De goedkoper wordende techniek jaagt de vraag harder op dan de prijs daalt. De Amerikaanse bank Goldman Sachs verwacht dat AI-agents het tokenverbruik tegen 2030 met een factor 24 laten groeien.
De consequentie zal zijn dat menselijke arbeid misschien wel goedkoper is dan het inzetten van AI-agents. En dat mag je ook als goed nieuws beschouwen, want veel mensen denken dat Agents hun baan zal overnemen, maar dat is dus niet altijd zo.
Caching en hergebruik van tokens
Veel moderne API’s bieden prompt caching. Dat betekent dat als je dezelfde systeemprompt of documenten meerdere keren meestuurt, hoef je daar niet telkens voor te betalen. Voor zakelijke gebruikers is dit een belangrijke besparing, zowel financieel als qua energie.
Training van je taalmodel = tokens verbruiken
Tijdens het ontwikkelen (trainen) van je taalmodel leert het model patronen door enorme hoeveelheden tekst te verwerken. Een modern groot taalmodel wordt getraind op iets in de orde van 10 tot 30 biljoen tokens (dat is 10.000–30.000 miljard). Het model “leest” deze tokens niet één keer rustig door. Voor elk token worden continu de gewichten (de mate waarin een token veel of weinig voorkomt) bijgesteld. Dat betekent rekenkundig drie tot vier keer zoveel tokengebruik als alleen het lezen van een token.
Deze training gebeurt eenmalig, maar de kosten zijn echt enorm. Die rekenkracht verbruikt tientallen tot honderden miljoenen euro’s aan GPU-tijd om het taalmodel te trainen. Dat is de tijd die het kost om via microchips die een AI-model gebruikt het taalmodel te trainen. GPUs gebruiken stroom en energie. Het voordeel is dat je ze één keer betaalt en er één model mee levert dat daarna miljarden keren gebruikt kan worden. Het bedrijf dat het model maakt (Anthropic, OpenAI, Google, enzovoort) draagt deze kosten. De kosten worden betaald uit jouw abonnementskosten. Maar vanwege de concurrerende markt waarin AI-bedrijven opereren, brengen ze telkens nieuwe, betere taalmodellen uit. Die moeten telkens opnieuw getraind worden. En dat kost dus weer, je raadt het al, veel tokens.
Inference = jouw tokenverbruik
Inference is wat er gebeurt als jij een vraag stelt en een antwoord krijgt. Het is de gebruikersvariant van tokens. Het model leert niets nieuws; de gewichten staan vast. Per gesprek dat je voert met je taalmodel worden er honderden tot tienduizenden tokens verwerkt: je prompt eromheen, de chatgeschiedenis, eventuele documenten, plus de tokens die het model genereert als antwoord. Per losse interactie is dit goedkoop (denk aan fracties van een cent tot enkele centen), maar het gebeurt heel vaak en op enorme schaal. Immers, er zijn miljoenen gebruikers die het taalmodel de hele dag door gebruiken. Opgeteld over de levensduur van een model overstijgt het totale inferentieverbruik vaak het trainingsverbruik ruimschoots.
Bij inference zijn er twee soorten tokens.: inputtokens (wat jij in je prompt meegeeft aan het taalmodel) en outputtokens (het antwoord dat het model genereert), waarbij output meestal duurder is omdat die token voor token wordt berekend.
Onzichtbaar tokenverbruik
Naast input- en outputtokens zijn er ook ‘onzichtbare’ tokens. Denk daarbij aan system prompts, opmaaktokens, tooldefinities en metadata. Wanneer je als gebruiker een ‘lege’ chat opent, verbruik je vaak meteen al honderden tokens voordat er ook maar één woord is getypt. Daarnaast gebruikt een model bij de functie Reasoning en ’thinking’ intern enorme hoeveelheden ‘denktokens’ die je als gebruiker niet ziet, maar wel verbruikt of betaalt.
Niet teveel inputtokens tegelijkertijd!
Je weet dat een taalmodel heel goed kan analyseren. In de praktijk valt dat een beetje tegen! Onderzoekers noemen dit fenomeen “lost in the middle“: taalmodellen presteren prima op informatie aan het begin en het einde van een lange context, maar slechter op informatie in het midden. Stop je op pagina 250 van een document een belangrijke alinea, dan is de kans groot dat het model die over het hoofd ziet, ook al staat hij technisch gezien gewoon in het contextvenster. Het is een beetje als een mens die een dik boek leest. De eerste hoofdstukken en het einde blijven hangen, maar het middendeel vervaagt. Een taalmodel heeft daar in versterkte mate last van.
Voor lange documenten werken andere promptstrategieën vaak beter: knip je document in stukken, laat het model per stuk een samenvatting maken, en combineer die samenvattingen daarna. Of gebruik een techniek genaamd RAG (Retrieval Augmented Generation), waarbij het model alleen die stukken tekst krijgt die echt relevant zijn voor jouw vraag. Dat is niet alleen nauwkeuriger, maar ook nog eens een stuk goedkoper en duurzamer. Laten we eens kijken naar andere manieren op milieubewust te prompten.
Minder tokens gebruiken in je prompt (milieubewust prompten)
Elke prompt verbruikt tokens en kost energie. Vooral elektriciteit voor de servers en water voor koeling in datacenters. Per losse vraag is dat weinig, maar opgeteld over alle gesprekken telt het wel degelijk. Daarom een en paar praktische manieren om je voetafdruk te verkleinen:
- Gebruik het juiste model voor de taak: een groter model verbruikt meer energie per token. Voor eenvoudige vragen, het vertalen van een woord, een korte samenvatting, een snelle vraag kun je googelen of een kleiner model gebruiken. Bewaar de zware modellen voor taken die echt complexe redenering vereisen, zoals analyses maken, ingewikkelde code schrijven of meerstapsonderzoek doen. Vergelijk het met het feit dat je geen vrachtwagen gebruikt om één brood te halen.
- Wees compact en duidelijk: een vage prompt leidt tot heen-en-weergesprekken met je taalmodel. Daarin stuur je telkens dezelfde context mee. Elk vervolgbericht herhaalt namelijk de hele gespreksgeschiedenis. Een goed geformuleerde prompt bespaart drie of vier rondes corrigeren. Tip: schrijf eerst je prompt op in een document en ‘plak’ deze dan in je taalmodel.
- Begin een nieuwe chat en ga niet door op een eerder gesprek. Lange chatgeschiedenissen worden bij elk nieuw bericht volledig meegestuurd naar het model. Een gesprek van 50 berichten kost per nieuw bericht veel meer dan een nieuw ‘vers’ gesprek. Begin een nieuwe chat als je onderwerp echt verandert, en houd lange werksessies gefocust op één taak.
- Vraag niet om meer dan je nodig hebt: output-tokens zijn duurder dan input-tokens, omdat ze één voor één berekend worden. Gericht vragen stellen helpt daarbij. Bijvoorbeeld: “Geef alleen het antwoord, geen uitleg” wanneer dat genoeg is. “Maximaal 100 woorden” in plaats van een uitgebreide verhandeling, “Geef alleen de aangepaste regels code” in plaats van het hele bestand opnieuw.
- Vermijd onnodige output: webzoekopdrachten, beeldgeneratie, code-uitvoering en uitgebreide redenering (“extended thinking”) kosten extra veel tokens. Zet ze daarom niet standaard in maar vraag er alleen om als ze echt iets toevoegen. Niet overal hoeft een infographic of een voorbeeld bij.
- Denk eerst, prompt later: de grootste besparing is misschien wel de ouderwetse: vraag jezelf af of je het antwoord ook ergens anders snel kunt vinden, google je antwoord, pak een boek of gebruik een rekenmachine of, soms, helpt het om ook zelf even na te denken. Je weet meer dan je denkt! Een taalmodel is een handig hulpmiddel, maar niet per se voor elke vraag het meest efficiënt.