# RLOO Trainer

[![model badge](https://img.shields.io/badge/All_models-RLOO-blue)](https://huggingface.co/models?other=rloo,trl)

## 概要

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

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

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

このポストトレーニング手法は、[Costa Huang](https://github.com/vwxyzjn) 氏によって提供され、その後 [Shirin Yamani](https://huggingface.co/ShirinYamani) 氏によってリファクタリングされました。

## クイックスタート

この例では、RLOO手法を用いてモデルを学習する方法を示します。[DeepMath-103Kデータセット](https://huggingface.co/datasets/trl-lib/DeepMath-103K)のプロンプトを使用して、[Qwen 0.5B Instructモデル](https://huggingface.co/Qwen/Qwen2-0.5B-Instruct)を学習します。データセットのデータは以下で確認できます:

<iframe src="https://huggingface.co/datasets/trl-lib/DeepMath-103K/embed/viewer/default/train?row=0" frameborder="0" width="100%" height="560px"
>

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

```python
# 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()
```

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

```bash
torchrun --nproc_per_node 8 train_rloo.py
```

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

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

![RLOO](https://huggingface.co/datasets/trl-lib/documentation-images/resolve/main/rloo.png)

### 補完の生成

各トレーニングステップにおいて、プロンプトのバッチをサンプリングし、各プロンプトに対して\\( G \\)個の補完セットを生成します（\\( o_i \\)と表記します）。

### 報酬の計算

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

1. クエリ\\( q \\)に条件付けられた、生成された\\( G \\)個のシーケンス\\( o_i = (o_{i,1}, \dots, o_{i,T}) \\)のそれぞれについて、報酬モデル\\( R(o_i, q) \\)を用いてスカラー報酬を計算します。
2. 同時に、シーケンス全体にわたって、現在のポリシー \\( \pi_\theta \\) と固定された参照ポリシー \\( \pi_{\text{ref}} \\) の間のKLダイバージェンスを推定します。シーケンス \\( o_i \\) に対するKL推定値は以下の通りです。

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

シーケンス\\( o_i \\)に最終的に割り当てられる報酬は次のようになります:

$$ r_i = R(o_i, q) - \beta \, \mathbb{D}_{\mathrm{KL}}\!\left[\pi_\theta \|\pi_{\mathrm{ref}}\right], $$

\\( \beta > 0 \\) は KL 罰則の強さを制御します。

> [!TIP]
> 完全にオンラインな設定（`num_iterations = 1`、デフォルト）では、データは現在のポリシーによって生成されます。この場合、KLペナルティは現在のポリシーを直接使用して計算されます。
>
> より一般的な設定（例えば、バッチごとに複数の勾配ステップを行う場合）では、データはより以前のスナップショット\\( \pi_{\text{old}} \\)によって生成されます。ペナルティがサンプリング分布と整合性を保つようにするため、KLは、このポリシーに対して定義されます：
>
> \\( \mathbb{D}_{\mathrm{KL}}\!\left[\pi_{\text{old}} \,\|\, \pi_{\text{ref}}\right]. \\)
>
> 同様に、サンプリングされたシーケンス\\( o \\) に対して、モンテカルロ推定は次のようになります:
>
> \\( \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個の補完のバッチにおいて、補完のベースラインは次のようになります。 $$ b_i = \frac{1}{G-1} \sum_{j \neq i} r_j $$

その後、各completionのadvantageは、そのrewardとbaselineの差として計算されます。

$$
A_i = r_i - b_i
$$

### 損失の計算

REINFORCE損失は、単に以下のように定義されます:

$$ \mathcal{L}_{\text{RLOO}}(\theta) = - \frac{1}{G} \sum_{i=1}^G \hat{A}_i \, \log \pi_\theta(o_i \mid q) $$

実際には、同じバッチに対して複数の勾配ステップを実行すると、現在のパラメータに対してアクションが実質的にオフポリシーになります。これを補正するために、重要性サンプリング比を導入します。サンプリングと勾配ステップの間でポリシーが変化した場合に、過度に大きな更新を防ぐために、この比をクリップします：

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

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

> [!NOTE]
> GRPOとは異なり、RLOOではKL項を介して勾配の逆伝播を行いません。ここではKLは純粋に報酬の整形に使用されます。`no_grad`の下で計算され、スカラー報酬\\( r_i \\)に組み込まれ、これがデタッチされたアドバンテージ\\( \hat{A}_i \\)となります。
>
> つまり、ポリシーへの勾配が流れる唯一の経路は、重要度比の項\\( \frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)} \\)であり、KL項はポリシーへの逆伝播を行いません。
>
> 一方、[GRPO](grpo_trainer)は、現在のポリシー \\( \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 の目的関数が信頼領域内に留まるようクリップされるシーケンス確率の比率: \\( \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`: 信頼領域の下限でクリップされたシーケンス確率の比率の平均: \\(r_{i,t}(\theta) < 1 - \epsilon_\mathrm{low}\\)。
- `clip_ratio/low_min`: 信頼領域の下限における、完了ごとの最小クリップ指標: \\(r_{i,t}(\theta) < 1 - \epsilon_\mathrm{low}\\)。
- `clip_ratio/high_mean`: 信頼領域の上限でクリップされたシーケンス確率の比率の平均: \\(r_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}\\)。
- `clip_ratio/high_max`: 信頼領域の上限における、完了ごとの最大クリップ指標: \\(r_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}\\)。

## カスタマイズ

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

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

```shell
pip install trl[vllm]
```

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

#### オプション 1: Colocate モード

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

```python
from trl import RLOOConfig

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

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

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

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

   ```bash
   VLLM_SERVER_DEV_MODE=1 vllm serve <model_name> \
       --weight-transfer-config '{"backend": "nccl"}' \
       --logprobs-mode processed_logprobs \
       --max-logprobs -1
   ```

2. **学習スクリプトでサーバーモードを有効にする**:

   ```python
   from trl import RLOOConfig

   training_args = RLOOConfig(
       ...,
       use_vllm=True,
       vllm_mode="server",
   )
   ```

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

> [!TIP]
> モデルサイズや学習に必要なGPUメモリ全体の要件に応じて、[RLOOConfig](/docs/trl/v1.18.0/ja/rloo_trainer#trl.RLOOConfig)の`vllm_gpu_memory_utilization`パラメータを調整し、リソースの未活用やメモリ不足エラーを回避する必要がある場合があります。
>
> モデルの構成と実験設定に基づいて、推奨されるGPUメモリ使用率を推定するための[HF Space](https://huggingface.co/spaces/trl-lib/recommend-vllm-memory)を提供しています。以下のように使用すると、`vllm_gpu_memory_utilization`の推奨値を取得できます。
>
> 
>
> 推奨値があなたの環境で機能しない場合、安定性を確保するために、推奨値に小さなバッファ（例：+0.05 または +0.1）を加えることをお勧めします。
>
> それでもメモリ不足エラーが発生する場合は、`vllm_enable_sleep_mode`をTrueに設定してください。これにより、最適化ステップ中にvllmのパラメータとキャッシュがオフロードされます。詳細については、[vLLM Sleep Modeによるメモリ使用量の削減](reducing_memory_usage#vllm-sleep-mode)を参照してください。

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

詳細については、[vLLMによるトレーニングの高速化](speeding_up_training#vllm-for-fast-generation-in-online-methods)を参照してください。

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

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

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

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

```sh
#!/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
```

```python
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](/docs/trl/v1.18.0/ja/rloo_trainer#trl.RLOOTrainer)は、稠密報酬モデルの代わりにカスタム報酬関数を使用することをサポートしています。互換性を確保するために、報酬関数は以下の要件を満たす必要があります。

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

1. **入力引数**:
   - この関数は、次のものをキーワード引数として受け取らなければなりません:
     - `prompts`（プロンプトを含む）
     - `completions`（生成された補完を含む）
     - `completion_ids`（トークン化された補完を含む）
     - `trainer_state` ([TrainerState](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.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`を使用することです。
   - データセットの形式によって、入力が異なります:
     - [標準形式](dataset_formats#standard)の場合、`prompts`と`completions`は文字列のリストになります。
     - [会話形式](dataset_formats#conversational)の場合、`prompts`と`completions`はメッセージの辞書のリストになります。

2. **戻り値**: 関数は float のリストを返す必要があります。各 float は、1つの completion に対応する報酬を表します。

#### 例1: 長い補完を報酬

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

```python
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]
```

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

```python
>>> 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: 長い補完を報酬する（文字数に基づく）

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

```python
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]
```

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

```python
>>> 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](https://huggingface.co/papers/2501.12948)で使用されている_format reward_関数に着想を得ています。プロンプトと補完が構造化されたメッセージで構成される対話形式向けに設計されています。

```python
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]
```

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

```python
>>> 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](https://huggingface.co/papers/2501.12948)で使用されている_accuracy reward_関数に着想を得ています。この例は、`ground_truth`という名前のカラムを含むデータセットを対象とした[標準形式](dataset_formats#standard)用に設計されています。

```python
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)]
```

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

```python
>>> 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](/docs/trl/v1.18.0/ja/rloo_trainer#trl.RLOOTrainer)で複数の報酬関数を使用する例です。この例では、タスク固有の報酬関数として`math_reward_func`と`coding_reward_func`を定義しています。`math_reward_func`は数学問題の正答性に基づいて報酬を与え、`coding_reward_func`はコーディング問題の解答が動作するかどうかに基づいて報酬を与えます。

```python
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](/docs/trl/v1.18.0/ja/rloo_trainer#trl.RLOOTrainer) は有効な関数とタスクで処理を続行します。これにより、[RLOOTrainer](/docs/trl/v1.18.0/ja/rloo_trainer#trl.RLOOTrainer) は、適用範囲が異なる複数の報酬関数を処理できるようになります。

[RLOOTrainer](/docs/trl/v1.18.0/ja/rloo_trainer#trl.RLOOTrainer)は、報酬関数が返す`None`の報酬を無視し、関連する関数が返した報酬のみを考慮します。これにより、モデルは関連するタスクで学習され、関連する報酬関数がないタスクは無視されるようになります。

#### 例5: 非同期報酬関数

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

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

```python
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 テーブルに追加の列を記録し、スカラー指標をプロットとして記録する報酬関数の例です。

```python
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](/docs/trl/v1.18.0/ja/rloo_trainer#trl.RLOOTrainer)に次のように渡します:

```python
from trl import RLOOTrainer

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

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

```python
from trl import RLOOTrainer

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

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

[RLOOTrainer](/docs/trl/v1.18.0/ja/rloo_trainer#trl.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`

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

### クイックスタート

[rloo\_vlm.py](https://github.com/huggingface/trl/blob/main/examples/rloo_visual_math/rloo_visual_math.py) を使用して VLM をファインチューニングします。[`lmms-lab/multimodal-open-r1-8k-verified`](https://huggingface.co/datasets/lmms-lab/multimodal-open-r1-8k-verified) での学習の例コマンド:

```bash
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]]

#### trl.RLOOTrainer[[trl.RLOOTrainer]]

```python
trl.RLOOTrainer(model: str | PreTrainedModel | PeftModel, reward_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 = None, train_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = None, eval_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 = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = None, reward_processing_classes: transformers.tokenization_utils_base.PreTrainedTokenizerBase | list[transformers.tokenization_utils_base.PreTrainedTokenizerBase] | None = None, callbacks: list[transformers.trainer_callback.TrainerCallback] | None = None, optimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None), quantization_config: BitsAndBytesConfig | None = None, peft_config: PeftConfig | None = None)
```

[ソース](https://github.com/huggingface/trl/blob/v1.18.0/trl/trainer/rloo_trainer.py#L113)

**パラメータ:**

model (`str` または [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) または `PeftModel`) : 学習対象のモデル。以下のいずれかです。 - 文字列。huggingface.co のモデルリポジトリにホストされている事前学習モデルの *model id*、または [save_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.save_pretrained) を使用してモデルの重みを保存した *ディレクトリ* へのパス。例えば `'./my_model_directory/'`。モデルは、`args.model_init_kwargs` のキーワード引数を用いて `<ModelArchitecture>.from_pretrained`（`<ModelArchitecture>` はモデル設定から導出されます）によって読み込まれます。`args.model_init_kwargs` に `dtype` が指定されていない場合、デフォルトは `float32` になります。これは [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.from_pretrained) と異なり、後者では（Transformers v5 以降）dtype がモデル設定から推論されます。 - [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) オブジェクト。因果言語モデルのみサポートされています。 - `PeftModel` オブジェクト。因果言語モデルのみサポートされています。

reward_funcs (`RewardFunc | list[RewardFunc]`) : 報酬の計算に使用する報酬関数です。報酬を計算するには、プロンプトと補完を引数としてすべての報酬関数を呼び出し、その報酬を合計します。以下のいずれかになります。 - 単一の報酬関数。例: - 文字列: huggingface.co のモデルリポジトリにホストされている事前学習モデルの *モデル ID*、または [save_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.save_pretrained) を使用してモデルの重みを保存した *ディレクトリ* へのパス。例: `'./my_model_directory/'`。モデルは `num_labels=1` と `args.model_init_kwargs` 内のキーワード引数を指定して [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForSequenceClassification.from_pretrained) を使用して読み込まれます。 - [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) オブジェクト: シーケンス分類モデルのみサポートされています。 - カスタム報酬関数: 関数には、プロンプトと生成された補完、およびデータセット内の追加の列が渡されます。報酬のリストを返す必要があります。カスタム報酬関数は同期または非同期のいずれかであり、報酬が該当サンプルに適用されない場合は `None` を返すこともできます。これは、異なるタイプのサンプルに異なる報酬関数が適用されるマルチタスク学習に有用です。報酬関数がサンプルに対して `None` を返した場合、その報酬関数はそのサンプルの報酬計算から除外されます。詳細については、[カスタム報酬関数の使用](#using-a-custom-reward-function) を参照してください。 トレーナーの状態も報酬関数に渡されます。トレーナーの状態は [TrainerState](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.TrainerState) のインスタンスであり、報酬関数のシグネチャの `trainer_state` 引数にアクセスすることで取得できます。 - 報酬関数のリスト。各項目は独立して上記のいずれかのタイプであっても構いません。リスト内で異なるタイプを混在させること（例: 文字列のモデル ID とカスタム報酬関数）は許可されています。

args ([RLOOConfig](/docs/trl/v1.18.0/ja/rloo_trainer#trl.RLOOConfig)、*任意*) : このトレーナーの設定です。`None`の場合、デフォルトの設定が使用されます。

train_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset) または [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset)) : 学習に使用するデータセットです。`"prompt"` という列を含んでいなければなりません。データセット内のその他の追加列は無視されます。サンプルの形式は、以下のいずれかです: - [Standard](dataset_formats#standard): 各サンプルがプレーンテキストを含む。 - [Conversational](dataset_formats#conversational): 各サンプルが構造化されたメッセージ（例: role と content）を含む。 `train_dataset` が [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset)（例: ストリーミングデータセット）である場合、その長さを推定できないため、学習ループを制限し、学習率スケジューラを設定するために必要な総学習ステップ数を指定するため、`max_steps` を学習引数で設定する必要があります。

eval_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset)、[IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset)、[DatasetDict](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.DatasetDict)、[IterableDatasetDict](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDatasetDict) または `dict[str, Dataset | IterableDataset]`) : 評価に使用する Dataset です。`train_dataset` と同じ要件を満たす必要があります。

processing_class ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase)、[ProcessorMixin](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/processors#transformers.ProcessorMixin)、*任意*) : データを処理するために使用される処理クラスです。padding side は "left" に設定する必要があります。`None` の場合、[from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.from_pretrained) を使用してモデル名から処理クラスが読み込まれます。padding トークンである `tokenizer.pad_token` を設定する必要があります。処理クラスで padding トークンが設定されていない場合、`tokenizer.eos_token` がデフォルトとして使用されます。

reward_processing_classes ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) または `list[PreTrainedTokenizerBase]`、*任意*) : `reward_funcs` で指定された報酬関数に対応する処理クラス。以下のいずれかになります。
- 単一の処理クラス: `reward_funcs` に報酬関数が1つのみ含まれている場合に使用します。
- 処理クラスのリスト: `reward_funcs` 内の報酬関数の順序と長さに一致する必要があります。
`None` に設定されている場合、または [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) に対応するリストの要素が `None` の場合、モデルのトークナイザーは [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoTokenizer.from_pretrained) を使用して自動的に読み込まれます。`reward_funcs` 内のカスタム報酬関数（[PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) ではないもの）の要素については、`reward_processing_classes` 内の対応するエントリは無視されます。

callbacks ([TrainerCallback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.TrainerCallback) のリスト、*任意*) : トレーニングループをカスタマイズするためのコールバックのリストです。[こちら](https://huggingface.co/docs/transformers/main_classes/callback)で詳細が記載されているデフォルトのコールバックのリストに追加されます。デフォルトで使用されているコールバックを削除したい場合は、[remove_callback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.Trainer.remove_callback) メソッドを使用してください。

optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`、*任意*、デフォルトは`(None, None)`) : 使用するオプティマイザーとスケジューラーを含むタプルです。デフォルトでは、モデルに対して`AdamW`のインスタンスと、`args`によって制御される[get_linear_schedule_with_warmup](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup)で与えられるスケジューラーが使用されます。

quantization_config ([BitsAndBytesConfig](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/quantization#transformers.BitsAndBytesConfig)、*optional*) : モデル識別子からモデルを読み込む際に使用される量子化設定。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](https://huggingface.co/papers/2402.14740).

例:

```python
>>> 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[[trl.RLOOTrainer.train]]

```python
train(resume_from_checkpoint: str | bool | None = None, trial: optuna.Trial | dict[str, Any] | None = None, ignore_keys_for_eval: list[str] | None = None)
```

[ソース](https://github.com/huggingface/trl/blob/v1.18.0/transformers/trainer.py#L1450)

**パラメータ:**

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[[trl.RLOOTrainer.save_model]]

```python
save_model(output_dir: str | None = None, _internal_call: bool = False)
```

[ソース](https://github.com/huggingface/trl/blob/v1.18.0/transformers/trainer.py#L4077)

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

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

#### push_to_hub[[trl.RLOOTrainer.push_to_hub]]

```python
push_to_hub(commit_message: str | None = 'End of training', blocking: bool = True, token: str | None = None, revision: str | None = None, private: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/trl/blob/v1.18.0/transformers/trainer.py#L4337)

**パラメータ:**

commit_message (`str`、*任意*、デフォルトは`"End of training"`) : push 時にコミットするメッセージ。

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` に渡される追加のキーワード引数。

**戻り値:**

`blocking=False`の場合、モデルがプッシュされたリポジトリのURL、または`blocking=True`の場合、コミットの進捗を追跡する`Future`オブジェクトを返します。

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

## RLOOConfig[[trl.RLOOConfig]]

#### trl.RLOOConfig[[trl.RLOOConfig]]

```python
trl.RLOOConfig(output_dir: str | None = None, per_device_train_batch_size: int = 8, num_train_epochs: float = 3.0, max_steps: int = -1, learning_rate: float = 1e-06, lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear', lr_scheduler_kwargs: dict | str | None = None, warmup_steps: float = 0, optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused', optim_args: str | None = None, weight_decay: float = 0.0, adam_beta1: float = 0.9, adam_beta2: float = 0.999, adam_epsilon: float = 1e-08, optim_target_modules: None | str | list[str] = None, gradient_accumulation_steps: int = 1, average_tokens_across_devices: bool = True, max_grad_norm: float = 1.0, label_smoothing_factor: float = 0.0, bf16: bool | None = None, fp16: bool = False, bf16_full_eval: bool = False, fp16_full_eval: bool = False, tf32: bool | None = None, activation_checkpointing: bool | None = None, activation_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, gradient_checkpointing: bool = True, gradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, torch_compile: bool = False, torch_compile_backend: str | None = None, torch_compile_mode: str | None = None, use_liger_kernel: bool = False, liger_kernel_config: dict[str, bool] | None = None, use_cache: bool = False, neftune_noise_alpha: float | None = None, torch_empty_cache_steps: int | None = None, auto_find_batch_size: bool = False, logging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps', logging_steps: float = 10, logging_first_step: bool = False, log_on_each_node: bool = True, logging_nan_inf_filter: bool = True, include_num_input_tokens_seen: str | bool = 'no', log_level: str = 'passive', log_level_replica: str = 'warning', disable_tqdm: bool | None = None, report_to: None | str | list[str] = 'none', run_name: str | None = None, project: str = 'huggingface', trackio_space_id: str | None = None, trackio_bucket_id: str | None = None, trackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = None, eval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no', eval_steps: float | None = None, eval_delay: float = 0, per_device_eval_batch_size: int = 8, prediction_loss_only: bool = False, eval_on_start: bool = False, eval_do_concat_batches: bool = True, eval_use_gather_object: bool = False, eval_accumulation_steps: int | None = None, include_for_metrics: list[str] = <factory>, batch_eval_metrics: bool = False, save_only_model: bool = False, save_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps', save_steps: float = 500, save_on_each_node: bool = False, save_total_limit: int | None = None, enable_jit_checkpoint: bool = False, push_to_hub: bool = False, hub_token: str | None = None, hub_private_repo: bool | None = None, hub_model_id: str | None = None, hub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save', hub_always_push: bool = False, hub_revision: str | None = None, load_best_model_at_end: bool = False, metric_for_best_model: str | None = None, greater_is_better: bool | None = None, ignore_data_skip: bool = False, restore_callback_states_from_checkpoint: bool = False, full_determinism: bool = False, seed: int = 42, data_seed: int | None = None, use_cpu: bool = False, accelerator_config: dict | str | None = None, parallelism_config: accelerate.parallelism_config.ParallelismConfig | None = None, dataloader_drop_last: bool = False, dataloader_num_workers: int = 0, dataloader_pin_memory: bool = True, dataloader_persistent_workers: bool = False, dataloader_prefetch_factor: int | None = None, dataloader_multiprocessing_context: str | None = None, dataloader_in_order: bool = True, remove_unused_columns: bool | None = False, label_names: list[str] | None = None, train_sampling_strategy: str = 'random', length_column_name: str = 'length', ddp_find_unused_parameters: bool | None = None, ddp_bucket_cap_mb: int | None = None, ddp_broadcast_buffers: bool | None = None, ddp_static_graph: bool | None = None, ddp_backend: str | None = None, ddp_timeout: int = 1800, fsdp: str | None = None, fsdp_config: dict[str, typing.Any] | str | None = None, deepspeed: dict | str | None = None, debug: str | list[transformers.debug_utils.DebugOption] = '', skip_memory_metrics: bool = True, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, resume_from_checkpoint: str | None = None, local_rank: int = -1, model_init_kwargs: dict[str, typing.Any] | str | None = None, trust_remote_code: bool = False, router_aux_loss_coef: float | None = None, disable_dropout: bool = False, num_generations: int | None = 2, num_generations_eval: int | None = None, max_completion_length: int | None = 512, ds3_gather_for_generation: bool = True, shuffle_dataset: bool | None = True, pad_to_multiple_of: int | str | None = 'auto', generation_batch_size: int | None = None, steps_per_generation: int | None = None, temperature: float = 1.0, top_p: float = 1.0, top_k: int = 0, min_p: float | None = None, generation_kwargs: dict | str | None = None, chat_template_kwargs: dict | str | None = None, repetition_penalty: float = 1.0, cache_implementation: str | None = None, use_vllm: bool = False, vllm_mode: str = 'colocate', vllm_model_impl: str = 'vllm', vllm_enable_sleep_mode: bool = False, vllm_structured_outputs_regex: str | None = None, vllm_server_base_url: str | None = None, vllm_server_host: str = '0.0.0.0', vllm_server_port: int = 8000, vllm_server_timeout: float = 240.0, vllm_group_port: int = 51216, vllm_gpu_memory_utilization: float = 0.3, vllm_max_model_length: int | None = None, vllm_tensor_parallel_size: int = 1, beta: float = 0.05, num_iterations: int = 1, epsilon: float = 0.2, epsilon_high: float | None = None, reward_weights: list[float] | None = None, normalize_advantages: bool = False, reward_clip_range: tuple[float, float] | None = None, mask_truncated_completions: bool = False, sync_ref_model: bool = False, ref_model_mixup_alpha: float = 0.6, ref_model_sync_steps: int = 512, log_completions: bool = False, log_multimodal: bool = True, num_completions_to_print: int | None = None, log_unique_prompts: bool = False, use_transformers_continuous_batching: bool = False, transformers_continuous_batching_config: dict | str | None = None, use_transformers_paged: bool = False)
```

[ソース](https://github.com/huggingface/trl/blob/v1.18.0/trl/trainer/rloo_config.py#L23)

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

model_init_kwargs (`str` または `dict[str, Any]`、*省略可能*) : [RLOOTrainer](/docs/trl/v1.18.0/ja/rloo_trainer#trl.RLOOTrainer) の `model` 引数が文字列として指定された場合に、[from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.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](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained) and [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.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`、*optional*、デフォルトは`2`) : プロンプトごとにサンプリングする生成回数。実効バッチサイズ (num_processes * per_device_batch_size * gradient_accumulation_steps) は、この値で割り切れる必要があります。

num_generations_eval (`int`, *optional*) : 評価時にサンプリングする生成回数。評価時に生成回数を減らすことで計算量を節約できます。`None`の場合、`num_generations`の値が使用されます。

max_completion_length (`int` または `None`、*任意*、デフォルトは `512`) : 生成される補完の最大長。

ds3_gather_for_generation (`bool`、*任意*、デフォルトは`True`) : この設定はDeepSpeed ZeRO-3に適用されます。有効にすると、生成のためにポリシーモデルの重みが集約され、生成速度が向上します。ただし、このオプションを無効にすると、単一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`, *optional*) : 生成に使用するバッチサイズ。`None`の場合、実効的な学習バッチサイズ、すなわち`per_device_train_batch_size * num_processes * steps_per_generation`がデフォルトとして使用されます。言い換えれば、最適化ステップごとに1つの生成バッチが処理されます。`steps_per_generation`とは排他的です。

steps_per_generation (`int`, *任意*) : 1回の生成あたりのステップ数。`None`の場合、`gradient_accumulation_steps`がデフォルト値として使用されます。`generation_batch_size`とは排他的です。

temperature (`float`、*任意*、デフォルトは`1.0`) : サンプリング用の温度です。温度が高いほど、補完はランダムになります。

top_p (`float`、*optional*、デフォルトは`1.0`) : 考慮する上位トークンの累積確率を制御する浮動小数点数です。値は(0, 1]の範囲でなければなりません。すべてのトークンを考慮するには`1.0`に設定してください。

top_k (`int`、*optional*、デフォルトは`0`) : top-kフィルタリングのために保持する、確率の高い語彙トークンの数。`0`の場合、top-kフィルタリングは無効になり、すべてのトークンが考慮されます。

min_p (`float`, *optional*) : 最小トークン確率です。最も確率の高いトークンの確率でスケーリングされます。`0.0` から `1.0` までの値である必要があります。一般的な値は `0.01-0.2` の範囲です。

generation_kwargs (`dict[str, Any]`, *任意*) : 補完をサンプリングする際に、[GenerationConfig](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/text_generation#transformers.GenerationConfig)（transformers を使用する場合）または `SamplingParams`（vLLM を使用する場合）に渡す追加のキーワード引数です。`suppress_tokens` や `num_beams` を設定するなど、生成の動作をさらにカスタマイズするために使用できます。他の生成パラメータ（`min_p` や `top_p` など）と競合するキーが含まれている場合、それらが上書きされます。

chat_template_kwargs (`dict[str, Any]`、*任意*) : 補完を生成する際に`apply_chat_template`関数に渡す追加のキーワード引数。

repetition_penalty (`float`、*optional*、デフォルトは`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` が `True` に設定されている場合の vLLM 統合で使用するモードです。 `"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`、*optional*、デフォルトは`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`、*optional*、デフォルトは`0.05`) : KL係数。`0.0`の場合、参照モデルは読み込まれず、メモリ使用量が削減され、トレーニング速度が向上します。

num_iterations (`int`, *任意*, デフォルトは `1`) : バッチあたりの反復回数（アルゴリズムでは μ と表記されます）。

epsilon (`float`、*任意*、デフォルトは`0.2`) : クリッピング用のエプシロン値。

epsilon_high (`float`, *任意*) : クリッピング用の上限エプシロン値。指定しない場合、引数 `epsilon` で指定された下限値と同じ値がデフォルトとして使用されます。論文 [DAPO](https://huggingface.co/papers/2503.14476) では `0.28` が推奨されています。

reward_weights (`list[float]`, *optional*) : 各報酬関数に対する重み。報酬関数の数と一致する必要があります。`None`の場合、すべての報酬が重み`1.0`で等しく重み付けされます。

normalize_advantages (`bool`, *任意*, デフォルトは `False`) : 利得を正規化するかどうかを指定します。正規化は、平均が `0.0` で標準偏差が `1.0` になるように、生成バッチごとに実行されます。

reward_clip_range (`tuple[float, float]`、*optional*) : 報酬のクリップ範囲を (min, max) として指定します。`None` の場合は、クリップは適用されません。

mask_truncated_completions (`bool`、*任意*、デフォルトは`False`) : 有効にすると、切り詰められた補完が損失計算から除外され、誤ってペナルティを課されることによる学習中のノイズの導入を防ぎます。[DAPO](https://huggingface.co/papers/2503.14476)論文によると、これは学習の安定性にとって良いプラクティスです。

sync_ref_model (`bool`、*任意*、デフォルトは`False`) : `ref_model_mixup_alpha`パラメータを使用して、`ref_model_sync_steps`ステップごとに参照モデルをアクティブモデルと同期するかどうか。この同期は[TR-DPO](https://huggingface.co/papers/2404.09656)論文に由来します。

ref_model_mixup_alpha (`float`、*任意*、デフォルトは`0.6`) : [TR-DPO](https://huggingface.co/papers/2404.09656)論文からのαパラメータです。更新時に現在のポリシーと以前の参照ポリシーの混合を制御します。参照ポリシーは、以下の式に従って更新されます: `π_ref = α * π_θ + (1 - α) * π_ref_prev`。このパラメータを使用するには、`sync_ref_model=True`を設定する必要があります。

ref_model_sync_steps (`int`、*任意*、デフォルトは`512`) : [TR-DPO](https://huggingface.co/papers/2404.09656)論文のτパラメータ。現在のポリシーが参照ポリシーと同期される頻度を決定します。このパラメータを使用するには、`sync_ref_model=True`を設定する必要があります。

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

log_completions (`bool`, *任意*, デフォルトは `False`) : `logging_steps` ステップごとに (プロンプト, 補完) のペアのサンプルをログに記録するかどうか。`rich` がインストールされている場合、サンプルを出力します。`wandb` および/または `trackio` のログ出力が有効な場合、`wandb` および/または `trackio` に記録します。

log_multimodal (`bool`、*任意*、デフォルトは`True`) : マルチモーダルコンテンツ（画像、動画など）を補完と合わせてログに記録するかどうか。高解像度のマルチモーダルデータを使用する際にログサイズを削減するには、これを無効にしてください。

num_completions_to_print (`int`, *optional*) : `rich`で表示する補完の回数。`None`の場合、すべての補完がログに記録されます。

log_unique_prompts (`bool`、*任意*、デフォルトは`False`) : 一意のプロンプトのみをログに記録するかどうか。`True`の場合、一意のプロンプトのみがログに記録されます。`False`の場合、すべてのプロンプトがログに記録されます。

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

use_transformers_continuous_batching (`bool`、*任意*、デフォルトは`False`) : 補完の生成に Transformers の連続バッチングエンジンを使用するかどうか。`transformers>=5.8.0`が必要です。

transformers_continuous_batching_config (`dict`, *任意*) : `ContinuousBatchingConfig` のキーワード引数です。

**非推奨のパラメータ:**

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

[RLOOTrainer](/docs/trl/v1.18.0/ja/rloo_trainer#trl.RLOOTrainer)の構成クラスです。

このクラスには、RLOO学習に固有のパラメータのみが含まれています。学習引数の完全なリストについては、[TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments)のドキュメントを参照してください。なお、このクラス内のデフォルト値は、[TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments)のものと異なる場合があります。

[HfArgumentParser](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.HfArgumentParser) を使用すると、このクラスをコマンドラインで指定できる [argparse](https://docs.python.org/3/library/argparse#module-argparse) の引数に変換できます。

> [!NOTE]
> これらのパラメータは、[TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments)とは異なるデフォルト値を持っています: - `logging_steps`: `500`ではなく、デフォルトで`10`になります。 - `gradient_checkpointing`: `False`ではなく、デフォルトで`True`になります。 - `bf16`: `fp16`が設定されていない場合、`False`ではなく、デフォルトで`True`になります。 - `learning_rate`: `5e-5`ではなく、デフォルトで`1e-6`になります。

## 参考文献

1. [RLOO論文](https://openreview.net/pdf?id=r1lgTGL5DE)
2. [ペーパー Back to Basics: LLMにおける人間からのフィードバック学習のためのREINFORCEスタイル最適化の再検討](https://huggingface.co/papers/2402.14740)
3. [論文 - REINFORCE++: 大規模言語モデルの整列のためのシンプルかつ効率的なアプローチ](https://huggingface.co/papers/2501.03262)
4. [ブログ記事 - RLHFにRLを取り戻す](https://huggingface.co/blog/putting_rl_back_in_rlhf_with_rloo)
5. [ブログ記事 - RLHFとそのバリアントの解明：進捗と実践的なエンジニアリングの知見](https://hijkzzz.notion.site/unraveling-rlhf-and-its-variants-engineering-insights#147d9a33ecc9806090f3d5c749d31f05)
6. [Youtube - RLOO: LLMにおける人間のフィードバックからの学習のためのコスト効率の高い最適化](https://www.youtube.com/watch?v=86asXGPK6RU&ab_channel=BuzzRobot)

## 旧実装（0.21 以前）からの移行ガイド

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

| TRL ≤ 0.21.x | TRL ≥ 0.22.0 |
| --- | --- |
| `rloo_k` | `num_generations`に名前が変更されました |
| `cliprange` | `epsilon` に変更されました |
| `kl_coef` | `beta` に名前が変更されました |
| `exp_name` | `run_name`に名前が変更されました。旧来の動作を再現するには、`run_name = f"{exp_name}__{seed}__{int(time.time())}"`を使用してください。 |
| `normalize_reward` | `normalize_advantages` に名前が変更されました。注: この関数は常にアドバンテージを正規化していました(旧名称にもかかわらず)。 |
| `num_ppo_epochs` | `num_iterations` に変更されました（デフォルト: `1`） |
| `token_level_kl` | **削除** – KLはシーケンスレベルでのみ計算されるようになりました |
| `dataset_num_proc` | **削除** – 未使用だったため |
| `num_mini_batches` | `steps_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_length` | `max_completion_length` に変更されました（デフォルト: `512`） |
| `stop_token` | **削除** |
| `stop_token_id` | **削除** – `processing_class.eos_token_id` を使用してください |
| `missing_eos_penalty` | **削除** – `eos_token_id`が`completion_ids`に含まれているかをチェックするカスタム報酬関数で再現 |

以下は、[RLOOTrainer](/docs/trl/v1.18.0/ja/rloo_trainer#trl.RLOOTrainer)の主な変更点の概要です。

| TRL ≤ 0.21.x | TRL ≥ 0.22.0 |
| --- | --- |
| `config` | `args` に名前が変更されました |
| `reward_model` | `reward_funcs` に名称変更され、報酬モデルとカスタム報酬関数の両方をサポートするようになりました |
| `policy` | `model` に変更されました |
| `ref_policy` | **削除** – 参照モデルは現在、`model`から自動的に作成されます |
| `data_collator` | **削除** |

