論文インデックス

以下の各論文は、Hugging Face の論文ページへのリンクです。また、hf CLI を使用してターミナルからこれらを読むこともできます。例えば、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は、純粋な強化学習（RL）から洗練された人間に適合したモデルへと移行する多段階のパイプラインを通じて、OpenAI-o1に匹敵する推論性能を実現しています。ベースモデルに対して純粋なRLを用いた先行モデルDeepSeek-R1-Zeroとは異なり、R1は構造化された4段階の進化を踏みます：

1. Cold Start: The base model is fine-tuned on a small set of high-quality, long Chain-of-Thought (CoT) data to provide a stable starting point.
2. 推論指向のRL: 大規模RLを適用し、ルールベースの報酬と言語一貫性報酬を用いることで、数学、コーディング、論理におけるパフォーマンスを向上させ、言語の混在を軽減します。
3. Rejection Sampling & SFT: RLチェックポイントを使用してリジェクションサンプリングで60万の推論サンプルを生成し、これに20万の非推論（汎用）サンプルを組み合わせることで、第2ラウンドのSupervised Fine-Tuning用の新しいデータセットを作成します。
4. すべてのシナリオへのRL適用: 最終的なRL段階では、推論能力を維持しつつ、すべてのドメインにわたってモデルを人間の好み（有用性と無害性）に整えます。

蒸留: 小型モデルの能力向上

この論文の重要な貢献の一つは、大規模モデル（DeepSeek-R1）から推論パターンを蒸留し、より小さなdenseモデル（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のバリアントです。論文の設定を再現するには、この設定を使用してください。

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
)

このメソッドは、トレーニングがわずかにオフポリシーになる場合にのみ効果があります。例えば、steps_per_generation > gradient_accumulation_stepsまたはnum_iterations > 1の場合です。それ以外の場合は、実質的に修正なしと同等です。

TRL は v1.13 まで実験的な GSPO-token 実装を提供していましたが、現在はライブラリから削除され、git 履歴でのみ利用可能です。上記のシーケンスレベルの目的関数との違いは、アドバンテージが $t$, によって変化する場合にのみ生じましたが、TRL は現在これを生成していません。

ポリシー比：GRPO と GSPO

GSPOでは、ポリシー比はシーケンスレベルで定義されます。つまり、現在のポリシーがシーケンスを生成する確率と、旧ポリシーが同じシーケンスを生成する確率の比です。

シーケンスの尤度は以下のように定義されます: $$\pi_\theta (o_i | q) = \prod_{t=1}^{|o_i|} \pi_\theta (o_{i,t} | q, o_{i, < t} ),$$

ここで $\pi_\theta$ はポリシー $\pi$ のパラメータ $\theta$, $o_i$ は $i$-番目の出力シーケンス $o$ 、 $o_{i,t}$ は $t$-番目のトークンであり、 $q$ は入力クエリです。シーケンス尤度比 $s_i (\theta)$ は以下のように定義されます: $$s_i (\theta) = \left(\frac{\pi_\theta (o_i | q)}{\pi_{\theta_{old}} (o_i | q)} \right)^{\frac{1}{|o_i|}}$$

指数 $\frac{1}{|o_i|}$ はシーケンス長の正規化を表しており、シーケンス尤度におけるシーケンス長の影響を最小限に抑えます。言い換えれば、トークン確率の幾何平均を計算し、異なる長さのシーケンス間で公平な比較を可能にします。

GSPO はシーケンスレベルでポリシー比を定義するのに対し、GRPO はトークンレベルで動作します。具体的には、GRPO はシーケンス内の各トークンについて重要度比を計算します： $$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})}$$

このトークンレベルの比率は、共有アドバンテージ $\hat{A}_i$, と組み合わされ、GRPOの目的関数はシーケンス全体で各トークンを独立にクリップして最適化します。

幾何平均ポリシー最適化

📜 論文: https://huggingface.co/papers/2507.20673

Geometric-Mean Policy Optimization (GMPO)は、GRPOのバリアントであり、算術平均ではなく、トークンレベルの重要性比の幾何平均を最大化します。幾何平均は外れ値の比に対してはるかに感度が低いため、ポリシーの更新がより安定し、はるかに広いクリッピング範囲を許容します。クリッピングはトークンごとに、対数空間で、アドバンテージの符号に基づいて片側のみ（標準的なPPOの信頼領域）に適用されます。重要なのは、これが幾何平均を計算する前に行われる点です。これがGMPOとGSPO（importance_sampling_level="sequence"）を区別する点であり、後者はシーケンスレベルの比を平均化後にクリッピングを適用します。

GMPO の目的関数は、GRPO のトークンごとの算術平均を、(クリップされた) トークン比の幾何平均に置き換えます: $$\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]$$

ここで $w_{i,t}(\theta)$ はトークンごとの重要度比です。実際には、数値の安定性を確保するために、積とクリッピングは対数空間で計算され、クリッピング範囲 $(\epsilon_1, \epsilon_2) = (e^{-0.4}, e^{0.4})$ は GRPO/DAPO と比べて著しく広く、探索を促進するように設計されています。

TRLには実験的な実装が提供されています。Experimental - 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
• Soft Overlong Punishment
• トークンレベルの損失
• Dynamic Sampling（⚠️ 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における長いChain-of-Thought推論の解明

📜 論文: https://huggingface.co/papers/2502.03373

本論文では、長いチェーン・オブ・サウスの強化学習を研究し、2つの補完的なルールベースの報酬を導入します:

• コサイン長さスケーリング報酬（get_cosine_scaled_reward()、付録 C.1）は、正解報酬をコンプリーションの長さでスケーリングします。正解のコンプリーションは短いほど高く評価され、誤答のコンプリーションは長いほどペナルティが小さくなります（探索を維持するため）。
• 長さを整形する際に報酬ハッキング戦略として生じる、退化した反復的な補完を抑制するための、n-gram反復ペナルティ（get_repetition_penalty_reward()、付録C.2）。

これら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は、パーミッションレスな計算リソース提供者の動的かつ異種なスウォーム全体で、完全に非同期のRLを用いて320億パラメータの言語モデルを訓練した、世界初のグローバル分散型強化学習訓練実行です。著者らは、標準的な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の法則が成り立ち、Qwen3モデルにおいて、エントロピーが最も高い20%のトークンのみで学習を行うことは、フルグラデーション更新と同等以上の性能を発揮します。

論文の主要な結果は、バニラ版のDAPO（⚠️ TRLではDynamic Samplingはサポートされていません）を使用しています。主要な結果を再現するには、以下の設定を使用してください：

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
)

Part I: 罠か、それとも技巧か？LLM推論のためのRL（Lite PPO）を深掘りする

📜 論文: https://huggingface.co/papers/2508.08221

この論文の著者たちは、以下の組み合わせが

1. バッチ全体で計算された標準偏差で報酬をスケーリングし
2. 総トークン数で損失を集約する

vanilla PPO lossを用いることで、critic-freeなポリシーの学習能力を引き出すことができます。彼らの結果は、このシンプルな組み合わせが一貫してパフォーマンスを向上させ、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)
)

勾配蓄積を使用する場合、損失はバッチ内のトークン総数で集約されますが、蓄積されたバッチ全体では集約されない点にご注意ください。詳細については、GRPO Trainer - Loss typesを参照してください。

切り詰め重要性サンプリング

📰 ブログ: https://fengyao.notion.site/off-policy-rl

📜 論文: https://huggingface.co/papers/1606.02647

オンラインポリシー学習手法では、通常、ロールアウト生成に最適化された推論フレームワーク（vLLM など）が、トレーニングバックエンドとは別に使用されます。これにより、ロールアウトとトレーニングの不一致が生じ、次の PPO 目的関数にその例が示されています。 $$\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] }$$

にもかかわらず $\textcolor{red}{\pi_{\text{inference}}}$ と $\textcolor{blue}{\pi_{\text{training}}}$ が同じモデルパラメータ $\theta$, を共有しているにもかかわらず、トークン確率に大きな違いが生じることがあります。この予期せぬ挙動は、オンポリシーの前提を暗黙のうちに破り、学習をサイレントにオフポリシーに変えてしまいます。

Truncated Importance Sampling (TIS) は、importance-sampling 補正によってモデルの更新を適応させることで、この問題を解決します。前述の PPO 目的関数の勾配計算は次のようになります $$\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] }$$

ここで $C_{\min}$ および $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

Masked Importance Sampling (MIS) は、 Truncated Importance Sampling と同じ問題を解決しますが、クリッピングをマスキングに置き換えます。MIS は、乖離が範囲外の更新を破棄することで、より決断的なアプローチをとります。 $[C_{\min}, C_{\max}]$.

$$\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
)

の experimental.async_grpo.AsyncGRPOTrainer, では、旧ログ確率はサンプラーのものが使用されるため、比率は学習済みポリシーとサンプラーの間で直接計算されます。また、 $[C_{\min}, C_{\max}]$ の範囲外のトークンは損失から除外されます。この機能はデフォルトで有効になっています:

from trl.experimental.async_grpo 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

訓練と推論の間の分布シフトを補正するための理論的に根拠のある方法は、上記の2つの論文 Truncated Importance Sampling および Masked Importance Sampling で導入された重要性サンプリングです。ただし、勾配のバイアスなしを維持し、安定した訓練を確保するためには、定式化の選択が極めて重要です。

本研究は、シーケンスレベルの重要性サンプリングが、学習と推論の不一致に対処するための健全なアプローチであることを示しています。トークンレベルの重要性サンプリングはシーケンスレベルの比率よりも分散が低くなりますが、バイアスを導入するため、自己回帰モデルには不適切であるとされています。トークンレベルの勾配推定子は $$\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$, シーケンスレベルのIS推定子は次のようになります: $$\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は、vllm_importance_sampling_mode設定パラメータを通じて、重要性サンプリングの粒度レベルを公開しています。ここで、"sequence_*"モードはシーケンスレベルの重要性サンプリング比を実装し、"token_*"モードはトークンごとの比を実装します。

強化学習のスケーリングの技術

📜 論文: https://huggingface.co/papers/2510.13786

大規模言語モデルにおける強化学習のスケーリングを分析・予測するためのフレームワークを定義し、計算効率に影響を与える重要な設計選択を特定した体系的な研究であり、ベストプラクティスのレシピであるScaleRLを提案しています。

以下の設定を使用することで、GRPOTrainerを用いてScaleRLのレシピを部分的に再現できます。

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
)

It Takes Two: あなたのGRPOは実はDPO

📜 論文: https://huggingface.co/papers/2510.00977

GRPOの有効性は、大規模なグループサイズによる正確なアドバンテージ推定ではなく、暗黙の対比目的関数に由来することを示しています。これにより、GRPOとDPOの間の形式的な接続が確立され、グループサイズは対比目的関数のモンテカルロ推定値にのみ影響を与えることが明らかになりました。著者らは、ロールアウトを2回のみ使用する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,
)

Soft Adaptive Policy Optimization

📜 論文: https://huggingface.co/papers/2511.20347

Soft Adaptive Policy Optimization (SAPO) は、ハードクリッピングを、オフポリシー更新を適応的に減衰させつつ有用な学習シグナルを保持する、温度制御された滑らかなゲートに置き換えます。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では、以下を実装しています：

• 無偏 KL 推定 無偏 KL 推定, は、現在のポリシー $\pi_\theta$ と行動ポリシー $\pi_{\text{old}}$. $$\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).$$

この機能はデフォルトで有効になっています（GRPOConfigのuse_bias_correction_kl=True）ので、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ダイバージェンスが高い）しているシーケンスを無視することで、学習を安定化させます。

オフポリシーバイナリマスク $\textcolor{red}{M_{i,t}}$ は以下のように定義されます: $$\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 の損失に適用されます。 $$\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}$ の値は指定されていませんが、良い初期値としては $\textcolor{blue}{\delta} = 0.5$. が考えられます。トレーニングが保守的すぎる、またはマスクされるシーケンスが多すぎる場合は、値を大きくできます。参考までに、 $\textcolor{blue}{\delta} = 1.0$ は、トークンあたり平均 1 nat の対数比発散に対応します。つまり、この閾値を超えたシーケンスでは、旧ポリシーは現在のポリシーよりも平均して $e^1 \approx 2.7$ 倍の確率でこれらのトークンを生成していたことになります。

• トップk/トップpサンプリングのバイアスを保つ Keep Sampling Mask 戦略では、サンプラーが切り詰められたサポート $\textcolor{red}{\mathcal{S}_{i,t}}$, 、つまり切り詰め後に残ったトークンから各トークンを抽出するため、ポリシーの対数確率が同じサポート上で再正規化されます: $$\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}.$$

これを無視すると、重要度比が低くバイアスがかかり、勾配がサンプラーが決して抽出しないトークンに確率質量を押し付け続けるため、学習が崩壊します。これはexperimental.async_grpo.AsyncGRPOTrainerでサポートされています。top_p < 1.0、top_k > 0、またはmin_p > 0.0の場合、ロールアウトワーカーはvLLM（>= 0.28、--return-sampling-mask --enable-scale-outで開始）から各トークンのサポートを記録し、トレーナーはそれに対して再正規化を行います。

from trl.experimental.async_grpo import AsyncGRPOConfig

training_args = AsyncGRPOConfig(
    ...,
    top_p=0.95,
    top_k=512,
)

vLLMのcolocateモード（>= 0.28）では、GRPOTrainerでもサポートされています。top_k > 0かつ重要性サンプリング補正が有効（デフォルト）の場合、vLLMは各トークンのサポートを返し、トレーナーがその範囲で再正規化を行います：

from trl import GRPOConfig

training_args = GRPOConfig(
    ...,
    use_vllm=True,
    top_p=0.95,
    top_k=512,
)

GDPO: 複数報酬RL最適化のためのグループ報酬分離正規化ポリシー最適化

📜 論文: https://huggingface.co/papers/2601.05242

GDPOは、マルチリワード学習のために設計された強化学習の最適化手法です。既存のアプローチでは、マルチリワード設定でGroup Relative Policy Optimization (GRPO)が一般的に適用されていますが、著者らは、これによりリワードアドバンテージの崩壊が発生し、学習シグナルの解像度が低下して、不安定な収束や収束失敗を引き起こすことを示しています。GDPOは、個々のリワード間のリワード正規化を分離することでこの問題を解決し、それらの相対的な差を保持したまま、より忠実な選好最適化を可能にします。GDPOをマルチリワードRL学習に適用するには、以下を設定するだけです：

報酬のグループ数が $N$ 、グループごとのサンプル数が $G$ の場合、GDPO は各報酬を独立に正規化します: $$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)} = \sum_{n=1}^{N} w_n A_n^{(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}$$

ここで、 $\text{mean}_{i',j'}\{A^{(i',j')}\}$ 、 $\text{std}_{i',j'}\{A^{(i',j')}\}$ バッチ内のすべてのグループにわたる統計量を表します。

from trl import GRPOConfig


training_args = GRPOConfig(
    ...,
    multi_objective_aggregation="normalize_then_sum",
)

このメソッドは、複数の報酬関数を用いたトレーニングの場合にのみ効果があります。

著者らは、スラームフリーで使いやすいつainingの例を提供しており、コミュニティがGDPOのGRPOに対する有効性を迅速に検証できるようにしています。詳細は、実験-”Aha” momentを参照してください。

Length-Unbiased Sequence Policy Optimization: Revealing and Controlling Response Length Variation in 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学習のための変分シーケンスレベルソフトポリシー最適化

📜 論文: https://huggingface.co/papers/2602.10693

VESPO は、ポリシーの陳腐化、非同期更新、および学習と推論の不一致によって引き起こされるオフポリシー RL における学習の不安定性に対処します。ヒューリスティックなトークンレベルのクリッピング（GRPO）やシーケンス長正規化（GSPO）に頼るのではなく、VESPO は変分フレームワークから原理的なリシェーピングカーネルを導出します。実際には、これにより滑らかで非対称な Gamma 重み付け関数が得られ、長さバイアスを導入することなく、極端なシーケンスレベルの重要度重みを適切に抑制します。 $$\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(\tau) = \frac{\pi_\theta(\tau)}{\mu(\tau)}$ はシーケンスレベルの重要度比であり、 $\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

学習と推論の不一致下では、スコア $\nabla_\theta \log \pi_\theta$ は、サンプラー $\mu$, の下で平均がゼロにならず、すべての更新がアドバンテージに比例する量だけポリシーをサンプラーへ引き寄せてしまいます。スコアセンタリングは各位置でその期待値を差し引くことで、一定のアドバンテージではポリシーが動かなくなります。 $$\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$ の重要性重みは、 Masked Importance Sampling: $f(r) = r$ 内では $[C_{\min}, C_{\max}]$ 、外では $0$ です。内側の期待値は、各位置でサンプラーが最も確率の高いトークンに対してとられ、その対数確率が報告されます。残りの語彙については、サンプラーは残りの質量に再スケーリングされた学習済みポリシーとして扱われます。

experimental.async_grpo.AsyncGRPOTrainerのデフォルトの目的であり、そのロールアウトワーカーはvLLMに対して、生成されたすべてのトークンの上位の対数確率を要求します。

from trl.experimental.async_grpo 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に関連する論文。

最適アドバンテージ回帰によるLLM推論のRL高速化

📜 論文: https://huggingface.co/papers/2505.20686

A*-PO（Optimal Advantage Regression）は、オンラインクリティクとマルチサンプルグループロールアウトの両方を回避する、LLM推論のための2段階の強化学習手法です。第1段階では、参照ポリシーのサンプルからオフラインで最適価値V*(x) = β·log E_{y∼π_ref}[exp(r(x, y)/β)]を推定します。第2段階では、プロンプトごとに1回の生成のみを行い、二乗誤差回帰損失(β·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()

直接ポリシー最適化

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を補完する。また、以下のように定義される新しい損失関数も導入している。 $$\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フィルタリング済みデータとヒンジノルム損失を使用して学習するには、以下のコードを使用できます。

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()

Reverse KLを超えて: 多様な分散制約によるDirect Preference Optimizationの一般化

📜 論文: https://huggingface.co/papers/2309.16240

f-DPO を提案します。通常の reverse-KL 正則化項を一般的な f 分散に置き換えることで DPO を拡張し、mode-seeking と mass-covering の挙動のトレードオフを調整できます（例: forward KL、JS、α 分散）。変更点は、DPO の log-ratio margin を f' スコアに置き換えることです f' スコア: $$\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 \)-発散を定義する凸関数の微分です。

再現方法:

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_\pi ;\mathbb{E}\big[\Psi\left(p^*(y \succ y' \mid x)\right)\big] - \tau\mathrm{KL}(\pi||\pi_{\text{ref}}),$$

これにより、RLHF と DPO が、logit の選択に対応する特殊ケースであることが明らかになります $\Psi$. この論文では、この logit 変換がほぼ決定論的な選好を増幅し、KL 正則化を効果的に弱めることを示しており、過学習を説明しています。 Identity 変換 (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を提案しています。InfoNCAは、応答に対する報酬誘起の目標分布に一致させることで、明示的な報酬（または選好）からポリシーを学習します。また、DPOがその特殊な二値ケースであることを示しています。さらに、NCAを導入し、純粋な相対的（対照的）目的関数で観察される可能性の崩壊を防ぐために、絶対的な可能性項を追加しています。

ペアワイズ好みを扱う場合、chosen/rejected を$K=2$, スコアを定義します$r=\beta(\log\pi_\theta-\log\pi_{\text{ref}})$, NCA 好み損失を適用します$-\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損失を解析的にデバイズすることでこれを修正し、証明可能な保証を提供します。 $$\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 $\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は、言語モデルのアライメントを、最適な報酬加重分布からの行動クローニングとして再定式化します。これにより、強化学習を回避しつつ理論的根拠を維持する、単純な教師あり学習の目的関数が得られます。 非対応の報酬データとペアワイズ好意データの両方をサポートし、報酬シフト不変の定式化により、好意設定ではDPOスタイルの損失関数に帰着します。

ペアワイズ選好設定において、BCO損失は以下のように定義されます。 $$\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) は、学習中に参照ポリシーを更新します。Anthropic HH データセットおよび TLDR データセットにおいて DPO に対する有効性を示しており、GPT-4 による自動評価で DPO を最大 19% 上回り、一貫性、正確性、詳細度、有用性、無害性を改善します。論文の設定を再現するには、この設定を使用してください：

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

Iterative RPOは、チェーン・オブ・サウスの候補を反復的に生成し、正解と誤解から選好ペアを構築し、DPO + NLLの目的関数で学習することで、推論を改善します。追加のNLL項は、実際に勝利するトレースを生成することを学習するために重要です。

TRLでは、"sigmoid"（DPO）と"sft"（NLL）を組み合わせることで、DPO + 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はこのループを自動的には実行しません。

言語モデルの整列のためのセルフプレイ好適性最適化

📜 論文: 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

Regularized Preference Optimization (RPO) は、DPO の損失と SFT の損失を融合させることで、RLHF における過剰最適化を軽減します。これにより、プロキシ報酬が虚しく高いアクションを選択するポリシーを、証明可能に防止できます。論文の設定を再現するには、この設定を使用してください。

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

Optimal Transport によるアライメント（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は、DPO形式の学習におけるオフポリシーギャップを軽減するために、ポリシー確率によって選好ペアを再重み付けします。損失関数は以下の通りです： $$\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) = \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 を提案しています。 $\alpha \in [0,1]$: $$\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|).$$

設定 $\alpha=1$ では標準的な DPO に戻ります。 $\alpha$ を小さくすると、好み（preference）の品質を維持したまま冗長性を低減できます。 最適な $\alpha$ はモデルファミリーや、ベースモデルか instruct モデルかを訓練しているかによって異なりますが、論文では $\alpha=0.5$ を強力なデフォルトの初期値として推奨しています。

from trl import DPOConfig

training_args = DPOConfig(
    ld_alpha=0.5,
)

混合好意最適化によるマルチモーダル大規模言語モデルの推論能力の向上

📜 論文: https://huggingface.co/papers/2411.10442

Mixed Preference Optimization (MPO) を導入し、標準的な事前学習と SFT 後に生じる分布シフトおよび弱い Chain-of-Thought (CoT) を解決することで、MLLM のマルチモーダル推論を改善します。本論文の貢献は、(1) 高品質なマルチモーダル選好データのための自動化パイプラインである MMPR、および (2) CoT を強化する複合的な選好目的関数（ペアワイズ + BCO スタイル + SFT）である MPO です。InternVL2-8B-MPO は MathVista で 67.0 を達成し（InternVL2-8B 比 +8.7）、10 倍大きい InternVL2-76B と同等の性能を示します。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

長さ正規化シグモイド損失は、Bradley-Terry損失を計算する前に、選択された回答と拒否された回答の対数比スコアをそれぞれの補完長で割ることで、DPOにおける長さバイアスを解消します。このトークンごとの正規化は、 SimPO (付録I「DPO w/ LN」のアブレーション)で、参照モデルなしの環境における平均対数確率報酬として導入され、その後、 Tülu 3 (セクション4.3)のようなポストトレーニングのレシピにおいて、標準的な参照モデルベースのDPOに採用されました。損失は次の通りです: $$\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",
)

カーネマン・トヴェルスキー最適化

KTOTrainerに関連する論文

KTO: Prospect Theoretic Optimizationとしてのモデルアライメント

📜 論文: https://huggingface.co/papers/2402.01306

KTOは、Prospect Theory（展望理論）からアライメント目的関数を導出し、バイナリの人間フィードバック（好き/嫌い）から直接学習します。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）は、ランダム性を低減しバイアスを排除することで、言語モデルのファインチューニングの安定性と効率を向上させます。論文で説明されているようにSFTでBEMAを使用するには、BEMACallbackを使用できます。

from trl import BEMACallback, SFTTrainer

trainer = SFTTrainer(
    ...
    callbacks=[BEMACallback()],
)

SFTの一般化について:報酬の修正を伴う強化学習の視点

📜 論文: https://huggingface.co/papers/2508.05629

Dynamic Fine-Tuning (DFT) は、勾配を動的にリスケールすることで、大規模言語モデル (LLM) の汎化性能を向上させます。標準的な Supervised Fine-Tuning (SFT) を上回る性能を発揮し、オフライン強化学習においても競争力のある結果を示します。 $$\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]$$

ここで $\text{sg}(\cdot)$ はストップグラデーション演算子です。論文で説明されているように SFT と DFT を使用するには、 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

この論文では、LLMの学習に使用される標準的な連結後分割の前処理（packing_strategy="wrapped"）により、多くのドキュメントが恣意的に切り詰められ、学習に悪影響を及ぼすことが示されています。提案手法では、Best-Fit Decreasing バイナリーパッキングアルゴリズムを用いてドキュメントのチャンクをコンテキストウィンドウにパッキングし、トークンの利用率を高く保ちつつ切り詰めを大幅に削減し、モデルの性能を向上させます。TRLでは、これを"bfd_split"パッキング戦略としてSFTConfigに実装しています。パッキングの詳細については、SFTのドキュメントを参照してください。

from trl import SFTConfig

training_args = SFTConfig(
    packing=True,
    packing_strategy="bfd_split",
    max_length=4096,
)

Unified Text-to-Text Transformerを用いた転移学習の限界を探る

📜 論文: https://huggingface.co/papers/1910.10683

T5の論文では、転移学習のための統一されたテキスト対テキストフレームワークを提案し、シーケンスパッキング（セクション3.5.2）を導入しています。これは、複数の短いシーケンスを固定長のブロックにグループ化することで、パディングを削減し、トレーニングの効率を向上させる手法です。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)
)

Uniform Diffusion Modelsの再パラメータ化: Leave-One-Out Denoiser

📜 論文: https://huggingface.co/papers/2605.22765

一様離散拡散モデルにおいて、通常のプラグイン交差エントロピーでは、単純なデノイザーを学習できません$\mathbb{E}[X_0 \mid X_t]$ 各トークンを、その自身の破損値を使わずに予測する、leave-one-out (LOO) 事後分布を学習します。本論文では、デノイザー、LOO 事後分布、スコア間の正確な変換を導出しており、同じ交差エントロピーでいずれのパラメータ化としてもネットワークを訓練できます。LOO 事後分布をパラメータ化する logits$f_\theta$ の softmax に対して、損失で使用するデノイザーは $$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),$$

つまり、観測されたトークンの logit に対する加法的補正であり、$K$ は語彙サイズ、$\alpha_t$ は uniform forward がクリーンなトークンを保持する確率です。論文では、LOO パラメータ化が生成を常に改善すると報告されています。ブロック拡散 SFT の例 examples/sft_diffusion_gemma/sft_diffusion_gemma.py は、 --model_prediction_type (mean （通常のデノイザー用で、公開されたチェックポイントに一致）または mean_loo （LOO 事後分布用）の両方のパラメータ化を公開しています：

accelerate launch --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
    examples/sft_diffusion_gemma/sft_diffusion_gemma.py \
    --use_peft \
    --gradient_checkpointing \
    --model_prediction_type mean_loo \
    --output_dir diffusiongemma-26B-A4B-it-gsm8k-lora

大規模Transformerモデルにおけるアクティベーション再計算の削減

📜 論文: https://huggingface.co/papers/2205.05198

フルアクティベーションチェックポイントは、チェックポイント化された領域内のすべてのオペレーション（アテンションを含む）をバックワード時に再計算します。しかし、メモリを保持するコストに対する再計算コストの割合が大きいのは、アテンションを含む一部のオペレーションだけです。論文の選択的アクティベーション再計算では、領域全体ではなく、これらのコストの高いオペレーションのみをチェックポイント化します。TRLはこれを選択的アクティベーションチェックポイント（SAC）としてSFTTrainerに実装しており、フォワードパス中にアテンションの出力を保存することで、バックワード時にその再計算を行いません。

from trl import SFTConfig

training_args = SFTConfig(
    gradient_checkpointing=True,
    gradient_checkpointing_kwargs={"selective": True},
)

パラメータ効率の良いファインチューニング（PEFT）

PEFTをTRLと組み合わせて使用する方法の詳細については、PEFT Integrationガイドを参照してください。

LoRA: 大規模言語モデルの低ランク適応

📜 論文: https://huggingface.co/papers/2106.09685

Low-Rank Adaptation (LoRA)は、下流タスクでの性能を維持または向上させながら、大規模な事前学習モデルにおける学習可能なパラメータ数とGPUメモリ使用量を削減します。TRLはPEFT libraryを通じてLoRAを統合しており、peft_config引数にLoraConfigを渡すことで、任意のTRLトレーナーで簡単に有効化できます。SFTTrainerでLoRAを使用する例を以下に示します。

from trl import SFTTrainer
from peft import LoraConfig

trainer = SFTTrainer(
    ...,
    peft_config=LoraConfig(),
)

DoRA: 重み分解低ランク適応

📜 論文: https://huggingface.co/papers/2402.09353

重み分解低ランク適応（DoRA）は、LoRA のパフォーマンスを向上させることができます。特に低ランクの場合に効果的です。DoRA は事前学習済み重みを 2 つの要素、すなわち大きさ（magnitude）と方向（direction）に分解します。方向は通常の LoRA で処理され、大きさは学習可能なパラメータとして扱われます。TRL は PEFT ライブラリ を通じて DoRA を統合しており、LoraConfig に use_dora=True を設定することで簡単に有効化できます。

from peft import LoraConfig

config = LoraConfig(use_dora=True, ...)

Reinforce Leave-One-Out

RLOOTrainerに関連する論文

基礎への回帰：LLMにおける人間のフィードバックからの学習のためのREINFORCEスタイル最適化の再検討

📜 論文: https://huggingface.co/papers/2402.14740

RLOOは、leave-one-outベースラインを用いて分散を低減するREINFORCEのバリアントです。バッチ内の他のすべてのサンプルの平均値と各サンプルを比較して報酬を計算し、標準的な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

対比選好最適化（CPO）を紹介する。CPOは、機械翻訳のための選好ベースの手法であり、SFTのように参照文を模倣するのではなく、十分だが不完全な翻訳を回避するようにモデルを訓練する。本論文では、MTにおけるSFTの限界（参照文の品質の問題を含む）を分析し、22Kの対訳文のみを用いてALMAにCPOを適用することで、WMT’21〜WMT’23においてWMTコンペティションの優勝者やGPT-4に匹敵するかそれを超えるALMA-Rが得られることを示している。experimental.cpo.CPOTrainerを通じてTRLで使用される。論文の設定を再現するには、この設定を使用する：

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は、シーケンスの平均対数確率を暗黙の報酬として使用することで、参照モデルの必要性を排除する、よりシンプルかつ効果的な好み最適化手法です。Bradley-Terry目的関数にターゲット報酬マージンを導入し、勝利した応答と敗北した応答の間のマージンを大きくすることを促します。論文の設定を再現するには、この設定を使用してください。

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パラメータを活用して、標準的なlog rewardを超えて報酬関数の形状を変更するのを助けます。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,
    ...
)

トリプル・プリファレンス・オプティマイゼーション

トリプル・プリファレンス・オプティマイゼーション: 単一ステップのオプティマイゼーションによるより良いアライメントの達成

📜 論文: https://huggingface.co/papers/2405.16681

トリプル・プリファレンス・オプティマイゼーション（TPO）を導入します。TPOは、プロンプトごとに3つの応答（ゴールド（reference）補完、優先（chosen）補完、非優先（rejected）補完）を用いてLLMをアラインする、好み学習手法です。この手法は、単一の最適化ステップで完結します。TPOは、(chosen, rejected)ペアに対する対比目的関数と、ゴールド応答に対する教師ありNLL項を組み合わせることで、個別のSFTステージやDPOで用いられる参照モデルの必要性を排除します。TRLはv1.16までTPOTrainerとして実装を提供していましたが、現在はライブラリに含まれておらず、git履歴のみで利用可能です。

Nash Learning from Human Feedback

Nash Learning from Human Feedback

📜 論文: https://huggingface.co/papers/2312.00886

Nash-MD を紹介します。これは標準的な RLHF の代替案であり、2 つの入力に条件付けられた選好モデルを学習し、ナッシュ均衡でのポリシーを見つけます。報酬モデルに対する最適化を行うのではなく、Nash-MD は、競合する任意のポリシーの応答よりも一貫して好まれる応答を生成するポリシーを生成します。このアルゴリズムはミラー降下法の原理に基づいています。TRL は v1.13 まで NashMDTrainer として実装を提供していましたが、現在はライブラリの一部ではなく、git の履歴で引き続き利用可能です。

報酬モデリング

RewardTrainerに関連する論文

支援か、それとも群れか？報酬モデルのアンサンブルは報酬ハッキングを緩和するが、排除はできない

📜 論文: https://huggingface.co/papers/2312.09244

この論文では、中心化された報酬モデルを直接学習するための補助損失関数を提案しています。この補助損失は報酬の二乗和を最小化することで、モデルが自然に平均ゼロの出力を生成するように促し、不定性の問題を解決します。 $$\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で使用するには、RewardConfigのcenter_rewards_coefficient引数を以下のように使用できます:

from trl import RewardConfig

training_args = RewardConfig(
    center_rewards_coefficient=0.01,  # η in the paper
    ...
)

Llama 2: オープンな基盤モデルとファインチューニング済みチャットモデル

📜 論文: https://huggingface.co/papers/2307.09288

本論文では、著者らは、好みを4段階のスケール（例： はるかに良い) ）に分解する手法を活用し、報酬モデルにより情報量の多いフィードバックを提供することを提案しています。これは、損失関数にマージンを追加することで実現され、より高い好み評価を持つペアに対して、報酬モデルがスコアの差を大きくするように促します。 $$\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に関連する論文

オンラインAIフィードバックからの直接言語モデルアライメント

📜 論文: 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に対する1行の変更であり、サンプル効率の証明が可能で、ほぼ最適な言語モデルポリシーに収束します。TRLはv1.13までXPOTrainerとして実装を提供していましたが、現在はライブラリの一部ではなく、git履歴で引き続き利用可能です。

蒸留

教師モデルの助けを借りて学生モデルを訓練するに関する論文。

言語モデルのオンポリシー蒸留：自己生成された誤りから学ぶ

📜 論文: https://huggingface.co/papers/2306.13649

Generalized Knowledge Distillation (GKD) を紹介します。GKD は、固定のシーケンスセットではなく、教師モデルのフィードバックを用いて生徒モデルが自ら生成した出力で学習することで、自動回帰モデルにおける知識蒸留 (KD) の分布不一致の問題に対処します。GKD は柔軟な損失関数 (例えば、生徒モデルが教師モデルに追従できない場合の KL 以外の関数) をサポートし、RL によるファインチューニング (RLHF) と統合できます。本論文では、要約、翻訳、算術推論、および指示チューニングに関する結果が報告されています。TRL では experimental.gkd.GKDTrainer によって利用可能であり、論文のオン/オフポリシー混合 (lmbda) を公開しています。DistillationTrainer は、常にオンポリシーである場合の同じ汎用 JSD 目的関数を実装しています。論文の設定を再現するには、この設定を使用してください:

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

ポストトレーニングを3つの段階として構成します。1つ目は一般的なSFT、2つ目はドメインごとの独立したRLトレーニング（各ドメインにつき1つのエキスパートを訓練。例えば、数学では検証可能な回答RL、ソフトウェアエンジニアリングではサンドボックス化されたエージェントRLなど）、3つ目は凍結されたドメインエキスパートを単一の統合された学生モデルに融合する最終的なMOPD段階です。この最終段階では、学生モデルがプロンプトごとに1つの軌跡を生成し、各軌跡は対応するドメインの教師モデルにのみ送信されます（教師モデル間で平均化やアンサンブルは行われません）。その後、その軌跡に沿った1つの教師モデルの分布に対するトークンごとの逆KLを最小化することで、学生モデルが更新されます。この手法は、experimental.async_distillation.AsyncDistillationTrainerを通じてTRLで使用できます。このクラスは第3段階である融合段階を実装しており、teacher_server_urlsに複数のエントリを渡すことでMOPDが有効になります。各行のteacher_idカラムによって、どの（すでに訓練済みの）教師モデルがその行をスコアリングするかが選択されます。論文の逆KL目的関数と一致させるには、beta=1.0を使用してください。

オンポリシー蒸留における位置バイアスについて

📜 論文: https://huggingface.co/papers/2606.22600

experimental.iw_opd.IWOPDTrainer と distillation_objective="iw_opd" を使用して TRL で利用可能な Importance-Weighted On-Policy Distillation (IW-OPD) を紹介します。IW-OPD は、蓄積された教師モデルと生徒モデルのプレフィックスの乖離に基づいて、サンプリングされたトークンの蒸留更新を再重み付けすることで、OPD の位置バイアスを解決します。初期のトークンはより大きな重みを保ち、大きなドリフトが発生した後の後続のトークンは重みが低減されます。

この論文では、clipped policy-gradient 設定 (verl) と vLLM のロールアウトを用いて IW-OPD を最適化しています。IWOPDTrainer は、以下の対応する蒸留およびロールアウト設定を公開しています。論文に記載されているポリシー最適化の設定、例えばクリッピング範囲 0.2、dual-clip 定数 3.0、内部 PPO エポック数、エントロピー係数、KL 報酬ペナルティ、補助 KL、ロールアウト重要度補正は、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では、学生モデルがトレーニングデータの各バッチに対してロールアウトを生成します。その後、学生モデルと教師モデルの両方から、ロールアウトの各トークンに対する確率分布を取得します。学生モデルは、自身のトークン分布と教師モデルのトークン分布との間の負のKullback-Leibler（KL）ダイバージェンスを最小化するように最適化されます。

On-Policy Distillation は、SFT や GRPO を上回る性能を示すことが実証されており、SFT によって失われた汎化能力を回復するために使用できます。

さらに、オンポリシー蒸留は計算効率が高く、データが限られている場合でも過学習しにくいという利点があります。

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も使用できます。Unlocking On-Policy Distillation for Any Model Familyを参照してください。

あらゆるモデルファミリー向けのオンポリシー蒸留の解放

🌐 プロジェクト: https://huggingface.co/spaces/HuggingFaceH4/general-on-policy-logit-distillation

General Online Logit Distillation (GOLD) を紹介します。GOLD は、異なるトークナイザーとモデルファミリーを持つ生徒/教師ペアへのオンポリシー蒸留を拡張します。GOLD はトークナイザー間でテキストスパンをアラインし、Universal Logit Distillation (ULD) を適用することで、補完トークンがドロップされないようにできます。experimental.gold.GOLDTrainer を通じて TRL で使用されます。

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蒸留フレームワークを拡張します。これはオフポリシー手法（lmbda=0）であり、データセットが補完テキストを提供し、生徒と教師の両方がそのテキスト上でフォワードパスを実行し、それらのlogits間でクロス・トークナイザーKD損失が計算されます。オンポリシーな生徒のロールアウトは不要です。事前計算されたスパースな射影行列 W ∈ ℝ^{V_s × V_t} が、各生徒トークンを最も対応すると考えられる教師トークンにマッピングし、生徒の分布を教師の語彙空間に射影することで、両者を直接比較できるようにします。TRLでは、xtoken_loss_type="p_kl" または "h_kl" を使用して experimental.gold.GOLDTrainer 経由で利用されます。

2つの損失関数の定式化が提供されています:

参照実装と同様に、H-KL は全語彙の対数確率を共通集合にスライスし、P-KL は教師の対数確率を各スパンで平均化しますが、再正規化は行わないため、KD 項は負の値になり得ます。CE と KD は、各蓄積ウィンドウに対して、トークン数とアライメント済みスパン数をそれぞれ別々に使用します。動的な CE/KD バランス調整と P-KL のトップ k 選択は、マイクロバッチごとに計算されます。

この実装では、凍結された射影行列を使用しています。論文では、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

次に、サンプルスクリプトで学習を実行します（オフポリシー、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は、教師モデルと生徒モデル間のシーケンスレベルの逆KLDを最小化し、強化学習によって最適化される、初のオンポリシー知識蒸留手法です。

Think Machine Lab の On-Policy Distillation の一般化版であり、beta=1 の場合の GKD のような分布レベルの単一ステップ蒸留シグナルや、長文脈の逆方向 KLD シグナルを追加するオプションを備えています。

TRLはv1.14までMiniLLMTrainerとして実装を提供していましたが、現在はライブラリに含まれておらず、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

Self-Distilled Fine-Tuning (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はv1.15までSSDTrainerとして実装を提供していましたが、現在はライブラリに含まれておらず、gitの履歴のみで利用可能です。

SoftmaxとCross-Entropyの修正

📜 論文: https://huggingface.co/papers/2610.31642

高確信度の予測におけるsoftmaxの崩壊、および学生と教師のlogitsがほぼ一致する際の打ち消しを特定します。TRLのチャンク化されたlog確率および蒸留ヘッドは、ターゲットを除外した正規化とlog空間での確率差を用いることで、小さな勾配を保持します。これらの数値的な修正は、DistillationTrainerにおけるforward KL、reverse KL、および汎用JSDにも自動的に適用されます。

Entropy-preserving reinforcement learning の付録 B.4 で、以前に高信頼性の policy-gradient の失敗が特定され、FP64 で勾配を選択的に再計算する手法が提案されていました。TRL のカーネルは、安定した FP32 の数式を用いてこれらの勾配を保持します。

付録 B.1 で議論されている FSDP2 の出力キャストに関する別件の問題は、Accelerate #4403 によって対処されています。古いバージョンの Accelerate では、FP32 のカーネル出力を保持するために、output_dtype=None を指定した混合精度ポリシーが必要です。

以下の例は、セクション7で報告されたハイパーパラメータを、soft-target交差エントロピーの学生勾配を共有するTRLのforward-KL目的関数にマッピングしています。これは言語モデルの蒸留を説明するものであり、論文のmodular arithmetic実験を再現するものではありません。論文では、学生モデルを教師モデルの重みで初期化しています。これはconfigとは独立して、モデルを構築する際に処理する必要があります。その他のtrainerのデフォルト値は変更されません。

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はDeepSpeed統合を通じてZeROをサポートしています。これを使用するには、希望する設定を含むDeepSpeed設定ファイルを指定してください。

# config.yaml
distributed_type: DEEPSPEED
num_processes: 2
deepspeed_config:
  zero_stage: 3

accelerate launch --config_file config_file を使用して学習スクリプトを起動します。

accelerate launch --config_file config.yaml train.py