Deel A · Module 04
Inferentie & sampling
Waarom is het niet deterministisch?
Leerdoelen
Na deze module kun je:
- voorspellen wat er met een kansverdeling gebeurt als je temperature, top-k of top-p verandert (en dat narekenen met softmax);
- uitleggen waarom dezelfde prompt verschillende antwoorden kan geven, waarom zelfs “temperature 0” geen garantie op identieke output is, en waarom één vroege keuze de rest van een antwoord (of een agent-run) meeneemt;
- aan een
stop_reasonzien waarom het genereren stopte, en kiezen hoe je een agent bouwt en test die niet op herhaalbaarheid kan rekenen.
Voorkennis-check
Twee vragen over eerdere modules. Fout? Lees die module eerst terug.
Waar zitten we?
Laag 1 van de stack: het model. Inferentie is de laatste stap van die laag: uit de scores van het netwerk wordt één token gekozen. De parameters die dit sturen (max_tokens, stop sequences, vroeger ook temperature) komen via de API in laag 2 aan de oppervlakte.
De stof in drie lagen
Kern ± 5 min
Een taalmodel genereert tekst één token tegelijk. Bij elke stap rekent het netwerk een logit uit voor elk token in de vocabulaire: een ruwe score. Softmax zet die scores om in kansen die optellen tot 1. Daarna moet er één token gekozen worden, dat aan de tekst wordt toegevoegd, waarna de lus opnieuw begint.
Dat kiezen is geen eigenschap van het netwerk maar een aparte stap: decoding of sampling. Twee uitersten:
- Greedy: neem altijd het token met de hoogste kans. Dit is deterministisch, maar leidt bij lange uitvoer tot saaie of zichzelf herhalende tekst.
- Sampling: trek een token volgens de kansen. Bij 79% voor “ Amsterdam” krijg je dat in ongeveer 79 van de 100 keer, en bij de andere 21 een ander token. Dit is de eerste, bedoelde reden dat dezelfde prompt andere uitvoer kan geven.
Drie knoppen sturen die trekking. Probeer ze hieronder uit en let op wat er verandert in de balken, in de entropie (een maat voor hoe “open” de verdeling is) en in het histogram van je trekkingen.
- Temperature deelt alle logits door T vóór de softmax. Lage T maakt de verdeling scherper (T → 0 komt neer op greedy), hoge T maakt hem vlakker.
- Top-k laat alleen de k meest waarschijnlijke tokens over.
- Top-p (nucleus) laat de kleinste groep tokens over waarvan de kansen samen minstens p halen.
De getallen in deze visual zijn illustratief: gekozen om het mechanisme te laten zien, niet gemeten aan een echt model. De rekenregels (softmax, top-k, top-p) zijn wel echt; in “Onder de motorkap” draai je ze zelf.
Waarom dit voor een agent-bouwer ertoe doet
Een agent is een lus van tientallen modelaanroepen (B3). Elke aanroep is een reeks trekkingen. Houd daarom rekening met drie dingen:
- Je kunt niet op identieke herhaling rekenen. Ook niet als je de temperature laag zet. Hieronder lees je waarom.
- Eén afwijking vroeg in een run werkt door. Het gekozen token wordt context voor alles wat volgt, en bij een agent geldt hetzelfde voor een gekozen tool-aanroep.
- Eén geslaagde run bewijst weinig. Evals moeten dezelfde taak meerdere keren draaien en een slagingspercentage rapporteren (D3).
Even with temperature set to 0, the results will not be fully deterministic, and identical inputs might produce different outputs across API calls.
Verdieping mechanisme en bronnen
Waarom niet gewoon altijd het meest waarschijnlijke token?
Het ligt voor de hand: als het model een kans geeft, neem dan de hoogste. Dat werkt voor korte, feitelijke antwoorden. Voor langere tekst werkt het slechter. De documentatie van Hugging Face zegt het zo:
Greedy search works well for tasks with relatively short outputs where creativity is not a priority. However, it breaks down when generating longer sequences because it begins to repeat itself.
Holtzman et al. (ICLR 2020) laten zien dat dit ook geldt voor methoden die de meest waarschijnlijke zin zoeken (beam search): de hoogste kans levert voor open tekst niet de beste tekst, maar vaak generieke, repetitieve tekst. Sampling uit de volledige verdeling gaat de andere kant op: de lange staart van onwaarschijnlijke tokens heeft samen genoeg massa om af en toe iets onzinnigs te trekken. Ze bepleiten daarom de staart af te kappen.
Temperature, top-k en top-p: drie manieren om de staart te beheersen
- Temperature verandert de vorm van de hele verdeling. Holtzman et al. merken op dat dit een prijs heeft:
while lowering the temperature improves generation quality, it comes at the cost of decreasing diversity
- Top-k kapt af op een vast aantal. Dat is grof: soms zijn drie kandidaten te veel (het model is zeker), soms te weinig (er zijn tientallen redelijke woorden).
- Top-p kapt af op een vaste hoeveelheid kansmassa, zodat het aantal kandidaten meebeweegt met de zekerheid van het model.
Under Nucleus Sampling, the number of candidates considered rises and falls dynamically
In de praktijk worden ze gecombineerd. De volgorde in de visual (en in veel implementaties, zoals Hugging Face generate) is: eerst temperature, dan top-k, dan top-p, dan hernormaliseren zodat de overgebleven kansen weer optellen tot 1. Dat is een conventie; andere bibliotheken kunnen een andere volgorde hanteren.
Autoregressief: één keuze beïnvloedt alles daarna
Een gekozen token wordt onderdeel van de invoer van de volgende stap. Het model heeft geen “rewind”: het ziet niet dat een token toevallig een laagkanskeuze was, alleen dat het in de tekst staat. Daardoor kan één vroege afwijking uitwaaieren. Probeer het hieronder: loop het scenario door, kies zelf of laat het model trekken, en spring met de tijdlijn terug om een andere afslag te nemen. Let op hoe de kansen verderop meeveranderen, en op de kans op het volledige pad.
Dit scenario is verzonnen en klein (vier kandidaten per stap). Het echte model rekent bij elke stap over de hele vocabulaire, maar het mechanisme is hetzelfde. Voor agents is het verlengde: een foute tool-aanroep of een misvatting in een eerdere turn blijft in de messages-lijst staan en kleurt alles wat volgt (B3, B4).
Waarom temperature 0 niet altijd 100% reproduceerbaar is
Bij T = 0 is de keuze greedy: er wordt niets getrokken. Als de uitvoer toch verschilt, zijn dus de logits verschillend. Dat kan, om twee redenen die samen gelden:
- Floating-point getallen zijn niet associatief.
(a + b) + ckan een ander resultaat geven dana + (b + c), omdat elke optelling afrondt. Wie dezelfde getallen in een andere volgorde optelt, krijgt een klein ander resultaat. - De volgorde hangt af van de batchgrootte. Inference-servers voegen verzoeken van verschillende gebruikers samen tot een batch. Volgens Thinking Machines Lab (Horace He, 2025) is het een rekenkernel die per batchgrootte een andere optelvolgorde kiest, en de belasting van de server (en dus de batchgrootte) is vanuit jou gezien willekeurig:
the primary reason nearly all LLM inference endpoints are nondeterministic is that the load (and thus batch-size) nondeterministically varies!
De afwijking in de logits is minuscuul. Pas als twee kandidaten bijna even hoog scoren, slaat de top om; en omdat generatie autoregressief is, wordt zo’n omslag bij het volgende token al een ander gesprek. Dezelfde bron meet het effect aan een open model (Qwen3-235B) bij temperature 0:
Surprisingly, we generate 80 unique completions, with the most common of these occuring 78 times.
Let op: dit is één meting aan één open model op één opstelling, bij één serverconfiguratie. Hoe vaak het bij een model van Anthropic gebeurt, is niet openbaar; de Anthropic-docs zeggen alleen dat het kan. De bron stelt ook dat het oplosbaar is (batch-invariante kernels), maar dat kost snelheid en zit niet in elke dienst.
Wat de Claude API hiervan exposeert
Dit onderdeel is veranderd, dus kijk altijd naar de actuele docs. De stand volgens de Anthropic-documentatie op 17 november 2026:
max_tokensenstop_sequenceszijn gewone parameters van de Messages API.max_tokensis een bovengrens; het model kan eerder stoppen. Een request kan ookstream: truezetten.temperature,top_pentop_kbestonden eerder, maar zijn in de API-referentie niet meer als parameters te vinden. Voor een lijst modellen (waaronder Claude Sonnet 5.5, Opus 5.5 en Haiku 5.5) geeft een niet-standaardwaarde een 400-fout, en vanaf API-versie2026-10-21geeft elke waarde een 400-fout op elk model. Zonder de parameters wordt er met de standaardwaarden gesampled (temperature 1,0).- Bij oudere modellen waren
temperatureentop_kniet te combineren met extended thinking.
Prompting is the recommended way to guide model behavior on Claude Opus 5.5.
Dat verschuift het werk. Waar je bij een open model (Hugging Face generate, Llama, Mixtral, lokaal via een server naar keuze) alle knoppen zelf hebt, stuur je bij de huidige Claude-modellen met je prompt, valideer je de uitvoer en bouw je op herhaling en meten in plaats van op determinisme. In de praktijk is “zet temperature op 0” dus geen betrouwbare betrouwbaarheidsstrategie, ook niet waar het nog kan.
Stopcondities: waarom houdt het genereren op?
De lus “kies een token, voeg toe, herhaal” stopt niet vanzelf. Er zijn drie redenen om te stoppen, en je API-response vertelt welke:
- Het model kiest zelf het einde. Een speciaal einde-token is ook gewoon een kandidaat in de verdeling. Wordt het getrokken, dan is het antwoord af:
stop_reason: end_turn. - Jouw limiet is bereikt.
max_tokenskapt af, midden in een zin of een JSON-object als het moet:stop_reason: max_tokens. Dit is geen “klaar”. De docs zeggen dat bij een afgekapte tool-aanroep een retry met hogere limiet nodig is. - Er verscheen een stopreeks die je zelf opgaf (
stop_sequences):stop_reason: stop_sequence, met welke het was.
Daarnaast kent de API tool_use (het model vraagt om een tool, B2), pause_turn, refusal en model_context_window_exceeded. Een robuuste loop heeft een tak per waarde (B1, B3).
Latency: time-to-first-token en tokens per seconde
Omdat tokens één voor één ontstaan, heeft een antwoord twee tijden. Eerst moet de hele prompt verwerkt worden voor het eerste token er is; dat is de time to first token. Daarna volgt de rest van het antwoord in een tempo van een aantal tokens per seconde.
Time to first token (TTFT) is a performance metric that measures the time it takes for a language model to generate the first token of its output after receiving a prompt.
Als vereenvoudiging: totale tijd ≈ TTFT + (aantal uitvoertokens ÷ tokens per seconde). Een lang antwoord kost dus lineair meer tijd; een lange prompt verhoogt vooral de TTFT. Streaming (stream: true) laat je de tokens tonen zodra ze er zijn, zodat een gebruiker na de TTFT al kan lezen. De totale tijd verandert er niet door. Voor een agent die toch eerst alle tool-aanroepen moet afwachten, helpt streaming vooral de eindgebruiker, niet de lus zelf.
Gevolgen voor het bouwen van agents
- Tool-calls en JSON willen lage variatie. Een afwijkend token in een JSON-sleutelnaam is een kapotte aanroep. Kun je de sampling niet meer instellen, beperk dan de vrijheid op andere manieren: korte, strikte schema’s, validatie in de harness (C2), en een tool_result met een duidelijke foutmelding zodat het model kan herstellen.
- Plan voor herhaling. Idempotente tools, retries met een bovengrens, en geen aanname dat een tweede run dezelfde stappen zet.
- Meet in runs, niet in voorbeelden. Een taak die in 9 van 10 runs slaagt, is een andere taak dan een die altijd slaagt. Bij een agent van n stappen met per stap kans s op goed gaan, is de kans op een foutloze run ongeveer sn: 0,9820 ≈ 0,67. Meer in D3.
Onder de motorkap formules en numpy-code
Softmax met temperature
formules
p_i = exp(z_i / T) / sum_j exp(z_j / T) z = logits, T = temperature
H = - sum_i p_i * log2(p_i) entropie in bits (0 * log 0 telt als 0)
Intuïtie: delen door T < 1 vergroot de afstanden tussen de logits, delen door T > 1 verkleint ze. Bij T → 0 wint steeds nadrukkelijker de hoogste logit (greedy); bij T → ∞ worden alle kansen gelijk. Dit is dezelfde formule als in Holtzman et al. (vergelijking 4). T = 0 zelf kun je niet invullen (deling door nul); implementaties behandelen het als argmax.
Met de logits uit de visual (Amsterdam 8,4; de 6,1; Den 5,6; …) en T = 1: trek het maximum af (exp(0) = 1, exp(6,1 − 8,4) = 0,100, exp(5,6 − 8,4) = 0,061, …). De som over alle twaalf is 1,265. Dus P(Amsterdam) = 1 ÷ 1,265 = 0,79 en P( de) = 0,100 ÷ 1,265 = 0,079.
Top-k en top-p
top-k en top-p
top-k: houd de k tokens met de hoogste p, zet de rest op 0, deel door de som van wat overblijft
top-p: sorteer p aflopend; houd de kleinste kop waarvan de cumulatieve som >= p; hernormaliseer
Top-p is de definitie uit Holtzman et al. (vergelijking 2 en 3): de kleinste verzameling V(p) met som ≥ p, herschaald naar som 1.
Sampler in numpy
Dit is dezelfde logica als de visual, in ongeveer 40 regels. Het bestand heet sampler.py; je hebt alleen numpy nodig.
sampler.py
import numpy as np
tokens = [" Amsterdam", " de", " Den", " Rotterdam", " een", " Utrecht",
" het", " in", " Amst", " ook", " niet", " geen"]
logits = np.array([8.4, 6.1, 5.6, 5.0, 4.7, 4.2, 3.9, 3.6, 3.1, 2.8, 2.2, 1.5])
def softmax(z, T=1.0):
z = z / T
z = z - z.max() # maximum aftrekken: voorkomt overflow
e = np.exp(z)
return e / e.sum()
def filter_top_k(p, k):
keep = np.argsort(-p)[:k] # indices van de k grootste kansen
q = np.zeros_like(p)
q[keep] = p[keep]
return q / q.sum() # hernormaliseren
def filter_top_p(p, top_p):
order = np.argsort(-p)
cum = np.cumsum(p[order])
n = int(np.searchsorted(cum, top_p - 1e-12)) + 1 # kleinste kop met cumulatief >= top_p
q = np.zeros_like(p)
q[order[:n]] = p[order[:n]]
return q / q.sum()
def sample(logits, rng, T=1.0, k=None, top_p=None):
if T == 0: # greedy: geen kansverdeling nodig
return int(np.argmax(logits))
p = softmax(logits, T)
if k is not None:
p = filter_top_k(p, k)
if top_p is not None:
p = filter_top_p(p, top_p)
return int(rng.choice(len(p), p=p))
def entropy_bits(p):
p = p[p > 0]
return float(-(p * np.log2(p)).sum())
if __name__ == "__main__":
for T in (0.5, 1.0, 2.0):
p = softmax(logits, T)
print(f"T={T}: P(Amsterdam)={p[0]:.3f} entropie={entropy_bits(p):.2f} bit")
p = filter_top_p(softmax(logits), 0.9)
print("top-p 0.9:", {t.strip(): round(float(x), 3) for t, x in zip(tokens, p) if x > 0})
for naam, kw in [("greedy", dict(T=0)), ("T=1", dict(T=1.0)),
("T=2", dict(T=2.0)), ("T=1, top_p=0.9", dict(T=1.0, top_p=0.9))]:
rng = np.random.default_rng(42) # vaste seed: herhaalbaar
trekkingen = [sample(logits, rng, **kw) for _ in range(1000)]
n_amst = trekkingen.count(0)
print(f"{naam:16s} Amsterdam {n_amst:4d}/1000, verschillende tokens: {len(set(trekkingen))}")
- Zonder deze regel geeft
exp(710)een overflow. Aftrekken van een constante verandert de uitkomst van softmax niet. - Na het afkappen tellen de kansen niet meer op tot 1; delen door de som herstelt dat.
searchsortedvindt de eerste positie waar de cumulatieve somtop_phaalt. De kleine1e-12vangt afrondingsruis op, zodat 0,9 precies op 0,9 niet net één token te veel of te weinig geeft.- Bij T = 0 is er niets te trekken. Alle andere paden gebruiken de RNG.
- Met dezelfde seed krijg je dezelfde trekkingen. Dat is precies wat een hosted API niet voor je regelt (en zelfs met seed zou de floating-point-ruis uit de volgende sectie blijven bestaan).
Floating-point: waarom optelvolgorde ertoe doet
float-optelling (Python)
print((0.1 + 0.2) + 0.3, 0.1 + (0.2 + 0.3), (0.1 + 0.2) + 0.3 == 0.1 + (0.2 + 0.3))
# 0.6000000000000001 0.6 False
float32-optelvolgorde (numpy)
import numpy as np
x = np.random.default_rng(0).standard_normal(10000).astype(np.float32)
a = np.float32(0)
for v in x: a += v # van voor naar achter
b = np.float32(0)
for v in x[::-1]: b += v # van achter naar voor
print(a, b, a == b, abs(a - b))
# 63.11896 63.118443 False 0.0005187988
Hetzelfde gebeurt in een matrixvermenigvuldiging met duizenden termen, in 16- of 32-bits getallen (nog grover dan de 64-bits floats van Python). De rekenkernel bepaalt de volgorde. Thinking Machines Lab laat zien dat het niet de ruwe parallelliteit van de GPU is die per aanroep een andere uitkomst geeft; dezelfde matrixvermenigvuldiging op dezelfde data geeft herhaaldelijk precies hetzelfde resultaat:
even on a GPU, running the same matrix multiplication on the same data repeatedly will always provide bitwise equal results.
De variatie komt van de batchgrootte (zie Verdieping). Hierboven zie je het effect van optelvolgorde zelf: 10.000 willekeurige float32-getallen, van voor naar achter en van achter naar voor opgeteld, geven een kleine afwijking (0,0005 op een som van ongeveer 63), omdat elke optelling afrondt. In een netwerk is zo’n verschil per getal minuscuul. Het wordt pas zichtbaar als twee logits bijna gelijk zijn.
Wat dit niet is
- De details van Claude (welke kernels, batchstrategie, of er intern nog sampling-instellingen zijn) zijn niet openbaar. Alles hierboven over inference-nondeterminisme komt uit open modellen en algemene bronnen, plus de zin van Anthropic dat het bij hen ook voorkomt.
- Seeds: een
seed-parameter regelt alleen de RNG van de trekking. Hij maakt de logits niet identiek.
Uitgewerkt voorbeeld: dezelfde logits, andere instellingen
Dit is de uitvoer van sampler.py (numpy 2.x, seed 42). Let op hoe dezelfde twaalf logits met andere instellingen een heel ander gedrag geven.
uitvoer van python3 sampler.py
T=0.5: P(Amsterdam)=0.984 entropie=0.14 bit
T=1.0: P(Amsterdam)=0.790 entropie=1.28 bit
T=2.0: P(Amsterdam)=0.412 entropie=2.84 bit
top-p 0.9: {'Amsterdam': 0.861, 'de': 0.086, 'Den': 0.052}
greedy Amsterdam 1000/1000, verschillende tokens: 1
T=1 Amsterdam 792/1000, verschillende tokens: 11
T=2 Amsterdam 412/1000, verschillende tokens: 12
T=1, top_p=0.9 Amsterdam 868/1000, verschillende tokens: 3
- Halve temperature: het verschil tussen de top en de rest verdubbelt in logit-ruimte. Amsterdam gaat van 79% naar 98% en de entropie zakt van 1,28 naar 0,14 bit: bijna deterministisch, maar niet helemaal.
- Standaard (T = 1) is de verdeling zoals het model hem bedoelt. De entropie is 1,28 bit; dat komt ongeveer overeen met het kiezen uit 2,4 gelijk waarschijnlijke opties (21,28).
- Top-p 0,9 houdt drie tokens over (samen 91,8% vóór hernormaliseren) en schaalt hun kansen op naar 1: Amsterdam gaat van 79,0% naar 86,1%. De negen andere tokens zijn niet meer te trekken.
- Over 1000 trekkingen bij T = 1 komt Amsterdam 792 keer voor, dicht bij de verwachte 790. Elf van de twaalf tokens komen ten minste één keer voor: dat is het “lange staart”-effect.
- Top-p verkleint dat tot drie verschillende tokens. De prijs is minder diversiteit; dat is hetzelfde ruil als bij een lagere temperature, maar zonder de verdeling zelf te vervormen.
De visual gebruikt een andere RNG dan numpy (een kleine seeded generator in JavaScript), dus de exacte trekkingen verschillen. De kansen niet: die komen uit dezelfde formules.
Breid de sampler uit en meet variatie
Opdracht
- Zet
sampler.py(uit “Onder de motorkap”) in een map. Installeernumpyen draai hem; controleer dat je dezelfde getallen krijgt als in het uitgewerkte voorbeeld. - Voeg min-p toe: houd alleen tokens met
p >= min_p * p.max(), en hernormaliseer. Probeermin_p = 0.05op de standaardverdeling (T = 1). - Voeg een repetition penalty toe: voor elk token dat al in de uitvoer staat deel je een positieve logit door de penalty (en vermenigvuldig je een negatieve ermee), vóór de softmax. Gebruik penalty 1,5 op “ Amsterdam” en kijk wat er met de verdeling gebeurt.
- Optioneel (meten op een echt model): stuur dezelfde prompt 10 keer naar een model naar keuze en tel hoeveel verschillende antwoorden je krijgt. Met een lokaal of open model (bijvoorbeeld via Hugging Face
generatemetdo_sample=True) kun je dit doen bij temperature 0,2, 0,7 en 1,2 en de variatie vergelijken (bijvoorbeeld het aantal unieke antwoorden of de lengte-spreiding). Met een huidig Claude-model kun je geen temperature zetten; dan meet je alleen de variatie bij de standaardinstelling, en je vergelijkt wat verschillende prompts doen.
Verwacht resultaat
Min-p 0,05: de drempel is 0,05 × 0,790 = 0,0395. Dat laat precies drie tokens over (Amsterdam, de, Den) met kansen 0,861, 0,086 en 0,052: dezelfde set als top-p 0,9, maar bereikt via een drempel die meebeweegt met de hoogste kans. Repetition penalty 1,5: de logit van Amsterdam gaat van 8,4 naar 5,6, de kans van 0,79 naar ongeveer 0,19, en “ de” (0,31) wordt het meest waarschijnlijke token. Een penalty die te groot is, drukt dus ook tokens weg die terecht herhaald moeten worden (denk aan een naam die vaker voorkomt). Optionele meting: bij een lokaal open model met één gebruiker zie je bij temperature (bijna) 0 meestal één antwoord, bij 1,2 bijna zoveel verschillende antwoorden als runs. Wijkt het bij temperature 0 toch af op een server met meerdere gebruikers, dan zie je het effect uit de Verdieping; hoe groot dat is, verschilt per opstelling.
Als het niet werkt, kijk naar …
ModuleNotFoundError: numpy: installeer numpy in je omgeving (python3 -m pip install numpy, bij voorkeur in een virtualenv).ValueError: probabilities do not sum to 1uitrng.choice: je bent vergeten te hernormaliseren na het filteren.- Min-p laat alles over, of niets: vergelijk met
p.max()van de kansen, niet van de logits, en doe het na de softmax. - Repetition penalty maakt de kans groter: je deelt een negatieve logit door een penalty > 1 en maakt hem daarmee minder negatief. Behandel positief en negatief apart.
- Andere getallen dan in de tekst: controleer de seed en de volgorde van RNG-aanroepen; de tellingen in het voorbeeld horen bij
default_rng(42)en numpy 2.x. De kansen (niet de tellingen) moeten altijd kloppen.