TRL documentation

DPO 训练器

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.18.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

DPO 训练器

All_models-DPO-blue smol_course-Chapter_2-yellow

概述

TRL 支持用于训练语言模型的直接偏好优化(DPO)Trainer,如 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,并且在摘要生成和单轮对话任务中,其响应质量与现有方法相当或有所提升,同时实现和训练过程显著更简单。

该后训练方法由 Kashif Rasul 贡献,之后由 Quentin Gallouédec 进行了重构。

快速入门

本示例演示了如何使用 TRL 中的 DPOTrainer 来训练语言模型。我们在 UltraFeedback dataset 上训练了一个 Qwen 3 0.6B 模型。

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 需要一个偏好数据集。DPOTrainer 同时兼容标准和对话数据集格式。当提供对话数据集时,训练器会自动将聊天模板应用于该数据集。

# 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 数据集的示例:

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"])))
{
    "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 方法

直接偏好优化(DPO)是一种旨在使语言模型与偏好数据对齐的训练方法。与监督式输入-输出对不同,该模型在同一提示词的两个补全对上接受训练,其中一个补全优于另一个。其目标直接优化模型,以相对于参考模型扩大偏好补全与非偏好补全之间的对数似然差距,而无需显式的奖励模型。在实践中,这通常通过抑制非偏好补全的似然性来实现,而不是通过提高偏好补全的似然性。

本节详细说明了 DPO 在实际中的工作原理,涵盖关键步骤:预处理和损失计算。

预处理和分词

在训练过程中,每个样本应包含一个提示(prompt),以及一个首选(chosen)和一个非首选(rejected)的补全。有关预期格式的详细信息,请参阅数据集格式。 DPOTrainer 会使用模型的 tokenizer 对每个输入进行分词。

计算损失

dpo_figure

DPO 中使用的损失函数定义如下:LDPO(θ)=−E(x,y+,y−) ⁣[log⁡σ ⁣(β(log⁡πθ(y+ ⁣∣x)πref(y+ ⁣∣x)−log⁡πθ(y− ⁣∣x)πref(y− ⁣∣x)))] \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 x 是提示词, y+ y^+ 是首选补全, y− y^- 是非首选补全。 πθ \pi_{\theta} 是正在训练的策略模型, πref \pi_{\mathrm{ref}} 是参考模型, σ \sigma 是 sigmoid 函数, β>0 \beta > 0 是一个超参数,用于控制偏好信号的强度。

损失类型

文献中已提出目标函数的多种表述形式。最初,DPO 的目标函数定义如上所述。

loss_type=描述
"sigmoid"(默认)给定偏好数据,我们可以根据 Bradley-Terry 模型拟合一个二分类器,事实上 DPO 的作者提出通过对归一化似然使用 logsigmoid 上的 sigmoid 损失来拟合逻辑回归。
"hinge"RSO 的作者建议对 SLiC 论文中的归一化似然使用铰链损失。在这种情况下,beta 是间隔的倒数。
"ipo"IPO 的作者认为 logit 变换可能导致过拟合,并提出了恒等变换以直接优化偏好;TRL 将其暴露为 loss_type="ipo"。
"exo_pair"EXO 的作者提出了反向 KL 偏好优化。label_smoothing 必须严格大于 0.0;推荐值为 1e-3(简化成对变体参见公式 16)。完整方法使用 K>2 个 SFT 补全,并随着 K 的增大而趋近于 PPO。
"nca_pair"NCA 的作者表明,NCA 优化的是每个响应的绝对似然,而非相对似然。
"robust"Robust DPO 的作者提出了一种在噪声偏好下无偏的 DPO 损失。在 DPOConfig 中使用 label_smoothing 来建模标签翻转概率;有效值范围为 [0.0, 0.5)。
"bco_pair"BCO 的作者训练了一个二元分类器,其 logit 作为奖励,使该分类器将 {prompt, chosen completion} 对映射为 1,将 {prompt, rejected completion} 对映射为 0。
"sppo_hard"SPPO 的作者声称,SPPO 能够通过迭代求解纳什均衡,将选中的奖励推高至 1/2,将拒绝的奖励压低到 -1/2,从而缓解数据稀疏性问题。该实现通过采用硬标签概率来近似此算法,将获胜者赋值为 1,将失败者赋值为 0。
"aot" 或 loss_type="aot_unpaired"AOT 的作者提出了基于最优传输的分布偏好对齐。loss_type="aot" 适用于配对数据;loss_type="aot_unpaired" 适用于非配对数据。两者均通过排序分位数来强制实现随机占优;增大每个 GPU 的批处理大小会有所帮助。
"apo_zero" 或 loss_type="apo_down"APO 方法引入了锚定目标。apo_zero 会提升获胜者的权重并降低失败者的权重(适用于模型表现不及获胜者的情况)。apo_down 会同时降低两者的权重,但对失败者施加更强的压力(适用于模型表现已优于获胜者的情况)。
"discopop"DiscoPOP 论文利用大语言模型来发现更高效的离线偏好优化损失函数。在该论文中,所提出的 DiscoPOP 损失函数(一种对数比率调制损失)在多项任务(IMDb 正面文本生成、Reddit TLDR 摘要以及 Alpaca Eval 2.0)上均优于其他优化损失函数。
"sft"SFT(Supervised Fine-Tuning)损失是负对数似然损失,用于训练模型生成首选回复。
"sigmoid_norm"SimPO 的作者通过按非掩码 token 的数量进行归一化,解决了原始 sigmoid 损失中的长度偏差问题;TRL 将其暴露为 loss_type="sigmoid_norm"。
"udpo"UDPO 的作者提出了一种在噪声偏好下无偏的 DPO 损失,与 "robust" 不同,当翻转概率被高估时,该损失仍保持无偏。在 DPOConfig 中使用 label_smoothing 来设置翻转概率 ε;有效值范围为 [0.0, 0.5)。

记录的指标

在训练和评估过程中,我们记录以下指标:

  • global_step:迄今为止已执行的优化器步数总数。
  • epoch:当前 epoch 编号,基于数据集迭代。
  • num_tokens:迄今为止处理的 token 总数。
  • loss:当前日志记录区间内的平均 DPO 损失。
  • entropy:模型在未屏蔽 token 上的预测 token 分布的平均熵。
  • aux_loss:混合专家(Mixture-of-Experts)模型的负载均衡辅助损失,在乘以 router_aux_loss_coef 并加到总损失之前。仅当模型为 MoE 模型且 router_aux_loss_coef 非零时记录。
  • mean_token_accuracy:模型 top-1 预测与所选补全中 token 相匹配的非掩码 token 的比例。
  • learning_rate:当前学习率,如果使用调度器,该值可能会动态变化。
  • grad_norm:梯度裁剪前计算的梯度 L2 范数。
  • logits/chosen:模型为所选补全中的 token 分配的平均 logit 值。
  • logits/rejected:模型分配给被拒绝补全中各个 token 的平均 logit 值。
  • logps/chosen:模型为所选补全中的 token 分配的平均对数概率。
  • logps/rejected:模型为被拒绝的补全中的 token 分配的平均对数概率。
  • rewards/chosen: 为选中的补全计算的平均隐式奖励,计算方式为 βlog⁡πθ(y+ ⁣∣x)πref(y+ ⁣∣x) \beta \log \frac{\pi_{\theta}(y^{+}\!\mid x)}{\pi_{\mathrm{ref}}(y^{+}\!\mid x)} .
  • rewards/rejected: 为被拒绝的补全计算的平均隐式奖励,计算公式为 βlog⁡πθ(y− ⁣∣x)πref(y− ⁣∣x) \beta \log \frac{\pi_{\theta}(y^{-}\!\mid x)}{\pi_{\mathrm{ref}}(y^{-}\!\mid x)} .
  • rewards/margins:所选完成项与被拒绝完成项之间的平均隐式奖励差值。
  • rewards/accuracies:隐式奖励中,被选中的补全高于被拒绝的补全的示例所占的比例。

自定义

兼容性与约束

当前 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(训练或评估)一起使用。

多损失组合

DPO 训练器支持以不同权重组合多个损失函数,从而实现更精细的优化策略。这在实现诸如 MPO(混合偏好优化)等算法时尤为有用。MPO 是一种结合多个优化目标的训练方法,如论文 Enhancing the Reasoning Ability of Multimodal Large Language Models via Mixed Preference Optimization 中所述。

要组合多个损失,请以列表形式指定损失类型及对应的权重:

# 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。例如,如果您想以不同的精度加载模型,类似于

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

您可以通过向 DPOConfig 传递 model_init_kwargs={"dtype": torch.bfloat16} 参数来实现此操作。

from trl import DPOConfig

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

请注意,from_pretrained() 的所有关键字参数均受支持。

使用 PEFT 训练适配器

我们支持与 🤗 PEFT 库的紧密集成,允许任何用户方便地训练适配器并在 Hub 上共享,而无需训练整个模型。

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。为此,首先在 DPOTrainer 外部加载一个 PeftModel,然后直接将其传递给 trainer,而不传入 peft_config 参数。

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

在训练适配器时,由于只学习新参数,通常使用比全量微调更高的学习率(≈1e‑5)。

DPOConfig(learning_rate=1e-5, ...)

用于 DPO 的快速实验

RapidFire AI 是一个构建在 TRL 之上的开源实验引擎,允许你同时启动多个 DPO 配置,即使只有一块 GPU 也是如此。与按顺序尝试配置不同,RapidFire 让你能够更早地查看所有配置的学习曲线,停止表现不佳的运行,并在运行过程中使用新设置克隆有前景的配置,而无需重启。有关更多信息,请参阅RapidFire AI Integration。

使用 Unsloth 进行训练

Unsloth 是一个用于微调和强化学习的开源框架,可将 LLM(如 Llama、Mistral、Gemma、DeepSeek 等)的训练速度提升高达 2 倍,同时减少高达 70% 的 VRAM 占用,并提供简化的、与 Hugging Face 兼容的训练、评估和部署工作流。更多信息请参阅 Unsloth 集成。

使用 DPO 进行工具调用

DPOTrainer 完全支持对具有 tool calling 能力的模型进行微调。在这种情况下,每个数据集示例应包含:

  • 对话消息(提示、选中和拒绝),包括任何工具调用(tool_calls)和工具响应(tool 角色消息)
  • tools 列中可用工具列表,通常以 JSON 模式提供

有关预期数据集结构的详细信息,请参阅 Dataset Format — Tool Calling 部分。

训练视觉语言模型

DPOTrainer 完全支持训练视觉语言模型(VLM)。要训练 VLM,请提供一个包含 image 列(每个样本一张图像)或 images 列(每个样本一个图像列表)的数据集。有关预期数据集结构的更多信息,请参阅 数据集格式 — 视觉数据集 部分。 此类数据集的一个示例是 RLAIF-V Dataset 数据集。

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

对于 VLM,截断可能会移除图像 token,从而导致训练过程中出现错误。为避免这种情况,请在 DPOConfig 中设置 max_length=None。这允许模型处理完整的序列长度,而不会截断图像 token。

DPOConfig(max_length=None, ...)

仅在确认截断不会移除整个数据集中的图像标记后,才使用 max_length。

DPOTrainer

类 trl.DPOTrainer

< >

( model: str | PreTrainedModel | PeftModelref_model: transformers.modeling_utils.PreTrainedModel | None = Noneargs: trl.trainer.dpo_config.DPOConfig | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | datasets.dataset_dict.DatasetDict | datasets.dataset_dict.IterableDatasetDict | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)quantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = None )

参数

  • model (str 或 PreTrainedModel 或 PeftModel) — 要训练的模型。可以是以下之一:
    • 一个字符串,可以是托管在 huggingface.co 模型仓库中的预训练模型的 model id,也可以是包含使用 save_pretrained 保存的模型权重的 目录 的路径,例如 './my_model_directory/'。该模型使用 <ModelArchitecture>.from_pretrained 加载(其中 <ModelArchitecture> 由模型配置推导得出),并传入 args.model_init_kwargs 中的关键字参数。如果未在 args.model_init_kwargs 中指定 dtype,则默认为 float32。这与 from_pretrained 不同,在后者中(自 Transformers v5 起),dtype 是从模型配置中推断得出的。
    • 一个 PreTrainedModel 对象。仅支持因果语言模型。
    • 一个 PeftModel 对象。仅支持因果语言模型。
  • ref_model (PreTrainedModel, 可选) — 用于计算参考对数概率的参考模型。如果提供,该模型将直接用作参考策略。它不能是 PeftModel。如果为 None,训练器将自动使用与 model 对应的初始策略,即 DPO 训练开始前的模型状态。
    • 如果提供,该模型将直接用作参考策略。它不能是 PeftModel。
    • 如果为 None,训练器将自动使用与 model 对应的初始策略,即 DPO 训练开始前的模型状态。
  • args (DPOConfig,可选) — 此训练器的配置。如果为 None,则使用默认配置。
  • data_collator (DataCollator, 可选) — 用于将处理后的 train_dataset 或 eval_dataset 中的元素列表组合成批次的函数。 如果模型是语言模型,默认使用 DataCollatorForPreference;如果模型是视觉语言模型,则默认使用 DataCollatorForVisionPreference。自定义的 collator 必须在填充之前截断序列;训练器不会在 collation 之后应用截断。
  • train_dataset (Dataset 或 IterableDataset) — 用于训练的 语言建模 类型或 提示-补全 类型。样本的格式可以是以下两种之一:
    • 标准:每个样本包含纯文本。
    • 对话式:每个样本包含结构化的消息(例如角色和内容)。

    当 train_dataset 是一个 IterableDataset(例如流式数据集)时,必须在训练参数中设置 max_steps,因为其长度无法推断,而确定训练循环的上限并配置学习率调度器需要知道总的训练步数。

  • eval_dataset (Dataset、IterableDataset、DatasetDict、IterableDatasetDict 或 dict[str, Dataset | IterableDataset]) — 用于评估的数据集。它必须满足与 train_dataset 相同的要求。
  • processing_class(PreTrainedTokenizerBase 或 ProcessorMixin,可选)— 用于处理数据的处理类。填充侧必须设置为“left”。如果为 None,则使用 from_pretrained 从模型名称加载处理类。必须设置填充标记 tokenizer.pad_token。如果处理类未设置填充标记,则默认使用 tokenizer.eos_token。
  • compute_metrics (Callable[[EvalPrediction], dict], 可选) — 用于在评估期间计算指标的函数。必须接受一个 EvalPrediction 并返回一个从字符串到指标值的字典。当传入的 SFTConfig 中 batch_eval_metrics 设置为 True 时,您的 compute_metrics 函数必须接受一个布尔类型的 compute_result 参数。这将在最后一个评估批次之后触发,以指示该函数 需要计算并返回全局汇总统计量,而不是累积批次级别的 统计量。它接收的 logits 将通过额外的前向传播重新计算。此功能已弃用,并将在 v2.0.0 中移除。
  • callbacks (列表 TrainerCallback, 可选) — 用于自定义训练循环的回调列表。这些回调将被添加到 此处.

    如果要移除其中一个默认使用的回调,请使用 remove_callback 方法。

  • optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None],可选,默认为 (None, None)) — 一个包含要使用的优化器和调度器的元组。默认情况下,将在您的模型上使用 AdamW 的实例,并使用由 args 控制的、通过 get_linear_schedule_with_warmup 给出的调度器。
  • quantization_config (BitsAndBytesConfig, 可选) — 从模型标识符加载模型时使用的量化配置。与 peft_config 结合用于 QLoRA 训练。如果模型已经实例化,则忽略此配置。
  • peft_config (PeftConfig,可选) — 用于包装模型的 PEFT 配置。如果为 None,则不包装模型。

用于直接偏好优化(DPO)方法的 Trainer。该算法最初在论文 Direct Preference Optimization: Your Language Model is Secretly a Reward Model 中提出。 此类是 Trainer 类的封装,并继承其所有属性和方法。

示例:

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

训练

< >

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

参数

  • resume_from_checkpoint (str 或 bool,可选) — 如果为 str,则为之前 Trainer 实例保存的检查点的本地路径。如果为 bool 且等于 True,则加载之前 Trainer 实例保存在 args.output_dir 中的最后一个检查点。如果存在,训练将从此处加载的模型/优化器/调度器状态中恢复。
  • trial (optuna.Trial 或 dict[str, Any],可选) — 用于超参数搜索的试验运行或超参数字典。
  • ignore_keys_for_eval (list[str],可选) — 在训练期间收集预测结果以进行评估时,应忽略的模型输出(如果输出是字典)中的键列表。

返回值

~trainer_utils.TrainOutput

包含全局步数、训练损失和指标的 Object。

主要训练入口。

save_model

< >

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

将保存模型,以便您可以使用 from_pretrained() 重新加载它。

仅从主进程保存。

push_to_hub

< >

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

参数

  • commit_message (str,可选,默认为 "End of training") — 推送时提交的提交信息。
  • blocking (bool,可选,默认为 True) — 是否仅在 git push 完成后才返回。
  • token (str,可选,默认为 None) — 具有写入权限的 Token,用于覆盖 Trainer 的原始参数。
  • revision (str, 可选) — 要从中提交内容的 git 版本。默认为 “main” 分支的头部。
  • private (bool,可选) — 创建仓库时是否将其设为私有。默认值为 args.hub_private_repo。如果仓库已存在,则此参数无效。
  • kwargs (dict[str, Any],可选) — 传递给 ~Trainer.create_model_card 的额外关键字参数。

将 self.model 和 self.processing_class 上传到 🤗 模型库中的仓库 self.args.hub_model_id。

DPOConfig

类 trl.DPOConfig

< >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-06lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool | None = Nonegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool = Truelabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonedisable_dropout: bool = Truedataset_num_proc: int | None = Nonemax_length: int | None = 1024truncation_mode: str = 'keep_start'padding_free: bool = Falsepad_to_multiple_of: int | str | None = 'auto'precompute_ref_log_probs: bool = Falseprecompute_ref_batch_size: int | None = Noneloss_type: list[str] = <factory>loss_weights: list[float] | None = Noneld_alpha: float | None = Nonef_divergence_type: str = 'reverse_kl'f_alpha_divergence_coef: float = 0.5label_smoothing: float = 0.0beta: float = 0.1use_weighting: bool = Falsediscopop_tau: float = 0.05activation_offloading: bool = Falsesync_ref_model: bool = Falseref_model_mixup_alpha: float = 0.6ref_model_sync_steps: int = 512pad_token: str | None = None )

控制模型的参数

  • model_init_kwargs (dict[str, Any], 可选) — 用于 from_pretrained 的关键字参数,当 DPOTrainer 的 model 参数以字符串形式提供时使用。加载处理类时也会使用 revision 的值。
  • trust_remote_code (bool,可选,默认为 False) — 是否允许加载附带自定义 Python 代码的模型和分词器。该参数会转发给 from_pretrained 和 from_pretrained。
  • router_aux_loss_coef (float, 可选) — 混合专家(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, 可选) — 预计算参考模型对数概率时使用的批大小。可以将其设置为高于训练批大小以加快预处理速度。如果为 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],可选) — 用于多损失组合的损失权重列表。在组合多种损失类型时使用。示例:对于 MPO,使用 [0.8, 0.2, 1.0]。如果未提供,则默认对所有损失类型使用相等的权重(1.0)。
  • ld_alpha (float, 可选) — 来自 LD-DPO 论文的 α 参数,用于控制响应中冗长 token 对数概率的权重。如果为 None,则不对冗长部分应用权重,损失函数等同于标准 DPO 损失。取值必须在 [0.0, 1.0] 范围内:ld_alpha=1.0 表示不应用权重,而 ld_alpha=0.0 会屏蔽超出共享长度的 token。
  • f_divergence_type (str, 可选,默认为 "reverse_kl") — 策略与参考模型之间的 f-散度正则项(f-DPO 论文)。可能的取值为:reverse_kl (默认值)、forward_kl、js_divergence、alpha_divergence。仅基于 chosen-rejected 奖励差构建的损失类型支持非默认值:'sigmoid'、'sigmoid_norm'、'hinge'、 'ipo'、'exo_pair'、'robust'、'discopop'、'sft'、'udpo'。其他损失类型没有有效的 f-散度推广,若传入非默认值将被拒绝。
  • f_alpha_divergence_coef (float,可选,默认为 0.5) — α 散度正则项 u^-α 的 α 系数,仅在 f_divergence_type='alpha_divergence' 时使用。
  • label_smoothing (float, 可选,默认为 0.0) — 在 Robust DPO、UDPO 和 EXO 中使用的标签平滑参数。在 Robust DPO 和 UDPO 中,它被解释为偏好标签被翻转的概率 ε,且必须位于 [0.0, 0.5) 区间内;Robust DPO 论文推荐的典型值为 0.1。UDPO 使用它来设置 a = ε / (1 - ε),UDPO 论文推荐 a = 0.8,即 ε = 4/9。在 EXO 中,它对应于 ε 标签平滑参数,该论文推荐的典型值为 1e-3。
  • beta (float,可选,默认为 0.1) — 控制与参考模型偏差的参数。β 值越高,与参考模型的偏差越小。对于 IPO 损失(loss_type='ipo'),该值是论文中用 τ 表示的正则化参数。
  • use_weighting (bool,可选,默认为 False) — 是否使用策略的长度归一化序列概率,对偏好对应用 WPO 风格的加权。
  • discopop_tau (float, 可选,默认为 0.05) — 来自 DiscoPOP 论文的 τ/温度参数,用于在使用 loss_type='discopop' 时控制对数比率调制损失的形状。该论文建议默认值为 discopop_tau=0.05。
  • activation_offloading (bool,可选,默认为 False) — 是否将激活值卸载到 CPU。
  • sync_ref_model (bool,可选,默认为 False) — 是否每隔 ref_model_sync_steps 步使用 ref_model_mixup_alpha 参数将参考模型与活动模型进行同步。此同步机制源自 TR-DPO 论文。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 设置为 True。
  • ref_model_sync_steps (int,可选,默认为 512) — 来自 TR-DPO 论文的 τ 参数,用于确定当前策略与参考策略同步的频率。要使用此参数,必须 设置 sync_ref_model=True。

已弃用的参数

  • pad_token —

    参数 pad_token 已弃用,并将在 v2.0.0 版本中移除。请直接将 tokenizer.pad_token 设置为 processing_class 并传递给 trainer。

DPOTrainer 的配置类。

此类仅包含 DPO 训练特有的参数。完整的训练参数列表,请参阅 TrainingArguments 文档。请注意,此类中的默认值可能与 TrainingArguments 中的不同。

使用 HfArgumentParser,我们可以将该类转换为 argparse 参数,从而在命令行中指定。

这些参数的默认值与 TrainingArguments 不同:

  • logging_steps:默认值为 10,而非 500。
  • gradient_checkpointing:默认值为 True,而非 False。
  • bf16:如果未设置 fp16,则默认值为 True,而不是 False。
  • learning_rate:默认值为 1e-6,而非 5e-5。
Update on GitHub