TRL documentation

Индекс статей

You are viewing v1.18.1 version. A newer version v1.18.2 is available.
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Индекс статей

Каждая статья ниже содержит ссылку на её страницу на 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 следует структурированной эволюции из четырех этапов:

  1. Холодный старт: базовая модель дообучается на небольшом наборе высококачественных длинных данных Chain-of-Thought (CoT), чтобы обеспечить стабильную отправную точку.
  2. RL с акцентом на рассуждения: крупномасштабное RL применяется для повышения производительности в математике, программировании и логике, используя правила-наградные функции и награду за языковую согласованность для снижения смешения языков.
  3. Rejection Sampling & SFT: контрольная точка RL генерирует 600 тыс. образцов рассуждений с помощью rejection sampling, которые объединяются с 200 тыс. образцов без рассуждений (общего назначения) для создания нового набора данных для второго раунда Supervised Fine-Tuning.
  4. 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. Она отличалась от описанной выше цели на уровне последовательности только в том случае, если преимущество изменяется в зависимости от t t , что TRL в настоящее время не генерирует.

Соотношение политик: GRPO и GSPO

В GSPO отношение политик определяется на уровне последовательности. Иными словами, это отношение вероятности генерации данной последовательности текущей политикой к вероятности генерации той же последовательности старой политикой.

Вероятность последовательности определяется как: πθ(oi∣q)=∏t=1∣oi∣πθ(oi,t∣q,oi,<t), \pi_\theta (o_i | q) = \prod_{t=1}^{|o_i|} \pi_\theta (o_{i,t} | q, o_{i, < t} ),

где πθ \pi_\theta — политика π \pi с параметрами θ\theta, oi o_i — i i --я выходная последовательность o o а oi,to_{i,t} — t t --й токен в этой последовательности, q q — входной запрос. Соотношение вероятностей последовательности si(θ) s_i (\theta) определяется следующим образом: si(θ)=(πθ(oi∣q)πθold(oi∣q))1∣oi∣ s_i (\theta) = \left(\frac{\pi_\theta (o_i | q)}{\pi_{\theta_{old}} (o_i | q)} \right)^{\frac{1}{|o_i|}}

Показатель степени 1∣oi∣ \frac{1}{|o_i|} представляет собой нормализацию по длине последовательности, минимизирующую влияние длины последовательности на её вероятность. Иными словами, вычисляется среднее геометрическое вероятностей токенов, что обеспечивает справедливое сравнение последовательностей разной длины.

Хотя GSPO определяет отношение политик на уровне последовательности, GRPO работает на уровне токенов. Конкретно, GRPO вычисляет отношение важности для каждого токена в последовательности: wi,t(θ)=πθ(oi,t∣q,oi,<t)πθold(oi,t∣q,oi,<t) w_{i,t}(\theta) = \frac{\pi_\theta (o_{i,t} | q, o_{i,< t})}{\pi_{\theta_{\text{old}}} (o_{i,t} | q, o_{i,< t})}

Затем это токенное отношение объединяется с общим преимуществом A^i \hat{A}_i , и цель GRPO обрезает и оптимизирует каждый токен независимо в пределах последовательности.

Оптимизация политики по среднему геометрическому

📜 Статья: https://huggingface.co/papers/2507.20673

Оптимизация политики по среднему геометрическому (GMPO) — это вариант GRPO, который максимизирует среднее геометрическое отношений важности на уровне токенов, а не среднее арифметическое. Среднее геометрическое гораздо менее чувствительно к выбросам в отношениях, поэтому обновление политики более стабильно и допускает значительно более широкий диапазон обрезания. Обрезание применяется для каждого токена в логарифмическом пространстве и является односторонним в соответствии со знаком преимущества (стандартная область доверия PPO) — при этом оно выполняется до вычисления среднего геометрического. Именно это отличает GMPO от GSPO (importance_sampling_level="sequence"), где обрезание отношения на уровне последовательности выполняется после усреднения.

Целевая функция GMPO заменяет посимвольное арифметическое среднее в GRPO на геометрическое средние (обрезанных) отношений токенов: JGMPO(θ)=Eq,{oi}[1G∑i=1G(∏t=1∣oi∣min⁡[wi,t(θ)sgn⁡(A^i), clip⁡(wi,t(θ)sgn⁡(A^i),ϵ1,ϵ2)]sgn⁡(A^i))1∣oi∣A^i] \mathcal{J}_{\text{GMPO}}(\theta) = \mathbb{E}_{q, \{o_i\}} \left[ \frac{1}{G} \sum_{i=1}^{G} \left( \prod_{t=1}^{|o_i|} \min\left[ w_{i,t}(\theta)^{\operatorname{sgn}(\hat{A}_i)},\ \operatorname{clip}\left(w_{i,t}(\theta)^{\operatorname{sgn}(\hat{A}_i)}, \epsilon_1, \epsilon_2\right) \right]^{\operatorname{sgn}(\hat{A}_i)} \right)^{\frac{1}{|o_i|}} \hat{A}_i \right]

где wi,t(θ) w_{i,t}(\theta) — отношение важности для каждого токена. На практике произведение и обрезание вычисляются в логарифмическом пространстве для численной стабильности, а диапазон обрезания (ϵ1,ϵ2)=(e−0.4,e0.4) (\epsilon_1, \epsilon_2) = (e^{-0.4}, e^{0.4}) значительно шире, чем в 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

Авторы данной статьи обнаруживают, что комбинация:

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

позволяет раскрыть потенциал обучения политик без критика с использованием стандартной функции потерь 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: Ea∼πinference(θold)[min⁡(πtraining(a,θ)πtraining(a,θold) A^,  clip(πtraining(a,θ)πtraining(a,θold), 1−ϵ, 1+ϵ) A^)] \small{ \mathbb{E}_{a\sim\textcolor{red}{\pi_{\text{inference}}}(\theta_{\mathrm{old}})} \Bigl[ \min\Bigl( \frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})}\,\hat A, \;\mathrm{clip}\bigl(\frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})},\,1-\epsilon,\,1+\epsilon\bigr)\,\hat A \Bigr) \Bigr] }

Несмотря на то, что πinference \textcolor{red}{\pi_{\text{inference}}} и πtraining \textcolor{blue}{\pi_{\text{training}}} используют одни и те же параметры модели θ \theta , они могут генерировать существенно различные вероятности токенов. Это неожиданное поведение неявно нарушает предположение об on-policy и незаметно переводит обучение в off-policy режим.

Метод усечённого importance sampling (TIS) решает эту проблему, адаптируя обновление модели с помощью коррекции importance sampling. Вычисление градиента для упомянутой выше цели PPO принимает вид Ea∼πinference(θold)[clip(πtraining(a,θold)πinference(a,θold),Cmin⁡,Cmax⁡)⏟truncated importance ratio⋅∇θmin⁡(πtraining(a,θ)πtraining(a,θold) A^,  clip(πtraining(a,θ)πtraining(a,θold), 1−ϵ, 1+ϵ) A^)] \small{ \mathbb{E}_{a\sim\textcolor{red}{\pi_{\text{inference}}}(\theta_{\mathrm{old}})} \Bigl[ \underbrace{\text{clip}\bigl(\frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})}{\textcolor{red}{\pi_{\text{inference}}}(a, \theta_{\mathrm{old}})}, C_{\min}, C_{\max}\bigr)}_{\text{truncated importance ratio}} \cdot \nabla_\theta \min\Bigl( \frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})}\,\hat A, \;\mathrm{clip}\bigl(\frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})},\,1-\epsilon,\,1+\epsilon\bigr)\,\hat A \Bigr) \Bigr] }

где Cmin⁡ C_{\min} и Cmax⁡ C_{\max} являются гиперпараметрами. 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

📰 Блог: https://yingru.notion.site/When-Speed-Kills-Stability-Demystifying-RL-Collapse-from-the-Training-Inference-Mismatch-271211a558b7808d8b12d403fd15edda

Маскированное Importance Sampling (MIS) решает ту же проблему, что и Truncated Importance Sampling но заменяет обрезание на маскирование. MIS занимает более решительную позицию, отбрасывая обновления, расхождение которых выходит за пределы диапазона [Cmin⁡,Cmax⁡] [C_{\min}, C_{\max}] .

Ea∼πinference(θold)[1[Cmin⁡≤πtraining(a,θold)πinference(a,θold)≤Cmax⁡]⋅πtraining(a,θold)πinference(a,θold)⏟masked importance ratio⋅∇θmin⁡(πtraining(a,θ)πtraining(a,θold) A^,  clip(πtraining(a,θ)πtraining(a,θold), 1−ϵ, 1+ϵ) A^)] \small{ \mathbb{E}_{a\sim\textcolor{red}{\pi_{\text{inference}}}(\theta_{\mathrm{old}})} \Bigl[ \underbrace{\mathbf{1}\left[ C_{\min} \le \frac{\pi_{\text{training}}(a, \theta_{\mathrm{old}})} {\pi_{\text{inference}}(a, \theta_{\mathrm{old}})} \le C_{\max} \right] \cdot \frac{\pi_{\text{training}}(a, \theta_{\mathrm{old}})} {\pi_{\text{inference}}(a, \theta_{\mathrm{old}})}}_{\text{masked importance ratio}} \cdot \nabla_\theta \min\Bigl( \frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})}\,\hat A, \;\mathrm{clip}\bigl(\frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})},\,1-\epsilon,\,1+\epsilon\bigr)\,\hat A \Bigr) \Bigr] }

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, старые лог-вероятности принадлежат сэмплеру, поэтому отношение вычисляется непосредственно между обучаемой политикой и сэмплером, а токены вне диапазона [Cmin⁡,Cmax⁡] [C_{\min}, C_{\max}] исключаются из функции потерь. Эта опция включена по умолчанию:

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
)

Важность выборки на уровне последовательности

📰 Блог: https://yingru.notion.site/When-Speed-Kills-Stability-Demystifying-RL-Collapse-from-the-Training-Inference-Mismatch-271211a558b7808d8b12d403fd15edda

Теоретически обоснованным способом коррекции смещения распределения между этапами обучения и инференса является importance sampling, как описано в двух упомянутых выше статьях Truncated Importance Sampling и Masked Importance Sampling. Однако выбор формулировки имеет решающее значение для сохранения не смещённости градиента и обеспечения стабильного обучения.

Эта работа показывает, что importance sampling на уровне последовательности — это корректный подход для решения проблемы рассогласования между обучением и инференсом. Хотя importance sampling на уровне токенов обеспечивает меньшую дисперсию, чем отношение на уровне последовательности, он вносит смещение и, следовательно, считается непригодным для авторегрессионных моделей. Оценщик градиента на уровне токенов: Ex∼D, y∼πθinference(⋅∣x)[R(x,y) ⋅ ∑t=0∣y∣−1πθtraining(yt ∣ x,y<t)πθinference(yt ∣ x,y<t) ∇θlog⁡πθtraining(yt ∣ x,y<t)] \mathbb{E}_{x\sim\mathcal{D},\, y\sim \pi^{\text{inference}}_\theta(\cdot|x)} \Bigg[ R(x,y)\,\cdot\, \sum_{t=0}^{|y|-1} \frac{\pi^{\text{training}}_\theta(y_t\,|\,x, y_{<t})} {\pi^{\text{inference}}_\theta(y_t\,|\,x, y_{<t})} \,\nabla_\theta \log \pi^{\text{training}}_\theta(y_t\,|\,x, y_{<t}) \Bigg] Правильный, несмещённый оценщик градиента политики применяет единое отношение важности ко всей сгенерированной последовательности (траектории) y y , Оценщик Sequence-Level IS выглядит так: Ex∼D, y∼πθinference(⋅∣x)[πθtraining(y∣x)πθinference(y∣x) R(x,y) ∇θlog⁡πθtraining(y∣x)] \mathbb{E}_{x\sim\mathcal{D},\, y\sim \pi^{\text{inference}}_\theta(\cdot|x)} \Bigg[ \frac{\pi^{\text{training}}_\theta(y|x)} {\pi^{\text{inference}}_\theta(y|x)} \, R(x,y)\, \nabla_\theta \log \pi^{\text{training}}_\theta(y|x) \Bigg]

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 с помощью отношения важности между текущей политикой πθ \pi_\theta и политикой поведения πold \pi_{\text{old}} . DKL ⁣(πθ(oi,t) ∥ πref(oi,t))=πθ(oi,t∣q,oi,<t)πold(oi,t∣q,oi,<t)(πref(oi,t∣q,oi,<t)πθ(oi,t∣q,oi,<t)−log⁡πref(oi,t∣q,oi,<t)πθ(oi,t∣q,oi,<t)−1). \mathrm{D}_{\mathrm{KL}}\!\left(\pi_\theta(o_{i,t}) \,\|\, \pi_{\text{ref}}(o_{i,t})\right) = \textcolor{red}{\frac{\pi_\theta(o_{i,t}\mid q, o_{i,<t})}{\pi_{\text{old}}(o_{i,t}\mid q, o_{i,<t})}} \left( \frac{\pi_{\text{ref}}(o_{i,t}\mid q, o_{i,<t})}{\pi_\theta(o_{i,t}\mid q, o_{i,<t})} - \log \frac{\pi_{\text{ref}}(o_{i,t}\mid q, o_{i,<t})}{\pi_\theta(o_{i,t}\mid q, o_{i,<t})} - 1 \right).

Эта функция включена по умолчанию (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 Mi,t\textcolor{red}{M_{i,t}} определяется следующим образом: Mi,t={0if A^i,t<0and1∣oi∣∑t=1∣oi∣log⁡πθold(oi,t∣q,oi,<t)πθ(oi,t∣q,oi,<t)>δ1otherwise \textcolor{red}{M_{i,t}} = \begin{cases} 0 & \text{if } \hat{A}_{i,t} < 0 \quad \text{and} \quad \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} \log \frac{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,<t})}{\pi_\theta(o_{i,t} \mid q, o_{i,<t})} > \textcolor{blue}{\delta} \\ 1 & \text{otherwise} \end{cases}

Затем эта маска применяется к функции потерь GRPO следующим образом: LGRPO(θ)=−1G∑i=1G1∣oi∣∑t=1∣oi∣[min⁡(πθ(oi,t∣q,oi,<t)πθold(oi,t∣q,oi,<t)A^i,t, clip(πθ(oi,t∣q,oi,<t)πθold(oi,t∣q,oi,<t),1−ϵ,1+ϵ)A^i,t)Mi,t−βDKL[πθ∥πref]] \mathcal{L}_{\text{GRPO}}(\theta) = -\frac{1}{G} \sum_{i=1}^G \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} \left[ \min \left( \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,< t})} \hat{A}_{i,t}, \, \text{clip}\left( \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,< t})}, 1 - \epsilon, 1 + \epsilon \right) \hat{A}_{i,t} \right) \textcolor{red}{M_{i,t}} - \beta \mathbb{D}_{\text{KL}}\left[\pi_\theta \| \pi_{\text{ref}}\right] \right]

Чтобы включить эту функцию, используйте off_policy_mask_threshold (соответствующий δ \textcolor{blue}{\delta} ) в GRPOConfig:

from trl import GRPOConfig

training_args = GRPOConfig(
    ...,
    off_policy_mask_threshold=0.5,
)

Хотя в статье не указано значение δ \textcolor{blue}{\delta} , хорошей отправной точкой может служить δ=0.5 \textcolor{blue}{\delta} = 0.5 . Если обучение кажется слишком консервативным или маскируется слишком много последовательностей, можно увеличить значение. Для справки, δ=1.0 \textcolor{blue}{\delta} = 1.0 соответствует среднему расхождению логарифмического отношения 1 нат на токен, то есть на последовательностях, где этот порог превышен, старая политика в среднем была e1≈2.7 e^1 \approx 2.7 раз более вероятна в генерации этих токенов, чем текущая политика.

  • Стратегия Keep Sampling Mask , которая сохраняет беспристрастность выборки top-k/top-p. Сэмплер извлекает каждый токен из усечённой области определения Si,t \textcolor{red}{\mathcal{S}_{i,t}} , то есть из токенов, оставшихся после усечения, поэтому лог-вероятность политики нормируется заново на этой же области определения: log⁡πθ(oi,t∣q,oi,<t)=zoi,t−log⁡∑v∈Si,tezv. \log \pi_\theta(o_{i,t} \mid q, o_{i,<t}) = z_{o_{i,t}} - \log \sum_{v \in \textcolor{red}{\mathcal{S}_{i,t}}} e^{z_v}.

Без этого отношение важности смещено в сторону занижения, и градиент продолжает переносить вероятность на токены, которые сэмплер никогда не выбирает, что приводит к срыву обучения. Это поддерживается в 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 для обучения с подкреплением с несколькими наградами, просто установите:

Для группы из N N наград и G G выборок на группу GDPO нормализует каждую награду независимо: An(i,j)=rn(i,j)−mean{rn(i,1),…,rn(i,G)}std{rn(i,1),…,rn(i,G)}+ϵ A_n^{(i,j)} = \frac{r_n^{(i,j)} - \text{mean}\{r_n^{(i,1)}, \ldots, r_n^{(i,G)}\}}{\text{std}\{r_n^{(i,1)}, \ldots, r_n^{(i,G)}\} + \epsilon}

Затем нормализованное групповое преимущество агрегируется по наградам: A(i,j)=∑n=1NwnAn(i,j) A^{(i,j)} = \sum_{n=1}^{N} w_n A_n^{(i,j)}

Итоговая нормализация по батчу даёт: A^(i,j)=A(i,j)−meani′,j′{A(i′,j′)}stdi′,j′{A(i′,j′)}+ϵ \hat{A}^{(i,j)} = \frac{A^{(i,j)} - \text{mean}_{i',j'}\{A^{(i',j')}\}}{\text{std}_{i',j'}\{A^{(i',j')}\} + \epsilon}

Здесь meani′,j′{A(i′,j′)} \text{mean}_{i',j'}\{A^{(i',j')}\} и stdi′,j′{A(i′,j′)} \text{std}_{i',j'}\{A^{(i',j')}\} обозначают статистику по всем группам в батче.

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, которая плавно подавляет экстремальные веса важности на уровне последовательности, не внося смещения по длине. LVESPO(θ)=−Eτ∼μ[W(τ)k⋅exp⁡(λ(1−W(τ)))⏟ϕ(W) detached ⋅A(τ)⋅log⁡πθ(τ)] \mathcal{L}_{\text{VESPO}}(\theta) = - \mathbb{E}_{\tau \sim \mu} \left[ \underbrace{W(\tau)^{k} \cdot \exp\left(\lambda (1 - W(\tau))\right)}_{\phi(W) \text{ detached }} \cdot \mathcal{A}(\tau) \cdot \log \pi_\theta(\tau) \right]

где W(τ)=πθ(τ)μ(τ) W(\tau) = \frac{\pi_\theta(\tau)}{\mu(\tau)} — отношение важности на уровне последовательности, а ϕ(W) \phi(W) отсоединяется от графа вычислений и служит коэффициентом масштабирования градиента.

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

При рассогласовании между обучением и инференсом оценка ∇θlog⁡πθ \nabla_\theta \log \pi_\theta в среднем равна нулю при сэмплере μ \mu , поэтому каждое обновление смещает политику в сторону сэмплера, причём величина смещения растёт вместе с преимуществом. Центрирование оценки вычитает это математическое ожидание на каждой позиции, так что постоянное преимущество больше не сдвигает политику: ∇θL=−Eo∼μ[A^(f(rt)∇θlog⁡πθ(ot)−Ev∼μ[f(rv)∇θlog⁡πθ(v)])],rv=πθ(v)μ(v), \nabla_\theta \mathcal{L} = - \mathbb{E}_{o \sim \mu} \left[ \hat{A} \left( f(r_t) \nabla_\theta \log \pi_\theta(o_t) - \mathbb{E}_{v \sim \mu} \left[ f(r_v) \nabla_\theta \log \pi_\theta(v) \right] \right) \right], \quad r_v = \frac{\pi_\theta(v)}{\mu(v)},

с f f весом важности Masked Importance Sampling: f(r)=r f(r) = r внутри [Cmin⁡,Cmax⁡] [C_{\min}, C_{\max}] и 0 0 снаружи. Внутреннее математическое ожидание берется по наиболее вероятным токенам сэмплера на каждой позиции, для которых он сообщает лог-вероятности; для остальной части словаря сэмплер рассматривается как обученная политика, перенормированная на оставшуюся массу.

Это целевая функция по умолчанию для 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. Они также вводят новую функцию потерь, определяемую как: Lhinge-norm(πθ)=E(x,yw,yl)∼D[max⁡(0,  1−[γlog⁡πθ(yw∣x)πref(yw∣x)−γlog⁡πθ(yl∣x)πref(yl∣x)])] \mathcal{L}_{\text{hinge-norm}}(\pi_\theta) = \mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} \left[ \max\left(0,\; 1 - \left[\gamma \log \frac{\pi_\theta(y_w \mid x)}{\pi_\text{ref}(y_w \mid x)} - \gamma \log \frac{\pi_\theta(y_l \mid x)}{\pi_\text{ref}(y_l \mid x)}\right]\right) \right]

Для обучения на данных, отфильтрованных с помощью 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′-оценку: Lf-DPO(πθ)=E(x,yw,yl)∼D[−log⁡σ(βf′(πθ(yw∣x)πref(yw∣x))−βf′(πθ(yl∣x)πref(yl∣x)))] \mathcal{L}_{f\text{-DPO}}(\pi_\theta) = \mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} \left[ -\log \sigma\left( \beta \textcolor{red}{f'}\textcolor{red}{\Big(}\frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)}\textcolor{red}{\Big)} - \beta \textcolor{red}{f'}\textcolor{red}{\Big(}\frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)}\textcolor{red}{\Big)} \right) \right]

где f′ 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 для вероятностей парных предпочтений, max⁡π;E[Ψ(p∗(y≻y′∣x))]−τKL(π∣∣πref), \max_\pi ;\mathbb{E}\big[\Psi\left(p^*(y \succ y' \mid x)\right)\big] - \tau\mathrm{KL}(\pi||\pi_{\text{ref}}),

что раскрывает RLHF и DPO как частные случаи, соответствующие выбору логитов Ψ \Psi . В статье показано, что это преобразование логитов усиливает почти детерминированные предпочтения и фактически ослабляет регуляризацию 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, который добавляет абсолютный член правдоподобия для предотвращения коллапса правдоподобия, наблюдаемого в чисто относительных (контрастных) целевых функциях.

При попарных предпочтениях, для выбранных/отклонённыхK=2 K=2 , определяем оценкиr=β(log⁡πθ−log⁡πref) r=\beta(\log\pi_\theta-\log\pi_{\text{ref}}) , и применяем функцию потерь предпочтений NCA−log⁡σ(rw)−12log⁡σ(−rw)−12log⁡σ(−rl) -\log\sigma(r_w)-\tfrac12\log\sigma(-r_w)-\tfrac12\log\sigma(-r_l) .

Чтобы воспроизвести условия из статьи, используйте эту конфигурацию:

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 при простой модели шума, с доказуемыми гарантиями. Lrobust(πθ)=(1−ε)LDPO(yw,yl)−εLDPO(yl,yw)1−2ε \mathcal{L}_{\text{robust}}(\pi_\theta) = \frac{(1-\varepsilon)\mathcal{L}_{\text{DPO}}(y_w, y_l) - \varepsilon\mathcal{L}_{\text{DPO}}(y_l, y_w)} {1-2\varepsilon}

Where LDPO \mathcal{L}_{\text{DPO}} is the DPO loss defined in Direct Preference Optimization: Your Language Model is Secretly a Reward Model and ε \varepsilon 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 "ε\varepsilon"} in Section 6 of the paper
)

Оптимизация бинарного классификатора для выравнивания больших языковых моделей

📜 Статья: https://huggingface.co/papers/2404.04656

Теоретический анализ и новый алгоритм, Binary Classifier Optimization, объясняют и улучшают выравнивание больших языковых моделей с использованием бинарных сигналов обратной связи. Для воспроизведения условий из статьи используйте следующую конфигурацию:

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

Для настройки попарных предпочтений функция потерь BCO определяется как: Lbco_pair(πθ)=E(x,yw,yl)∼D[−log⁡σ(β[(log⁡πθ−log⁡πref)(yw)−(log⁡πθ−log⁡πref)(yl)])] \mathcal{L}_{\text{bco\_pair}}(\pi_\theta) = \mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} \left[ -\log \sigma\Big( \beta[(\log\pi_\theta-\log\pi_{\text{ref}})(y_w) - (\log\pi_\theta-\log\pi_{\text{ref}})(y_l)] \Big) \right]

Чтобы воспроизвести статью в этой конфигурации, используйте следующие настройки:

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. Потери: LWPO=−E(x,yw,yl)∼D[w(x,yw)w(x,yl)log⁡p(yw≻yl∣x)] \mathcal{L}_{\text{WPO}} = -\mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} \left[ \textcolor{red}{w(x, y_w) w(x, y_l)} \log p(y_w \succ y_l \mid x) \right]

где вес w(x,y) w(x, y) определяется как: w(x,y)=exp⁡(1∣y∣∑t=1∣y∣log⁡πθ(yt∣x,y<t)∑v∈Vπθ(v∣x,y<t)2) w(x, y) = \exp\left(\frac{1}{|y|}\sum_{t=1}^{|y|} \log \frac{\pi_\theta(y_t \mid x, y_{<t})}{\sum_{v \in \mathcal{V}} \pi_\theta(v \mid x, y_{<t})^2}\right)

Чтобы воспроизвести условия из статьи, используйте эту конфигурацию:

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, который модифицирует агрегацию лог-вероятностей последовательности, разбивая более длинный ответ на общий префикс (до длины более короткого ответа) и избыточный хвост, а затем снижая вес хвоста с помощью коэффициента α∈[0,1] \alpha \in [0,1] : log⁡πθ(ylong∣x)=log⁡πθ(y1:lp∣x)+α⋅log⁡πθ(ylp+1:l∣x,y1:lp),lp=min⁡(∣yw∣,∣yl∣). \log \pi_\theta(y_{\text{long}}|x) = \log \pi_\theta(y_{1:l_p}|x) + \alpha \cdot \log \pi_\theta(y_{l_p+1:l}|x, y_{1:l_p}), \quad l_p=\min(|y_w|,|y_l|).

Настройка α=1 \alpha=1 восстанавливает стандартный DPO; меньшее значение α \alpha снижает многословность, сохраняя качество предпочтений. Оптимальное значение α \alpha зависит от семейства моделей и от того, обучаете ли вы базовую или instruct-модель, но в статье предлагается α=0.5 \alpha=0.5 как хорошая точка для начала.

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). Функция потерь: Lsigmoid_norm=−log⁡σ ⁣(β(1∣yw∣log⁡πθ(yw∣x)πref(yw∣x)−1∣yl∣log⁡πθ(yl∣x)πref(yl∣x))), \mathcal{L}_{\text{sigmoid\_norm}} = -\log\sigma\!\left(\beta \left({\color{red}\frac{1}{|y_w|}}\log\frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - {\color{red}\frac{1}{|y_l|}}\log\frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)}\right)\right), которую можно задать с помощью:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="sigmoid_norm",
)

Непредвзятое выравнивание больших языковых моделей с зашумленными предпочтениями

📜 Статья: https://huggingface.co/papers/2607.03248

В этой статье шум предпочтений моделируется как инвертирование меток с вероятностью ε \varepsilon и инвертирует это преобразование, так чтобы политика, обученная на зашумленных предпочтениях, имела тот же оптимум, что и при чистых предпочтениях. TRL реализует нормализованную форму полученной функции потерь Unbiased DPO (UDPO), называемой в статье α-UDPO: LUDPO=−αlog⁡ez+aez+1,z=β(log⁡πθ(yw∣x)πref(yw∣x)−log⁡πθ(yl∣x)πref(yl∣x)),a=ε1−ε,α=1+a1−a, \mathcal{L}_{\text{UDPO}} = -\alpha \log \frac{e^{z} + a}{e^{z} + 1}, \quad z = \beta \left( \log \frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - \log \frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)} \right), \quad a = \frac{\varepsilon}{1 - \varepsilon}, \quad \alpha = \frac{1 + \sqrt{a}}{1 - \sqrt{a}},

что является потерей DPO для a=0 a = 0 . Постоянная α \alpha поддерживает максимальную величину градиента равной 1, как в DPO. В отличие от Robust DPO, в статье показано, что оптимум остаётся несмещённым, если истинная вероятность инверсии меньше предполагаемого ε \varepsilon (Следствие 4.7), поэтому ε \varepsilon не обязательно оценивать точно. В TRL ε \varepsilon задаётся с помощью label_smoothing. Чтобы использовать a=0.8 a = 0.8 , значение, которое авторы статьи рекомендуют практикам:

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) и демонстрируя конкурентоспособные результаты в офлайн-обучении с подкреплением. LDFT(θ)=E(x,y)∼D[−∑t=1∣y∣sg(πθ(yt∣y<t,x))  log⁡πθ(yt∣y<t,x)] \mathcal{L}_{\text{DFT}}(\theta) = \mathbb{E}_{(x,y) \sim \mathcal{D}} \left[ - \sum_{t=1}^{|y|} \textcolor{red}{\text{sg}\big(\pi_\theta(y_t \mid y_{<t}, x)\big)} \; \log \pi_\theta(y_t \mid y_{<t}, x) \right]

где sg(⋅) \text{sg}(\cdot) — оператор остановки градиента. Чтобы использовать 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

Для моделей равномерного дискретного диффузного процесса обычная подстановка кросс-энтропии не обучает простому денойзеруE[X0∣Xt] \mathbb{E}[X_0 \mid X_t] а апостериорному распределению leave-one-out (LOO), которое предсказывает каждый токен, не используя его собственное повреждённое значение. В статье выведены точные преобразования между денойзером, апостериорным распределением LOO и градиентом (score), поэтому сеть можно обучать в любом из этих параметризований с одной и той же кросс-энтропией. Даны логитыfθ f_\theta softmax которых параметризует апостериорное распределение LOO, денойзер, используемый в функции потерь, равен dθ(xt,t)ℓ=softmax ⁣(fθ(xt,t)ℓ+log⁡ ⁣(1+K αt1−αt xtℓ)), d_\theta(x_t, t)^\ell = \mathrm{softmax}\!\left( f_\theta(x_t, t)^\ell + \log\!\left(1 + \frac{K\,\alpha_t}{1 - \alpha_t}\, x_t^\ell\right) \right),

то есть аддитивная коррекция логита наблюдаемого токена, гдеK K — размер словаря, аαt \alpha_t — вероятность того, что прямое равномерное распространение сохраняет исходный токен. В статье сообщается, что параметризация 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

В этой статье предложена вспомогательная функция потерь, предназначенная для прямого обучения центрированной модели вознаграждения. Эта вспомогательная функция потерь минимизирует сумму квадратов вознаграждений, побуждая модель естественным образом выдавать выходные значения со средним нулём и тем самым устраняя проблему недоопределённости. L(θ)=−E(x,y+,y−)∼D[log⁡σ(rθ(x,y+)−rθ(x,y−))−η⋅(rθ(x,y+)+rθ(x,y−))2]. \mathcal{L}(\theta) = - \mathbb{E}_{(x,y^+,y^-) \sim \mathcal{D}} \left[ \log \sigma(r_\theta(x, y^+) - r_\theta(x, y^-)) \textcolor{red}{- \eta \cdot (r_\theta(x, y^+) + r_\theta(x, y^-))^2} \right].

Чтобы использовать эту вспомогательную потерю с 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

В этой статье авторы предлагают использовать свои оценки предпочтений, разложенные по шкале из четырёх пунктов (например, значительно лучше) ), чтобы предоставлять более информативную обратную связь модели вознаграждения. Это достигается путём добавления маржи в функцию потерь, что побуждает модель вознаграждения назначать более крупные разрывы в оценках для пар с более высокими оценками предпочтений. L(θ)=−E(x,y+,y−,m)∼D[log⁡σ(rθ(x,y+)−rθ(x,y−)−m)]. \mathcal{L}(\theta) = - \mathbb{E}_{(x,y^+,y^-,\textcolor{red}{m}) \sim \mathcal{D}} \left[ \log \sigma(r_\theta(x, y^+) - r_\theta(x, y^-) \textcolor{red}{- m}) \right].

Вы можете добавить маржу к функции потерь, добавив столбец 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-policydense
Обучение с подкреплениемon-policysparse
Дистилляция по стратегииon-policydense

Метод 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()

Ожидаемые столбцы набора данных:

  • prompt
  • privileged_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()

Ожидаемые столбцы набора данных:

  • prompt
  • privileged_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
Update on GitHub