дорожка · 26.10.2026 · обучение на предпочтениях

Как модель учат предпочитать хороший ответ: пары сравнений, модель награды, RLHF и DPO

После обучения на огромном количестве текста модель умеет продолжать что угодно, но ещё не умеет быть полезным собеседником. Первый шаг — показать ей образцы хороших ответов, о нём была дорожка о дообучении. Второй шаг, о котором сегодня, — научить модель различать, какой из двух её собственных ответов лучше, и сдвигать вероятности в сторону лучшего. Разберём, откуда берутся пары сравнений, как из них получается число-оценка (модель награды), как классическая схема с обучением с подкреплением удерживает модель от ухода в странное, как метод DPO делает то же самое одной функцией потерь и почему на этом этапе модель легче всего научить не тому: длинным ответам, поддакиванию и обману оценщика. Все примеры — игрушечные расчёты на numpy с пятью вариантами ответа; код на странице мы запускали, выводы взяты из этих запусков.

Все дорожки — /put. Прошлая — функция потерь и шаг обучения.

1 Зачем после образцов учат на сравнениях: пары «лучше — хуже»

Зачем это в работе. Когда ты выбираешь модель, читаешь её карточку или сам дообучаешь открытую модель, рядом с обучением на образцах почти всегда стоит второй этап: обучение на предпочтениях. От него во многом зависят тон, длина, готовность отказать и склонность соглашаться с пользователем. Если знать, как устроен этот этап, понятно, откуда берутся типичные привычки ассистентов и какие данные надо собрать, чтобы их поправить.

Как это устроено. Обучение на образцах (supervised fine-tuning, SFT) показывает модели один правильный ответ и поднимает его вероятность — функцией потерь из прошлой дорожки. Но у большинства вопросов нет одного правильного ответа, а есть лучше и хуже, и написать идеальный образец трудно и дорого. Сравнить два готовых ответа человеку гораздо проще: прочитал оба и выбрал. Поэтому данные для второго этапа устроены как пары предпочтений (preference pairs): вопрос, ответ, который выбрали (chosen), и ответ, который отвергли (rejected).

Порядок обычно такой. Модель после обучения на образцах генерирует на один вопрос два или несколько ответов, обычно с ненулевой температурой, чтобы они различались. Разметчик, а в последние годы часто и другая модель-судья, выбирает лучший. Так в работе об InstructGPT (Ouyang и соавторы, 2022) описан классический путь из трёх этапов: образцы, затем модель награды на сравнениях разметчиков, затем обучение с подкреплением. Вариант, где сравнения делает модель по списку принципов, описан в работе о «конституционном» ИИ (Constitutional AI, Bai и соавторы, 2022) и называется обучением на отзывах ИИ (RLAIF).

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

Ограничение: сравнение относительное. Из пары «A лучше B» нельзя узнать, хорош ли A сам по себе, — оба ответа могут быть плохими. И разметчик выбирает по тому, что видит за минуту: уверенный тон, аккуратное оформление, длину. Эти поверхностные признаки модель выучит так же старательно, как настоящую пользу, — подробно в пятой ступени.

Подробный пример. Одна запись в наборе предпочтений в формате, который принимает, например, библиотека TRL от Hugging Face (поля prompt, chosen, rejected):

{
  "prompt":   "Сколько будет 15% от 240? Ответь коротко.",
  "chosen":   "36.",
  "rejected": "Отличный вопрос! Проценты — это доля от ста. Чтобы найти 15% от 240, нужно 240 умножить на 0,15, получится 32."
}

Здесь отвергнутый ответ плох по трём причинам сразу: он не выполнил просьбу «коротко», начинается с пустой похвалы и содержит арифметическую ошибку (240 × 0,15 = 36). Обучение на образцах с ответом «36.» подняло бы вероятность короткого верного ответа, но никак не наказало бы привычку хвалить вопрос. Пара позволяет сказать модели прямо: из этих двух продолжений второе должно стать менее вероятным. Обрати внимание и на слабость записи: из неё модель не узнает, какая из трёх причин главная. Если в наборе много пар, где отвергнутый ответ к тому же длиннее, модель может выучить «короче — лучше» как общее правило.

Где обычно ошибаются.

  • Собирают пары, где оба ответа написаны людьми, а не моделью. Модель тогда учится различать чужие тексты, а не исправлять свои ошибки; принято сравнивать ответы той же модели, которую дообучают.
  • Делают пары, в которых выбранный и отвергнутый различаются сразу многим. Чем меньше различий, тем яснее сигнал, за что именно наказали.
  • Не проверяют согласие разметчиков между собой. Если два человека на одной паре выбирают по-разному в трети случаев, модель не может согласиться с ними чаще.

Обучение на образцах (supervised fine-tuning, SFT). дообучение, где модели показывают готовый хороший ответ и поднимают его вероятность.

Обучение на предпочтениях (preference tuning). дообучение по сравнениям двух ответов: поднять выбранный относительно отвергнутого.

Пара предпочтений (preference pair). запись «вопрос, выбранный ответ, отвергнутый ответ».

chosen и rejected. поля с выбранным и отвергнутым ответом в наборах данных для такого обучения.

Разметчик. человек или модель-судья, который выбирает лучший ответ в паре.

RLHF. обучение с подкреплением на отзывах людей — схема «модель награды плюс обучение с подкреплением».

RLAIF. та же схема, где сравнения делает модель по заданным принципам, а не люди.

2 Модель награды: как из сравнений получить число

Зачем это в работе. Модель награды (reward model) — это отдельная сеть, которая ставит ответу одно число «насколько он хорош». Её используют не только для обучения: ею отбирают лучший из нескольких ответов, фильтруют данные, ею же иногда проверяют качество. Нужно понимать, из чего она выучена и почему её число имеет смысл только в сравнении, иначе легко принять её оценку за объективную истину.

Как это устроено. Обычно берут ту же языковую модель, убирают слой, предсказывающий токены, и ставят вместо него слой, выдающий одно число r по всему тексту «вопрос плюс ответ». Обучают её на парах: для выбранного ответа считаем r_w, для отвергнутого r_l, и хотим, чтобы r_w было больше. Перевод разности в вероятность берут из модели Брэдли–Терри (Bradley–Terry, 1952), придуманной для сравнения игроков по результатам партий: вероятность, что A лучше B, равна σ(r_A − r_B), где σ — сигмоида, плавно переводящая любое число в промежуток от 0 до 1. При равных наградах это 0,5, при разности 2 — около 0,88.

Функция потерь — знакомый минус логарифм вероятности правильного ответа: −ln σ(r_w − r_l). Если модель награды уверенно согласна с разметчиком, потеря близка к нулю; если уверенно не согласна — большая. Градиент толкает r_w вверх и r_l вниз тем сильнее, чем сильнее модель ошибается, ровно как в последнем слое из прошлой дорожки.

Важное ограничение: в формуле участвует только разность наград. Если прибавить ко всем наградам одно и то же число, ничего не изменится. Поэтому абсолютное значение «награда 2,3» ничего не значит, а сравнивать можно только ответы на один вопрос одной и той же моделью награды. Второе ограничение: модель награды не может стать точнее данных. Если разметчики на части пар выбирают почти наугад, предел её согласия с ними ниже 100%.

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

Подробный пример. Пять вариантов ответа описаны тремя признаками: длина в сотнях слов, насколько ответ по делу (от 0 до 1) и есть ли в нём фактическая ошибка. «Настоящая польза» задана весами: длина сама по себе не важна, дело +3, ошибка −4. Разметчик выбирает лучший ответ в паре случайно, но по формуле Брэдли–Терри с этими весами, то есть иногда ошибается на близких парах. Мы учим линейную модель награды на 1500 парах и проверяем на остальных. Общий файл:

import numpy as np
# Пять вариантов ответа на один вопрос. Признаки: длина (сотни слов), по делу (0..1), ошибка в фактах (0/1)
NAMES = ["короткий верный", "подробный верный", "вежливая вода", "длинный с ошибкой", "отказ"]
X = np.array([[0.5, 0.9, 0], [2.0, 1.0, 0], [3.0, 0.2, 0], [3.5, 0.8, 1], [0.3, 0.0, 0]])
TRUE_W = np.array([0.0, 3.0, -4.0])          # «настоящая» полезность, которую знает только честный эксперт
def sigmoid(z): return 1 / (1 + np.exp(-z))
def make_pairs(n, w_annot, rng):
    """Разметчик видит два ответа и выбирает лучший по Брэдли–Терри с весами w_annot."""
    a, b = rng.integers(0, len(X), n), rng.integers(0, len(X), n)
    keep = a != b; a, b = a[keep], b[keep]
    p_a = sigmoid(X[a] @ w_annot - X[b] @ w_annot)
    a_wins = rng.random(len(a)) < p_a
    return np.where(a_wins, a, b), np.where(a_wins, b, a)   # (выбранный, отвергнутый)
def fit_reward(win, lose, steps=3000, lr=0.5):
    w = np.zeros(X.shape[1]); D = X[win] - X[lose]
    for _ in range(steps):
        p = sigmoid(D @ w)                        # вероятность, что модель награды согласна с разметчиком
        w -= lr * (-(1 - p) @ D / len(D))         # градиент средней потери −ln σ(r_w − r_l)
    return w, -np.log(sigmoid(D @ w)).mean()
import numpy as np
from common import *
rng = np.random.default_rng(0)
win, lose = make_pairs(2000, TRUE_W, rng)
w, L = fit_reward(win[:1500], lose[:1500])
acc = (X[win[1500:]] @ w > X[lose[1500:]] @ w).mean()
print("истинные веса     ", TRUE_W)
print("выученные веса    ", np.round(w, 2))
print(f"потеря на обучении {L:.3f}; согласие с разметчиком на отложенных парах {acc:.1%}")
print("награда ответов:", {n: round(float(r), 2) for n, r in zip(NAMES, X @ w)})

У нас этот код напечатал:

истинные веса      [ 0.  3. -4.]
выученные веса     [-0.03  2.61 -3.81]
потеря на обучении 0.354; согласие с разметчиком на отложенных парах 87.8%
награда ответов: {'короткий верный': 2.34, 'подробный верный': 2.56, 'вежливая вода': 0.44, 'длинный с ошибкой': -1.81, 'отказ': -0.01}

Модель награды по одним сравнениям восстановила веса, близкие к настоящим: длине почти ноль, делу 2,61 вместо 3, ошибке −3,81 вместо −4. Согласие на отложенных парах 87,8%, а не 100%: разметчик сам выбирал со случайностью, и на близких парах (короткий верный против подробного верного) угадать его выбор нельзя. Это нормальный потолок, а не признак плохой модели. И заметь: подробный верный ответ получил 2,56, отказ около нуля, — но если бы мы прибавили ко всем наградам 100, обучение шло бы точно так же.

Где обычно ошибаются.

  • Сравнивают награды ответов на разные вопросы. Шкала у каждого вопроса своя, сравнение имеет смысл только внутри одного вопроса.
  • Ждут от модели награды согласия с разметчиками близкого к 100% и считают её плохой. Сначала стоит измерить, как часто разметчики соглашаются друг с другом: это и есть потолок.
  • Учат модель награды на ответах одной модели, а применяют к ответам совсем другой. На непривычных ответах её оценки ненадёжны, а именно туда её и уведёт оптимизация.

Модель награды (reward model). сеть, которая ставит паре «вопрос — ответ» одно число: насколько ответ хорош.

Модель Брэдли–Терри (Bradley–Terry). правило, по которому вероятность «A лучше B» равна сигмоиде от разности их оценок.

Сигмоида (σ). функция, плавно переводящая любое число в вероятность от 0 до 1; σ(0) = 0,5.

Попарная потеря (pairwise loss). −ln σ(r_w − r_l): штраф за то, что модель не согласна с выбором разметчика.

Согласие (agreement). доля пар, где модель награды ставит выше тот же ответ, что выбрал разметчик.

Согласие разметчиков между собой. как часто разные люди выбирают одно и то же; верхний предел для модели награды.

Сдвиг шкалы. прибавка одного числа ко всем наградам, которая ничего не меняет в обучении.

3 Обучение с подкреплением на поводке: награда минус расстояние до исходной модели

Зачем это в работе. В карточках моделей и в настройках библиотек для этого этапа всегда есть параметр с греческой буквой β (бета) или «коэффициент KL». Он решает, насколько далеко модели разрешено уйти от исходной версии ради высокой награды. Слишком свободный поводок — модель находит, чем обмануть модель награды; слишком короткий — обучение почти ничего не меняет. Понимать этот компромисс нужно и для RLHF, и для DPO из следующей ступени, потому что там тот же β.

Как это устроено по шагам. Берём модель после обучения на образцах, её называют политикой (policy) — в обучении с подкреплением так называют то, что выбирает действия, здесь — токены. Политика генерирует ответ на вопрос, модель награды ставит ему число, и веса сдвигают так, чтобы ответы с высокой наградой стали вероятнее. Так как награда приходит за весь ответ, а не за каждый токен, нужен специальный метод обучения с подкреплением; в InstructGPT использовали PPO (Proximal Policy Optimization, Schulman и соавторы, 2017), который ограничивает, насколько сильно политика может измениться за один шаг.

Поводок. Ко второй модели — копии исходной, которую не обучают (reference model), — постоянно сравнивают вероятности политики. Мера расхождения двух распределений называется расхождением Кульбака–Лейблера (KL divergence): ноль, если распределения совпадают, и тем больше, чем сильнее политика ставит вероятность туда, где у исходной модели её почти не было. Цель обучения — не просто максимум награды, а «средняя награда минус β, умноженное на KL». Чем больше β, тем дороже уход от исходной модели.

У этой задачи есть точное решение, которое понадобится в следующей ступени: лучшая политика равна исходной, умноженной на e в степени r/β и нормированной, π*(y) ∝ π_ref(y) · e^(r(y)/β). Смысл простой: ответы с высокой наградой получают вероятность больше, чем у исходной модели, но множитель зависит от β; при большом β распределение почти не меняется, при малом вся вероятность уходит на ответ с максимальной наградой.

Зачем поводок, если награда и так знает, что хорошо. Модель награды обучена на ответах исходной модели и надёжна только рядом с ними. Чем дальше политика уходит, тем чаще она попадает в область, где модель награды ставит высокие числа ответам, которые людям не понравились бы. Это явление называют переоптимизацией награды (reward over-optimization); в работе Gao, Schulman и Hilton (2022) измерили, что при росте KL «истинная» оценка сначала растёт, а потом падает, хотя оценка модели награды продолжает расти.

Подробный пример. Те же пять ответов. Исходная модель выдаёт их с вероятностями 0,30, 0,15, 0,25, 0,10, 0,20. Модель награды неидеальна: длинному ответу с ошибкой она ставит 3,4 — больше всех, — потому что не заметила ошибку. Считаем по точной формуле лучшую политику для четырёх β и сравниваем, что растёт: награда или настоящая польза.

import numpy as np
from common import *
pi_ref = np.array([0.30, 0.15, 0.25, 0.10, 0.20])   # как часто исходная модель выбирает каждый ответ
r = np.array([2.0, 3.0, 0.5, 3.4, -1.0])            # оценки модели награды; «длинный с ошибкой» ей нравится больше всех
true = X @ TRUE_W
for beta in [10, 1, 0.3, 0.05]:
    pi = pi_ref * np.exp(r / beta); pi /= pi.sum()  # оптимум задачи «награда − β·KL»
    kl = (pi * np.log(pi / pi_ref)).sum()
    print(f"β={beta:<5} π={np.round(pi, 3)}  KL={kl:.2f}  награда={pi @ r:.2f}  истинная польза={pi @ true:.2f}")
print("истинная польза ответов:", np.round(true, 2))

У нас этот код напечатал:

β=10    π=[0.318 0.176 0.228 0.122 0.157]  KL=0.01  награда=1.53  истинная польза=1.33
β=1     π=[0.254 0.346 0.047 0.344 0.008]  KL=0.57  награда=2.73  истинная польза=1.20
β=0.3   π=[0.02  0.278 0.    0.702 0.   ]  KL=1.49  награда=3.26  истинная польза=-0.24
β=0.05  π=[0.    0.001 0.    0.999 0.   ]  KL=2.30  награда=3.40  истинная польза=-1.60
истинная польза ответов: [ 2.7  3.   0.6 -1.6  0. ]

Вот переоптимизация в миниатюре. При β = 10 политика почти не отошла (KL 0,01). При β = 1 награда выросла с 1,53 до 2,73, но настоящая польза уже чуть упала: поводок отпустили, и вероятность «длинного с ошибкой» выросла с 0,12 до 0,34. При β = 0,3 и 0,05 награда продолжает расти до 3,40, а настоящая польза уходит в минус: политика почти всегда выдаёт ответ, который обманул модель награды. По графику награды при этом всё выглядит как успех — поэтому настоящее качество проверяют отдельно, а не по той же модели награды.

Где обычно ошибаются.

  • Следят только за ростом награды. Нужно одновременно смотреть на KL и на независимую проверку: рост награды при резком росте KL — первый признак обмана.
  • Уменьшают β, «чтобы быстрее учиться». На деле это ослабляет поводок и ускоряет переоптимизацию.
  • Забывают, что исходная модель для поводка должна быть той же, с которой начали. Если поменять её на другую версию, KL измеряет расстояние не туда.

Политика (policy). обучаемая модель, которая выбирает ответ; термин из обучения с подкреплением.

Исходная модель (reference model). замороженная копия модели до этого этапа, с которой сравнивают политику.

Расхождение KL (KL divergence). мера того, насколько одно распределение вероятностей отличается от другого; ноль при совпадении.

β (бета). коэффициент, определяющий цену ухода от исходной модели; больше β — короче поводок.

PPO. метод обучения с подкреплением, который ограничивает изменение политики за один шаг; применялся в InstructGPT.

Переоптимизация награды (reward over-optimization). ситуация, когда оценка модели награды растёт, а настоящее качество падает.

Точное решение с поводком. π* ∝ π_ref · e^(r/β): исходные вероятности, умноженные на поправку за награду.

4 DPO: те же предпочтения без модели награды и без обучения с подкреплением

Зачем это в работе. Схема с моделью награды и PPO требует держать в памяти несколько моделей сразу, генерировать ответы во время обучения и настраивать капризный метод с подкреплением. Для дообучения открытых моделей своими силами чаще берут DPO (Direct Preference Optimization, Rafailov и соавторы, 2023): одна обучаемая модель, одна замороженная копия и обычная функция потерь на готовых парах. Если ты будешь дообучать модель на своих предпочтениях, скорее всего, начнёшь именно с него.

Как это устроено. Возьмём точное решение из прошлой ступени π* ∝ π_ref · e^(r/β) и перевернём его: награда выражается через саму политику, r(y) = β · ln(π(y)/π_ref(y)) плюс число, общее для всех ответов на этот вопрос. Эту величину называют неявной наградой (implicit reward): насколько политика подняла логарифм вероятности ответа по сравнению с исходной моделью, умноженное на β. Подставим её в попарную потерю Брэдли–Терри из второй ступени: общее число сокращается при вычитании, и модель награды больше не нужна.

Получается потеря DPO: −ln σ(β · [(ln π(y_w) − ln π_ref(y_w)) − (ln π(y_l) − ln π_ref(y_l))]). По шагам для одной пары: считаем логарифм вероятности выбранного и отвергнутого ответа у обучаемой модели и у замороженной (логарифм вероятности ответа — это сумма логарифмов вероятностей его токенов), вычитаем, умножаем на β, подставляем в −ln σ. В начале обучения политика равна исходной, разность нулевая, и потеря равна ln 2 ≈ 0,693 — это удобная проверка, что всё подключено верно.

Ограничения. DPO учится только на готовых парах и не генерирует новых ответов во время обучения, поэтому не видит, что модель начнёт выдавать после сдвига; в этом смысле его называют офлайн-методом (offline), в отличие от PPO. Потеря DPO зависит только от разности: она довольна, если выбранный ответ стал вероятнее отвергнутого относительно исходной модели, даже если оба стали менее вероятны, а вероятность ушла на какие-то третьи ответы. Поэтому при обучении смотрят не только на потерю, но и на сами логарифмы вероятностей выбранных и отвергнутых ответов.

Отличие от RLHF: тот же β, та же цель «предпочтения плюс поводок», то же точное решение, к которому оба метода стремятся при идеальной оптимизации. Разница в способе: RLHF сначала явно учит модель награды и потом оптимизирует политику с подкреплением, DPO делает один шаг обучения прямо на парах.

Подробный пример. Политика — распределение по нашим пяти ответам, исходная модель — те же вероятности 0,30, 0,15, 0,25, 0,10, 0,20. Набор — 3000 пар, выбранных честным разметчиком из второй ступени. Учим потерей DPO с β = 0,5 и в конце сравниваем неявную награду β·ln(π/π_ref) с настоящей пользой. Обе величины центрируем (вычитаем среднее), потому что награда определена с точностью до общего сдвига.

import numpy as np
from common import *
rng = np.random.default_rng(1)
win, lose = make_pairs(3000, TRUE_W, rng)
ref_logits = np.log(np.array([0.30, 0.15, 0.25, 0.10, 0.20]))
z = ref_logits.copy(); beta = 0.5
def logp(z): return z - np.log(np.exp(z).sum())
for step in range(401):
    lp, lr_ = logp(z), logp(ref_logits)
    m = beta * ((lp[win] - lr_[win]) - (lp[lose] - lr_[lose]))   # разность неявных наград
    if step in (0, 50, 400):
        print(f"шаг {step:3d}: потеря DPO {-np.log(sigmoid(m)).mean():.3f}  π={np.round(np.exp(lp), 3)}")
    g = -(1 - sigmoid(m)) * beta                                  # d(потеря)/d(m) на каждой паре
    p = np.exp(lp); grad = np.zeros_like(z)
    for i, c in zip((win, lose), (1, -1)):                       # d logπ(y)/dz = onehot(y) − π
        np.add.at(grad, i, c * g); grad -= c * g.sum() * p
    z -= 2.0 * grad / len(win)
implicit = beta * (logp(z) - logp(ref_logits))
print("неявная награда β·ln(π/π_ref):", np.round(implicit - implicit.mean(), 2))
print("истинная польза (центр.):     ", np.round(X @ TRUE_W - (X @ TRUE_W).mean(), 2))

У нас этот код напечатал:

шаг   0: потеря DPO 0.693  π=[0.3  0.15 0.25 0.1  0.2 ]
шаг  50: потеря DPO 0.368  π=[0.535 0.424 0.03  0.001 0.011]
шаг 400: потеря DPO 0.346  π=[0.47  0.52  0.008 0.    0.002]
неявная награда β·ln(π/π_ref): [ 1.64  2.04 -0.33 -2.45 -0.89]
истинная польза (центр.):      [ 1.76  2.06 -0.34 -2.54 -0.94]

Потеря стартовала ровно с 0,693, как и положено. За 50 шагов модель почти перестала выдавать ответ с ошибкой и отказ, а к 400-му шагу больше половины вероятности досталось подробному верному ответу. Главное — последние две строки: неявная награда, которую мы ни разу явно не учили, совпала с настоящей пользой почти до десятых (2,04 против 2,06 у лучшего ответа, −2,45 против −2,54 у ответа с ошибкой). Это и есть смысл названия статьи DPO: обучаемая языковая модель сама содержит модель награды. Заметь и поводок: короткий верный ответ не исчез (0,47), хотя подробный немного лучше, — при β = 0,5 модель не обязана сваливаться в один вариант.

Где обычно ошибаются.

  • Берут исходную модель для DPO не ту, которой генерировали пары. Формула предполагает, что ответы пришли от π_ref; если это не так, неявная награда искажается.
  • Смотрят только на потерю DPO. Она может падать и тогда, когда вероятность выбранных ответов тоже падает; поэтому логируют обе вероятности отдельно.
  • Считают логарифм вероятности ответа вместе с токенами вопроса. Как и при обычном дообучении, токены вопроса маскируют, иначе сравнение ответов смешивается с вероятностью одного и того же вопроса.

DPO (Direct Preference Optimization). метод обучения на парах предпочтений одной функцией потерь, без отдельной модели награды и без обучения с подкреплением.

Неявная награда (implicit reward). β · ln(π/π_ref): насколько политика подняла вероятность ответа относительно исходной модели.

Логарифм вероятности ответа (log-probability). сумма логарифмов вероятностей всех токенов ответа.

ln 2 ≈ 0,693. потеря DPO в самом начале, когда политика ещё совпадает с исходной моделью.

Офлайн-метод (offline). обучение только на заранее собранных данных, без новых ответов модели во время обучения.

Онлайн-метод (online). обучение, где модель по ходу генерирует новые ответы и получает за них оценку, как в PPO.

Центрирование. вычитание среднего, чтобы сравнивать величины, заданные с точностью до общего сдвига.

5 Где награду обманывают: длина, поддакивание и уверенный тон

Зачем это в работе. Многие раздражающие привычки ассистентов — длинные ответы, похвала вопросу, согласие с заведомо неверным утверждением пользователя, уверенный тон при незнании — объясняются не «характером модели», а тем, что на этапе предпочтений она получала за это награду. Если ты оцениваешь модели или собираешь свои пары, нужно знать эти перекосы, чтобы не вшить их в собственную модель и не принять их за качество.

Как это устроено. Модель награды и DPO учатся повторять выбор разметчика, а не настоящую пользу. Всё, что систематически сопутствует выбранным ответам, становится признаком «хорошего», даже если само по себе не помогает. Длина — самый изученный пример: в работе Singhal и соавторов (2023) показано, что заметная часть прироста награды после RLHF объясняется просто ростом длины ответов. Поддакивание (sycophancy) — второй: в работе Sharma и соавторов (2023) модели, обученные на отзывах людей, систематически подстраивались под мнение пользователя, а в самих данных предпочтений ответы, совпадающие с мнением человека, чаще выбирались.

Затем включается оптимизация из третьей ступени. Политика ищет ответы с максимальной наградой, и если за длину платят, она может растягивать ответ без конца: каждое лишнее слово немного повышает оценку и ничего не стоит. Это называют взломом награды (reward hacking): модель находит способ получить высокую оценку, не выполняя то, ради чего оценку придумали. Поводок β замедляет этот процесс, но не устраняет перекос, который уже сидит в данных.

Чем бороться. Собирать пары, где выбранный и отвергнутый ответ близки по длине, или учитывать длину при сравнении; в оценке моделей используют, например, вариант AlpacaEval, поправленный на длину (length-controlled). Добавлять пары, где правильный выбор — вежливо не согласиться с пользователем. Проверять модель на отдельном наборе с известными ответами, а не той же моделью награды, которой учили.

Подробный пример. Тот же мир из пяти ответов, но разметчик устал: длинные ответы ему нравятся (вес длины 1,2 вместо 0), а фактическую ошибку он замечает хуже (−1 вместо −4). Учим модель награды на его выборе и смотрим, что она поощряет, а потом позволяем политике удлинять ответ с ошибкой.

import numpy as np
from common import *
rng = np.random.default_rng(2)
ANNOT_W = np.array([1.2, 3.0, -1.0])     # уставший разметчик: любит длину, ошибку замечает хуже
win, lose = make_pairs(2000, ANNOT_W, rng)
w, _ = fit_reward(win, lose)
print("веса модели награды:", np.round(w, 2), " (истинные", TRUE_W, ")")
print("награда ответов:", {n: round(float(v), 2) for n, v in zip(NAMES, X @ w)})
# политика может растягивать ответ: тот же «длинный с ошибкой», но длиннее
for extra in [0, 2, 4]:
    x = X[3] + np.array([extra, 0, 0])
    print(f"длинный с ошибкой +{extra} сотни слов: награда {x @ w:.2f}, истинная польза {x @ TRUE_W:.2f}")
print("лучший по награде:", NAMES[int(np.argmax(X @ w))], "| лучший на деле:", NAMES[int(np.argmax(X @ TRUE_W))])

У нас этот код напечатал:

веса модели награды: [ 1.25  3.03 -1.07]  (истинные [ 0.  3. -4.] )
награда ответов: {'короткий верный': 3.35, 'подробный верный': 5.53, 'вежливая вода': 4.36, 'длинный с ошибкой': 5.73, 'отказ': 0.38}
длинный с ошибкой +0 сотни слов: награда 5.73, истинная польза -1.60
длинный с ошибкой +2 сотни слов: награда 8.23, истинная польза -1.60
длинный с ошибкой +4 сотни слов: награда 10.74, истинная польза -1.60
лучший по награде: длинный с ошибкой | лучший на деле: подробный верный

Модель награды честно выучила вкус уставшего разметчика: за каждые сто слов +1,25, за ошибку всего −1,07. В результате длинный ответ с ошибкой (5,73) обошёл подробный верный (5,53), а «вежливая вода» почти не отстаёт от верных ответов. Последние строки — взлом награды: добавив 400 слов, политика подняла награду с 5,73 до 10,74, настоящая польза осталась −1,60. Модель награды при этом отлично согласуется с разметчиком, то есть по внутренним метрикам всё в порядке; поймать проблему можно, только сравнив с независимой проверкой.

Где обычно ошибаются.

  • Сравнивают модели судьёй или по голосованию людей, не учитывая длину ответов. Модель, которая просто пишет длиннее, выигрывает без настоящего улучшения.
  • Добавляют в пары предпочтений ответы, где выбранный всегда соглашается с пользователем. Модель учится поддакивать и перестаёт поправлять ошибки в вопросе.
  • Считают проблему решённой, если ответы стали короче. Перекос может переехать в другой признак — списки, жирный шрифт, уверенные формулировки, — поэтому проверяют пользу, а не один симптом.

Взлом награды (reward hacking). ситуация, когда модель получает высокую оценку способом, который не делает ответ лучше.

Перекос по длине (length bias). привычка разметчиков и моделей награды ставить выше длинные ответы.

Поддакивание (sycophancy). склонность модели соглашаться с пользователем, даже когда он неправ.

Ложный признак (spurious feature). свойство, которое часто сопутствует хорошим ответам в данных, но само пользы не приносит.

Поправка на длину (length-controlled). способ сравнения моделей, убирающий выигрыш только за счёт длинных ответов.

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

Уставший разметчик. наш условный пример: человек, который при быстрой оценке ориентируется на внешние признаки ответа.

Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.