DPO — предпочтения без RL

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

В прошлом уроке RLHF с PPO потребовал четыре модели, генерацию на каждом шаге и десяток капризных гиперпараметров. В 2023 году группа из Стэнфорда (Rafailov и др.) показала, что для той же цели — максимум награды при KL-поводке к референсной модели — reward model и RL не нужны вовсе. Достаточно одного loss по парам предпочтений, который учится так же просто, как SFT.

Метод назвали DPOпрямая оптимизация предпочтений (DPO)EN direct preference optimization (DPO)Rafailov и др., 2023. Обучение на парах предпочтений без reward model и без RL-цикла. (Direct Preference Optimization), а подзаголовок статьи объясняет главный трюк: «ваша языковая модель тайно является reward model». В 2024 году DPO стал стандартной ступенью пост-трейнинга открытых моделей, включая DeepSeek LLM Chat и Qwen2. Сегодня он остаётся одним из основных способов подогнать стиль, тон и безопасность, когда награду нельзя проверить автоматически.

flowchart LR
subgraph PPO["RLHF с PPO"]
  direction LR
  A1["Пары предпочтений"] --> A2["Обучить reward model"]
  A2 --> A3["PPO: генерация, RM, критик, референс"]
  A3 --> A4["Политика"]
end
subgraph DPO["DPO"]
  direction LR
  B1["Пары предпочтений"] --> B2["Один loss: политика + замороженный референс"]
  B2 --> B4["Политика"]
end

DPO выбрасывает два этапа из конвейера RLHF

Вывод DPO за три шага

Нам понадобятся две формулы из прошлых уроков: оптимальная политика при KL-штрафе (урок 6.3.1) и модель Брэдли–Терри (урок 6.3.2).

Шаг 1. Мы знаем оптимальную политику

Цель RLHF — максимизировать $\mathbb{E}_{y \sim \pi}[r(x, y)] - \beta\, \mathrm{KL}(\pi \,\Vert\, \pi_{\text{ref}})$. Её решение мы уже видели:

$$\begin{gathered} \pi^*(y \mid x) = \frac{1}{Z(x)}\, \pi_{\text{ref}}(y \mid x)\, \exp\!\Big(\frac{r(x, y)}{\beta}\Big), \\ Z(x) = \sum_y \pi_{\text{ref}}(y \mid x)\, e^{r(x, y)/\beta} \end{gathered}$$

Почему именно так? Распишем $\mathrm{KL}(\pi \,\Vert\, \pi^*)$ по определению и подставим $\log \pi^* = \log \pi_{\text{ref}} + r/\beta - \log Z(x)$:

$$\begin{aligned} \mathrm{KL}(\pi \,\Vert\, \pi^*) &= \mathbb{E}_{y \sim \pi}\Big[\log \pi - \log \pi_{\text{ref}} - \frac{r}{\beta} + \log Z(x)\Big] \\ &= \mathrm{KL}(\pi \,\Vert\, \pi_{\text{ref}}) - \frac{\mathbb{E}_{y \sim \pi}[r]}{\beta} + \log Z(x) \end{aligned}$$

Умножим обе части на $-\beta$ и перенесём $\beta \log Z(x)$ в другую сторону: цель RLHF равна $-\beta\, \mathrm{KL}\big(\pi \,\Vert\, \pi^*\big) + \beta \log Z(x)$. Второе слагаемое от $\pi$ не зависит, а KL неотрицательна и равна нулю только при $\pi = \pi^*$ (урок 1.3.3). Значит, максимум цели достигается ровно в $\pi^*$.

Проблема в $Z(x)$ — нормировочной константе, которая делает сумму вероятностей равной 1 (в статьях её называют статсуммой, partition function): это сумма по всем возможным текстам, посчитать её нельзя. Поэтому RLHF и идёт обходным путём через PPO.

Шаг 2. Выразим награду через политику

Прологарифмируем формулу для $\pi^*$ и выразим из неё $r$:

$$r(x, y) = \beta \log \frac{\pi^*(y \mid x)}{\pi_{\text{ref}}(y \mid x)} + \beta \log Z(x)$$

Это поворот всего вывода: любая политика задаёт свою награду, для которой она оптимальна. Награда «спрятана» в отношении вероятностей политики и референса. Её называют неявной наградойнеявная наградаEN implicit rewardВ DPO: r(x, y) = β · log(π(y|x) / π_ref(y|x)) — награда, «спрятанная» в самой политике..

Шаг 3. Подставим в Брэдли–Терри

Модели предпочтений нужна только разность наград двух ответов на один и тот же промпт. Слагаемое $\beta \log Z(x)$ зависит только от промпта и сокращается:

$$P(y_w \succ y_l \mid x) = \sigma\Big(\beta \log \frac{\pi^*(y_w \mid x)}{\pi_{\text{ref}}(y_w \mid x)} - \beta \log \frac{\pi^*(y_l \mid x)}{\pi_{\text{ref}}(y_l \mid x)}\Big)$$

Неизвестная $Z(x)$ исчезла. Осталось заменить $\pi^*$ на обучаемую политику $\pi_\theta$ и максимизировать правдоподобие наблюдённых предпочтений — ровно как reward model в прошлом уроке:

$$\mathcal{L}_{\text{DPO}}(\theta) = -\,\mathbb{E}_{(x, y_w, y_l)}\Big[\log \sigma\Big( \underbrace{\beta \log \frac{\pi_\theta(y_w \mid x)}{\pi_{\text{ref}}(y_w \mid x)}}_{\hat r_w} - \underbrace{\beta \log \frac{\pi_\theta(y_l \mid x)}{\pi_{\text{ref}}(y_l \mid x)}}_{\hat r_l}\Big)\Big]$$

Смысл: это тот же loss reward model, только награда здесь не отдельная сеть, а $\hat r = \beta \log(\pi_\theta / \pi_{\text{ref}})$. Учим «reward model» — и оптимальная для неё политика получается бесплатно, потому что это она сама.

Как DPO считается на практике

Для каждой пары нужны четыре числа — лог-вероятности ответов под политикой и под референсом:

1. Склеить «промпт + chosen» и «промпт + rejected», прогнать через политику, взять log-вероятности токенов.
2. Сложить их только по токенам ответа — та же маска, что в SFT (урок 6.1.2). Получаем $\log \pi_\theta(y_w \mid x)$ и $\log \pi_\theta(y_l \mid x)$.
3. То же для референсной модели без градиентов. Референс не меняется, поэтому его лог-вероятности можно посчитать один раз заранее и не держать модель в памяти.
4. Неявные награды, их разность, $-\log\sigma$, среднее по батчу.

Пример с числами. $\log \pi_\theta(y_w) = -10$, $\log \pi_\theta(y_l) = -12$, у референса оба $-11$, $\beta = 0.1$. Награды: $\hat r_w = 0.1 \cdot (-10 + 11) = +0.1$ и $\hat r_l = -0.1$. Отрыв $0.2$, loss $= \log(1 + e^{-0.2}) = 0.598$.

Проверка здравого смысла: на первом шаге $\pi_\theta = \pi_{\text{ref}}$, все награды нулевые, и loss равен $\ln 2 = 0.693$ — как у reward model. TRL и другие библиотеки логируют rewards/chosen, rewards/rejected, rewards/margins и rewards/accuracies (доля пар, где $\hat r_w > \hat r_l$). Смотрите на все четыре, а не только на loss.

Что делает градиент

$$\nabla_\theta \mathcal{L}_{\text{DPO}} = -\beta\, \mathbb{E}\Big[\, \underbrace{\sigma(\hat r_l - \hat r_w)}_{\text{вес пары}} \big(\nabla_\theta \log \pi_\theta(y_w \mid x) - \nabla_\theta \log \pi_\theta(y_l \mid x)\big)\Big]$$

Поднимаем вероятность хорошего ответа, опускаем плохого, а вес пары тем больше, чем сильнее неявная награда ошибается. При отрыве $-2$ (перепутан порядок) вес $\sigma(2) = 0.88$, при отрыве $+2$ — уже $0.12$. Авторы DPO показали, что без этого веса (просто «вверх chosen, вниз rejected») модель быстро деградирует.

β — длина поводка

$\beta$ — тот же коэффициент KL-штрафа из RLHF. Он стоит внутри сигмоиды, поэтому задаёт, насколько сильно политика должна разойтись с референсом, чтобы loss стал маленьким. Пусть мы хотим loss 0.1 на паре, то есть $\beta h \approx 2.25$ (потому что $-\log \sigma(2.25) \approx 0.1$), где $h$ — разность лог-отношений, а нужное $h$ получаем делением: $h = 2.25 / \beta$:

$\beta$	Нужная разность $h$ (в натах)	Поведение
0.5	4.5	короткий поводок: политика остаётся близко к референсу
0.1	22.5	стандарт (по умолчанию в статье DPO и в TRL)
0.01	225	длинный поводок: модель может уйти далеко и «сломаться»

Маленький $\beta$ — сильнее подгонка под пары и выше риск деградации. Большой — осторожные изменения.

Проверим теорию: DPO сходится к π*

Возьмём один промпт и 4 возможных ответа со скрытыми «истинными» наградами. Предпочтения сгенерируем по Брэдли–Терри, обучим DPO и сравним результат с формулой $\pi^* \propto \pi_{\text{ref}}\, e^{r/\beta}$. Чтобы не зависеть от случайных сэмплов, используем «бесконечные данные»: все пары с вероятностями предпочтений.

import itertools

import torch
import torch.nn.functional as F

# Один промпт, 4 возможных ответа. Политика — просто логиты над ответами.
answers = ["верно и кратко", "верно, но с водой", "уверенно неверно", "отказ"]
r_true = torch.tensor([2.0, 1.5, -1.0, 0.0])          # скрытая «истинная» награда
ref = torch.log_softmax(torch.tensor([0.0, 1.0, 0.5, -0.5]), 0)   # π_ref (после SFT)
beta = 1.0

# Все пары (i, j); вероятность, что человек предпочтёт i, — по Брэдли–Терри
pairs = list(itertools.combinations(range(4), 2))
i_idx = torch.tensor([i for i, _ in pairs])
j_idx = torch.tensor([j for _, j in pairs])
p_human = torch.sigmoid(r_true[i_idx] - r_true[j_idx])

logits = ref.clone().requires_grad_(True)               # старт: π = π_ref
opt = torch.optim.Adam([logits], lr=0.05)
for step in range(2001):
    logp = torch.log_softmax(logits, 0)
    h = beta * ((logp - ref)[i_idx] - (logp - ref)[j_idx])     # разница неявных наград
    loss = -(p_human * F.logsigmoid(h) + (1 - p_human) * F.logsigmoid(-h)).mean()
    opt.zero_grad()
    loss.backward()
    opt.step()
    if step in (0, 2000):
        print(f"шаг {step:4d}: DPO loss = {loss.item():.4f}")

pi_dpo = torch.softmax(logits, 0).detach()
pi_star = torch.softmax(ref + r_true / beta, 0)          # теория: π* ∝ π_ref·exp(r/β)
for a, p0, p1, p2 in zip(answers, ref.exp(), pi_dpo, pi_star):
    print(f"{a:<18} π_ref={p0:.3f}  DPO={p1:.3f}  π*={p2:.3f}")

шаг    0: DPO loss = 0.6931
шаг 2000: DPO loss = 0.4241
верно и кратко     π_ref=0.167  DPO=0.356  π*=0.356
верно, но с водой  π_ref=0.455  DPO=0.586  π*=0.586
уверенно неверно   π_ref=0.276  DPO=0.029  π*=0.029
отказ              π_ref=0.102  DPO=0.029  π*=0.029

DPO пришёл точно в $\pi^*$, ни разу не построив reward model. Обратите внимание: «верно, но с водой» в итоге вероятнее, чем «верно и кратко», хотя его награда ниже. Референс любил этот ответ, а KL-поводок сохраняет его вкусы. Чтобы «кратко» победило, нужен меньший $\beta$ — или другой референс.

DPO против PPO

	RLHF с PPO	DPO
Модели	4, две обучаются	2, обучается одна (референс можно заменить готовыми логпробами)
Reward model	отдельная, обучается заранее	неявная, внутри политики
Генерация во время обучения	на каждом шаге (on-policy)	нет — готовые пары (offline)
Гиперпараметры	lr ×2, $\beta$, $\varepsilon$, $\gamma$, $\lambda$, эпохи…	в основном $\beta$ и lr
Стабильность	капризный	как у SFT
Исследование	модель учится на своих новых ответах	только на ответах из датасета
Где сильнее	рассуждения, код, задачи с проверяемой наградой	стиль, тон, безопасность, «вкус»

У простоты DPO есть цена — четыре известные слабости:

1. Сдвиг распределения. Пары часто сгенерированы другими моделями. DPO смотрит только на разность двух ответов и может поднять вероятность третьих, которых нет ни в одной паре. Исследование Tsinghua (Xu и др., 2024) показало: аккуратно настроенный PPO обгоняет DPO во всех их тестах, включая соревновательное программирование. Лекарство — онлайн- или итеративный DPO: свежие пары из текущей политики, размеченные reward model.
2. Обе вероятности падают. Loss зависит только от разности. Если $\log \pi(y_w)$ упал с $-10$ до $-15$, а $\log \pi(y_l)$ — с $-12$ до $-17$, loss не изменился, хотя хороший ответ стал в $e^5 \approx 150$ раз менее вероятен. Такое часто видно в логах: rewards/chosen уходит в минус. Помогает, например, добавка SFT-loss на chosen-ответах.
3. Переобучение на однозначных парах. Если предпочтение в паре абсолютное, оптимум Брэдли–Терри — бесконечный отрыв. DPO будет раздвигать лог-отношения без конца, и KL-поводок фактически перестаёт работать.
4. Длина. Chosen-ответы в датасетах обычно длиннее, и DPO выучивает многословие — тот же reward hacking, только офлайн.

Российский угол

В статье «Встречаем YandexGPT 5» команда Яндекса пишет, что на этапе RLHF совмещала DPO, PPO и собственную модификацию LogDPO. Мотивация — слабость № 2: по словам авторов, на неоднозначных парах обычный DPO может «разучить» модель давать даже хорошие ответы, а LogDPO делает обучение стабильнее. Точную формулу смотрите в самой статье.

Варианты: IPO, KTO, SimPO, ORPO

Каждый вариант лечит одну из слабостей DPO:

Метод	Нужен референс?	Данные	Идея
IPO (DeepMind, 2023)	да	пары	квадратичный loss $(h - \frac{1}{2\beta})^2$: цель — конечный отрыв, нет переобучения (слабость № 3)
KTO (2024)	да	одиночные ответы с меткой «хорошо/плохо»	пары не нужны; loss построен по мотивам теории перспектив Канемана–Тверски: выигрыш и проигрыш относительно «точки отсчёта» весят по-разному
SimPO (2024)	нет	пары	награда — средняя лог-вероятность на токен $\frac{\beta}{\lvert y \rvert} \log \pi_\theta(y \mid x)$ и отступ $\gamma$ в сигмоиде: экономит память и борется с длиной (№ 4)
ORPO (2024)	нет	пары	SFT и предпочтения в одном этапе через отношение шансов (odds ratio)

SimPO целиком:

$$\mathcal{L}_{\text{SimPO}} = -\log \sigma\Big(\frac{\beta}{\lvert y_w \rvert} \log \pi_\theta(y_w \mid x) - \frac{\beta}{\lvert y_l \rvert} \log \pi_\theta(y_l \mid x) - \gamma\Big)$$

KTO особенно практичен: кнопки 👍/👎 в чат-интерфейсе дают ровно такие данные. А IPO вы реализуете в задании ниже.

Практика

Задание: DPO loss по лог-вероятностям

Реализуйте сумму лог-вероятностей ответа с маской, устойчивый DPO loss с неявными наградами (как dpo_loss в TRL), вес пары в градиенте и loss IPO.

DPO и IPO по логпробамnumpy · нужен интернет7 тестов

import numpy as np


def sequence_logprob(token_logprobs, mask):
    """log π(y|x) для каждой строки батча.

    token_logprobs — массив [B, T]: лог-вероятности токенов последовательности «промпт + ответ»;
    mask — массив [B, T] из 0/1: 1 только у токенов ОТВЕТА (промпт и паддинг не считаем).
    Вернуть массив [B] — сумму лог-вероятностей токенов ответа.
    """
    # TODO: ваш код
    ...


def dpo_loss(pi_chosen, pi_rejected, ref_chosen, ref_rejected, beta=0.1):
    """DPO loss по логпробам целых ответов (массивы [B] или числа).

    Неявные награды: r_c = beta * (pi_chosen - ref_chosen),
                     r_r = beta * (pi_rejected - ref_rejected).
    loss = mean( -log sigmoid(r_c - r_r) )  — считать УСТОЙЧИВО (np.logaddexp).

    Вернуть кортеж (loss: float, r_c: массив, r_r: массив) — по образцу dpo_loss в TRL
    (только TRL возвращает loss каждого примера, а мы — сразу среднее).
    """
    # TODO: ваш код
    ...


def dpo_weight(pi_chosen, pi_rejected, ref_chosen, ref_rejected, beta=0.1):
    """Вес каждого примера в градиенте DPO: sigmoid(r_r - r_c).

    Близок к 1, когда неявная награда «ошибается» (r_r > r_c), и к 0, когда пара уже выучена.
    """
    # TODO: ваш код
    ...


def ipo_loss(pi_chosen, pi_rejected, ref_chosen, ref_rejected, beta=0.1):
    """IPO (Azar и др., 2023): mean( (h - 1/(2*beta))**2 ),
    где h = (pi_chosen - ref_chosen) - (pi_rejected - ref_rejected) — БЕЗ умножения на beta.
    """
    # TODO: ваш код
    ...


# Проверьте себя кнопкой «Запустить»:
lp = np.array([[-0.5, -1.0, -2.0, -0.1]])
print(sequence_logprob(lp, [[0, 0, 1, 1]]))                 # ≈ [-2.1]
print(dpo_loss(-10.0, -12.0, -11.0, -11.0, beta=0.1))      # loss ≈ 0.598, награды 0.1 и -0.1
print(dpo_weight([-10.0, -12.0], [-12.0, -10.0], [-11.0, -11.0], [-11.0, -11.0], beta=0.1))

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

Локально: DPO на «игрушечной LLM»

Полный цикл DPO на PyTorch: модель предсказывает следующий токен, у каждой пары общий промпт из 4 токенов и ответ из 8. Chosen-ответы состоят из «хороших» токенов 0–9, rejected — из «плохих» 40–49. Код почти без изменений переносится на настоящую модель из transformers: меняется только model(ids) на model(ids).logits.

import copy

import torch
import torch.nn as nn
import torch.nn.functional as F

torch.manual_seed(0)
V, d, B, P, T = 50, 16, 8, 4, 12          # словарь, ширина, батч, длина промпта, полная длина
policy = nn.Sequential(nn.Embedding(V, d), nn.Linear(d, V))   # «LLM»: логиты следующего токена
ref = copy.deepcopy(policy).requires_grad_(False)              # замороженная копия = π_ref


def seq_logp(model, ids, mask):
    """log π(y|x): сумма log-вероятностей токенов ОТВЕТА (сдвиг на 1, как в SFT)."""
    logits = model(ids[:, :-1])                                   # предсказания для позиций 1..T-1
    # для каждой позиции берём log-вероятность того токена, который там действительно стоит
    logp = torch.log_softmax(logits, -1).gather(-1, ids[:, 1:, None]).squeeze(-1)
    return (logp * mask[:, 1:]).sum(-1)


def dpo_loss(chosen, rejected, mask, beta=0.1):
    pi_c, pi_r = seq_logp(policy, chosen, mask), seq_logp(policy, rejected, mask)
    with torch.no_grad():                                         # референс не обучается
        ref_c, ref_r = seq_logp(ref, chosen, mask), seq_logp(ref, rejected, mask)
    r_c, r_r = beta * (pi_c - ref_c), beta * (pi_r - ref_r)       # неявные награды
    loss = -F.logsigmoid(r_c - r_r).mean()
    return loss, r_c.detach(), r_r.detach(), pi_c.detach(), pi_r.detach()


prompt = torch.randint(0, V, (B, P))
chosen = torch.cat([prompt, torch.randint(0, 10, (B, T - P))], 1)     # «хорошие» токены 0..9
rejected = torch.cat([prompt, torch.randint(40, 50, (B, T - P))], 1)  # «плохие» токены 40..49
mask = torch.cat([torch.zeros(B, P), torch.ones(B, T - P)], 1)        # loss только по ответу

opt = torch.optim.Adam(policy.parameters(), lr=1e-2)
for step in range(101):
    loss, r_c, r_r, pi_c, pi_r = dpo_loss(chosen, rejected, mask)
    if step % 50 == 0:
        acc = (r_c > r_r).float().mean()
        print(f"шаг {step:3d}: loss {loss.item():.3f} | награды chosen {r_c.mean():+.2f}, "
              f"rejected {r_r.mean():+.2f} | точность {acc:.2f} | log π: {pi_c.mean():.1f} / {pi_r.mean():.1f}")
    opt.zero_grad()
    loss.backward()
    opt.step()

шаг   0: loss 0.693 | награды chosen +0.00, rejected +0.00 | точность 0.00 | log π: -33.7 / -32.8
шаг  50: loss 0.005 | награды chosen +1.32, rejected -3.94 | точность 1.00 | log π: -20.5 / -72.3
шаг 100: loss 0.001 | награды chosen +1.37, rejected -5.15 | точность 1.00 | log π: -19.9 / -84.3

Старт — ровно $\ln 2$, точность 0, потому что награды равны (строгое «больше» не выполняется). Дальше заметна асимметрия: rejected «утопили» гораздо сильнее (награда $-5.15$), чем подняли chosen ($+1.37$). DPO охотнее выигрывает отрыв за счёт плохих ответов. На настоящих данных, где chosen и rejected похожи, это и превращается в слабость № 2.

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

Настоящий DPO проще всего запустить в LLaMA-Factory из урока 6.2.2. Возьмите свой tea_lora.yaml и поменяйте в нём четыре вещи: stage: dpo вместо stage: sft; добавьте pref_beta: 0.1 и pref_loss: sigmoid (это и есть DPO, там же можно выбрать orpo и simpo); датасет замените на dpo_mix_zh или dpo_mix_en — китайскую или английскую часть DPO-En-Zh-20k, из которого MiniMind берёт свою выборку; learning rate уменьшите до 5.0e-6, как в официальном образце examples/train_lora/qwen3_lora_dpo.yaml. Для пробного запуска добавьте max_samples: 2000.

llamafactory-cli train my_dpo.yaml                     # одна карта
FORCE_TORCHRUN=1 llamafactory-cli train my_dpo.yaml    # все 4 карты (data parallel)

Ориентиры — оценка по объёму вычислений, а не замер. Qwen2.5-0.5B-Instruct с LoRA на 2000 пар — минуты на одной карте, без ограничения max_samples — порядка часа. 7B с LoRA тоже поместится на карту (база — 14 ГБ в BF16), но будет примерно в 14 раз медленнее; тут и пригодятся все четыре карты.

Память. С LoRA вторая копия модели не нужна: референсом служит та же база с выключенным адаптером. Но на каждую пару считаются два ответа — chosen и rejected, — поэтому активаций вдвое больше, чем в SFT при том же батче. Если 7B упирается в 32 ГБ, уменьшите per_device_train_batch_size или cutoff_len.

Опыт на четырёх картах: длина поводка β. Сделайте четыре копии конфига с pref_beta 0.05, 0.1, 0.3 и 0.5 (и разными output_dir) и запустите их одновременно — каждую на своей карте:

i=0
for b in 0.05 0.1 0.3 0.5; do
  CUDA_VISIBLE_DEVICES=$i llamafactory-cli train my_dpo_beta$b.yaml > log-beta$b.txt 2>&1 &
  i=$((i + 1))
done; wait

• На что смотреть. rewards/accuracies и rewards/margins, как в игрушечном примере выше. «Награды» в логе умножены на β, поэтому между прогонами удобнее сравнивать logps/chosen и logps/rejected — лог-вероятности хороших и плохих ответов без множителя. Растёт ли вероятность хороших ответов или в основном падает вероятность плохих? Затем задайте всем четырём моделям одни и те же 10 вопросов: при малом β модель дальше уходит от исходной — сильнее меняется стиль и чаще появляются странности.
• Чем это лучше CPU. Игрушечная модель выше учится за секунды, но у неё нет «языка», который можно испортить. DPO на настоящей модели на CPU шёл бы часами даже для 0.5B, а на картах четыре значения β сравниваются за время одного прогона.

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

Китайский угол: DPO в Qwen, DeepSeek и MiniMind

DeepSeek LLM Chat (январь 2024, arXiv:2401.02954) выровнен связкой SFT + DPO на данных предпочтений о полезности и безвредности. Ещё до GRPO DeepSeek выбрали самый простой и стабильный путь.

Qwen2 (2407.10671) разделил выравнивание на две стадии. Офлайн — DPO на заранее собранном датасете. Онлайн — модель генерирует несколько ответов, reward model выбирает из них пары, и на них снова делается DPO. Это и есть итеративный DPO против сдвига распределения. Дополнительно Qwen применили Online Merging Optimizer, чтобы уменьшить налог на выравниваниеналог на выравниваниеEN alignment taxПадение качества на обычных задачах после выравнивания под предпочтения..

Qwen2.5 (2412.15115) оставил DPO офлайн-стадией — около 150 тыс. пар для рассуждений, фактов и следования инструкциям, которые трудно оценить reward model. Онлайн-стадию перевели на GRPO. Это хорошо показывает разделение ролей: DPO — для готовых пар, RL — для онлайн-обучения.

Tsinghua (Xu и др., 2404.10719) задала вопрос прямо: «DPO лучше PPO?» Теоретически DPO может найти смещённые решения, которые эксплуатируют ответы вне распределения данных. На практике хорошо настроенный PPO выигрывал во всех их экспериментах.

MiniMind (github, Apache-2.0) реализует DPO с нуля на PyTorch в train_dpo.py. Функция dpo_loss занимает десяток строк: chosen лежат в первой половине батча, rejected — во второй, дальше та же формула, что в этом уроке. Данные dpo.jsonl — выборка из китайско-английского набора DPO-En-Zh-20k от LLaMA-Factory. По умолчанию (проверено в октябре 2026) $\beta = 0.15$ и очень маленький learning rate — $4 \cdot 10^{-8}$: в подсказке к параметру авторы советуют не больше $5 \cdot 10^{-8}$, чтобы модель не забывала выученное на SFT. В README авторы честно пишут о границах метода. DPO нужны только две модели, actor и ref, он стабилен и прост. Но он не исследует новые ответы, поэтому хорошо выравнивает предпочтения и безопасность и мало помогает научиться «решать задачи». Для этого в MiniMind есть PPO и GRPO.

Термины. DPO («прямая оптимизация предпочтений»), данные предпочтений и неявная награда по-китайски называются дословно.

Проверь себя

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

1 Каким будет DPO loss на самом первом шаге, если политика инициализирована референсной моделью? Округлите до двух знаков.

2 $\log \pi_\theta(y_w) = -20$, $\log \pi_{\text{ref}}(y_w) = -21$, $\log \pi_\theta(y_l) = -30$, $\log \pi_{\text{ref}}(y_l) = -29$, $\beta = 0.5$. Чему равен DPO loss? Округлите до двух знаков.

3 Почему в DPO не нужно считать статсумму $Z(x)$?

$Z(x)$ всегда равна 1$\beta \log Z(x)$ зависит только от промпта и сокращается в разности наград двух ответов на этот промпт$Z(x)$ оценивают сэмплированием ответовDPO просто игнорирует её, и поэтому оценка смещена

4 Какие утверждения о DPO верны?Можно выбрать несколько ответов

Ему не нужна отдельная reward modelВо время обучения он генерирует новые ответы политикойЕму нужны лог-вероятности референсной модели — саму модель или заранее посчитанные числаВ базовом виде он обучается офлайн и не исследует новые ответыУ него больше гиперпараметров, чем у PPO

5 В логах DPO loss падает, rewards/margins растут, но и rewards/chosen, и rewards/rejected уходят в минус. Что это значит?

Это невозможно — в коде ошибкаТак бывает: loss зависит только от разности, и вероятность хорошего ответа тоже может падать — это стоит контролироватьЗначит, $\beta$ слишком большой, и обучение остановилось

6 Какой метод не требует референсной модели и использует среднюю лог-вероятность на токен с отступом $\gamma$? (одно слово)

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

Итоги

• Оптимальная политика RLHF $\pi^* \propto \pi_{\text{ref}} e^{r/\beta}$ позволяет выразить награду через политику: $\hat r = \beta \log(\pi_\theta / \pi_{\text{ref}})$. Статсумма $Z(x)$ сокращается в модели Брэдли–Терри.
• DPO — это loss reward model, где награда спрятана в самой политике. Две модели, нет генерации, обучение как SFT. Старт — $\ln 2$.
• $\beta$ — длина KL-поводка. Вес пары в градиенте $\sigma(\hat r_l - \hat r_w)$ фокусирует обучение на ошибках.
• Слабости DPO — офлайн-данные, падение вероятности chosen, переобучение, длина. Их лечат онлайн-DPO, IPO, KTO, SimPO. Для рассуждений индустрия перешла к онлайн-RL — GRPO.

Дальше: модуль 6.4 — GRPO из DeepSeekMath и путь DeepSeek-R1: RL без критика, с проверяемыми наградами и группой ответов вместо value-модели.