Объяснение тонкой настройки GRPO: обучение локального LLM рассуждать

Модели, ориентированные на логическое мышление, такие как DeepSeek-R1, привлекли большое внимание, и теперь многие хотят, чтобы подобное поведение было и у небольших моделей, которые они сами запускают. Обычно за это приписывают технику тонкой настройки GRPO. Метод контролируемой тонкой настройки (SFT) учит модель имитировать шаблоны в примерах. Групповая относительная оптимизация политики (GRPO) использует метод обучения с подкреплением, чтобы направить модель к решениям, которые действительно работают, что ближе к обучению её мышлению, чем к формированию определенного стиля ответов.

В этой статье рассматривается место GRPO среди методов RLHF, что означают её пять основных параметров и как они превращаются в несколько десятков строк кода для обучения.

Место GRPO среди методов настройки по предпочтениям

RLHF, то есть обучение с усилением на основе обратной связи от людей, лучше всего рассматривать как общий термин. PPO, GRPO и DPO — это разные оптимизаторы, направленные на одну и ту же цель: приведение модели в соответствие с предпочтениями людей.

Для понимания может помочь аналогия с приготовлением блюд. RLHF — это процесс улучшения блюда путем дегустации и корректировок. PPO — это более старый, сложный способ приготовления, требующий второй модели (критика) и большого объема памяти GPU. GRPO — это более современный, простой способ, при котором не нужен критик, и память экономится за счет сравнения ответов друг с другом.

Цикл обучения с усилением

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

1. политика генерации, которая представляет собой модель, находящуюся в процессе обучения
2. референтная политика — исходная модель, оставленная без изменений
3. модель значений, которая оценивает среднюю награду

Модель награды оценивает результаты, а обучение направлено на повышение этой оценки.

PPO использует подход актор-критик, что означает обучение двух отдельных сетей. Актором является сама LLM. Критиком служит сеть значений примерно такого же размера, которая предсказывает награду, которую должен получить ответ. Наличие обеих сетей примерно вдвое увеличивает объем памяти, необходимый во время обучения.

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

DeepSeek представил метод GRPO в своей статье DeepSeekMath 2024 года, а позже этот метод был использован в модели DeepSeek-R1.

Пять основных элементов метода GRPO

Метод основан на пяти ключевых идеях. Для каждой из них ставится цель объяснить, что она измеряет и почему была спроектирована именно так.

1. Отношение стратегий: насколько изменилось мнение модели?

Это отношение сравнивает вероятность, которую даёт обновлённая модель тому или иному ответу, с вероятностью, которую давала предыдущая модель: новая вероятность ответа y для вводного запроса x делится на старую вероятность.

Если убрать символы, то вопрос сводится к тому, насколько сейчас модель склонна дать этот ответ больше или меньше, чем до данного шага обучения.

Представьте студента до и после ночи подготовки: некоторые ответы теперь кажутся более очевидными, а другие — менее. Отношение отражает эту смену уровня уверенности модели.

• Значение выше 1 означает, что модель более уверена в своем ответе, чем раньше.
• Значение ниже 1 означает, что уверенность снизилась, и модель отклоняется от этого ответа.
• Значение ровно 1 означает, что обновление никак не повлияло на этот ответ.

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

2. Средняя награда: каков средний балл этой группы ответов?

Среднее значение — это сумма наград для группы из G ответов, деленная на G. Z — это количество ответов, взятых для одного вопроса, причем каждый ответ получает оценку от модели наград.

Предположим, вы просите модель решить математическую задачу и получаете пять вариантов ответа с определённой случайностью. Один из них идеален (награда 1,0), другой частично верен (0,5), а третий совершенно неверен (0,0). Среднее значение показывает, насколько хорошо модель справляется с этой задачей в данный момент.

Именно роль, которую она играет, делает GRPO интересным подходом. Для PPO требовался критик — вторая сеть, задачей которой было предсказание ожидаемой награды, причём её обучение было дорогостоящим, требовало много памяти и подвержено ошибкам. GRPO же предлагает не предсказывать среднее значение, а просто взять группу ответов и вычислить среднее из реальных наград; таким образом получается базовый показатель бесплатно, без дополнительных сетей и лишней памяти. Именно это и означает «группа» в названии метода.

3. Стандартное отклонение: насколько распределены оценки?

Стандартное отклонение показывает, насколько каждое вознаграждение отстоит от среднего значения, вычисляя квадратный корень из среднеквадратичного расстояния. Если среднее значение описывает типичную производительность, то стандартное отклонение указывает на стабильность.

Высокое значение означает, что ответы крайне разнородны: некоторые отличные, а некоторые ужасные. Низкое значение означает, что модель каждый раз выдает ответы сопоставимого качества.

Рассмотрим двух студентов. У студента А оценки: 90, 10, 95, 5 и 88; среднее значение — 57,6 при очень большом диапазоне: крайне нестабильно. У студента Б оценки: 58, 56, 60, 57 и 59; среднее значение — 58 при очень малом диапазоне: стабильно посредственно.

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

4. Преимущество относительно группы: превзошла ли эта ответная стратегия остальные?

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

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

Представьте оценивание очень сложного экзамена, где средний балл по классу составляет 40 из 100. Ученик получил 60 баллов. Как абсолютная оценка это звучит посредственно, но относительно класса это на 20 баллов выше среднего, что является отличным результатом. Принцип преимущества работает аналогичным образом: игнорируются абсолютные значения наград, и оценивается, превзошел ли данный ответ то, что модель обычно генерирует для данного запроса.

Три свойства делают этот подход полезным.

1. Отсутствие критика. Преимущество PPO заключалось в том, что критик оценивал ожидаемую награду. GRPO заменяет этот способ предположений на эмпирическое среднее значение внутри группы.
2. Самокалибровка. Если модель оценки награды смещена и ставит все оценки слишком высоко или слишком низко, относительная формула устраняет это смещение. Важен только ранг внутри группы.
3. Стабильность. Благодаря нормализации скорость обучения адаптируется. Когда модель активно исследует пространство возможных решений, обновления происходят резко. По мере сближения к оптимуму они становятся более мягкими.

5. Штраф KL: оставайтесь узнаваемым собой

Это защитный тормоз. В то время как механизм GRPO побуждает модель искать ответы с высокой наградой, показатель KL действует в противоположном направлении, запрещая модели становиться кем-то другим. Он сравнивает текущую модель с замороженной эталонной моделью, которая обычно представляет собой базовую модель до начала работы с методом RL. Разность KL — это показатель степени отличия двух вероятностных распределений. Формула, приведенная в исходном тексте, — это часто используемая оценка по отдельным токенам, рассчитываемая на основе соотношения вероятностей эталонной и текущей моделей.

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

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

Модели наград несовершенны и могут быть обмануты. Модель без показателя KL может обнаружить, что начало диалога фразой «Дайте мне подумать по шагам» приносит дополнительную награду, даже если это ничего не добавляет. Ориентация на эталонные варианты способствует такого рода манипуляциям с наградами. На практике показатель KL включается в функцию потерь с небольшим весом, примерно от 0,01 до 0,04. Он предназначен не для того, чтобы остановить прогресс, а лишь для поддержания его сбалансированности.

Полное объяснение простыми словами

1. Сгенерировать группу ответов на один вопрос.
2. Оценить каждый ответ с помощью модели наград.
3. Рассчитать среднее значение и стандартное отклонение этих оценок.
4. Определить преимущество каждого ответа, то есть насколько он выше или ниже среднего значения.

Проверьте коэффициент политики, чтобы увидеть, насколько изменилась степень уверенности в каждом ответе.

Ограничьте крупные изменения, чтобы модель не сильно колебалась.

Накажите отклонения от эталона с помощью показателя KL.

Обновите модель так, чтобы она отдавала предпочтение ответам с высоким относительным преимуществом.

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

trainer.train()

Поскольку математическая часть рассмотрена, вот код, который применяет эти принципы на практике. Он использует Unsloth для загрузки 4-битной модели Llama 3.2 3B Instruct с поддержкой vLLM, применяет адаптеры LoRA, обязывает модель использовать определённый формат рассуждений с помощью системного промпта и создаёт набор данных для обучения из GSM8K. vLLM необходим, поскольку GRPO требует быстрого генерирования множества вариантов ответов на каждый промпт.

from unsloth import FastLanguageModel
from datasets import load_dataset
import re

# 1. Load 4-bit model with vLLM backend for fast group generation
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Llama-3.2-3B-Instruct",
    max_seq_length=1024,
    load_in_4bit=True,
    fast_inference=True,
    max_lora_rank=32,
    gpu_memory_utilization=0.6,
)

# 2. Attach LoRA adapters
model = FastLanguageModel.get_peft_model(
    model,
    r=32,
    target_modules=["q_proj","k_proj","v_proj","o_proj","gate_proj","up_proj","down_proj"],
    lora_alpha=64,
    use_gradient_checkpointing="unsloth",
)

# 3. Enforcing reasoning format - GRPO needs structure to reward
SYSTEM_PROMPT = "Respond in the following format:\n<reasoning>\n...\n</reasoning>\n<answer>\n...\n</answer>"

# 4. Load GSM8K and wrap prompts
dataset = load_dataset("openai/gsm8k", "main")["train"]
dataset = dataset.map(lambda x: {
    "prompt": [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": x["question"]}
    ],
    "answer": x["answer"].split("####")[1].strip()
})
#vLLM is used in GRPO because GRPO requires the AI to generate a ma

Функции награды

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

1. correctness_reward — основной сигнал. Он извлекает текст внутри тегов ответа и присваивает значение 2.0 при совпадении с эталонным решением, в противном случае — 0.0. Вес этой функции выбран достаточно большим, чтобы правильный ответ всегда имел приоритет перед аккуратным форматированием.
2. int_reward служит запасным механизмом. На ранних этапах обучения почти всё ошибочно, поэтому эта функция присваивает 0.5 за просто вывод любого допустимого числа, что поддерживает наличие сигналов для обучения до тех пор, пока модель не начнёт решать задачи.

soft_format_reward и strict_format_reward начисляют по 0,5 за структуру тегов «рассуждение-затем-ответ». Параметр soft_format_reward терпим к отклонениям в форматировании, тогда как strict_format_reward требует точного расположения элементов. Вместе они помогают превратить беспорядочный вывод в аккуратный.

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

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

def extract_xml_answer(text: str) -> str:
    return text.split("<answer>")[-1].split("</answer>")[0].strip()

# Primary signal: is the final answer correct?
def correctness_reward(prompts, completions, answer, **kwargs):
    responses = [c[0]["content"] for c in completions]
    extracted = [extract_xml_answer(r) for r in responses]
    return [2.0 if r == a else 0.0 for r, a in zip(extracted, answer)]

# Dense shaping rewards - keep learning signal alive even when answers are wrong
def int_reward(completions, **kwargs):
    return [0.5 if extract_xml_answer(c[0]["content"]).isdigit() else 0.0 for c in completions]

def strict_format_reward(completions, **kwargs):
    pattern = r"^<reasoning>\n.*?\n</reasoning>\n<answer>\n.*?\n</answer>\nquot;
    return [0.5 if re.match(pattern, c[0]["content"]) else 0.0 for c in completions]

def soft_format_reward(completions, **kwargs):
    pattern = r"<reasoning>.*?</reasoning>\s*<answer>.*?</answer>"
    return [0.5 if re.match(pattern, c[0]["content"]) else 0.0 for c in completions]

def xmlcount_reward(completions, **kwargs):
    def score(text):
        count = 0.0
        if text.count("<reasoning>\n") == 1: count += 0.125
        if text.count("\n</reasoning>\n") == 1: count += 0.125
        if text.count("\n<answer>\n") == 1:
            count += 0.125
            count -= len(text.split("\n</answer>\n")[-1]) * 0.001
        if text.count("\n</answer>") == 1:
            count += 0.125
            count -= (len(text.split("\n</answer>")[-1]) - 1) * 0.001
        return count
    return [score(c[0]["content"]) for c in completions]pyt

Тренер

from trl import GRPOConfig, GRPOTrainer

trainer = GRPOTrainer(
    model=model,
    processing_class=tokenizer,
    reward_funcs=[
        xmlcount_reward,      # tag quality
        soft_format_reward,   # structure (forgiving)
        strict_format_reward, # structure (exact)
        int_reward,           # partial credit
        correctness_reward,   # ground-truth match
    ],
    args=GRPOConfig(
        learning_rate=5e-6,
        per_device_train_batch_size=1,
        gradient_accumulation_steps=1,
        num_generations=8,          # G = group size
        max_prompt_length=256,
        max_completion_length=200,
        max_steps=250,
        warmup_ratio=0.1,
        max_grad_norm=0.1,
        output_dir="outputs",
    ),
    train_dataset=dataset,
)

trainer.train()

На каждом шаге GRPOTrainer выполняет пять описанных выше вычислений.

Почему DPO сталкивается с трудностями в рассуждениях

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

Однако рассуждения на самом деле не являются проблемой предпочтений — это проблема поиска.

Предположим, вы хотите, чтобы модель доказала теорему геометрии. DPO нуждается в человеке или более сильной модели, которая определит, какое из двух доказательств лучше. Что делать, если оба неверны? А что, если правильное доказательство требует 12 шагов и никогда не выбиралось в качестве примера? DPO может учиться только на предоставленных парах данных и не способен разработать новую стратегию рассуждений.

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

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

Заключительные мысли

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