Skip to main content
§ Video

Hoe ChatGPT echt werkt, zonder de wiskunde

Bekijk op YouTube ↗

Er zit geen kleine expert achter het chatvenster, en er is geen bibliotheek met afgewerkte antwoorden die zit te wachten om opgevraagd te worden. Onder de motorkap staat een heel grote verzameling getallen die steeds dezelfde basisbeweging uitvoert.

Dit is om een praktische reden de moeite waard om te begrijpen, niet om een academische. Wie het mechanisme eenmaal ziet, houdt op de typische fouten van het model mysterieus te vinden en begint ze voorspelbaar te vinden — dat is het verschil tussen hopen dat een AI-systeem zich gedraagt en er beheersmaatregelen omheen kunnen ontwerpen.

Laten we dus één prompt volgen, van begin tot eind. (Dit beschrijft de algemene architectuur van decodermodellen in GPT-stijl; de interne techniek van een specifiek commercieel product is niet volledig publiek.)


Tekst wordt tokens

Lang voordat u iets typt, wordt het model getraind op enorme tekstverzamelingen — websites, boeken, artikelen, documentatie, conversaties, code — gefilterd, opgeschoond en grotendeels gededupliceerd. Maar het model kan geen alinea's doorslikken. Tekst wordt eerst omgezet in tokens.

Een token kan een heel woord zijn, een deel van een woord, leesteken, of een spatie plus nabijgelegen letters. Een veelvoorkomend woord is misschien één token; een ongewone naam wordt in verschillende stukken verdeeld. Daarom kunnen modellen vreemd slecht zijn in letters tellen of zeldzame spellingen behandelen — ze zien tekst niet zoals u. Ze zien een reeks token-ID's, en dat zijn gewoon getallen uit een woordenlijst.


Getallen worden betekenis

Een token-ID is slechts een label. Token 8.421 is op zichzelf niet wijzer dan token 8.420. Daarom wordt elke token afgebeeld op een embedding: een lange lijst geleerde numerieke kenmerken, die u kunt zien als een startcoordinaat op een enorme kaart.

Die coördinaten krijgen tijdens de training structuur. "King" eindigt dichter bij "queen" dan bij "microwave". Volgorde telt ook — de hond achtervolgde de kat is niet de kat achtervolgde de hond — dus coderen transformers positie naast identiteit, met positionele embeddings of roterende positie-informatie.

Cruciaal is dat deze representaties contextueel worden naarmate ze door het netwerk bewegen. "Bank" in "de oever van de rivier" ontwikkelt zich anders dan "bank" in "de bankrekening". Betekenis wordt niet opgehaald uit een permanent woordenboekitem; ze wordt geconstrueerd uit de omringende tekst.


Attention: wat er op dit moment toe doet

De transformer bestaat uit veel herhaalde blokken. Elk blok laat informatie tussen tokens stromen en transformeert die vervolgens verder. Het beroemde onderdeel is self-attention.

Neem de zin: "De trofee paste niet in de koffer omdat hij te groot was." Wat was te groot? Om "hij" op te lossen, heeft het model eerdere context nodig. In een causaal model in GPT-stijl kan elke positie zichzelf gebruiken en de posities daarvoor, maar tijdens het genereren niet spieken naar toekomstige tokens.

Binnen attention produceert elke positie drie projecties — een query, een key en een value. De query vertegenwoordigt wat de huidige positie nodig heeft; keys beschrijven waar andere posities op kunnen matchen; values dragen de informatie die ze bijdragen. Het model vergelijkt queries met keys, zet de matches om in attentionsterktes en mengt de bijbehorende values.

Meerdere attention-heads lopen parallel en kunnen verschillende relaties vastleggen — nabijgelegen grammatica, verre verwijzingen, patronen in code. Het is verleidelijk om zich elke head voor te stellen met één net, menselijk leesbare taak. Neurale netwerken organiseren zich zelden zo beleefd.

Elk blok koppelt attention (context verzamelen) aan een feedforward-netwerk (transformeren wat elke positie heeft geleerd), en residuële verbindingen helpen eerdere informatie de tocht door vele lagen te overleven. Herhaal het blok vaak genoeg en simpele tokenrepresentaties worden veel rijkere contextuele representaties.


Training is geen encyclopedie uploaden

Tijdens de pre-training speelt het model herhaaldelijk het spel van volgende-token-voorspelling. Geef het "De hoofdstad van Frankrijk is" en vraag wat erop volgt. In het begin gokt een ongetraind model in feite — het zou "banaan" kunnen kiezen.

Het systeem vergelijkt de voorspellingen met de werkelijke volgende tokens en berekent een loss: een getal dat uitdrukt hoe fout het zat. Backpropagation werkt de berekening achterwaarts af om te bepalen hoe elke instelbare parameter aan de fout heeft bijgedragen, en een optimalisator duwt die parameters in richtingen die de toekomstige loss naar verwachting verlagen. Dan herhaalt het, op meer tekst. Voorspellen, meten, terugwerken, bijstellen.

Die parameters zijn de weights — miljarden stuks, elk gewoon een getal. Eén enkele weight bevat geen feit en geen vaardigheid. Nuttige patronen liggen verspreid over vele parameters; kennis is gedistribueerd. De weights zijn een gecomprimeerd statistisch model van geleerde patronen, inclusief de hiaten, tegenstrijdigheden en vooringenomenheden van de data. Modellen zijn geen doorzoekbare kopieën van hun datasets.

Pre-training levert een capabele tekstvoorspeller, geen behulpzame assistent. Dat doet post-training: voorbeelden van instructies en goede antwoorden, vervolgens menselijke of model-feedback en preferentie-optimalisatie om gewenste antwoorden waarschijnlijker te maken. Pre-training leert patronen; post-training leert het model zich niet te gedragen als een eigenwijze internet-autocomplete.


Inferentie: één token per keer

Wanneer u het model daadwerkelijk gebruikt, bewegen de wijzers niet meer. De weights blijven bevroren.

Uw prompt wordt tokens, passeert de lagen, en het model produceert een score — een logit — voor elke token in zijn woordenlijst. Een decoderingsstrategie kiest er één, voegt die toe, en het hele proces draait opnieuw. Het antwoord wordt token na token gegenereerd.

Alles wat het model hiervoor kan gebruiken, moet binnen zijn actieve context liggen: uw prompt, eerdere berichten, systeeminstructies, toolresultaten. Context is tijdelijk werkmateriaal — niet de getrainde weights, en geen permanent geheugen.

Omdat genereren sequentieel is, zou het opnieuw verwerken van een lang gesprek voor elke nieuwe token verspilling zijn. Vandaar een van de minst glamoureuse namen in AI: de KV-cache. Wanneer eerdere tokens worden verwerkt, worden hun key- en value-vectoren opgeslagen en hergebruikt, zodat alleen de nieuwe query, key en value berekend moeten worden. Dat maakt genereren veel sneller en verbruikt aanzienlijk geheugen — een dure stapel notities, geen dagboek.

Tot slot: sampling. Altijd de hoogst scorende token kiezen maakt output stijf en repetitief, dus sampling staat variatie toe. Temperatuur herschaalt de logits: een hogere temperatuur vlakt de verdeling af en geeft onwaarschijnlijkere kandidaten meer kans. Het beïnvloedt variatie, geen kennis — de temperatuur verlagen maakt een model niet beter geïnformeerd.


Waarom vlotte modellen hallucineren

Nu verklaart het mechanisme de fout. Pre-training minimaliseert de voorspellingsloss. Die verifieert niet rechtstreeks of een bewering waar is.

Als geleerde patronen een antwoord ondersteunen dat overtuigend klinkt, kan het model het genereren zelfs wanneer de bewering fout is. Het kan feiten mengen, een verwijzing verzinnen, of iets met totale overtuiging beschrijven dat nooit heeft bestaan. Zoeken, retrieval en toolgebruik kunnen de onderbouwing verbeteren — maar ze hangen bewijs aan een systeem dat nooit op waarheid is geoptimaliseerd.

Vloeiend taalgebruik is bewijs dat het model goed is in taal. Het is geen bewijs dat de werkelijkheid heeft ingestemd.

Dat onderscheid is de hele basis om verificatie als een operationele beheersmaatregel te behandelen in plaats van als een extraatje — precies waar de AI-geletterdheidsplicht uit de AI-verordening op doelt.


En hoe het op kleinere hardware past

Weights worden op een gekozen numerieke precisie opgeslagen. Minder bits gebruiken vermindert zowel het geheugen dat ze innemen als de data die de hardware moet verplaatsen. Stel u voor dat u elke wijzer met extreem fijne precisie opneemt en dan beslist dat minder posities nauwkeurig genoeg zijn.

Bij overhead buiten beschouwing gelaten: 70 miljard weights hebben bij 16 bits ruwweg 140 GB nodig, maar bij 4 bits ongeveer 35 GB. Dat is kwantisatie, en het is een echte technische afweging — het onderwerp van het artikel over lokale AI.


De hele reis

Tekst wordt tokens. Tokens worden numerieke representaties. Transformers bouwen context. Training stelt weights bij. Post-training vormt de assistent. Tijdens inferentie genereren bevroren weights één token per keer, levert het contextvenster tijdelijke werkinformatie en vermijdt de KV-cache attentionwerk te herhalen.

Geen van die onderdelen is op zichzelf magie. Het opmerkelijke gedrag komt uit hun schaal en hun samenwerking. Waar u mee werkt is een getraind voorspellingssysteem: krachtig, imperfect, en volkomen capabel om "zeker" te zeggen vlak voordat het uw middag verpest.