После обучения на огромном количестве текста модель умеет продолжать что угодно, но ещё не умеет быть полезным собеседником. Первый шаг — показать ей образцы хороших ответов, о нём была дорожка о дообучении. Второй шаг, о котором сегодня, — научить модель различать, какой из двух её собственных ответов лучше, и сдвигать вероятности в сторону лучшего. Разберём, откуда берутся пары сравнений, как из них получается число-оценка (модель награды), как классическая схема с обучением с подкреплением удерживает модель от ухода в странное, как метод DPO делает то же самое одной функцией потерь и почему на этом этапе модель легче всего научить не тому: длинным ответам, поддакиванию и обману оценщика. Все примеры — игрушечные расчёты на numpy с пятью вариантами ответа; код на странице мы запускали, выводы взяты из этих запусков.
Все дорожки — /put. Прошлая — функция потерь и шаг обучения.
Зачем это в работе. Когда ты выбираешь модель, читаешь её карточку или сам дообучаешь открытую модель, рядом с обучением на образцах почти всегда стоит второй этап: обучение на предпочтениях. От него во многом зависят тон, длина, готовность отказать и склонность соглашаться с пользователем. Если знать, как устроен этот этап, понятно, откуда берутся типичные привычки ассистентов и какие данные надо собрать, чтобы их поправить.
Как это устроено. Обучение на образцах (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. та же схема, где сравнения делает модель по заданным принципам, а не люди.
Зачем это в работе. Модель награды (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, обучение шло бы точно так же.
Где обычно ошибаются.
Модель награды (reward model). сеть, которая ставит паре «вопрос — ответ» одно число: насколько ответ хорош.
Модель Брэдли–Терри (Bradley–Terry). правило, по которому вероятность «A лучше B» равна сигмоиде от разности их оценок.
Сигмоида (σ). функция, плавно переводящая любое число в вероятность от 0 до 1; σ(0) = 0,5.
Попарная потеря (pairwise loss). −ln σ(r_w − r_l): штраф за то, что модель не согласна с выбором разметчика.
Согласие (agreement). доля пар, где модель награды ставит выше тот же ответ, что выбрал разметчик.
Согласие разметчиков между собой. как часто разные люди выбирают одно и то же; верхний предел для модели награды.
Сдвиг шкалы. прибавка одного числа ко всем наградам, которая ничего не меняет в обучении.
Зачем это в работе. В карточках моделей и в настройках библиотек для этого этапа всегда есть параметр с греческой буквой β (бета) или «коэффициент 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, а настоящая польза уходит в минус: политика почти всегда выдаёт ответ, который обманул модель награды. По графику награды при этом всё выглядит как успех — поэтому настоящее качество проверяют отдельно, а не по той же модели награды.
Где обычно ошибаются.
Политика (policy). обучаемая модель, которая выбирает ответ; термин из обучения с подкреплением.
Исходная модель (reference model). замороженная копия модели до этого этапа, с которой сравнивают политику.
Расхождение KL (KL divergence). мера того, насколько одно распределение вероятностей отличается от другого; ноль при совпадении.
β (бета). коэффициент, определяющий цену ухода от исходной модели; больше β — короче поводок.
PPO. метод обучения с подкреплением, который ограничивает изменение политики за один шаг; применялся в InstructGPT.
Переоптимизация награды (reward over-optimization). ситуация, когда оценка модели награды растёт, а настоящее качество падает.
Точное решение с поводком. π* ∝ π_ref · e^(r/β): исходные вероятности, умноженные на поправку за награду.
Зачем это в работе. Схема с моделью награды и 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 (Direct Preference Optimization). метод обучения на парах предпочтений одной функцией потерь, без отдельной модели награды и без обучения с подкреплением.
Неявная награда (implicit reward). β · ln(π/π_ref): насколько политика подняла вероятность ответа относительно исходной модели.
Логарифм вероятности ответа (log-probability). сумма логарифмов вероятностей всех токенов ответа.
ln 2 ≈ 0,693. потеря DPO в самом начале, когда политика ещё совпадает с исходной моделью.
Офлайн-метод (offline). обучение только на заранее собранных данных, без новых ответов модели во время обучения.
Онлайн-метод (online). обучение, где модель по ходу генерирует новые ответы и получает за них оценку, как в PPO.
Центрирование. вычитание среднего, чтобы сравнивать величины, заданные с точностью до общего сдвига.
Зачем это в работе. Многие раздражающие привычки ассистентов — длинные ответы, похвала вопросу, согласие с заведомо неверным утверждением пользователя, уверенный тон при незнании — объясняются не «характером модели», а тем, что на этапе предпочтений она получала за это награду. Если ты оцениваешь модели или собираешь свои пары, нужно знать эти перекосы, чтобы не вшить их в собственную модель и не принять их за качество.
Как это устроено. Модель награды и 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.