Reinforcement Learning в обучении LLM - PPO, DPO, GRPO - что это?

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

Rejection Sampling - простой способ делать RL

Rejection Sampling (выборка с отклонением) — это метод, используемый для улучшения качества генерации ответов LLM на этапе выравнивания (alignment) после SFT. Основная идея заключается в том, чтобы генерировать несколько вариантов ответов на один запрос, оценивать их с помощью модели вознаграждения (reward model), а затем выбирать лучший ответ для дообучения модели. Этот подход применялся, например, в LLaMA-2 Chat.

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

Как реализуется Rejection Sampling

Шаг 1: Генерация нескольких ответов

  • Модель генерирует несколько вариантов ответов на один и тот же промт (например, 4–10 вариантов). Для этого используются параметры вроде num_return_sequences в Hugging Face Transformers.
  • Пример: 
    responses = model.generate(prompt, num_return_sequences=5, do_sample=True)

Шаг 2: Оценка ответов

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

Шаг 3: Выбор лучшего ответа

  • Из всех вариантов выбирается ответ с максимальной наградой (или с учетом других критериев, например, безопасности). Этот ответ становится "предпочтительным" (chosen), а остальные — "непредпочтительными" (rejected).

Шаг 4: Дообучение модели

  • Модель дообучается на парах (prompt, chosen), чтобы чаще генерировать ответы, которые получают высокие оценки от reward model. Иногда используются и пары (prompt, rejected) для явного снижения вероятности плохих ответов.

Для чего нужен Rejection Sampling

  • Улучшение качества ответов: Модель учится избегать нежелательных генераций (например, токсичных или бессвязных) за счет фильтрации через reward model.
  • Простота реализации: Не требует сложных алгоритмов RL (вроде PPO) и работает как supervised learning.
  • Гибкость: Может использоваться как самостоятельный метод или в комбинации с DPO/PPO для усиления эффекта .

Требования к данным:

  1. Промты: Запросы, на которые модель должна отвечать (например, вопросы, инструкции).
  2. Сгенерированные ответы: Несколько вариантов ответов на каждый промт.
  3. Оценки от reward model: Числовые метки для каждого ответа.

Пример формата данных:

{
  "prompt": "Как приготовить кофе?",
  "responses": [
    {"text": "Возьмите кофе и воду...", "reward": 8.5},
    {"text": "Кофе — это вкусный напиток...", "reward": 3.2},
    ...
  ]
}

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

Алгоритм обучения модели с Rejection Sampling

Этапы обучения:

  1. Генерация:
    • Для каждого промта в обучающем датасете генерируется N ответов (например, 5–10) с помощью do_sample=True и параметра temperature для разнообразия.
  2. Фильтрация:
    • Ответы оцениваются reward model. Выбирается ответ с максимальной наградой.
  3. Обучение:
    • Модель обучается на парах (prompt, chosen) с использованием стандартной функции потерь (например, cross-entropy) для повышения вероятности предпочтительных ответов.
  4. Оптимизация:
    • Добавляются регуляризаторы в loss (например, KL-дивергенция между исходной и текущей моделью), чтобы избежать деградации стабильности генерации.

Пример кода на PyTorch:

# Генерация нескольких ответов для одного примера
with torch.no_grad():
    responses = model.generate(
        input_ids=prompt_ids,
        num_return_sequences=5,
        do_sample=True,
        max_length=500
    )

# Получаем reward'ы для каждого ответа
rewards = reward_model(responses).detach()

# Выбираем лучший ответ
best_idx = torch.argmax(rewards)
best_response = responses[best_idx].unsqueeze(0)

# Объединяем промпт и лучший ответ
full_input = torch.cat([prompt_ids, best_response], dim=-1)

# Создаем labels: промпт игнорируем (-100), учимся только на ответе
labels = torch.cat([
    torch.full_like(prompt_ids, -100),
    best_response
], dim=-1)

# Forward pass + loss
outputs = model(input_ids=full_input, labels=labels)
loss = outputs.loss

# Backward pass
optimizer.zero_grad()
loss.backward()
optimizer.step()

Преимущества и недостатки

Преимущества:

  • Простота: Не требует сложных RL-алгоритмов.
  • Эффективность: Позволяет быстро улучшить качество ответов за счет фильтрации.
  • Гибкость: Совместим с любыми reward model (включая GPT-4 для автоматической разметки) .

Недостатки:

  • Вычислительная стоимость: Генерация множества ответов на один промт требует ресурсов.
  • Ограниченная вариативность: Модель может переобучиться на шаблонах reward model.
  • Отсутствие обратной связи: В отличие от PPO, не использует итеративное обновление политики .

Rejection Sampling — это эффективный метод подгонки (aligbnent) LLM, сочетающий простоту реализации и хорошие результаты. Он особенно полезен, когда нет возможности использовать сложные RL-алгоритмы (например, PPO), но есть access к reward model. Однако его эффективность зависит от качества reward model, наличия промптов для реализации генерации и вычислительных ресурсов для генерации множественных ответов.

DPO - Direct Preference Optimization

https://arxiv.org/pdf/2305.18290

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

Исходные пары для DPO SFT обучения можно создавать как людьми, так и с помощью оценки LLM.

Построение датасета

Сравнение сгенерированных ответов проводится людьми (экспертами или пользователями). Например:

  • LLM генерирует два варианта ответа на промт «Как приготовить кофе?»:
    • Ответ A: «Возьмите кофе, налейте горячую воду, перемешайте».
    • Ответ B: «Кофе — это вкусный напиток, он бывает разных видов».
  • Люди выбирают, какой ответ лучше. Если большинство голосует за A, он помечается как предпочтительный, а B — как непредпочтительный .

Разметка создаётся вручную или с помощью автоматизированных систем:

  • Шаг 1: Сбор ответов на один промт (например, 10 ответов).
  • Шаг 2: Люди или алгоритмы (например, GPT-4) сравнивают пары и выбирают лучший и в пару ему более плохой ответ.

  • Шаг 3: Формирование датасета вида:

    {
"prompt": "Как приготовить кофе?",
"chosen": "Возьмите кофе, налейте горячую воду, перемешайте.",
"rejected": "Кофе — это вкусный напиток, он бывает разных видов."
}

Такие данные используются для обучения DPO .

DPO обучается как обычная модель с учителем, но с особой функцией потерь:

Формула потерь DPO (Loss):

\[ \mathcal{L}_{\text{DPO}} = -\log \sigma\left( \log p_{\theta}(\text{chosen}) - \log p_{\theta}(\text{rejected}) \right),\]

где:

  • \(p_{\theta}(\text{chosen})\) — вероятность предпочтительного ответа,

  • \(p_{\theta}(\text{rejected})\) — вероятность непредпочтительного ответа,

  • \(\sigma(x) = \frac{1}{1 + e^{-x}}\). — сигмоида

  • Модель учится увеличивать вероятность предпочтительных ответов и уменьшать вероятность непредпочтительных.

  • Например, если текущая модель выдаёт для пары (A, B) вероятности \(p(A) = 0.6\), \(p(B) = 0.4\), то потери будут минимальны. Если же \(p(A) = 0.4\), \(p(B) = 0.6\), потери возрастут, и модель изменит параметры, чтобы исправить это.

Для каждого ответа (chosen или rejected) модель вычисляет лог-вероятность всей последовательности токенов \(y=[y_1 ,y_2 ,...,y_T ]\):

\[ logp_θ​(y∣x)=∑_{t=1}^T​log(p_θ​(y_t​∣x,y < t ​))\]

где \(p_θ (y_t ∣x,y < t )\) — вероятность текущего токена \(y_t\)​ при заданных контексте x и предыдущих токенах \(y < t\)

Этапы обучения в DPO

Шаг 1: Подготовка данных

  • Собираются пары (prompt, chosen, rejected) через сравнение ответов LLM людьми или другими моделями .

Шаг 2: Инициализация модели

  • Берётся предобученная LLM (например, Llama-3) как начальная точка .

Шаг 3: Обучение с функцией потерь DPO

  • Для каждой пары ответов:
    1. Вычисляется лог-вероятность \(\log p_{\theta}(\text{chosen})\) и \(\log p_{\theta}(\text{rejected})\).
    2. Разница передаётся в сигмоид-функцию: \(\sigma(\text{diff})\).
    3. Цель — максимизировать \(\sigma(\text{diff})\), чтобы предпочтительный ответ становился вероятнее .

Шаг 4: Оптимизация

  • Используется градиентный спуск (например, AdamW) для минимизации потерь.
  • Как гиперпараметр используется параметр \(\beta > 0\), чтобы контролировать силу учета предпочтений:

    \[ \mathcal{L}_{\text{DPO}} = -\log \sigma\left( \beta \cdot (\log p_{\theta}(\text{chosen}) - \log p_{\theta}(\text{rejected})) \right).\]

В некоторых реализациях (например, в Hugging Face DPO Trainer) используется референсная модель pref​ для нормализации:

\[ \log\left( \frac{p_{\theta}(\text{chosen})}{p_{\text{ref}}(\text{chosen})} \right) - \log\left( \frac{p_{\theta}(\text{rejected})}{p_{\text{ref}}(\text{rejected})} \right)\]

Это помогает контролировать отклонение от исходной предобученной модели (аналог техники с KL дивергенцией).

Шаг 5: Тестирование

  • После обучения модель генерирует ответы, которые снова проверяются на соответствие предпочтениям. Если результаты неудовлетворительны, процесс повторяется с новыми данными.

Преимущества DPO

  1. Без reward model: Не нужно обучать отдельную модель для оценки награды, как в PPO (но все равно надо уметь сравнивать ответы модели в большой модели, хотя бы заготовить такие пары сравненных ответов заранее).
  2. Стабильность: Работает как supervised learning, что снижает риски нестабильного обучения RL.
  3. Простота реализации: Можно использовать стандартные фреймворки (Hugging Face Transformers) для обучения как в обуычном SFT.

Недостатки

  • Ограниченная гибкость: В сложных сценариях (например, многократные итерации генерации) DPO может уступать PPO. И надо повторно размечать и готовить пары предпочтений.

Для эффективного обучения с помощью DPO обычно требуется от нескольких тысяч до десятков тысяч пар (prompt, chosen, rejected). Конкретный размер зависит от сложности задачи и размера самой модели. Например:

  • Маленькие датасеты: 2–10 тыс. пар, подходят для экспериментов или небольших моделей (например, датасет not-lain/dpo-standard содержит всего 2 строки ).
  • Средние датасеты: 10–40 тыс. пар, например, Human-Like-DPO-Dataset с 10,884 строками.
  • Крупные датасеты: 40 тыс. и более пар, как mlabonne/orpo-dpo-mix-40k.

Чем больше модель и сложнее задача (например, выравнивание с человеческими предпочтениями), тем больше данных требуется для стабильного обучения. Исследования показывают, что эффективность DPO чувствительна к качеству и количеству данных.

DPO-обучение обычно проводят в течение 1–3 эпох, так как увеличение количества эпох может привести к ухудшению качества модели из-за переобучения или нестабильности оптимизации. Вот ключевые детали:

  1. Стандартный подход:

    • В большинстве случаев обучение DPO ограничивается 1 эпохой, особенно при использовании небольших датасетов (например, ~2–40 тыс. пар предпочтений).
    • Это связано с тем, что повторное прохождение по данным может вызвать переобучение, так как модель начинает запоминать конкретные примеры вместо обобщения предпочтений.

  2. Исключения для малых датасетов:

    • Если датасет очень маленький (например, ~2 тыс. пар), иногда используют до 3 эпох, чтобы компенсировать недостаток данных.
    • Однако даже в этом случае важно тщательно контролировать переобучение через метрики валидации.

  3. Риски увеличения эпох:

    • При увеличении числа эпох (>3) часто наблюдается "performance crash" — ухудшение качества генерации из-за деградации стабильности обучения.
    • Это особенно критично для больших моделей, где даже одна эпоха требует значительных вычислительных ресурсов.

  4. Рекомендации:

    • Начинайте с 1 эпохи, а затем проверяйте эффективность на валидационных данных перед увеличением количества эпох.
    • Для улучшения результатов вместо увеличения эпох лучше настраивать гиперпараметры (например, коэффициент β, размер батча).

Функция потерь в DPO (Direct Preference Optimization) не использует KL-дивергенцию напрямую, как в PPO, но основана на логарифме отношения вероятностей предпочтительных (chosen) и непредпочтительных (rejected) ответов.

DPO с KL дивергенцией

В работе https://arxiv.org/abs/2411.07595 (2024) предлагается Entropy Controllable DPO (EC-DPO), где в функцию потерь добавляется обратная KL-дивергенция относительно опорной политики (например, исходной предобученной модели):

\[ \mathcal{L}_{\text{EC-DPO}} = \mathcal{L}_{\text{DPO}} + \lambda \cdot D_{\text{KL}}(p_\theta \parallel p_{\text{ref}})\]

где λ — коэффициент регуляризации. Это позволяет контролировать степень отклонения модели от опорной политики (исходной предобученной модели), избегая чрезмерной адаптации под задачу DPO.

KL-дивергенция (Расхождение Кульбака-Лейблера) \(D_{\text{KL}}(p_\theta \parallel p_{\text{ref}})\) в обучении LLM вычисляется как мера разницы между распределениями вероятностей, предсказываемыми обучаемой моделью (\(p_\theta\)) и референсной моделью (\(p_{\text{ref}}\)).

Использование KL-дивергенции в EC-DPO помогает балансировать между качеством предпочтений и стабильностью модели.

Для дискретных распределений KL-дивергенция определяется как:

\[ D_{\text{KL}}(p_\theta \parallel p_{\text{ref}}) = \sum_{y} p_\theta(y) \cdot \log \frac{p_\theta(y)}{p_{\text{ref}}(y)},\]

где \(y\) — возможные выходные последовательности (например, токены в ответе модели). Однако в реальных задачах LLM пространство всех возможных последовательностей \(y\) слишком велико для прямого вычисления .

На практике KL-дивергенция вычисляется локально для конкретного промпта \(x\) и сгенерированного ответа \(y = [y_1, y_2, ..., y_T]\), где \(T\) — длина последовательности. Для каждого токена \(y_t\) в ответе:

\[ D_{\text{KL}}(p_\theta \parallel p_{\text{ref}}) = \sum_{t=1}^T \log \frac{p_\theta(y_t \mid x, y_{<t})}{p_{\text{ref}}(y_t \mid x, y_ {< t})},\]

где:

  • \(p_\theta(y_t \mid x, y_{<t})\) — вероятность токена \(y_t\), предсказанная обучаемой моделью,
  • \(p_{\text{ref}}(y_t \mid x, y_{< t})\) — вероятность того же токена, предсказанная референсной моделью (например, исходной предобученной моделью) .

Предположим, для токена \(y_t\) модель \(p_\theta\) предсказывает вероятность \(0.8\), а референсная модель \(p_{\text{ref}}\) — \(0.6\). Тогда вклад этого токена в KL-дивергенцию:

\[ \log \frac{0.8}{0.6} = \log(1.333) \approx 0.2877.\]

Если модель \(p_\theta\) и референс \(p_{\text{ref}}\) совпадают (\(p_\theta = p_{\text{ref}}\)), KL-дивергенция равна нулю. Чем больше различие между распределениями, тем выше значение \(D_{\text{KL}}\) .

В реальных задачах KL-дивергенция часто нормируется по длине последовательности \(T\) или усредняется по батчу, чтобы избежать численной нестабильности:

\[ D_{\text{KL}}^{\text{avg}} = \frac{1}{T} \sum_{t=1}^T \log \frac{p_\theta(y_t \mid x, y_{<t})}{p_{\text{ref}}(y_t \mid x, y_{< t})}.\]

Это позволяет использовать KL-дивергенцию как регуляризатор в функции потерь:

\[ \mathcal{L}_{\text{EC-DPO}} = \mathcal{L}_{\text{DPO}} + \lambda \cdot D_{\text{KL}}^{\text{avg}},\]

где \(\lambda\) контролирует силу регуляризации .

  • KL-дивергенция не симметрична: \(D_{\text{KL}}(p_\theta \parallel p_{\text{ref}}) \neq D_{\text{KL}}(p_{\text{ref}} \parallel p_\theta)\) .
  • KL-дивергенция определена только если \(p_\theta(y) > 0\) везде, где \(p_{\text{ref}}(y) > 0\) (условие абсолютной непрерывности) .




GRPO: Group Relative Policy Optimization


GRPO (Group Relative Policy Optimization) — это алгоритм обучения с подкреплением (RL), разработанный для улучшения способности языковых моделей к рассуждениям, особенно в задачах, требующих точности, таких как математика. Он был представлен в исследованиях DeepSeek и активно ими осипользуется. Этот алгоритм направлен на снижение вычислительных затрат и упрощение процесса обучения по сравнению с традиционными методами вроде PPO.

Основная идея

GRPO устраняет необходимость обучения функции ценности (value function), которая используется в PPO для оценки преимущества (advantage). Вместо этого GRPO использует среднюю награду группы ответов на один промт как базовый уровень для сравнения. Это позволяет избежать сложностей, связанных с обучением модели-критика (critic network), и значительно снижает использование памяти и вычислительных ресурсов .

Как это работает

  1. Генерация нескольких ответов: Для каждого промта модель генерирует несколько вариантов ответов (например, 5–10) .
  2. Оценка через reward model: Каждый ответ оценивается моделью вознаграждения (reward model), которая присваивает числовую метку, отражающую качество ответа .
  3. Вычисление средней награды группы: Среднее значение наград всех ответов на один промт становится основой (baseline) для сравнения.
  4. Обновление политики: Модель обучается увеличивать вероятность ответов с наградой выше средней и снижать вероятность ответов с наградой ниже средней. Это делается через функцию потерь, которая максимизирует разницу между реальной и средней наградой.

Формула функции потерь GRPO

Функция потерь GRPO основана на сравнении логарифмических вероятностей ответов с их средней наградой в группе:

\[ \mathcal{L}_{\text{GRPO}} = -\mathbb{E}_{t} \left[ \log p_{\theta}(a_i|s_j) \cdot \left( r_i - \bar{r} \right) \right],\]

где:

  • \(p_{\theta}(a_i|s_j)\) — вероятность действия (ответа) \(a_i\) в состоянии \(s_j\) (те мы для промпта \(s_j\) делаем несколько генераций и \(a_i\) одна из них. И вероятность этой генерации при условии этого промпта \(p_{\theta}(a_i|s_j)\) мы можем посчитать на основе выходов LLM),
  • \(r_i\) — награда за конкретный ответ,
  • \(\bar{r}\) — средняя награда всех ответов на промт \(s_j\).

Если \(r_i > \bar{r}\), вероятность ответа увеличивается, иначе — снижается.

Или более простым языком, если для промпта \(s_j\) сгенерировано \(N\) ответов \(a_1, a_2, ..., a_N\), то:

\[ \bar{r} = \frac{1}{N} \sum_{i=1}^N r_i,\]

а потери вычисляются как:

\[ \mathcal{L}_{\text{GRPO}} = -\frac{1}{N} \sum_{i=1}^N \log p_\theta(a_i \mid s_j) \cdot (r_i - \bar{r}).\]

  • Интерпретация:
    • Если \(r_i > \bar{r}\), то \((r_i - \bar{r}) > 0\), и лог-вероятность \(\log p_\theta(a_i \mid s_j)\) увеличивается (модель учится чаще выбирать такие ответы).
    • Если \(r_i < \bar{r}\), то \((r_i - \bar{r}) < 0\), и лог-вероятность уменьшается (модель учится избегать такие ответы).

Требования к данным:

  • Промты: Запросы, на которые модель должна отвечать (например, математические задачи).
  • Сгенерированные ответы: Несколько вариантов ответов на каждый промт, созданных с помощью параметров вроде do_sample=True и temperature для разнообразия.
  • Модель вознаграждения: Предобученная reward model, которая оценивает качество ответов (например, на основе человеческих предпочтений или автоматических метрик) .

Пример формата данных:

{
  "prompt": "Решите уравнение x² + 5x + 6 = 0",
  "responses": [
    {"text": "Корни: x₁ = -2, x₂ = -3", "reward": 9.2},
    {"text": "Это сложно...", "reward": 3.1},
    {"text": "Дискриминант равен 1", "reward": 6.5}
  ]
}

Средняя награда группы: \(\bar{r} = (9.2 + 3.1 + 6.5)/3 = 6.27\). Ответы с \(r_i > 6.27\) получают положительное влияние на обновление модели .

Шаг обучения в GRPO

Этапы:

  1. Генерация: Модель генерирует несколько ответов на промты из обучающего датасета.
  2. Оценка: Все ответы оцениваются reward model, вычисляется средняя награда группы.
  3. Обновление политики: Функция потерь GRPO корректирует параметры модели, увеличивая вероятность ответов с \(r_i > \bar{r}\) и снижая для \(r_i < \bar{r}\).
  4. Итерация: Процесс повторяется до сходимости.

Преимущества GRPO

  • Экономия ресурсов: Не требует обучения критика, что снижает вычислительную нагрузку.
  • Простота реализации: Замена сложных RL-механизмов на групповые сравнения упрощает настройку.
  • Эффективность в задачах рассуждения: GRPO показывает хорошие результаты в математических задачах, где важна точность (например, DeepSeekMath, DeepSeek R1).

Недостатки GRPO

  • Ограниченная применимость: Метод эффективен в сценариях с четкими критериями оценки (например, математика, кодинг), но может быть менее стабильным в открытых задачах, где награда субъективна.
  • Зависимость от reward model: Качество обучения напрямую зависит от точности модели вознаграждения .

PPO

PPO был первым примененным к LLM RL алгоритмом. Именно он сделал из из инструктивной модели gpt3.5 умную ChatGPT.

Но технически и идеологически он более сложный чем RL алгоритмы представленные выше.

У вас по-прежнему есть промпты \(s_t \) которые вы продолжаете различными генерациями и вам хочется сдвигать модель в сторону увеличения частоты хороших генераций.

Помимо reward_model тут нужна еще модель Critic (критик) — отдельная нейросеть, которая обучается предсказывать \(V(s_t )\). Она обновляется параллельно с политикой и минимизирует ошибку между предсказанным и фактическим вознаграждением.

Где \(V(s_t )\) — оценка среднего вознаграждения, которое можно получить из состояния \(s_t\)​ при текущей политике. Те по текущему промпту мы предсказываем какой средний ревард мы можем выбить генерируя много продолжений промпта текущей моделью.

В PPO используются и reward модель, и модель-critic модель, и они выполняют разные функции:

  1. Reward модель:

    • Используется для оценки мгновенного вознаграждения \(r_t\) за конкретный сэмпл (например, пару "запрос-ответ" в задачах с текстом).
    • Она обучается до начала PPO на данных предпочтений (например, человек оценивает, какой из двух ответов лучше).
    • Не обновляется в процессе PPO, фиксирована, чтобы избежать смещения.

  2. Critic модель:

    • Обучается в процессе PPO вместе с LLM и оценивает ожидаемое суммарное вознаграждение \(V(s_t)\) из текущего состояния \(s_t\).
    • Используется для вычисления advantage \(A_t\), которое показывает, насколько текущее действие лучше среднего для этого состояния.
    • Обновляется параллельно с политикой (моделью LLM) через минимизацию ошибки предсказания \(V(s_t)\) относительно фактического вознаграждения.

Пример работы в RLHF (обучение с человеческими предпочтениями):

  1. Reward модель оценивает качество ответов на запросы, сравнивая их с эталонами (например, человек выбирает лучший ответ из нескольких вариантов).
  2. PPO использует эту reward модель для получения \(r_t\), а critic — для оценки долгосрочной ценности действий.
  3. Политика обновляется через clipped surrogate loss, чтобы избежать больших скачков в параметрах.
  • Reward модель ≠ Critic: первая фиксирована и задаёт "цель", вторая обучается и помогает стабилизировать обновления политики.
  • В некоторых случаях (например, в альтернативных подходах) reward модель может заменяться на другие методы, но в классическом PPO она обязательна.

В алгоритме PPO (Proximal Policy Optimization) обновление весов модели происходит через ограничение изменений параметров с помощью Clipping, чтобы обеспечить стабильность обучения.

Шаг PPO

1. Сбор данных

  • Для заданного запроса генерируются несколько ответов (сэмплов) с использованием текущей политики (модели). Эти сэмплы оцениваются с помощью reward model для получения скалярного вознаграждения (reward) за каждый ответ.

2. Вычисление преимущества (Advantage)

  • Для каждого сэмпла рассчитывается advantage estimate — мера того, насколько лучше каждая текущая генерация по сравнению с ожидаемым средним вознаграждением. Это помогает определить, какие действия (ответы) должны получать положительные или отрицательные корректировки весов.

Advantage показывает, насколько лучше текущее действие по сравнению с ожидаемым средним для данного состояния.

\(A_t = Q(s_t, a_t) - V(s_t)\)

  • \(Q(s_t, a_t)\) — оценка полезности конкретного действия \(a_t\) в состоянии \(s_t\).
  • \(V(s_t)\) — оценка среднего вознаграждения, которое можно получить из состояния \(s_t\) при текущей политике.

Как это реализуется в PPO:

  • Вместо прямого расчёта \(Q(s_t, a_t)\) и \(V(s_t)\), используется обобщённая оценка преимущества (GAE) :

    \[ A_t = \sum_{l=0}^{\infty} (\gamma \lambda)^l \delta_{t+l}, \quad \text{где } \delta_t = r_t + \gamma V(s_{t+1}) - V(s_t) \]

    Здесь \(\gamma\) — коэффициент дисконтирования, \(\lambda\) — параметр сглаживания.

  • Critic (критик) — отдельная нейросеть, которая обучается предсказывать \(V(s_t)\). Она обновляется параллельно с политикой и минимизирует ошибку между предсказанным и фактическим вознаграждением.

3. Отношение вероятностей (Probability Ratio)

  • Для каждого сэмпла вычисляется отношение вероятностей:
    \(r_t(\theta) = \frac{\pi_\theta(a_t | s_t)}{\pi_{\theta_{\text{old}}}(a_t | s_t)}\),
    где \(\pi_\theta\) — текущая политика (модель с обновляемыми весами), а \(\pi_{\theta_{\text{old}}}\) — политика на предыдущем шаге обучения. Это отношение показывает, насколько изменилась вероятность действия при обновлении параметров .

При этом надо сохранять данные вывода старой модели, чтобы оценить отношение вероятностей.

4. Функция потерь с ограничением (Clipped Surrogate Objective)

  • Основная идея PPO — ограничить изменения параметров, чтобы избежать резких скачков в политике. Для этого используется clipped surrogate loss:
    \(L^{CLIP}(\theta) = \mathbb{E}_t \left[ \min\left( r_t(\theta) \cdot A_t, \text{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon) \cdot A_t \right) \right]\),
    где \(\epsilon\) — гиперпараметр (например, 0.2), задающий диапазон допустимых изменений, а \(A_t\) — advantage.
    Если отношение \(r_t(\theta)\) выходит за пределы \([1-\epsilon, 1+\epsilon]\), оно обрезается (clipped), чтобы предотвратить большие обновления .

5. Оптимизация с градиентным спуском

  • Функция потерь \(L^{CLIP}\) минимизируется с помощью градиентного спуска (например, Adam optimizer). Градиенты вычисляются через обратное распространение ошибки (backpropagation), и веса модели обновляются на каждом слое, как в стандартных нейросетях .
    Обновление параметров происходит по формуле:
    \(\theta \leftarrow \theta - \alpha \nabla_\theta L^{CLIP}(\theta)\),
    где \(\alpha\) — скорость обучения.

6. Итерации и повторные оценки

  • Процесс повторяется для новых эпизодов (запросов), пока не будет достигнута сходимость. При этом важно сохранять баланс между скоростью обучения и стабильностью: слишком большие обновления могут ухудшить результат, а маленькие — замедлить обучение.

Ключевые особенности PPO

  • Clipping гарантирует, что обновления весов не превысят заданный порог, что снижает дисперсию и предотвращает сбои в обучении.
  • Многократное использование данных (multiple epochs): для одного набора сэмплов функция потерь может оптимизироваться несколько раз, но с ограничением на изменения параметров.

Сравним DPO и PPO как два полярных по сложности метода RL оптимизации LLM.

  • DPO напрямую использует данные предпочтений (например, пары «предпочтительный/непредпочтительный ответ») без необходимости обучения отдельной модели вознаграждения (reward model). Это упрощает процесс, так как DPO формирует целевую функцию, которая напрямую максимизирует вероятность предпочтительных ответов.
  • PPO же сначала обучает модель вознаграждения на тех же данных предпочтений, а затем использует её для оптимизации политики через RL-обучение. Это добавляет этапы обучения и вычислений.
  • DPO преобразует задачу RL в задачу обучения с учителем. Он сравнивает предпочтительные и непредпочтительные ответы, корректируя модель так, чтобы вероятность предпочтительных ответов увеличивалась, а непредпочтительных — снижалась. Это делает обучение более стабильным и простым в реализации.
  • PPO сохраняет парадигму RL: модель генерирует ответы, оценивает их с помощью reward model, рассчитывает advantage и обновляет политику через clipping и несколько эпох обучения.
  • DPO требует меньше ресурсов, так как работает с фиксированным набором данных предпочтений и не нуждается в генерации новых данных во время обучения. Это ускоряет процесс и снижает инженерные затраты.
  • PPO вычислительно дороже: на каждом шаге необходимо генерировать новые ответы для оценки advantage, что увеличивает нагрузку на вычислительные мощности.
  • DPO демонстрирует сопоставимую эффективность при меньших затратах, но может уступать PPO в сложных сценариях, где требуется глубокая оптимизация политики .
  • PPO часто достигает более высоких показателей награды и win rates (например, в задачах, где важно точное соответствие предпочтениям), но требует тонкой настройки гиперпараметров и стабильности обучения.
  • DPO проще, быстрее и дешевле, но менее гибок.
  • PPO мощнее и точнее, но сложнее в реализации и требует больше ресурсов .