TRL documentation
Индекс статей
Индекс статей
Каждая статья ниже содержит ссылку на её страницу на Hugging Face. Также любую из них можно прочитать из терминала с помощью CLI
hf, напримерhf papers read 2402.03300— это особенно удобно для кодинг-агентов.
Групповая относительная оптимизация политики
Статьи, связанные с GRPOTrainer.
DeepSeekMath: Пределы математического рассуждения в открытых языковых моделях
📜 Статья: https://huggingface.co/papers/2402.03300
Представляет Group Relative Policy Optimization (GRPO) и демонстрирует значительный прирост в математическом рассуждении благодаря предобучению с акцентом на математику и оптимизации в стиле PPO с групповым относительным подходом. Используется в TRL через GRPOTrainer.
from trl import GRPOConfig, GRPOTrainer
# The paper doesn't specify its hyperparameters, so here we provide hyperparameters from "DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning" instead.
training_args = GRPOConfig(
loss_type="grpo",
beta=0.001, # "the KL coefficient to 0.001"
epsilon=10.0, # "the GRPO clip ratio ϵ to 10"
num_generations=16, # "For each question, we sample 16 outputs..."
max_completion_length=32_768, # "...with a maximum length of 32,768"
steps_per_generation=16, # "To accelerate training, each rollout generates 8,192 outputs, which are randomly split into 16 minibatches"
# "resulting in a training batch size of 512". One way to achieve this setting with 1 device is per_device_train_batch_size=4, gradient_accumulation_steps=128
per_device_train_batch_size=4,
gradient_accumulation_steps=128,
)
trainer = GRPOTrainer(
...,
args=training_args,
)DeepSeek-R1: Стимулирование способности к рассуждению в LLM с помощью обучения с подкреплением
📜 Статья: https://huggingface.co/papers/2501.12948
DeepSeek-R1 достигает уровня рассуждений, сопоставимого с OpenAI-o1, благодаря многоэтапному конвейеру, который переходит от чистого обучения с подкреплением (RL) к отточенной модели, выровненной по человеческим предпочтениям. В отличие от предшественника, DeepSeek-R1-Zero, который использовал чистое RL на базовой модели, R1 следует структурированной эволюции из четырех этапов:
- Холодный старт: базовая модель дообучается на небольшом наборе высококачественных длинных данных Chain-of-Thought (CoT), чтобы обеспечить стабильную отправную точку.
- RL с акцентом на рассуждения: крупномасштабное RL применяется для повышения производительности в математике, программировании и логике, используя правила-наградные функции и награду за языковую согласованность для снижения смешения языков.
- Rejection Sampling & SFT: контрольная точка RL генерирует 600 тыс. образцов рассуждений с помощью rejection sampling, которые объединяются с 200 тыс. образцов без рассуждений (общего назначения) для создания нового набора данных для второго раунда Supervised Fine-Tuning.
- RL для всех сценариев: финальный этап RL настраивает модель на предпочтения человека (полезность и безопасность) во всех областях, сохраняя при этом сильные стороны рассуждений.
Дистилляция: расширение возможностей малых моделей
Ключевым вкладом статьи является демонстрация того, что паттерны рассуждений можно дистиллировать из большой модели (DeepSeek-R1) в более мелкие плотные модели (например, серии Qwen и Llama). Было обнаружено, что дистилляция оказывается более эффективной для малых моделей, чем их обучение с нуля с использованием чистого RL.
Вы можете использовать GRPOTrainer для воспроизведения этапов этого конвейера, требующих интенсивного рассуждения.
from trl import GRPOConfig, GRPOTrainer
# Example configuration for a reasoning-oriented GRPO stage
# Based on the Open-R1 recipe for Qwen-7B
training_args = GRPOConfig(
learning_rate=4.0e-5,
max_completion_length=32768, # Support for long Chain-of-Thought
num_generations=16, # Sample 16 outputs per prompt for group relative advantage
beta=0.001, # KL coefficient
use_vllm=True, # Use vLLM backend for accelerated rollout generation
)
trainer = GRPOTrainer(
model=model,
args=training_args,
train_dataset=dataset,
reward_funcs=[accuracy_reward, format_reward], # R1-Zero used rule-based rewards
)
trainer.train()Оптимизация групповой последовательной политики
📜 Статья: https://huggingface.co/papers/2507.18071
GSPO — это вариант GRPO, который вычисляет веса importance sampling на уровне последовательности, а не для каждого токена. Чтобы воспроизвести настройки из статьи, используйте следующую конфигурацию:
from trl import GRPOConfig
training_args = GRPOConfig(
importance_sampling_level="sequence",
loss_type="grpo",
beta=0.0, # GSPO set KL regularization to zero: https://github.com/volcengine/verl/pull/2775#issuecomment-3131807306
epsilon=3e-4, # GSPO paper (v2), section 5.1
epsilon_high=4e-4, # GSPO paper (v2), section 5.1
gradient_accumulation_steps=1,
steps_per_generation=4, # partition rollout batch into 4 mini-batches. GSPO paper (v2), section 5.1. Must be 4 times gradient_accumulation_steps
)Обратите внимание, что этот метод оказывает влияние только в том случае, если обучение слегка отклоняется от политики (off-policy) — например, когда steps_per_generation > gradient_accumulation_steps или num_iterations > 1. В противном случае он фактически эквивалентен отсутствию модификации.
TRL поставляла экспериментальную реализацию GSPO-token до версии v1.13; она больше не входит в состав библиотеки и остаётся доступной в истории git. Она отличалась от описанной выше цели на уровне последовательности только в том случае, если преимущество изменяется в зависимости от , что TRL в настоящее время не генерирует.
Соотношение политик: GRPO и GSPO
В GSPO отношение политик определяется на уровне последовательности. Иными словами, это отношение вероятности генерации данной последовательности текущей политикой к вероятности генерации той же последовательности старой политикой.
Вероятность последовательности определяется как:
где — политика с параметрами , — --я выходная последовательность а — --й токен в этой последовательности, — входной запрос. Соотношение вероятностей последовательности определяется следующим образом:
Показатель степени представляет собой нормализацию по длине последовательности, минимизирующую влияние длины последовательности на её вероятность. Иными словами, вычисляется среднее геометрическое вероятностей токенов, что обеспечивает справедливое сравнение последовательностей разной длины.
Хотя GSPO определяет отношение политик на уровне последовательности, GRPO работает на уровне токенов. Конкретно, GRPO вычисляет отношение важности для каждого токена в последовательности:
Затем это токенное отношение объединяется с общим преимуществом , и цель GRPO обрезает и оптимизирует каждый токен независимо в пределах последовательности.
Оптимизация политики по среднему геометрическому
📜 Статья: https://huggingface.co/papers/2507.20673
Оптимизация политики по среднему геометрическому (GMPO) — это вариант GRPO, который максимизирует среднее геометрическое отношений важности на уровне токенов, а не среднее арифметическое. Среднее геометрическое гораздо менее чувствительно к выбросам в отношениях, поэтому обновление политики более стабильно и допускает значительно более широкий диапазон обрезания. Обрезание применяется для каждого токена в логарифмическом пространстве и является односторонним в соответствии со знаком преимущества (стандартная область доверия PPO) — при этом оно выполняется до вычисления среднего геометрического. Именно это отличает GMPO от GSPO (importance_sampling_level="sequence"), где обрезание отношения на уровне последовательности выполняется после усреднения.
Целевая функция GMPO заменяет посимвольное арифметическое среднее в GRPO на геометрическое средние (обрезанных) отношений токенов:
где — отношение важности для каждого токена. На практике произведение и обрезание вычисляются в логарифмическом пространстве для численной стабильности, а диапазон обрезания значительно шире, чем в GRPO/DAPO, чтобы поощрять исследование.
TRL предоставляет экспериментальную реализацию, см. Экспериментально - GMPO:
from trl.experimental.gmpo import GMPOConfig, GMPOTrainer
training_args = GMPOConfig(
epsilon=0.4, # log-space clip range -> ratios clipped to (exp(-0.4), exp(0.4)); paper, Sec. 4
beta=0.0,
)DAPO: открытая система обучения с подкреплением для LLM в масштабе
📜 Статья: https://huggingface.co/papers/2503.14476
Алгоритм DAPO включает 5 ключевых компонентов:
- Фильтрация слишком длинных
- Clip-Higher
- Мягкое наказание за чрезмерно длинные ответы
- Потери на уровне токенов
- Динамическая выборка (⚠️ Не поддерживается в TRL)
Чтобы воспроизвести условия из статьи, используйте эту конфигурацию:
from trl import GRPOConfig, GRPOTrainer
training_args = GRPOConfig(
# Overlong Filtering
mask_truncated_completions=True,
# Token-level Loss
loss_type="dapo",
# Clip-Higher
epsilon_high=0.28, # DAPO paper: section 4.1
epsilon=0.2, # DAPO paper: section 4.1
# Other parameters used
per_device_train_batch_size=512, # mini-batch size for training in the paper, DAPO paper: section 4.1
num_generations=16, # number of sample responses in the paper, DAPO paper: section 4.1
max_completion_length=20480, # maximum number of tokens for generation in the paper, DAPO paper: section 4.1
beta=0.0, # section 2.3, DAPO paper
)
# Soft Overlong Punishment
sop_reward = get_soft_overlong_punishment(max_completion_len=20480, soft_punish_cache=4096) # DAPO paper: section 4.1
trainer = GRPOTrainer(
...,
args=training_args,
reward_funcs=[..., sop_reward],
)Разгадка длинного цепочного рассуждения в LLM
📜 Статья: https://huggingface.co/papers/2502.03373
В данной статье рассматривается RL с длинными цепочками рассуждений (chain-of-thought) и вводятся два взаимодополняющих правила-наград (rule-based rewards):
- Косинусная награда с масштабированием по длине (get_cosine_scaled_reward(), Приложение C.1), которая масштабирует награду за правильность в зависимости от длины завершения: правильное завершение получает более высокую награду, если оно короче, а неправильное завершение получает меньшее наказание, если оно длиннее (что сохраняет разведку).
- Штраф за повторение n-грамм (get_repetition_penalty_reward(), Приложение C.2), который подавляет дегенеративные, повторяющиеся завершения, возникающие как стратегия обмана вознаграждения при формировании длины.
Они разработаны для совместного использования:
from trl import GRPOTrainer
from trl.rewards import get_cosine_scaled_reward, get_repetition_penalty_reward
# max_len should match the generation budget (in tokens)
cosine_scaled_reward = get_cosine_scaled_reward(max_len=4096)
# Penalize repeated 3-grams, down to -1.0 for fully repetitive completions
repetition_penalty = get_repetition_penalty_reward(ngram_size=3, max_penalty=-1.0)
trainer = GRPOTrainer(
...,
reward_funcs=[cosine_scaled_reward, repetition_penalty],
)INTELLECT-2: модель рассуждений, обученная с помощью глобально децентрализованного обучения с подкреплением
📜 Статья: https://huggingface.co/papers/2505.07291
INTELLECT-2 — это первый глобально распределённый прогон обучения с подкреплением языковой модели на 32 миллиарда параметров, использующий полностью асинхронное RL на динамическом гетерогенном рое безлимитных участников, предоставляющих вычислительные мощности. Авторы предлагают модификации стандартного рецепта обучения GRPO, включая двустороннее обрезание GRPO для повышения стабильности обучения. Чтобы воспроизвести настройки из статьи, используйте эту конфигурацию:
from trl import GRPOConfig
training_args = GRPOConfig(
delta=4, # δ in section 4.1 of the paper
epsilon=0.2, # ε in section 4.1 of the paper
beta=0.001, # KL divergence coefficient in section 4.1 of the paper
num_generations=16, # responses per prompt in section 4.1 of the paper
learning_rate=3e-7, # section 4.1 of the paper
)Skywork-OR1: открытые модели рассуждений
📜 Статья: https://huggingface.co/papers/2505.22312
Skywork-OR1 — это семейство открытых моделей рассуждений, обученных с помощью GRPO. В статье вводится адаптивное управление энтропией: к целевой функции GRPO добавляется член регуляризации энтропии −α·H(π_θ), а коэффициент α автоматически корректируется на каждом шаге оптимизатора. Если средняя энтропия модели на токен опускается до целевого значения или ниже, α увеличивается, чтобы стимулировать большее исследование; в противном случае он уменьшается. Бонус применяется только тогда, когда энтропия находится на уровне целевого значения или ниже. Для воспроизведения этого адаптивного управления энтропией используйте следующую конфигурацию:
from trl import GRPOConfig, GRPOTrainer
training_args = GRPOConfig(
use_adaptive_entropy=True, # enable adaptive entropy control (Section 3.3 of the paper)
entropy_coef=0.01, # initial entropy regularization coefficient
entropy_target=5.0, # target mean per-token entropy (nats); tune for your model
entropy_coef_delta=0.005, # step size for coefficient updates per optimizer step
)
trainer = GRPOTrainer(
...,
args=training_args,
)Помимо правила 80/20: высокоэнтропийные токены меньшинства обеспечивают эффективное обучение с подкреплением для рассуждений LLM
📜 Статья: https://huggingface.co/papers/2506.01939
Небольшая доля токенов с высокой энтропией выступает в роли «развилки» рассуждений в цепочке рассуждений (CoT), стимулируя исследование и повышение производительности для RLVR, тогда как большинство токенов с низкой энтропией вносят малый вклад или даже препятствуют обучению. RLVR в основном корректирует токены с высокой энтропией, в значительной степени сохраняя общие паттерны энтропии базовой модели. Таким образом, следуя правилу 80/20, обучение только на 20% токенов с наивысшей энтропией сопоставимо с полными обновлениями градиента или превосходит их для моделей Qwen3.
Основные результаты статьи используют vanilla DAPO (⚠️ Dynamic Sampling не поддерживается в TRL). Чтобы воспроизвести основные результаты, используйте следующую конфигурацию:
from trl import GRPOConfig, GRPOTrainer
from trl.rewards import get_soft_overlong_punishment
training_args = GRPOConfig(
# --- vanilla DAPO parameters (80/20 rule: section 5.2) --- #
# Overlong Filtering
mask_truncated_completions=True,
# Token-level Loss
loss_type="dapo",
# Clip-Higher
epsilon_high=0.28, # DAPO paper: section 4.1
epsilon=0.2, # DAPO paper: section 4.1
# Other parameters used
per_device_train_batch_size=512, # mini-batch size for training in the paper, DAPO paper: section 4.1
num_generations=16, # number of sample responses in the paper, DAPO paper: section 4.1
max_completion_length=20480, # maximum number of tokens for generation in the paper, DAPO paper: section 4.1
beta=0.0, # section 2.3, DAPO paper
# --- Gradients on the highest entropy tokens --- #
top_entropy_quantile=0.2
)
# Soft Overlong Punishment
sop_reward = get_soft_overlong_punishment(max_completion_len=20480, soft_punish_cache=4096) # DAPO paper: section 4.1
trainer = GRPOTrainer(
...,
args=training_args,
reward_funcs=[..., sop_reward],
)Dr. GRPO: Понимание обучения, похожего на R1-Zero: критический взгляд
📜 Статья: https://huggingface.co/papers/2503.20783
Исследование обучения R1-Zero выявляет влияние предобучения на результаты RL и предлагает Dr. GRPO для повышения эффективности токенов, что обеспечивает более высокую точность на AIME 2024. Для воспроизведения настроек из статьи используйте следующую конфигурацию:
from trl import GRPOConfig
training_args = GRPOConfig(
loss_type="dr_grpo",
per_device_train_batch_size=1, # train_batch_size_per_device in the Training section of the repository
num_generations=8, # num_samples in the Training section of the repository
max_completion_length=3000, # generate_max_length in the Training section of the repository
beta=0.0, # β in the Training section of the repository
)Часть I: Хитрости или ловушки? Глубокий анализ RL для рассуждений LLM (Lite PPO)
📜 Статья: https://huggingface.co/papers/2508.08221
Авторы данной статьи обнаруживают, что комбинация:
- масштабирование вознаграждений с использованием стандартного отклонения, вычисленного по всей выборке, и
- суммирование потерь по общему числу токенов
позволяет раскрыть потенциал обучения политик без критика с использованием стандартной функции потерь PPO. Их результаты показывают, что это простое сочетание последовательно улучшает производительность, превосходя такие стратегии, как GRPO и DAPO.
TRL поддерживает использование этих результатов для обучения модели GRPO следующим образом:
from trl import GRPOConfig
training_args = GRPOConfig(
...
scale_rewards="batch",
loss_type="dapo",
# Other parameters used
beta=0.0, # = init_kl_coef in the paper
top_p=0.99,
top_k=100,
temperature=0.99,
num_generations=8, # = num_return_sequences in the paper
num_iterations=1, # = ppo_epochs in the paper
per_device_train_batch_size=4,
gradient_accumulation_steps=32,
steps_per_generation=8, # (rollout_batch_size*num_return_sequences) / (per_device_train_batch_size*gradient_accumulation_steps)
)Обратите внимание, что при использовании накопления градиентов (gradient accumulation) потеря агрегируется по общему числу токенов в батче, а не по накопленному батчу. Подробнее см. в разделе GRPO Trainer - Loss types.
Трuncated Importance Sampling
📰 Блог: https://fengyao.notion.site/off-policy-rl
📜 Статья: https://huggingface.co/papers/1606.02647
Методы обучения политики в режиме онлайн обычно используют оптимизированный фреймворк для генерации rollout (например, vLLM), который отделён от бэкенда обучения. Это приводит к рассогласованию между rollout и обучением, что наглядно демонстрируется в следующей целевой функции PPO:
Несмотря на то, что и используют одни и те же параметры модели , они могут генерировать существенно различные вероятности токенов. Это неожиданное поведение неявно нарушает предположение об on-policy и незаметно переводит обучение в off-policy режим.
Метод усечённого importance sampling (TIS) решает эту проблему, адаптируя обновление модели с помощью коррекции importance sampling. Вычисление градиента для упомянутой выше цели PPO принимает вид
где и являются гиперпараметрами. TIS реализован в GRPO и активируется при выборе варианта vllm_importance_sampling_mode , содержащего термин truncate, например "sequence_truncate" или "token_truncate".
from trl import GRPOConfig
training_args = GRPOConfig(
...
use_vllm=True,
vllm_importance_sampling_correction=True, # default True
vllm_importance_sampling_mode="sequence_truncate", # or "token_truncate"
vllm_importance_sampling_clip_max=2.0, # hyper-parameter C_max
)Маскированное выборное сэмплирование
📰 Блог: https://ringtech.notion.site/icepop
📜 Статья: https://huggingface.co/papers/2510.18855
Маскированное Importance Sampling (MIS) решает ту же проблему, что и Truncated Importance Sampling но заменяет обрезание на маскирование. MIS занимает более решительную позицию, отбрасывая обновления, расхождение которых выходит за пределы диапазона .
MIS реализован для GRPO и активируется при выборе варианта vllm_importance_sampling_mode, содержащего термин "mask", например "sequence_mask" или "token_mask".
from trl import GRPOConfig
training_args = GRPOConfig(
...
use_vllm=True,
vllm_importance_sampling_correction=True, # default True
vllm_importance_sampling_mode="sequence_mask", # or "token_mask"
vllm_importance_sampling_clip_max=2.0, # hyper-parameter C_max
vllm_importance_sampling_clip_min=0.5, # hyper-parameter C_min
)В AsyncGRPOTrainer, старые лог-вероятности принадлежат сэмплеру, поэтому отношение вычисляется непосредственно между обучаемой политикой и сэмплером, а токены вне диапазона исключаются из функции потерь. Эта опция включена по умолчанию:
from trl import AsyncGRPOConfig
training_args = AsyncGRPOConfig(
...,
vllm_importance_sampling_clip_min=0.5, # hyper-parameter C_min
vllm_importance_sampling_clip_max=5.0, # hyper-parameter C_max
)Важность выборки на уровне последовательности
Теоретически обоснованным способом коррекции смещения распределения между этапами обучения и инференса является importance sampling, как описано в двух упомянутых выше статьях Truncated Importance Sampling и Masked Importance Sampling. Однако выбор формулировки имеет решающее значение для сохранения не смещённости градиента и обеспечения стабильного обучения.
Эта работа показывает, что importance sampling на уровне последовательности — это корректный подход для решения проблемы рассогласования между обучением и инференсом. Хотя importance sampling на уровне токенов обеспечивает меньшую дисперсию, чем отношение на уровне последовательности, он вносит смещение и, следовательно, считается непригодным для авторегрессионных моделей. Оценщик градиента на уровне токенов: Правильный, несмещённый оценщик градиента политики применяет единое отношение важности ко всей сгенерированной последовательности (траектории) , Оценщик Sequence-Level IS выглядит так:
TRL предоставляет уровень гранулярности Importance Sampling через параметр конфигурации vllm_importance_sampling_mode, где режимы "sequence_*" реализуют коэффициент Importance Sampling на уровне последовательности, а "token_*" — на уровне токена.
Искусство масштабирования обучения с подкреплением
📜 Статья: https://huggingface.co/papers/2510.13786
Систематическое исследование, в котором определяется фреймворк для анализа и прогнозирования масштабирования обучения с подкреплением в больших языковых моделях, выявляются ключевые проектные решения, влияющие на эффективность использования вычислительных ресурсов, и предлагается рецепт лучших практик под названием ScaleRL.
Вы можете частично воспроизвести рецепт ScaleRL, используя GRPOTrainer со следующими конфигурациями:
from trl import GRPOConfig
training_args = GRPOConfig(
loss_type="cispo",
epsilon_high=5.0,
num_generations=16,
scale_rewards="batch",
cast_lm_head_to_fp32=True
)Двое против всех: ваш GRPO — это, по сути, DPO
📜 Статья: https://huggingface.co/papers/2510.00977
Показывает, что эффективность GRPO обусловлена неявной контрастивной целью, а не точной оценкой преимущества за счёт больших размеров групп. Это устанавливает формальную связь между GRPO и DPO, где размер группы влияет только на оценки Монте-Карло для контрастивной цели. Авторы вводят 2-GRPO — с использованием всего двух прогонов, — который демонстрирует производительность, сопоставимую с 16-GRPO, при значительно меньших затратах на обучение. Используется в TRL через GRPOTrainer с num_generations=2. Чтобы воспроизвести настройки из статьи, используйте следующую конфигурацию:
from trl import GRPOConfig, GRPOTrainer
training_args = GRPOConfig(
num_generations=2, # minimal two-rollout case (2-GRPO) from the paper
loss_type="grpo",
)
trainer = GRPOTrainer(
...,
args=training_args,
)Мягкая адаптивная оптимизация политики
📜 Статья: https://huggingface.co/papers/2511.20347
Метод Soft Adaptive Policy Optimization (SAPO) заменяет жёсткое обрезание (hard clipping) на плавный, управляемый температурой механизм, который адаптивно ослабляет обновления вне политики (off-policy), сохраняя при этом полезные сигналы обучения. В отличие от GSPO и GRPO, SAPO обеспечивает как согласованность на уровне последовательности, так и адаптивность на уровне токенов. Как и GSPO, SAPO поддерживает согласованность на уровне последовательности, однако его мягкое управление формирует непрерывную область доверия, что позволяет избежать хрупкой полосы жёсткого обрезания, используемой в GSPO.
Чтобы воспроизвести условия из статьи, используйте эту конфигурацию:
from trl import GRPOConfig
training_args = GRPOConfig(
loss_type="sapo",
sapo_temperature_pos=1.0, # default value
sapo_temperature_neg=1.05, # default value
scale_rewards="group",
...
)DeepSeek-V3.2: Новые рубежи открытых больших языковых моделей
📜 Статья: https://huggingface.co/papers/2512.02556
Технический отчёт DeepSeek-V3.2 представляет несколько методов для повышения производительности GRPO. В TRL мы реализовали:
- Оценка Unbiased KL Estimate, которая корректирует оценщик K3 (используемый в исходной реализации GRPO) для получения несмещённой оценки KL с помощью отношения важности между текущей политикой и политикой поведения .
Эта функция включена по умолчанию (use_bias_correction_kl=True в GRPOConfig), поэтому вам нужно только установить beta > 0:
from trl import GRPOConfig
training_args = GRPOConfig(
...,
beta=0.001, # the paper doesn't specify the value used, so we use the value from "DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning"
)- Маскировка вне политики (Off-Policy Masking), которая стабилизирует обучение, игнорируя последовательности, в которых политика показывает низкие результаты (отрицательное преимущество) и значительно отклонилась от старой политики (высокое расхождение KL).
Двоичная маска off-policy определяется следующим образом:
Затем эта маска применяется к функции потерь GRPO следующим образом:
Чтобы включить эту функцию, используйте off_policy_mask_threshold (соответствующий ) в GRPOConfig:
from trl import GRPOConfig
training_args = GRPOConfig(
...,
off_policy_mask_threshold=0.5,
)Хотя в статье не указано значение , хорошей отправной точкой может служить . Если обучение кажется слишком консервативным или маскируется слишком много последовательностей, можно увеличить значение. Для справки, соответствует среднему расхождению логарифмического отношения 1 нат на токен, то есть на последовательностях, где этот порог превышен, старая политика в среднем была раз более вероятна в генерации этих токенов, чем текущая политика.
- Стратегия Keep Sampling Mask , которая сохраняет беспристрастность выборки top-k/top-p. Сэмплер извлекает каждый токен из усечённой области определения , то есть из токенов, оставшихся после усечения, поэтому лог-вероятность политики нормируется заново на этой же области определения:
Без этого отношение важности смещено в сторону занижения, и градиент продолжает переносить вероятность на токены, которые сэмплер никогда не выбирает, что приводит к срыву обучения. Это поддерживается в AsyncGRPOTrainer: при top_p < 1.0, top_k > 0 или min_p > 0.0 воркер rollout записывает поддержку каждого токена из vLLM (>= 0.28, начиная с --return-sampling-mask --enable-scale-out), а тренер перенормирует по ней:
from trl import AsyncGRPOConfig
training_args = AsyncGRPOConfig(
...,
top_p=0.95,
top_k=512,
)Также поддерживается в GRPOTrainer с vLLM в режиме colocate (>= 0.28): при top_k > 0 и включённой коррекции importance sampling (по умолчанию) vLLM возвращает поддержку для каждого токена, а trainer перенормирует по ней:
from trl import GRPOConfig
training_args = GRPOConfig(
...,
use_vllm=True,
top_p=0.95,
top_k=512,
)GDPO: Group reward-Decoupled Normalization Policy Optimization для оптимизации RL с несколькими наградами
📜 Статья: https://huggingface.co/papers/2601.05242
GDPO — это метод оптимизации с подкреплением, разработанный для обучения с несколькими наградами. Хотя существующие подходы обычно применяют Group Relative Policy Optimization (GRPO) в сценариях с несколькими наградами, авторы показывают, что это приводит к коллапсу преимуществ наград, что снижает разрешение сигнала обучения и вызывает нестабильную или неудачную сходимость. GDPO решает эту проблему, разделяя нормализацию наград для каждой отдельной награды, сохраняя их относительные различия и обеспечивая более точную оптимизацию предпочтений. Чтобы включить GDPO для обучения с подкреплением с несколькими наградами, просто установите:
Для группы из наград и выборок на группу GDPO нормализует каждую награду независимо:
Затем нормализованное групповое преимущество агрегируется по наградам:
Итоговая нормализация по батчу даёт:
Здесь и обозначают статистику по всем группам в батче.
from trl import GRPOConfig
training_args = GRPOConfig(
...,
multi_objective_aggregation="normalize_then_sum",
)Обратите внимание, что этот метод оказывает влияние только в том случае, если обучение включает более одной функции вознаграждения.
Авторы предоставляют простой в использовании пример обучения без slurm, который позволяет сообществу быстро проверить эффективность GDPO по сравнению с GRPO, см. Эксперимент — «Ага»-момент.
Оптимизация политики последовательности без смещения по длине: выявление и контроль вариаций длины ответа в RLVR
📜 Статья: https://huggingface.co/papers/2602.05261
Метод Length-Unbiased Sequence Policy Optimization (LUSPO) модифицирует GSPO, масштабируя потерю каждой последовательности по её длине. Это устраняет смещение градиента в GSPO, которое наказывает более длинные ответы. Чтобы воспроизвести настройки из статьи, используйте следующую конфигурацию:
from trl import GRPOConfig
training_args = GRPOConfig(
loss_type="luspo",
importance_sampling_level="sequence",
epsilon=2e-3, # section 5.1 of the paper
epsilon_high=2.5e-3, # section 5.1 of the paper
)VESPO: вариационная оптимизация мягкой политики на уровне последовательности для стабильного обучения LLM с использованием off-policy
📜 Статья: https://huggingface.co/papers/2602.10693
VESPO решает проблему нестабильности обучения в off-policy RL, вызванную устареванием политики, асинхронными обновлениями и рассогласованием между обучением и инференсом. Вместо использования эвристического обрезания на уровне токенов (GRPO) или нормализации по длине последовательности (GSPO), VESPO выводит обоснованное ядро преобразования из вариационного подхода. На практике это приводит к гладкой, асимметричной функции взвешивания Gamma, которая плавно подавляет экстремальные веса важности на уровне последовательности, не внося смещения по длине.
где — отношение важности на уровне последовательности, а отсоединяется от графа вычислений и служит коэффициентом масштабирования градиента.
from trl import GRPOConfig
training_args = GRPOConfig(
loss_type="vespo",
use_vllm=True, # or False if not using any token-level `vllm_importance_sampling_correction` methods
vllm_importance_sampling_mode="token_truncate", # default correction mode for VESPO, `token_mask` also supported
vespo_k_pos=2.0, # power exponent (c1 in paper Section 3.4) for positive advantages
vespo_lambda_pos=3.0, # decay factor (c2 in paper Section 3.4) for positive advantages
vespo_k_neg=3.0, # power exponent (c1 in paper Section 3.4) for negative advantages
vespo_lambda_neg=2.0, # decay factor (c2 in paper Section 3.4) for negative advantages
)Центрирование оценок стабилизирует обучение с подкреплением вне политики
📜 Статья: https://huggingface.co/papers/2609.20807
При рассогласовании между обучением и инференсом оценка в среднем равна нулю при сэмплере , поэтому каждое обновление смещает политику в сторону сэмплера, причём величина смещения растёт вместе с преимуществом. Центрирование оценки вычитает это математическое ожидание на каждой позиции, так что постоянное преимущество больше не сдвигает политику:
с весом важности Masked Importance Sampling: внутри и снаружи. Внутреннее математическое ожидание берется по наиболее вероятным токенам сэмплера на каждой позиции, для которых он сообщает лог-вероятности; для остальной части словаря сэмплер рассматривается как обученная политика, перенормированная на оставшуюся массу.
Это целевая функция по умолчанию для AsyncGRPOTrainer, чей рабочий процесс rollout запрашивает у vLLM верхние лог-вероятности каждого сгенерированного токена:
from trl import AsyncGRPOConfig
training_args = AsyncGRPOConfig(
...,
score_centering=True, # default; `False` trains with the clipped objective instead
vllm_importance_sampling_clip_min=0.5, # hyper-parameter C_min
vllm_importance_sampling_clip_max=5.0, # hyper-parameter C_max
num_sampler_logprobs=8, # tokens per position the expectation is taken over
)Оптимальная регрессия преимущества
Статьи, связанные с experimental.a2po.A2POTrainer.
Ускорение RL для рассуждений LLM с помощью оптимальной регрессии преимущества
📜 Статья: https://huggingface.co/papers/2505.20686
A*-PO (Optimal Advantage Regression) — это двухэтапный метод RL для рассуждений LLM, который обходит необходимость в онлайн-критике и многократных групповых роллаутах. На первом этапе оптимальная ценность V*(x) = β·log E_{y∼π_ref}[exp(r(x, y)/β)] оценивается офлайн по выборкам референсной политики; на втором этапе выполняются обновления on-policy с одним генерированием на промпт с использованием функции потерь квадратичной ошибки (β·log(π(y|x)/π_ref(y|x)) − (r(x, y) − V*(x)))². Это обеспечивает более быструю тренировку и меньший пиковый объем памяти по сравнению с PPO/GRPO/REBEL. Метод предполагает бинарную верифицируемую награду и не может превзойти Pass@K референсной политики. См. A2PO. Официальный код доступен в ZhaolinGao/A-PO.
from trl.experimental.a2po import A2POConfig, A2POTrainer
# Hyperparameters from the paper (Qwen2.5, GSM8K/MATH)
training_args = A2POConfig(
beta1=0.5, # KL temperature for offline V* estimation
beta2=1e-3, # KL temperature for the on-policy regression target
num_value_samples=8, # N samples per prompt from the reference policy
)
trainer = A2POTrainer(
model=...,
reward_funcs=..., # should return a binary reward in {0, 1}
args=training_args,
train_dataset=...,
)
trainer.train()Direct Preference Optimization
Статьи, связанные с DPOTrainer
Direct Preference Optimization: ваша языковая модель — это секретно модель вознаграждения
📜 Статья: https://huggingface.co/papers/2305.18290
Direct Preference Optimization (DPO) настраивает языковые модели более эффективно и с лучшим качеством по сравнению с обучением с подкреплением на основе обратной связи человека (RLHF), напрямую оптимизируя обучение политики на основе предпочтений человека. Чтобы воспроизвести условия из статьи, используйте следующую конфигурацию:
from trl import DPOConfig
training_args = DPOConfig(
loss_type="sigmoid", # losses in Appendix B of the paper
per_device_train_batch_size=64, # batch size in Appendix B of the paper
learning_rate=1e-6, # learning rate in Appendix B of the paper
beta=0.1, # β in Appendix B of the paper
)SLiC-HF: калибровка вероятности последовательности с использованием обратной связи от человека
📜 Статья: https://huggingface.co/papers/2305.10425
Показано, что калибровка вероятности последовательностей (Sequence Likelihood Calibration, SLiC) является эффективным и более простым альтернативным подходом к обучению с подкреплением на основе обратной связи от человека (Reinforcement Learning from Human Feedback, RLHF) для обучения языковых моделей на основе предпочтений человека. Чтобы воспроизвести условия из статьи, используйте следующую конфигурацию:
from trl import DPOConfig
training_args = DPOConfig(
loss_type="hinge", # Section 2 of the paper
per_device_train_batch_size=512, # batch size in Section 3.2 of the paper
learning_rate=1e-4, # learning rate in Section 3.2 of the paper
)Эти параметры отображаются только в опубликованной версии
Статистическое отклонение выборки улучшает оптимизацию предпочтений
📜 Статья: https://huggingface.co/papers/2309.06657
Предлагает RSO, выбор более сильных пар предпочтений с помощью статистического отклоняющего выборки для улучшения офлайн-оптимизации предпочтений; дополняет DPO/SLiC. Они также вводят новую функцию потерь, определяемую как:
Для обучения на данных, отфильтрованных с помощью RSO, и с потерей hinge-norm можно использовать следующий код:
from trl import DPOConfig, DPOTrainer
dataset = ...
def rso_accept(example): # replace with your actual filter/score logic
return example["rso_keep"]
train_dataset = train_dataset.filter(rso_accept)
training_args = DPOConfig(
loss_type="hinge",
beta=0.05, # correspond to γ in the paper
)
trainer = DPOTrainer(
...,
args=training_args,
train_dataset=train_dataset,
)
trainer.train()Помимо обратного KL: обобщение прямой оптимизации предпочтений с использованием разнообразных ограничений на расхождение
📜 Статья: https://huggingface.co/papers/2309.16240
Предлагает f-DPO, расширяя DPO путём замены обычного регуляризатора обратного KL-распределения на общее f-расхождение, что позволяет балансировать между поведением, ориентированным на режимы, и поведением, охватывающим массу (например, прямое KL, JS, α-расхождения). Единственное изменение — замена логарифмического отношения DPO на f′-оценку:
где — производная выпуклой функции, определяющей выбранную f-дивергенцию.
Для воспроизведения:
from trl import DPOConfig
training_args = DPOConfig(
loss_type="sigmoid",
beta=0.1,
f_divergence_type="js_divergence", # or "reverse_kl" (default), "forward_kl", "js_divergence", "alpha_divergence"
f_alpha_divergence_coef=0.5, # only used if f_divergence_type="alpha_divergence"
)Общий теоретический парадигма для понимания обучения на основе предпочтений человека
📜 Статья: https://huggingface.co/papers/2310.12036
Обучение на основе человеческих предпочтений можно записать как единую целевую функцию с регуляризацией KL для вероятностей парных предпочтений,
что раскрывает RLHF и DPO как частные случаи, соответствующие выбору логитов . В статье показано, что это преобразование логитов усиливает почти детерминированные предпочтения и фактически ослабляет регуляризацию KL, что объясняет переобучение. Используя Identity transform (IPO) можно избежать этой проблемы, оптимизируя предпочтения напрямую, без предположения о модели вознаграждения Bradley–Terry. Чтобы воспроизвести условия из статьи, используйте эту конфигурацию:
from trl import DPOConfig
training_args = DPOConfig(
loss_type="ipo", # Section 5.1 of the paper
per_device_train_batch_size=90, # mini-batch size in Section C.1 of the paper
learning_rate=1e-2, # learning rate in Section C.1 of the paper
)Эти параметры отображаются только в опубликованной версии
К эффективной и точной оптимизации выравнивания языковых моделей
📜 Статья: https://huggingface.co/papers/2402.00856
В статье показано, что методы прямого предпочтения, такие как DPO, оптимизируют неверное направление KL, что приводит к размытому захвату предпочтений, и предлагается EXO как эффективный способ точно оптимизировать целевую функцию выравнивания с человеческими предпочтениями, используя сопоставление вероятностей обратного KL вместо приближений прямого KL. Для воспроизведения настроек из статьи используйте следующую конфигурацию:
from trl import DPOConfig
training_args = DPOConfig(
loss_type="exo_pair", # Section 3.2 of the paper
# From Section B of the paper
per_device_train_batch_size=64,
learning_rate=1e-6,
beta=0.1,
)Шумовой контрастный выравнивание языковых моделей с явными наградами
📜 Статья: https://huggingface.co/papers/2402.05369
Статья переосмысливает выравнивание языковых моделей как задачу контрастной классификации шума, предлагая InfoNCA для обучения политики на основе явных вознаграждений (или предпочтений) путём подбора целевого распределения, индуцированного вознаграждением, по ответам, и показывая, что DPO является частным бинарным случаем. Затем вводится NCA, который добавляет абсолютный член правдоподобия для предотвращения коллапса правдоподобия, наблюдаемого в чисто относительных (контрастных) целевых функциях.
При попарных предпочтениях, для выбранных/отклонённых, определяем оценки, и применяем функцию потерь предпочтений NCA.
Чтобы воспроизвести условия из статьи, используйте эту конфигурацию:
from trl import DPOConfig
training_args = DPOConfig(
loss_type="nca_pair",
# From Section C of the paper
per_device_train_batch_size=32,
learning_rate=5e-6,
beta=0.01,
)Доказуемо робастный DPO: выравнивание языковых моделей с зашумленной обратной связью
📜 Статья: https://huggingface.co/papers/2403.00409
DPO даёт сбой при зашумлённых человеческих предпочтениях, поскольку инвертированные метки смещают целевую функцию. Robust DPO устраняет это, аналитически устраняя смещение в функции потерь DPO при простой модели шума, с доказуемыми гарантиями.
Where is the DPO loss defined in Direct Preference Optimization: Your Language Model is Secretly a Reward Model and is the probability of a label flip.
Это единственное исправление превращает зашумлённые данные предпочтений в несмещённую оценку чистой целевой функции DPO.
from trl import DPOConfig
training_args = DPOConfig(
loss_type="robust",
per_device_train_batch_size=16, # batch size in Section B of the paper
learning_rate=1e-3, # learning rate in Section B of the paper
beta=0.1, # β in Section B of the paper,
max_length=512, # max length in Section B of the paper
label_smoothing=0.1 # label smoothing {@html ""} in Section 6 of the paper
)Оптимизация бинарного классификатора для выравнивания больших языковых моделей
📜 Статья: https://huggingface.co/papers/2404.04656
Теоретический анализ и новый алгоритм, Binary Classifier Optimization, объясняют и улучшают выравнивание больших языковых моделей с использованием бинарных сигналов обратной связи. Для воспроизведения условий из статьи используйте следующую конфигурацию:
BCO переосмысливает выравнивание языковых моделей как клонирование поведения из оптимального распределения, взвешенного по награде, что приводит к простым целям обучения с учителем, позволяющим избежать RL, сохраняя при этом теоретическую обоснованность. Он поддерживает как ненапаренные данные наград, так и данные попарных предпочтений, с формулировкой, инвариантной к сдвигу награды, которая в задаче предпочтений сводится к потере в стиле DPO.
Для настройки попарных предпочтений функция потерь BCO определяется как:
Чтобы воспроизвести статью в этой конфигурации, используйте следующие настройки:
from trl import DPOConfig
training_args = DPOConfig(
loss_type="bco_pair",
# From Section C of the paper
per_device_train_batch_size=128,
learning_rate=5e-7,
beta=0.01,
)Изучите свою эталонную модель для действительно хорошей согласованности
📜 Статья: https://huggingface.co/papers/2404.09656
Trust Region DPO (TR-DPO) обновляет эталонную политику в процессе обучения, демонстрируя эффективность по сравнению с DPO на наборах данных Anthropic HH и TLDR, превосходя DPO до 19% по результатам автоматической оценки с помощью GPT-4, улучшая связность, корректность, уровень детализации, полезность и безвредность. Чтобы воспроизвести настройки из статьи, используйте эту конфигурацию:
from trl import DPOConfig
training_args = DPOConfig(
sync_ref_model=True, # enable TR-DPO (Section 3 of the paper)
ref_model_mixup_alpha=0.6, # α soft update weight (Table 1 of the paper)
ref_model_sync_steps=512, # τ update frequency in steps (Table 1 of the paper)
beta=0.05, # β temperature (Table 1 of the paper)
learning_rate=1e-6, # learning rate (Table 2 of the paper)
num_train_epochs=1, # Table 2 of the paper
max_length=1024, # max tokens length (Table 2 of the paper)
max_grad_norm=2, # max gradient norm (Table 2 of the paper)
warmup_steps=100, # warm-up steps (Table 2 of the paper)
)Оптимизация предпочтений для итеративного рассуждения
📜 Статья: https://huggingface.co/papers/2404.19733
Итеративный RPO улучшает рассуждения, многократно генерируя кандидаты цепочки рассуждений, формируя пары предпочтений на основе правильных и неправильных ответов и обучаясь с целью DPO + NLL. Дополнительный член NLL является ключевым для обучения модели реально генерировать выигрышные трассы.
TRL может выразить целевую функцию DPO + NLL, комбинируя "sigmoid" (DPO) с "sft" (NLL):
from trl import DPOConfig, DPOTrainer
training_args = DPOConfig(
loss_type=["sigmoid", "sft"],
loss_weights=[1.0, 1.0], # alpha in the paper, recommended value is 1.0
)
trainer = DPOTrainer(
...,
args=training_args,
)Обратите внимание, что в статье используется итеративный цикл: на каждой итерации текущая модель генерирует новые кандидаты CoT, после чего выполняется дообучение на свежих парах предпочтений. TRL не автоматизирует этот цикл за вас.
Self-Play Preference Optimization для выравнивания языковых моделей
📜 Статья: https://huggingface.co/papers/2405.00675
Метод самоигры SPPO для выравнивания языковых моделей достигает наилучших результатов, аппроксимируя политику равновесия Нэша в условиях игры с нулевой суммой, превосходя другие подходы при ограниченном объёме данных. Для воспроизведения условий из статьи используйте следующую конфигурацию:
from trl import DPOConfig
training_args = DPOConfig(
loss_type="sppo_hard",
# From Section 5 of the paper
beta=0.001, # β = η^−1
per_device_train_batch_size=64,
learning_rate=5e-7,
)Доказуемое смягчение переоптимизации в RLHF: ваша функция потерь SFT неявно является противоречивым регуляризатором
📜 Статья: https://huggingface.co/papers/2405.16436
Регуляризованная оптимизация предпочтений (RPO) снижает эффект чрезмерной оптимизации в RLHF, объединяя потерю DPO с потерей SFT, что доказуемо предотвращает выбор политикой действий с ложно высокими наградами прокси-функции. Для воспроизведения условий из статьи используйте следующую конфигурацию:
from trl import DPOConfig
training_args = DPOConfig(
loss_type=["sigmoid", "sft"], # RPO loss = DPO + SFT (Section 5 of the paper)
loss_weights=[1.0, 0.005], # η=0.005 SFT weight in Appendix E.1 of the paper
beta=0.01, # β in Appendix E.1 of the paper
learning_rate=5e-7, # learning rate in Appendix E.1 of the paper
num_train_epochs=1, # Appendix E.1 of the paper
)Распределительное выравнивание предпочтений LLM с помощью оптимального транспорта
📜 Статья: https://huggingface.co/papers/2406.05882
Метод выравнивания с помощью оптимального транспорта (AOT) выравнивает большие языковые модели на уровне распределений, штрафуя нарушения стохастического доминирования между распределениями положительных и отрицательных выборок, что обеспечивает наилучшие результаты на бенчмарках выравнивания. Для воспроизведения условий из статьи используйте следующую конфигурацию:
from trl import DPOConfig
training_args = DPOConfig(
loss_type="aot",
beta=0.01, # from the caption of Figure 2
)или для версии без пар:
from trl import DPOConfig
training_args = DPOConfig(
loss_type="aot_unpaired",
beta=0.01, # from the caption of Figure 2
)В статье нет дополнительных гиперпараметров.
Открытие алгоритмов оптимизации предпочтений с помощью и для больших языковых моделей
📜 Статья: https://huggingface.co/papers/2406.08414
Метод, управляемый LLM, автоматически находит высокоэффективные алгоритмы оптимизации предпочтений, что привело к созданию нового алгоритма DiscoPOP, сочетающего логистическую и экспоненциальную функции потерь. Для воспроизведения условий из статьи используйте следующую конфигурацию:
from trl import DPOConfig
training_args = DPOConfig(
loss_type="discopop",
per_device_train_batch_size=64, # batch size in Section B.1 of the paper
learning_rate=5e-7, # learning rate in Section B.1 of the paper
beta=0.05, # β in Section B.1 of the paper,
discopop_tau=0.05 # τ in Section E of the paper
)WPO: Улучшение RLHF с помощью оптимизации взвешенных предпочтений
📜 Статья: https://huggingface.co/papers/2406.11827
WPO пересчитывает веса пар предпочтений на основе вероятностей политики, чтобы сократить разрыв между off-policy и on-policy в обучении в стиле DPO. Потери:
где вес определяется как:
Чтобы воспроизвести условия из статьи, используйте эту конфигурацию:
from trl import DPOConfig
training_args = DPOConfig(
loss_type="sigmoid", # DPO loss used in the paper
beta=0.01, # Section 4 of the paper
use_weighting=True,
)Оптимизация предпочтений с якорем и контрастивные ревизии: решение проблемы недоопределённости в выравнивании
📜 Статья: https://huggingface.co/papers/2408.06266
CLAIR и APO улучшают выравнивание LLM за счёт более контрастных пар предпочтений и контролируемых целей выравнивания, что повышает производительность модели до уровня, близкого к GPT4-turbo. Для воспроизведения настроек из статьи используйте следующую конфигурацию:
from trl import DPOConfig
training_args = DPOConfig(
loss_type="apo_zero", # Section 4 of the paper
per_device_train_batch_size=64, # batch size in Section B.1 of the paper
learning_rate=2e-7, # learning rate in Section 5.2 of the paper
beta=0.1, # β in Section 5.2 of the paper,
)from trl import DPOConfig
training_args = DPOConfig(
loss_type="apo_down", # Section 4 of the paper
per_device_train_batch_size=64, # batch size in Section B.1 of the paper
learning_rate=2e-7, # learning rate in Section 5.2 of the paper
beta=0.1, # β in Section 5.2 of the paper,
)Эти параметры отображаются только в опубликованной версии
Подавление зависимости от длины в прямой оптимизации предпочтений
📜 Статья: https://huggingface.co/papers/2409.06411
Показывает, что стандартный DPO по своей природе чувствителен к длине, что часто приводит к чрезмерно длинным или многословным генерациям. В статье предлагается LD-DPO, который модифицирует агрегацию лог-вероятностей последовательности, разбивая более длинный ответ на общий префикс (до длины более короткого ответа) и избыточный хвост, а затем снижая вес хвоста с помощью коэффициента :
Настройка восстанавливает стандартный DPO; меньшее значение снижает многословность, сохраняя качество предпочтений. Оптимальное значение зависит от семейства моделей и от того, обучаете ли вы базовую или instruct-модель, но в статье предлагается как хорошая точка для начала.
from trl import DPOConfig
training_args = DPOConfig(
ld_alpha=0.5,
)Улучшение способности к рассуждению мультимодальных больших языковых моделей с помощью смешанной оптимизации предпочтений
📜 Статья: https://huggingface.co/papers/2411.10442
Представляет метод Mixed Preference Optimization (MPO) для улучшения мультимодального рассуждения в MLLM, решая проблемы смещения распределения и слабого Chain-of-Thought (CoT) после стандартного предварительного обучения и SFT. В статье представлены (1) MMPR — автоматизированный конвейер для получения высококачественных мультимодальных предпочтительных данных, и (2) MPO — комбинированная целевая функция предпочтений (pairwise + BCO-style + SFT), повышающая качество CoT. Модель InternVL2-8B-MPO достигает 67.0 на MathVista (+8.7 по сравнению с InternVL2-8B), что сопоставимо с результатом модели InternVL2-76B, в 10 раз большей по размеру. Используется в TRL через DPOConfig с составной функцией потерь. Для воспроизведения настроек из статьи используйте следующую конфигурацию:
from trl import DPOConfig
training_args = DPOConfig(
loss_type=["sigmoid", "bco_pair", "sft"], # ℒ = w_p·ℒ_p + w_q·ℒ_q + w_g·ℒ_g (Section 3.2 of the paper)
loss_weights=[0.8, 0.2, 1.0], # w_p, w_q, w_g loss weights (Section 7 of the paper)
learning_rate=5e-6, # learning rate (Section 7 of the paper)
)TÜLU 3: Новые рубежи в постобучении открытых языковых моделей
📜 Статья: https://huggingface.co/papers/2411.15124
Сигмоидная функция потерь с нормализацией по длине устраняет смещение по длине в DPO, деля логарифмические отношения выбранных и отклонённых оценок на соответствующие длины завершений перед вычислением функции потерь Bradley-Terry. Эта нормализация на токен была введена в SimPO (Приложении I «Абляция DPO w/ LN») в качестве средней логарифмической вероятности в качестве вознаграждения для настройки без эталонной модели, а затем была принята для стандартного DPO на основе эталонной модели в рецептах постобучения, таких как Tülu 3 (Раздел 4.3). Функция потерь: которую можно задать с помощью:
from trl import DPOConfig
training_args = DPOConfig(
loss_type="sigmoid_norm",
)Непредвзятое выравнивание больших языковых моделей с зашумленными предпочтениями
📜 Статья: https://huggingface.co/papers/2607.03248
В этой статье шум предпочтений моделируется как инвертирование меток с вероятностью и инвертирует это преобразование, так чтобы политика, обученная на зашумленных предпочтениях, имела тот же оптимум, что и при чистых предпочтениях. TRL реализует нормализованную форму полученной функции потерь Unbiased DPO (UDPO), называемой в статье α-UDPO:
что является потерей DPO для . Постоянная поддерживает максимальную величину градиента равной 1, как в DPO. В отличие от Robust DPO, в статье показано, что оптимум остаётся несмещённым, если истинная вероятность инверсии меньше предполагаемого (Следствие 4.7), поэтому не обязательно оценивать точно. В TRL задаётся с помощью label_smoothing. Чтобы использовать , значение, которое авторы статьи рекомендуют практикам:
from trl import DPOConfig
training_args = DPOConfig(
loss_type="udpo",
label_smoothing=4 / 9, # flip probability ε, for a = ε / (1 - ε) = 0.8 as recommended in Appendix B.1 of the paper
beta=0.1, # 0.1 for HH and UltraFeedback, 0.5 for TL;DR (Appendix B.1 of the paper)
learning_rate=5e-6, # 5e-6 for Llama-3.2-3B and Qwen3-1.7B, 1e-6 for 8B models (Appendix B.1 of the paper)
num_train_epochs=3, # Appendix B.1 of the paper
per_device_train_batch_size=16, # total batch size of 128 on 8 GPUs (Appendix B.1 of the paper)
max_grad_norm=10.0, # Appendix B.1 of the paper
warmup_ratio=0.1, # Appendix B.1 of the paper
)Оптимизация по Канеману–Тверски
Статьи, связанные с KTOTrainer
KTO: выравнивание модели как оптимизация в рамках теории перспектив
📜 Статья: https://huggingface.co/papers/2402.01306
KTO выводит целевую функцию выравнивания из теории перспектив и обучается непосредственно по бинарной обратной связи человека (понравилось/не понравилось), сопоставляя или превосходя методы в стиле DPO при этом хорошо справляясь с несбалансированными и зашумлёнными сигналами. Чтобы воспроизвести условия из статьи, вы можете использовать конфигурацию по умолчанию для KTOTrainer:
from trl import KTOConfig, KTOTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained(model_id)
tokenizer = AutoTokenizer.from_pretrained(model_id)
trainer = KTOTrainer(
model=model,
processing_class=tokenizer,
args=KTOConfig(),
train_dataset=...,
)
trainer.train()Детальная настройка с учителем
Статьи, связанные с SFTTrainer
TailSFT: Отфильтрованная дообученная настройка улучшает результаты постобучения
📜 Статья: https://huggingface.co/papers/2608.25756
TailSFT сохраняет покрытие ответов для последующего обучения с подкреплением, отфильтровывая последовательности, у которых нормализованная по длине потеря наиболее улучшилась по сравнению с начальной политикой. Пример tail_sft_gsm8k реализует распределённую фильтрацию выборок для отбора из статьи путём наследования от SFTTrainer. Он записывает потерю начальной политики для каждой последовательности до начала обучения и фильтрует примеры независимо в каждой выборке для отбора.
python examples/tail_sft_gsm8k/tail_sft.py
EMA без задержки: схемы усреднения итераций с коррекцией смещения
📜 Статья: https://huggingface.co/papers/2508.00180
Скорректированное смещением экспоненциальное скользящее среднее (BEMA) повышает стабильность и эффективность дообучения языковых моделей за счёт снижения стохастичности и устранения смещения. Чтобы использовать BEMA с SFT, как описано в статье, можно применить BEMACallback:
from trl import BEMACallback, SFTTrainer
trainer = SFTTrainer(
...
callbacks=[BEMACallback()],
)Обобщение SFT: взгляд с позиции обучения с подкреплением с корректировкой вознаграждения
📜 Статья: https://huggingface.co/papers/2508.05629
Динамическая дообучение (DFT) улучшает обобщающую способность больших языковых моделей (LLM) за счёт динамического масштабирования градиентов, превосходя стандартное дообучение с учителем (SFT) и демонстрируя конкурентоспособные результаты в офлайн-обучении с подкреплением.
где — оператор остановки градиента. Чтобы использовать DFT с SFT, как описано в статье, можно использовать аргумент loss_type="dft" :
from trl import SFTConfig
training_args = SFTConfig(
loss_type="dft",
...
)Чтобы максимально точно воспроизвести условия из статьи, вы можете использовать следующую конфигурацию (см. Раздел 4.1). Авторы также отмечают, что гиперпараметры не очень чувствительны (Раздел 4.3):
SFTConfig(
loss_type="dft",
learning_rate=5e-5,
max_length=2048,
# Target batch size 256; achieved via per-device batch 8 * grad accumulation 32
per_device_train_batch_size=8,
gradient_accumulation_steps=32,
)Меньше усечений — лучшее моделирование языка
📜 Статья: https://huggingface.co/papers/2404.10830
В статье показано, что стандартная предобработка «соединить, затем разбить» (packing_strategy="wrapped"), используемая для обучения LLM, приводит к произвольному усечению многих документов, что ухудшает качество обучения. Авторы предлагают упаковывать фрагменты документов в контекстные окна с помощью алгоритма упаковки в контейнеры Best-Fit Decreasing, что значительно снижает количество усечений при сохранении высокой эффективности использования токенов и улучшении характеристик модели. В TRL это реализовано как стратегия упаковки "bfd_split" в SFTConfig. Подробнее об упаковке см. в документации SFT.
from trl import SFTConfig
training_args = SFTConfig(
packing=True,
packing_strategy="bfd_split",
max_length=4096,
)Исследование пределов трансферного обучения с помощью унифицированного текстового трансформера
📜 Статья: https://huggingface.co/papers/1910.10683
В статье T5 предлагается единая текстово-текстовая (text-to-text) архитектура для трансферного обучения и вводится упаковка последовательностей (раздел 3.5.2): объединение нескольких коротких последовательностей в блоки фиксированной длины для сокращения количества заполнителей (padding) и повышения эффективности обучения. Упаковка поддерживается в TRL через SFTConfig с использованием SFTTrainer. Чтобы включить упаковку в TRL, используйте следующую конфигурацию:
from trl import SFTConfig
training_args = SFTConfig(
packing=True, # enable sequence packing (Section 3.5.2 of the paper)
max_length=512, # packed sequence length (Section 3.5.2 of the paper)
)Параметризация моделей диффузии с равномерным распределением: денойзер Leave-One-Out
📜 Статья: https://huggingface.co/papers/2605.22765
Для моделей равномерного дискретного диффузного процесса обычная подстановка кросс-энтропии не обучает простому денойзеру а апостериорному распределению leave-one-out (LOO), которое предсказывает каждый токен, не используя его собственное повреждённое значение. В статье выведены точные преобразования между денойзером, апостериорным распределением LOO и градиентом (score), поэтому сеть можно обучать в любом из этих параметризований с одной и той же кросс-энтропией. Даны логиты softmax которых параметризует апостериорное распределение LOO, денойзер, используемый в функции потерь, равен
то есть аддитивная коррекция логита наблюдаемого токена, где — размер словаря, а — вероятность того, что прямое равномерное распространение сохраняет исходный токен. В статье сообщается, что параметризация LOO последовательно улучшает генерацию. Пример SFT для блок-диффузии examples/sft_diffusion_gemma/sft_diffusion_gemma.py предоставляет обе параметризации через --model_prediction_type (mean для простого денойзера, соответствующий опубликованной контрольной точке, или mean_loo для апостериорного распределения LOO):
torchrun --nproc_per_node 8 examples/sft_diffusion_gemma/sft_diffusion_gemma.py \
--deepspeed examples/deepspeed_configs/zero3.json \
--use_peft \
--gradient_checkpointing \
--model_prediction_type mean_loo \
--output_dir diffusiongemma-26B-A4B-it-gsm8k-loraСокращение пересчета активаций в больших трансформерных моделях
📜 Статья: https://huggingface.co/papers/2205.05198
Полное контрольное сохранение активаций (full activation checkpointing) пересчитывает каждую операцию в контрольной области во время обратного прохода, включая attention, хотя лишь несколько операций (в том числе attention) дают основную долю стоимости пересчёта по сравнению с памятью, которую они заняли бы при сохранении. Селективное пересчёт активаций (selective activation recomputation) из статьи сохраняет контрольные точки только для тех дорогостоящих операций, а не для всей области. TRL реализует это как селективное контрольное сохранение активаций (SAC) для SFTTrainer, сохраняя выход attention во время прямого прохода, чтобы в обратном проходе не пересчитывать его:
from trl import SFTConfig
training_args = SFTConfig(
gradient_checkpointing=True,
gradient_checkpointing_kwargs={"selective": True},
)Параметрически эффективная дообучение (PEFT)
Для общей информации об использовании PEFT с TRL обратитесь к руководству Интеграция PEFT.
LoRA: Low-Rank Adaptation of Large Language Models
📜 Статья: https://huggingface.co/papers/2106.09685
Low-Rank Adaptation (LoRA) сокращает количество обучаемых параметров и потребление памяти GPU в крупных предобученных моделях, сохраняя или улучшая качество на задачах, следующих за предобучением. TRL интегрирует LoRA через библиотеку PEFT, и её можно легко включить в любом тренера TRL, передав LoraConfig в аргумент peft_config. Ниже приведён пример использования LoRA с SFTTrainer:
from trl import SFTTrainer
from peft import LoraConfig
trainer = SFTTrainer(
...,
peft_config=LoraConfig(),
)DoRA: адаптация низкого ранга с разложением весов
📜 Статья: https://huggingface.co/papers/2402.09353
Метод Weight-Decomposed Low-Rank Adaptation (DoRA) способен повысить производительность LoRA, особенно при низких рангах. DoRA разлагает предобученные веса на два компонента: величину и направление. Направление обрабатывается стандартным LoRA, а величина представляет собой обучаемые параметры. TRL интегрирует DoRA через библиотеку PEFT, и его можно легко включить, установив use_dora=True в LoraConfig.
from peft import LoraConfig
config = LoraConfig(use_dora=True, ...)Reinforce Leave-One-Out
Статьи, связанные с RLOOTrainer
Возвращение к основам: повторное рассмотрение оптимизации в стиле REINFORCE для обучения с обратной связью от человека в LLM
📜 Статья: https://huggingface.co/papers/2402.14740
RLOO — это вариант REINFORCE, который снижает дисперсию за счёт использования базовых значений leave-one-out. Он вычисляет вознаграждения, сравнивая каждую выборку со средним значением всех остальных выборок в батче, что обеспечивает более стабильные градиенты по сравнению со стандартным REINFORCE. Чтобы воспроизвести настройки из статьи, используйте следующую конфигурацию:
from trl import RLOOConfig
training_args = RLOOConfig(
per_device_train_batch_size=512, # section C Training Detail of the paper
steps_per_generation=2, # section C Training Detail of the paper
beta=0.03, # section C Training Detail of the paper
num_generations=2, # experiments of paper different num_generations={2,4}
learning_rate=1e-6, # section C Training Detail of the paper
)REINFORCE++: простой и эффективный подход к выравниванию больших языковых моделей
📜 Статья: https://huggingface.co/papers/2501.03262
REINFORCE++ — это улучшенный вариант классического алгоритма REINFORCE, который включает ключевые методы оптимизации из PPO, но исключает необходимость в сети критика. Он обеспечивает простоту, повышенную стабильность обучения и снижение вычислительных затрат за счёт глобальной нормализации преимуществ на всём батче. Чтобы приблизиться к настройкам из статьи с помощью RLOOTrainer, используйте следующую конфигурацию:
from trl import RLOOConfig
training_args = RLOOConfig(
normalize_advantages=True, # global advantage normalization, core of REINFORCE++
)Оптимизация предпочтений по коэффициенту шансов
Статьи, связанные с experimental.orpo.ORPOTrainer
ORPO: Монолитная оптимизация предпочтений без эталонной модели
📜 Статья: https://huggingface.co/papers/2403.07691
Введение алгоритма оптимизации предпочтений на основе монолитного отношения шансов без опорной модели (ORPO) улучшает выравнивание предпочтений при контролируемой дообучении, превосходя более крупные модели по ключевым метрикам. Для воспроизведения условий из статьи используйте следующую конфигурацию:
from trl.experimental.orpo import ORPOConfig
training_args = ORPOConfig(
beta=0.1, # λ odds ratio loss weight (Table 7 of the paper, Mistral-ORPO-β)
learning_rate=5e-6, # learning rate (Appendix C of the paper)
lr_scheduler_type="inverse_sqrt", # scheduler (Appendix C of the paper)
num_train_epochs=5, # Appendix C of the paper
warmup_steps=200, # warm-up steps (Appendix C of the paper)
per_device_train_batch_size=8, # batch size (Appendix C of the paper)
)Контрастная оптимизация предпочтений
Статьи, связанные с experimental.cpo.CPOTrainer
Контрастная оптимизация предпочтений: расширение возможностей LLM в машинном переводе
📜 Статья: https://huggingface.co/papers/2401.08417
Представляет метод оптимизации контрастных предпочтений (Contrastive Preference Optimization, CPO) — подход на основе предпочтений для машинного перевода, который обучает модели избегать приемлемых, но несовершенных переводов, а не копировать эталонные примеры, как это делается при SFT. В статье анализируются ограничения SFT в задачах MT (включая проблемы с качеством эталонных переводов) и показано, что применение CPO к ALMA с использованием всего 22K параллельных предложений приводит к созданию ALMA-R, который соответствует или превосходит победителей соревнований WMT и GPT-4 на WMT’21–WMT’23. Используется в TRL через experimental.cpo.CPOTrainer. Чтобы воспроизвести настройки из статьи, используйте следующую конфигурацию:
from trl.experimental.cpo import CPOConfig
training_args = CPOConfig(
loss_type="sigmoid", # preference learning loss (Section 3 of the paper)
cpo_alpha=1.0, # NLL regularizer weight (Section 3 of the paper)
beta=0.1, # β temperature (Section 4.2 of the paper)
learning_rate=1e-4, # learning rate (official code)
lr_scheduler_type="inverse_sqrt", # scheduler (official code)
num_train_epochs=1, # Section 4.2 of the paper
warmup_ratio=0.01, # warm-up ratio (Section 4.2 of the paper)
max_length=512, # max sequence length (Section 4.2 of the paper)
)SimPO: простая оптимизация предпочтений с наградой без опорной модели
📜 Статья: https://huggingface.co/papers/2405.14734
SimPO — это более простой, но при этом более эффективный подход к оптимизации предпочтений, который использует среднюю логарифмическую вероятность последовательности в качестве неявной награды, что исключает необходимость в эталонной модели. Он вводит целевой разрыв награды в целевую функцию Брэдли-Терри, чтобы стимулировать больший разрыв между выигрышными и проигрышными ответами. Чтобы воспроизвести настройки из статьи, используйте следующую конфигурацию:
from trl.experimental.cpo import CPOConfig
training_args = CPOConfig(
loss_type="simpo", # SimPO loss (Section 3 of the paper)
cpo_alpha=0.0, # no BC regularizer for SimPO
beta=2.5, # β in Appendix B of the paper
simpo_gamma=1.375, # γ target reward margin, from γ/β=0.55 in Appendix B of the paper
learning_rate=1e-6, # learning rate in Appendix B of the paper
num_train_epochs=1, # Appendix B of the paper
)AlphaPO — Форма вознаграждения важна для выравнивания LLM
📜 Статья: https://huggingface.co/papers/2501.03884
AlphaPO — это новый метод Direct Alignment Algorithms (DAAs), который использует параметр alpha для изменения формы функции вознаграждения за пределами стандартного логарифмического вознаграждения. AlphaPO помогает сохранять детальный контроль над смещением вероятности и чрезмерной оптимизацией. Чтобы воспроизвести настройки из статьи, используйте следующую конфигурацию:
from trl.experimental.cpo import CPOConfig
# Mistral-Instruct from Table 3 of the paper
training_args = CPOConfig(
loss_type="alphapo",
alpha=0.25,
beta=2.5,
simpo_gamma=0.1,
learning_rate=7e-7,
...
)Оптимизация тройных предпочтений
Triple Preference Optimization: достижение лучшей согласованности с помощью одношаговой оптимизации
📜 Статья: https://huggingface.co/papers/2405.16681
Представляет метод обучения на предпочтениях Triple Preference Optimization (TPO), который выравнивает LLM с тремя ответами на один запрос — эталонным (reference) завершением, предпочтительным (chosen) завершением и нежелательным (rejected) завершением — за один шаг оптимизации. TPO сочетает контрастную целевую функцию для пары (chosen, rejected) с членом NLL, обучаемым с учителем на эталонном ответе, что устраняет необходимость в отдельном этапе SFT и в эталонной модели, используемой в DPO. TRL поставляла реализацию в виде TPOTrainer до версии v1.16; теперь она больше не входит в состав библиотеки и остаётся доступной в истории git.
Nash Обучение с обратной связью от человека
Nash Обучение с обратной связью от человека
📜 Статья: https://huggingface.co/papers/2312.00886
Представляет Nash-MD — альтернативу стандартному RLHF, которая обучает модель предпочтений, условную на два входа, и находит политику в точке равновесия Нэша. Вместо оптимизации относительно модели вознаграждения Nash-MD формирует политики, которые последовательно генерируют ответы, предпочитаемые по сравнению с ответами любой конкурирующей политики. Алгоритм основан на принципах зеркального спуска. TRL поставляла реализацию в виде NashMDTrainer до версии v1.13; теперь она больше не входит в состав библиотеки и остаётся доступной в истории git.
Моделирование вознаграждения
Статьи, связанные с RewardTrainer
Помощь или стадное поведение? Ансамбли моделей вознаграждения смягчают, но не устраняют взлом вознаграждения
📜 Статья: https://huggingface.co/papers/2312.09244
В этой статье предложена вспомогательная функция потерь, предназначенная для прямого обучения центрированной модели вознаграждения. Эта вспомогательная функция потерь минимизирует сумму квадратов вознаграждений, побуждая модель естественным образом выдавать выходные значения со средним нулём и тем самым устраняя проблему недоопределённости.
Чтобы использовать эту вспомогательную потерю с RewardTrainer, вы можете использовать аргумент center_rewards_coefficient в RewardConfig следующим образом:
from trl import RewardConfig
training_args = RewardConfig(
center_rewards_coefficient=0.01, # η in the paper
...
)Llama 2: открытые базовые и дообученные чат-модели
📜 Статья: https://huggingface.co/papers/2307.09288
В этой статье авторы предлагают использовать свои оценки предпочтений, разложенные по шкале из четырёх пунктов (например, значительно лучше) ), чтобы предоставлять более информативную обратную связь модели вознаграждения. Это достигается путём добавления маржи в функцию потерь, что побуждает модель вознаграждения назначать более крупные разрывы в оценках для пар с более высокими оценками предпочтений.
Вы можете добавить маржу к функции потерь, добавив столбец margin в набор данных. Приведённый ниже пример показывает, как настроить вариант «Margin Small» из статьи.
def add_margin(example):
preference_to_margin = {
"significantly better": 1.0,
"better": 2.0/3.0,
"slightly better": 1.0/3.0,
"negligibly better / unsure": 0.0,
}
return {"margin": preference_to_margin[example["preference_label"]]}
dataset = dataset.map(add_margin)Онлайн-оптимизация прямых предпочтений
Статьи, связанные с experimental.online_dpo.OnlineDPOTrainer
Прямое выравнивание языковой модели по обратной связи от онлайн-ИИ
📜 Статья: https://huggingface.co/papers/2402.04792
Online DPO улучшает методы прямого выравнивания по предпочтениям, предоставляя обратную связь от модели в реальном времени, и превосходит как DPO, так и PPO.
Для использования Online DPO можно применить experimental.online_dpo.OnlineDPOTrainer.
Эвристическая оптимизация предпочтений: использование неявного приближения Q* для эффективного по образцам RLHF
📜 Статья: https://huggingface.co/papers/2405.21046
XPO дополняет целевую функцию DPO новым и обоснованным бонусом за исследование, что позволяет алгоритму выходить за пределы области определения исходной модели и данных обратной связи от людей. Это изменение в одну строку в онлайн-DPO, которое доказуемо эффективно по количеству выборок и сходится к почти оптимальной политике языковой модели. TRL предоставила реализацию в виде XPOTrainer до версии v1.13; теперь она больше не входит в состав библиотеки, но остаётся доступной в истории git.
Дистилляция
Статьи, посвященные обучению ученической модели с помощью учительской модели.
Дистилляция языковых моделей по политике: обучение на собственных ошибках
📜 Статья: https://huggingface.co/papers/2306.13649
Представляет Generalized Knowledge Distillation (GKD), которая решает проблему рассогласования распределений в KD для авто-регрессионных моделей, обучая ученика на собственных сгенерированных им выводах с обратной связью от учителя, а не на фиксированном наборе последовательностей. GKD поддерживает гибкие функции потерь (например, помимо KL, когда ученик не может точно соответствовать учителю) и интегрируется с дообучением с подкреплением (RLHF). В статье представлены результаты для задач суммаризации, перевода, арифметического рассуждения и instruction-tuning. Используется в TRL через experimental.gkd.GKDTrainer, который предоставляет возможность смешивания on/off-policy из статьи (lmbda). DistillationTrainer реализует ту же цель обобщенного JSD для случая постоянного on-policy. Чтобы воспроизвести настройки из статьи, используйте следующую конфигурацию:
from trl.experimental.gkd import GKDConfig
# XSum summarization task (Table A.1 of the paper)
training_args = GKDConfig(
lmbda=0.5, # λ student data fraction (Section 3 of the paper)
beta=0.5, # β Generalized JSD interpolation, 0=KL, 1=reverse KL (Section 3 of the paper)
temperature=1.0, # student training temperature (Appendix A of the paper)
max_steps=40000, # training steps (Table A.1 of the paper)
learning_rate=3e-4, # learning rate (Table A.1 of the paper)
per_device_train_batch_size=32, # batch size (Table A.1 of the paper)
warmup_steps=2000, # warm-up steps (Table A.1 of the paper)
max_new_tokens=64, # max output tokens (Table A.1 of the paper)
)MOPD: дистилляция с несколькими учителями по политике для интеграции возможностей в постобучении LLM
📜 Статья: https://huggingface.co/papers/2606.30406
Структура пост-обучения включает три этапа: общее SFT, независимое обучение с подкреплением (RL) для каждого домена с одним экспертом на домен (например, RL с проверяемыми ответами для математики, RL в песочнице для агентных задач в области разработки ПО) и финальный этап MOPD, на котором замороженные доменные эксперты объединяются в единую модель-студента. На этом финальном этапе студент генерирует траекторию для каждого промпта, каждая траектория направляется соответствующему доменному учителю (без усреднения или ансамблирования между учителями), а обновление студента выполняется путем минимизации обратного KL-распределения на уровне токенов относительно распределения этого одного учителя вдоль траектории. Используется в TRL через experimental.async_distillation.AsyncDistillationTrainer, который реализует этот третий, объединяющий этап: передача более одного элемента в teacher_server_urls включает MOPD, при этом столбец teacher_id каждой строки определяет, какой (уже обученный) учитель оценивает её. Используйте beta=1.0, чтобы соответствовать целевой функции обратного KL из статьи.
О позиционном смещении при дистилляции по стратегии
📜 Статья: https://huggingface.co/papers/2606.22600
Представляет Importance-Weighted On-Policy Distillation (IW-OPD), которая устраняет позиционное смещение в OPD за счёт пересчёта весов обновлений дистилляции для сэмплированных токенов на основе накопленного расхождения префиксов учителя и ученика. Ранние токены сохраняют более высокие веса, тогда как поздние токены после значительного дрейфа получают пониженные веса. Используется в TRL через experimental.iw_opd.IWOPDTrainer с параметром distillation_objective="iw_opd".
В статье IW-OPD оптимизируется с использованием настройки clipped policy-gradient (verl) и rollouts на vLLM. IWOPDTrainer предоставляет соответствующие настройки дистилляции и rollouts, приведённые ниже; параметры оптимизации политики из статьи, такие как диапазон обрезания 0.2, константа dual-clip 3.0, внутренние эпохи PPO, коэффициент энтропии, штраф за KL-вознаграждение, вспомогательный KL и коррекция важности rollout, не являются параметрами IWOPDConfig.
from trl.experimental.iw_opd import IWOPDConfig
# Table 6 and Algorithm 1 of the paper, mapped to IWOPDConfig where available.
training_args = IWOPDConfig(
distillation_objective="iw_opd",
iw_opd_gamma=0.5, # γ amplification, Algorithm 1 and Appendix C.3
lmbda=1.0, # fully on-policy rollouts
learning_rate=1e-5, # Table 6
per_device_train_batch_size=1, # Table 6 uses PPO micro-batch size 1 per GPU
gradient_accumulation_steps=32, # with 32 GPUs, this gives the paper's 1024-prompt batch
num_generations=1, # Table 6 rollout samples per prompt
temperature=1.0, # Table 6 training decoding temperature
top_p=1.0, # Table 6 training decoding top-p
max_prompt_length=2048, # Table 6
max_completion_length=16384, # Table 6
warmup_ratio=0.0, # Table 6
use_vllm=True, # Table 6 uses vLLM rollouts
vllm_sync_frequency=1, # refresh rollout policy after each update
save_steps=10, # Table 6 checkpoint frequency
eval_steps=10, # Table 6 validation frequency
)Дистилляция по политике
📰 Блог: https://thinkingmachines.ai/blog/on-policy-distillation/
On-Policy Distillation предполагает, что модель-ученик генерирует rollout'ы для каждой партии обучающих данных. Затем мы получаем распределения вероятностей для каждого токена в rollout'ах как от модели-ученика, так и от модели-учителя. После этого модель-ученика оптимизируют для минимизации отрицательного расхождения Кульбака-Лейблера (KL) между её собственными распределениями токенов и распределениями модели-учителя.
| Метод | Выборка | Сигнал вознаграждения |
|---|---|---|
| Обучение с учителем | off-policy | dense |
| Обучение с подкреплением | on-policy | sparse |
| Дистилляция по стратегии | on-policy | dense |
Метод On-Policy Distillation демонстрирует более высокую эффективность по сравнению с SFT и GRPO, а также позволяет восстановить способности к обобщению, утраченные в ходе SFT.
Кроме того, дистилляция on-policy более эффективна с точки зрения вычислений и менее склонна к переобучению при обучении на ограниченных данных.
Для обучения модели с использованием on-policy дистилляции в TRL можно применить следующую конфигурацию с DistillationTrainer и DistillationConfig:
from trl import DistillationConfig
training_args = DistillationConfig(
beta=1.0, # to ensure reverse-kl as the loss function
teacher_model_name_or_path="teacher-model", # specify the teacher model
)В качестве альтернативы можно использовать experimental.gkd.GKDTrainer и experimental.gkd.GKDConfig:
from trl.experimental.gkd import GKDConfig
training_args = GKDConfig(
lmbda=1.0, # student produces rollouts for all batches
beta=1.0, # to ensure reverse-kl as the loss function
teacher_model_name_or_path="teacher-model", # specify the teacher model
)Вы также можете использовать experimental.gold.GOLDTrainer для дистилляции on-policy; см. Unlocking On-Policy Distillation for Any Model Family.
Открываем возможности дистилляции по политике для любой семейства моделей
🌐 Проект: https://huggingface.co/spaces/HuggingFaceH4/general-on-policy-logit-distillation
Представляет General Online Logit Distillation (GOLD), которая расширяет on-policy дистилляцию на пары ученик/учитель с различными токенизаторами и семействами моделей. GOLD выравнивает текстовые фрагменты между токенизаторами и может применять Universal Logit Distillation (ULD), чтобы токены завершения не терялись. Используется в TRL через experimental.gold.GOLDTrainer.
from trl.experimental.gold import GOLDConfig
training_args = GOLDConfig(
lmbda=1.0, # student produces rollouts for all batches
beta=1.0, # to ensure reverse-kl as the loss function
use_uld_loss=True, # Universal Logit Distillation for cross-tokenizer pairs
)X-Token: проекционно-управляемая кросс-токенизаторная дистилляция знаний
📜 Статья: https://huggingface.co/papers/2605.21699
X-Token расширяет фреймворк дистилляции GOLD для пар «ученик-учитель», которые не используют общий токенизатор. Это off-policy метод (lmbda=0): набор данных предоставляет текст завершения, и как ученик, так и учитель выполняют прямой проход по этому тексту, после чего вычисляется loss KD между их логитами с учётом различий в токенизаторах. Генерация rollouts со стороны ученика в on-policy режиме не требуется. Предварительно вычисленная разреженная матрица проекции W ∈ ℝ^{V_s × V_t} сопоставляет каждый токен ученика с токенами учителя, которым он наиболее вероятно соответствует, проецируя распределение ученика в пространство словаря учителя, чтобы их можно было напрямую сравнить. Используется в TRL через experimental.gold.GOLDTrainer с параметром xtoken_loss_type="p_kl" или "h_kl".
Предусмотрены две формулировки функции потерь:
| Вариант | xtoken_loss_type | Описание |
|---|---|---|
| P-KL | "p_kl" | Проекция полного распределения ученика в словарь учителя через W и вычисление прямой KL-дивергенции на глобальном подмножестве top-k. Реализует уравнение (4) из статьи. |
| H-KL | "h_kl" | Гибридный: прямое KL-распределение на ренормализованных распределениях над расширенным общим множеством (вес проекции top-1 ≥ 0.6) и отсортированный L1 для редких токенов. Реализует уравнение (3) с отображением из уравнения (5). |
Как и в эталонной реализации, H-KL вырезает лог-вероятности по всему словарю до общего множества, а P-KL усредняет лог-вероятности учителя по каждому фрагменту без перенормировки, поэтому член KD может быть отрицательным. CE и KD используют отдельные счётчики токенов и выровненных фрагментов для каждого окна накопления. Динамическая балансировка CE/KD и выбор top-k для P-KL вычисляются для каждого микробатча.
Эта реализация использует замороженную матрицу проекции. В статье также совместно обучается матрица для P-KL; данный вариант здесь не реализован.
Сначала создайте матрицу проекции с помощью подготовительных скриптов в examples/xtoken/. Шаг 1 повторно токенизирует словарь ученика с помощью токенизатора учителя; необязательный флаг --runtime-top-k затем выполняет сортировку и обрезку матрицы за один проход (эквивалентно последующему запуску sort_and_cut_projection_matrix.py):
python examples/xtoken/build_projection_matrix.py \
--student-model meta-llama/Llama-3.2-1B-Instruct \
--teacher-model Qwen/Qwen3-4B \
--runtime-top-k 4 \
--output-dir cross_tokenizer_dataЗатем обучите модель с помощью примера скрипта (off-policy, vLLM не требуется):
python examples/xtoken/xtoken.py \
--model_name_or_path meta-llama/Llama-3.2-1B-Instruct \
--teacher_model_name_or_path Qwen/Qwen3-4B \
--dataset_name trl-lib/chatbot_arena_completions \
--xtoken_loss_type p_kl \
--xtoken_projection_matrix_path cross_tokenizer_data/projection_map_Llama-3.2_to_Qwen3_multitoken_top_32_double_special_top4.pt \
--lmbda 0.0или передайте путь к experimental.gold.GOLDConfig напрямую:
from trl.experimental.gold import GOLDConfig
config = GOLDConfig(
lmbda=0.0, # "off-policy knowledge distillation"
xtoken_temperature=1.0, # "temperature τ=1.0"
xtoken_dynamic_scaling=True, # Eq. (7): stop-gradient CE/KD balance
xtoken_loss_type="p_kl",
xtoken_projection_matrix_path="cross_tokenizer_data/projection_map_Llama-3.2_to_Qwen3_multitoken_top_32_double_special_top4.pt",
teacher_tokenizer_name_or_path="Qwen/Qwen3-4B",
)Дистилляция знаний больших языковых моделей
📜 Статья: https://huggingface.co/papers/2306.08543
MiniLLM — это первый метод дистилляции знаний on-policy, который минимизирует последовательностный обратный KLD между моделью-учителем и моделью-учеником и оптимизируется с помощью обучения с подкреплением.
Это обобщённая версия On-Policy Distillation от Think Machine Lab, с возможностью добавления сигналов одношаговой дистилляции на уровне распределения (как GKD при beta=1) и сигналов обратного KLD для длинного контекста.
TRL поставляла реализацию в виде MiniLLMTrainer до версии v1.14; теперь она больше не входит в состав библиотеки и остаётся доступной в истории git.
Обучение с подкреплением с помощью самодистилляции
📜 Статья: https://huggingface.co/papers/2601.20802
Метод оптимизации политики с самодистилляцией (SDPO) расширяет возможности обучения с подкреплением с проверяемыми наградами, преобразуя развёрнутую текстовую обратную связь (например, ошибки времени выполнения, оценки судьи) в плотный сигнал обучения без использования внешнего учителя или явной модели наград. SDPO рассматривает текущую модель, обусловленную обратной связью, как самоучителя и дистиллирует её предсказания следующего токена, основанные на обратной связи, обратно в политику. Примечательно, что SDPO также превосходит базовые методы в стандартных средах RLVR, возвращающих только скалярную обратную связь, используя успешные прокрутки как неявную обратную связь для неудачных попыток.
from trl.experimental.sdpo import SDPOConfig, SDPOTrainer
training_args = SDPOConfig(
distillation_alpha=0.5, # Jensen-Shannon divergence (recommended)
distillation_mode="topk_logits", # Explicitly select top-K logit distillation
distillation_topk=100, # Required for top-K logit distillation
distillation_is_clip=2.0, # Importance sampling clipping
distillation_weight=1.0, # Convex weight: (1-w)*policy + w*distillation; 1.0 = pure distillation
use_successful_as_teacher=True, # Use successful rollouts as teacher
teacher_model_kind="ema", # Supported: "base", "live", "ema"
teacher_update_rate=0.05, # EMA update rate
include_environment_feedback=True, # required to use the dataset's privileged_context (defaults to False)
)
trainer = SDPOTrainer(
model="Qwen/Qwen2.5-1.5B-Instruct",
reward_funcs=...,
args=training_args,
train_dataset=...,
)
trainer.train()Ожидаемые столбцы набора данных:
promptprivileged_contextдля необязательной обратной связи от среды
Подробнее см. в документации SDPO Trainer.
Само-дистилляция обеспечивает непрерывное обучение
📜 Статья: https://huggingface.co/papers/2601.19897
Само-дистиллированная дообучение (SDFT) выполняет само-дистилляцию в рамках текущей политики, генерируя завершения во время обучения, а затем дистиллируя явное представление этих же завершений, обусловленное учителем, обратно в ученика. Модель-учитель выбирается с помощью teacher_model_kind: "base" (начальный ученик), "live" (текущий ученик) или "ema" (учитель с экспоненциальным усреднением). Промпт для учителя формируется внутренним образом из промпта ученика prompt и привилегированного контекста набора данных privileged_context.
from datasets import Dataset
from trl.experimental.sdft import SDFTConfig, SDFTTrainer
dataset = Dataset.from_dict(
{
"prompt": [[{"role": "user", "content": "Solve 2+2."}]],
"privileged_context": ["Example answer: 4."],
}
)
training_args = SDFTConfig(
distillation_alpha=0.5,
distillation_mode="topk_logits",
distillation_topk=5,
max_completion_length=64,
)
trainer = SDFTTrainer(
model="Qwen/Qwen2.5-1.5B-Instruct",
args=training_args,
train_dataset=dataset,
)
trainer.train()Ожидаемые столбцы набора данных:
promptprivileged_context, содержащий только дополнительную информацию, доступную только учителю
Подробнее см. в документации SDFT Trainer.
Простая самодистилляция улучшает генерацию кода
📜 Статья: https://huggingface.co/papers/2604.01193
Simple Self-Distillation (SSD) улучшает генерацию кода, отбирая завершения от модели при заданной температуре и конфигурации усечения во время обучения, а затем дообучая модель на этих необработанных, непроверенных образцах с использованием стандартной функции потерь кросс-энтропии. Модель вознаграждения, верификатор, учительская модель или обучение с подкреплением не требуются. SSD изменяет распределения токенов в зависимости от контекста: подавляя «хвосты» отвлекающих токенов в позициях «фиксации» (где синтаксис оставляет мало неоднозначности) и сохраняя разнообразие в позициях «ветвления» (где существует несколько допустимых продолжений).
TRL поставляла реализацию в виде SSDTrainer до версии v1.15; теперь она больше не входит в состав библиотеки и остаётся доступной в истории git.
Исправление для Softmax и кросс-энтропии
📜 Статья: https://huggingface.co/papers/2610.31642
Определяет коллапс softmax при предсказаниях с высокой уверенностью и взаимное уничтожение, когда логиты ученика и учителя почти совпадают. Головки для кусковой лог-вероятности и дистилляции в TRL используют нормализацию с исключением целевого значения и разности вероятностей в лог-пространстве, чтобы сохранять малые градиенты. Числовые исправления применяются автоматически, в том числе для прямой KL, обратной KL и обобщённого JSD в DistillationTrainer.
Приложение B.4 работы Entropy-preserving reinforcement learning ранее выявило сбой градиента политики при высокой уверенности и предложило выборочно пересчитывать градиенты в FP64. Ядра TRL сохраняют эти градиенты, используя устойчивые формулы FP32.
Отдельная проблема с приведением типа вывода FSDP2, обсуждаемая в Приложении B.1, решена в Accelerate #4403. В более старых версиях Accelerate для сохранения выходов ядра в FP32 требуется политика смешанной точности с output_dtype=None.
В следующем примере гиперпараметры, приведённые в разделе 7, сопоставляются с целью forward-KL в TRL, которая использует градиент студента, соответствующий кросс-энтропии с мягкими целевыми значениями. Пример иллюстрирует дистилляцию языковой модели, а не воспроизводит эксперимент с модульной арифметикой из статьи. В статье веса студента инициализируются весами учителя; это необходимо учитывать при построении моделей независимо от конфигурации. Остальные значения по умолчанию для тренера остаются без изменений.
from trl import DistillationConfig
training_args = DistillationConfig(
beta=0.0, # Forward KL has the same student gradient as soft-target cross-entropy.
temperature=4.0, # "distillation temperature T=4"
learning_rate=2e-3, # "eta=2 x 10^-3"
lr_scheduler_type="constant",
optim="adamw_torch", # AdamW with zero weight decay has the same updates as Adam.
weight_decay=0.0, # "lambda=0"
adam_epsilon=1e-8, # "epsilon=10^-8"
max_steps=2000, # "2,000 steps of Adam"
)Распределённое обучение
ZeRO: Оптимизация памяти для обучения моделей с триллионом параметров
📜 Статья: https://huggingface.co/papers/1910.02054
ZeRO (Zero Redundancy Optimizer) устраняет избыточность памяти при обучении с параллелизмом по данным и по модели, распределяя состояния оптимизатора, градиенты и параметры между устройствами, сохраняя при этом низкий объём коммуникации и высокую вычислительную гранулярность. Это позволяет эффективно обучать большие модели, которые иначе не поместились бы в память GPU.
TRL поддерживает ZeRO через интеграцию с DeepSpeed. Для этого укажите файл конфигурации DeepSpeed с нужными параметрами,
{
"zero_optimization": {"stage": 3},
"bf16": {"enabled": "auto"},
"train_batch_size": "auto",
"train_micro_batch_size_per_gpu": "auto"
}Укажите deepspeed="zero3.json" в конфигурации обучения и запустите скрипт обучения с помощью torchrun.
torchrun --nproc_per_node 2 train.py