Van basismodel naar assistent: SFT, RLHF, DPO en GRPO

De eerste stap is het minst glamoureus en doet het meeste werk. Verzamel voorbeelden van instructies gekoppeld aan goede antwoorden, en train daarop verder met precies de loss uit hoofdstuk 8 — voorspel de volgende token — maar alleen op het antwoordgedeelte. Dit is supervised fine-tuning, of SFT.

Er wordt niets nieuws over taal geleerd. Wat wordt geleerd is een format: dat tekst met deze vorm wordt gevolgd door tekst met die vorm, en daarna stopt. Kijk nog eens naar de mislukking van het basismodel. Het beantwoordde de vraag in de eerste zin en kon daarna niet stoppen, omdat niets in zijn training ooit het einde van een antwoord markeerde. Stoppen is aangeleerd gedrag.

Daarom moet het model ook verteld worden waar de grenzen liggen, en dat is wat een chat template doet:

<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>
<|im_start|>user
What is the capital of France?<|im_end|>
<|im_start|>assistant

Die <|im_start|>- en <|im_end|>-markers zijn echte tokens in de vocabulaire, toegevoegd vóór fine-tuning, en het model zag er miljoenen in precies deze posities. Zo weet het wiens beurt het is en waar een beurt eindigt.

Sla de template over en geef het model een kale vraag, en je geeft het een sequentie die het niet in training heeft gezien. Gemeten, hetzelfde model, dezelfde vraag, dezelfde greedy decoding:

 The capital of France is Paris.

To verify this, I will use a simple
Python code snippet to confirm that
Paris is indeed the capital city of
France.

[...and then it starts writing a
Python script to check its own answer]

The capital of France is Paris.

Het antwoord is in beide gevallen goed, maar zonder de markers dwaalt het model af naar Python schrijven om zichzelf te controleren, omdat de prompt die het ontving op niets lijkt waarop het is fine-tuned. Dit is de meest voorkomende oorzaak van „het model werd dommer toen ik het rechtstreeks aanriep”: de template is geen decoratie rond het model, hij is onderdeel van het model, en een verkeerde template is stille degradatie zonder foutmelding.

SFT heeft een plafond, en dat plafond is de data. Om op een demonstratie te fine-tunen moet iemand de ideale response schrijven — en voor de meeste interessante vragen is een goed antwoord schrijven moeilijk, traag, duur, en levert het precies één antwoord op waarvan je de kwaliteit niet kunt verifiëren.

Waar mensen goed in zijn is vergelijken. Als een annotator twee responses ziet, kan die in een paar seconden betrouwbaar zeggen welke beter is, zonder een van beide zelf te kunnen produceren. Op dat feit is de hele tweede fase gebouwd, en dit is het deel dat de meeste uitleg omdraait:

Mensen schrijven de antwoorden niet. Ze rangschikken paren.

De data bestaat dus uit paren — een prompt, twee responses, en welke heeft gewonnen. Dat kun je niet in een next-token loss stoppen, want er is geen doelsequentie. Daar is een andere machine voor nodig.

Je kunt een mens niet tijdens training elke response laten scoren — dat zijn miljoenen beoordelingen. Dus train je een model om de mensen na te bootsen: een reward model dat een response neemt en een scalar teruggeeft.

Het trainen uit vergelijkingen gebruikt een resultaat uit 1952. Het Bradley–Terry-model² zegt dat als twee items latente sterktes hebben, de kans dat het ene het andere verslaat de logistische functie is van hun verschil. Draai dat om en het wordt een loss: gegeven dat een mens $y_w$ verkoos boven $y_l$, maximaliseer

wat in code de hele trainingslus is:

loss = -F.logsigmoid(reward(chosen) - reward(rejected)).mean()   

Let op wat het model nooit ziet: een absolute score. Het leert alleen verschillen, en dat is precies wat de data bevat.

Nu het deel dat het meten waard is. Een reward model leert wat de annotators beloonden, en annotators zijn mensen. Hier is een simulatie waarin de werkelijke kwaliteit van een response alleen afhangt van nuttig en correct zijn — lengte is niets waard — maar de gesimuleerde annotator een lichte voorkeur heeft voor langere antwoorden wanneer alles verder dicht bij elkaar ligt, wat een goed gedocumenteerde menselijke bias is. Train het reward model op 2.000 vergelijkingen en lees de gewichten:

Het reward model werkt perfect. Het heeft trouw de voorkeuren geleerd die het te zien kreeg — inclusief het deel van die voorkeuren dat niets met kwaliteit te maken heeft. Een reward model is geen maat voor goed; het is een maat voor wat de annotators kozen, en elke bias in de annotatiepool is nu een coëfficiënt in een differentieerbare functie waartegen een veel groter model zo meteen gaat optimaliseren.

Dat brengt ons bij wat er gebeurt wanneer je ervoor optimaliseert. Geef de policy een vast budget aan inspanning om te besteden over de eigenschappen van de response, met een realistische asymmetrie: nuttig zijn en correct zijn zijn duur, en langer zijn is goedkoop — je blijft gewoon schrijven.

Reward per eenheid inspanning, voor het hierboven getrainde model: nuttig 8,26, correct 8,31, lengte 31,70. Lengte betaalt bijna vier keer beter dan correctheid, niet omdat het reward model kapot is, maar omdat lengte goedkoop is.

Optimaliseer tegen die reward en kijk naar beide getallen:

De reward steeg met een factor 2,5. Datgene wat de reward moest meten ging naar nul. De policy ontdekte dat hij enorm goed kon scoren door lang te schrijven en niets te zeggen, en geen enkel deel van de trainingslus had een manier om dat te merken, omdat het reward model de definitie van goed is binnen de lus.

Dit is reward hacking, en als je je ooit hebt afgevraagd waarom chatmodellen zo breedsprakig zijn, is deze tabel een groot deel van het antwoord.

De standaardverdediging is om de policy te bestraffen wanneer die te ver weg beweegt van waar hij begon, waarbij afstand wordt gemeten met de KL-divergentie uit hoofdstuk 4:

De referentie $\pi_{\text{ref}}$ is het SFT-model — de policy vóór de reinforcement-fase. De claim is dat dit voorkomt dat het model afdwaalt naar gedegenereerd gedrag. Laten we uitzoeken hoeveel van die claim overeind blijft bij meting. Zelfde opzet, sweep over $\beta$:

Lees de laatste rij tegenover de rest. Bij $\beta = 0$ en $\beta = 1$ doet de straf helemaal niets: de reward is zoveel meer waard dan de KL dat de optimizer de boete betaalt en toch hackt. Tussen 5 en 15 slaat het gedrag om. En bij $\beta = 60$ is de werkelijke kwaliteit teruggeklommen naar 1,769 — wat nog steeds lager is dan de 1,791 die het referentiemodel had voordat dit alles begon.

Eén kanttekening voordat dat getal ergens wordt geciteerd: de 1,791 uit de laatste rij en de 0,974 die de eerste tabel aan de startende policy geeft, zijn twee verschillende metingen van hetzelfde pre-RL-model, afzonderlijk genomen door de twee experimenten. Vergelijk rijen binnen een tabel, nooit tussen tabellen — de conclusie van elke tabel staat op zijn eigen rijen, en geen van beide hangt af van de baseline van de andere.

De eerlijke samenvatting is dus niet „de KL-straf voorkomt reward hacking”. Het is:

De KL-straf voorkomt reward hacking niet. Hij beperkt hoe ver de policy van de referentie kan bewegen — en omdat de mislukking beweging vereist, helpt dat. Maar het is een lijn, geen correctie: bij lage $\beta$ knapt de lijn, en bij hoge $\beta$ krijg je het referentiemodel terug en heeft de hele dure fase niets opgeleverd.

De bruikbare band is smal, de locatie ervan hangt af van het reward model, en er is geen manier om hem te vinden behalve door te kijken. Daarom moet het referentiemodel goed zijn — de KL is een vloer op de kwaliteit van de referentie, geen plafond op de mislukking — en het is een groot deel van de reden waarom deze fase in de praktijk moeilijk is in plaats van in principe.

Het algoritme dat dit op schaal liet werken is Proximal Policy Optimization.³ In één alinea: het schat de advantage van elke response, werkt de policy bij om de waarschijnlijkheid van responses boven de baseline te verhogen, en clipt de grootte van elke afzonderlijke update zodat een grote advantage-schatting de policy niet in één stap kan vernietigen. Toegepast op taalmodellen⁴ betekent dit vier modellen tegelijk in het spel houden — de policy, de referentie, het reward model en een critic — waarbij de policy tijdens de hele training verse samples genereert.

Het werkt, het leverde InstructGPT op en alles wat daarvan afstamt, en het is echt moeilijk: vier modellen in geheugen, sampling in de trainingslus, en een verdiende reputatie voor instabiliteit. Doen alsof je het in een blogpost kunt implementeren zou oneerlijk zijn, dus dit hoofdstuk doet dat niet.

Wat het voor de meeste doeleinden verving, kwam voort uit een observatie. De KL-geregulariseerde doelstelling hierboven heeft een gesloten-vorm optimale policy, en die expressie kan worden omgekeerd: de reward kan worden geschreven in termen van de optimale policy en de referentie. Stop je dat terug in de Bradley–Terry-loss, dan verdwijnt het reward model volledig. Wat overblijft is een supervised loss op voorkeurenparen — geen sampling, geen critic, geen reward model, twee modellen in geheugen in plaats van vier.

Dat is Direct Preference Optimization,⁵ en het zijn twee regels:

def dpo_loss(pi_w, pi_l, ref_w, ref_l, beta=0.1):
    """pi_* and ref_* are summed log-probabilities of a full response."""
    logits = beta * ((pi_w - ref_w) - (pi_l - ref_l))   
    return -F.logsigmoid(logits)                        

Lees wat er staat. De grootheid die omhoog wordt geduwd is hoeveel meer de policy de winnaar verkiest dan de referentie deed, min hoeveel meer hij de verliezer verkiest. De referentie is geen straf die er achteraf op is geschroefd — hij zit in de loss, en daarom heeft DPO geen aparte KL-term nodig.

De belangrijkste eigenschap zit in de gradient. Evalueer de loss en de gradient op hetzelfde paar in vijf verschillende toestanden van de policy:

De gradient groeit naarmate de policy het verkeerder heeft. Paren die het model al aankan dragen bijna niets bij; paren die het omgekeerd doet domineren de update. DPO weegt elk voorbeeld op basis van hoe fout de policy het momenteel heeft, automatisch, zonder scheduling — en die zelfweging is het mechanisme dat het werk doet dat bij PPO door de advantage-schatting en de critic werd gedaan. (De loss op de derde rij is precies $\ln 2$, wat het anker is om elke implementatie aan te toetsen: een policy die identiek is aan zijn referentie heeft niets geleerd en hoort op $\ln 2$ te zitten.)

GRPO⁶ neemt een andere route uit hetzelfde probleem. Het behoudt de sampling-lus maar verwijdert de critic: in plaats van een model te trainen om de baseline te voorspellen, sampled het een groep responses op dezelfde prompt en gebruikt het het gemiddelde van de rewards van de groep rechtstreeks als baseline. De advantage van een response is hoeveel beter die was dan zijn siblings. Dat ruilt een heel model in voor een grotere batch, en het is wat verifieerbare-reward-training — het onderwerp van hoofdstuk 12 — praktisch maakte.

Twee dingen om mee te nemen.

Het eerste is dat deze fase een kostprijs heeft, en die zie je terug als capability. Modellen worden na alignment-training vaak meetbaar slechter op sommige benchmarktaken — de alignment tax — omdat de doelstelling veranderde: een response die veilig, voorbehouden en goed geformatteerd is, is niet altijd de response die nauwkeurigheid maximaliseert. Een deel van die kloof is technisch weggewerkt, en een deel ervan is een echte afweging in plaats van een bug om te repareren.

Het tweede is de vraag die het woord aligned verbergt. Aligned met wie? De keten is: een bedrijf schrijft richtlijnen, contractors interpreteren ze, hun vergelijkingen trainen een reward model, het reward model vormt een policy, en de policy beantwoordt een vraag van iemand die daar niets van heeft gezien. Elke schakel is een keuze van specifieke mensen, en geen enkel algoritme in dit hoofdstuk heeft een mening over de vraag of die keuzes goed zijn.

Dat is geen retorische versiering. Het is de concrete reden waarom twee frontiermodellen verschillende verzoeken weigeren, waarom hetzelfde model tussen versies van gedachten verandert, en waarom „aligned” een beschrijving is van een proces in plaats van een eigenschap van een artefact. De wiskunde in dit hoofdstuk staat vast. Dat deel niet.

Post-training leerde het model antwoorden. Het leerde het niet om te denken vóór het antwoord geeft, en die twee verschillen op een manier die trainbaar blijkt.

Hoofdstuk 12 gaat over wat er gebeurt wanneer je een model meer compute laat besteden aan een moeilijke vraag op het moment van antwoorden in plaats van op het moment van training — chain of thought, reinforcement learning uit verifieerbare rewards, en de reden dat een model dat zijn uitwerking laat zien niet alleen zichzelf uitlegt maar anders compute. Het lost ook de schuld uit dit hoofdstuk in: GRPO bestaat daarin, doet het werk dat PPO’s critic vroeger deed, op rewards waarvoor helemaal geen annotator nodig is omdat een bewijs klopt of niet.

De generaties hierboven komen uit gpt2 en Qwen/Qwen2.5-0.5B-Instruct met greedy decoding, dus ze reproduceren exact. Hoofdstuk 11 van de Hugging Face LLM Course loopt SFT en DPO door met trl en peft als je het echte werk wilt draaien in plaats van de simulatie; hoofdstuk 7 van Sebastian Raschka’s Build a Large Language Model (From Scratch) implementeert instruction fine-tuning end-to-end zonder library.