Tools die chatten, samenvatten en code schrijven lijken bijna magisch, totdat je het mechanisme eronder ziet. Een groot taalmodel, of LLM, is in wezen een zeer geavanceerd systeem voor het voorspellen van het volgende stuk tekst. Dat ene idee verklaart zowel wat deze tools goed doen als waarom ze falen op de manier waarop ze dat doen.

Deze gids legt de belangrijkste concepten uit zonder enige wiskunde en bouwt vervolgens een kleine voorspeller voor het volgende woord om het idee concreet te maken. We hebben die code uitgevoerd op Python 3.13 en de uitvoer komt uit die run. Het is een eenvoudig telspeeltje in plaats van een neuraal netwerk, en echte LLM’s zijn veel capabeler. We vermijden ook het vermelden van cijfers voor specifieke modellen, omdat deze snel veranderen.

Wat is een groot taalmodel?

Een LLM is een vorm van kunstmatige intelligentie die is getraind om menselijke taal te begrijpen en te genereren. Laten we de naam woord voor woord nemen:

• Groot: het heeft een groot aantal aanpasbare interne waarden, parameters genoemd, en leert van een enorme hoeveelheid tekst.
• Taal: het werkt met tekst, inclusief natuurlijke taal en code.
• Model: het is een wiskundig systeem dat patronen uit gegevens haalt en deze gebruikt om voorspellingen te doen.

Modellen zijn de motor en producten zoals chatassistenten zijn de auto die eromheen is gebouwd. Een product voegt vaak een gebruikersinterface, veiligheidssystemen, zoek- en andere tools toe.

Het kernidee: voorspellen wat er daarna komt

Dit doe je zelf. Als je leest ‘de hoofdstad van Frankrijk is’, denk je meteen aan ‘Parijs’. Een LLM doet iets vergelijkbaars, maar dan op veel grotere schaal. Gegeven wat tekst, berekent het hoe waarschijnlijk elk mogelijk volgend token is, kiest er één, voegt het toe aan de tekst en herhaalt het.

Er wordt geen database met opgeslagen antwoorden opgezocht. Het model bevat patronen die tijdens de training zijn geleerd, in de vorm van cijfers. Wanneer deze patronen overeenkomen met de waarheid, krijg je een correct antwoord. Doen ze dat niet, dan kun je alsnog een vloeiend antwoord krijgen, en dat is een belangrijk verschil met een zoekmachine.

Een kleine werkende demo

Om de voorspelling van de volgende token in de eenvoudigste vorm te zien, telt dit script welk woord op welk woord volgt in een kleine tekst. Vervolgens genereert het nieuwe tekst op basis van die tellingen. Statistici noemen dit een bigrammodel.

import random
from collections import Counter, defaultdict

TEXT = """the cat sat on the mat . the dog sat on the rug .
the cat saw the dog . the dog saw the cat ."""

tokens = TEXT.split()

follows = defaultdict(Counter)
for current, following in zip(tokens, tokens[1:]):
    follows[current][following] += 1

def probabilities(word):
    counts = follows[word]
    total = sum(counts.values())
    return {w: round(n / total, 2) for w, n in counts.most_common()}

print(probabilities("the"))
print(probabilities("sat"))

# {'cat': 0.38, 'dog': 0.38, 'mat': 0.12, 'rug': 0.12}
# {'on': 1.0}

Die output is een waarschijnlijkheidsverdeling. Na “de” beschouwt het model “kat” en “hond” het meest waarschijnlijk. Nu genereren we tekst door herhaaldelijk steekproeven te nemen uit deze waarschijnlijkheden:

def generate(start, length, seed):
    rng = random.Random(seed)
    words = [start]
    for _ in range(length):
        counts = follows[words[-1]]
        words.append(rng.choices(list(counts), weights=counts.values())[0])
    return " ".join(words)

print(generate("the", 6, seed=1))
print(generate("the", 6, seed=2))
print(generate("the", 6, seed=3))

# the cat . the cat saw the
# the rug . the cat . the
# the cat saw the dog . the

Let op drie dingen. Hetzelfde begin kan verschillende teksten opleveren, omdat de keuze willekeurig is. De uitvoer lijkt op de trainingsgegevens, zelfs voor reeksen die er nooit in zijn verschenen. En het heeft helemaal geen begrip, daarom leest “het vloerkleed. de kat” als onzin.

Vraag het naar een woord dat het nog nooit heeft gezien, en het heeft niets te bieden: follows["elephant"] is leeg. Ons speelgoed kijkt slechts naar één vorig woord. De enorme sprong in echte LLM’s komt voort uit het overwegen van lange stukken context en het leren van veel meer gegevens, waarbij gebruik wordt gemaakt van een neuraal netwerk in plaats van een simpele telling.

Tokens: hoe een model leest

LLM’s lezen geen hele woorden zoals wij. Tekst wordt eerst opgesplitst in tokens, die een woord, een deel van een woord of leestekens kunnen zijn. Elk token is gekoppeld aan een getal en het model werkt volledig met getallen.

Tokens zijn in de praktijk om twee redenen belangrijk. Het gebruik van gehoste modellen wordt gewoonlijk geprijsd op basis van tokens, en elk model heeft een limiet voor het aantal dat het tegelijk kan verwerken. Tokenisatie verklaart ook een aantal bekende vreemde gedragingen. Omdat modellen brokken zien in plaats van letters, zijn taken zoals het tellen van de letters in een woord traditioneel verrassend moeilijk voor hen.

Inbedding: betekenis als getallen

Elk token wordt omgezet in een inbedding, een lange lijst met getallen die het in een soort betekenisruimte plaatst. Verwante concepten komen dicht bij elkaar terecht, dus ‘kat’ en ‘kitten’ hebben nabijgelegen posities, terwijl ‘kat’ en ‘factuur’ dat niet doen.

Hetzelfde idee drijft semantisch zoeken aan, waarbij je documenten vindt op basis van betekenis in plaats van exacte woorden. Onze vectordatabasegids behandelt dat gebruik.

Aandacht en de transformator

De meeste moderne LLM’s zijn gebaseerd op de transformator-architectuur, geïntroduceerd door Google-onderzoekers in het artikel ‘Attention Is All You Need’ uit 2017. Het belangrijkste mechanisme ervan is zelfaandacht.

Denk eens aan deze zin: “De trofee paste niet in de koffer omdat hij te groot was.” Waar verwijst ‘het’ naar? Je weet dat het de trofee betekent. Met aandacht kan een model elk eerder token wegen bij het verwerken van elk nieuw token, zodat het ‘het’ kan koppelen aan de meest relevante woorden, zelfs als deze ver uit elkaar liggen.

Eerdere benaderingen verwerkten tekst stap voor stap en hadden de neiging verre woorden uit het oog te verliezen. Transformers kijken samen naar de hele context, en ze kunnen een groot deel van dit werk parallel uitvoeren op gespecialiseerde hardware, wat training over zulke grote hoeveelheden tekst praktisch maakte.

Hoe een LLM wordt opgeleid

Vooropleiding geeft een model een brede taalvaardigheid, maar het kan zijn dat u uw tekst gewoon voortzet in plaats van deze te beantwoorden. De latere stadia vormen het tot een nuttige assistent. Het trainen van grote modellen vergt aanzienlijke rekenkracht en is duur. Het gebruik van een kant-en-klaar model, bekend als inferentie, is per verzoek veel goedkoper.

Hoe het tekst genereert

1. Uw prompt wordt opgesplitst in tokens en omgezet in insluitingen.
2. Het netwerk verwerkt ze en gebruikt aandacht om ze met elkaar in verband te brengen.
3. Het geeft een waarschijnlijkheid weer voor elk mogelijk volgend token.
4. Er wordt één token geselecteerd en aan de context toegevoegd.
5. Stappen 2 tot en met 4 worden herhaald totdat een stopconditie wordt bereikt.

Dit is de reden waarom antwoorden doorgaans woord voor woord verschijnen wanneer ze worden gestreamd. De tekst wordt letterlijk in volgorde geproduceerd. Temperatuur bepaalt hoe avontuurlijk stap 4 is: lage waarden geven de voorkeur aan de meest waarschijnlijke tokens, terwijl hogere waarden meer variatie mogelijk maken.

Voorwaarden waaraan u zult voldoen

Beperkingen die u moet kennen

• Hallucinaties. Een model kan feiten, citaten of codefuncties verzinnen. Omdat het waarschijnlijke tekst oplevert, kunnen valse verklaringen volkomen plausibel lijken.
• Kennislimiet. Tenzij een product verbinding maakt met zoeken of andere tools, is het mogelijk niet op de hoogte van recente gebeurtenissen.
• Beperkte context. Als een gesprek het contextvenster overschrijdt, kunnen eerdere details worden verwijderd of samengevat. Modellen onthouden ook niet automatisch eerdere chats, tenzij een product die functie toevoegt.
• Vooroordelen. Trainingsgegevens weerspiegelen menselijke vooroordelen, en deze kunnen in de resultaten voorkomen.
• Inconsistentie. Dezelfde vraag kan verschillende antwoorden opleveren, wat belangrijk is als je er software bovenop bouwt.
• Beveiligingsrisico’s. Verborgen instructies in tekst kunnen een model manipuleren, een probleem dat bekend staat als prompt injection.

LLM’s goed gebruiken

Behandel een LLM als een snelle, bekwame assistent wiens werk moet worden beoordeeld. Een paar gewoonten maken een groot verschil:

• Wees specifiek. Duidelijke instructies, context en voorbeelden zorgen voor betere resultaten. Onze gids voor snelle engineering laat zien hoe.
• Geef de feiten aan. Als de antwoorden uit uw eigen documenten moeten komen, gebruik dan RAG in plaats van op uw geheugen te vertrouwen.
• Controleer wat belangrijk is. Controleer cijfers, citaten en juridische of medische claims aan de hand van betrouwbare bronnen.
• Test de gegenereerde code. Voer de code uit en schrijf er tests voor, zoals u zou doen voor die van een collega. Onze gids AI-codebeoordelingstools biedt enige hulp.
• Bescherm gevoelige gegevens. Controleer de regels van uw organisatie voordat u vertrouwelijke informatie deelt met een gehoste tool.

Als u besluit hoe u een model voor uw eigen werk wilt aanpassen, helpt onze vergelijking van RAG versus fijnafstemming versus snelle engineering u bij uw keuze.

Tot slot

Een LLM is een next-token-voorspeller die op buitengewone schaal is getraind, en is nuttiger en feilbaarder dan die beschrijving suggereert. Als u het mechanisme in gedachten houdt, kunt u het goed gebruiken: het is sterk in taal en patronen en heeft uw toezicht op de feiten nodig. Om het concreet te maken, voert u het kleine script hierboven uit met uw eigen tekst, probeert u vervolgens dezelfde prompt meerdere keren in een echte assistent en vergelijkt u de antwoorden.

Veelgestelde vragen

Blijf leren