Основы RL для языковых моделей

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

После SFTобучение с учителем на инструкциях (SFT)EN supervised fine-tuning (SFT) модель умеет подражать образцовым ответам. Но для многих задач написать идеальный ответ трудно, а оценить готовый — легко. Решила ли модель уравнение? Проходят ли тесты? Какой из двух ответов вежливее? Человеку проще сказать «этот лучше», чем написать лучший вариант самому.

Обучение с подкреплениемобучение с подкреплениемEN reinforcement learning (RL) (reinforcement learning, RL) — способ учиться именно так: модель сама генерирует ответ, получает за него число-оценку и подстраивается, чтобы оценки росли. На этом стоят RLHF в ChatGPT (следующий урок), GRPO в DeepSeek-R1 (модуль 6.4) и почти весь современный пост-трейнингпост-трейнинг, дообучение после претрейнаEN post-training.

Классическую теорию вы прошли в модуле 6.0: MDP и функции ценности (6.0.1), TD и Q-learning (6.0.2), градиент политики, actor-critic, GAE и PPO (6.0.3). Теперь применим её к языковой модели. Хорошая новость: для LLM из всей теории чаще всего нужна одна формула — градиент политики — и два приёма к ней: baseline и KL-штраф. Посмотрим, как они выглядят, когда политика — это LLM.

Словарь RL на примере LLM

АгентагентEN agentВ китайском встречается и «дайли» («посредник»), но в AI-контексте стандарт — «чжинэнти» (буквально «интеллектуальное тело»)., средасреда (в RL и для агентов)EN environmentТо, с чем взаимодействует агент — инструменты, песочница, симулятор пользователя — вместе с правилами выдачи награды., состояние $s_t$, действие $a_t$, награданаграда, вознаграждениеEN rewardЧисло, которым среда оценивает действие или весь ответ. У LLM обычно одна награда в конце ответа. $r_t$, политикаполитика (стратегия агента)EN policy $\pi_\theta(a \mid s)$ и эпизод (траекториятраекторияEN trajectoryПолная запись эпизода агента — все мысли, вызовы инструментов и наблюдения. Единица данных для оценки и agentic RL.) — из урока 6.0.1. Сопоставим их для игры и для LLM:

Понятие	Классический RL (игра Atari)	Языковая модель
Агент	игрок-нейросеть	LLM
Состояние $s_t$	кадр экрана	промпт + уже сгенерированные токены
Действие $a_t$	кнопка джойстика (18 вариантов)	следующий токен (у Qwen ~152 тыс. вариантов)
Политика $\pi_\theta(a \mid s)$	вероятности кнопок	softmax над словарём — это и есть LLM
Переход	физика игры	детерминированный: дописать токен в контекст
Награда	очки в игре	оценка ответа: reward model, проверка ответа, тесты
Эпизод	одна партия	один ответ до токена <eos>

Главное наблюдение: LLM уже является политикой. Вероятность всего ответа $y = (y_1, \dots, y_T)$ на промпт $x$ — произведение вероятностей токенов, а её логарифм — сумма:

$$\log \pi_\theta(y \mid x) = \sum_{t=1}^{T} \log \pi_\theta(y_t \mid x, y_{<t})$$

Это та же сумма лог-вероятностей, что и в loss SFT. Разница только в том, чей ответ мы подставляем: в SFT — образцовый от человека, в RL — сгенерированный самой моделью.

Особенность LLM — разреженная награда (sparse reward). Ответ из 500 токенов — это 500 действий, а оценка одна, в самом конце. Поэтому ответ часто рассматривают как одно большое действие: промпт → ответ целиком → награда. Это контекстный бандитконтекстный бандитEN contextual banditЗадача RL из одного шага, но в разных ситуациях (контекстах). Ответ LLM целиком на промпт — пример такой задачи. из урока 6.0.1: один шаг, но в разных ситуациях (промптах).

flowchart LR
P["Промпт x"] --> L["LLM = политика π_θ"]
L -->|"сэмплируем ответ y"| E["Среда: reward model, тесты, проверка ответа"]
E -->|"награда r(x, y)"| U["Обновление θ: чаще генерировать то, что дало высокую r"]
U --> L

Цикл RL для языковой модели

Цель — максимизировать среднюю награду:

$$J(\theta) = \mathbb{E}_{x \sim \mathcal{D},\; y \sim \pi_\theta(\cdot \mid x)}\big[\, r(x, y) \,\big]$$

Здесь $\mathcal{D}$ — набор промптов: берём промпт, модель отвечает, усредняем награду по промптам и ответам.

Как и в уроке 6.0.3, обычный backprop здесь бессилен: ответ получен сэмплированием, а награда — чёрный ящик («тесты прошли — 1, нет — 0»).

Градиент политики для LLM

Градиент политики вы вывели в уроке 6.0.3 для целых траекторий. В варианте «ответ — одно действие» вывод занимает три строки: матожидание — сумма по ответам, награда $r(y)$ от $\theta$ не зависит, а $\nabla \pi = \pi\, \nabla \log \pi$:

$$\begin{aligned} \nabla_\theta J &= \sum_y \nabla_\theta \pi_\theta(y)\, r(y) \\ &= \sum_y \pi_\theta(y)\, \nabla_\theta \log \pi_\theta(y)\, r(y) \\ &= \mathbb{E}_{y \sim \pi_\theta}\big[\, r(y)\, \nabla_\theta \log \pi_\theta(y) \,\big] \end{aligned}$$

Результат — снова матожидание, его оценивают сэмплами ответов. Это градиент политикиградиент политикиEN policy gradient∇J = E[r · ∇ log π(y|x)] — основа REINFORCE, PPO и GRPO. для LLM.

Как это читать. $\nabla_\theta \log \pi_\theta(y)$ — направление, в котором растёт вероятность ответа $y$. Ровно этот градиент считает SFT. Значит, policy gradient — это SFT на собственных ответах модели, взвешенный наградой:

• $r > 0$ — делаем «шаг SFT» к этому ответу, его вероятность растёт;
• $r < 0$ — шаг в обратную сторону, вероятность падает;
• $r = 0$ — ничего не происходит.

В коде это одна строка: вместо loss = -logp.sum() в SFT пишем loss = -(reward * logp.sum()).

Пример с числами

Промпт «Сколько будет 7·8?», три возможных ответа: «56», «54», «не знаю». Политика — softmax от логитов $z = [0, 0, 0]$, все вероятности по $1/3$. Градиент логарифма вероятности по логитам вы уже встречали в уроке 2.2.2: там градиент cross-entropy по логитам равнялся $p - \text{onehot}$, а $\log \mathrm{softmax}(z)_a$ — это cross-entropy с правильным ответом $a$, взятая со знаком минус:

$$\frac{\partial \log \mathrm{softmax}(z)_a}{\partial z_i} = \mathbb{1}[i = a] - p_i$$

Здесь $\mathbb{1}[i = a]$ — индикатор: 1, если $i = a$, и 0 иначе. То есть производная по «своему» логиту равна $1 - p_a$, а по каждому чужому — $-p_i$.

Сэмплировали «56», награда $r = 1$. Градиент: $[1, 0, 0] - [\tfrac13, \tfrac13, \tfrac13] = [0.67, -0.33, -0.33]$. Шаг градиентного подъёма с $\alpha = 0.5$: $z = [0.33, -0.17, -0.17]$, новые вероятности $[0.45, 0.27, 0.27]$. Модель стала чаще отвечать «56», хотя ни разу не видела образцовый ответ — только оценку своего.

REINFORCE

Алгоритм REINFORCEREINFORCEEN REINFORCEАлгоритм Уильямса (1992) — оценка градиента политики по сэмплам эпизодов (метод Монте-Карло). (Уильямс, 1992) — прямое применение формулы:

1. Сгенерировать текущей политикой $N$ ответов $y_1, \dots, y_N$.
2. Посчитать награды $r_i$.
3. Оценить градиент: $\hat g = \frac{1}{N}\sum_i r_i\, \nabla_\theta \log \pi_\theta(y_i \mid x)$.
4. Шаг: $\theta \leftarrow \theta + \alpha \hat g$. Вернуться к пункту 1.

Алгоритм on-policyon-policy (обучение на данных текущей политики)EN on-policyПротивоположность — off-policy, обучение на данных другой политики.: формула верна, только если ответы получены текущей политикой (урок 6.0.3). После шага старые ответы «протухают», и для следующего шага нужно генерировать заново. У LLM генерация — самая медленная часть, поэтому RL намного дороже SFT. PPO умеет делать несколько шагов на одном наборе ответов — как это выглядит в RLHF, разберём в следующем уроке.

Проблема дисперсии и baseline

Допустим, reward model ставит всем ответам оценки от 5 до 7: у «56» — 7, у «54» — 5, у «не знаю» — 6. Все награды положительны, и любой сэмплированный ответ, даже ошибочный, «подталкивается вверх». Лучший ответ побеждает только в среднем, по многим сэмплам. Оценка градиента прыгает от шага к шагу — у неё огромная дисперсия.

Лекарство — вычесть из награды базовую линию (baselineбазовая линия (baseline)EN baselineЧисло, которое вычитают из награды; не смещает градиент политики, но снижает его дисперсию.) $b$, которая не зависит от ответа:

$$\nabla_\theta J = \mathbb{E}\big[\, (r(y) - b)\, \nabla_\theta \log \pi_\theta(y) \,\big]$$

Матожидание градиента от этого не меняется ($\mathbb{E}[b\, \nabla \log \pi] = b\, \nabla 1 = 0$, вывод — в уроке 6.0.3), а шум падает — посмотрим, насколько, на нашем примере.

Посчитаем точно для нашего примера ($p = [\tfrac13, \tfrac13, \tfrac13]$, награды $[7, 5, 6]$):

Baseline $b$	Матожидание градиента	Дисперсия оценки (сумма по компонентам)
0	$[0.33, -0.33, 0]$	24.2
6 (средняя награда)	$[0.33, -0.33, 0]$	0.22

Направление то же, а дисперсия упала в 109 раз (точные значения — $218/9$ и $2/9$). Это как разница между «все ответы хорошие, но некоторые чуть лучше» и «этот лучше среднего, а этот хуже».

Разность $A = r - b$ называют преимуществом (advantageпреимущество (advantage)EN advantageA = r − b или A(s, a) = Q(s, a) − V(s): насколько действие лучше среднего в этой ситуации.): насколько ответ лучше, чем «обычно» в этой ситуации. Строго $A(s, a) = Q(s, a) - V(s)$ — функции ценности из урока 6.0.1. В нашем примере с одним шагом $Q$ — это просто награда ответа, а $V$ — средняя награда по политике. Знак $A$ решает, поднимать вероятность ответа или опускать.

Чем брать baseline — главное, чем отличаются RL-алгоритмы для LLM:

Алгоритм	Baseline $b$	Где встретится
REINFORCE (наш вариант)	среднее всех прошлых наград	задание этого урока
PPO	обученная value-модель (критик) $V_\psi(s)$	уроки 6.0.3 и 6.3.2
RLOO	среднее наград других ответов на тот же промпт	статья Cohere «Back to Basics» (2024)
GRPO	среднее по группе ответов на промпт, ещё и делённое на std	DeepSeekMath, R1 (модуль 6.4)

Кому отдать награду

В easy-rl этот вопрос назван «распределить подходящие баллы». Награда пришла за весь ответ, но какой токен «виноват»? REINFORCE и GRPO дают одно и то же преимущество всем токенам ответа. PPO пытается оценить вклад каждого токена с помощью критика и GAE (урок 6.0.3). Для коротких ответов разница мала, для длинных рассуждений — заметна.

KL-штраф к референсной модели

RL максимизирует награду — и ничего больше. Если не ограничить модель, она уйдёт далеко от исходной:

1. Взлом награды. Reward model — тоже нейросеть с «дырами». Политика найдёт ответы, которые RM оценивает высоко, хотя они плохие: длинная вода, лесть, повторы. Подробно — в следующем уроке.
2. Потеря разнообразия. Политика схлопывается в один «самый выгодный» ответ на всё.
3. Порча языка и забывание того, что модель умела после претрейна и SFT.

Решение — держать модель рядом с замороженной копией себя до RL. Эту копию называют референсной модельюреференсная модельEN reference modelЗамороженная копия модели до RL (обычно SFT-модель), к которой обучаемую политику «привязывает» KL-штраф. $\pi_{\text{ref}}$, обычно это SFT-модель. К цели добавляют KL-штрафKL-штрафEN KL penaltyСлагаемое −β·KL(π ‖ π_ref) в цели RL; не даёт политике уйти далеко от референсной модели.:

$$J(\theta) = \mathbb{E}_{y \sim \pi_\theta}\big[\, r(x, y) \,\big] - \beta\, \mathrm{KL}\big(\pi_\theta(\cdot \mid x) \,\Vert\, \pi_{\text{ref}}(\cdot \mid x)\big)$$

KL-дивергенциюKL-дивергенция (дивергенция Кульбака — Лейблера)EN Kullback–Leibler divergenceKL(p ‖ q) = Σ p log(p / q) = H(p, q) − H(p) ≥ 0. Несимметрична, поэтому не настоящее расстояние. вы считали в уроке 1.3.3. Для ответов-последовательностей её нельзя посчитать точно (вариантов астрономически много), поэтому оценивают по сэмплу — суммой по токенам сгенерированного ответа:

$$\widehat{\mathrm{KL}} = \sum_t \Big[\log \pi_\theta(y_t \mid \cdot) - \log \pi_{\text{ref}}(y_t \mid \cdot)\Big]$$

Пример: модель после RL даёт токену вероятность 0.9, а референсная — 0.3. Вклад в KL: $\ln(0.9/0.3) = \ln 3 \approx 1.10$. При $\beta = 0.05$ (на практике берут значения порядка 0.01–0.1) штраф за этот токен — 0.055. Мелочь, но за сотни «необычных» токенов набегает заметно. Учтите: у отдельного токена или ответа такая оценка бывает и отрицательной (если $\pi_\theta$ дала токену меньшую вероятность, чем референс), но в среднем по сэмплам она равна KL и неотрицательна.

К чему приводит KL-штраф

У задачи «максимум награды минус $\beta \cdot$ KL» есть точное решение:

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

где $Z(x)$ — нормировка. Это перевзвешенная референсная модель: каждый ответ умножается на $e^{r/\beta}$.

• $\beta \to 0$: побеждает ответ с максимальной наградой, политика схлопывается в него.
• $\beta \to \infty$: $\pi^* = \pi_{\text{ref}}$, награда игнорируется.
• Между ними — компромисс, который регулирует один параметр.

Запомните эту формулу: в уроке про DPO из неё за три строки получится целый алгоритм.

KL в награде или в loss

В InstructGPT штраф $-\beta \log(\pi_\theta / \pi_{\text{ref}})$ добавляют к награде на каждом токене. В GRPO (DeepSeekMath) KL вынесен прямо в функцию потерь и оценивается другой формулой, которая всегда неотрицательна. Подробно — в модуле 6.4.

Практика

Задание: REINFORCE на многоруком бандите

Многорукий бандитмногорукий бандитEN multi-armed banditПростейшая задача RL — K «ручек» с неизвестными средними наградами, один шаг на эпизод. — простейшая задача RL: $K$ «ручек» с неизвестными средними наградами, один шаг на эпизод. Это ровно «LLM с одним промптом и $K$ вариантами ответа». Реализуйте градиент лог-softmax, шаг REINFORCE, точное матожидание градиента и цикл обучения с baseline.

REINFORCE и baseline на бандитеnumpy · нужен интернет7 тестов

import numpy as np


def softmax(z):
    """Устойчивый softmax (из урока 1.3) — уже готов."""
    z = np.asarray(z, dtype=float)
    e = np.exp(z - z.max())
    return e / e.sum()


def grad_log_prob(logits, action):
    """Градиент log softmax(z)[action] по вектору логитов z.

    Ответ — np.ndarray той же длины, что logits: onehot(action) - softmax(z).
    """
    # TODO: ваш код
    ...


def reinforce_update(logits, action, reward, baseline, lr):
    """Один шаг REINFORCE (градиентный ПОДЪЁМ — награду мы максимизируем).

    Вернуть НОВЫЙ массив логитов: z + lr * (reward - baseline) * grad_log_prob(z, action).
    Входной массив не изменять.
    """
    # TODO: ваш код
    ...


def expected_gradient(logits, rewards, baseline):
    """Точное матожидание оценки градиента REINFORCE для бандита
    с детерминированными наградами rewards[a]:

        E[g] = sum_a  p_a * (rewards[a] - baseline) * grad_log_prob(z, a)
    """
    # TODO: ваш код
    ...


def train_bandit(arm_means, steps=1000, lr=0.1, use_baseline=True, seed=0):
    """Обучить политику softmax(z) на многоруком бандите алгоритмом REINFORCE.

    - старт: z = нули;
    - rng = np.random.default_rng(seed);
    - на каждом шаге: p = softmax(z); действие a ~ p (rng.choice);
      награда r ~ Normal(arm_means[a], 1) (rng.normal);
    - baseline = среднее всех ПРОШЛЫХ наград (на первом шаге 0);
      если use_baseline=False — baseline всегда 0;
    - z = reinforce_update(z, a, r, baseline, lr).

    Вернуть итоговые вероятности softmax(z).
    """
    # TODO: ваш код
    ...


# Проверьте себя кнопкой «Запустить»:
print(grad_log_prob([0.0, 0.0, 0.0], 1))                      # ≈ [-0.333, 0.667, -0.333]
print(train_bandit([10.0, 10.5, 11.0]))                        # лучшая ручка — последняя
print(train_bandit([10.0, 10.5, 11.0], use_baseline=False))   # а что без baseline?

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

Нажмите «Запустить» после решения: с baseline политика находит лучшую ручку ($p \approx 0.99$), а без него на наградах около 10 «залипает» на случайной ручке. Каждая награда положительна, и шаг $0.1 \cdot 10 \cdot (1 - p_a)$ — до 0.7 по логиту — толкает вверх любое выпавшее действие, так что выигрывает не лучшая ручка, а та, которой повезло в начале. У эталона получается $[0.002, 0.997, 0.001]$ — уверенно и неправильно.

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

Модель — биграммная таблица логитов над словарём из шести «слов». Она генерирует ответы из 4 токенов, награда — число вежливых слов («спасибо» или «thanks»). Сравним обучение без KL-штрафа и с $\beta = 0.5$. Baseline — средняя награда по батчу.

import torch

vocab = ["да", "нет", "ок", "привет", "спасибо", "thanks"]
V, L = len(vocab), 4                          # словарь и длина «ответа»
polite = torch.tensor([0, 0, 0, 0, 1, 1.0])   # награда за каждое «спасибо»/«thanks»


def train(beta, steps=300, batch=64, lr=0.5):
    torch.manual_seed(0)
    # «Языковая модель»: биграммная таблица логитов [пред. токен → след. токен]
    logits = torch.zeros(V + 1, V, requires_grad=True)     # +1 строка для <bos>
    ref = logits.detach().clone()                          # замороженная копия = π_ref
    opt = torch.optim.SGD([logits], lr=lr)
    for step in range(steps + 1):
        prev = torch.full((batch,), V)                     # все начинают с <bos>
        logp, logp_ref, tokens = [], [], []
        for t in range(L):                                 # авторегрессионная генерация
            # Categorical — категориальное распределение (урок 1.3.1) из логитов: строка таблицы для предыдущего токена
            dist = torch.distributions.Categorical(logits=logits[prev])
            tok = dist.sample()                            # сэмплируем следующий токен для каждого из 64 ответов
            logp.append(dist.log_prob(tok))                # log π_θ(выбранного токена) — через него пойдёт градиент
            # log π_ref того же токена: gather достаёт из каждой строки элемент с номером tok
            logp_ref.append(torch.log_softmax(ref[prev], -1).gather(1, tok[:, None])[:, 0])
            tokens.append(tok)
            prev = tok
        logp, logp_ref = torch.stack(logp, 1), torch.stack(logp_ref, 1)   # [batch, L]
        tokens = torch.stack(tokens, 1)
        R = polite[tokens].sum(1)                          # награда за весь ответ
        kl = (logp - logp_ref).sum(1).detach()             # оценка KL по сэмплу
        shaped = R - beta * kl                             # награда с KL-штрафом
        adv = shaped - shaped.mean()                       # baseline = среднее по батчу
        loss = -(adv * logp.sum(1)).mean()                 # REINFORCE
        opt.zero_grad()
        loss.backward()
        opt.step()
        if step % 100 == 0:
            print(f"beta={beta:<4} шаг {step:3d}: награда {R.mean():.2f} из {L}, KL {kl.mean():.2f}")
    return logits


for beta in [0.0, 0.5]:
    lg = train(beta)
    p = torch.softmax(lg[V], -1)   # распределение первого токена после <bos>
    print("  p(первый токен):", {w: round(x, 2) for w, x in zip(vocab, p.tolist())})

Вывод (PyTorch 2.x на CPU; в других версиях числа могут немного отличаться):

beta=0.0  шаг   0: награда 1.39 из 4, KL 0.00
beta=0.0  шаг 100: награда 3.89 из 4, KL 4.22
beta=0.0  шаг 200: награда 3.98 из 4, KL 5.36
beta=0.0  шаг 300: награда 3.95 из 4, KL 5.44
  p(первый токен): {'да': 0.0, 'нет': 0.0, 'ок': 0.0, 'привет': 0.0, 'спасибо': 0.09, 'thanks': 0.91}
beta=0.5  шаг   0: награда 1.39 из 4, KL 0.00
beta=0.5  шаг 100: награда 3.14 из 4, KL 1.70
beta=0.5  шаг 200: награда 3.23 из 4, KL 1.89
beta=0.5  шаг 300: награда 3.22 из 4, KL 1.87
  p(первый токен): {'да': 0.05, 'нет': 0.05, 'ок': 0.05, 'привет': 0.05, 'спасибо': 0.39, 'thanks': 0.39}

Что видно:

• Без KL награда почти максимальная, но модель схлопнулась: 91% ответов начинаются с «thanks», хотя «спасибо» стоит столько же. Разнообразие потеряно, KL от исходной модели — 5.4.
• С $\beta = 0.5$ награда ниже (3.2), зато KL втрое меньше, оба вежливых слова равноправны, остальные не исчезли.
• Сверим с формулой $\pi^* \propto \pi_{\text{ref}}\, e^{r/\beta}$. Референс равномерный, а награда — сумма наград отдельных токенов, поэтому $e^{R/\beta}$ распадается на произведение множителей по токенам, и каждый токен оптимальной политики выбирается независимо, с весом $e^{1/0.5} = e^2$ у вежливого слова и $1$ у остальных: $\pi^*(\text{«спасибо»}) = e^{2} / (4 + 2e^{2}) = 0.393$, а для остальных $1/(4 + 2e^2) = 0.053$. Обучение пришло ровно туда: 0.39 и 0.05. Теория даёт и награду $4 \cdot 2 \cdot 0.393 \approx 3.15$ — близко к 3.22 в логе (это оценка по одному батчу из 64 ответов, она шумит).

Китайский угол: baseline вместо критика — GRPO

Самое известное китайское применение идей этого урока — GRPO из DeepSeekMath (февраль 2024). DeepSeek взяли REINFORCE-подобный градиент и выбрали baseline так: на каждый промпт генерируется группа ответов, преимущество каждого — его награда минус среднее по группе, делённое на стандартное отклонение. Отдельная value-модель размером с саму LLM (как в PPO) больше не нужна. KL к референсной модели вынесен прямо в loss. Этот алгоритм потом обучил DeepSeek-R1. Причём награда у R1-Zero вычисляется правилами — проверка ответа и формата (правиловая наградаправиловая наградаEN rule-based rewardНаграду считает программа (сверка ответа, запуск тестов, проверка формата), а не нейросеть. Её трудно «взломать».), без нейросетевой reward model, чтобы её нельзя было «взломать».

Где учить классический RL по-китайски:

• easy-rl, «Грибная книга» (Datawhale) — гл. 4 «Градиент стратегии»: два приёма из этого урока названы там «добавить базовую линию» (baseline) и «распределить подходящие баллы» (распределить баллы по шагам). Гл. 5 — PPO, понадобится в следующем уроке.
• «Обучение с подкреплением своими руками» (Hands-on-RL, Шанхайский университет Цзяотун, Apache-2.0) — ноутбуки к главе 2 «Задача о многоруком бандите» (бандиты, как в нашем задании) и к главе 9 «Алгоритмы градиента стратегии» (REINFORCE на PyTorch).

Термины. Градиент политики по-китайски — «градиент стратегии», baseline — «базовая линия»; функция преимущества и референсная модель («опорная модель») называются дословно.

Проверь себя

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

1 Если смотреть на генерацию LLM как на задачу RL на уровне токенов, что такое действие?

Весь промпт пользователяВыбор следующего токенаЧисло-оценка от reward modelШаг оптимизатора

2 Логиты $z = [0, 0, 0]$, сэмплировали действие 0 с наградой $r = 1$, baseline $b = 0$, шаг $\alpha = 0.5$. Какой станет вероятность действия 0 после шага REINFORCE? Округлите до двух знаков.

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

Он не меняет матожидание оценки градиентаОн уменьшает дисперсию оценки градиентаОн должен быть равен максимальной наградеВ GRPO baseline — средняя награда группы ответов на тот же промпт

4 Reward model ставит всем ответам оценки от 5 до 7, baseline не используется. Что происходит при обучении REINFORCE?

Ничего: градиент равен нулюВероятность каждого сэмплированного ответа, даже плохого, подталкивается вверх; лучший выигрывает лишь в среднем — обучение шумное и медленноеМодель сразу выбирает лучший ответНаграды нужно сделать отрицательными, иначе обучение невозможно

5 Что произойдёт с политикой, если KL-коэффициент $\beta \to 0$?

Политика останется равной референсной моделиПолитика схлопнется в ответы с максимальной наградой и сможет эксплуатировать ошибки reward modelОбучение остановится, потому что градиент станет нулевым

6 Референсная модель равновероятно выбирает один из 4 ответов. Награды $[1, 0, 0, 0]$, $\beta = 1$. Какова вероятность первого ответа у оптимальной политики $\pi^*$? Округлите до двух знаков.

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

Итоги

• LLM — уже готовая политика: состояние — контекст, действие — токен, награда — оценка ответа в конце.
• Градиент политики $\mathbb{E}[r \nabla \log \pi]$ — это SFT на собственных ответах модели, взвешенный наградой. REINFORCE оценивает его сэмплами и требует свежей генерации на каждом шаге (on-policy).
• Baseline не меняет матожидание градиента, но резко снижает дисперсию; $A = r - b$ — advantage. Разные способы выбрать baseline дают REINFORCE, PPO, RLOO и GRPO.
• KL-штраф держит модель рядом с $\pi_{\text{ref}}$; оптимум — $\pi^* \propto \pi_{\text{ref}} e^{r/\beta}$.

Дальше: откуда берётся награда, если ответ нельзя проверить автоматически, — reward model на человеческих предпочтениях, модель Брэдли–Терри и PPO.