Från basmodell till assistent: SFT, RLHF, DPO och GRPO

Det första steget är det minst glamorösa och gör större delen av arbetet. Samla exempel på instruktioner parade med bra svar, och fortsätt träna på dem med exakt samma loss som i kapitel 8 — förutsäg nästa token — men bara på svarsdelen. Detta är supervised fine-tuning, eller SFT.

Inget nytt lärs ut om språk. Det som lärs ut är ett format: att text av den här formen följs av text av den där formen, och sedan slutar den. Titta igen på basmodellens misslyckande. Den svarade på frågan i första meningen och kunde sedan inte sluta, eftersom inget i dess träning någonsin markerade slutet på ett svar. Att sluta är ett inlärt beteende.

Det är också därför modellen behöver få veta var gränserna går, vilket är vad en chat template ä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

Dessa <|im_start|>- och <|im_end|>-markörer är riktiga tokens i vokabulären, tillagda före fine-tuning, och modellen såg miljontals av dem på exakt dessa positioner. Det är så den vet vems tur det är och var en tur slutar.

Hoppa över templaten och ge modellen en ren fråga, så ger du den en sekvens den inte har sett under träningen. Uppmätt, samma modell, samma fråga, samma 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 är rätt i båda fallen, men utan markörerna glider modellen över till att skriva Python för att kontrollera sig själv, eftersom prompten den fick inte liknar något den fine-tunades på. Detta är den enskilt vanligaste orsaken till ”modellen blev dummare när jag anropade den direkt”: templaten är inte dekoration runt modellen, den är en del av modellen, och en felaktig template är en tyst försämring utan något felmeddelande.

SFT har ett tak, och taket är datan. För att fine-tuna på en demonstration behöver någon skriva det ideala svaret — och för de flesta intressanta frågor är det svårt, långsamt och dyrt att skriva ett bra svar, och det ger exakt ett svar vars kvalitet du inte kan verifiera.

Det människor är bra på är jämförelse. När en annoterare visas två svar kan hen på några sekunder tillförlitligt säga vilket som är bättre, utan att kunna producera något av dem. Detta är faktumet som hela det andra steget bygger på, och det är den del de flesta förklaringar får bakvänd:

Människor skriver inte svaren. De rankar par.

Datan är alltså par — en prompt, två svar och vilket som vann. Det kan inte stoppas in i en next-token loss, eftersom det inte finns någon målsekvens. Det behöver en annan maskin.

Du kan inte be en människa poängsätta varje svar under träningen — det handlar om miljontals bedömningar. Så du tränar en modell att imitera människorna: en belöningsmodell som tar ett svar och returnerar en skalär.

Att träna den från jämförelser använder ett resultat från 1952. Bradley–Terry-modellen² säger att om två objekt har latenta styrkor, är sannolikheten att det ena slår det andra den logistiska funktionen av deras skillnad. Vänd på det och det blir en loss: givet att en människa föredrog $y_w$ framför $y_l$, maximera

vilket i kod är hela träningsloopen:

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

Lägg märke till vad modellen aldrig ser: en absolut poäng. Den lär sig bara skillnader, vilket är exakt vad datan innehåller.

Nu den del som är värd att mäta. En belöningsmodell lär sig vad annoterarna belönade, och annoterare är människor. Här är en simulering där den sanna kvaliteten på ett svar bara beror på att det är användbart och korrekt — längd är ingenting värt — men den simulerade annoteraren har en mild preferens för längre svar när allt annat är nära, vilket är en väldokumenterad mänsklig bias. Träna belöningsmodellen på 2000 jämförelser och läs av dess vikter:

Belöningsmodellen fungerar perfekt. Den har troget lärt sig preferenserna den visades — inklusive den del av preferenserna som inte har något med kvalitet att göra. En belöningsmodell är inte ett mått på bra; den är ett mått på vad annoterarna valde, och varje bias i annoteringspoolen är nu en koefficient i en deriverbar funktion som en mycket större modell snart ska optimera mot.

Vilket tar oss till vad som händer när du optimerar den. Ge policyn en fast budget av ansträngning att lägga på svarets egenskaper, med en realistisk asymmetri: att vara användbar och korrekt är dyrt, och att vara längre är billigt — du fortsätter bara skriva.

Reward per ansträngningsenhet, för modellen som tränades ovan: användbar 8,26, korrekt 8,31, längd 31,70. Längd betalar nästan fyra gånger bättre än korrekthet, inte för att belöningsmodellen är trasig, utan för att det är billigt.

Optimera mot den reward och titta på båda siffrorna:

Reward ökade med en faktor 2,5. Det som reward skulle mäta gick till noll. Policyn upptäckte att den kunde få enormt bra poäng genom att skriva långt och säga ingenting, och ingen del av träningsloopen hade något sätt att märka det, eftersom belöningsmodellen är definitionen av bra inuti loopen.

Detta är reward hacking, och om du någonsin har undrat varför chatmodeller är så ordrika är den här tabellen en stor del av svaret.

Standardförsvaret är att straffa policyn för att röra sig för långt från där den började, med avstånd mätt som KL-divergens från kapitel 4:

Referensen $\pi_{\text{ref}}$ är SFT-modellen — policyn före reinforcement-steget. Påståendet är att detta hindrar modellen från att vandra iväg in i degenererat beteende. Låt oss ta reda på hur mycket av det påståendet som överlever mätning. Samma upplägg, svepande $\beta$:

Läs den sista raden i förhållande till resten. Vid $\beta = 0$ och $\beta = 1$ gör straffet ingenting alls: reward är så mycket mer värd än KL att optimeraren betalar böterna och hackar ändå. Mellan 5 och 15 svänger beteendet. Och vid $\beta = 60$ har sann kvalitet klättrat tillbaka till 1,769 — vilket fortfarande är under de 1,791 som referensmodellen hade innan något av detta började.

En brasklapp innan den siffran citeras någonstans: 1,791 i sista raden och 0,974 som den första tabellen ger startpolicyn är två olika mätningar av samma pre-RL-modell, tagna av de två experimenten separat. Jämför rader inom en tabell, aldrig mellan dem — slutsatsen i varje tabell står på sina egna rader, och ingen av dem beror på den andras baseline.

Den ärliga sammanfattningen är alltså inte ”KL-straffet förhindrar reward hacking”. Den är:

KL-straffet förhindrar inte reward hacking. Det begränsar hur långt policyn kan röra sig från referensen — och eftersom misslyckandet kräver rörelse hjälper det. Men det är ett koppel, inte en korrigering: vid låg $\beta$ brister kopplet, och vid hög $\beta$ får du tillbaka referensmodellen och hela det dyra steget köpte ingenting.

Det användbara intervallet är smalt, dess läge beror på belöningsmodellen, och det finns inget sätt att hitta det annat än genom att titta. Därför måste referensmodellen vara bra — KL är ett golv vid referensens kvalitet, inte ett tak på misslyckandet — och det är en stor del av varför detta steg är svårt i praktiken snarare än i princip.

Algoritmen som fick detta att fungera i skala är Proximal Policy Optimization.³ I ett stycke: den uppskattar advantage för varje svar, uppdaterar policyn för att öka sannolikheten för svar över baseline, och klipper storleken på varje enskild uppdatering så att en stor advantage-uppskattning inte kan förstöra policyn i ett steg. Tillämpat på språkmodeller⁴ betyder det att hålla fyra modeller i spel samtidigt — policyn, referensen, belöningsmodellen och en critic — medan policyn genererar färska sampel genom hela träningen.

Det fungerar, det producerade InstructGPT och allt som härstammar från det, och det är genuint svårt: fyra modeller i minnet, sampling i träningsloopen och ett rykte om instabilitet som är välförtjänt. Att låtsas att du kan implementera det i ett blogginlägg vore oärligt, så det gör inte det här kapitlet.

Det som ersatte det för de flesta ändamål kom ur en observation. Det KL-regulariserade målet ovan har en optimal policy i sluten form, och det uttrycket kan inverteras: reward kan skrivas i termer av den optimala policyn och referensen. Om man sätter in det tillbaka i Bradley–Terry-loss får man belöningsmodellen att försvinna helt. Kvar blir en supervised loss på preferenspar — ingen sampling, ingen critic, ingen belöningsmodell, två modeller i minnet i stället för fyra.

Detta är Direct Preference Optimization,⁵ och det är två rader:

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 vad den säger. Storheten som trycks upp är hur mycket mer policyn föredrar vinnaren än referensen gjorde, minus hur mycket mer den föredrar förloraren. Referensen är inte ett straff som bultas på i efterhand — den finns inne i loss, vilket är varför DPO inte behöver en separat KL-term.

Egenskapen som betyder mest finns i gradienten. Utvärdera loss och dess gradient på samma par i fem olika tillstånd hos policyn:

Gradienten växer ju mer fel policyn har. Par som modellen redan hanterar bidrar nästan ingenting; par den får bakvänt dominerar uppdateringen. DPO viktar varje exempel efter hur fel policyn har just nu, automatiskt, utan schemaläggning — och den självviktingen är mekanismen som gör arbetet som PPO:s advantage-uppskattning och critic gjorde. (Loss i tredje raden är exakt $\ln 2$, vilket är ankaret att kontrollera varje implementation mot: en policy som är identisk med sin referens har inte lärt sig något och ska ligga på $\ln 2$.)

GRPO⁶ tar en annan väg ut ur samma problem. Den behåller samplingloopen men tar bort critic: i stället för att träna en modell att förutsäga baseline samplar den en grupp av svar på samma prompt och använder gruppens medelreward som baseline direkt. Ett svars advantage är hur mycket bättre det var än sina syskon. Det byter ut en hel modell mot en större batch, och det är vad som gjorde träning med verifierbara rewards — ämnet för kapitel 12 — praktisk.

Två saker att ta med vidare.

Den första är att detta steg har en kostnad, och den syns som förmåga. Modeller blir ofta mätbart sämre på vissa benchmarkuppgifter efter alignment-träning — alignment-skatten — eftersom målet ändrades: ett svar som är säkert, försiktigt och välformaterat är inte alltid det svar som maximerar träffsäkerhet. En del av det gapet har ingenjörats bort, och en del av det är en verklig avvägning snarare än en bugg att fixa.

Den andra är frågan som ordet aligned döljer. Aligned med vem? Kedjan är: ett företag skriver riktlinjer, underleverantörer tolkar dem, deras jämförelser tränar en belöningsmodell, belöningsmodellen formar en policy, och policyn svarar på en fråga från någon som inte såg något av detta. Varje länk är ett val gjort av specifika människor, och ingen av algoritmerna i det här kapitlet har någon åsikt om huruvida de valen är bra.

Det är inte en retorisk utsmyckning. Det är den konkreta orsaken till att två frontier-modeller vägrar olika begäranden, varför samma modell ändrar sig mellan versioner, och varför ”aligned” är en beskrivning av en process snarare än en egenskap hos en artefakt. Matematiken i det här kapitlet är avgjord. Den delen är det inte.

Post-training lärde modellen att svara. Den lärde den inte att tänka innan den svarar, och de två är olika på ett sätt som visar sig vara träningsbart.

Kapitel 12 handlar om vad som händer när du låter en modell lägga mer beräkning på en svår fråga vid svarstid i stället för vid träningstid — chain of thought, reinforcement learning från verifierbara rewards, och skälet till att en modell som visar sitt arbete inte bara förklarar sig utan beräknar annorlunda. Det löser också skulden från det här kapitlet: GRPO finns där, gör jobbet som PPO:s critic brukade göra, på rewards som inte behöver någon annoterare alls eftersom ett bevis antingen kontrollerar eller inte.

Genereringarna ovan kommer från gpt2 och Qwen/Qwen2.5-0.5B-Instruct med greedy decoding, så de reproduceras exakt. Kapitel 11 i Hugging Face LLM Course går igenom SFT och DPO med trl och peft om du vill köra det riktiga i stället för simuleringen; kapitel 7 i Sebastian Raschkas Build a Large Language Model (From Scratch) implementerar instruction fine-tuning från början till slut utan ett bibliotek.