От базовой модели к ассистенту: 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|> — реальные tokens в словаре, добавленные перед fine-tuning, и модель видела миллионы таких markers ровно в этих позициях. Так она понимает, чей сейчас ход и где ход заканчивается.

Пропустите 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-tune на демонстрации, нужен кто-то, кто напишет идеальный ответ, — а для большинства интересных вопросов хороший ответ писать трудно, долго, дорого, и в итоге получается ровно один ответ, качество которого вы не можете проверить.

В чём люди сильны, так это в сравнении. Увидев два ответа, аннотатор за несколько секунд надёжно скажет, какой лучше, даже если не смог бы написать ни один из них. На этом факте построен весь второй этап, и именно эту часть большинство объяснений переворачивает с ног на голову:

Люди не пишут ответы. Они ранжируют пары.

Значит, данные — это пары: prompt, два ответа и указание, какой победил. Это нельзя подставить в next-token loss, потому что целевой последовательности нет. Нужна другая машина.

Нельзя просить человека оценивать каждый ответ во время обучения — это миллионы суждений. Поэтому вы обучаете модель имитировать людей: reward model, которая принимает ответ и возвращает скаляр.

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

что в коде и есть весь цикл обучения:

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

Обратите внимание, чего модель никогда не видит: абсолютной оценки. Она учит только различия — ровно то, что содержится в данных.

Теперь часть, которую стоит измерить. Reward model учится тому, что вознаграждали аннотаторы, а аннотаторы — люди. Вот симуляция, где истинное качество ответа зависит только от полезности и правильности — длина не стоит ничего, — но у симулированного аннотатора есть лёгкое предпочтение более длинных ответов, когда всё остальное близко; это хорошо задокументированное человеческое смещение. Обучите reward model на 2000 сравнениях и прочитайте её веса:

Reward model работает идеально. Она добросовестно выучила предпочтения, которые ей показали, — включая ту их часть, которая не имеет отношения к качеству. Reward model — не мера хорошего; это мера того, что выбрали аннотаторы, и каждое смещение в пуле разметки теперь стало коэффициентом в дифференцируемой функции, которую гораздо более крупная модель вот-вот начнёт оптимизировать.

И это приводит нас к тому, что происходит при оптимизации. Дайте policy фиксированный бюджет усилий, который нужно распределить между свойствами ответа, с реалистичной асимметрией: быть полезным и правильным дорого, а быть длиннее дёшево — нужно просто продолжать писать.

Reward на единицу усилия для модели, обученной выше: полезность 8.26, правильность 8.31, длина 31.70. Длина окупается почти в четыре раза лучше правильности — не потому, что reward model сломана, а потому, что это дёшево.

Оптимизируйте по этому reward и смотрите на оба числа:

Reward вырос в 2,5 раза. То, что reward должен был измерять, ушло в ноль. Policy обнаружила, что может получать огромные баллы, если писать много и не говорить ничего, и никакая часть обучающего цикла не могла это заметить, потому что reward model и есть определение хорошего внутри цикла.

Это reward hacking, и если вы когда-нибудь задавались вопросом, почему chat models такие многословные, эта таблица — значительная часть ответа.

Стандартная защита — штрафовать policy за слишком большое отклонение от начальной точки, измеряя расстояние KL-дивергенцией из главы 4:

Reference $\pi_{\text{ref}}$ — это SFT-модель, policy до reinforcement-этапа. Утверждается, что это не даёт модели уйти в дегенеративное поведение. Давайте выясним, сколько в этом утверждении остаётся после измерения. Та же постановка, перебор $\beta$:

Читайте последнюю строку относительно остальных. При $\beta = 0$ и $\beta = 1$ штраф вообще ничего не делает: reward стоит настолько больше, чем KL, что optimiser платит штраф и всё равно взламывает метрику. Между 5 и 15 поведение резко меняется. А при $\beta = 60$ истинное качество поднимается обратно до 1.769 — что всё ещё ниже 1.791, которые были у reference model до того, как всё это началось.

Одна оговорка, прежде чем кто-то где-то процитирует это число: 1.791 в последней строке и 0.974, которые первая таблица даёт starting policy, — это два разных измерения одной и той же pre-RL модели, сделанные отдельно в двух экспериментах. Сравнивайте строки внутри таблицы, никогда между таблицами: вывод каждой таблицы держится на её собственных строках, и ни один не зависит от baseline другой.

Так что честное резюме — не «KL-штраф предотвращает reward hacking». Оно такое:

KL-штраф не предотвращает reward hacking. Он ограничивает, насколько далеко policy может отойти от reference, — а поскольку для сбоя нужно движение, это помогает. Но это поводок, а не исправление: при низком $\beta$ поводок рвётся, а при высоком $\beta$ вы получаете обратно reference model, и весь дорогой этап не купил ничего.

Полезная полоса узкая, её положение зависит от reward model, и найти её можно только наблюдением. Поэтому reference model должна быть хорошей: KL — это пол на уровне качества reference, а не потолок для сбоя. И это большая часть причины, по которой этот этап труден на практике, а не в принципе.

Алгоритм, благодаря которому это заработало в масштабе, — Proximal Policy Optimization.³ В одном абзаце: он оценивает advantage каждого ответа, обновляет policy, чтобы повысить вероятность ответов выше baseline, и clipping размера каждого отдельного обновления, чтобы большая оценка advantage не разрушила policy за один шаг. В применении к языковым моделям⁴ это означает держать в игре сразу четыре модели — policy, reference, reward model и critic, — причём policy генерирует свежие samples на протяжении всего обучения.

Он работает, он породил InstructGPT и всё, что от него произошло, и он действительно сложен: четыре модели в памяти, sampling в обучающем цикле и заслуженная репутация нестабильности. Делать вид, что его можно реализовать в blog post, было бы нечестно, поэтому эта глава этого не делает.

То, что заменило его для большинства целей, возникло из одного наблюдения. У KL-регуляризованной цели выше есть оптимальная policy в closed form, и это выражение можно обратить: reward можно записать через оптимальную policy и reference. Если подставить это обратно в loss Bradley–Terry, reward model полностью исчезает. Остаётся supervised loss на preference pairs — без sampling, без critic, без 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)                        

Прочитайте, что они говорят. Вверх проталкивается величина, показывающая, насколько сильнее policy предпочитает победителя, чем это делала reference, минус насколько сильнее она предпочитает проигравшего. Reference — не штраф, прикрученный потом; она находится внутри loss, поэтому DPO не нужен отдельный KL-член.

Самое важное свойство — в gradient. Посчитайте loss и его gradient на одной и той же паре в пяти разных состояниях policy:

Gradient растёт по мере того, как policy ошибается сильнее. Пары, с которыми модель уже справляется, почти ничего не вносят; пары, которые она переворачивает наоборот, доминируют в обновлении. DPO взвешивает каждый пример по тому, насколько policy сейчас ошибается, автоматически, без расписания — и это самовзвешивание является механизмом, который выполняет работу, раньше выполнявшуюся оценкой advantage и critic в PPO. (Loss в третьей строке равен ровно $\ln 2$ — это якорь для проверки любой реализации: policy, идентичная своей reference, ничему не научилась и должна сидеть на $\ln 2$.)

GRPO⁶ выбирает другой выход из той же проблемы. Он сохраняет цикл sampling, но удаляет critic: вместо обучения модели предсказывать baseline он сэмплирует группу ответов на один и тот же prompt и напрямую использует средний reward группы как baseline. Advantage ответа — это то, насколько он лучше своих соседей. Это меняет целую модель на больший batch, и именно это сделало практичным обучение на проверяемых rewards — тему главы 12.

Две мысли, которые нужно унести дальше.

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

Вторая — вопрос, который скрывает слово aligned. С кем aligned? Цепочка такова: компания пишет guidelines, подрядчики их интерпретируют, их сравнения обучают reward model, reward model формирует policy, а policy отвечает на вопрос человека, который ничего из этого не видел. Каждое звено — выбор конкретных людей, и ни один алгоритм в этой главе не имеет собственного мнения о том, хороши ли эти выборы.

Это не риторический эффект. Это конкретная причина, по которой две frontier models отказывают на разные запросы, почему одна и та же модель меняет мнение между версиями, и почему «aligned» — описание процесса, а не свойство артефакта. Математика в этой главе устоялась. Эта часть — нет.

Post-training научил модель отвечать. Он не научил её думать перед ответом, а это две разные вещи — причём, как оказывается, вторую тоже можно обучать.

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

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