RLHF — reward model и PPO

Зачем это нужно

В прошлом уроке награда бралась «из воздуха»: правильный ответ на «7·8» легко проверить. Но как проверить, что письмо вежливое, объяснение понятное, а шутка смешная? Формулы нет. Есть люди, которые могут сравнить два ответа и сказать, какой лучше.

RLHFобучение с подкреплением на основе отзывов людей (RLHF)EN reinforcement learning from human feedback (RLHF) (reinforcement learning from human feedback — обучение с подкреплением на отзывах людей) превращает такие сравнения в награду. Сначала на них учат отдельную нейросеть — reward modelмодель вознагражденияEN reward model (RM, модель вознаграждения), а потом RL-алгоритмом PPO оптимизируют модель против этой RM. Так OpenAI сделала InstructGPT (2022), предшественника ChatGPT. Напомним главный результат статьи из урока 6.1.1: ответы InstructGPT на 1.3 млрд параметров люди предпочли ответам GPT-3 на 175 млрд — модели более чем в 100 раз больше. Выравнивание (alignmentвыравнивание (alignment)EN alignment) дало больше, чем стократный рост размера.

Этот урок — про три части RLHF: данные предпочтений, reward model и PPO. И про то, почему всё это дорого и хрупко.

flowchart LR
S["SFT-модель"] -->|"K ответов на промпт"| H["Люди ранжируют ответы"]
H --> D["Пары: chosen ≻ rejected"]
D --> RM["Reward model: r(x, y) ∈ ℝ"]
S --> PPO["PPO: политика + критик + референс + RM"]
RM --> PPO
PPO --> A["Выровненная модель"]

Конвейер RLHF (InstructGPT): SFT → предпочтения → reward model → PPO

Шаг 1. Сбор предпочтений

Почему сравнения, а не оценки по шкале 1–10? Люди плохо держат абсолютную шкалу: у одного «7» — это хорошо, у другого — средне, и сегодня не так, как вчера. А «A лучше B» люди говорят гораздо согласованнее.

Как это устроено в InstructGPT:

• Промпты — запросы пользователей API и задания, написанные разметчиками.
• SFT-модель генерирует на промпт от $K = 4$ до $K = 9$ ответов.
• Около 40 нанятых разметчиков ранжируют их от лучшего к худшему.
• Ранжирование из $K$ ответов даёт $\binom{K}{2}$ пар: для $K = 9$ это 36 сравнений за один просмотр.

Результат — данные предпочтенийданные предпочтенийEN preference dataТройки (промпт, лучший ответ, худший ответ) — chosen / rejected.: тройки «промпт, лучший ответ (chosen, $y_w$), худший (rejected, $y_l$)». Именно в таком формате лежат открытые датасеты: Anthropic HH-RLHF, PKU-SafeRLHF и десятки других.

Люди не согласны друг с другом

В InstructGPT обученные разметчики соглашались друг с другом в 72.6% случаев. Значит, примерно каждое четвёртое сравнение «спорное», и никакая reward model не угадает 100% пар. Шум в данных — норма, а не баг, и его нужно учитывать (об этом — китайская работа Fudan в конце урока).

Разметка дорогая и медленная, поэтому всё чаще сравнения делает сильная LLM по написанным людьми принципам — RLAIF (RL from AI feedback). Формат данных и вся математика ниже от этого не меняются.

Шаг 2. Модель Брэдли–Терри

Нужно связать «скрытое качество» ответа — число $r$ — с вероятностью, что человек выберет этот ответ. Модель Брэдли–Терримодель Брэдли–ТерриEN Bradley–Terry modelP(A ≻ B) = σ(r_A − r_B). Та же модель стоит за рейтингом Эло и лидербордом Chatbot Arena. (1952) предлагает самое простое:

$$P(y_w \succ y_l \mid x) = \frac{e^{r(x, y_w)}}{e^{r(x, y_w)} + e^{r(x, y_l)}} = \sigma\big(r(x, y_w) - r(x, y_l)\big)$$

где $\sigma$ — сигмоидасигмоида (логистическая функция)EN sigmoid (logistic function)σ(z) = 1 / (1 + e^(−z)) — превращает любое число в вероятность от 0 до 1., а знак $\succ$ читается «лучше, чем». Второе равенство получается делением числителя и знаменателя на $e^{r_w}$: $\frac{1}{1 + e^{-(r_w - r_l)}} = \sigma(r_w - r_l)$. Важна только разница наград:

Разница $r_w - r_l$	0	1	2	3
$P(y_w \succ y_l)$	0.50	0.73	0.88	0.95

Это та же модель, что стоит за рейтингом Эло в шахматах и за лидербордом Chatbot Arena, где модели сравнивают вслепую парами. По сути — логистическая регрессиялогистическая регрессияEN logistic regressionНесмотря на название, это метод классификации. У Чжоу Чжихуа («арбузная книга») — «регрессия логарифма шансов», у Ли Хана («Методы статистического обучения») — фонетическая запись английского слова logistic. из урока 2.2.2: бинарная классификация «лучше ли A, чем B» с логитом $r_w - r_l$.

Максимизируем правдоподобие наблюдённых предпочтений — получаем loss reward model:

$$\mathcal{L}_{\text{RM}} = -\,\mathbb{E}_{(x, y_w, y_l)}\Big[\log \sigma\big(r_\phi(x, y_w) - r_\phi(x, y_l)\big)\Big]$$

Три полезных факта:

1. Проверка здравого смысла. В начале обучения награды почти равны, $\sigma(0) = 0.5$, и loss $\approx \ln 2 = 0.693$. Видите на первом шаге 5.0 — ищите баг.
2. Градиент по разнице равен $-\sigma(r_l - r_w)$: большой, когда RM ошибается, и почти нулевой на выученных парах.
3. Сдвиг не важен. Прибавьте ко всем наградам 100 — loss не изменится. Награда определена с точностью до константы, поэтому её нормируют перед RL.

Шаг 3. Reward model

Архитектура RM — та же LLM (обычно инициализированная SFT-моделью), только вместо LM-головы на $V$ выходов стоит линейный слой на один выход. Промпт и ответ пропускают через трансформер и берут скаляр на последнем токене:

import torch
import torch.nn as nn


class RewardModel(nn.Module):
    def __init__(self, backbone, d_model):
        super().__init__()
        self.backbone = backbone                       # трансформер без LM-головы
        self.v_head = nn.Linear(d_model, 1)            # d_model → одно число

    def forward(self, input_ids, last_idx):
        h = self.backbone(input_ids)                   # [B, T, d_model]
        h_last = h[torch.arange(len(h)), last_idx]     # скрытое состояние последнего токена ответа
        return self.v_head(h_last).squeeze(-1)         # [B] — награды

В InstructGPT reward model была на 6 млрд параметров — в 30 раз меньше политики на 175B: большие RM учились нестабильно и стоили слишком дорого. Все $\binom{K}{2}$ пар одного промпта клали в один элемент батча: каждый ответ проходит через сеть один раз, и RM меньше переобучается на повторяющихся ответах.

Шаг 4. PPO для языковой модели

Теперь у нас есть награда. Можно взять REINFORCE из прошлого урока, но у него две беды:

• Один шаг на одну генерацию. Генерация — самая дорогая часть, а градиент по устаревшим ответам неверен.
• Слишком большой шаг может за одно обновление испортить политику, и она начнёт генерировать мусор, на котором уже ничему не научится.

PPOпроксимальная оптимизация политики (PPO)EN proximal policy optimization (PPO)Schulman и др., 2017. Ограничивает шаг обновления «клиппингом» отношения вероятностей. (Schulman и др., 2017) решает обе проблемы. Сам алгоритм вы разобрали в уроке 6.0.3: отношение вероятностей, клиппинг, критик, GAE, энтропия и несколько эпох на одном батче. Здесь — только то, что меняется, когда политика — LLM.

Отношение вероятностей и клиппинг по токенам

Ответы сгенерированы старой политикой $\pi_{\text{old}}$, а учим новую $\pi_\theta$, поэтому каждый токен ответа взвешивают отношением вероятностейвыборка по значимости (importance sampling)EN importance samplingПеревзвешивание сэмплов старой политики отношением π_new / π_old — основа PPO. (importance sampling) и обрезают его до $[1 - \varepsilon, 1 + \varepsilon]$:

$$\rho_t = \frac{\pi_\theta(y_t \mid s_t)}{\pi_{\text{old}}(y_t \mid s_t)}, \qquad L^{\text{CLIP}} = \mathbb{E}_t\Big[\min\big(\rho_t A_t,\ \mathrm{clip}(\rho_t, 1 - \varepsilon, 1 + \varepsilon)\, A_t\big)\Big]$$

Здесь $s_t$ — промпт плюс уже написанные токены, $y_t$ — токен ответа, обычно $\varepsilon = 0.2$. Правило из таблицы пяти случаев урока 6.0.3: PPO не даёт уйти слишком далеко в «выгодную» сторону, но всегда даёт исправить ошибку. Например, при $A = +1$ и $\rho = 1.5$ цель обрезана до 1.2 и градиента нет: вероятность хорошего токена уже подняли на 50%. При $A = -1$ и $\rho = 1.5$ градиент есть: плохой токен стал чаще, это надо исправить.

Важная для LLM оговорка: поправка учитывает только вероятность токена, но не то, что новая политика писала бы другие продолжения. Поэтому политики не должны расходиться далеко — за этим, кроме клиппинга, следит и KL-штраф к референсной модели.

Критик и преимущество для каждого токена

Откуда $A_t$? В PPO baseline — отдельная нейросеть, критиккритик, value-модельEN critic / value modelСеть, предсказывающая ожидаемую награду из текущего состояния; в PPO служит baseline для каждого токена. $V_\psi(s_t)$: она по началу ответа предсказывает, какую награду он в итоге получит. Обычно это копия RM или SFT-модели со скалярной головой; учат её регрессией $(V_\psi(s_t) - G_t)^2$, где $G_t$ — возврат (return): сумма наград, фактически полученных от токена $t$ до конца ответа.

Награда в RLHF складывается так: на каждом токене — KL-штраф $-\beta \log \frac{\pi_\theta(y_t)}{\pi_{\text{ref}}(y_t)}$ из прошлого урока, а на последнем токене к нему добавляется оценка RM. Преимущество считают методом GAEобобщённая оценка преимущества (GAE)EN generalized advantage estimation (GAE)Schulman и др., 2015. Смешивает оценки преимущества разной длины с коэффициентом λ. (вывод и пример с роботом-курьером — в уроке 6.0.3), обычно с $\gamma = 1$:

$$\delta_t = r_t + \gamma V(s_{t+1}) - V(s_t), \qquad \hat A_t = \sum_{l \ge 0} (\gamma \lambda)^l\, \delta_{t+l}$$

Пример на токенах. Ответ из трёх токенов, RM поставила 1.0 (KL для простоты опустим), критик оценил состояния перед каждым токеном как $V = [0.5, 0.6, 0.9]$, после последнего токена $V = 0$ (ответ закончен), $\gamma = 1$. Награды по токенам $r = [0, 0, 1]$, поэтому $\delta = [0 + 0.6 - 0.5,\ 0 + 0.9 - 0.6,\ 1 + 0 - 0.9] = [0.1, 0.3, 0.1]$: второй токен поднял «шансы ответа» с 0.6 до 0.9 — критик считает его ключевым.

• При $\lambda = 1$: $\hat A = [0.5, 0.4, 0.1]$ — это просто $R - V(s_t)$, как в REINFORCE с baseline.
• При $\lambda = 0$: $\hat A = \delta = [0.1, 0.3, 0.1]$ — заслуга достаётся тому токену, после которого оценка выросла.
• При типичном $\lambda = 0.95$: $\hat A = [0.475, 0.395, 0.1]$ — компромисс между шумом и смещением.

Так критик раздаёт заслугу по токенам — то, чего нет у REINFORCE и GRPO, где все токены ответа получают одно преимущество. Но для этого критик должен быть точным на каждом токене, хотя награда приходит только в конце, — это его главная слабость в LLM.

Один шаг RLHF с PPO

1. Генерация. Политика отвечает на батч промптов. Это самая медленная часть шага.
2. Оценка. RM ставит награды; референсная модель считает свои log-вероятности для KL; критик — значения $V$.
3. Преимущества по GAE, их нормируют по батчу.
4. Обновление. 1–4 эпохи по мини-батчам: политика — по $L^{\text{CLIP}}$, критик — по MSE (полный loss — урок 6.0.3).
5. Повторить с новым батчем промптов.

В InstructGPT к цели добавили ещё слагаемое с градиентами обычного претрейна (вариант PPO-ptx). Оно уменьшает налог на выравниваниеналог на выравниваниеEN alignment taxПадение качества на обычных задачах после выравнивания под предпочтения. — падение качества на обычных NLP-задачах после выравнивания.

Почему это дорого: четыре модели

flowchart TB
P["Политика π_θ — обучается"] -->|"ответы"| RM["Reward model — заморожена"]
P -->|"log π"| REF["Референс π_ref — заморожена"]
P -->|"состояния"| C["Критик V_ψ — обучается"]
RM -->|"награда"| G["GAE: преимущества"]
REF -->|"KL-штраф"| G
C -->|"V(s_t)"| G
G --> P
G --> C

Четыре модели в памяти во время PPO

Прикинем память для политики на 7B. Как вы считали в уроке 6.2.1, обучение с Adam в смешанной точности требует примерно 16 байт на параметр (веса BF16, градиенты, FP32-копия весов и два момента Adam), то есть ~112 ГБ. Замороженная модель в BF16 — 2 байта на параметр, ~14 ГБ. Активации и KV-кэш генерации — сверху.

Метод	Модели в памяти	Веса + оптимизатор
SFT	политика	~112 ГБ
PPO	политика + критик (обучаются), референс + RM (заморожены)	112 + 112 + 14 + 14 ≈ 252 ГБ
DPO (урок 6.3.3)	политика + референс	~126 ГБ
GRPO (модуль 6.4)	политика + референс (+ RM, если нужна)	~126–140 ГБ

Кроме памяти, у PPO много чувствительных гиперпараметров: два learning rate, $\beta$, $\varepsilon$, $\gamma$, $\lambda$, число эпох, нормировки наград и преимуществ. Неудачная комбинация — и обучение разваливается. Поэтому о «секретах» PPO написано столько работ, в том числе китайских (см. ниже), а DeepSeek в итоге избавились от критика совсем (GRPO).

🖥 На вашей машине (4×GPU)

У вас 4 карты по 32 ГБ — 128 ГБ на всё. Полный PPO для 7B (~252 ГБ без активаций) не поместится, полный DPO для 7B (~126 ГБ) тоже: на активации места не останется. Реалистичный путь — LoRA из урока 6.2.1. Веса базы заморожены (14 ГБ в BF16), обучается доля процента параметров, а референсной моделью служит та же база с выключенным адаптером, так что вторая копия не нужна. Так DPO для моделей 0.5–7B помещается на одну-две карты (команды — в практике следующего урока).

Что запустить: настоящий PPO на 0.5B. Полный PPO без LoRA разумно пробовать на маленьких моделях. Готовый рецепт — quickstart фреймворка verl (ByteDance): политика и критик — Qwen2.5-0.5B-Instruct, задачи — школьная математика GSM8K, награда — правило «итоговое число совпало с эталоном». Reward model здесь не нужна, поэтому из схемы выше в памяти три модели. По таблице это 8 + 8 ГБ на политику и критика с Adam и 1 ГБ на референс, плюс vLLM для генерации и активации: на четырёх картах с запасом. Подготовка данных и команда для GRPO разобраны в практикуме 6.4.5; для PPO уберите строки с adv_estimator=grpo и rollout.n=8 и добавьте параметры критика по образцу quickstart из документации verl (critic.model.path, critic.optim.lr и размер микробатча критика).

• На что смотреть. critic/vf_loss — ошибка критика, должна падать; critic/score/mean — средняя награда; actor/pg_clipfrac — доля токенов, где сработал клиппинг; строки timing_s/… — сколько секунд ушло на генерацию и на обновление политики и критика.
• Главный опыт. Прогоните на тех же данных GRPO из практикума 6.4.5 и сравните пик памяти (nvidia-smi) и время шага. Разница — цена критика, ради экономии которой DeepSeek придумала GRPO.
• Чем это лучше CPU. На процессоре PPO с тремя моделями и генерацией ответов длиной в сотни токенов шёл бы минуты на шаг. Игрушечные примеры урока показывают отдельные детали, а здесь вы увидите весь цикл на настоящей LLM.

Подробнее о машине — на странице «Ваша лаборатория».

Reward hacking: когда мера становится целью

Закон Гудхартазакон ГудхартаEN Goodhart's law«Когда мера становится целью, она перестаёт быть хорошей мерой».: когда мера становится целью, она перестаёт быть хорошей мерой. Reward model — лишь приближение к мнению людей, обученное на конечных данных. Политика, которую оптимизируют против неё тысячи шагов, находит места, где RM ошибается. Это взлом наградывзлом награды (reward hacking)EN reward hackingПолитика находит способ получить высокую награду, не делая того, что задумали люди..

Классика из RL для игр: в 2016 году OpenAI описала агента гоночной игры CoastRunners. Он нашёл лагуну, где можно бесконечно кружить и собирать бонусы, и набирал больше очков, чем люди, так ни разу и не доехав до финиша. У LLM то же самое выглядит так:

• Длина. RM привыкла, что подробные ответы лучше, и награждает воду.
• Угодничествоугодничество (sycophancy)EN sycophancyСклонность модели соглашаться с пользователем и льстить ему вместо правдивого ответа — частый побочный эффект RLHF. (sycophancy). Согласиться с пользователем выгоднее, чем поправить его.
• Форма вместо содержания: списки, жирный шрифт, уверенный тон — при неверных фактах.

Исследование OpenAI 2022 года (Gao и др., «Scaling Laws for Reward Model Overoptimization») измерило это на синтетической «золотой» RM. По мере удаления политики от исходной (рост KL) оценка обучаемой RM растёт монотонно, а «настоящее» качество сначала растёт, потом падает. Чем больше RM, тем выше удаётся поднять настоящее качество до спада.

Чем лечат:

• KL-штраф и ранняя остановка по KL;
• ансамбль RM и пессимистичная оценка (минимум или среднее минус разброс);
• переобучение RM на свежих ответах текущей политики — итеративный, онлайн-RLHF;
• штрафы за длину и формат;
• там, где это возможно, — правиловые награды: проверка ответа или запуск тестов. Так сделал DeepSeek-R1.

К закону Гудхарта мы вернёмся на ступени 9: в уроке 9.3.3 reward hacking разобран как часть общей задачи выравнивания — шумная прокси против прокси с лазейкой, угодничество, Constitutional AI и эксперименты лабораторий, где взлом награды переходил в другие виды плохого поведения.

Практика

Задание: loss Брэдли–Терри

Реализуйте вероятность и устойчивый loss Брэдли–Терри, его градиент, превращение ранжирования из $K$ ответов в пары и «reward model» с одним числом на ответ — как рейтинг Chatbot Arena.

Брэдли–Терри и reward modelnumpy · нужен интернет6 тестов

import numpy as np


def sigmoid(x):
    """Устойчивая сигмоида — уже готова. Работает и для x = ±1000."""
    x = np.asarray(x, dtype=float)
    return np.exp(-np.logaddexp(0.0, -x))


def bt_prob(r_chosen, r_rejected):
    """Вероятность по Брэдли–Терри, что chosen лучше rejected: sigmoid(r_c - r_r).

    Аргументы — числа или массивы одинаковой формы.
    """
    # TODO: ваш код
    ...


def bt_loss(r_chosen, r_rejected):
    """Loss reward model: среднее по парам  -log sigmoid(r_c - r_r).

    Вернуть float. Должен быть устойчив: для Δ = -1000 ответ ≈ 1000, а не inf.
    Подсказка: -log sigmoid(Δ) = log(1 + exp(-Δ)) = np.logaddexp(0, -Δ).
    """
    # TODO: ваш код
    ...


def bt_grad(r_chosen, r_rejected):
    """Градиенты bt_loss (СРЕДНЕГО по N парам) по r_chosen и по r_rejected.

    Вернуть кортеж (g_chosen, g_rejected) — два массива формы как у входа.
    """
    # TODO: ваш код
    ...


def ranking_to_pairs(ranking):
    """Разметчик упорядочил K ответов от лучшего к худшему: например [3, 0, 2, 1].

    Вернуть список ВСЕХ пар (победитель, проигравший) — их C(K, 2):
    [(3, 0), (3, 2), (3, 1), (0, 2), (0, 1), (2, 1)].
    """
    # TODO: ваш код
    ...


def fit_scores(pairs, n_items, steps=500, lr=1.0):
    """«Reward model» с одним числом на ответ: s = нули, затем `steps` шагов
    градиентного спуска s -= lr * grad, где grad — градиент bt_loss
    по s (собрать из bt_grad для s[winners] и s[losers]).

    Вернуть s - s.mean() (награда определена с точностью до сдвига).
    Внимание: один ответ входит во многие пары — используйте np.add.at или цикл.
    """
    # TODO: ваш код
    ...


# Проверьте себя кнопкой «Запустить»:
print(bt_prob(1.0, 0.0))                       # ≈ 0.7311
print(ranking_to_pairs([3, 0, 2, 1]))
print(fit_scores([(0, 1), (0, 1), (1, 0), (1, 2), (2, 1), (0, 2)], 3))

ЗапуститьПроверитьПодсказкаСбросить

Локально: reward model на PyTorch и взлом награды

Сгенерируем синтетические ответы с тремя свойствами: верен ли ответ, насколько он подробен (люди это ценят) и какой длины. «Люди» выбирают по Брэдли–Терри на основе верности и подробности. А reward model видит только верность и длину — подробность ей приходится угадывать по длине. Как обычно и бывает: «понятность» измерить трудно, а длина — вот она.

import torch
import torch.nn.functional as F

torch.manual_seed(0)


def answers(n):
    """Признаки ответа: верен ли он, насколько подробен (это ценят люди) и его длина."""
    correct = torch.bernoulli(torch.full((n,), 0.5))
    detail = torch.rand(n)                              # 0…1, модель вознаграждения его НЕ видит
    length = 3 * detail + 0.3 * torch.randn(n).abs()    # сотни токенов; подробнее → длиннее
    utility = 2 * correct + detail                      # «истинное» мнение людей
    return torch.stack([correct, length], 1), utility


# 1) Данные предпочтений: пары ответов, человек выбирает по Брэдли–Терри
xa, ua = answers(4000)
xb, ub = answers(4000)
a_wins = torch.bernoulli(torch.sigmoid(ua - ub)).bool()
chosen = torch.where(a_wins[:, None], xa, xb)
rejected = torch.where(a_wins[:, None], xb, xa)

# 2) Reward model: линейная голова над признаками, loss Брэдли–Терри
rm = torch.nn.Linear(2, 1)
opt = torch.optim.Adam(rm.parameters(), lr=0.05)
for step in range(300):
    margin = rm(chosen) - rm(rejected)
    loss = -F.logsigmoid(margin).mean()
    opt.zero_grad()
    loss.backward()
    opt.step()

w = rm.weight.data[0]
acc = (margin > 0).float().mean()
print(f"loss {loss.item():.3f}, точность на парах {acc:.2f}")
print(f"веса RM: за верность {w[0]:.2f}, за каждые 100 токенов длины {w[1]:.2f}")

# 3) «Политика» ищет ответ, который RM оценит выше всего
short_ok = torch.tensor([1.0, 1.0])      # верный ответ на 100 токенов
long_bad = torch.tensor([0.0, 20.0])     # неверная «простыня» на 2000 токенов
print(f"RM: верный короткий {rm(short_ok).item():.2f}, неверная простыня {rm(long_bad).item():.2f}")

loss 0.533, точность на парах 0.71
веса RM: за верность 1.95, за каждые 100 токенов длины 0.29
RM: верный короткий 2.90, неверная простыня 6.49

RM честно выучилась: вес за верность 1.95 (у «людей» 2), точность 71%. Потолок здесь задаёт шум самих предпочтений, как у живых разметчиков: даже идеальная RM, знающая истинную полезность, угадала бы лишь около 73% пар. Но длина для неё — признак подробности, и неверная простыня на 2000 токенов получает награду на 3.6 выше верного короткого ответа. Сравнивать награды можно только разностью (сдвиг не важен), и по Брэдли–Терри это значит: RM на $\sigma(3.6) \approx 97\%$ «уверена», что простыня лучше. Таких длинных ответов в обучающих данных не было — RM экстраполирует линейный тренд туда, где его никто не проверял. RL-политика, которую не держит KL-штраф, рано или поздно найдёт эту область.

Китайский угол: «секреты RLHF» и борьба со взломом награды

Qwen-Chat (2023, техотчёт Qwen) обучали классическим конвейером: reward model и PPO поверх SFT; в отчёте сравниваются чат-модели после SFT и после RLHF. С этого же года китайские лаборатории много публикуют о том, как заставить RLHF работать:

• Fudan NLP (MOSS-RLHF). Secrets of RLHF, Part I: PPO (2023) разбирает, какие детали PPO действительно важны. Главный вывод: ключ к стабильности — ограничения на политику (например, KL-штраф). Авторы собрали набор приёмов PPO-max. В Part II: Reward Modeling (2024) оценивают «силу» каждого предпочтения голосованием ансамбля RM, чтобы найти неверные и спорные пары. Это ответ на те самые 27% разногласий разметчиков.
• Shanghai AI Lab, InternLM2 (2403.17297) — COOL RLHF: одна условная RM для разных, иногда противоречащих предпочтений и несколько раундов онлайн-PPO, чтобы гасить reward hacking, который появляется в каждом раунде.
• Пекинский университет, Safe RLHF (2310.12773) разделяет «полезность» и «безвредность»: отдельная reward model и отдельная cost model, баланс между ними подбирается методом Лагранжа (классическим способом оптимизации с ограничением: «максимизируй полезность, пока вред не выше порога»). Команда выложила открытый датасет PKU-SafeRLHF с раздельной разметкой полезности и безвредности.
• DeepSeek-R1 (2501.12948) в RL для рассуждений отказался от нейросетевой RM. Авторы прямо пишут, что на большом масштабе она подвержена reward hacking. Награды R1-Zero — правиловые: верен ли ответ и соблюдён ли формат.

Код, который стоит прочитать: в MiniMind скрипт train_ppo.py в одном файле показывает все четыре роли этого урока. Actor — сама MiniMind. Critic — её копия со скалярной головой. Reference — замороженная копия. Reward model — InternLM2-1.8B-Reward от Shanghai AI Lab, примерно в 30 раз больше самой MiniMind-3 (64M параметров). Раз оценки ставит модель, а не люди, в README MiniMind этот этап честно называется RLAIF. По умолчанию (проверено в октябре 2026) там стоят $\varepsilon = 0.2$, коэффициент KL 0.02, $\gamma = 1$ и $\lambda = 0.95$ — те же значения, что в нашем примере с GAE. Теорию PPO по-китайски лучше всего читать в easy-rl, гл. 5: importance sampling там — «выборка по значимости», а клиппинг — «обрезка».

Проверь себя

Проверь себя6 вопросов·

1 Reward model поставила ответу A награду 2, ответу B — 1. С какой вероятностью, по Брэдли–Терри, человек предпочтёт A? Округлите до двух знаков.

2 Вы запустили обучение reward model. Какой loss ожидается на самом первом шаге? Округлите до двух знаков.

3 Разметчик упорядочил 9 ответов на один промпт. Сколько пар «лучше — хуже» это даёт для обучения RM?

4 В PPO с $\varepsilon = 0.2$ у токена преимущество $A = +1$, а отношение вероятностей $\rho = 1.5$. Что сделает градиент цели $L^{\text{CLIP}}$?

Продолжит поднимать вероятность токенаНичего: значение обрезано до $1.2 \cdot A$, градиент равен нулюНачнёт опускать вероятность токена

5 Какие утверждения о классическом RLHF с PPO верны?Можно выбрать несколько ответов

Политика обучаетсяКритик (value-модель) обучаетсяРеференсная модель обучается вместе с политикойReward model во время PPO замороженаРеференсная модель нужна для KL-штрафа

6 После RLHF ответы стали втрое длиннее, оценка reward model выросла, а в слепом сравнении люди довольны новыми ответами меньше, чем старыми. Как называется явление?

Переобучение SFTReward hacking: политика эксплуатирует то, что RM переоценивает длинуСлишком большой KL-штрафКатастрофическое забывание токенизатора

Проверить ответы

Итоги

• RLHF превращает сравнения «A лучше B» в награду: данные предпочтений → reward model → PPO.
• Брэдли–Терри: $P(y_w \succ y_l) = \sigma(r_w - r_l)$; loss RM — $-\log\sigma(r_w - r_l)$, в начале он равен $\ln 2$.
• PPO переиспользует ответы через отношение вероятностей и клиппингом не даёт политике уйти далеко за шаг. Критик и GAE дают преимущество каждому токену.
• Цена — четыре модели в памяти (~250 ГБ для 7B без активаций), медленная генерация и капризные гиперпараметры.
• Reward hacking неизбежен при сильной оптимизации прокси-награды; от него спасают KL, обновление RM и проверяемые награды.

Дальше: DPO — как из той же формулы $\pi^* \propto \pi_{\text{ref}} e^{r/\beta}$ получить обучение на предпочтениях без reward model и без PPO.