Deel A · Module 03

Training: pretraining, instructie, RLHF/RLAIF

Waarom gedraagt een model zich als assistent?

Zone: machine ± 15 min kern

Leerdoelen

Na deze module kun je:

  • voorspellen wat een base model doet met een vraag (aanvullen, niet antwoorden) en aanwijzen welke trainingsfase het assistent-gedrag toevoegt;
  • de cross-entropy loss van één voorspelling uitrekenen, en voorspellen hoe de loss zich gedraagt bij een te hoge learning rate of bij overfitting;
  • gedrag als weigeren, hallucineren, sycophancy en een kennis-cutoff herleiden tot een fase, en kiezen tussen prompting, RAG en fine-tuning.

Voorkennis-check

Twee vragen over eerdere modules. Fout? Lees die module eerst terug.

Waar zitten we?

Laag 1 van de stack: het model. Alles erboven (API, loop, harness) gebruikt een model waarvan de gewichten hier zijn vastgelegd. Deze module gaat over hoe die gewichten ontstaan, en dus waar gedrag vandaan komt dat jij later alleen nog kunt sturen.

De stof in drie lagen

Kern ± 5 min

Een model is niet van nature een assistent. Het wordt er een gemaakt, in drie stappen die steeds dezelfde techniek gebruiken (gewichten bijstellen om een fout te verkleinen) maar telkens met andere data en een andere vraag: wat is een goede uitvoer?

1. Pretraining: het volgende token voorspellen

Het model krijgt een enorme hoeveelheid tekst en moet bij elke positie het volgende token voorspellen. De fout daarbij heet de loss: hoe weinig kans gaf het model aan het token dat er echt stond? Na elke batch tekst worden de gewichten een klein stukje bijgesteld zodat die kans iets hoger wordt. Dat heet gradient descent. Miljarden stappen later heeft het model taal, feiten, stijlen en codepatronen opgepikt, simpelweg omdat die helpen om het volgende token te voorspellen.

Wat je overhoudt is een base model. Het kan tekst afmaken, maar het is geen assistent: een vraag is voor hem het begin van een document, en het kiest een waarschijnlijk vervolg. Dat kan een antwoord zijn, maar ook nog vijf vragen. Het kent bovendien alleen wat in zijn trainingsdata stond, tot een vaste datum.

2. Supervised fine-tuning (SFT): leren instructies te volgen

Mensen schrijven voorbeelden: een instructie en een goed antwoord. Het model wordt nogmaals getraind met dezelfde loss, nu op die voorbeelden. Het leert het formaat: instructie erin, antwoord eruit.

3. Voorkeuren: leren wat mensen goed vinden (RLHF, RLAIF)

Een demonstratie schrijven is duur, twee antwoorden vergelijken is goedkoop. Mensen kiezen welk van twee antwoorden beter is. Daarmee train je een reward model dat een score voorspelt, en daarna stel je het taalmodel bij zodat het antwoorden maakt met een hoge score. Bij RLAIF (Constitutional AI, Anthropic) doet een model die vergelijking, aan de hand van een lijst principes.

Klik hieronder door de fasen. Let op het antwoord op dezelfde prompt: het base model vervolgt, het SFT-model volgt de instructie, het voorkeursmodel is behulpzaam en weigert het schadelijke verzoek.

De brug naar agents

Dit is waarom prompting werkt maar nooit het model verandert. Training legt de gewichten vast. Een system prompt, een CLAUDE.md of een tool-resultaat staat in de context; het model leest dat, en zijn gewichten blijven gelijk. Je stuurt dus gedrag dat de training al heeft aangelegd (instructies volgen, toon, rol), maar je kunt het niet herschrijven. Drie gevolgen voor wie agents bouwt:

  • Hetzelfde verzoek kan bij elk model anders uitpakken, omdat de trainingsdata en de voorkeuren verschillen. Sturing werkt via de context en moet je per model testen (C1, D3).
  • Een instructie is een verzoek, geen garantie. Moet iets altijd of nooit gebeuren, bouw dat dan in de harness (C2).
  • Kennis na de cutoff of kennis die verandert, zit niet in de gewichten. Die lever je in de context (B5).

Zelf zien leren

Training is te groot om te zien, maar de kern past in een klein model. Hieronder leert een tabel van kansen op 1.200 tekens tekst welk teken op welk teken volgt (een bigram-model). Het begint met een gok (elk teken even waarschijnlijk, loss = ln 27) en wordt per stap beter. Train, genereer tussendoor, en zet de learning rate eens te hoog.

Let op twee dingen. De validatie-loss (op tekst die het model niet ziet) stopt met dalen eerder dan de train-loss, en gaat bij lang trainen weer omhoog: het model past zich aan de trainingstekst aan. Dat is overfitting. En een bigram-model ziet maar één teken terug: de gegenereerde tekst heeft de klank van Nederlands, maar geen betekenis. Een transformer (A2) kijkt naar de hele voorafgaande context, en daar komt de rest van wat een model kan vandaan.

Verdieping mechanisme en bronnen

Wat pretraining wel en niet leert

Het doel van pretraining is alleen volgend-token-voorspelling. De InstructGPT-auteurs wijzen erop dat dit niet hetzelfde doel is als “doe wat de gebruiker wil”:

This is because the language modeling objective used for many recent large LMs—predicting the next token on a webpage from the internet—is different from the objective “follow the user’s instructions helpfully and safely”

Schaal geeft schaal: GPT-3 is getraind op 300 miljard tokens, uit onder meer een gefilterde versie van Common Crawl, “nearly a trillion words” (Brown et al., 2020). Voor Claude zijn omvang, samenstelling en parameteraantal niet openbaar; in deze module staan open modellen als voorbeeld.

Een belangrijk neveneffect: een base model kan taken doen die je alleen in de prompt voordoet. Dat heet in-context learning of few-shot prompting. Het kost geen gradient-stap:

For all tasks, GPT-3 is applied without any gradient updates or fine-tuning, with tasks and few-shot demonstrations specified purely via text interaction with the model.

Dat verklaart waarom je een base model wel kunt gebruiken als “assistent”, door de prompt te schrijven als begin van een document waarin het antwoord het logische vervolg is. SFT en voorkeurstraining maken dat overbodig.

SFT: weinig data, andere vraag

SFT gebruikt dezelfde loss als pretraining, maar op voorbeelden van gewenst gedrag. Het kost veel minder data. Bij InstructGPT waren dat ongeveer 12.700 prompts met door labelers geschreven antwoorden (Tabel 6 in het paper: 11.295 van labelers en 1.430 van klanten), tegenover 300 miljard tokens bij GPT-3. SFT-modellen werden 16 epochs getraind, en overfitten op validatie-loss na één epoch, maar werden desondanks beter beoordeeld op voorkeur. Daarom zegt de validatie-loss hier niet alles: je meet wat je uiteindelijk wilt hebben.

RLHF: reward model en policy-optimalisatie

De methode komt uit onderzoek naar reinforcement learning, waar het moeilijk is om een beloningsfunctie te schrijven. Christiano et al. (2017) lieten mensen kiezen tussen twee korte fragmenten van gedrag en leerden daaruit een beloning:

In this work, we explore goals defined in terms of (non-expert) human preferences between pairs of trajectory segments.

InstructGPT past dit toe op taal in drie stappen: (1) SFT op demonstraties, (2) een reward model trainen op rankings (labelers rangschikten 4 tot 9 antwoorden per prompt), (3) het SFT-model bijstellen met reinforcement learning (PPO) om de score van het reward model te verhogen, met een strafterm om niet te ver van het SFT-model af te raken. Het reward model is zelf ook een taalmodel, met een scalaire uitvoer in plaats van tokens (6 miljard parameters in dat paper). De trainingsdata: ongeveer 33.200 prompts met rankings voor het reward model en 31.100 prompts voor de RL-stap (opgeteld uit Tabel 6).

Het effect was groot, voor een bescheiden deel van de rekenkracht:

In human evaluations on our prompt distribution, outputs from the 1.3B parameter InstructGPT model are preferred to outputs from the 175B GPT-3, despite having 100x fewer parameters.

Ouyang et al. (2022), abstract

De auteurs rapporteren voor het 175B-model 60 petaflops/s-days voor PPO-ptx, tegenover 3.640 voor GPT-3. De les: de duurste fase is niet de fase die het gedrag het meest verandert.

RLAIF en Constitutional AI

Mensen die schadelijke antwoorden beoordelen is duur en belastend. Bai et al. (Anthropic, 2022) vervangen dat deel door een model dat zijn antwoorden beoordeelt aan de hand van een lijst principes, een “constitution”:

The only human oversight is provided through a list of rules or principles, and so we refer to the method as ‘Constitutional AI’.

Er zijn twee fasen. In de eerste maakt het model een antwoord, bekritiseert het zelf volgens een principe, herschrijft het, en wordt het getraind op de herschreven antwoorden (supervised). In de tweede vergelijkt een model twee antwoorden volgens een principe; daaruit komt een preference model dat als beloning dient (RL from AI Feedback). Voor behulpzaamheid gebruikt het paper nog wel menselijke labels.

Wat Anthropic daar nu mee doet, staat deels in de aankondiging van Claudes constitution (januari 2026). De trainingsmethoden zijn sindsdien geëvolueerd, en de details zijn niet publiek. Wat er wel staat:

Claude itself also uses the constitution to construct many kinds of synthetic training data, including data that helps it learn and understand the constitution, conversations where the constitution might be relevant, responses that are in line with its values, and rankings of possible responses.

Reasoning en verifieerbare beloningen

Voor taken met een controleerbaar antwoord (wiskunde, code die tests haalt) is geen menselijke beoordelaar nodig: een programma kan de beloning bepalen. Dat heet reinforcement learning met verifieerbare beloningen. Twee openbare voorbeelden:

Here we show that the reasoning abilities of LLMs can be incentivized through pure reinforcement learning (RL), obviating the need for human-labeled reasoning trajectories.

Het open Tulu 3-recept noemt het expliciet als aparte fase (RLVR) na SFT en voorkeurstraining (Lambert et al., 2024, arxiv.org/abs/2411.15124). Welke methoden Anthropic voor Claude gebruikt, is niet openbaar; neem dit als illustratie van het principe.

Waar gedrag vandaan komt

GedragOorsprong (vereenvoudigd)Wat het voor jou betekent
Instructies volgen, antwoordvormSFT en voorkeurstrainingEen prompt is een instructie, geen document; je hoeft de prompt niet als begin van een document te schrijven.
Weigeren van schadelijke verzoekenVoorkeursdata en/of principes (RLHF, RLAIF)Grens verschilt per model en kan te streng of te los uitpakken. Test jouw use case; prompt kan het verschuiven, niet garanderen.
HallucinerenPretraining beloont een plausibel vervolg; de InstructGPT-auteurs noemen “making up facts” als gevolg van het mismatch-doel.Laat feiten uit tools of retrieval komen en controleer ze; vraag niet blind om “wees eerlijk”.
SycophancyVoorkeursdata: bevestigende antwoorden worden vaker verkozen (Sharma et al., 2023)Een agent die jouw plan prijst is geen review. Laat een tweede, onafhankelijke check doen (D3).
Knowledge cutoffEinde van de pretraining-dataAlles daarna moet in de context. Zie de huidige Claude-modellen: cutoff Jun 2026 (Anthropic docs).

Voor sycophancy is dit onderzocht door Anthropic:

Optimizing model outputs against PMs also sometimes sacrifices truthfulness in favor of sycophancy.

En voor de kennis-cutoff geeft Anthropic zelf de definitie:

The date through which the model’s knowledge is most extensive and reliable.

Fine-tunen, prompten of RAG?

ProbleemEerste keuzeWaarom
Toon, rol, werkwijze, projectregelsPrompt of CLAUDE.md (C1)Goedkoop, direct, per taak aan te passen, werkt zonder training.
Kennis die verandert of ontbreektRetrieval of tool (B5, B2)Gewichten leren geen actuele feiten; context wel, en je kunt bronnen tonen.
Vast formaat of stijl, duizenden voorbeelden, prompts worden te langFine-tunen (SFT)Je verplaatst voorbeelden van de prompt naar de gewichten. Kost data, training en onderhoud per modelversie.
Gedrag dat nooit mag mislukkenHook of check in de harness (C2)Geen enkele training garandeert iets in elk geval.

Of je een gesloten model kunt fine-tunen, hangt van de aanbieder en het model af; kijk in hun documentatie voordat je erop rekent.

Onder de motorkap loss, gradient, Bradley-Terry

Cross-entropy met getallen

Na de prompt “De hoofdstad van Frankrijk is” geeft het model scores (logits) aan vier kandidaat-tokens. Softmax maakt er kansen van. De loss van deze ene voorspelling is -ln(p) van het juiste token.

ce.py (standaardbibliotheek, uitvoer gecontroleerd)

import math
tokens = [" Parijs", " Lyon", " groot", " de"]
logits = [3.0, 1.0, 0.5, -1.0]

def softmax(z):
    m = max(z)
    e = [math.exp(x - m) for x in z]
    s = sum(e)
    return [x / s for x in e]

p = softmax(logits)
juist = tokens.index(" Parijs")
loss = -math.log(p[juist])
print(f"loss = -ln({p[juist]:.3f}) = {loss:.3f}")

grad = [pi - (1.0 if i == juist else 0.0) for i, pi in enumerate(p)]
print("gradient:", [round(g, 3) for g in grad])

logits2 = [z - 1.0 * g for z, g in zip(logits, grad)]
p2 = softmax(logits2)
print(f"na 1 stap: p = {p2[juist]:.3f}, loss = {-math.log(p2[juist]):.3f}")

Uitvoer: p(Parijs) = 0,809, loss = 0,212, gradient [-0,191, 0,110, 0,066, 0,015], en na één stap p = 0,848, loss = 0,164. Een model dat bij dezelfde vraag op “Lyon” zet (logits [1, 3, 0,5, -1]) geeft Parijs p = 0,110 en dus loss 2,212. Een gok over vier opties kost ln 4 = 1,386.

De gradient van de loss naar de logits is p - one-hot: het juiste token wordt omhoog geduwd met sterkte 1 - p, de andere omlaag met sterkte p. Is het model al zeker (p dicht bij 1), dan is de gradient klein: je leert weinig van wat je al weet.

Learning rate

Gradient descent zet w = w - lr * gradient. De gradient geeft de richting, de learning rate de stapgrootte. Te klein: dalen duurt eeuwen. Te groot: je springt over het dal heen en de loss klimt. In de visual zie je dat bij lr ≥ 100 voor dit model; de grens hangt af van het model en de data en wordt in echte training vaak bijgehouden met een schema (zoals de cosine learning rate decay in de InstructGPT-training).

Reward model: Bradley-Terry

Het reward model geeft een antwoord een getal r. Bij twee antwoorden is de kans dat mensen de gekozen verkiezen boven de afgewezene P = sigmoid(r_gekozen - r_afgewezen). Alleen het verschil telt, vergelijkbaar met Elo bij schaken. De trainings-loss is -ln P, dezelfde cross-entropy als hierboven maar over “welk van de twee”:

It can be understood as equating rewards with a preference ranking scale analogous to the famous Elo ranking system developed for chess (Elo 1978).

bt.py (standaardbibliotheek, uitvoer gecontroleerd)

import math
sigmoid = lambda x: 1 / (1 + math.exp(-x))
rm_loss = lambda rw, rl: -math.log(sigmoid(rw - rl))
for rw, rl in [(1.2, 0.4), (0.4, 1.2), (2.0, 2.0), (11.2, 10.4)]:
    d = rw - rl
    print(f"r_win={rw:5.1f} r_lose={rl:5.1f} P(win)={sigmoid(d):.3f} loss={rm_loss(rw, rl):.3f}")

Uitvoer: (1,2; 0,4) geeft P = 0,690 en loss 0,371; omgekeerd (0,4; 1,2) P = 0,310 en loss 1,171; gelijke scores geven P = 0,5 en loss 0,693; en beide scores met 10 verhoogd (11,2; 10,4) geeft exact dezelfde loss als de eerste. Het absolute niveau is dus vrij; daarom normaliseren de InstructGPT-auteurs het reward model met een bias voor de RL-stap.

De RL-doelfunctie met strafterm

Het paper maximaliseert niet de ruwe reward, maar:

objective(φ) = E[ r(x,y) - β · log( π_RL(y|x) / π_SFT(y|x) ) ] + γ · E[ log π_RL(x) ]

De tweede term (β) straft afwijking van het SFT-model; zonder die term kan het model de reward “hacken” met onzin die toevallig hoog scoort. De laatste term (γ, PPO-ptx) mengt pretraining-gradienten in, tegen prestatieverlies op standaard NLP-datasets. Proxy-beloning plus strafterm: precies de structuur waar sycophancy in kan sluipen als de proxy iets anders beloont dan je bedoelt.

Uitgewerkt voorbeeld: een bigram-model trainen in numpy

Dezelfde tekst, dezelfde split en dezelfde stappen als de visual hierboven, dus je ziet dezelfde getallen. Het script en corpus.txt staan in oefenrepo/a3-training/.

bigram.py

import numpy as np

tekst = open("corpus.txt").read().strip()
tekens = sorted(set(tekst))
V = len(tekens)
ix = {c: i for i, c in enumerate(tekens)}
d = np.array([ix[c] for c in tekst])
x, y = d[:-1], d[1:]
snit = int(len(x) * 0.8)
xt, yt, xv, yv = x[:snit], y[:snit], x[snit:], y[snit:]

def loss_en_grad(W, x, y):
    z = W[x]
    z = z - z.max(axis=1, keepdims=True)
    p = np.exp(z)
    p /= p.sum(axis=1, keepdims=True)
    loss = -np.log(p[np.arange(len(y)), y]).mean()
    p[np.arange(len(y)), y] -= 1
    G = np.zeros_like(W)
    np.add.at(G, x, p / len(y))
    return loss, G

W = np.zeros((V, V))
lr = 20.0
print(f"V = {V}, ln V = {np.log(V):.3f}")
for stap in range(0, 201):
    loss, G = loss_en_grad(W, xt, yt)
    if stap in (0, 10, 50, 100, 200):
        val, _ = loss_en_grad(W, xv, yv)
        print(f"stap {stap:3d}  train {loss:.3f}  val {val:.3f}")
    W -= lr * G

uitvoer

V = 27, ln V = 3.296
stap   0  train 3.296  val 3.296
stap  10  train 2.427  val 2.613
stap  50  train 2.119  val 2.372
stap 100  train 2.051  val 2.350
stap 200  train 2.012  val 2.367
  1. Elke positie levert een paar: huidig teken (input) en volgend teken (doel). Het model ziet maar één teken terug, dat maakt het een bigram-model.
  2. De laatste 20% blijft buiten de training en dient voor de validatie-loss. Dezelfde rol heeft een held-out set in echte training.
  3. Het “model” is een tabel: rij = huidig teken, kolom = score (logit) voor elk volgend teken. Dit is de enige parameter-matrix; echte modellen vervangen de tabel door een transformer, maar de loss en de update zijn identiek.
  4. De cross-entropy: het gemiddelde van -ln p van het juiste teken. Dit is hetzelfde getal als de berekening in “Onder de motorkap”.
  5. De gradient naar de logits: p - one-hot. Het juiste teken krijgt p - 1 (negatief, dus omhoog geduwd), de andere p.
  6. Nulgewichten betekent uniforme kansen, dus de loss begint op ln 27 = 3,296: even slecht als gokken. Elke dalende loss daaronder is geleerde structuur.
  7. Probeer 0,5 en 500. Bij 500 klimt de loss (instabiel); bij 0,5 duurt het ruim 300 stappen voordat je onder 2,5 komt.
  8. De update: een stap tegen de gradient in. Validatie-loss daalt eerst mee en zakt vanaf ongeveer stap 100 niet meer: de tabel gaat zich aan de trainingstekst aanpassen (overfitting).
Doe-opdracht

Laat een model leren, en vergelijk base met instruct

Tijd: 30 tot 60 minuten. Deel A is verplicht en draait overal; deel B is een optionele uitbreiding en vraagt een download van ongeveer 1 GB.

Opdracht A: bigram-training (Karpathy-stijl)

  1. Ga naar oefenrepo/a3-training/ en installeer numpy (python3 -m pip install numpy). Draai python3 bigram.py.
  2. Verander lr naar 0,5, 20 en 500 en noteer de train-loss na 50 stappen. Welke is het snelst, welke is instabiel?
  3. Lees de gegenereerde tekst na stap 0 en stap 200 (roep genereer(W) aan voor je traint en erna). Wat is er veranderd, en wat niet?
  4. Vervang het eigen corpus door een eigen tekstbestand van ongeveer 5.000 tekens. Wat doet het met de bodem en met het verschil tussen train en validatie?
  5. Uitbreiding: geef het model twee tekens context in plaats van één (de rij is dan d[i]*V + d[i+1] en de tabel krijgt V*V rijen). Vergelijk train- en validatie-loss met de bigram.

Opdracht B (optioneel): base en instruct naast elkaar

Qwen2.5-0.5B bestaat als base model en als instruct-variant. De model card van het base model zegt: We do not recommend using base language models for conversations. Vergelijk ze met dezelfde prompt:

vergelijk.py (niet gedraaid in de bouwomgeving van deze module; vereist pip install torch transformers)

from transformers import AutoModelForCausalLM, AutoTokenizer

prompt = "Wat is de hoofdstad van Australië?"
for naam in ["Qwen/Qwen2.5-0.5B", "Qwen/Qwen2.5-0.5B-Instruct"]:
    tok = AutoTokenizer.from_pretrained(naam)
    model = AutoModelForCausalLM.from_pretrained(naam)
    if naam.endswith("Instruct"):
        tekst = tok.apply_chat_template(
            [{"role": "user", "content": prompt}],
            tokenize=False, add_generation_prompt=True)
    else:
        tekst = prompt               # base model: gewoon tekst, geen chat-sjabloon
    inp = tok(tekst, return_tensors="pt")
    uit = model.generate(**inp, max_new_tokens=60, do_sample=False)
    print(naam, "->", repr(tok.decode(uit[0][inp.input_ids.shape[1]:], skip_special_tokens=True)))
Verwacht resultaat

A. De uitvoer begint op V = 27, ln V = 3.296 en volgt de tabel uit het uitgewerkte voorbeeld: train 2,427 en val 2,613 na 10 stappen, train 2,012 en val 2,367 na 200. Met lr = 0.5 ben je na 200 stappen nog boven 2,5; met lr = 500 springt de loss rond of komt hij ver boven 3,3. De gegenereerde tekst gaat van willekeurige tekens naar Nederlands-achtige klanken (korte woorden, spaties op logische plekken) zonder betekenis. Met twee tekens context zakt de train-loss lager (bij mij 1,28 na 200 stappen met lr = 20), maar de validatie-loss is niet beter dan bij de bigram (2,45 tegenover 2,37): meer context levert op een klein corpus vooral onthouden op.

B. Ik kon dit niet in deze omgeving draaien, dus de precieze uitvoer is niet gemeten. Wat je mag verwachten: het base model zet de tekst voort en geeft niet noodzakelijk een antwoord (bijvoorbeeld nog een vraag of een los fragment); het instruct-model geeft een kort antwoord als assistent. Dat verschil is de les; de precieze tekst kan per versie verschillen.

Als het niet werkt, kijk naar …
  • ModuleNotFoundError: numpy: installeer numpy in de omgeving die je gebruikt (python3 -m pip install numpy).
  • FileNotFoundError: corpus.txt: draai het script vanuit de map oefenrepo/a3-training/.
  • Andere getallen dan hierboven: controleer dat je dezelfde corpus.txt gebruikt (1.209 tekens, 27 verschillende tekens) en een split van 80/20 zonder shuffle.
  • Loss wordt nan: lr is veel te hoog, of je hebt de - z.max(...)-regel (stabiele softmax) weggelaten.
  • B: base model blijft praten of herhaalt de prompt: dat is geen fout. Gebruik max_new_tokens om af te kappen. Geeft het instruct-model rare tekens, controleer dat je apply_chat_template gebruikt.

Zelftoets