Je opent je favoriete AI-applicatie, typt een uitgebreide vraag in, en drukt op enter. Vrijwel onmiddellijk begint er een antwoord over je scherm te rollen. Het voelt bijna magisch, alsof er ergens ver weg een razendsnelle typist zit die het antwoord voor je aan het bedenken is. Maar de realiteit is nog veel fascinerender. Wat er op dat moment plaatsvindt, noemen we in de wereld van artificiële intelligentie inference (gevolgtrekking).
Waar we vaak veel horen over de 'training' van een AI-model—het proces dat maanden duurt, miljarden teksten vereist en gigantische datacenters laat loeien—is inference het moment van de waarheid. Het is de fase waarin het getrainde model zijn opgedane kennis toepast om een specifieke taak voor jou uit te voeren. Of je nu een simpele samenvatting vraagt, of een complexe webapplicatie bouwt die afhankelijk is van razendsnelle AI-antwoorden via een API, inference is de motor die alles draaiende houdt.
In dit artikel pellen we het proces van inference stap voor stap af. We laten de ingewikkelde wiskundige formules voor wat ze zijn en focussen op de fundamentele mechanismen. Hoe verandert jouw getypte prompt in een stroom van logische woorden? En waarom kost het genereren van tekst eigenlijk zoveel rekenkracht en geheugen?
Training versus Inference: Een Noodzakelijk Onderscheid
Om te begrijpen wat inference is, moeten we het eerst kort afzetten tegen training. Je kunt het vergelijken met het onderwijssysteem. De trainingsfase is te vergelijken met een student die jarenlang in de bibliotheek zit om boeken uit zijn hoofd te leren. Tijdens de training worden de zogenaamde 'gewichten' of parameters van het model aangepast. Dit is een extreem rekenintensief proces waarbij het model leert hoe de menselijke taal in elkaar zit, welke concepten aan elkaar gerelateerd zijn en hoe logica werkt.
Inference is het moment dat de student examen doet. De student leert op dat moment niets nieuws meer (de gewichten staan vast), maar gebruikt de opgedane kennis om een uniek antwoord te formuleren op een nieuwe vraag. Zelfs als een vraag nog nooit eerder exact zo is gesteld, kan het model door middel van patroonherkenning een accuraat antwoord construeren.
De Analogie: De Meesterkok in een Gigantische Keuken
Laten we een concrete analogie gebruiken om het complexe proces van inference in een neuraal netwerk te begrijpen. Stel je een meesterkok voor die alle recepten ter wereld uit zijn hoofd kent (dit is ons getrainde model). Je loopt zijn restaurant binnen en geeft hem een briefje met een bestelling: "Maak een vegetarische pasta, maar dan zonder knoflook en met extra basilicum." Dit briefje is jouw prompt.
De kok gaat niet zomaar in één keer een heel bord pasta voor je neerzetten. In plaats daarvan bouwt hij het gerecht ingrediënt voor ingrediënt op, waarbij hij na elk toegevoegd ingrediënt de saus even proeft om te bepalen wat de logische volgende stap is. Dit 'ingrediënt voor ingrediënt' werken is cruciaal om te onthouden wanneer we het straks gaan hebben over tokens. Als de bestelling heel lang is, of als er honderd kookboeken op het aanrecht liggen waar de kok rekening mee moet houden, wordt zijn werkblad vol en overzichtelijk. Het koken wordt trager en het kost meer moeite. Dit werkblad symboliseert het tijdelijke geheugen van het AI-model.
Stap 1: Van Jouw Prompt Naar Tokens (Tokenisatie)
Wanneer jij je prompt verstuurt, ziet het AI-model helemaal geen letters of woorden. Grote taalmodellen (LLM's) kunnen uitsluitend met getallen werken. De allereerste stap in de inference-pijplijn is daarom het vertalen van jouw menselijke taal naar machinetaal. Dit proces heet tokenisatie.
Een 'token' is een brokstukje tekst. Dit kan een heel woord zijn, maar vaker is het een deel van een woord of zelfs maar één enkele letter. Je kunt een token zien als de atomen van de taal voor een AI. De zin "Het is vandaag een mooie dag" wordt door een tokenizer in stukjes geknipt en elk stukje krijgt een uniek ID-nummer uit het 'woordenboek' (de vocabulaire) van het model.
Wil je hier meer over weten of zelf uitproberen hoe jouw teksten worden opgeknipt? Lees dan onze uitgebreide gids over tokenisatie uitgelegd. Het belangrijkste om nu te onthouden is dat jouw prompt verandert in een lange reeks getallen. Vanaf dat moment rekent het model niet met taal, maar met wiskundige vectoren in een multidimensionale ruimte.
Stap 2: De Input Verwerken (De Prefill Fase)
Nu jouw prompt is omgezet in een reeks getallen (tokens), moet het model de context gaan begrijpen. Dit gebeurt in de zogenaamde prefill fase. In tegenstelling tot het latere schrijven van het antwoord (dat woord voor woord gaat), kan het model deze leesfase razendsnel en parallel uitvoeren.
Grafische kaarten (GPU's) zijn extreem goed in het tegelijkertijd uitvoeren van duizenden kleine berekeningen. Tijdens de prefill fase leest de GPU als het ware al jouw invoer-tokens in één klap. Het model analyseert de relaties tussen alle woorden in jouw prompt. Het bouwt in deze fase een soort wiskundige samenvatting op van de complete context die jij hebt aangedragen.
Belangrijk in applicatie-ontwikkeling: De prefill fase is de reden waarom het doorgaans heel snel gaat als je een enorme lap tekst in een prompt plakt, zoals wanneer je technieken zoals Retrieval-Augmented Generation (RAG) gebruikt. Je stuurt bijvoorbeeld eerst de inhoud van drie lange documenten mee als context, voordat je een korte vraag stelt. Het model kan al die documenten in één snelle 'prefill sweep' verwerken. Het daadwerkelijke genereren van het antwoord is wat de meeste tijd in beslag neemt.
Stap 3: Het Volgende Woord Raden (De Forward Pass)
Zodra de context is begrepen, begint het echte werk: het voorspellen van het allereerste token van het antwoord. Dit is de kern van AI-inference en wordt de forward pass genoemd. Jouw getokeniseerde prompt reist door het gehele neurale netwerk, van de onderste laag tot de bovenste laag.
Tijdens deze reis passeert de data talloze 'Transformer-blokken'. Binnen deze blokken gebeuren twee zeer belangrijke dingen:
- Het Attention-mechanisme: Dit mechanisme zorgt ervoor dat het model begrijpt welke woorden in jouw prompt belangrijk zijn ten opzichte van elkaar. Bij de zin "De bank is gesloten omdat zij geen geld meer hadden", begrijpt het attention-mechanisme dat 'zij' verwijst naar de financiële instelling 'bank', en niet naar een meubelstuk. Voor een diepgaande blik hierop, zie ons artikel over hoe attention werkt in taalmodellen.
- Feed-Forward netwerken: Na de attention-stap wordt de data door een klassiek neuraal netwerk gestuurd dat de interne 'kennis' van het model raadpleegt (opgedaan tijdens de training) om patronen en feiten op te halen die relevant zijn voor de huidige context.
Aan het einde van deze reis door het model (de top van het netwerk) spuugt het model niet zomaar één woord uit. In plaats daarvan produceert het een gigantische lijst met waarschijnlijkheden voor elk mogelijk token in zijn hele vocabulaire. Het model zegt eigenlijk: "Op basis van jouw prompt is de kans 80% dat het volgende token 'De' is, 15% dat het 'Het' is, en 0,01% dat het 'Banaan' is."
Stap 4: Kiezen en Herhalen (Autoregressieve Generatie)
Nu we een lijst met waarschijnlijkheden hebben, moet er een keuze worden gemaakt. Hier komen de zogenaamde sampling-instellingen kijken. Als je de temperatuur (temperature) van een model op 0 zet, kiest het simpelweg altijd het token met de hoogste kans. Staat de temperatuur hoger, dan mag het model af en toe een minder waarschijnlijk, en dus creatiever, token kiezen. Wil je dit zelf sturen in je prompts of API-calls? Bekijk dan ons overzicht van alle belangrijke sampling parameters.
Laten we zeggen dat het model het woordje 'De' heeft gekozen. Wat nu? Hier komt het meest cruciale aspect van LLM-inference om de hoek kijken: het proces is autoregressief. Dit is een duur woord voor: de output van zojuist, wordt de input voor de volgende stap.
Het gekozen token 'De' wordt letterlijk aan jouw originele prompt vastgeplakt. De nieuwe, iets langere prompt wordt vervolgens in zijn geheel wéér door het hele neurale netwerk gestuurd (een nieuwe forward pass) om het dáárop volgende token te voorspellen. En dit proces herhaalt zich. Token voor token. Keer op keer. Totdat het model een speciaal stop-token voorspelt dat aangeeft dat de zin of het antwoord compleet is. Vandaar dat je het antwoord vaak letterlijk over je scherm ziet 'typen'.
Het Geheim Voor Snelheid: De KV-Cache
Als je kritisch hebt meegelezen bij Stap 4, valt je misschien een gigantisch probleem op. Als het model voor élk nieuw woord de héle voorafgaande prompt (inclusief de reeds gegenereerde antwoorden) opnieuw door het netwerk moet sturen, zou het systeem na een paar zinnen tergend traag worden. De berekening zou immers bij elk nieuw woord exponentieel zwaarder worden.
Gelukkig is hier een ingenieuze oplossing voor bedacht: de Key-Value Cache (KV-Cache). Je kunt dit vergelijken met een detective die een ingewikkelde zaak probeert op te lossen. Als de detective een nieuwe aanwijzing vindt, gaat hij niet het volledige dossier van duizend pagina's opnieuw van kaft tot kaft lezen. In plaats daarvan houdt hij een notitieboekje bij met een samenvatting van de belangrijkste verbanden. De nieuwe aanwijzing wordt alleen nog vergeleken met de samenvatting in het notitieboekje.
De KV-cache doet precies dit. Het bewaart de 'tussenresultaten' (de wiskundige representaties) van alle voorgaande tokens in het tijdelijke geheugen van de grafische kaart (het VRAM). Als het model een nieuw woord moet voorspellen, berekent het alleen de wiskundige waardes voor het állernieuwste woord, en gebruikt het de opgeslagen cache voor de rest van de context. Dit bespaart een enorme hoeveelheid rekenkracht en zorgt ervoor dat het genereren van tekst soepel blijft doorlopen.
Waarom Lange Context Trager en Duurder Is
Hoewel de KV-cache het proces redt van extreme traagheid, introduceert het wel een nieuwe flessenhals: het geheugen. Elk token dat in de cache wordt opgeslagen, neemt een klein beetje fysiek werkgeheugen (RAM of VRAM) in beslag. Hoe langer het gesprek wordt, of hoe meer documenten je als context meestuurt (zoals in veel enterprise RAG-oplossingen), hoe gigantischer deze cache wordt.
Wanneer je applicaties bouwt die grote context-windows vereisen (bijvoorbeeld het analyseren van PDF-rapporten van 100 pagina's), loopt het geheugengebruik exponentieel op. Uiteindelijk moet de hardware zoveel data in het snelle geheugen houden, dat de geheugenbandbreedte de beperkende factor wordt. De processor moet wachten tot de data uit het geheugen is gehaald. Dit verklaart direct waarom cloud-providers je vaak betalen per token: jij huurt op dat moment niet alleen rekenkracht, maar je reserveert fysiek geheugen op hun peperdure systemen.
Daarnaast neemt de complexiteit van het attention-mechanisme zelf ook toe. Als een model moet bepalen welk van de 10.000 voorgaande woorden het meest relevant is voor het huidige woord, vereist dat aanzienlijk meer rekenwerk dan wanneer het model dit voor slechts 100 woorden hoeft te doen. Om deze enorme datastromen te kunnen verwerken, zijn speciale chip-architecturen noodzakelijk. Wil je begrijpen waarom conventionele computers hier tekortschieten en speciale chips noodzakelijk zijn? Lees dan verder op ons zusterplatform over de technische infrastructuur achter AI servers.
Conclusie
AI inference is een prachtig georkestreerde wiskundige dans. Het is geen magie, maar statistiek op steroïden. Van het moment dat jouw prompt wordt opgeknipt in abstracte tokens, via de razendsnelle prefill-fase, tot de autoregressieve loop waarbij woord voor woord nauwkeurig wordt gewogen en gegenereerd.
Door te begrijpen hoe deze 'motor' werkt, ben je veel beter in staat om efficiënter met taalmodellen om te gaan. Je begrijpt waarom grote lappen tekst in een prompt voor hogere kosten of tragere antwoorden kunnen zorgen (vanwege de uitdijende KV-cache), waarom de eerste letter van een antwoord soms even op zich laat wachten (de prefill fase moet eerst klaar zijn), maar ook waarom het model, eenmaal op gang, met een constante snelheid door kan ratelen. Of je nu gewoon efficiënter wil prompten of complexe softwarearchitecturen bouwt: kennis van de forward pass en inference is de sleutel tot succesvolle AI-implementaties.