Модуль 8. RLHF и прямые методы оптимизации предпочтений

Политика генерирует ответы и обновляется. База задаёт KL-якорь и заморожена. Модель награды оценивает ответы и обычно заморожена на стадии оптимизации политики. Критик оценивает ожидаемую будущую награду и обучается вместе с RL-контуром.

Это четыре роли, а не четыре обязательные независимые копии. Память уменьшают общей основой политики и головы ценности, LoRA, квантованием замороженных компонентов, кэшированием логарифмов вероятностей базы, выгрузкой на CPU, разнесением ролей между процессами и меньшими моделью награды и критиком. Остаются генерация, прямые проходы базы и модели награды, оценивание ценности, хранение роллаутов и обратный проход политики.

Штрафованная задача является лагранжевой формой ограниченной. В идеальной выпуклой постановке активному ограничению соответствует множитель $\beta$. В нейросетевом обучении параметризация невыпукла, оценки стохастичны, а оптимизация конечна, поэтому выбранный $\beta$ не задаёт точный фактический KL.

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

Число $-0.7$ — одно значение

которое может быть отрицательным. Его ожидание по $a\sim\pi_\theta$ равно

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

Нужны пары к одному запросу, BT-правдоподобие, точный KL-регуляризованный оптимум, фиксированная база и общий носитель. Два ответа должны проходить одинаковую токенизацию, шаблон и обрезку; метки должны отражать нужную рубрику.

Если BT неточна, DPO остаётся определённой классификационной потерей, но интерпретация как точного восстановления неявной награды становится приближённой. Ошибочные пары не делают градиент неопределённым — они направляют его к ошибочной цели.

DPO получает запрос и пару полных ответов. Классический офлайн-RL обычно получает переходы или траектории с наградами. DPO не требует явной Q-функции, уравнений Беллмана и бутстрэппинга; база входит непосредственно в логарифмические отношения.

Общее — фиксированные данные и риск слабого покрытия. Но в офлайн-RL ошибка может усиливаться максимизацией и бутстрэппингом, а DPO эксплуатирует ограниченность пар, стиль, длину и неразмеченные альтернативы. Поэтому DPO — прямой метод оптимизации политики по фиксированным предпочтениям, родственный офлайн-обучению, но не тождественный классическому офлайн-RL.

Нет. Предпочтённый ответ должен улучшиться относительно отклонённого, но оба могут потерять вероятность, если третий ответ получает ещё больше массы. Нужны выбранный и отклонённый логарифмы вероятностей, их отношения к базе, маржа, KL, длина, градиентный вес и независимое качество свежих генераций.

Здесь есть корреляция длины с меткой, асимметричная обрезка и устаревший кэш базы. Нужно сохранять исходный текст, токены, маски, длины до/после обрезки, причину остановки, токенизатор, шаблон, версии политики и базы, параметры декодирования, происхождение пары и версию предобработки.

Деление на длину меняет целевую функцию. Оно может ослабить одно смещение, но создать предпочтение коротких ответов и не исправляет кэш, обрезку или плохую разметку.

1. DPO — качественные пары и доступная база; смотреть выбранные/отклонённые логарифмы отдельно.

2. KTO — отдельные желательные и нежелательные примеры; контролировать баланс и семантику меток.

3. ORPO — одноэтапная SFT+парная цель без отдельной базы; смотреть NLL и парную часть.

4. IPO, cDPO или ранняя остановка — конечная маржа/шум; нужна независимая метрика качества.

5. RLVR с PPO-, RLOO- или GRPO-подобным обновлением — проверяемая награда и свежие ответы; смотреть награду, KL и энтропию.

6. SimPO — явная нормировка по длине; проверять качество по длиновым срезам.

Фиксированная сумма $R-\alpha C$ заранее задаёт цену риска. Если масштаб $C$ изменился или фактическая частота нарушений оказалась выше ожидаемой, сама цель не требует вернуть стоимость к заданному бюджету. Ограниченная задача формулирует проверяемое условие $\mathbb E[C]\le d$, а двойственная переменная играет роль адаптивной цены нарушения:

При превышении бюджета $\lambda$ растёт и усиливает штраф; при запасе по ограничению он уменьшается, но остаётся неотрицательным. Это не делает метод безошибочным: качество зависит от измерения стоимости и от оптимизации политики.

Награда и стоимость отвечают на разные вопросы и могут иметь разные данные, ошибки и пороги. Сведение $C$ к $-R$ позволяет высокой полезности компенсировать критический риск. Отдельные модели и журналы позволяют увидеть такой обмен.

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

После нормировки

Далее

а регуляризованная цель равна примерно $0.362412$. Для базы цель равна $0.3-0.5\cdot0.2=0.2$, поскольку её KL к себе нулевой.

Для $r'(y)=r(y)+c$:

Общий множитель сокращается при нормировке. Если $\pi_{\mathrm{ref}}(y)=0$, ненормированный вес равен нулю при конечной награде. Первое свойство отражает неидентифицируемость абсолютного уровня награды, второе — ограничение носителя прямым KL.

В BT входит разность наград. Две добавки $\beta\log Z(x)$ сокращаются, поэтому

Отрицательный логарифм вероятности наблюдаемого выбора:

Выбранное отношение: $-2.0-(-2.2)=0.2$. Отклонённое: $-3.0-(-2.4)=-0.6$. Поэтому

При большом положительном зазоре вес стремится к нулю.

Следовательно,

Для $\tau=0.25$ цель $h^*=2$. Потери при $h=1,2,4$ равны $1,0,4$. IPO штрафует и недостаточный, и чрезмерный зазор, тогда как обычная DPO-потеря продолжает уменьшаться при его росте.

Нормировочная константа softmax сокращается:

Третий логит забирает массу, хотя первый падает медленнее второго. Сигнал — рост маржи при падении выбранного логарифма вероятности, дополненный независимой оценкой генераций.

Для смеси

Награда растёт по $q$, а ограничение даёт $q\le0.25$. Поэтому

Лагранжева функция линейна по $q$:

Следовательно, при $\lambda<0.4$ максимум достигается в $q=1$, при $\lambda>0.4$ — в $q=0$, а при $\lambda=0.4$ любое $q\in[0,1]$ даёт одинаковое значение. В седловой точке ограничение и двойственная цена совместно удерживают $q$ на границе допустимого множества.

Один двойственный шаг:

Средний бюджет допускает рискованное действие с ограниченной частотой. Жёсткий запрет задаёт $q=0$ для соответствующего класса состояний. Это разные требования и разные допустимые множества политик.

import numpy as np


def optimal_kl_policy(reference, rewards, beta):
    reference = np.asarray(reference, dtype=np.float64)
    rewards = np.asarray(rewards, dtype=np.float64)
    if reference.ndim != 1 or rewards.shape != reference.shape:
        raise ValueError("aligned vectors required")
    if beta <= 0 or not np.isfinite(beta):
        raise ValueError("beta must be finite and positive")
    if np.any(reference < 0) or not np.isclose(reference.sum(), 1.0):
        raise ValueError("reference must be a distribution")
    support = reference > 0
    logits = np.full_like(reference, -np.inf)
    logits[support] = np.log(reference[support]) + rewards[support] / beta
    maximum = np.max(logits[support])
    weights = np.zeros_like(reference)
    weights[support] = np.exp(logits[support] - maximum)
    return weights / weights.sum()

Для сетки $\beta$ вычисляются policy @ rewards и категориальный KL. В учебном примере при уменьшении $\beta$ обе величины растут.

import numpy as np


def shape_token_rewards(policy_logprobs, reference_logprobs, terminal_reward, beta, mask):
    p = np.asarray(policy_logprobs, dtype=np.float64)
    q = np.asarray(reference_logprobs, dtype=np.float64)
    mask = np.asarray(mask, dtype=np.float64)
    if p.ndim != 1 or q.shape != p.shape or mask.shape != p.shape:
        raise ValueError("aligned vectors required")
    if np.any((mask != 0) & (mask != 1)) or mask.sum() == 0:
        raise ValueError("mask must be non-empty and binary")
    rewards = -beta * (p - q) * mask
    rewards[np.flatnonzero(mask)[-1]] += terminal_reward
    return rewards

Проверка:

out = shape_token_rewards([-0.2, -1.0, -2.0], [-0.2, -1.3, -1.8], 1.5, 0.2, [0, 1, 1])
assert np.isclose(out.sum(), 1.5 - 0.2 * (0.3 - 0.2))

import numpy as np


def softplus(x):
    x = np.asarray(x, dtype=np.float64)
    return np.maximum(x, 0.0) + np.log1p(np.exp(-np.abs(x)))


def summarize_pairs(pc, pr, rc, rr, beta):
    pc, pr, rc, rr = [np.asarray(x, dtype=np.float64) for x in (pc, pr, rc, rr)]
    if not (pc.shape == pr.shape == rc.shape == rr.shape):
        raise ValueError("shared shape required")
    chosen_ratio = pc - rc
    rejected_ratio = pr - rr
    margin = chosen_ratio - rejected_ratio
    z = beta * margin
    return {
        "mean_loss": float(np.mean(softplus(-z))),
        "pair_accuracy": float(np.mean(margin > 0)),
        "mean_margin": float(np.mean(margin)),
        "mean_chosen_logp": float(np.mean(pc)),
        "mean_rejected_logp": float(np.mean(pr)),
        "mean_implicit_chosen_reward": float(np.mean(beta * chosen_ratio)),
        "mean_implicit_rejected_reward": float(np.mean(beta * rejected_ratio)),
        "mean_gradient_weight": float(np.mean(beta / (1.0 + np.exp(z)))),
    }

Логиты $(-t,-3t,4t)$ дают тест, где маржа растёт, а выбранный logp падает.

import math


def softplus(x):
    return max(x, 0.0) + math.log1p(math.exp(-abs(x)))


def simpo_reward(sequence_logp, length, beta):
    if length <= 0 or beta <= 0:
        raise ValueError("positive length and beta required")
    return beta * sequence_logp / length


def log_odds_from_logprob(logp):
    if not math.isfinite(logp) or logp >= 0:
        raise ValueError("logp must be finite and negative")
    p = math.exp(logp)
    return logp - math.log1p(-p)


def orpo_total_loss(chosen_mean_nll, chosen_logp, rejected_logp, lam):
    if chosen_mean_nll < 0 or lam < 0:
        raise ValueError("non-negative inputs required")
    ratio = log_odds_from_logprob(chosen_logp) - log_odds_from_logprob(rejected_logp)
    return chosen_mean_nll + lam * softplus(-ratio)

Параметры разных методов входят в разные формулы; одинаковое численное значение не означает одинакового градиента.

import numpy as np


def likelihood_displacement_curve(ts):
    ts = np.asarray(ts, dtype=np.float64)
    logits = np.stack([-ts, -3.0 * ts, 4.0 * ts], axis=1)
    logits -= logits.max(axis=1, keepdims=True)
    p = np.exp(logits)
    p /= p.sum(axis=1, keepdims=True)
    return {"t": ts, "chosen": p[:, 0], "rejected": p[:, 1], "other": p[:, 2], "log_margin": 2.0 * ts}


def displacement_alert(curve):
    return bool(
        np.all(np.diff(curve["log_margin"]) > 0)
        and np.mean(np.diff(np.log(curve["chosen"]))) < 0
    )

Сигнал видит геометрию вероятностей, но не содержание третьего ответа. Поэтому он является диагностикой, а не доказательством снижения качества.

import numpy as np


def dual_ascent_step(multipliers, expected_costs, limits, step_size):
    lam = np.asarray(multipliers, dtype=np.float64)
    costs = np.asarray(expected_costs, dtype=np.float64)
    bounds = np.asarray(limits, dtype=np.float64)
    if lam.shape != costs.shape or lam.shape != bounds.shape:
        raise ValueError("all arrays must have the same shape")
    if np.any(lam < 0) or not np.all(np.isfinite(lam)):
        raise ValueError("multipliers must be finite and non-negative")
    if step_size <= 0 or not np.isfinite(step_size):
        raise ValueError("step_size must be finite and positive")
    return np.maximum(0.0, lam + step_size * (costs - bounds))


def two_action_constrained_optimum(
    safe_reward,
    risky_reward,
    safe_cost,
    risky_cost,
    cost_limit,
):
    values = np.asarray(
        [safe_reward, risky_reward, safe_cost, risky_cost, cost_limit],
        dtype=np.float64,
    )
    if not np.all(np.isfinite(values)):
        raise ValueError("all inputs must be finite")
    if risky_cost <= safe_cost:
        raise ValueError("the teaching contract requires risky_cost > safe_cost")
    if cost_limit < safe_cost:
        raise ValueError("the cost budget is infeasible even for the safe action")
    q_max = np.clip(
        (cost_limit - safe_cost) / (risky_cost - safe_cost),
        0.0,
        1.0,
    )
    return float(q_max if risky_reward > safe_reward else 0.0)

Для учебных чисел функция возвращает $0.25$. При нарушении, например $C=0.6>d=0.25$, множитель увеличивается; при $C<d$ уменьшается до нуля с проекцией на неотрицательную полуось.

Проверка кода подтверждает только алгебру обновления. Она не проверяет, что $C$ измеряет нужный риск, что данные покрывают будущие запросы или что ограничение на среднее достаточно для критического сценария.