TRL documentation

RLOO Trainer

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

RLOO Trainer

model badge

概要

TRLは、Arash Ahmadian、Chris Cremer、Matthias Gallé、Marzieh Fadaee、Julia Kreutzer、Ahmet ÜstünおよびSara Hookerによる論文Back to Basics: Revisiting REINFORCE Style Optimization for Learning from Human Feedback in LLMsに記載されているRLOO Trainerによる言語モデルの学習をサポートしています。

論文の要旨は以下の通りです:

強化学習からの人間フィードバック(RLHF)という形態のAIアライメントは、高性能な大規模言語モデルにとって不可欠な要素としてますます見なされています。近接方策最適化(PPO)は、最近の文献においてRLHFの強化学習部分の標準的な手法として位置づけられています。しかし、PPOは計算コストが高く、ハイパーパラメータの調整が敏感であるという問題があります。私たちは、PPOの開発に導いた動機づけの原則の多くは、RLHFの文脈では実務上の懸念として重要度が低いと主張し、計算コストを抑えつつ性能を維持し、さらには向上させる手法を提唱します。私たちは、強化学習の文脈において人間からの好みによるアライメントの定式化を再検討します。シンプルさを指針とし、PPOの多くの構成要素はRLHFの文脈では不要であり、はるかにシンプルなREINFORCE様式の最適化バリアントが、PPOやDPO、RAFTといった新提案の「RLフリー」手法よりも優れた性能を発揮することを示します。私たちの研究は、LLMのアライメント特性への慎重な適応により、オンライン強化学習最適化の恩恵を低コストで享受できることを示唆しています。

このポストトレーニング手法は、Costa Huang 氏によって提供され、その後 Shirin Yamani 氏によってリファクタリングされました。

クイックスタート

この例では、RLOO手法を用いてモデルを学習する方法を示します。DeepMath-103Kデータセットのプロンプトを使用して、Qwen 0.5B Instructモデルを学習します。データセットのデータは以下で確認できます:

以下はモデルを学習するためのスクリプトです。accuracy_rewardにはmath-verifyが必要ですが、pip install trl[math_verify]でインストールできます。

# train_rloo.py
from datasets import load_dataset
from trl import RLOOTrainer
from trl.rewards import accuracy_reward

dataset = load_dataset("trl-lib/DeepMath-103K", split="train")

trainer = RLOOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs=accuracy_reward,
    train_dataset=dataset,
)
trainer.train()

以下のコマンドを使用してスクリプトを実行します:

torchrun --nproc_per_node 8 train_rloo.py

RLOOメソッドのより詳細な解説

RLOOはオンライン学習アルゴリズムであり、学習中に訓練済みモデル自体によって生成されたデータを用いて反復的に改善されます。RLOOの目的関数の直感は、生成された補完のアドバンテージを最大化しつつ、モデルが参照ポリシーに近いままであることを保証することです。RLOOの動作を理解するために、4つの主要なステップに分解できます: 補完の生成、アドバンテージの計算、KLダイバージェンスの推定、および損失の計算。

RLOO

補完の生成

各トレーニングステップにおいて、プロンプトのバッチをサンプリングし、各プロンプトに対して G G の補完を生成します( oi o_i ).

報酬の計算

RLOOでは、報酬は2つの要素で構成されます。報酬モデル(または報酬関数)によって提供される報酬と、固定された参照ポリシーから大きく逸脱することを抑制するためのKLペナルティです。

  1. 各 G G 生成シーケンス oi=(oi,1,…,oi,T) o_i = (o_{i,1}, \dots, o_{i,T}) クエリ q q , に対して条件付けられたものについて、報酬モデルを用いてスカラー報酬を計算します。 R(oi,q) R(o_i, q) .
  2. 同時に、現在のポリシー πθ \pi_\theta と固定された参照ポリシー πref \pi_{\text{ref}} のシーケンス全体におけるKLダイバージェンスを推定します。シーケンス oi o_i のKL推定値は次のとおりです。 DKL ⁣[πθ∥πref]=∑t=1Tlog⁡πθ(oi,t∣q,oi,<t)πref(oi,t∣q,oi,<t). \mathbb{D}_{\mathrm{KL}}\!\left[\pi_\theta\|\pi_{\mathrm{ref}}\right] = \sum_{t=1}^T \log \frac{\pi_\theta(o_{i,t} \mid q, o_{i,<t})}{\pi_{\mathrm{ref}}(o_{i,t} \mid q, o_{i,<t})}.

シーケンスに割り当てられる最終報酬 oi o_i は次のようになります: ri=R(oi,q)−β DKL ⁣[πθ∥πref], r_i = R(o_i, q) - \beta \, \mathbb{D}_{\mathrm{KL}}\!\left[\pi_\theta \|\pi_{\mathrm{ref}}\right],

ここで β>0 \beta > 0 は KL 罰則の強さを制御します。

完全にオンラインな設定(num_iterations = 1、デフォルト)では、データは現在のポリシーによって生成されます。この場合、KLペナルティは現在のポリシーを直接使用して計算されます。

より一般的な設定(例えば、バッチごとに複数の勾配ステップを行う場合)では、データは以前のスナップショット πold \pi_{\text{old}} . によるサンプリング分布とペナルティを一致させるために、KL はこのポリシーに関して定義されます:

DKL ⁣[πold ∥ πref]. \mathbb{D}_{\mathrm{KL}}\!\left[\pi_{\text{old}} \,\|\, \pi_{\text{ref}}\right].

同様に、サンプリングされたシーケンス o o , に対するモンテカルロ推定は次のようになります:

DKL ⁣[πold∥πref]=∑t=1Tlog⁡πold(oi,t∣q,oi,<t)πref(oi,t∣q,oi,<t). \mathbb{D}_{\mathrm{KL}}\!\left[\pi_{\text{old}} \|\pi_{\mathrm{ref}}\right] = \sum_{t=1}^T \log \frac{\pi_{\text{old}}(o_{i,t} \mid q, o_{i,<t})}{\pi_{\mathrm{ref}}(o_{i,t} \mid q, o_{i,<t})}.

アドバンテージの計算

各コンプリーションの報酬が計算された後、現在のサンプルを除く、同じバッチ内の他のすべてのサンプルの報酬の平均をベースラインとして計算します。このベースラインは、ポリシー勾配推定の変動を低減するために使用されます。各コンプリーションのアドバンテージは、その報酬からこのleave-one-outベースラインを引いた差として得られます。

形式的に、G 個の補完のバッチにおいて、補完のベースラインは次のようになります。bi=1G−1∑j≠irj b_i = \frac{1}{G-1} \sum_{j \neq i} r_j

その後、各コンプリートのアドバンテージは、その報酬とベースラインの差として計算されます: Ai=ri−bi A_i = r_i - b_i

損失の計算

REINFORCE損失は、次のように単純に定義されます。 LRLOO(θ)=−1G∑i=1GA^i log⁡πθ(oi∣q) \mathcal{L}_{\text{RLOO}}(\theta) = - \frac{1}{G} \sum_{i=1}^G \hat{A}_i \, \log \pi_\theta(o_i \mid q)

実際には、同じバッチに対して複数の勾配ステップを実行すると、現在のパラメータに対してアクションが実質的にオフポリシーになります。これを補正するために、重要性サンプリング比を導入します。サンプリングと勾配ステップの間でポリシーが変化した場合に、過度に大きな更新を防ぐために、この比をクリップします: LRLOO(θ)=−1G∑i=1Gmin⁡(πθ(oi∣q)πθold(oi∣q)A^i, clip(πθ(oi∣q)πθold(oi∣q),1−ϵ,1+ϵ)A^i) \mathcal{L}_{\text{RLOO}}(\theta) = - \frac{1}{G} \sum_{i=1}^G \min \left( \frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)} \hat{A}_i, \, \text{clip}\left(\frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)}, 1-\epsilon, 1+\epsilon\right) \hat{A}_i \right)

完全にオンラインな単一ステップ設定(デフォルト)では、 πθ(oi∣q)πθold(oi∣q)=1 \frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)} = 1 これは標準的な REINFORCE に帰着します。

GRPO とは異なり、RLOO は KL 項を通じて勾配を逆伝播しません。ここでは KL は純粋に報酬の整形に使用され、 no_grad の下で計算され、スカラー報酬 ri r_i , に折り込まれ、これがデタッチされたアドバンテージ A^i \hat{A}_i .

つまり、ポリシーへの勾配が流れる唯一の経路は、重要度比の項です πθ(oi∣q)πθold(oi∣q) \frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)} , また、KL 項はポリシーに逆伝播しません。

一方、 GRPO は、現在のポリシー πθ \pi_\theta , を介して勾配が比率項とKLペナルティの両方に流れるように、目的関数に明示的な微分可能なKL項をオンザフライで計算して追加します。

記録されたメトリクス

学習と評価の実行中、以下のメトリクスを記録します:

  • num_tokens: プロンプトと補完の両方を含む、これまでに処理されたトークンの総数。
  • step_time: 1回の学習ステップ(生成を含む)に要する平均時間(秒)。
  • completions/mean_length: 生成された補完の平均長さ。
  • completions/min_length: 生成される補完の最小長。
  • completions/max_length: 生成される補完の最大長。
  • completions/mean_terminated_length: EOSで終了した生成済み補完の平均長さ。
  • completions/min_terminated_length: EOSで終了する生成された補完の最小長さ。
  • completions/max_terminated_length: EOSで終了する生成された補完の最大長。
  • completions/clipped_ratio: 切り詰められた(クリップされた)補完の割合。
  • rewards/{reward_func_name}/mean: 特定の報酬関数からの平均報酬。
  • rewards/{reward_func_name}/std: 特定の報酬関数からの報酬の標準偏差。
  • reward: 各関数にわたる報酬を合計した後の全体の平均報酬(reward_weightsで重み付け)。
  • reward_std: 関数全体にわたる合計報酬の標準偏差(reward_weightsで重み付け済み)を、バッチ全体に対して計算したものです。
  • frac_reward_zero_std: 生成バッチ内で報酬の標準偏差がゼロであるサンプルの割合。この値は、そのプロンプトに対する多様性が低いことを示唆しています(すべての回答が正解または誤解である)。
  • entropy: 生成された補完全体にわたるトークン予測の平均エントロピー。(mask_truncated_completions=Trueの場合、マスクされたシーケンスのトークンは除外されます。)
  • aux_loss: Mixture-of-Experts モデルのロードバランス用の補助損失。router_aux_loss_coef によってスケーリングされ、損失に追加される前の値です。モデルが MoE モデルであり、router_aux_loss_coef がゼロでない場合にのみ記録されます。
  • kl: 生成された補完に対して計算される、モデルと参照モデルの間の平均KLダイバージェンス。betaがゼロでない場合のみ記録されます。
  • clip_ratio/region_mean: 信頼領域内に収まるよう RLOO 目的関数がクリップされるシーケンス確率の比率: clip(ri(θ),1−ϵlow,1+ϵhigh) ,ri(θ)=πθ(oi∣q)πθold(oi∣q) \text{clip}\left( r_{i}(\theta), 1 - \epsilon_\mathrm{low}, 1 + \epsilon_\mathrm{high} \right)\,, \quad r_{i}(\theta) = \frac{\pi_\theta(o_{i} \mid q)}{\pi_{\theta_{\text{old}}}(o_{i} \mid q)} . 値が高いほどクリップされるサンプルが増え、ポリシー πθ\pi_\theta が変更できる範囲が制限されます。
  • clip_ratio/low_mean: トラストリージョンの下限でクリップされたシーケンス確率の比率の平均値: ri,t(θ)<1−ϵlowr_{i,t}(\theta) < 1 - \epsilon_\mathrm{low}.
  • clip_ratio/low_min: トラストリージョンの下限における、1 回の生成ごとの最小クリップ指標: ri,t(θ)<1−ϵlowr_{i,t}(\theta) < 1 - \epsilon_\mathrm{low}.
  • clip_ratio/high_mean: トラストリージョンの上限でクリップされたシーケンス確率の比率の平均値: ri,t(θ)>1+ϵhighr_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}.
  • clip_ratio/high_max: トラストリージョンの上限における、1 回の生成ごとの最大クリップ指標: ri,t(θ)>1+ϵhighr_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}.

カスタマイズ

vLLMによる生成でトレーニングを高速化

オンライン手法による学習では、生成が主なボトルネックとなることがよくあります。生成を高速化するには、LLM向けの高スループット・低レイテンシ推論エンジンであるvLLMを使用できます。これを有効にするには、まずパッケージをインストールします。

pip install trl[vllm]

トレーニング中のvLLMの使用方法として、サーバーモードとコロケーションモードの2つをサポートしています。

オプション 1: Colocate モード

このモードでは、vLLMはトレーナープロセス内で実行され、学習モデルとGPUメモリを共有します。これにより、別のサーバーを起動する必要がなくなり、GPUの利用率を向上させることができますが、学習用GPU上でメモリ競合が発生する可能性があります。これがデフォルトのモードです。

from trl import RLOOConfig

training_args = RLOOConfig(
    ...,
    use_vllm=True,  # vllm_mode="colocate" by default
)

オプション2: サーバーモード

このモードでは、vLLMは別プロセス(および別GPU)で実行され、HTTP経由でトレーナーと通信します。推論用に専用GPUがある場合に最適です。

  1. vLLMサーバーを開始します:

    VLLM_SERVER_DEV_MODE=1 vllm serve <model_name> \
        --weight-transfer-config '{"backend": "nccl"}' \
        --logprobs-mode processed_logprobs \
        --max-logprobs -1
  2. 学習スクリプトでサーバーモードを有効にする:

    from trl import RLOOConfig
    
    training_args = RLOOConfig(
        ...,
        use_vllm=True,
        vllm_mode="server",
    )

サーバーがトレーナーとは異なる GPU を使用していることを確認してください。そうでない場合、NCCL エラーが発生する可能性があります。使用する GPU は、CUDA_VISIBLE_DEVICES 環境変数で指定できます。

モデルサイズや学習に必要なGPUメモリ全体の要件に応じて、RLOOConfigのvllm_gpu_memory_utilizationパラメータを調整し、リソースの未活用やメモリ不足エラーを回避する必要がある場合があります。

モデルの構成と実験設定に基づいて、推奨されるGPUメモリ使用率を推定するためのHF Spaceを提供しています。以下のように使用すると、vllm_gpu_memory_utilizationの推奨値を取得できます。

推奨値があなたの環境で機能しない場合、安定性を確保するために、推奨値に小さなバッファ(例:+0.05 または +0.1)を加えることをお勧めします。

それでもメモリ不足エラーが発生する場合は、vllm_enable_sleep_modeをTrueに設定してください。これにより、最適化ステップ中にvllmのパラメータとキャッシュがオフロードされます。詳細については、vLLM Sleep Modeによるメモリ使用量の削減を参照してください。

デフォルトでは、RLOOはvLLMに対してMASTER_ADDR=localhostとMASTER_PORT=12345を使用しますが、環境変数を適切に設定することでこれらの値を上書きできます。

詳細については、vLLMによるトレーニングの高速化を参照してください。

大規模なRLOO: 複数ノードで70B以上のモデルを学習

Qwen2.5-72Bのような大規模モデルを学習させる場合、複数のGPUやノードにわたって効率的かつスケーラブルな学習を実現するために、いくつかの重要な最適化が必要です。これには以下が含まれます。

  • DeepSpeed ZeRO Stage 3: ZeRO はデータ並列性を利用して、モデルの状態(重み、勾配、オプティマイザの状態)を複数の GPU および CPU に分散し、各デバイスのメモリおよび計算要件を削減します。大規模モデルは単一の GPU に収まらないため、そのようなモデルの学習には ZeRO Stage 3 の使用が必須です。詳細については、DeepSpeed Integrationを参照してください。
  • torchrun: PyTorchのランチャーは、すべてのノードでGPUごとに1つのプロセスを起動し、共通のrendezvousを通じてそれらを接続します。詳細については、トレーニングの分散化を参照してください。
  • vLLM: 生成を高速化するために vLLM を使用する方法については、前のセクションを参照してください。

以下は、RLOOを使用して複数ノードで70Bモデルを学習するためのSLURMスクリプトの例です。このスクリプトは4ノードでモデルを学習し、5番目のノードをvLLMによる生成に使用します。

#!/bin/bash
#SBATCH --nodes=5
#SBATCH --gres=gpu:8

# Get the list of allocated nodes
NODELIST=($(scontrol show hostnames $SLURM_JOB_NODELIST))

# Assign the first 4 nodes for training and the 5th node for vLLM
TRAIN_NODES="${NODELIST[@]:0:4}"  # Nodes 0, 1, 2, 3 for training
VLLM_NODE="${NODELIST[4]}"  # Node 4 for vLLM

# Run training on the first 4 nodes (Group 1)
srun --nodes=4 --ntasks=4 --nodelist="${NODELIST[@]:0:4}" torchrun \
     --nnodes 4 \
     --nproc_per_node 8 \
     --node_rank $SLURM_PROCID \
     --rdzv_backend c10d \
     --rdzv_endpoint ${NODELIST[0]}:29500 \
     train_rloo.py \
     --server_ip $VLLM_NODE &

# Run vLLM server on the 5th node (Group 2)
srun --nodes=1 --ntasks=1 --nodelist="${NODELIST[4]}" env VLLM_SERVER_DEV_MODE=1 vllm serve Qwen/Qwen2.5-72B --tensor-parallel-size 8 \
    --weight-transfer-config '{"backend": "nccl"}' \
    --logprobs-mode processed_logprobs \
    --max-logprobs -1 &

wait
import argparse

from datasets import load_dataset
from trl import RLOOTrainer, RLOOConfig

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--vllm_server_host", type=str, default="", help="The server IP")
    args = parser.parse_args()

    # Example dataset from TLDR
    dataset = load_dataset("trl-lib/tldr", split="train")

    # Dummy reward function: count the number of unique characters in the completions
    def reward_num_unique_chars(completions, **kwargs):
        return [len(set(c)) for c in completions]

    training_args = RLOOConfig(
        output_dir="Qwen2.5-72B-RLOO",
        per_device_train_batch_size=4,
        bf16=True,
        deepspeed="examples/deepspeed_configs/zero3.json",
        use_vllm=True,
        vllm_mode="server",
        vllm_server_host=args.vllm_server_host.replace("ip-", "").replace("-", "."),  # from ip-X-X-X-X to X.X.X.X
    )

    trainer = RLOOTrainer(model="Qwen/Qwen2.5-72B", args=training_args, reward_funcs=reward_num_unique_chars, train_dataset=dataset)
    trainer.train()

if __name__=="__main__":
    main()

カスタム報酬関数を使用する

RLOOTrainerは、稠密報酬モデルの代わりにカスタム報酬関数を使用することをサポートしています。互換性を確保するために、報酬関数は以下の要件を満たす必要があります。

報酬関数は、同期の Python コール可能オブジェクトまたは非同期の async def コルーチンのいずれかとして定義できます。複数の非同期報酬関数を指定した場合、それらは並行して待機(asyncio.gather によって並列実行)されるため、レイテンシが重複します。

  1. 入力引数:

    • この関数は、次のものをキーワード引数として受け取らなければなりません:

      • prompts(プロンプトを含む)
      • completions(生成された補完を含む)
      • completion_ids(トークン化された補完を含む)
      • trainer_state (TrainerState): トレーナーの現在の状態です。これにより、トレーニングの進捗に基づいて報酬を調整するカリキュラムラーニングのような、動的な報酬関数の実装が可能になります。
      • log_extra: 補完テーブルに追加の列を追加するための、呼び出し可能な log_extra(column: str, values: list)。例 6 を参照してください。
      • log_metric: スカラー指標をプロットとしてkl、entropyなどとともに記録するための、呼び出し可能なlog_metric(name: str, value: float)。例6を参照してください。
      • データセットが持つ可能性のあるすべての列名(promptを除く)。例えば、データセットにground_truthという名前の列が含まれている場合、関数はground_truthをキーワード引数として呼び出されます。

      この要件を満たす最も簡単な方法は、関数シグネチャに**kwargsを使用することです。

    • データセットの形式によって、入力が異なります:

      • 標準形式の場合、promptsとcompletionsは文字列のリストになります。
      • 会話形式の場合、promptsとcompletionsはメッセージの辞書のリストになります。
  2. 戻り値: 関数は float のリストを返す必要があります。各 float は、1つの completion に対応する報酬を表します。

例1: 長い補完を報酬

以下は、長い補完を報酬とする標準形式の報酬関数の例です:

def reward_func(completion_ids, **kwargs):
    """Reward function that assigns higher scores to longer completions (in terms of token count)."""
    return [float(len(ids)) for ids in completion_ids]

次のようにテストできます:

>>> prompts = ["The sky is", "The sun is"]  # not used in the reward function, but the trainer will pass it
>>> completions = [" blue.", " in the sky."]  # not used in the reward function, but the trainer will pass it
>>> completion_ids = [[6303, 13], [304, 279, 12884, 13]]
>>> reward_func(prompts=prompts, completions=completions, completion_ids=completion_ids)
[2.0, 4.0]

例 1.1: 長い補完を報酬する(文字数に基づく)

前回の例と同様ですが、今回は報酬関数がトークン数ではなく文字数に基づいています。

def reward_func(completions, **kwargs):
    """Reward function that assigns higher scores to longer completions (in terms of character count)."""
    return [float(len(completion)) for completion in completions]

次のようにテストできます:

>>> prompts = ["The sky is", "The sun is"]
>>> completions = [" blue.", " in the sky."]
>>> completion_ids = [[6303, 13], [304, 279, 12884, 13]]  # not used in the reward function, but the trainer will pass it
>>> reward_func(prompts=prompts, completions=completions, completion_ids=completion_ids)
[6.0, 12.0]

例2: 特定の形式で報酬完了

以下は、補完が特定の形式を持っているかをチェックする報酬関数の例です。この例は、論文DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learningで使用されているformat reward関数に着想を得ています。 プロンプトと補完が構造化されたメッセージで構成される対話形式向けに設計されています。

import re

def format_reward_func(completions, **kwargs):
    """Reward function that checks if the completion has a specific format."""
    pattern = r"^<think>.*?</think><answer>.*?</answer>$"
    completion_contents = [completion[0]["content"] for completion in completions]
    matches = [re.match(pattern, content) for content in completion_contents]
    return [1.0 if match else 0.0 for match in matches]

この関数は次のようにテストできます。

>>> prompts = [
...     [{"role": "user", "content": "What is the result of (1 + 2) * 4?"}],
...     [{"role": "user", "content": "What is the result of (3 + 1) * 2?"}],
... ]
>>> completions = [
...     [{"role": "assistant", "content": "<think>The sum of 1 and 2 is 3, which we multiply by 4 to get 12.</think><answer>(1 + 2) * 4 = 12</answer>"}],
...     [{"role": "assistant", "content": "The sum of 3 and 1 is 4, which we multiply by 2 to get 8. So (3 + 1) * 2 = 8."}],
... ]
>>> format_reward_func(prompts=prompts, completions=completions)
[1.0, 0.0]

例3: 参照に基づく報酬の補完

以下は、補完が正しいかどうかを確認する報酬関数の例です。この例は、論文DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learningで使用されているaccuracy reward関数に着想を得ています。 この例は、標準形式向けに設計されており、データセットにはground_truthという名前のカラムが含まれます。

import re

def reward_func(completions, ground_truth, **kwargs):
    # Regular expression to capture content inside \boxed{}
    matches = [re.search(r"\\boxed\{(.*?)\}", completion) for completion in completions]
    contents = [match.group(1) if match else "" for match in matches]
    # Reward 1 if the content is the same as the ground truth, 0 otherwise
    return [1.0 if c == gt else 0.0 for c, gt in zip(contents, ground_truth)]

この関数は次のようにテストできます。

>>> prompts = ["Problem: Solve the equation $2x + 3 = 7$. Solution:", "Problem: Solve the equation $3x - 5 = 10$."]
>>> completions = [r" The solution is \boxed{2}.", r" The solution is \boxed{6}."]
>>> ground_truth = ["2", "5"]
>>> reward_func(prompts=prompts, completions=completions, ground_truth=ground_truth)
[1.0, 0.0]

例4: マルチタスク報酬関数

以下は、RLOOTrainerで複数の報酬関数を使用する例です。この例では、タスク固有の報酬関数としてmath_reward_funcとcoding_reward_funcを定義しています。math_reward_funcは数学問題の正答性に基づいて報酬を与え、coding_reward_funcはコーディング問題の解答が動作するかどうかに基づいて報酬を与えます。

from datasets import Dataset
from trl import RLOOTrainer

# Define a dataset that contains both math and coding problems
dataset = Dataset.from_list(
    [
        {"prompt": "What is 2+2?", "task": "math"},
        {"prompt": "Write a function that returns the sum of two numbers.", "task": "code"},
        {"prompt": "What is 3*4?", "task": "math"},
        {"prompt": "Write a function that returns the product of two numbers.", "task": "code"},
    ]
)

# Math-specific reward function
def math_reward_func(prompts, completions, task, **kwargs):
    rewards = []
    for prompt, completion, t in zip(prompts, completions, task):
        if t == "math":
            # Calculate math-specific reward
            correct = check_math_solution(prompt, completion)
            reward = 1.0 if correct else -1.0
            rewards.append(reward)
        else:
            # Return None for non-math tasks
            rewards.append(None)
    return rewards

# Coding-specific reward function
def coding_reward_func(prompts, completions, task, **kwargs):
    rewards = []
    for prompt, completion, t in zip(prompts, completions, task):
        if t == "code":
            # Calculate coding-specific reward
            works = test_code_solution(prompt, completion)
            reward = 1.0 if works else -1.0
            rewards.append(reward)
        else:
            # Return None for non-coding tasks
            rewards.append(None)
    return rewards

# Use both task-specific reward functions
trainer = RLOOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs=[math_reward_func, coding_reward_func],
    train_dataset=dataset,
)

trainer.train()

この例では、math_reward_func と coding_reward_func は、数学とコーディングの問題の両方を含む混合データセットで動作するように設計されています。データセットの task 列は、各問題にどの報酬関数を適用するかを決定するために使用されます。データセットのサンプルに関連する報酬関数が存在しない場合、報酬関数は None を返し、RLOOTrainer は有効な関数とタスクで処理を続行します。これにより、RLOOTrainer は、適用範囲が異なる複数の報酬関数を処理できるようになります。

RLOOTrainerは、報酬関数が返すNoneの報酬を無視し、関連する関数が返した報酬のみを考慮します。これにより、モデルは関連するタスクで学習され、関連する報酬関数がないタスクは無視されるようになります。

例5: 非同期報酬関数

カスタム報酬関数は、async def コルーチンとして定義することもできます。報酬が低速な I/O に依存する場合(リモートサービスの呼び出しなど)に便利です。複数の非同期報酬関数を渡すと、RLOOTrainer はそれらを並行して実行し、レイテンシを重複させます。

以下は、I/O 束縛操作をシミュレートする非同期報酬関数の最小限の例です:

import asyncio

async def async_reward_func(prompts, completions, **kwargs):
    # Simulate an I/O-bound call (e.g., HTTP request, database lookup)
    await asyncio.sleep(0.01)
    # Simple toy reward: 1.0 if the completion is non-empty, else 0.0
    return [1.0 if completion else 0.0 for completion in completions]

例6: 追加の列とメトリックのログ記録

以下は、completions テーブルに追加の列を記録し、スカラー指標をプロットとして記録する報酬関数の例です。

import re

def reward_func(completions, ground_truth, log_extra=None, log_metric=None, **kwargs):
    extracted = [re.search(r"\\boxed\{(.*?)\}", c) for c in completions]
    extracted = [m.group(1) if m else None for m in extracted]
    rewards = [1.0 if e == gt else 0.0 for e, gt in zip(extracted, ground_truth)]

    if log_extra:
        log_extra("golden_answer", list(ground_truth))
        log_extra("extracted_answer", [e or "[none]" for e in extracted])

    if log_metric:
        log_metric("accuracy", sum(rewards) / len(rewards))

    return rewards

報酬関数をトレーナーに渡す

カスタム報酬関数を使用するには、RLOOTrainerに次のように渡します:

from trl import RLOOTrainer

trainer = RLOOTrainer(
    reward_funcs=reward_func,
    ...,
)

リストとして複数の報酬関数を渡すことができます。このリストには、同期関数と非同期関数の両方が含まれる場合があります。

from trl import RLOOTrainer

trainer = RLOOTrainer(
    reward_funcs=[reward_func, async_reward_func1, async_reward_func2],
    ...,
)

報酬は、各関数からの報酬の合計として計算されます。reward_weightsが設定に指定されている場合は、加重和として計算されます。

RLOOTrainerは、異なるタイプの複数の報酬関数をサポートしていることに注意してください。詳細は、パラメータのドキュメントを参照してください。

ビジョン言語モデルの学習

RLOOは、テキストと画像の両方を含むマルチモーダルデータセットで、ビジョン言語モデル(VLM)のトレーニングをサポートしています。

サポートされているモデル

テスト済み:

  • Gemma3 — 例: google/gemma-3-4b-it
  • LLaVA-NeXT — 例: llava-hf/llava-v1.6-mistral-7b-hf
  • Qwen2-VL — 例: Qwen/Qwen2-VL-2B-Instruct
  • Qwen2.5-VL — 例: Qwen/Qwen2.5-VL-3B-Instruct
  • SmolVLM2 — 例: HuggingFaceTB/SmolVLM2-2.2B-Instruct

すべてのVLMとの互換性は保証されていません。サポートされるべきモデルがあると思われる場合は、GitHubでissueを立ててください。より良い方法としては、必要な変更を含むpull requestを送信することです。

クイックスタート

rloo_vlm.pyを使用してVLMのファインチューニングを行います。lmms-lab/multimodal-open-r1-8k-verifiedでの学習の例として、以下のコマンドを使用します:

torchrun --nproc_per_node 8 examples/rloo_visual_math/rloo_visual_math.py \
  --deepspeed examples/deepspeed_configs/zero3.json \
  --model_name_or_path Qwen/Qwen2.5-VL-3B-Instruct \
  --output_dir rloo-Qwen2.5-VL-3B-Instruct \
  --learning_rate 1e-5 \
  --dtype bfloat16 \
  --max_completion_length 1024 \
  --use_vllm \
  --vllm_mode colocate \
  --use_peft \
  --lora_target_modules "q_proj", "v_proj" \
  --log_completions

設定のコツ

  • ビジョン言語投影層にLoRAを使用する
  • メモリ使用量を削減するために4ビット量子化を有効にします
  • VLMはメモリに負荷がかかります — 小さいバッチサイズから開始してください
  • ほとんどのモデルは vLLM(server モードおよび colocate モード)と互換性があります。

データセットの形式

各トレーニングサンプルには、以下を含める必要があります:

  • prompt: プロセッサのチャットテンプレートで整形されたテキスト
  • image/images: PIL Image または PIL Image のリスト

Trainerは、モデルのimage processorを介して、画像からテンソルへの変換を自動的に処理します。

RLOOTrainer

クラス trl.RLOOTrainer

< >

( model: str | PreTrainedModel | PeftModelreward_funcs: str | transformers.modeling_utils.PreTrainedModel | collections.abc.Callable[..., list[float | None]] | list[str | transformers.modeling_utils.PreTrainedModel | collections.abc.Callable[..., list[float | None]]]args: trl.trainer.rloo_config.RLOOConfig | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | datasets.dataset_dict.DatasetDict | datasets.dataset_dict.IterableDatasetDict | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonereward_processing_classes: transformers.tokenization_utils_base.PreTrainedTokenizerBase | list[transformers.tokenization_utils_base.PreTrainedTokenizerBase] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)quantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = None )

パラメータ

  • model (str または PreTrainedModel または PeftModel) — 学習対象のモデル。以下のいずれかです:
    • 文字列。huggingface.co上のモデルリポジトリにホストされている事前学習モデルのmodel id、またはsave_pretrainedを使用してモデルの重みを保存したディレクトリへのパス(例: './my_model_directory/')です。モデルは、モデル設定から導出される<ModelArchitecture>を用いた<ModelArchitecture>.from_pretrainedによって、args.model_init_kwargs内のキーワード引数を使用して読み込まれます。args.model_init_kwargsにdtypeが指定されていない場合、デフォルトはfloat32です。これは、モデル設定からdtypeを推論する(Transformers v5以降)from_pretrainedとは異なります。
    • PreTrainedModelオブジェクト。因果言語モデルのみサポートされています。
    • PeftModelオブジェクト。因果言語モデルのみサポートされています。
  • reward_funcs (RewardFunc | list[RewardFunc]) — 報酬の計算に使用する報酬関数です。報酬を計算するには、プロンプトと補完を引数としてすべての報酬関数を呼び出し、その報酬を合計します。以下のいずれかになります:
    • 単一の報酬関数、例えば次のようなもの:

      • 文字列: huggingface.co上のモデルリポジトリにホストされている事前学習済みモデルのモデルID、またはsave_pretrainedを使用して保存されたモデルの重みを含むディレクトリへのパス。例: './my_model_directory/'。モデルはnum_labels=1およびargs.model_init_kwargs内のキーワード引数を使用して、from_pretrainedで読み込まれます。

      • PreTrainedModel オブジェクト: シーケンス分類モデルのみサポートされています。

      • カスタム報酬関数: 関数には、プロンプトと生成された補完、およびデータセット内の追加の列が渡されます。報酬のリストを返す必要があります。カスタム報酬関数は同期または非同期のいずれかであり、報酬が該当サンプルに適用されない場合はNoneを返すこともできます。これは、異なる報酬関数が異なるタイプのサンプルに適用されるマルチタスク学習に有用です。報酬関数がサンプルに対してNoneを返した場合、その報酬関数はそのサンプルの報酬計算から除外されます。詳細については、カスタム報酬関数の使用を参照してください。

        トレーナーの状態は、報酬関数にも渡されます。トレーナーの状態はTrainerStateのインスタンスであり、報酬関数のシグネチャにあるtrainer_state引数にアクセスすることで取得できます。

    • 報酬関数のリストです。各項目は、上記のいずれかの型を独立して指定できます。リスト内で異なる型を混在させること(例: 文字列のモデルIDとカスタム報酬関数)は許可されています。

  • args (RLOOConfig、任意) — このトレーナーの設定です。None の場合、デフォルトの設定が使用されます。
  • train_dataset (Dataset または IterableDataset) — 学習に使用するデータセットです。データセットには "prompt". データセット内のその他の列は無視されます。サンプルの形式は次のいずれかです:
    • Standard: 各サンプルにはプレーンテキストが含まれています。
    • 対話形式: 各サンプルには構造化されたメッセージ(例: roleとcontent)が含まれます。

    train_dataset が IterableDataset(ストリーミングデータセットなど)である場合、その長さを推定できないため、学習ループの上限を定め、学習率スケジューラを設定するために必要な総学習ステップ数を指定するため、max_steps を学習引数で設定する必要があります。

  • eval_dataset (Dataset、IterableDataset、DatasetDict、IterableDatasetDict または dict[str, Dataset | IterableDataset]) — 評価に使用する Dataset です。train_dataset と同じ要件を満たす必要があります。
  • processing_class (PreTrainedTokenizerBase、ProcessorMixin、任意) — データを処理するために使用される処理クラスです。padding side は “left” に設定する必要があります。None の場合、from_pretrained を使用してモデル名から処理クラスを読み込みます。padding トークンである tokenizer.pad_token を設定する必要があります。処理クラスに padding トークンが設定されていない場合、tokenizer.eos_token がデフォルトとして使用されます。
  • reward_processing_classes (PreTrainedTokenizerBase または list[PreTrainedTokenizerBase], 省略可能) — reward_funcs で指定された報酬関数に対応する処理クラスです。 reward_funcs. 以下のいずれかです:
    • 単一の処理クラス: reward_funcsに報酬関数が1つのみ含まれている場合に使用されます。
    • 処理クラスのリスト: reward_funcs内の報酬関数の順序と長さに一致する必要があります。 Noneに設定されている場合、またはPreTrainedModelに対応するリストの要素が Noneの場合、モデルのトークナイザーは from_pretrainedを使用して自動的に読み込まれます。reward_funcs内のカスタム報酬 関数(PreTrainedModelではないもの)に対応するreward_processing_classesの エントリは無視されます。
  • callbacks (のリスト TrainerCallback, 省略可) — トレーニングループをカスタマイズするためのコールバックのリスト。デフォルトのコールバックのリストに追加されます。デフォルトのコールバックの詳細は こちら.

    デフォルトで使用するコールバックの1つを削除したい場合は、remove_callbackメソッドを使用します。

  • optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]、任意、デフォルトは (None, None)) — 使用するオプティマイザーとスケジューラーを含むタプルです。デフォルトでは、モデルに対して AdamW のインスタンスと、args によって制御される get_linear_schedule_with_warmup によって与えられるスケジューラーが使用されます。
  • quantization_config (BitsAndBytesConfig、任意) — モデル識別子からモデルを読み込む際に使用される量子化設定です。QLoRA 学習には peft_config と組み合わせて使用します。モデルがすでにインスタンス化されている場合は無視されます。
  • peft_config (PeftConfig, 任意) — モデルをラップするために使用される PEFT 設定です。None の場合、モデルはラップされません。

Trainer for the Reinforce Leave One Out (RLOO) method. This algorithm was initially proposed in the paper Back to Basics: Revisiting REINFORCE Style Optimization for Learning from Human Feedback in LLMs.

例:

>>> from trl import RLOOTrainer
>>> from trl.rewards import accuracy_reward
>>> from datasets import load_dataset

>>> dataset = load_dataset("trl-lib/DeepMath-103K", split="train")

>>> trainer = RLOOTrainer(
...     model="Qwen/Qwen2.5-0.5B-Instruct",
...     reward_funcs=accuracy_reward,
...     train_dataset=dataset,
... )
>>> trainer.train()

train

< >

( resume_from_checkpoint: str | bool | None = Nonetrial: optuna.Trial | dict[str, Any] | None = Noneignore_keys_for_eval: list[str] | None = None ) → ~trainer_utils.TrainOutput

パラメータ

  • resume_from_checkpoint (str または bool、省略可) — str の場合、以前の Trainer インスタンスによって保存されたチェックポイントのローカルパスを指定します。bool で True の場合、以前の Trainer インスタンスによって args.output_dir に保存された最後のチェックポイントを読み込みます。指定がある場合、ここで読み込まれたモデル/オプティマイザ/スケジューラの状態からトレーニングを再開します。
  • trial (optuna.Trial または dict[str, Any]、省略可) — ハイパーパラメータ探索のための試行またはハイパーパラメータの辞書。
  • ignore_keys_for_eval (list[str]、省略可) — モデルの出力が辞書である場合、学習中の評価で予測を収集する際に無視すべきキーのリストです。

戻り値

~trainer_utils.TrainOutput

グローバルステップ数、トレーニング損失、およびメトリクスを含むオブジェクト。

メインの学習エントリポイント。

save_model

< >

( output_dir: str | None = None_internal_call: bool = False )

モデルを保存するため、from_pretrained()を使用して再読み込みできます。

メインプロセスからのみ保存します。

push_to_hub

< >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = Noneprivate: bool | None = None**kwargs )

パラメータ

  • commit_message (str、任意、デフォルトは"End of training") — プッシュ時にコミットするメッセージ。
  • blocking (bool、省略可能、デフォルトはTrue) — git pushが完了した後にのみ関数が返すかどうか。
  • token (str、任意、デフォルトはNone) — Trainer の元の引数を上書きするための書き込み権限を持つトークン。
  • revision (str, 省略可) — コミット元の git リビジョンです。“main” ブランチのヘッドがデフォルトです。
  • private (bool、省略可) — リポジトリ作成時にプライベートにするかどうか。デフォルトはargs.hub_private_repoです。リポジトリが既に存在する場合は、この引数は無効です。
  • kwargs (dict[str, Any]、省略可) — ~Trainer.create_model_card に渡される追加のキーワード引数。

self.args.hub_model_id のリポジトリに、self.model と self.processing_class を 🤗 model hub にアップロードします。

RLOOConfig

クラス trl.RLOOConfig

< >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-06lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool = Truegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool | None = Falselabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonedisable_dropout: bool = Falsenum_generations: int | None = 2num_generations_eval: int | None = Nonemax_completion_length: int | None = 512ds3_gather_for_generation: bool = Trueshuffle_dataset: bool | None = Truepad_to_multiple_of: int | str | None = 'auto'generation_batch_size: int | None = Nonesteps_per_generation: int | None = Nonetemperature: float = 1.0top_p: float = 1.0top_k: int = 0min_p: float | None = Nonegeneration_kwargs: dict | str | None = Nonechat_template_kwargs: dict | str | None = Nonerepetition_penalty: float = 1.0cache_implementation: str | None = Noneuse_vllm: bool = Falsevllm_mode: str = 'colocate'vllm_model_impl: str = 'vllm'vllm_enable_sleep_mode: bool = Falsevllm_structured_outputs_regex: str | None = Nonevllm_server_base_url: str | None = Nonevllm_server_host: str = '0.0.0.0'vllm_server_port: int = 8000vllm_server_timeout: float = 240.0vllm_group_port: int = 51216vllm_gpu_memory_utilization: float = 0.3vllm_max_model_length: int | None = Nonevllm_tensor_parallel_size: int = 1beta: float = 0.05num_iterations: int = 1epsilon: float = 0.2epsilon_high: float | None = Nonereward_weights: list[float] | None = Nonenormalize_advantages: bool = Falsereward_clip_range: tuple[float, float] | None = Nonemask_truncated_completions: bool = Falsesync_ref_model: bool = Falseref_model_mixup_alpha: float = 0.6ref_model_sync_steps: int = 512log_completions: bool = Falselog_multimodal: bool = Truenum_completions_to_print: int | None = Nonelog_unique_prompts: bool = Falseuse_transformers_continuous_batching: bool = Falsetransformers_continuous_batching_config: dict | str | None = Noneuse_transformers_paged: bool = False )

モデルと参照モデルを制御するパラメータ

  • model_init_kwargs (strまたはdict[str, Any]、省略可) — model引数がRLOOTrainerの文字列として指定された場合に使用される、from_pretrainedのキーワード引数です。処理クラスの読み込み時にもrevisionの値が使用されます。
  • trust_remote_code (bool, optional, defaults to False) — Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to from_pretrained and from_pretrained. Also applied to reward-model and reward-tokenizer loads.
  • router_aux_loss_coef (float, 任意) — Mixture-of-Experts (MoE) モデルにおける負荷分散用の補助損失の係数です。この重みで学習損失に追加されます。設定されていない場合、モデル設定で宣言された値が使用されます。0.0 に設定すると無効になります。MoE 以外のモデルで使用するとエラーになります。
  • disable_dropout (bool、任意、デフォルトはFalse) — モデル内の dropout を無効にするかどうか。参照モデルを用いた学習時に有用であり、同じ入力に対してモデルが異なる logprobs を生成することを防ぎます。

データ前処理を制御するパラメータ

  • remove_unused_columns (bool、任意、デフォルトは False) — データセットで "prompt" 列のみを保持するかどうか。"prompts" と "completions" 以外の列を必要とするカスタムの報酬関数を使用する場合は、この値を False に設定してください。
  • num_generations (int, 省略可能, デフォルトは 2) — プロンプトごとにサンプリングする生成数。実効バッチサイズ (num_processes * per_device_batch_size * gradient_accumulation_steps) は、この値で割り切れる必要があります。
    • gradient_accumulation_steps) は、この値で割り切れる必要があります。
  • num_generations_eval (int, 任意) — 評価時にサンプリングする生成回数です。評価時に生成回数を減らすことで計算量を節約できます。None の場合、num_generations の値が使用されます。
  • max_completion_length (int または None、任意、デフォルトは 512) — 生成される補完の最大長。
  • ds3_gather_for_generation (bool、任意、デフォルトは True) — この設定は DeepSpeed ZeRO-3 に適用されます。有効にすると、生成のためにポリシーモデルの重みが集約され、生成速度が向上します。ただし、このオプションを無効にすると、1 つの GPU の VRAM 容量を超えるモデルのトレーニングが可能になりますが、その代わりとして生成速度は低下します。このオプションを無効にすると、vLLM による生成と互換性がありません。
  • shuffle_dataset (bool、任意、デフォルトはTrue) — 学習データセットをシャッフルするかどうか。
  • pad_to_multiple_of (int または str、任意、デフォルトは "auto") — 設定されている場合、プロンプト ID と補完 ID は、この値の倍数にパディングされます。"auto" は Neuron (AWS Trainium) 上で 128 の倍数にパディングします。Neuron は入力形状ごとに一度だけコンパイルされるためです。その他の環境ではパディングは行われません。

生成を制御するパラメータ

  • generation_batch_size (int, 任意) — 生成に使用するバッチサイズ。None の場合、実効的な学習バッチサイズ、すなわち per_device_train_batch_size * num_processes * steps_per_generation がデフォルトとして使用されます。つまり、1回の最適化ステップごとに1つの生成バッチが処理されます。steps_per_generation とは排他的です。
  • steps_per_generation (int, 省略可) — 1回の生成あたりのステップ数。Noneの場合、gradient_accumulation_stepsがデフォルト値として使用されます。generation_batch_sizeとは排他的です。
  • temperature (float、任意、デフォルトは1.0) — サンプリング用の温度です。温度が高いほど、補完はランダムになります。
  • top_p (float、任意、デフォルトは 1.0) — 考慮する上位トークンの累積確率を制御する浮動小数点数です。値は (0, 1] の範囲でなければなりません。すべてのトークンを考慮するには 1.0 を設定してください。
  • top_k (int、任意、デフォルトは0) — トップkフィルタリングのために保持する、確率の高い語彙トークンの数。0の場合、トップkフィルタリングは無効になり、すべてのトークンが対象となります。
  • min_p (float, 省略可) — トークンの最小確率です。最も確率の高いトークンの確率でスケーリングされます。0.0 と 1.0 の間の値である必要があります。一般的な値は 0.01-0.2 の範囲です。
  • generation_kwargs (dict[str, Any], 省略可) — 補完のサンプリング時に GenerationConfig (transformers を使用する場合) または SamplingParams (vLLM を使用する場合) に渡す追加のキーワード引数です。 suppress_tokens や num_beams の設定など、生成の動作をさらにカスタマイズするために使用できます。 他の生成パラメータ (例: min_p、top_p など) と競合するキーが含まれている場合、それらが上書きされます。
  • chat_template_kwargs (dict[str, Any], 省略可) — 補完を生成する際にapply_chat_template関数に渡す追加のキーワード引数。
  • repetition_penalty (float、任意、デフォルト値は1.0) — プロンプトとこれまでに生成されたテキストにトークンが出現しているかどうかに基づいて、新しいトークンをペナルティする浮動小数点数です。 値が1.0より大きい場合、モデルは新しいトークンを使用するよう促され、値が1.0より小さい場合、モデルはトークンを繰り返すよう促されます。
  • cache_implementation (str, 任意) — use_vllm が False に設定されている場合、生成を高速化するためのキャッシュ方式の実装。

vLLM による生成加速を制御するパラメータ

  • use_vllm (bool、省略可、デフォルトは False) — 補完の生成に vLLM を使用するかどうかを指定します。True に設定すると、デフォルトの model.generate() の代わりに、vLLM を生成に使用します。vllm のインストールが必要です。
  • vllm_mode (str, 省略可能, デフォルトは "colocate") — が use_vllm に設定されている場合の vLLM 統合で使用するモード True. のいずれかである必要があります "server" または "colocate".
    • "server": トレーナーは、別の vLLM サーバーに生成リクエストを送信します。vLLM サーバーが実行されていることを確認してください(vllm serveで開始)。
    • "colocate": vLLM は同じプロセス内で実行され、トレーニング用の GPU を共有します。これにより、別のサーバーを必要としない一方で、トレーニングとの間でリソースの競合が発生する可能性があります。
  • vllm_model_impl (str、任意、デフォルトは"vllm") — vLLM に使用するモデル実装です。"transformers" または "vllm" のいずれかである必要があります。"transformers": モデル実装に transformers バックエンドを使用します。"vllm": モデル実装に vllm ライブラリを使用します。
  • vllm_enable_sleep_mode (bool、任意、デフォルトはFalse) — オプティマイザーステップ中に重み/キャッシュをオフロードするために、vLLM のスリープモードを有効にします。GPU メモリ使用率を低く保ちますが、エンジンの復帰時にホストとデバイス間の転送遅延が発生します。
  • vllm_structured_outputs_regex (str, 省略可) — vLLM の構造化出力に使用する正規表現です。None(デフォルト)の場合、構造化出力は無効になります。

vLLM サーバーを制御するパラメータ(`vllm_mode` が `"server"` の場合のみ使用)

  • vllm_server_base_url (str, 省略可) — vLLM サーバーのベース URL (例: "http://localhost:8000")。指定された場合、vllm_server_host および vllm_server_port は無視されます。
  • vllm_server_host (str、任意、デフォルトは "0.0.0.0") — 接続する vLLM サーバーのホストです。vllm_server_base_url が指定されている場合は無視されます。
  • vllm_server_port (int、任意、デフォルトは8000) — 接続する vLLM サーバーのポートです。vllm_server_base_url が指定されている場合は無視されます。
  • vllm_server_timeout (float, 省略可能、デフォルト値は 240.0) — vLLM サーバーの起動を待機する合計タイムアウト時間(秒)です。タイムアウト後にサーバーが起動していない場合、ConnectionError が発生します。
  • vllm_group_port (int, 任意、デフォルトは 51216) — 重み更新グループ用のポート番号です。vLLM サーバーとの通信に使用されます。ポートが占有されていない限り、変更する必要はありません。

colocate された vLLM 実行を制御するパラメータ(`vllm_mode` が `"colocate"` の場合のみ使用)

  • vllm_gpu_memory_utilization (float、任意、デフォルト値は 0.3) — vLLM の GPU メモリ使用率を制御します。この設定は、vllm_mode が "colocate" に設定されている場合にのみ適用されます。vllm_mode="server" を使用している場合は、--vllm_gpu_memory_utilization フラグを指定して vLLM サーバーを起動する際に、このパラメータを別途渡す必要があります。
  • vllm_max_model_length (int, 省略可) — vLLM のコンテキストウィンドウです。データセット内の最大プロンプト長に max_completion_length を加えた値以上を設定してください。省略した場合、モデルの設定から推論されます。
  • vllm_tensor_parallel_size (int、任意、デフォルトは 1) — vLLM のテンソル並列サイズを制御します。この設定は、vllm_mode が "colocate" に設定されている場合にのみ適用されます。vllm_mode="server" を使用している場合は、--vllm_tensor_parallel_size フラグを指定して vLLM サーバーを起動する際に、このパラメータを別途渡す必要があります。

学習を制御するパラメータ

  • beta (float、任意、デフォルトは0.05) — KL係数。0.0の場合、参照モデルは読み込まれず、メモリ使用量が削減され、トレーニング速度が向上します。
  • num_iterations (int、任意、デフォルトは1) — バッチあたりの反復回数(アルゴリズムでは μ と表記されます)。
  • epsilon (float, 任意、デフォルトは 0.2) — クリッピング用のエプシロン値。
  • epsilon_high (float, オプション) — クリッピング用の上限エプシロン値です。指定しない場合、引数 epsilon で指定された下限値と同じ値がデフォルトとして使用されます。論文 DAPO では 0.28 が推奨されています。
  • reward_weights (list[float], 任意) — 各報酬関数に対する重み。報酬関数の数と一致する必要があります。None の場合、すべての報酬が重み 1.0 で等しく重み付けされます。
  • normalize_advantages (bool、省略可能、デフォルトはFalse) — アドバンテージを正規化するか否かを指定します。正規化は、生成バッチごとに平均0.0、標準偏差1.0となるように行われます。
  • reward_clip_range (tuple[float, float]、省略可) — (min, max) 形式の報酬のクリップ範囲。None の場合は、クリッピングは適用されません。
  • mask_truncated_completions (bool、任意、デフォルトは False) — 有効にすると、切り詰められた補完は損失計算から除外され、誤ってペナルティを課されることによる学習中のノイズの導入を防ぎます。DAPO 論文によると、これは学習の安定性にとって良いプラクティスです。
  • sync_ref_model (bool、任意、デフォルトはFalse) — ref_model_mixup_alpha パラメータを使用して、ref_model_sync_steps ステップごとに参照モデルをアクティブなモデルと同期するかどうか。TR-DPO 論文に由来する同期処理です。
  • ref_model_mixup_alpha (float, 任意、デフォルト値は 0.6) — TR-DPO論文からのαパラメータで、更新時の現在のポリシーと以前の参照ポリシーの間の混合を制御します。参照ポリシーは、以下の方程式に従って更新されます: π_ref = α * π_θ + (1 - α) * π_ref_prev。このパラメータを使用するには、sync_ref_model=True を設定する必要があります。
  • ref_model_sync_steps (int、任意、デフォルトは512) — TR-DPO論文のτパラメータで、現在のポリシーを参照ポリシーと同期する頻度を決定します。このパラメータを使用するには、sync_ref_model=Trueを設定する必要があります。

ログ出力を制御するパラメータ

  • log_completions (bool、任意、デフォルトはFalse) — logging_steps ステップごとに、(プロンプト、補完) のペアのサンプルをログに記録するかどうか。rich がインストールされている場合、サンプルを出力します。wandb および/または trackio のログ出力が有効な場合、wandb および/または trackio に記録します。
  • log_multimodal (bool、任意、デフォルトはTrue) — 補完と合わせてマルチモーダルコンテンツ(画像、動画など)をログに記録するかどうか。高解像度のマルチモーダルデータを使用する場合、ログサイズを削減するためにこれを無効にできます。
  • num_completions_to_print (int, 省略可) — richで表示する補完の数を指定します。Noneの場合、すべての補完がログに記録されます。
  • log_unique_prompts (bool、任意、デフォルトはFalse) — 一意のプロンプトのみをログに記録するかどうか。Trueの場合、一意のプロンプトのみがログに記録されます。Falseの場合、すべてのプロンプトがログに記録されます。

transformers の連続バッチ処理による生成高速化を制御するパラメータ

  • use_transformers_continuous_batching (bool、任意、デフォルトはFalse) — 補完の生成に transformers の continuous batching エンジンを使用するかどうか。transformers>=5.8.0 が必要です。
  • transformers_continuous_batching_config (dict、省略可) — ContinuousBatchingConfig 用のキーワード引数。

非推奨のパラメータ

  • use_transformers_paged —

    パラメータ use_transformers_paged は非推奨となり、バージョン v2.0.0 で削除されます。代わりに use_transformers_continuous_batching を使用してください。

RLOOTrainerの構成クラスです。

このクラスには、RLOO学習に固有のパラメータのみが含まれています。学習引数の完全なリストについては、TrainingArgumentsのドキュメントを参照してください。なお、このクラス内のデフォルト値は、TrainingArgumentsのものと異なる場合があります。

HfArgumentParser を使用すると、このクラスをコマンドラインで指定できる argparse の引数に変換できます。

これらのパラメータは、TrainingArgumentsとは異なるデフォルト値を持っています:

  • logging_steps: デフォルト値が500ではなく10になります。
  • gradient_checkpointing: デフォルト値がFalseではなくTrueに変更されました。
  • bf16: fp16が設定されていない場合、デフォルトでFalseではなくTrueになります。
  • learning_rate: 5e-5ではなく、デフォルト値が1e-6に変更されました。

参考文献

  1. RLOO論文
  2. ペーパー Back to Basics: LLMにおける人間からのフィードバック学習のためのREINFORCEスタイル最適化の再検討
  3. 論文 - REINFORCE++: 大規模言語モデルの整列のためのシンプルかつ効率的なアプローチ
  4. ブログ記事 - RLHFにRLを取り戻す
  5. ブログ記事 - RLHFとそのバリアントの解明:進捗と実践的なエンジニアリングの知見
  6. Youtube - RLOO: LLMにおける人間のフィードバックからの学習のためのコスト効率の高い最適化

旧実装(0.21 以前)からの移行ガイド

バージョン0.22.0のリリースに伴い、RLOOTrainerを刷新し、GRPOTrainerなどのライブラリ内の他のオンライントレーナーとより整合性を持たせました。この新しい実装により、トレーナーの設定パラメータと全体構造にいくつかの変更が導入されました。 以下は、RLOOConfigの主な変更点の概要です。

TRL ≤ 0.21.xTRL ≥ 0.22.0
rloo_knum_generationsに名前が変更されました
cliprangeepsilon に変更されました
kl_coefbeta に名前が変更されました
exp_namerun_nameに名前が変更されました。旧来の動作を再現するには、run_name = f"{exp_name}__{seed}__{int(time.time())}"を使用してください。
normalize_rewardnormalize_advantages に名前が変更されました。注: この関数は常にアドバンテージを正規化していました(旧名称にもかかわらず)。
num_ppo_epochsnum_iterations に変更されました(デフォルト: 1)
token_level_kl削除 – KLはシーケンスレベルでのみ計算されるようになりました
dataset_num_proc削除 – 未使用だったため
num_mini_batchessteps_per_generation に変更されました
total_episodes代わりにmax_steps=total_episodes / gradient_accumulation_stepsを使用してください
local_rollout_forward_batch_size削除 – 現在は自動的にper_device_train_batch_size(評価中はper_device_eval_batch_size)に設定されます
num_sample_generations削除 – 生成ログの頻度を制御するにはlogging_stepsを使用してください
response_lengthmax_completion_length に変更されました(デフォルト: 512)
stop_token削除
stop_token_id削除 – processing_class.eos_token_id を使用してください
missing_eos_penalty削除 – eos_token_idがcompletion_idsに含まれているかをチェックするカスタム報酬関数で再現

以下は、RLOOTrainerの主な変更点の概要です。

TRL ≤ 0.21.xTRL ≥ 0.22.0
configargs に名前が変更されました
reward_modelreward_funcs に名称変更され、報酬モデルとカスタム報酬関数の両方をサポートするようになりました
policymodel に変更されました
ref_policy削除 – 参照モデルは現在、modelから自動的に作成されます
data_collator削除
Update on GitHub