Модуль 4. Градиенты политики: от REINFORCE к PPO

Верны пункты 2 и 4.

• 2. Тождество переносит производную на $\log p_\theta(X)$, поэтому $f(X)$ достаточно вычислить для выбранного исхода; её производная не нужна.
• 4. Награда может быть результатом программы или человеческой оценки. Требуется дифференцируемость логарифма вероятности выбранного исхода по параметрам политики.

Пункт 1 неверен: дискретный случайный выбор не становится дифференцируемым — строится другой оцениватель градиента. Пункт 3 неверен: Монте-Карло остаётся стохастическим и часто высокодисперсионным. Пункт 5 неверен: перенос производной под сумму или интеграл требует условий регулярности.

При прямой зависимости $f_\theta$ правило произведения даёт

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

1. Да. Фиксированный симулятор входит в $p_\theta(\tau)$, но его логарифм не зависит от $\theta$, поэтому производная равна нулю.

2. Нет. Если переходы параметризованы тем же $\theta$, появляется дополнительный член $\nabla_\theta\log P_\theta(s'\mid s,a)$.

3. Да, из явной производной. Замороженная модель награды не требует дифференцирования, но её выход умножает градиент логарифма вероятности и определяет направление обучения.

4. Нет в выбранном оценивателе. Если мы сознательно проводим градиент через дифференцируемую модель мира, используются производные переходов. Это уже не чистый оцениватель с логарифмической производной по действиям.

Среда остаётся в распределении траекторий. Она определяет, какие состояния и награды увидит политика. Поэтому «производная перехода равна нулю» не означает «переход не влияет на градиентную оценку через данные».

Условно на истории до $a_t$ прошлые награды уже фиксированы. Их вклад имеет вид

Поэтому остаются только награды, на которые действие могло повлиять, — накопленная награда от текущего шага.

Если цель буквально равна

то после перегруппировки наград множитель при градиенте логарифма вероятности равен $\gamma^tG_t$. Запись только с $G_t$ часто использует дисконтированное распределение посещений состояний или иную нормировку цели. Она не является алгебраически той же строкой без изменения договорённости. При конечном горизонте удаление внешнего множителя меняет относительный вес ранних и поздних решений и потому может изменить направление градиента, а не только его длину.

Точно допустимы: 1, 2, 3.

• Константа и функция состояния не зависят от текущего действия.
• Среднее независимых других ответов условно не зависит от текущего ответа.

Не допустимо без поправки: 4. $Q_\psi(s,a)$ зависит от действия, поэтому доказательство через нулевое ожидание градиента логарифма вероятности не работает.

Известный масштаб при конечном размере группы: 5. Общее среднее включает текущую награду. При условно независимой группе оно масштабирует ожидаемый градиент на $(G-1)/G$, а не сохраняет его буквально.

1. $\bar R$ содержит $R_i/G$, а $R_i$ зависит от текущего ответа $Y_i$.

2. Ожидаемый масштаб равен $(G-1)/G$ от исходного градиента.

3. Среднее остальных ответов условно независимо от $Y_i$, поэтому его произведение с градиентом логарифма вероятности имеет нулевое ожидание.

4. Алгебраически

5. Оба типа преимуществ равны нулю. Внутригруппового сигнала для ранжирования ответов нет.

Случай I — техническое усечение с последующим reset().

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

2. Нет. Следующий элемент после reset() принадлежит другому эпизоду.

3. terminated=False, trace_cut=True.

Случай II — граница локального буфера.

1. Да. Среда продолжает тот же эпизод, поэтому следующий прогноз нужен для бутстрэппинга.

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

3. terminated=False, trace_cut=True для последней записи локального массива.

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

При $\varepsilon=0.2$ интервал равен $[0.8,1.2]$.

Все четыре отношения находятся вне интервала, поэтому ratio_outside_fraction=1. Клиппирование создаёт пессимистический минимум только в первой и четвёртой строках, поэтому active_clip_fraction=2/4=0.5.

1. Общая идея — несколько ответов на один запрос и относительная оценка внутри группы без обязательного отдельного критика.

2. Базовый RLOO использует среднее с исключением текущего ответа и цель REINFORCE; канонический GRPO использует PPO-подобные отношения и клиппирование, обычно нормирует групповой сигнал и добавляет регуляризацию относительно базовой политики.

3. Логарифм вероятности ответа равен сумме логарифмов вероятностей токенов. Поэтому один коэффициент ответа, умноженный на эту сумму, задаёт градиент логарифма вероятности полной последовательности.

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

Сначала

Для действия 2:

Сумма компонент с учётом округления равна нулю.

Обратная рекурсия:

Итак,

Внешний дисконт:

Второй вектор соответствует прямому градиенту буквальной цели с весами $\gamma^t$ для наград от начала эпизода.

Вероятности:

Ценность:

Градиенты логарифмических вероятностей:

Их квадраты норм:

После подстановки:

Различие возникает потому, что $b^*$ взвешивает значения действий квадратом нормы градиента логарифма вероятности. Редкое действие 1 имеет значительно больший градиентный вектор и поэтому получает больший вес, чем в обычном $V^\pi$.

Общее среднее:

Центрированные преимущества:

Опорные уровни с исключением текущего элемента:

RLOO-преимущества:

Они равны $4/3$ от центрированных преимуществ. Ожидаемый масштаб оценки с общим средним равен

Первый переход усечён, но не терминален:

Второй переход терминален:

Поскольку episode_end[0]=1, рекурсия не переносит $\delta_1$ назад:

Награда 100 относится к другому эпизоду после reset(). Она соседняя только в массиве, но не в траектории.

Неклиппированные члены:

Клиппированные отношения равны $(1.2,0.8,1.2,0.8)$, поэтому соответствующие члены:

Покомпонентный минимум:

Средняя цель:

Все отношения вне интервала, поэтому ratio_outside_fraction=1. Клиппирование меняет минимум в двух из четырёх случаев, поэтому active_clip_fraction=0.5.

Для двух значений $r=1.5$ вклад равен $0.5-\log 1.5\approx0.094535$, а для двух значений $r=0.5$ — $-0.5-\log0.5\approx0.193147$. Поэтому

Это неотрицательная выборочная диагностика. Она совпадает с обратной KL в математическом ожидании по старой политике при требуемом совпадении носителей, но один конечный пакет не превращает её в точное KL-ограничение.

import numpy as np

def stable_softmax(logits: np.ndarray) -> np.ndarray:
    z = np.asarray(logits, dtype=float)
    if z.ndim != 1:
        raise ValueError("logits must be one-dimensional")
    shifted = z - np.max(z)
    exp_z = np.exp(shifted)
    return exp_z / np.sum(exp_z)

def grad_log_softmax(logits: np.ndarray, action: int) -> np.ndarray:
    p = stable_softmax(logits)
    if not 0 <= action < len(p):
        raise ValueError("action is out of range")
    result = -p
    result[action] += 1.0
    return result

Вычитание максимума не меняет softmax, но предотвращает переполнение экспоненты.

import numpy as np

def reward_to_go(rewards: np.ndarray, gamma: float) -> np.ndarray:
    r = np.asarray(rewards, dtype=float)
    if r.ndim != 1:
        raise ValueError("rewards must be one-dimensional")
    if not 0.0 <= gamma <= 1.0:
        raise ValueError("gamma must lie in [0, 1]")
    result = np.empty_like(r)
    running = 0.0
    for t in range(len(r) - 1, -1, -1):
        running = r[t] + gamma * running
        result[t] = running
    return result

def discounted_score_weights(rewards: np.ndarray, gamma: float) -> np.ndarray:
    g = reward_to_go(rewards, gamma)
    return (gamma ** np.arange(len(g), dtype=float)) * g

Один обратный проход даёт сложность $O(T)$ и постоянную дополнительную память помимо результата.

import numpy as np

def leave_one_out_baselines(rewards: np.ndarray) -> np.ndarray:
    r = np.asarray(rewards, dtype=float)
    if r.ndim != 1 or len(r) < 2:
        raise ValueError("at least two rewards are required")
    return (np.sum(r) - r) / (len(r) - 1)

def group_mean_advantages(rewards: np.ndarray) -> np.ndarray:
    r = np.asarray(rewards, dtype=float)
    if r.ndim != 1 or len(r) == 0:
        raise ValueError("rewards must be a non-empty vector")
    return r - np.mean(r)

def group_zscore_advantages(rewards: np.ndarray, eps: float = 1e-8) -> np.ndarray:
    centered = group_mean_advantages(rewards)
    scale = float(np.sqrt(np.mean(centered ** 2)))
    if scale < eps:
        return np.zeros_like(centered)
    return centered / scale

Использована «популяционная» внутригрупповая дисперсия с делением на $G$, что соответствует распространённой нормировке преимуществ.

import numpy as np

def gae_advantages(
    rewards: np.ndarray,
    values: np.ndarray,
    next_values: np.ndarray,
    terminated: np.ndarray,
    trace_cuts: np.ndarray,
    gamma: float,
    gae_lambda: float,
) -> np.ndarray:
    r = np.asarray(rewards, dtype=float)
    v = np.asarray(values, dtype=float)
    nv = np.asarray(next_values, dtype=float)
    term = np.asarray(terminated, dtype=bool)
    cuts = np.asarray(trace_cuts, dtype=bool)
    if not (r.shape == v.shape == nv.shape == term.shape == cuts.shape) or r.ndim != 1:
        raise ValueError("all inputs must be aligned one-dimensional arrays")
    if not (0.0 <= gamma <= 1.0 and 0.0 <= gae_lambda <= 1.0):
        raise ValueError("gamma and gae_lambda must lie in [0, 1]")

    deltas = r + gamma * (~term).astype(float) * nv - v
    result = np.empty_like(deltas)
    running = 0.0
    for t in range(len(r) - 1, -1, -1):
        running = deltas[t] + gamma * gae_lambda * (not cuts[t]) * running
        result[t] = running
    return result

Ключевой момент — две маски отвечают на разные вопросы. При усечении или локальной границе буфера terminated=False, поэтому следующий прогноз используется; trace_cuts=True, поэтому текущая пакетная рекурсия останавливается.

from dataclasses import dataclass
import numpy as np

@dataclass(frozen=True)
class PPODiagnostics:
    ratio_outside_fraction: float
    active_clip_fraction: float
    approx_kl_nonnegative: float
    mean_log_ratio: float

def ppo_clipped_terms(ratio, advantage, clip_epsilon=0.2):
    r = np.asarray(ratio, dtype=float)
    a = np.asarray(advantage, dtype=float)
    if r.shape != a.shape or np.any(r <= 0):
        raise ValueError("positive aligned ratios are required")
    unclipped = r * a
    clipped = np.clip(r, 1 - clip_epsilon, 1 + clip_epsilon) * a
    pessimistic = np.minimum(unclipped, clipped)
    return unclipped, clipped, pessimistic

def ppo_diagnostics(new_log_prob, old_log_prob, advantage, clip_epsilon=0.2):
    log_ratio = np.asarray(new_log_prob, dtype=float) - np.asarray(old_log_prob, dtype=float)
    ratio = np.exp(log_ratio)
    a = np.asarray(advantage, dtype=float)
    unclipped, _, pessimistic = ppo_clipped_terms(ratio, a, clip_epsilon)
    outside = np.mean((ratio < 1 - clip_epsilon) | (ratio > 1 + clip_epsilon))
    active = np.mean(pessimistic < unclipped - 1e-15)
    approx_kl = np.mean((ratio - 1) - log_ratio)
    return PPODiagnostics(float(outside), float(active), float(approx_kl), float(np.mean(log_ratio)))

active_clip_fraction проверяет не положение отношения само по себе, а изменение пессимистического минимума.

import numpy as np

def response_token_mask(input_ids, prompt_lengths, pad_token_id, eos_token_id):
    ids = np.asarray(input_ids)
    lengths = np.asarray(prompt_lengths, dtype=int)
    if ids.ndim != 2 or lengths.shape != (ids.shape[0],):
        raise ValueError("input_ids must be [B, T] and prompt_lengths [B]")
    mask = np.zeros((ids.shape[0], ids.shape[1] - 1), dtype=float)
    for b in range(ids.shape[0]):
        active = True
        for pos in range(1, ids.shape[1]):
            token = int(ids[b, pos])
            if pos < lengths[b] or token == pad_token_id or not active:
                continue
            mask[b, pos - 1] = 1.0
            if token == eos_token_id:
                active = False
    return mask

def sequence_log_probability(token_log_probs, mask=None):
    lp = np.asarray(token_log_probs, dtype=float)
    if mask is None:
        return np.sum(lp, axis=-1)
    m = np.asarray(mask, dtype=float)
    if m.shape != lp.shape:
        raise ValueError("mask must match token_log_probs")
    return np.sum(lp * m, axis=-1)

def broadcast_sequence_advantages(sequence_advantages, token_mask):
    a = np.asarray(sequence_advantages, dtype=float)
    m = np.asarray(token_mask, dtype=float)
    if a.ndim != 1 or m.ndim != 2 or m.shape[0] != a.shape[0]:
        raise ValueError("advantages must be [B] and token_mask [B, T]")
    return a[:, None] * m

Возвращаемая маска сдвинута относительно исходных токенов, потому что логиты позиции $k$ оценивают метку позиции $k+1$. Сгенерированный EOS является действием политики и включается; запрос, PAD и хвост после EOS не входят в функцию потерь. Одинаковое преимущество на ненулевых позициях реализует градиент полного ответа, но не превращается в локальное объяснение вклада токенов.