Fra base model til assistant: SFT, RLHF, DPO og GRPO

Det første skridt er det mindst glamourøse og gør det meste af arbejdet. Indsaml eksempler på instruktioner parret med gode svar, og fortsæt træningen på dem med præcis samme loss som i Kapitel 8 — forudsig næste token — men kun på svardelen. Det er supervised fine-tuning, eller SFT.

Der bliver ikke lært noget nyt om sprog. Det, der læres, er et format: at tekst med denne form efterfølges af tekst med den form, og så stopper den. Se igen på base model'ens fejl. Den besvarede spørgsmålet i den første sætning og kunne derefter ikke stoppe, fordi intet i dens træning nogensinde markerede slutningen på et svar. At stoppe er en lært adfærd.

Det er også derfor, modellen skal have at vide, hvor grænserne går, hvilket er det, en chat template gør:

<|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

Disse <|im_start|>- og <|im_end|>-markører er rigtige tokens i vocabulary, tilføjet før fine-tuning, og modellen så millioner af dem i præcis disse positioner. Det er sådan, den ved, hvis tur det er, og hvor en tur slutter.

Spring templaten over og giv modellen et nøgent spørgsmål, og du giver den en sekvens, den ikke har set under træning. Målt, samme model, samme spørgsmål, samme 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.

Svaret er rigtigt i begge tilfælde, men uden markørerne glider modellen over i at skrive Python for at tjekke sig selv, fordi den prompt, den modtog, ikke ligner noget, den blev fine-tuned på. Det er den mest almindelige årsag til “modellen blev dummere, da jeg kaldte den direkte”: templaten er ikke pynt omkring modellen, den er en del af modellen, og en forkert template er en tavs forringelse uden en tilknyttet fejl.

SFT har et loft, og loftet er dataene. For at fine-tune på en demonstration skal nogen skrive det ideelle svar — og for de fleste interessante spørgsmål er det svært, langsomt og dyrt at skrive et godt svar, og det producerer præcis ét svar, hvis kvalitet du ikke kan verificere.

Det mennesker er gode til, er sammenligning. Når en annotator får vist to svar, kan vedkommende på få sekunder pålideligt sige, hvilket der er bedre, uden at være i stand til selv at producere nogen af dem. Det er det faktum, hele det andet trin bygger på, og det er den del, de fleste forklaringer vender på hovedet:

Mennesker skriver ikke svarene. De rangerer par.

Så dataene er par — en prompt, to svar, og hvilket der vandt. Det kan ikke sættes ind i en next-token loss, fordi der ikke er nogen target sequence. Det kræver en anden maskine.

Du kan ikke bede et menneske om at score hvert svar under træning — det er millioner af vurderinger. Så du træner en model til at efterligne mennesker: en reward model, der tager et svar og returnerer en scalar.

At træne den fra sammenligninger bruger et resultat fra 1952. Bradley–Terry-modellen² siger, at hvis to items har latente styrker, er sandsynligheden for, at den ene slår den anden, den logistiske funktion af deres forskel. Vend det om, og det bliver til en loss: givet at et menneske foretrak $y_w$ frem for $y_l$, maksimer

hvilket i code er hele træningsløkken:

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

Bemærk, hvad modellen aldrig ser: en absolut score. Den lærer kun forskelle, hvilket er præcis det, dataene indeholder.

Nu den del, der er værd at måle. En reward model lærer, hvad annotatorerne belønnede, og annotatorer er mennesker. Her er en simulation, hvor den sande kvalitet af et svar kun afhænger af at være nyttigt og korrekt — længde er intet værd — men den simulerede annotator har en mild præference for længere svar, når alt andet er tæt på, hvilket er en veldokumenteret menneskelig bias. Træn reward model på 2000 sammenligninger og aflæs dens vægte:

Reward model fungerer perfekt. Den har trofast lært de præferencer, den blev vist — inklusive den del af præferencerne, der intet har med kvalitet at gøre. En reward model er ikke et mål for godt; den er et mål for, hvad annotatorerne valgte, og hver bias i annotation-puljen er nu en koefficient i en differentiabel funktion, som en meget større model er ved at optimere mod.

Hvilket bringer os til, hvad der sker, når du optimerer den. Giv policy et fast budget af indsats, der skal fordeles på tværs af svarets egenskaber, med en realistisk asymmetri: at være nyttig og korrekt er dyrt, og at være længere er billigt — du fortsætter bare med at skrive.

Reward per indsatsenhed for modellen trænet ovenfor: nyttigt 8,26, korrekt 8,31, længde 31,70. Længde betaler næsten fire gange bedre end korrekthed, ikke fordi reward model er defekt, men fordi det er billigt.

Optimér mod den reward og se begge tal:

Reward steg med en faktor 2,5. Det, reward skulle måle, gik til nul. Policy opdagede, at den kunne score enormt godt ved at skrive langt og sige ingenting, og ingen del af træningsløkken havde nogen måde at opdage det på, fordi reward model er definitionen af godt inde i løkken.

Det er reward hacking, og hvis du nogensinde har undret dig over, hvorfor chatmodeller er så ordrige, er denne tabel en stor del af svaret.

Standardforsvaret er at straffe policy for at bevæge sig for langt væk fra, hvor den startede, ved at måle afstanden med KL divergence fra Kapitel 4:

Referencen $\pi_{\text{ref}}$ er SFT-modellen — policy før reinforcement-trinnet. Påstanden er, at dette forhindrer modellen i at vandre ud i degenereret adfærd. Lad os finde ud af, hvor meget af den påstand der overlever måling. Samme setup, med sweep over $\beta$:

Læs den sidste række op mod resten. Ved $\beta = 0$ og $\beta = 1$ gør straffen slet ingenting: reward er så meget mere værd end KL, at optimiser betaler bøden og hacker alligevel. Mellem 5 og 15 svinger adfærden. Og ved $\beta = 60$ er den sande kvalitet klatret tilbage til 1,769 — hvilket stadig er under de 1,791, referencemodellen havde, før noget af dette startede.

Én advarsel før det tal citeres nogen steder: 1,791 i sidste række og 0,974, som den første tabel giver den startende policy, er to forskellige målinger af den samme pre-RL-model, taget separat af de to eksperimenter. Sammenlign rækker inden for en tabel, aldrig på tværs — konklusionen i hver tabel står på sine egne rækker, og ingen af dem afhænger af den andens baseline.

Så den ærlige opsummering er ikke “KL penalty forhindrer reward hacking”. Den er:

KL penalty forhindrer ikke reward hacking. Den begrænser, hvor langt policy kan bevæge sig fra referencen — og fordi fejlen kræver bevægelse, hjælper det. Men det er en snor, ikke en korrektion: ved lav $\beta$ knækker snoren, og ved høj $\beta$ får du referencemodellen tilbage, og hele det dyre trin købte ingenting.

Det nyttige interval er smalt, dets placering afhænger af reward model, og der er ingen måde at finde det på undtagen ved at kigge. Derfor skal referencemodellen være god — KL er et gulv ved referencens kvalitet, ikke et loft over fejlen — og det er en stor del af grunden til, at dette trin er svært i praksis snarere end i princippet.

Algoritmen, der fik dette til at virke i stor skala, er Proximal Policy Optimization.³ I ét afsnit: den estimerer advantage for hvert svar, opdaterer policy for at øge sandsynligheden for svar over baseline og clipper størrelsen på hver enkelt opdatering, så et stort advantage-estimat ikke kan ødelægge policy i ét trin. Anvendt på language models⁴ betyder det at holde fire modeller i spil på samme tid — policy, referencen, reward model og en critic — med policy, der genererer friske samples gennem hele træningen.

Det virker, det producerede InstructGPT og alt, der nedstammer fra det, og det er oprigtigt svært: fire modeller i hukommelsen, sampling i træningsløkken og et fortjent ry for ustabilitet. At lade som om du kan implementere det i et blogindlæg, ville være uærligt, så det gør dette kapitel ikke.

Det, der erstattede det til de fleste formål, kom af at bemærke noget. Den KL-regulariserede objective ovenfor har en closed-form optimal policy, og det udtryk kan inverteres: reward kan skrives i termer af den optimale policy og referencen. Sæt det tilbage ind i Bradley–Terry loss, og reward model forsvinder helt. Tilbage er en supervised loss på præferencepar — ingen sampling, ingen critic, ingen reward model, to modeller i hukommelsen i stedet for fire.

Det er Direct Preference Optimization,⁵ og det er to linjer:

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)                        

Læs, hvad den siger. Den størrelse, der skubbes op, er hvor meget mere policy foretrækker vinderen, end referencen gjorde, minus hvor meget mere den foretrækker taberen. Referencen er ikke en penalty, der boltes på bagefter — den er inde i loss, og derfor behøver DPO ikke et separat KL-led.

Den vigtigste egenskab er i gradient. Evaluér loss og dens gradient på det samme par i fem forskellige tilstande af policy:

Gradient vokser, efterhånden som policy tager mere fejl. Par, som modellen allerede håndterer, bidrager næsten ingenting; par, den får vendt på hovedet, dominerer opdateringen. DPO vægter hvert eksempel efter, hvor forkert policy aktuelt er, automatisk, uden scheduling — og den selvvægtning er mekanismen, der gør det arbejde, som PPO's advantage-estimat og critic gjorde. (Loss i tredje række er præcis $\ln 2$, hvilket er ankeret til at kontrollere enhver implementation imod: en policy, der er identisk med sin reference, har ikke lært noget og bør ligge ved $\ln 2$.)

GRPO⁶ tager en anden vej ud af samme problem. Den beholder sampling-løkken, men sletter critic: i stedet for at træne en model til at forudsige baseline, sampler den en gruppe af svar på samme prompt og bruger gruppens gennemsnitlige reward direkte som baseline. Et svars advantage er, hvor meget bedre det var end dets søskende. Det bytter en hel model ud med en større batch, og det er det, der gjorde verifiable-reward-træning — emnet for Kapitel 12 — praktisk.

To ting at tage med videre.

Den første er, at dette trin har en omkostning, og den viser sig som capability. Modeller bliver ofte målbart dårligere til nogle benchmark-opgaver efter alignment training — alignment tax — fordi objective ændrede sig: et svar, der er sikkert, forbeholdent og velformateret, er ikke altid det svar, der maksimerer accuracy. Noget af det gap er blevet engineered væk, og noget af det er et reelt trade-off snarere end en bug, der skal fixes.

Den anden er spørgsmålet, ordet aligned skjuler. Aligned med hvem? Kæden er: en virksomhed skriver guidelines, contractors fortolker dem, deres sammenligninger træner en reward model, reward model former en policy, og policy besvarer et spørgsmål fra en person, der ikke så noget af det. Hvert led er et valg truffet af bestemte mennesker, og ingen af algoritmerne i dette kapitel har nogen holdning til, om de valg er gode.

Det er ikke en retorisk flourish. Det er den konkrete grund til, at to frontier models afviser forskellige anmodninger, hvorfor den samme model skifter mening mellem versioner, og hvorfor “aligned” er en beskrivelse af en proces snarere end en egenskab ved en artefakt. Matematikken i dette kapitel er afklaret. Den del er ikke.

Post-training lærte modellen at svare. Det lærte den ikke at tænke før den svarer, og de to ting er forskellige på en måde, der viser sig at være trainable.

Kapitel 12 handler om, hvad der sker, når du lader en model bruge mere computation på et svært spørgsmål ved svartid i stedet for ved træningstid — chain of thought, reinforcement learning fra verifiable rewards og grunden til, at en model, der viser sit arbejde, ikke blot forklarer sig selv, men beregner anderledes. Det indfrier også gælden fra dette kapitel: GRPO findes i det, gør det arbejde, PPO's critic plejede at gøre, på rewards, der slet ikke kræver nogen annotator, fordi et bevis enten checker eller ikke gør.

Genereringerne ovenfor kommer fra gpt2 og Qwen/Qwen2.5-0.5B-Instruct med greedy decoding, så de kan reproduceres præcis. Kapitel 11 i Hugging Face LLM Course gennemgår SFT og DPO med trl og peft, hvis du vil køre den ægte vare i stedet for simulationen; kapitel 7 i Sebastian Raschkas Build a Large Language Model (From Scratch) implementerer instruction fine-tuning end to end uden et library.