# DPO Trainer

[![All_models-DPO-blue](https://img.shields.io/badge/All_models-DPO-blue)](https://huggingface.co/models?other=dpo,trl) [![smol_course-Chapter_2-yellow](https://img.shields.io/badge/smol_course-Chapter_2-yellow)](https://github.com/huggingface/smol-course/tree/main/2_preference_alignment)

## 概要

TRLは、[Rafael Rafailov](https://huggingface.co/rmrafailov)、Archit Sharma、Eric Mitchell、[Stefano Ermon](https://huggingface.co/ermonste)、[Christopher D. Manning](https://huggingface.co/manning)、[Chelsea Finn](https://huggingface.co/cbfinn)による論文[Direct Preference Optimization: Your Language Model is Secretly a Reward Model](https://huggingface.co/papers/2305.18290)に記載されているDirect Preference Optimization (DPO) Trainerをサポートしており、言語モデルの学習に使用できます。

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

> 大規模な教師なし言語モデル（LM）は広範な世界知識や一部の推論スキルを学習しますが、その学習が完全に教師なしであるため、その動作を正確に制御することは困難です。既存の手法では、モデルの生成結果の相対的な品質に関する人間のラベルを収集し、これらの嗜好に合わせるために教師なし LM をファインチューニングします。この際、人間のフィードバックからの強化学習（RLHF）がしばしば用いられます。しかし、RLHF は複雑で不安定な手順であり、まず人間の嗜好を反映する報酬モデルをフィッティングし、その後、強化学習を用いてこの推定報酬を最大化しながら、元のモデルから大きく逸脱しないように大規模な教師なし LM をファインチューニングします。本論文では、RLHF における報酬モデルの新しいパラメータ化を導入し、これにより対応する最適ポリシーを閉形式で抽出できるようにしました。これにより、標準的な RLHF 問題を単純な分類損失のみで解くことが可能になります。この結果得られるアルゴリズムを Direct Preference Optimization（DPO）と呼びますが、これは安定しており、高性能で、計算負荷が軽いため、ファインチューニング中の LM からのサンプリングや、大幅なハイパーパラメータチューニングの必要性を排除します。私たちの実験は、DPO が既存の手法と同程度、あるいはそれ以上に LM をファインチューニングして人間の嗜好に合わせられることを示しています。特に、DPO によるファインチューニングは、生成の感情を制御する能力において PPO ベースの RLHF を上回り、要約やシングルターン対話における応答の品質を匹敵または向上させると同時に、実装と学習が大幅にシンプルです。

このポストトレーニング手法は、[Kashif Rasul](https://huggingface.co/kashif) 氏によって提供され、その後 [Quentin Gallouédec](https://huggingface.co/qgallouedec) 氏によってリファクタリングされました。

## クイックスタート

この例では、TRLの[DPOTrainer](/docs/trl/main/ja/dpo_trainer#trl.DPOTrainer)を使用して言語モデルをトレーニングする方法を示します。[UltraFeedback dataset](https://huggingface.co/datasets/openbmb/UltraFeedback)で[Qwen 3 0.6B](https://huggingface.co/Qwen/Qwen3-0.6B)モデルをトレーニングします。

```python
from trl import DPOTrainer
from datasets import load_dataset

trainer = DPOTrainer(
    model="Qwen/Qwen3-0.6B",
    train_dataset=load_dataset("trl-lib/ultrafeedback_binarized", split="train"),
)
trainer.train()
```

## 期待されるデータセットの型と形式

DPOには[preference](dataset_formats#preference)データセットが必要です。[DPOTrainer](/docs/trl/main/ja/dpo_trainer#trl.DPOTrainer)は、[標準](dataset_formats#standard)および[会話](dataset_formats#conversational)のデータセット形式の両方に対応しています。会話形式のデータセットが提供されると、トレーナーは自動的にデータセットにチャットテンプレートを適用します。

```python
# Standard format
## Explicit prompt (recommended)
preference_example = {"prompt": "The sky is", "chosen": " blue.", "rejected": " green."}
# Implicit prompt
preference_example = {"chosen": "The sky is blue.", "rejected": "The sky is green."}

# Conversational format
## Explicit prompt (recommended)
preference_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                      "chosen": [{"role": "assistant", "content": "It is blue."}],
                      "rejected": [{"role": "assistant", "content": "It is green."}]}
## Implicit prompt
preference_example = {"chosen": [{"role": "user", "content": "What color is the sky?"},
                                 {"role": "assistant", "content": "It is blue."}],
                      "rejected": [{"role": "user", "content": "What color is the sky?"},
                                   {"role": "assistant", "content": "It is green."}]}
```

データセットがこれらの形式のいずれでもない場合は、前処理によって期待される形式に変換できます。[Vezora/Code-Preference-Pairs](https://huggingface.co/datasets/Vezora/Code-Preference-Pairs)データセットを例に示します。

```python
from datasets import load_dataset

dataset = load_dataset("Vezora/Code-Preference-Pairs")

def preprocess_function(example):
    return {
        "prompt": [{"role": "user", "content": example["input"]}],
        "chosen": [{"role": "assistant", "content": example["accepted"]}],
        "rejected": [{"role": "assistant", "content": example["rejected"]}],
    }

dataset = dataset.map(preprocess_function, remove_columns=["instruction", "input", "accepted", "ID"])
print(next(iter(dataset["train"])))
```

```json
{
    "prompt": [{"role": "user", "content": "Create a nested loop to print every combination of numbers [...]"}],
    "chosen": [{"role": "assistant", "content": "Here is an example of a nested loop in Python [...]"}],
    "rejected": [{"role": "assistant", "content": "Here is an example of a nested loop in Python [...]"}],
}
```

## DPO手法をより深く掘り下げる

Direct Preference Optimization (DPO)は、言語モデルを好みデータに合わせて整列させるために設計された学習手法です。教師ありのインプットとアウトプットのペアではなく、同じプロンプトに対する2つの補完（completion）のペアでモデルを学習します。このとき、一方の補完がもう一方よりも好まれます。この目的関数は、明示的な報酬モデルを必要とすることなく、参照モデルに対する相対的な観点から、好ましい補完と好ましくない補完の対数尤度の差を広げるようにモデルを直接最適化します。実際には、これは通常、好ましい補完の尤度を高めるのではなく、好ましくない補完の尤度を抑制することによって達成されます。

このセクションでは、DPOが実際どのように動作するかを分解して説明します。主なステップである**前処理**と**損失の計算**について扱います。

### 前処理とトークン化

学習中、各サンプルにはプロンプトと、好ましい（`chosen`）および好ましくない（`rejected`）補完が含まれていることが期待されます。期待される形式の詳細については、[Dataset formats](dataset_formats)を参照してください。[DPOTrainer](/docs/trl/main/ja/dpo_trainer#trl.DPOTrainer)は、モデルのトークナイザーを使用して各入力をトークン化します。

### 損失の計算

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

DPOで使用される損失は、次のように定義されます。 $$ \mathcal{L}_{\mathrm{DPO}}(\theta) = -\mathbb{E}_{(x,y^{+},y^{-})}\!\left[\log \sigma\!\left(\beta\Big(\log\frac{\pi_{\theta}(y^{+}\!\mid x)}{\pi_{\mathrm{ref}}(y^{+}\!\mid x)}-\log \frac{\pi_{\theta}(y^{-}\!\mid x)}{\pi_{\mathrm{ref}}(y^{-}\!\mid x)}\Big)\right)\right] $$

ここで、\\( x \\) はプロンプト、\\( y^+ \\) は好ましい補完、\\( y^- \\) は好ましくない補完です。\\( \pi_{\theta} \\) は学習中のポリシーモデル、\\( \pi_{\mathrm{ref}} \\) は参照モデル、\\( \sigma \\) はシグモイド関数、\\( \beta > 0 \\) は好意シグナルの強さを制御するハイパーパラメータです。

#### 損失の種類

文献には、目的関数のいくつかの定式化が提案されています。当初、DPOの目的関数は上記の通り定義されていました。

| `loss_type=` | 説明 |
| --- | --- |
| `"sigmoid"`（デフォルト） | 好意データが与えられた場合、Bradley-Terryモデルに従って二値分類器をフィッティングできます。実際、[DPO](https://huggingface.co/papers/2305.18290)の著者たちは、正規化された尤度に対するシグモイド損失を`logsigmoid`を通じて適用することで、ロジスティック回帰をフィッティングすることを提案しています。 |
| `"hinge"` | [RSO](https://huggingface.co/papers/2309.06657)の著者らは、[SLiC](https://huggingface.co/papers/2305.10425)論文からの正規化尤度に対してヒンジ損失を使用することを提案しています。この場合、`beta`はマージンの逆数です。 |
| `"ipo"` | [IPO](https://huggingface.co/papers/2310.12036)の著者らは、logit変換が過学習を引き起こし得ると主張し、好みを直接最適化するために恒等変換を提案しています。TRLでは、これを`loss_type="ipo"`として公開しています。 |
| `"exo_pair"` | [EXO](https://huggingface.co/papers/2402.00856) の著者らは、reverse-KL 好適性最適化を提案しています。`label_smoothing` は `0.0` より厳密に大きい値でなければなりません。推奨値は `1e-3` です（簡略化されたペアワイズ変種については式 16 を参照）。完全な手法は `K>2` の SFT 補完を使用し、`K` が大きくなるにつれて PPO に近づきます。 |
| `"nca_pair"` | [NCA](https://huggingface.co/papers/2402.05369)の著者たちは、NCAが相対尤度ではなく、各応答の絶対尤度を最適化することを示しています。 |
| `"robust"` | [Robust DPO](https://huggingface.co/papers/2403.00409) の著者らは、ノイズのある好みデータに対するバイアスのない DPO ロスを提案しています。[DPOConfig](/docs/trl/main/ja/dpo_trainer#trl.DPOConfig) で `label_smoothing` を使用してラベル反転の確率をモデル化できます。有効な値は `[0.0, 0.5)` の範囲です。 |
| `"bco_pair"` | [BCO](https://huggingface.co/papers/2404.04656)の著者らは、ロジットを報酬として機能する二値分類器を訓練します。この分類器は、{プロンプト, 選択された補完}のペアを1に、{プロンプト, 拒否された補完}のペアを0にマッピングするように設計されています。 |
| `"sppo_hard"` | [SPPO](https://huggingface.co/papers/2405.00675)の著者らは、SPPOは選択された報酬を1/2に近づけ、拒否された報酬を-1/2に近づけることで、Nash均衡を反復的に解くことができ、データのスパース性问题を緩和できると主張しています。実装では、このアルゴリズムを近似するためにハードラベル確率を用いており、勝者に1、敗者に0を割り当てます。 |
| `"aot"` または `loss_type="aot_unpaired"` | [AOT](https://huggingface.co/papers/2406.05882) の著者らは、最適輸送による分布的選好アライメントを提案しています。`loss_type="aot"` はペアデータ用、`loss_type="aot_unpaired"` は非ペアデータ用です。どちらもソートされた分位数を用いて確率的優位性を強制します。GPU 単体のバッチサイズを大きくすると効果的です。 |
| `"apo_zero"` または `loss_type="apo_down"` | [APO](https://huggingface.co/papers/2408.06266)メソッドはアンカー付きの目的関数を導入します。`apo_zero`は勝者をブーストし、敗者を減衰させます（モデルが勝者のパフォーマンスを下回っている場合に有用です）。`apo_down`は両方を減衰させますが、敗者への圧力がより強くなります（モデルがすでに勝者のパフォーマンスを上回っている場合に有用です）。 |
| `"discopop"` | [DiscoPOP](https://huggingface.co/papers/2406.08414)論文では、LLMを用いてより効率的なオフライン好適性最適化損失を発見しています。本論文で提案されたDiscoPOP損失（対数比で調整された損失）は、異なるタスク（IMDbの肯定的なテキスト生成、Reddit TLDR要約、Alpaca Eval 2.0）において、他の最適化損失を上回るパフォーマンスを示しました。 |
| `"sft"` | SFT（Supervised Fine-Tuning）の損失は、好ましい応答を生成するようにモデルを訓練するために使用される負の対数尤度損失です。 |
| `"sigmoid_norm"` | [SimPO](https://huggingface.co/papers/2405.14734)の著者は、元のシグモイド損失における長さバイアスを、マスクされていないトークンの数で正規化することで対処しています。TRLでは、これを`loss_type="sigmoid_norm"`として公開しています。 |
| `"udpo"` | [UDPO](https://huggingface.co/papers/2607.03248) の著者らは、ノイズのある好みデータに対してバイアスのない DPO ロスを提案しています。このロスは、`"robust"` とは異なり、フリップ確率を過大評価した場合でもバイアスを保ちます。[DPOConfig](/docs/trl/main/ja/dpo_trainer#trl.DPOConfig) の `label_smoothing` を使用してフリップ確率 ε を設定します。有効な値の範囲は `[0.0, 0.5)` です。 |

## 記録されたメトリクス

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

- `global_step`: 現在までに実行されたオプティマイザーステップの総数。
- `epoch`: データセットの反復に基づいた現在のエポック番号。
- `num_tokens`: 現在までに処理されたトークンの総数。
- `loss`: 現在のログ区間におけるDPO損失の平均値。
- `entropy`: マスクされていないトークンにおける、モデルが予測したトークン分布の平均エントロピー。
- `aux_loss`: Mixture-of-Experts モデルのロードバランス用の補助損失。`router_aux_loss_coef` によってスケーリングされ、損失に追加される前の値です。モデルが MoE モデルであり、`router_aux_loss_coef` がゼロでない場合にのみ記録されます。
- `mean_token_accuracy`: 選択された補完のトークンとモデルのトップ1予測が一致する、マスクされていないトークンの割合。
- `learning_rate`: 現在の学習率。スケジューラを使用している場合、動的に変更される可能性があります。
- `grad_norm`: グラディエントクリッピングの前に計算される、勾配のL2ノルム。
- `logits/chosen`: モデルが選択された補完のトークンに割り当てた平均ロジット値。
- `logits/rejected`: モデルが拒否された補完のトークンに割り当てた平均ロジット値。
- `logps/chosen`: モデルが選択された補完のトークンに割り当てた平均対数確率。
- `logps/rejected`: モデルが拒否された補完のトークンに割り当てた平均対数確率。
- `rewards/chosen`: 選択された補完に対して計算される平均暗黙報酬。 \\( \beta \log \frac{\pi_{\theta}(y^{+}\!\mid x)}{\pi_{\mathrm{ref}}(y^{+}\!\mid x)} \\) として計算されます。
- `rewards/rejected`: 拒否された補完に対して計算される平均暗黙報酬。 \\( \beta \log \frac{\pi_{\theta}(y^{-}\!\mid x)}{\pi_{\mathrm{ref}}(y^{-}\!\mid x)} \\) で計算されます。
- `rewards/margins`: 選択された補完と拒否された補完の間の平均的な暗黙の報酬マージン。
- `rewards/accuracies`: 選択された補完の暗黙的な報酬が、拒否された補完のそれより高い例の割合。

## カスタマイズ

### 互換性と制約

現在の[DPOTrainer](/docs/trl/main/ja/dpo_trainer#trl.DPOTrainer)実装では、一部の引数の組み合わせが意図的に制限されています:

- `use_weighting=True` は、`loss_type="aot"` または `loss_type="aot_unpaired"` と併用できません。
- `lm_head`をターゲットとするPEFTアダプターはサポートされていません（代わりに`modules_to_save=["lm_head"]`を使用してください）。
- `sync_ref_model=True`は、独立した`ref_model`を保持しないPEFTモデルでトレーニングする場合はサポートされていません。
- `sync_ref_model=True` は `precompute_ref_log_probs=True` と併用できません。
- `precompute_ref_log_probs=True` は `IterableDataset`（train または eval）と併用できません。

### マルチロス組み合わせ

DPO トレーナーは、異なる重みを持つ複数の損失関数を組み合わせることをサポートしており、より高度な最適化戦略を可能にします。これは、MPO（Mixed Preference Optimization）のようなアルゴリズムの実装に特に有用です。MPO は、論文 [Enhancing the Reasoning Ability of Multimodal Large Language Models via Mixed Preference Optimization](https://huggingface.co/papers/2411.10442) に記載されているように、複数の最適化目標を組み合わせるトレーニング手法です。

複数の損失を組み合わせるには、損失の種類と対応する重みをリストとして指定します:

```python
# MPO: Combines DPO (sigmoid) for preference and BCO (bco_pair) for quality
training_args = DPOConfig(
    loss_type=["sigmoid", "bco_pair", "sft"],  # loss types to combine
    loss_weights=[0.8, 0.2, 1.0]  # corresponding weights, as used in the MPO paper
)
```

### モデルの初期化

`from_pretrained()` メソッドの kwargs を [DPOConfig](/docs/trl/main/ja/dpo_trainer#trl.DPOConfig) に直接渡すことができます。例えば、別の精度でモデルを読み込みたい場合は、

```python
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", dtype=torch.bfloat16)
```

`model_init_kwargs={"dtype": torch.bfloat16}` 引数を [DPOConfig](/docs/trl/main/ja/dpo_trainer#trl.DPOConfig) に渡すことで、これを行うことができます。

```python
from trl import DPOConfig

training_args = DPOConfig(
    model_init_kwargs={"dtype": torch.bfloat16},
)
```

`from_pretrained()`のすべてのキーワード引数がサポートされていることに注意してください。

### PEFTでアダプターを学習

🤗 PEFT ライブラリとの緊密な統合をサポートしており、モデル全体を学習させる代わりに、アダプターを学習して Hub で共有することを、すべてのユーザーが手軽に行えます。

```python
from datasets import load_dataset
from trl import DPOTrainer
from peft import LoraConfig

dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

trainer = DPOTrainer(
    "Qwen/Qwen3-0.6B",
    train_dataset=dataset,
    peft_config=LoraConfig(),
)

trainer.train()
```

[PeftModel](https://huggingface.co/docs/peft/main/en/package_reference/peft_model#peft.PeftModel)の学習を継続することもできます。そのためには、まず`PeftModel`を[DPOTrainer](/docs/trl/main/ja/dpo_trainer#trl.DPOTrainer)の外で読み込み、`peft_config`引数を渡さずにそのままトレーナーに直接渡します。

```python
from datasets import load_dataset
from trl import DPOTrainer
from peft import AutoPeftModelForCausalLM

model = AutoPeftModelForCausalLM.from_pretrained("trl-lib/Qwen3-4B-LoRA", is_trainable=True)
dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

trainer = DPOTrainer(
    model=model,
    train_dataset=dataset,
)

trainer.train()
```

> [!TIP]
> アダプターを学習する際は、学習されるのが新しいパラメータのみであるため、フルファインチューニングよりも高い学習率（約1e‑5）を使用するのが一般的です。
>
> ```python
> DPOConfig(learning_rate=1e-5, ...)
> ```

### DPOのための迅速な実験

RapidFire AI は、TRL の上に構築されたオープンソースの実験エンジンです。単一の GPU 上でも複数の DPO 設定を同時に起動できます。設定を順番に試すのではなく、RapidFire を使用すると、**すべての学習曲線を早期に確認し、性能が低い実行を停止し、実行中に有望な実行を新しい設定でクローンできます**。詳細については、[RapidFire AI Integration](rapidfire_integration)を参照してください。

### Unslothで学習

Unslothは、LLM（Llama、Mistral、Gemma、DeepSeekなど）のファインチューニングと強化学習のためのオープンソースフレームワークです。最大2倍の高速化と最大70%のVRAM削減を実現しながら、トレーニング、評価、デプロイメントのためのHugging Face互換の簡素化されたワークフローを提供します。詳細については、[Unsloth Integration](unsloth_integration)を参照してください。

## DPOによるツール呼び出し

[DPOTrainer](/docs/trl/main/ja/dpo_trainer#trl.DPOTrainer)は、_tool calling_機能を持つモデルのファインチューニングを完全にサポートしています。この場合、各データセットの例には以下を含める必要があります。

- ツール呼び出し（`tool_calls`）やツール応答（`tool`ロールのメッセージ）を含む、会話メッセージ（プロンプト、chosen、rejected）
- `tools` 列に表示される利用可能なツールのリスト。通常、JSON スキーマとして提供されます

期待されるデータセットの構造の詳細については、[Dataset Format — Tool Calling](dataset_formats#tool-calling)セクションを参照してください。

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

[DPOTrainer](/docs/trl/main/ja/dpo_trainer#trl.DPOTrainer)は、Vision-Language Models (VLMs) の学習を完全にサポートしています。VLMを学習するには、`image`列（サンプルごとに1枚の画像）または`images`列（サンプルごとに画像のリスト）を含むデータセットを指定してください。期待されるデータセットの構造の詳細については、[Dataset Format — Vision Dataset](dataset_formats#vision-dataset)セクションを参照してください。このようなデータセットの例として、[RLAIF-V Dataset](https://huggingface.co/datasets/HuggingFaceH4/rlaif-v_formatted)があります。

```python
from trl import DPOConfig, DPOTrainer
from datasets import load_dataset

trainer = DPOTrainer(
    model="Qwen/Qwen2.5-VL-3B-Instruct",
    args=DPOConfig(max_length=None),
    train_dataset=load_dataset("HuggingFaceH4/rlaif-v_formatted", split="train"),
)
trainer.train()
```

> [!TIP]
> VLMでは、切り詰めを行うと画像トークンが削除され、トレーニング中にエラーが発生する可能性があります。これを回避するには、[DPOConfig](/docs/trl/main/ja/dpo_trainer#trl.DPOConfig)で`max_length=None`を設定してください。これにより、モデルは画像トークンを切り詰めずに、シーケンス全体の長さを処理できます。
>
> ```python
> DPOConfig(max_length=None, ...)
> ```
>
> `max_length`は、データセット全体で切り詰めによって画像トークンが削除されないことを確認した場合にのみ使用してください。

## DPOTrainer[[trl.DPOTrainer]]

#### trl.DPOTrainer[[trl.DPOTrainer]]

```python
trl.DPOTrainer(model: str | PreTrainedModel | PeftModel, ref_model: transformers.modeling_utils.PreTrainedModel | None = None, args: trl.trainer.dpo_config.DPOConfig | None = None, data_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | 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, compute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | 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/main/trl/trainer/dpo_trainer.py#L407)

**パラメータ:**

model (`str` または [PreTrainedModel](https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel) または [PeftModel](https://huggingface.co/docs/peft/main/en/package_reference/peft_model#peft.PeftModel)) : 学習対象のモデル。以下のいずれかです。 - 文字列。huggingface.co のモデルリポジトリにホストされている事前学習モデルの *model id*、または [save_pretrained](https://huggingface.co/docs/transformers/main/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/main/en/main_classes/model#transformers.PreTrainedModel.from_pretrained) と異なり、後者では（Transformers v5 以降）dtype がモデル設定から推論されます。 - [PreTrainedModel](https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel) オブジェクト。因果言語モデルのみサポートされています。 - [PeftModel](https://huggingface.co/docs/peft/main/en/package_reference/peft_model#peft.PeftModel) オブジェクト。因果言語モデルのみサポートされています。

ref_model ([PreTrainedModel](https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel)、*任意*) : 参照ログ確率を計算するために使用される参照モデル。 - 指定された場合、このモデルが参照ポリシーとして直接使用されます。[PeftModel](https://huggingface.co/docs/peft/main/en/package_reference/peft_model#peft.PeftModel) は指定できません。 - `None` の場合、トレーナーは `model` に対応する初期ポリシー、つまり DPO トレーニング開始前のモデル状態を自動的に使用します。

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

data_collator (`DataCollator`, *任意*) : 処理済みの`train_dataset`または`eval_dataset`の要素のリストからバッチを形成するために使用する関数。モデルが言語モデルの場合は`DataCollatorForPreference`が、ビジョン言語モデルの場合は`DataCollatorForVisionPreference`がデフォルトとして使用されます。カスタムコレーターでは、パディングの前にシーケンスを切り詰める必要があります。トレーナーは、コレーション後の切り詰めは適用しません。

train_dataset ([Dataset](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.Dataset) または [IterableDataset](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.IterableDataset)) : 学習に使用するデータセット。このトレーナーは、[言語モデリング](#language-modeling) 型と [プロンプト-補完](#prompt-completion) 型の両方をサポートします。サンプルの形式は、以下のいずれかです。 - [標準](dataset_formats#standard): 各サンプルがプレーンテキストを含む。 - [会話](dataset_formats#conversational): 各サンプルが構造化されたメッセージ（例: role と content）を含む。 `train_dataset` が [IterableDataset](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.IterableDataset)（ストリーミングデータセットなど）の場合、その長さを推定できないため、学習ループの範囲を限定し、学習率スケジューラを設定するために必要な総学習ステップ数を指定するため、学習引数で `max_steps` を設定する必要があります。

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

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

compute_metrics (`Callable[[EvalPrediction], dict]`、*省略可*) : 評価時にメトリクスを計算するために使用される関数。[EvalPrediction](https://huggingface.co/docs/transformers/main/en/internal/trainer_utils#transformers.EvalPrediction) を引数に取り、文字列からメトリクス値への辞書を返す必要があります。[SFTConfig](/docs/trl/main/ja/sft_trainer#trl.SFTConfig) を `batch_eval_metrics` が `True` に設定されている状態で渡す場合、`compute_metrics` 関数はブール型の `compute_result` 引数を受け取らなければなりません。これは最後の評価バッチの後にトリガーされ、関数がバッチレベルの統計を累積するのではなく、グローバルなサマリー統計を計算して返す必要があることを示します。受信する logits は、追加のフォワードパスで再計算されます。これは非推奨であり、v2.0.0 で削除されます。

callbacks ([TrainerCallback](https://huggingface.co/docs/transformers/main/en/main_classes/callback#transformers.TrainerCallback) のリスト、*任意*) : トレーニングループをカスタマイズするためのコールバックのリストです。[こちら](https://huggingface.co/docs/transformers/main_classes/callback)で詳細が記載されているデフォルトのコールバックのリストに追加されます。デフォルトで使用されているコールバックを削除したい場合は、[remove_callback](https://huggingface.co/docs/transformers/main/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/main/en/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup)で与えられるスケジューラーが使用されます。

quantization_config ([BitsAndBytesConfig](https://huggingface.co/docs/transformers/main/en/main_classes/quantization#transformers.BitsAndBytesConfig)、*optional*) : モデル識別子からモデルを読み込む際に使用される量子化設定。QLoRA 学習には `peft_config` と組み合わせて使用します。モデルがすでにインスタンス化されている場合は無視されます。

peft_config ([PeftConfig](https://huggingface.co/docs/peft/main/en/package_reference/config#peft.PeftConfig)、*任意*) : モデルをラップするために使用されるPEFT設定。`None`の場合、モデルはラップされません。

Direct Preference Optimization (DPO) 手法用の Trainer です。このアルゴリズムは、論文 [Direct Preference Optimization: Your Language Model is Secretly a Reward Model](https://huggingface.co/papers/2305.18290) で初めて提案されました。このクラスは [Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer) クラスのラッパーであり、そのすべての属性とメソッドを継承します。

例:

```python
>>> from trl import DPOTrainer
>>> from datasets import load_dataset

>>> dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

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

#### train[[trl.DPOTrainer.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/main/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.DPOTrainer.save_model]]

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

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

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

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

#### push_to_hub[[trl.DPOTrainer.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/main/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 にアップロードします。

## DPOConfig[[trl.DPOConfig]]

#### trl.DPOConfig[[trl.DPOConfig]]

```python
trl.DPOConfig(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 = True, 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 = True, dataset_num_proc: int | None = None, max_length: int | None = 1024, truncation_mode: str = 'keep_start', padding_free: bool = False, pad_to_multiple_of: int | str | None = 'auto', precompute_ref_log_probs: bool = False, precompute_ref_batch_size: int | None = None, loss_type: list[str] = <factory>, loss_weights: list[float] | None = None, ld_alpha: float | None = None, f_divergence_type: str = 'reverse_kl', f_alpha_divergence_coef: float = 0.5, label_smoothing: float = 0.0, beta: float = 0.1, use_weighting: bool = False, discopop_tau: float = 0.05, activation_offloading: bool = False, sync_ref_model: bool = False, ref_model_mixup_alpha: float = 0.6, ref_model_sync_steps: int = 512, pad_token: str | None = None)
```

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

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

model_init_kwargs (`dict[str, Any]`、*省略可*) : [DPOTrainer](/docs/trl/main/ja/dpo_trainer#trl.DPOTrainer)の`model`引数が文字列として指定された場合に、[from_pretrained](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained)に渡すキーワード引数です。処理クラスの読み込み時にも`revision`の値が使用されます。

trust_remote_code (`bool`、*任意*、デフォルトは`False`) : カスタムのPythonコードを同梱したモデルやトークナイザーの読み込みを許可するかどうか。[from_pretrained](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained)および[from_pretrained](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoProcessor.from_pretrained)に転送されます。

router_aux_loss_coef (`float`, *任意*) : Mixture-of-Experts (MoE) モデルにおける負荷分散補助損失の係数です。この重みで学習損失に追加されます。設定されていない場合、モデル設定で宣言された値が使用されます。`0.0` に設定すると無効になります。MoE 以外のモデルで使用すると失敗します。

disable_dropout (`bool`、*任意*、デフォルトは`True`) : モデルとリファレンスモデルのdropoutを無効にするかどうか。

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

dataset_num_proc (`int`, *任意*) : データセットの処理に使用するプロセス数。

max_length (`int` または `None`、*任意*、デフォルトは `1024`) : トークン化されたシーケンスの最大長。`max_length` より長いシーケンスは、`truncation_mode` に応じて左側または右側から切り詰められます。`None` の場合は、切り詰めは行われません。

truncation_mode (`str`、*任意*、デフォルトは`"keep_start"`) : シーケンスが`max_length`を超えた場合に使用する切り詰めモード。サポートされている値は`"keep_start"`のみです。`"keep_end"`の値は非推奨となり、v2.0.0で削除されます。

padding_free (`bool`, *任意*, デフォルトは `False`) : バッチ内のすべてのシーケンスを単一の連続シーケンスにフラット化して、パディングなしでフォワードパスを実行するかどうかを指定します。これにより、パディングのオーバーヘッドを排除してメモリ使用量を削減できます。現在、これはフラット化されたバッチ構造を効率的に処理できる FlashAttention 2 または 3 のみでサポートされています。一時的に利用不可: DPO のリファクタリング以降、これを `True` に設定すると警告が表示され、標準的なパディングにフォールバックします。将来のアップデートで復活する予定です。

pad_to_multiple_of (`int` または `str`、*任意*、デフォルトは `"auto"`) : 設定されている場合、シーケンスはこの値の倍数にパディングされます。`"auto"` は Neuron (AWS Trainium) 上で 128 の倍数にパディングします。Neuron は入力形状ごとに一度だけコンパイルされるためです。その他の環境ではパディングを行いません。

precompute_ref_log_probs (`bool`、*任意*、デフォルトは`False`) : 学習を開始する前に、学習データセット全体に対する参照モデルの対数確率を事前計算するかどうか。参照モデルをメモリに保持する必要がなくなるため、学習中のメモリを節約できます。

precompute_ref_batch_size (`int`, *optional*) : 参照モデルの対数尤度を事前計算する際に使用するバッチサイズです。前処理を高速化するために、トレーニングのバッチサイズよりも大きく設定できます。`None` の場合、トレーニングでは `per_device_train_batch_size`、評価では `per_device_eval_batch_size` がデフォルトとして使用されます。

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

loss_type (`list[str]`、*任意*、デフォルトは`["sigmoid"]`) : 使用する損失の種類。指定可能な値は、`'sigmoid'`、`'hinge'`、`'ipo'`、`'exo_pair'`、`'nca_pair'`、`'robust'`、`'bco_pair'`、`'sppo_hard'`、`'aot'`、`'aot_unpaired'`、`'apo_zero'`、`'apo_down'`、`'discopop'`、`'sft'`、`'sigmoid_norm'`、`'udpo'`です。複数の損失タイプを指定した場合、`loss_weights`で指定された重みを使用してそれらが結合されます。

loss_weights (`list[float]`, *optional*) : 複数の損失を組み合わせる場合の損失重みのリストです。複数の損失タイプを組み合わせる際に使用します。例: MPO の場合は `[0.8, 0.2, 1.0]` です。指定されない場合、すべての損失タイプに対して等しい重み (`1.0`) がデフォルトとして使用されます。

ld_alpha (`float`, *optional*) : LD-DPO論文からのαパラメータ。レスポンス内の冗長トークンの対数尤度の重みを制御します。`None`の場合、冗長部分には重みが適用されず、損失は標準的なDPO損失と同等になります。値は[0.0, 1.0]の範囲でなければなりません。`ld_alpha=1.0`では重みが適用されず、`ld_alpha=0.0`では共有長を超えるトークンがマスクされます。

f_divergence_type (`str`、*任意*、デフォルトは`"reverse_kl"`) : ポリシーとリファレンス間のf-divergenceレギュラライザー（f-DPO論文）。指定可能な値は、`reverse_kl`（デフォルト）、`forward_kl`、`js_divergence`、`alpha_divergence`です。デフォルト以外の値をサポートするのは、chosen-rejectedの報酬差に基づいて構築された損失タイプのみです：`'sigmoid'`、`'sigmoid_norm'`、`'hinge'`、`'ipo'`、`'exo_pair'`、`'robust'`、`'discopop'`、`'sft'`、`'udpo'`。その他の損失タイプには有効なf-divergence一般化が存在しないため、デフォルト以外の値は拒否されます。

f_alpha_divergence_coef (`float`、*任意*、デフォルトは`0.5`) : `f_divergence_type='alpha_divergence'`の場合にのみ使用される、α-divergence u^-α正則化項のα係数。

label_smoothing (`float`、*optional*、デフォルトは`0.0`) : Robust DPO、UDPO、EXO で使用されるラベルスムーthingパラメータです。Robust DPO と UDPO では、好みが逆転する確率 ε として解釈され、[0.0, 0.5) の範囲に収まる必要があります。Robust DPO の論文で推奨される典型的な値は 0.1 です。UDPO では a = ε / (1 - ε) を設定するために使用され、UDPO の論文では a = 0.8、つまり ε = 4/9 が推奨されています。EXO では、ε ラベルスムーthingパラメータに対応し、論文では典型的な値として 1e-3 が推奨されています。

beta (`float`、*任意*、デフォルトは`0.1`) : 参照モデルからの逸脱を制御するパラメータです。βの値が大きいほど、参照モデルからの逸脱は少なくなります。IPO損失(`loss_type='ipo'`)の場合、この値は[論文](https://huggingface.co/papers/2310.12036)でτと表記される正則化パラメータです。

use_weighting (`bool`, *任意*, デフォルトは `False`) : ポリシーの長さ正規化されたシーケンス確率を用いて、好対立ペアに [WPO](https://huggingface.co/papers/2406.11827) 形式の重みを適用するかどうか。

discopop_tau (`float`、*optional*、デフォルトは`0.05`) : DiscoPOP論文からのτ/temperatureパラメータ。`loss_type='discopop'`を使用する場合、log-ratio modulated lossの形状を制御します。論文では、デフォルト値`discopop_tau=0.05`が推奨されています。

activation_offloading (`bool`、*任意*、デフォルトは`False`) : アクティベーションをCPUにオフロードするかどうか。

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

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](https://huggingface.co/papers/2404.09656)論文のτパラメータ。現在のポリシーが参照ポリシーと同期される頻度を決定します。このパラメータを使用するには、`sync_ref_model=True`を設定する必要があります。

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

pad_token :   パラメータ `pad_token` は非推奨となり、バージョン v2.0.0 で削除されます。代わりに、`tokenizer.pad_token` を直接設定し、`processing_class` としてトレーナーに渡してください。

[DPOTrainer](/docs/trl/main/ja/dpo_trainer#trl.DPOTrainer)の構成クラスです。

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

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

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

