DPO 訓練器

概述

TRL 支援 DPO 訓練器用於從偏好資料訓練語言模型，如 Rafael Rafailov、Archit Sharma、Eric Mitchell、Stefano Ermon、Christopher D. Manning 和 Chelsea Finn 在論文 Direct Preference Optimization: Your Language Model is Secretly a Reward Model 中所述。

論文摘要如下：

雖然大規模無監督語言模型（LMs）學習了廣泛的世界知識和一些推理技能，但由於其訓練完全無監督，難以精確控制其行為。現有的獲得這種可控性的方法是收集模型生成質量的人工標籤，並微調無監督 LM 以與這些偏好對齊，通常透過人類反饋強化學習（RLHF）。然而，RLHF 是一個複雜且通常不穩定的過程，首先擬合一個反映人類偏好的獎勵模型，然後使用強化學習微調大型無監督 LM 以最大化這個估計的獎勵，同時不偏離原始模型太遠。在本文中，我們引入了 RLHF 中獎勵模型的新引數化，該引數化能夠以閉合形式提取相應的最優策略，從而允許我們僅用一個簡單的分類損失來解決標準的 RLHF 問題。由此產生的演算法，我們稱之為直接偏好最佳化（DPO），穩定、高效能且計算量輕，無需在微調期間從 LM 取樣或進行大量超引數調整。我們的實驗表明，DPO 可以像現有方法一樣甚至更好地微調 LM 以與人類偏好對齊。值得注意的是，使用 DPO 進行微調在控制生成情感的能力方面超越了基於 PPO 的 RLHF，並在摘要和單輪對話中匹配或提高了響應質量，同時在實現和訓練方面顯著更簡單。

第一步是訓練一個 SFT 模型，以確保我們訓練的資料對於 DPO 演算法是同分布的。

然後，透過 DPO 微調語言模型包含兩個步驟，並且比 PPO 更容易

資料收集：根據給定的提示，收集包含肯定和否定生成對的偏好資料集。
最佳化：直接最大化 DPO 損失的對數似然。

此過程在下面的草圖中說明（來自 DPO 論文的圖 1）

在原始論文中閱讀更多關於 DPO 演算法的資訊。

快速開始

此示例演示如何使用 DPO 方法訓練模型。我們使用 Qwen 0.5B 模型作為基礎模型。我們使用來自 UltraFeedback 資料集的偏好資料。您可以在此處檢視資料集中的資料

以下是訓練模型的指令碼

# train_dpo.py
from datasets import load_dataset
from trl import DPOConfig, DPOTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
train_dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

training_args = DPOConfig(output_dir="Qwen2-0.5B-DPO")
trainer = DPOTrainer(model=model, args=training_args, processing_class=tokenizer, train_dataset=train_dataset)
trainer.train()

使用以下命令執行指令碼

accelerate launch train_dpo.py

在 8 個 GPU 上分散式訓練大約需要 3 分鐘。您可以透過檢查獎勵圖來驗證訓練進度。獎勵邊距的增加趨勢表明模型正在改進並隨著時間的推移生成更好的響應。

要檢視訓練好的模型的表現，您可以使用 Transformers Chat CLI。

$ transformers chat trl-lib/Qwen2-0.5B-DPO
<shirin_yamani>:
What is Huggingface?

<trl-lib/Qwen2-0.5B-DPO>:
Huggingface is a platform that allows users to access a variety of open-source machine learning resources such as pre-trained models and datasets Huggingface is a platform that allows users to access a variety of open-source machine learning resources such as pre-trained models and datasets for the development of machine learning models and applications. It provides a repository of over 300, 000 pre-trained models in  Huggingface is a platform that allows users to access a variety of open-source machine learning resources such as pre-trained models and datasets for the development of machine learning models and applications. It provides a repository of over 300, 000  pre-trained models in a variety of languages, enabling users to explore and utilize the latest techniques and technologies in the field of machine learning.

預期資料集型別

DPO 需要偏好資料集。DPOTrainer 支援對話式和標準資料集格式。當提供對話式資料集時，訓練器會自動將聊天模板應用於資料集。

儘管 DPOTrainer 支援顯式和隱式提示，但我們建議使用顯式提示。如果提供隱式提示資料集，訓練器將自動從 "chosen" 和 "rejected" 列中提取提示。有關更多資訊，請參閱偏好樣式部分。

視覺語言模型的特殊考量

DPOTrainer 支援微調視覺語言模型 (VLM)。對於這些模型，需要視覺資料集。要了解視覺資料集的特定格式，請參閱視覺資料集格式部分。

此外，與使用 tokenizer 的標準文字模型不同，對於 VLM，您應該用 processor 替換 tokenizer。

- model = AutoModelForCausalLM.from_pretrained(model_id)
+ model = AutoModelForVision2Seq.from_pretrained(model_id)

- tokenizer = AutoTokenizer.from_pretrained(model_id)
+ processor = AutoProcessor.from_pretrained(model_id)

  trainer = DPOTrainer(
      model,
      args=training_args,
      train_dataset=train_dataset,
-     processing_class=tokenizer,
+     processing_class=processor,
)

有關微調視覺語言模型的完整示例，請參閱 examples/scripts/dpo_vlm.py 中的指令碼。

示例指令碼

我們提供了一個使用 DPO 方法訓練模型的示例指令碼。該指令碼可在 trl/scripts/dpo.py 中找到

要在 UltraFeedback 資料集上使用 Qwen2 0.5B 模型測試 DPO 指令碼，請執行以下命令

accelerate launch trl/scripts/dpo.py \
    --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
    --dataset_name trl-lib/ultrafeedback_binarized \
    --num_train_epochs 1 \
    --output_dir Qwen2-0.5B-DPO

記錄的指標

在訓練和評估期間，我們記錄以下獎勵指標

rewards/chosen：策略模型和參考模型在選中響應的對數機率之間的平均差異，按 beta 縮放
rewards/rejected：策略模型和參考模型在拒絕響應的對數機率之間的平均差異，按 beta 縮放
rewards/accuracies：所選獎勵大於相應被拒獎勵的頻率的平均值
rewards/margins：選中獎勵和相應拒絕獎勵之間的平均差異

損失函式

DPO 演算法支援多種損失函式。損失函式可以透過 DPOConfig 中的 loss_type 引數設定。支援以下損失函式：

`loss_type=`	描述
`"sigmoid"`（預設）	給定偏好資料，我們可以根據 Bradley-Terry 模型擬合一個二元分類器，事實上 DPO 作者建議使用透過 `logsigmoid` 對歸一化似然進行的 sigmoid 損失來擬合邏輯迴歸。
`"hinge"`	RSO 作者提出使用來自 SLiC 論文的歸一化似然的合頁損失。在這種情況下，`beta` 是邊距的倒數。
`"ipo"`	IPO 作者對 DPO 演算法提供了更深入的理論理解，並指出了過擬合問題，並提出了一種替代損失。在這種情況下，`beta` 是選中完成對與拒絕完成對的對數似然比之間的間隙的倒數，因此 `beta` 越小，此間隙越大。根據論文，損失在完成的對數似然上取平均（不像 DPO 那樣只求和）。
`"exo_pair"`	EXO 作者提出最小化逆 KL 而不是 DPO 的負對數 sigmoid 損失，後者對應於前向 KL。設定非零 `label_smoothing`（預設為 `1e-3`）會導致 EXO 在成對偏好上的簡化版本（參見 EXO 論文的公式 (16)）。EXO 的完整版本使用 SFT 策略生成的 `K>2` 完成，當 `K` 足夠大時，它成為 PPO 目標（在一個常數範圍內）的無偏估計器。
`"nca_pair"`	NCA 作者表明 NCA 最佳化的是每個響應的絕對似然而不是相對似然。
`"robust"`	Robust DPO 作者提出了 DPO 損失的無偏估計，該估計對資料中的偏好噪聲具有魯棒性。與 cDPO 一樣，它假設偏好標籤以某種機率存在噪聲。在這種方法中，DPOConfig 中的 `label_smoothing` 引數用於模擬現有標籤噪聲的機率。要應用此保守損失，請將 `label_smoothing` 設定為大於 0.0 的值（介於 0.0 和 0.5 之間；預設值為 0.0）
`"bco_pair"`	BCO 作者訓練了一個二元分類器，其邏輯作為獎勵，以便分類器將 {prompt, chosen completion} 對對映為 1，將 {prompt, rejected completion} 對對映為 0。對於未配對資料，我們推薦專用的 BCOTrainer。
`"sppo_hard"`	SPPO 作者聲稱 SPPO 能夠透過迭代地將選定獎勵推高到 1/2，將拒絕獎勵推低到 -1/2 來解決納什均衡問題，並可以緩解資料稀疏性問題。該實現透過採用硬標籤機率來近似此演算法，為獲勝者分配 1，為失敗者分配 0。
`"aot"` 或 `loss_type="aot_pair"`	AOT 作者提出使用透過最優傳輸的分佈偏好對齊。傳統上，對齊演算法在樣本級別使用配對偏好，這不能確保在分佈級別上的對齊。另一方面，AOT 可以透過使正樣本的獎勵分佈在負樣本的分佈上在第一階上隨機佔優勢來對齊配對或未配對偏好資料上的 LLM。具體來說，`loss_type="aot"` 適用於配對資料集，其中每個提示都有選中和拒絕的響應；`loss_type="aot_pair"` 適用於未配對資料集。簡而言之，`loss_type="aot"` 確保對齊模型的選中與拒絕的對數似然比具有比參考模型更高的分位數。`loss_type="aot_pair"` 確保選中獎勵在所有分位數上都高於拒絕獎勵。請注意，在兩種情況下，分位數都是透過排序獲得的。為了充分利用 AOT 演算法的優勢，最大化每 GPU 批次大小非常重要。
`"apo_zero"` 或 `loss_type="apo_down"`	APO 方法引入了對齊目標的“錨定”版本。有兩種變體：`apo_zero` 和 `apo_down`。`apo_zero` 損失在增加獲勝輸出似然的同時降低失敗輸出似然，這在模型效能低於獲勝輸出時適用。另一方面，`apo_down` 降低獲勝和失敗輸出的似然，但更強調降低失敗輸出的似然。這種變體在模型效能優於獲勝輸出時更有效。
`"discopop"`	DiscoPOP 論文使用 LLM 發現更高效的離線偏好最佳化損失。在論文中，提出的 DiscoPOP 損失（一種對數比調製損失）在不同任務（IMDb 積極文字生成、Reddit TLDR 摘要和 Alpaca Eval 2.0）中優於其他最佳化損失。
`"sft"`	SFT（監督微調）損失是負對數似然損失，用於訓練模型生成首選響應。

多損失組合

DPO 訓練器支援將多個損失函式與不同權重結合，從而實現更復雜的最佳化策略。這對於實現 MPO（混合偏好最佳化）等演算法特別有用。MPO 是一種結合多個最佳化目標的訓練方法，如論文透過混合偏好最佳化增強多模態大語言模型的推理能力中所述。

要組合多個損失，請將損失型別和相應權重指定為列表

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

如果未提供 loss_weights，所有損失型別將具有相等權重（預設為 1.0）。

標籤平滑

cDPO 是對 DPO 損失的調整，我們假設偏好標籤以某種機率存在噪聲。在這種方法中，DPOConfig 中的 label_smoothing 引數用於模擬現有標籤噪聲的機率。要應用此保守損失，請將 label_smoothing 設定為大於 0.0 的值（介於 0.0 和 0.5 之間；預設值為 0.0）。

同步參考模型

TR-DPO 論文建議在 DPO 訓練期間，每隔 ref_model_sync_steps 步 SGD 後，以 ref_model_mixup_alpha 的權重同步參考模型權重。要啟用此回撥，請在 DPOConfig 中使用 sync_ref_model=True。

RPO 損失

RPO 論文實現了一種迭代偏好調整演算法，該演算法使用與此論文中的 RPO 損失相關的損失，該損失本質上包括對所選偏好的加權 SFT 損失以及 DPO 損失。要使用此損失，請在 DPOConfig 中將 rpo_alpha 設定為適當的值。該論文建議將此權重設定為 1.0。

WPO 損失

WPO 論文透過根據當前策略下的機率對偏好對進行重新加權，使離策略資料更接近於在策略資料。要使用此方法，請在 DPOConfig 中將 use_weighting 標誌設定為 True。

LD-DPO 損失

LD-DPO 論文根據混合係數將超出所需長度的響應部分分解為兩個組成部分——類人偏好和冗餘偏好 $\alpha$ 。要使用此方法，請將 DPOConfig 中的 ld_alpha 設定為適當的值。該論文建議將此值設定在 0.0 和 1.0 之間。

專家混合模型：啟用輔助損失

如果負載在專家之間大致均勻分佈，MOE（專家混合模型）效率最高。
為了確保在偏好調整期間類似地訓練 MOE，將負載均衡器的輔助損失新增到最終損失中是有益的。

透過在模型配置（例如 MixtralConfig）中設定 output_router_logits=True 來啟用此選項。
要調整輔助損失對總損失的貢獻程度，請在模型配置中使用超引數 router_aux_loss_coef=...（預設值：0.001）。

使用 unsloth 加速 DPO 微調

您可以使用與 SFTTrainer 完全相容的 unsloth 庫進一步加速 QLoRA / LoRA（快 2 倍，記憶體少 60%）。目前 unsloth 僅支援 Llama（Yi、TinyLlama、Qwen、Deepseek 等）和 Mistral 架構。DPO 的一些基準如下：

GPU	模型	資料集	🤗	🤗 + FlashAttention 2	🦥 Unsloth	🦥 節省視訊記憶體
A100 40G	Zephyr 7b	Ultra Chat	1 倍	1.24x	1.88x	-11.6%
Tesla T4	Zephyr 7b	Ultra Chat	1 倍	1.09倍	1.55x	-18.6%

首先根據官方文件安裝 unsloth。安裝後，您可以透過非常簡單的方式將 unsloth 整合到您的工作流程中；您只需載入 FastLanguageModel 而不是 AutoModelForCausalLM，如下所示：

  from datasets import load_dataset
  from trl import DPOConfig, DPOTrainer
- from transformers import AutoModelForCausalLM, AutoTokenizer
+ from unsloth import FastLanguageModel

- model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
- tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
+ model, tokenizer = FastLanguageModel.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
+ model = FastLanguageModel.get_peft_model(model)
  train_dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

- training_args = DPOConfig(output_dir="Qwen2-0.5B-DPO")
+ training_args = DPOConfig(output_dir="Qwen2-0.5B-DPO", bf16=True)
  trainer = DPOTrainer(model=model, args=training_args, processing_class=tokenizer, train_dataset=train_dataset)
  trainer.train()

儲存的模型與 Hugging Face 的 transformers 庫完全相容。在他們的官方倉庫中瞭解更多關於 unsloth 的資訊。

PEFT 的參考模型注意事項

在使用 PEFT 時，您有三個主要選項（以及幾種變體）來處理參考模型，假設您希望透過 DPO 進一步增強的模型是使用 (Q)LoRA 調優的。

簡單地建立模型的兩個例項，每個例項載入您的介面卡——工作正常，但效率很低。
將介面卡合併到基礎模型中，然後在上面建立另一個介面卡，然後將 ref_model 引數留空，在這種情況下，DPOTrainer 將解除安裝介面卡以進行參考推理——高效，但可能存在下面討論的缺點。
以不同的名稱載入介面卡兩次，然後在訓練期間使用 set_adapter 在 DPO 的介面卡和參考介面卡之間進行切換——與選項 2 相比效率略低（約介面卡大小的 VRAM 開銷），但避免了陷阱。

DPO 前合併 QLoRA 的缺點（方法 2）

正如 Benjamin Marie 所建議的，合併 QLoRA 介面卡的最佳選項是首先對基礎模型進行去量化，然後合併介面卡。類似於此指令碼。

但是，使用此方法後，您將擁有一個未量化的基礎模型。因此，要將 QLoRA 用於 DPO，您需要重新量化合並後的模型或使用未量化合並（導致更高的記憶體需求）。

使用選項 3 - 載入介面卡兩次

為了避免選項 2 的缺點，您可以將微調後的介面卡以不同的名稱兩次載入到模型中，並在 DPOTrainer 中設定模型/參考介面卡名稱。

例如：

# Load the base model.
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    llm_int8_threshold=6.0,
    llm_int8_has_fp16_weight=False,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
)
model = AutoModelForCausalLM.from_pretrained(
    "mistralai/mixtral-8x7b-v0.1",
    load_in_4bit=True,
    quantization_config=bnb_config,
    attn_implementation="flash_attention_2",
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
model.config.use_cache = False

# Load the adapter.
model = PeftModel.from_pretrained(
    model,
    "/path/to/peft",
    is_trainable=True,
    adapter_name="train",
)
# Load the adapter a second time, with a different name, which will be our reference model.
model.load_adapter("/path/to/peft", adapter_name="reference")

# Initialize the trainer, without a ref_model param.
training_args = DPOConfig(
    model_adapter_name="train",
    ref_adapter_name="reference",
)
dpo_trainer = DPOTrainer(
    model,
    args=training_args,
    ...
)

DPOTrainer

class trl.DPOTrainer

< 源 >

( model: typing.Union[str, torch.nn.modules.module.Module, transformers.modeling_utils.PreTrainedModel] ref_model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.modules.module.Module, str, NoneType] = None args: typing.Optional[trl.trainer.dpo_config.DPOConfig] = None data_collator: typing.Optional[transformers.data.data_collator.DataCollator] = None train_dataset: typing.Union[datasets.arrow_dataset.Dataset, datasets.iterable_dataset.IterableDataset, NoneType] = None eval_dataset: typing.Union[datasets.arrow_dataset.Dataset, datasets.iterable_dataset.IterableDataset, dict[str, typing.Union[datasets.arrow_dataset.Dataset, datasets.iterable_dataset.IterableDataset]], NoneType] = None processing_class: typing.Union[transformers.tokenization_utils_base.PreTrainedTokenizerBase, transformers.image_processing_utils.BaseImageProcessor, transformers.feature_extraction_utils.FeatureExtractionMixin, transformers.processing_utils.ProcessorMixin, NoneType] = None compute_metrics: typing.Optional[typing.Callable[[transformers.trainer_utils.EvalLoopOutput], dict]] = None callbacks: typing.Optional[list[transformers.trainer_callback.TrainerCallback]] = None optimizers: tuple = (None, None) optimizer_cls_and_kwargs: typing.Optional[tuple[type[torch.optim.optimizer.Optimizer], dict[str, typing.Any]]] = None preprocess_logits_for_metrics: typing.Optional[typing.Callable[[torch.Tensor, torch.Tensor], torch.Tensor]] = None peft_config: typing.Optional[ForwardRef('PeftConfig')] = None )

引數

model (Union[str, PreTrainedModel]) — 要訓練的模型。可以是：
- 字串，即 huggingface.co 上模型倉庫中預訓練模型的模型 ID，或包含使用 save_pretrained 儲存的模型權重的目錄路徑，例如 './my_model_directory/'。模型使用 from_pretrained 載入，並帶有 args.model_init_kwargs 中的關鍵字引數。
- PreTrainedModel 物件。僅支援因果語言模型。
ref_model (PreTrainedModelWrapper) — 帶有因果語言建模頭的 Hugging Face transformer 模型。用於隱式獎勵計算和損失。如果未提供參考模型，訓練器將建立一個與要最佳化的模型具有相同架構的參考模型。
args (DPOConfig, 可選, 預設為 None) — 此訓練器的配置。如果為 None，則使用預設配置。
data_collator (DataCollator, 可選) — 用於從處理過的 train_dataset 或 eval_dataset 元素列表中形成批處理的函式。預設為 DataCollatorForPreference。
train_dataset (Dataset 或 IterableDataset) — 用於訓練的資料集。DPO 支援偏好型別和。樣本的格式可以是：
- 標準：每個樣本包含純文字。
- 對話式：每個樣本包含結構化訊息（例如，角色和內容）。
eval_dataset (Dataset, IterableDataset 或 dict[str, Union[Dataset, IterableDataset]]) — 用於評估的資料集。它必須滿足與 train_dataset 相同的要求。
processing_class (PreTrainedTokenizerBase, BaseImageProcessor, FeatureExtractionMixin 或 ProcessorMixin, 可選, 預設為 None) — 用於處理資料的處理類。如果為 None，則使用 from_pretrained 從模型名稱載入處理類。
compute_metrics (Callable[[EvalPrediction], dict], 可選) — 用於在評估時計算指標的函式。必須接受 EvalPrediction 並返回一個從字串到指標值的字典。注意：當傳遞 batch_eval_metrics 設定為 True 的 TrainingArgs 時，您的 compute_metrics 函式必須接受布林引數 compute_result。這將在最後一個評估批次之後觸發，以指示函式需要計算並返回全域性彙總統計資訊，而不是累積批次級別的統計資訊。
callbacks (TrainerCallback 列表, 可選, 預設為 None) — 用於自定義訓練迴圈的回撥列表。這些回撥將被新增到此處詳細介紹的預設回撥列表中。

如果您想刪除其中一個使用的預設回撥，請使用 remove_callback 方法。
optimizers (tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR], 可選, 預設為 (None, None)) — 包含要使用的最佳化器和排程器的元組。預設為模型上的 AdamW 例項和由 args 控制的 get_linear_schedule_with_warmup 排程器。
optimizer_cls_and_kwargs (Tuple[Type[torch.optim.Optimizer], Dict[str, Any]], 可選, 預設為 None) — 包含要使用的最佳化器類和關鍵字引數的元組。覆蓋 args 中的 optim 和 optim_args。與 optimizers 引數不相容。
preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor], 可選, 預設為 None) — 一個函式，用於在每個評估步驟快取 logits 之前對其進行預處理。必須接受兩個張量（logits 和 labels），並返回處理後的 logits。此函式進行的修改將反映在 compute_metrics 接收到的預測中。

請注意，如果資料集沒有標籤，則標籤（第二個引數）將為 None。
peft_config (~peft.PeftConfig, 可選, 預設為 None) — 用於包裝模型的 PEFT 配置。如果為 None，則不包裝模型。

用於直接偏好最佳化 (DPO) 方法的訓練器。

此類是 transformers.Trainer 類的包裝器，並繼承其所有屬性和方法。

訓練

< source >

( resume_from_checkpoint: typing.Union[str, bool, NoneType] = None trial: typing.Union[ForwardRef('optuna.Trial'), dict[str, typing.Any], NoneType] = None ignore_keys_for_eval: typing.Optional[list[str]] = None **kwargs )

引數

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], 可選) — 模型輸出（如果為字典）中在訓練期間收集預測以進行評估時應忽略的鍵列表。
**kwargs (dict[str, Any], 可選) — 用於隱藏已棄用引數的附加關鍵字引數

主訓練入口點。

save_model

< source >

( output_dir: typing.Optional[str] = None _internal_call: bool = False )

將儲存模型，以便您可以使用 `from_pretrained()` 重新載入它。

僅從主程序儲存。

push_to_hub

< source >

( commit_message: typing.Optional[str] = 'End of training' blocking: bool = True token: typing.Optional[str] = None revision: typing.Optional[str] = None **kwargs )

引數

commit_message (str, 可選, 預設為 "End of training") — 推送時的提交訊息。
blocking (bool, 可選, 預設為 True) — 函式是否只在 `git push` 完成時才返回。
token (str, 可選, 預設為 None) — 具有寫入許可權的令牌，用於覆蓋 Trainer 的原始引數。
revision (str, 可選) — 要提交的 Git 修訂版本。預設為“main”分支的頭部。
kwargs (dict[str, Any], 可選) — 傳遞給 ~Trainer.create_model_card 的附加關鍵字引數。

將 `self.model` 和 `self.processing_class` 上傳到 🤗 模型中心的 `self.args.hub_model_id` 儲存庫。

DPOConfig

class trl.DPOConfig

< source >

( output_dir: typing.Optional[str] = None overwrite_output_dir: bool = False do_train: bool = False do_eval: bool = False do_predict: bool = False eval_strategy: typing.Union[transformers.trainer_utils.IntervalStrategy, str] = 'no' prediction_loss_only: bool = False per_device_train_batch_size: int = 8 per_device_eval_batch_size: int = 8 per_gpu_train_batch_size: typing.Optional[int] = None per_gpu_eval_batch_size: typing.Optional[int] = None gradient_accumulation_steps: int = 1 eval_accumulation_steps: typing.Optional[int] = None eval_delay: typing.Optional[float] = 0 torch_empty_cache_steps: typing.Optional[int] = None learning_rate: float = 1e-06 weight_decay: float = 0.0 adam_beta1: float = 0.9 adam_beta2: float = 0.999 adam_epsilon: float = 1e-08 max_grad_norm: float = 1.0 num_train_epochs: float = 3.0 max_steps: int = -1 lr_scheduler_type: typing.Union[transformers.trainer_utils.SchedulerType, str] = 'linear' lr_scheduler_kwargs: typing.Union[dict[str, typing.Any], str, NoneType] = <factory> warmup_ratio: float = 0.0 warmup_steps: int = 0 log_level: str = 'passive' log_level_replica: str = 'warning' log_on_each_node: bool = True logging_dir: typing.Optional[str] = None logging_strategy: typing.Union[transformers.trainer_utils.IntervalStrategy, str] = 'steps' logging_first_step: bool = False logging_steps: float = 10 logging_nan_inf_filter: bool = True save_strategy: typing.Union[transformers.trainer_utils.SaveStrategy, str] = 'steps' save_steps: float = 500 save_total_limit: typing.Optional[int] = None save_safetensors: typing.Optional[bool] = True save_on_each_node: bool = False save_only_model: bool = False restore_callback_states_from_checkpoint: bool = False no_cuda: bool = False use_cpu: bool = False use_mps_device: bool = False seed: int = 42 data_seed: typing.Optional[int] = None jit_mode_eval: bool = False use_ipex: bool = False bf16: typing.Optional[bool] = None fp16: bool = False fp16_opt_level: str = 'O1' half_precision_backend: str = 'auto' bf16_full_eval: bool = False fp16_full_eval: bool = False tf32: typing.Optional[bool] = None local_rank: int = -1 ddp_backend: typing.Optional[str] = None tpu_num_cores: typing.Optional[int] = None tpu_metrics_debug: bool = False debug: typing.Union[str, list[transformers.debug_utils.DebugOption]] = '' dataloader_drop_last: bool = False eval_steps: typing.Optional[float] = None dataloader_num_workers: int = 0 dataloader_prefetch_factor: typing.Optional[int] = None past_index: int = -1 run_name: typing.Optional[str] = None disable_tqdm: typing.Optional[bool] = None remove_unused_columns: typing.Optional[bool] = True label_names: typing.Optional[list[str]] = None load_best_model_at_end: typing.Optional[bool] = False metric_for_best_model: typing.Optional[str] = None greater_is_better: typing.Optional[bool] = None ignore_data_skip: bool = False fsdp: typing.Union[list[transformers.trainer_utils.FSDPOption], str, NoneType] = '' fsdp_min_num_params: int = 0 fsdp_config: typing.Union[dict[str, typing.Any], str, NoneType] = None fsdp_transformer_layer_cls_to_wrap: typing.Optional[str] = None accelerator_config: typing.Union[dict, str, NoneType] = None deepspeed: typing.Union[dict, str, NoneType] = None label_smoothing_factor: float = 0.0 optim: typing.Union[transformers.training_args.OptimizerNames, str] = 'adamw_torch' optim_args: typing.Optional[str] = None adafactor: bool = False group_by_length: bool = False length_column_name: typing.Optional[str] = 'length' report_to: typing.Union[NoneType, str, list[str]] = None ddp_find_unused_parameters: typing.Optional[bool] = None ddp_bucket_cap_mb: typing.Optional[int] = None ddp_broadcast_buffers: typing.Optional[bool] = None dataloader_pin_memory: bool = True dataloader_persistent_workers: bool = False skip_memory_metrics: bool = True use_legacy_prediction_loop: bool = False push_to_hub: bool = False resume_from_checkpoint: typing.Optional[str] = None hub_model_id: typing.Optional[str] = None hub_strategy: typing.Union[transformers.trainer_utils.HubStrategy, str] = 'every_save' hub_token: typing.Optional[str] = None hub_private_repo: typing.Optional[bool] = None hub_always_push: bool = False hub_revision: typing.Optional[str] = None gradient_checkpointing: bool = False gradient_checkpointing_kwargs: typing.Union[dict[str, typing.Any], str, NoneType] = None include_inputs_for_metrics: bool = False include_for_metrics: list = <factory> eval_do_concat_batches: bool = True fp16_backend: str = 'auto' push_to_hub_model_id: typing.Optional[str] = None push_to_hub_organization: typing.Optional[str] = None push_to_hub_token: typing.Optional[str] = None mp_parameters: str = '' auto_find_batch_size: bool = False full_determinism: bool = False torchdynamo: typing.Optional[str] = None ray_scope: typing.Optional[str] = 'last' ddp_timeout: int = 1800 torch_compile: bool = False torch_compile_backend: typing.Optional[str] = None torch_compile_mode: typing.Optional[str] = None include_tokens_per_second: typing.Optional[bool] = False include_num_input_tokens_seen: typing.Optional[bool] = False neftune_noise_alpha: typing.Optional[float] = None optim_target_modules: typing.Union[NoneType, str, list[str]] = None batch_eval_metrics: bool = False eval_on_start: bool = False use_liger_kernel: typing.Optional[bool] = False liger_kernel_config: typing.Optional[dict[str, bool]] = None eval_use_gather_object: typing.Optional[bool] = False average_tokens_across_devices: typing.Optional[bool] = True model_init_kwargs: typing.Optional[dict[str, typing.Any]] = None ref_model_init_kwargs: typing.Optional[dict[str, typing.Any]] = None model_adapter_name: typing.Optional[str] = None ref_adapter_name: typing.Optional[str] = None force_use_ref_model: bool = False disable_dropout: bool = True use_logits_to_keep: bool = False dataset_num_proc: typing.Optional[int] = None padding_value: typing.Optional[int] = None label_pad_token_id: int = -100 max_prompt_length: typing.Optional[int] = 512 max_completion_length: typing.Optional[int] = None max_length: typing.Optional[int] = 1024 truncation_mode: str = 'keep_end' padding_free: bool = False precompute_ref_log_probs: bool = False precompute_ref_batch_size: typing.Optional[int] = None tools: typing.Optional[list[typing.Union[dict, typing.Callable]]] = None loss_type: list = <factory> use_liger_loss: bool = False base_model_attribute_name: str = 'model' beta: float = 0.1 f_divergence_type: FDivergenceType = <FDivergenceType.REVERSE_KL: 'reverse_kl'> f_alpha_divergence_coef: float = 1.0 reference_free: bool = False label_smoothing: float = 0.0 use_weighting: bool = False rpo_alpha: typing.Optional[float] = None ld_alpha: typing.Optional[float] = None discopop_tau: float = 0.05 loss_weights: typing.Optional[list[float]] = None sync_ref_model: bool = False ref_model_mixup_alpha: float = 0.6 ref_model_sync_steps: int = 512 generate_during_eval: bool = False )

Parameters that control the model and reference model

model_init_kwargs (dict[str, Any] 或 None, 可選, 預設為 None) — AutoModelForCausalLM.from_pretrained 的關鍵字引數，用於 DPOTrainer 的 model 引數以字串形式提供時。
ref_model_init_kwargs (dict[str, Any] 或 None, 可選, 預設為 None) — AutoModelForCausalLM.from_pretrained 的關鍵字引數，用於 DPOTrainer 的 ref_model 引數以字串形式提供時。
model_adapter_name (str 或 None, 可選, 預設為 None) — 使用多個介面卡時，訓練目標 PEFT 介面卡的名稱。
ref_adapter_name (str 或 None, 可選, 預設為 None) — 使用多個介面卡時，參考 PEFT 介面卡的名稱。
force_use_ref_model (bool, 可選, 預設為 False) — 如果您提供了一個 PEFT 模型作為活動模型，並希望為 ref_model 使用不同的模型，請將此標誌設定為 True。
disable_dropout (bool, 可選, 預設為 True) — 是否在模型和參考模型中停用 dropout。
use_logits_to_keep (bool, 可選, 預設為 False) — 如果為 True，則在正向傳播中僅計算指定數量的 logits。這對於節省記憶體和加速訓練非常有用，因為無需計算所有 token 的 logits，尤其是在處理非常長的提示（其中標籤被忽略為 -100）時。

控制資料預處理的引數

dataset_num_proc (int 或 None, 可選, 預設為 None) — 用於處理資料集的程序數。
padding_value (int 或 None, 可選, 預設為 None) — 要使用的填充值。如果為 None，則使用 tokenizer 的填充值。
label_pad_token_id (int, 可選, 預設為 -100) — 用於標籤的填充值。
max_prompt_length (int 或 None, 可選, 預設為 512) — 提示的最大長度。
max_completion_length (int 或 None, 可選, 預設為 None) — 補全的最大長度。
max_length (int 或 None, 可選, 預設為 1024) — 完整序列（提示 + 補全）的最大長度。
truncation_mode (str, 可選, 預設為 "keep_end") — 當序列超出 max_length 時使用的截斷模式。可能的值為 "keep_end" 和 "keep_start"。
padding_free (bool, 可選, 預設為 False) — 是否透過將批處理中的所有序列扁平化為單個連續序列來執行無填充的正向傳遞。這透過消除填充開銷來減少記憶體使用。目前，這僅支援 flash_attention_2 注意力實現，它可以高效處理扁平化的批處理結構。
precompute_ref_log_probs (bool, 可選, 預設為 False) — 是否預先計算參考模型中的對數機率。將其設定為 True 可以在訓練期間不需要參考模型進行訓練，這有助於減少 GPU 記憶體使用。如果設定為 False（預設），參考模型將在訓練期間用於即時計算對數機率。
precompute_ref_batch_size (int 或 None, 可選, 預設為 None) — 預計算參考模型對數機率時使用的批處理大小。這可以設定高於訓練批處理大小以加速預處理。如果為 None，則訓練時預設為 per_device_train_batch_size，評估時預設為 per_device_eval_batch_size。
tools (Optional[list[Union[dict, Callable]]], 可選, 預設為 None) — 模型可訪問的工具（可呼叫函式）列表。如果模板不支援函式呼叫，此引數將無效。

控制訓練的引數

loss_type (str 或 list[str], 可選, 預設為 "sigmoid") — 要使用的損失型別。可能的值有：
- "sigmoid": 來自原始 DPO 論文的 sigmoid 損失。
- "hinge": 來自 SLiC 論文的歸一化似然的 hinge 損失。
- "ipo": 來自 IPO 論文的 IPO 損失。
- "exo_pair": 來自 EXO 論文的成對 EXO 損失。
- "nca_pair": 來自 NCA 論文的成對 NCA 損失。
- "robust": 來自 Robust DPO 論文的對偏好噪聲具有魯棒性的 DPO 損失的無偏估計。
- "bco_pair": 來自 BCO 論文的成對 BCO 損失。
- "sppo_hard": 來自 SPPO 論文的帶有硬標籤的 SPPO 損失。
- "aot": 來自 AOT 論文的成對資料集的 AOT 損失。
- "aot_pair": 來自 AOT 論文的非成對資料集的 AOT 損失。
- "discopop": 來自 DiscoPOP 論文的 DiscoPOP（又稱對數比率調製損失，LRML）損失。
- "apo_zero": 來自 APO 論文的 APO-zero 損失。
- "apo_down": 來自 APO 論文的 APO-down 損失。
- "sft": 負對數似然損失（標準監督微調損失）。
多種損失型別可以透過逗號分隔組合（例如，["sigmoid", "bco_pair", "sft"] 用於 MPO）。loss_weights 引數可用於指定每種損失型別對應的權重。
use_liger_loss (bool, 可選, 預設為 False) — 是否使用 Liger 損失。
base_model_attribute_name (str, 可選, 預設為 "model") — 模型中包含基礎模型的屬性名稱。當 use_liger_loss 為 True 且模型沒有 get_decoder 方法時，用於從模型中獲取基礎模型。
beta (float, 可選, 預設為 0.1) — 控制與參考模型偏差的引數。β 越高意味著與參考模型的偏差越小。對於 IPO 損失（loss_type="ipo"），β 是論文中 τ 表示的正則化引數。
f_divergence_type (str, 可選, 預設為 FDivergenceType.REVERSE_KL) — 用於計算策略和參考模型之間散度的 f-散度正則化函式型別。
f_alpha_divergence_coef (float, 可選, 預設為 1.0) — DPO 損失中 α-散度 u^-α 正則化函式中的 α 係數。
reference_free (bool, 可選, 預設為 False) — 是否忽略提供的參考模型，並隱式使用一個對所有響應分配相等機率的參考模型。
label_smoothing (float, 可選, 預設為 0.0) — 來自 cDPO 報告和 Robust DPO 論文的 Robust DPO 標籤平滑引數，應介於 0.0 和 0.5 之間。
use_weighting (bool, 可選, 預設為 False) — 是否按照 WPO 論文中的方式對損失進行加權。
rpo_alpha (float, 可選, 預設為 None) — 來自 RPO 論文 (v3) 的 α 引數，它控制損失中 NLL 項的權重。如果為 None，則不應用權重，損失與 DPO 損失相同。論文建議 rpo_alpha=1.0。
ld_alpha (float 或 None, 可選, 預設為 None) — 來自 LD-DPO 論文的 α 引數，它控制響應中詳細標記對數機率的權重。如果為 None，則不對詳細部分應用權重，損失等同於標準 DPO 損失。論文建議將 ld_alpha 設定在 0.0 和 1.0 之間。
discopop_tau (float, 可選, 預設為 0.05) — 來自 DiscoPOP 論文的 τ/溫度引數，它控制對數比率調製損失的形狀。論文建議預設值 discopop_tau=0.05。
loss_weights (list[float] 或 None, 可選, 預設為 None) — 多損失組合的損失權重列表。在組合多種損失型別時使用。例如：[0.8, 0.2, 1.0] 用於 MPO。如果未提供，則所有損失型別預設為等權重（1.0）。
sync_ref_model (bool, 可選, 預設為 False) — 是否每隔 ref_model_sync_steps 步使用 ref_model_mixup_alpha 引數同步參考模型和活動模型。此同步源自 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。

控制日誌記錄的引數

generate_during_eval (bool, 可選, 預設為 False) — 在評估期間是否生成並記錄模型和參考模型的完成結果到 W&B 或 Comet。

用於 DPOTrainer 的配置類。

此類僅包含 DPO 訓練特有的引數。有關訓練引數的完整列表，請參閱 TrainingArguments 文件。請注意，此類的預設值可能與 TrainingArguments 中的預設值不同。

使用 HfArgumentParser，我們可以將此類別轉換為可在命令列上指定的 argparse 引數。

DataCollatorForPreference

class trl.trainer.dpo_trainer.DataCollatorForPreference

< 來源 >

( pad_token_id: int return_tensors: str = 'pt' )

引數

pad_token_id (int) — 用於填充的標記 ID。
return_tensors (str, 可選, 預設為 "pt") — 返回張量的型別。目前僅支援 "pt"。

用於偏好資料的 Data Collator。如果輸入長度不一致，則動態填充到批次的最大長度。

示例

>>> from trl import DataCollatorForPreference

>>> collator = DataCollatorForPreference(pad_token_id=0)
>>> examples = [
...     {"prompt_input_ids": [1, 2, 3], "chosen_input_ids": [4, 5], "rejected_input_ids": [6]},
...     {"prompt_input_ids": [7, 8], "chosen_input_ids": [9, 10], "rejected_input_ids": [11, 12, 13]},
... ]
>>> collator(examples)
{'prompt_input_ids': tensor([[1, 2, 3],
                             [0, 7, 8]]),
 'prompt_attention_mask': tensor([[1, 1, 1],
                                  [0, 1, 1]]),
 'chosen_input_ids': tensor([[ 4,  5],
                             [ 9, 10]]),
 'chosen_attention_mask': tensor([[1, 1],
                                  [1, 1]]),
 'rejected_input_ids': tensor([[ 6,  0,  0],
                               [11, 12, 13]]),
 'rejected_attention_mask': tensor([[1, 0, 0],
                                    [1, 1, 1]])
}

< > 在 GitHub 上更新