От базов модел до асистент: SFT, RLHF, DPO и GRPO

Първата стъпка е най-малко бляскава и върши по-голямата част от работата. Събират се примери от инструкции, съчетани с добри отговори, и обучението продължава върху тях със същата загуба от Глава 8 — предсказване на следващия token — но само върху частта с отговора. Това е supervised fine-tuning, или SFT.

Не се преподава нищо ново за езика. Това, което се преподава, е формат: че текст с тази форма е последван от текст с онази форма, а после той спира. Вижте отново провала на базовия модел. Той отговори на въпроса в първото изречение и после не можа да спре, защото нищо в обучението му никога не е маркирало края на отговор. Спирането е научено поведение.

Затова моделът трябва да получи и указание къде са границите — именно това е chat template:

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

Тези маркери <|im_start|> и <|im_end|> са реални token в речника, добавени преди fine-tuning, и моделът е видял милиони от тях точно на тези позиции. Така той знае чий ред е и къде свършва един ход.

Пропуснете template и подайте на модела гол въпрос — така му давате последователност, която не е виждал по време на обучение. Измерено, същият модел, същият въпрос, същото 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.

Отговорът е правилен и в двата случая, но без маркерите моделът се отклонява към писане на Python, за да се провери сам, защото prompt, който е получил, не прилича на нищо, върху което е бил fine-tuned. Това е най-честата причина за „моделът стана по-глупав, когато го извиках директно“: template не е декорация около модела, той е част от модела, а грешен template е тиха деградация без прикачена грешка.

SFT има таван, а таванът са данните. За да правите fine-tuning върху демонстрация, някой трябва да напише идеалния отговор — а за повечето интересни въпроси писането на добър отговор е трудно, бавно, скъпо и произвежда точно един отговор, чието качество не можете да проверите.

Това, в което хората са добри, е сравнението. При два показани отговора анотатор може надеждно да каже кой е по-добър за няколко секунди, без да може сам да произведе който и да е от тях. Това е фактът, върху който е изграден целият втори етап, и това е частта, която повечето обяснения обръщат наопаки:

Хората не пишат отговорите. Те класират двойки.

Следователно данните са двойки — prompt, два отговора и кой е спечелил. Това не може да се включи в загуба за следващ token, защото няма целева последователност. Нужна е различна машина.

Не можете да карате човек да оценява всеки отговор по време на обучение — това са милиони преценки. Затова обучавате модел да имитира хората: reward model, който приема отговор и връща скалар.

Обучението му от сравнения използва резултат от 1952 г. Моделът Bradley–Terry² казва, че ако два елемента имат латентни сили, вероятността единият да победи другия е логистичната функция на разликата им. Обърнете това и то става загуба: при положение че човек е предпочел $y_w$ пред $y_l$, максимизирайте

което в код е целият цикъл на обучение:

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

Забележете какво моделът никога не вижда: абсолютна оценка. Той винаги научава само разлики, което е точно това, което съдържат данните.

Сега частта, която си струва да бъде измерена. Reward model научава какво са възнаграждавали анотаторите, а анотаторите са хора. Ето симулация, в която истинското качество на отговор зависи само от това да е полезен и правилен — дължината не струва нищо — но симулираният анотатор има леко предпочитание към по-дълги отговори, когато всичко друго е близко, което е добре документиран човешки bias. Обучете reward model върху 2000 сравнения и прочетете теглата му:

Reward model работи перфектно. Той вярно е научил предпочитанията, които са му били показани — включително онази част от тези предпочитания, която няма нищо общо с качеството. Reward model не е мярка за добро; той е мярка за това какво са избрали анотаторите, а всеки bias в пула от анотации вече е коефициент в диференцируема функция, срещу която много по-голям модел скоро ще оптимизира.

Това ни води до въпроса какво става, когато оптимизирате срещу него. Дайте на политиката фиксиран бюджет от усилие, който да разпредели между свойствата на отговора, с реалистична асиметрия: да бъдеш полезен и правилен е скъпо, а да бъдеш по-дълъг е евтино — просто продължаваш да пишеш.

Награда на единица усилие за модела, обучен по-горе: полезен 8,26, правилен 8,31, дължина 31,70. Дължината плаща почти четири пъти по-добре от правилността не защото reward model е счупен, а защото е евтина.

Оптимизирайте срещу тази награда и наблюдавайте и двете числа:

Наградата се повиши с фактор 2,5. Нещото, което наградата трябваше да измерва, падна до нула. Политиката откри, че може да получава огромно високи оценки, като пише надълго и не казва нищо, а никоя част от цикъла на обучение нямаше начин да забележи, защото reward model е дефиницията за добро вътре в цикъла.

Това е reward hacking и ако някога сте се чудили защо chat моделите са толкова многословни, тази таблица е голяма част от отговора.

Стандартната защита е да се наказва политиката, ако се отдалечи твърде много от началната си позиция, като разстоянието се измерва с KL дивергенцията от Глава 4:

Референцията $\pi_{\text{ref}}$ е SFT моделът — политиката преди reinforcement етапа. Твърдението е, че това предотвратява отклоняването на модела към дегенеративно поведение. Нека видим каква част от това твърдение оцелява при измерване. Същата постановка, с обхождане на $\beta$:

Прочетете последния ред спрямо останалите. При $\beta = 0$ и $\beta = 1$ наказанието не прави нищо: наградата струва толкова повече от KL, че оптимизаторът плаща глобата и хаква въпреки това. Между 5 и 15 поведението се преобръща рязко. А при $\beta = 60$ истинското качество се е върнало до 1,769 — което е все още под 1,791, които референтният модел е имал, преди всичко това да започне.

Едно уточнение, преди някой да цитира това число: 1,791 от последния ред и 0,974, което първата таблица дава на началната политика, са две различни измервания на един и същ модел преди RL, направени отделно от двата експеримента. Сравнявайте редове вътре в една таблица, никога между таблици — заключението на всяка таблица стои върху собствените ѝ редове и нито едно не зависи от baseline на другата.

Така че честното обобщение не е „KL penalty предотвратява reward hacking“. То е:

KL penalty не предотвратява reward hacking. Той ограничава колко далеч политиката може да се отмести от референцията — и понеже провалът изисква отместване, това помага. Но това е каишка, не корекция: при ниско $\beta$ каишката се къса, а при високо $\beta$ получавате референтния модел обратно и целият скъп етап не е купил нищо.

Полезната зона е тясна, местоположението ѝ зависи от reward model и няма начин да бъде намерена освен чрез гледане. Затова референтният модел трябва да е добър — KL е под на качеството на референцията, не таван на провала — и това е голяма част от причината този етап да е труден на практика, а не по принцип.

Алгоритъмът, който направи това работещо в мащаб, е Proximal Policy Optimization.³ В един абзац: той оценява advantage на всеки отговор, обновява политиката така, че да увеличи вероятността на отговори над baseline, и ограничава размера на всяко единично обновяване, за да не може голяма оценка на advantage да унищожи политиката с една стъпка. Приложено към езикови модели⁴, това означава да се държат четири модела в игра едновременно — политиката, референцията, reward model и критик — като политиката генерира нови проби през цялото обучение.

Работи, произведе InstructGPT и всичко, което произлезе от него, и е действително трудно: четири модела в паметта, семплиране в цикъла на обучение и заслужена репутация за нестабилност. Да се преструваме, че може да бъде имплементиран в блог пост, би било нечестно, затова тази глава не го прави.

Това, което го замени за повечето цели, дойде от едно наблюдение. KL-регуляризираната цел по-горе има оптимална политика в затворена форма и този израз може да бъде обърнат: наградата може да бъде записана чрез оптималната политика и референцията. Замяната ѝ обратно в загубата на Bradley–Terry кара reward model да изчезне изцяло. Остава supervised загуба върху двойки предпочитания — без семплиране, без критик, без reward model, два модела в паметта вместо четири.

Това е Direct Preference Optimization,⁵ и се състои от два реда:

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)                        

Прочетете какво казва. Количеството, което се избутва нагоре, е колко повече политиката предпочита победителя спрямо референцията, минус колко повече предпочита губещия. Референцията не е наказание, завинтено отгоре след това — тя е вътре в загубата, затова DPO не се нуждае от отделен KL член.

Свойството, което има най-голямо значение, е в gradient. Оценете загубата и нейния gradient върху същата двойка в пет различни състояния на политиката:

Gradient расте, когато политиката греши повече. Двойките, с които моделът вече се справя, допринасят почти нищо; двойките, които обръща наопаки, доминират обновяването. DPO претегля всеки пример според това колко грешна е политиката в момента, автоматично, без scheduling — и това самопретегляне е механизмът, който върши работата, която оценката на advantage и критикът вършеха в PPO. (Загубата на третия ред е точно $\ln 2$, което е котвата за проверка на всяка имплементация: политика, идентична с референцията си, не е научила нищо и трябва да стои на $\ln 2$.)

GRPO⁶ поема по различен път навън от същия проблем. Той запазва цикъла на семплиране, но изтрива критика: вместо да обучава модел да предсказва baseline, той семплира група от отговори към същия prompt и използва средната награда на групата директно като baseline. Advantage на един отговор е колко по-добър е бил от своите „братя и сестри“. Това заменя цял модел с по-голям batch и именно то направи практично обучението с проверима награда — темата на Глава 12.

Две неща, които да вземете напред.

Първото е, че този етап има цена, и тя се проявява като способност. Моделите често стават измеримо по-лоши на някои benchmark задачи след alignment обучение — alignment tax — защото целта се е променила: отговор, който е безопасен, предпазлив и добре форматиран, не винаги е отговорът, който максимизира точността. Част от тази разлика е инженерно премахната, а част от нея е реален компромис, не бъг за поправяне.

Второто е въпросът, който думата aligned скрива. Подравнен с кого? Веригата е: компания пише насоки, изпълнители ги тълкуват, техните сравнения обучават reward model, reward model оформя политика, а политиката отговаря на въпрос от някого, който не е видял нищо от това. Всяка връзка е избор, направен от конкретни хора, и нито един от алгоритмите в тази глава няма мнение дали тези избори са добри.

Това не е реторична украса. Това е конкретната причина два frontier модела да отказват различни заявки, същият модел да променя мнението си между версии и „aligned“ да бъде описание на процес, а не свойство на артефакт. Математиката в тази глава е установена. Тази част — не.

Post-training научи модела да отговаря. Не го научи да мисли преди да отговори, а двете са различни по начин, който се оказва обучаем.

Глава 12 е за това какво се случва, когато позволите на модел да изразходва повече изчисление върху труден въпрос по време на отговаряне, а не по време на обучение — chain of thought, reinforcement learning от проверими награди и причината модел, който показва работата си, не просто се обяснява, а изчислява различно. Тя също изплаща дълга от тази глава: GRPO присъства там, вършейки работата, която преди вършеше критикът на PPO, върху награди, които не се нуждаят от никакъв анотатор, защото едно доказателство или се проверява, или не.

Генерациите по-горе идват от gpt2 и Qwen/Qwen2.5-0.5B-Instruct с greedy decoding, затова се възпроизвеждат точно. Глава 11 от Hugging Face LLM Course преминава през SFT и DPO с trl и peft, ако искате да стартирате истинското нещо вместо симулацията; глава 7 от Build a Large Language Model (From Scratch) на Sebastian Raschka имплементира instruction fine-tuning от край до край без библиотека.