DPO 训练器

TRL 支持 DPO 训练器，用于根据偏好数据训练语言模型，如 Rafailov 等人在 2023 年的论文直接偏好优化：您的语言模型实际上是一个奖励模型中所述。有关完整示例，请查看 examples/scripts/dpo.py。

第一步始终是训练您的 SFT 模型，以确保我们训练的数据符合 DPO 算法的分布。

DPO 的工作原理

通过 DPO 微调语言模型包括两个步骤，并且比 PPO 更简单。

数据收集：收集一个偏好数据集，其中包含给定提示的生成结果的正负选择对。
优化：直接最大化 DPO 损失的对数似然。

可以在 Hugging Face Hub 上使用 dpo 标签找到与 DPO 兼容的数据集。您还可以浏览 librarian-bots/direct-preference-optimization-datasets 集合以识别可能支持 DPO 训练的数据集。

此过程在下图中进行了说明（来自原始论文的图 1）

在原始论文中阅读有关 DPO 算法的更多信息。

预期数据集格式

DPO 训练器对数据集的格式有非常具体的要求。由于模型将被训练以直接优化哪个句子在给定两个句子时最相关，因此我们提供了一个来自 Anthropic/hh-rlhf 数据集的示例

因此，如果您使用默认的 DPODataCollatorWithPadding 数据整理器，则最终数据集对象应包含这 3 个条目。条目应命名为

提示
选中
拒绝

例如

dpo_dataset_dict = {
    "prompt": [
        "hello",
        "how are you",
        "What is your name?",
        "What is your name?",
        "Which is the best programming language?",
        "Which is the best programming language?",
        "Which is the best programming language?",
    ],
    "chosen": [
        "hi nice to meet you",
        "I am fine",
        "My name is Mary",
        "My name is Mary",
        "Python",
        "Python",
        "Java",
    ],
    "rejected": [
        "leave me alone",
        "I am not fine",
        "Whats it to you?",
        "I dont have a name",
        "Javascript",
        "C++",
        "C++",
    ],
}

其中 prompt 包含上下文输入，chosen 包含相应的选中响应，rejected 包含相应的负面（拒绝）响应。可以看出，一个提示可以有多个响应，这反映在字典的值数组中重复的条目中。

可以使用 DPOTrainer 微调视觉语言模型 (VLMs)。在这种情况下，数据集还必须包含键 images，并且训练器的 tokenizer 是 VLM 的 processor。例如，对于 Idefics2，处理器期望数据集具有以下格式

注意：目前，VLM 支持仅限于 Idefics2，不扩展到其他 VLM。

dpo_dataset_dict = {
    'images': [
        [Image.open('beach.jpg')],
        [Image.open('street.jpg')],
    ],
    'prompt': [
        'The image <image> shows',
        '<image> The image depicts',
    ],
    'chosen': [
        'a sunny beach with palm trees.',
        'a busy street with several cars and buildings.',
    ],
    'rejected': [
        'a snowy mountain with skiers.',
        'a calm countryside with green fields.',
    ],
}

预期模型格式

与期望 AutoModelForCausalLMWithValueHead 用于价值函数的 PPO 相比，DPO 训练器期望 AutoModelForCausalLM 或 AutoModelForVision2Seq 的模型。

使用 DPOTrainer

有关详细示例，请查看 examples/scripts/dpo.py 脚本。在高级别上，我们需要使用我们希望训练的 model 初始化 DPOTrainer，一个参考 ref_model，我们将使用它来计算首选和拒绝响应的隐式奖励，beta 指的是隐式奖励的超参数，并且数据集包含上面列出的 3 个条目。请注意，model 和 ref_model 需要具有相同的架构（即仅解码器或编码器-解码器）。

training_args = DPOConfig(
    beta=0.1,
)
dpo_trainer = DPOTrainer(
    model,
    ref_model,
    args=training_args,
    train_dataset=train_dataset,
    tokenizer=tokenizer,  # for visual language models, use tokenizer=processor instead
)

此后，可以调用

dpo_trainer.train()

请注意，beta 是 DPO 损失的温度参数，通常在 0.1 到 0.5 的范围内。当 beta -> 0 时，我们忽略参考模型。

损失函数

给定偏好数据，我们可以根据 Bradley-Terry 模型拟合一个二元分类器，事实上，DPO 作者建议通过 logsigmoid 对归一化似然使用 sigmoid 损失来拟合逻辑回归。要使用此损失，请在 DPOConfig 中设置 loss_type="sigmoid"（默认值）。

RSO 作者建议对来自 SLiC 论文的归一化似然使用 hinge 损失。要使用此损失，请在 DPOConfig 中设置 loss_type="hinge"。在这种情况下，beta 是边距的倒数。

IPO 作者对 DPO 算法提供了更深入的理论理解，并指出了过度拟合的问题，并提出了一种替代损失。要使用此损失，请在 DPOConfig 中设置 loss_type="ipo"。在这种情况下，beta 是选定与拒绝完成对的日志似然比之间的差距的倒数，因此 beta 越小，此差距越大。根据论文，损失在完成的日志似然上取平均值（与 DPO 仅求和不同）。

cDPO 是对 DPO 损失的调整，我们假设偏好标签以某种概率存在噪声。在这种方法中，DPOConfig 中的 label_smoothing 参数用于模拟现有标签噪声的概率。要应用此保守损失，请将 label_smoothing 设置为大于 0.0 的值（介于 0.0 和 0.5 之间；默认值为 0.0）。

EXO 作者建议最小化反向 KL，而不是 DPO 的负对数 sigmoid 损失，后者对应于正向 KL。要使用此损失，请在 DPOConfig 中设置 loss_type="exo_pair"。将非零 label_smoothing（默认值 1e-3）设置为 EXO 在成对偏好上的简化版本（参见 EXO 论文的公式 (16)）。EXO 的完整版本使用由 SFT 策略生成的 K>2 个完成，当 K 足够大时，它成为 PPO 目标（最多一个常数）的无偏估计量。

NCA 作者表明，NCA 优化每个响应的绝对似然，而不是相对似然。要使用此损失，请在 DPOConfig 中设置 loss_type="nca_pair"。

鲁棒 DPO 作者提出了一种对数据中偏好噪声具有鲁棒性的 DPO 损失的无偏估计。与 cDPO 一样，它假设偏好标签以某种概率存在噪声。在这种方法中，DPOConfig 中的 label_smoothing 参数用于模拟现有标签噪声的概率。要应用此保守损失，请将 label_smoothing 设置为大于 0.0 的值（介于 0.0 和 0.5 之间；默认值为 0.0），并在 DPOConfig 中设置 loss_type="robust"。

BCO 作者训练了一个二元分类器，其 logit 用作奖励，以便分类器将 {提示，选定完成} 对映射到 1，并将 {提示，拒绝完成} 对映射到 0。要使用此损失，请在 DPOConfig 中设置 loss_type="bco_pair"。

TR-DPO 论文建议在 DPO 训练期间，每隔 ref_model_sync_steps 步 SGD 后，使用权重 ref_model_mixup_alpha 同步参考模型权重。要切换此回调，请在 DPOConfig 中使用 sync_ref_model=True。

RPO 论文使用与这篇论文中的 RPO 损失相关的损失实现了迭代偏好调整算法，该算法基本上包括对选定偏好的加权 SFT 损失以及 DPO 损失。要使用此损失，请在 DPOConfig 中将 rpo_alpha 设置为适当的值。该论文建议将此权重设置为 1.0。

SPPO 作者声称，SPPO 能够通过将选定奖励推至 1/2 以及将拒绝奖励推至 -1/2 来迭代地解决纳什均衡问题，并且可以缓解数据稀疏性问题。该实现通过使用硬标签概率来近似此算法，将 1 分配给获胜者，将 0 分配给失败者。要使用此损失，请在 DPOConfig 中设置 loss_type="sppo_hard"。

AOT 作者建议使用通过最优传输进行分布式偏好对齐。传统上，对齐算法在样本级别使用配对偏好，这不能确保在分布级别上的对齐。另一方面，AOT 可以通过使正样本的奖励分布在一阶上随机支配负样本的分布来对配对或未配对偏好数据上的 LLM 进行对齐。具体来说，loss_type="aot" 适用于配对数据集，其中每个提示都有选定和拒绝的响应；loss_type="aot_pair" 适用于未配对数据集。简而言之，loss_type="aot" 确保对齐模型的选定与拒绝的对数似然比高于参考模型的该比率的分位数。loss_type="aot_pair" 确保选定奖励在所有分位数上都高于拒绝奖励。请注意，在这两种情况下，分位数都是通过排序获得的。为了充分利用 AOT 算法的优势，最大化每个 GPU 的批次大小非常重要。

APO 方法引入了对齐目标的“锚定”版本。有两种变体：apo_zero 和 apo_down。apo_zero 损失增加了获胜输出的可能性，同时减少了失败输出的可能性，使其适用于模型性能低于获胜输出的情况。另一方面，apo_down 减少了获胜和失败输出的可能性，但更侧重于减少失败输出的可能性。当模型优于获胜输出时，此变体更有效。要使用这些损失，请在 DPOConfig 中设置 loss_type="apo_zero" 或 loss_type="apo_down"。

专家混合模型：启用辅助损失

如果负载在专家之间大致均匀分布，则 MOE 最有效。
为了确保在偏好调整期间以类似的方式训练 MOE，将负载均衡器的辅助损失添加到最终损失中是有益的。

此选项通过在模型配置（例如 MixtralConfig）中设置 output_router_logits=True 来启用。
要调整辅助损失对总损失的贡献程度，请使用超参数 router_aux_loss_coef=...（默认值：0.001）。

日志记录

在训练和评估过程中，我们记录以下奖励指标：

rewards/chosen：选择响应的策略模型和参考模型的对数概率之间的平均差值，乘以 beta。
rewards/rejected：拒绝响应的策略模型和参考模型的对数概率之间的平均差值，乘以 beta。
rewards/accuracies：选择奖励大于相应拒绝奖励的频率的平均值。
rewards/margins：选择奖励和相应拒绝奖励之间的平均差值。

使用 Unsloth 加速 DPO 微调

您可以使用与 SFTTrainer 完全兼容的 unsloth 库进一步加速 QLoRA/LoRA（速度提升 2 倍，内存减少 60%）。目前，unsloth 仅支持 Llama（Yi、TinyLlama、Qwen、Deepseek 等）和 Mistral 架构。以下是 DPO 的一些基准测试结果：

GPU	模型	数据集	🤗	🤗 + Flash Attention 2	🦥 Unsloth	🦥 减少的 VRAM
A100 40G	Zephyr 7b	Ultra Chat	1x	1.24x	1.88x	-11.6%
Tesla T4	Zephyr 7b	Ultra Chat	1x	1.09x	1.55x	-18.6%

首先根据官方文档安装 unsloth。安装完成后，您可以非常简单地将 unsloth 整合到您的工作流程中；只需加载 FastLanguageModel 而不是加载 AutoModelForCausalLM，如下所示：

import torch
from trl import DPOConfig, DPOTrainer
from unsloth import FastLanguageModel

max_seq_length = 2048 # Supports automatic RoPE Scaling, so choose any number.

# Load model
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/zephyr-sft",
    max_seq_length = max_seq_length,
    dtype = None, # None for auto detection. Float16 for Tesla T4, V100, Bfloat16 for Ampere+
    load_in_4bit = True, # Use 4bit quantization to reduce memory usage. Can be False.
    # token = "hf_...", # use one if using gated models like meta-llama/Llama-2-7b-hf
)

# Do model patching and add fast LoRA weights
model = FastLanguageModel.get_peft_model(
    model,
    r = 16,
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                      "gate_proj", "up_proj", "down_proj",],
    lora_alpha = 16,
    lora_dropout = 0, # Dropout = 0 is currently optimized
    bias = "none",    # Bias = "none" is currently optimized
    use_gradient_checkpointing = True,
    random_state = 3407,
)

training_args = DPOConfig(
    output_dir="./output",
    beta=0.1,
)

dpo_trainer = DPOTrainer(
    model,
    ref_model=None,
    args=training_args,
    train_dataset=train_dataset,
    tokenizer=tokenizer,
)
dpo_trainer.train()

保存的模型与 Hugging Face 的 transformers 库完全兼容。在他们的官方仓库中了解更多关于 unsloth 的信息。

使用 PEFT 的参考模型注意事项

假设您想要使用 DPO 进一步增强使用 (Q)LoRA 调整的模型，那么您有三种主要选择（以及一些变体）来处理使用 PEFT 时参考模型的工作方式。

简单地创建两个模型实例，每个实例都加载您的适配器 - 可以正常工作，但效率非常低下。
将适配器合并到基础模型中，在其上创建另一个适配器，然后将 ref_model 参数保留为 null，在这种情况下，DPOTrainer 将卸载适配器以进行参考推理 - 效率很高，但在下面讨论了一些潜在的缺点。
使用不同的名称加载适配器两次，然后在训练期间使用 set_adapter 在正在进行 DPO 的适配器和参考适配器之间切换 - 与方法 2 相比效率略低（大约适配器大小的 VRAM 开销），但避免了缺点。

在 DPO 之前合并 QLoRA 的缺点（方法 2）

正如 Benjamin Marie 所建议的，合并 QLoRA 适配器的最佳选择是首先反量化基础模型，然后合并适配器。类似于此脚本。

但是，使用这种方法后，您将拥有一个未量化的基础模型。因此，要对 DPO 使用 QLoRA，您需要重新量化合并后的模型或使用未量化的合并（导致更高的内存需求）。

使用选项 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: Union = None ref_model: Union = None beta: float = 0.1 label_smoothing: float = 0 loss_type: Optional = None args: Optional = None data_collator: Optional = None label_pad_token_id: int = -100 padding_value: Optional = None truncation_mode: str = 'keep_end' train_dataset: Optional = None eval_dataset: Union = None tokenizer: Optional = None model_init: Optional = None callbacks: Optional = None optimizers: Tuple = (None, None) preprocess_logits_for_metrics: Optional = None max_length: Optional = None max_prompt_length: Optional = None max_target_length: Optional = None peft_config: Optional = None is_encoder_decoder: Optional = None disable_dropout: bool = True generate_during_eval: bool = False compute_metrics: Optional = None precompute_ref_log_probs: bool = False dataset_num_proc: Optional = None model_init_kwargs: Optional = None ref_model_init_kwargs: Optional = None model_adapter_name: Optional = None ref_adapter_name: Optional = None reference_free: bool = False force_use_ref_model: bool = False )

参数

model (transformers.PreTrainedModel) — 用于训练的模型，最好是 AutoModelForSequenceClassification。
ref_model (PreTrainedModelWrapper) — 具有随意语言建模头的 Hugging Face 变压器模型。用于隐式奖励计算和损失。如果没有提供参考模型，则训练器将创建与要优化的模型具有相同架构的参考模型。
args (DPOConfig) — 用于训练的 DPO 配置参数。
data_collator (transformers.DataCollator) — 用于训练的数据整理器。如果未指定，则将使用默认数据整理器 (DPODataCollatorWithPadding)，它将在给定成对序列的数据集的情况下，将序列填充到批次中序列的最大长度。
train_dataset (datasets.Dataset) — 用于训练的数据集。
eval_dataset (datasets.Dataset) — 用于评估的数据集。
tokenizer (transformers.PreTrainedTokenizerBase) — 用于训练的分词器。如果您想使用默认的数据整理器，则此参数是必需的。
model_init (Callable[[], transformers.PreTrainedModel]) — 用于训练的模型初始化器。如果指定为 None，则将使用默认的模型初始化器。
callbacks (List[transformers.TrainerCallback]) — 用于训练的回调函数。
optimizers (Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]) — 用于训练的优化器和调度器。
preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor]) — 用于在计算指标之前预处理 logits 的函数。
peft_config (Dict，默认为 None) — 用于训练的 PEFT 配置。如果您传递 PEFT 配置，则模型将被包装在一个 PEFT 模型中。
compute_metrics (Callable[[EvalPrediction], Dict]，可选) — 用于计算指标的函数。必须接受一个 EvalPrediction 并返回一个字符串到指标值的字典。

初始化 DPOTrainer。

compute_reference_log_probs

< source >

( padded_batch: Dict )

计算 DPO 特定数据集的单个填充批次的参考模型的对数概率。

concatenated_forward

< source >

( model: Module batch: Dict )

在给定的输入批次上运行给定的模型，并将选择的和拒绝的输入连接在一起。

我们这样做是为了避免进行两次前向传递，因为对于 FSDP 来说它更快。

concatenated_inputs

< source >

( batch: Dict is_encoder_decoder: bool = False is_vision_model: bool = False label_pad_token_id: int = -100 padding_value: int = 0 device: Optional = None )

将选定和拒绝的输入连接成单个张量。

dpo_loss

< 源代码 >

( policy_chosen_logps: FloatTensor policy_rejected_logps: FloatTensor reference_chosen_logps: FloatTensor reference_rejected_logps: FloatTensor ) → 三个张量的元组

返回值

三个张量的元组

(losses, chosen_rewards, rejected_rewards)。losses 张量包含批次中每个示例的 DPO 损失。chosen_rewards 和 rejected_rewards 张量分别包含选定和拒绝响应的奖励。

计算一批策略和参考模型对数概率的 DPO 损失。

evaluation_loop

< 源代码 >

( dataloader: DataLoader description: str prediction_loss_only: Optional = None ignore_keys: Optional = None metric_key_prefix: str = 'eval' )

覆盖内置的评估循环以存储每个批次的指标。预测/评估循环，由Trainer.evaluate()和Trainer.predict()共享。

适用于有标签或无标签的情况。

get_batch_logps

< 源代码 >

( logits: FloatTensor labels: LongTensor label_pad_token_id: int = -100 is_encoder_decoder: bool = False )

计算给定 logits 下给定标签的对数概率。

get_batch_loss_metrics

< 源代码 >

( model batch: Dict train_eval: Literal = 'train' )

计算给定输入批次的训练或测试的 DPO 损失和其他指标。

get_batch_samples

< 源代码 >

( model batch: Dict )

为给定的输入批次生成模型和参考模型的样本。

get_eval_dataloader

< 源代码 >

( eval_dataset: Optional = None )

参数

eval_dataset (torch.utils.data.Dataset, 可选) — 如果提供，将覆盖 self.eval_dataset。如果它是一个 Dataset，则model.forward()方法不接受的列将自动删除。它必须实现__len__。

返回评估 ~torch.utils.data.DataLoader。

transformers.src.transformers.trainer.get_eval_dataloader 的子类，用于预计算 ref_log_probs。

get_train_dataloader

< 源代码 >

( )

返回训练 ~torch.utils.data.DataLoader。

transformers.src.transformers.trainer.get_train_dataloader 的子类，用于预计算 ref_log_probs。

log

< 源代码 >

( logs: Dict )

参数

logs (Dict[str, float]) — 要记录的值。

在各种观察训练的对象（包括存储的指标）上记录 logs。

null_ref_context

< 源代码 >

( )

用于处理空引用模型（即 peft 适配器操作）的上下文管理器。

DPOConfig

类 trl.DPOConfig

< 源代码 >

( output_dir: str overwrite_output_dir: bool = False do_train: bool = False do_eval: bool = False do_predict: bool = False eval_strategy: Union = '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: Optional = None per_gpu_eval_batch_size: Optional = None gradient_accumulation_steps: int = 1 eval_accumulation_steps: Optional = None eval_delay: Optional = 0 torch_empty_cache_steps: Optional = None learning_rate: float = 5e-05 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: Union = 'linear' lr_scheduler_kwargs: Union = <factory> warmup_ratio: float = 0.0 warmup_steps: int = 0 log_level: Optional = 'passive' log_level_replica: Optional = 'warning' log_on_each_node: bool = True logging_dir: Optional = None logging_strategy: Union = 'steps' logging_first_step: bool = False logging_steps: float = 500 logging_nan_inf_filter: bool = True save_strategy: Union = 'steps' save_steps: float = 500 save_total_limit: Optional = None save_safetensors: Optional = 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: Optional = None jit_mode_eval: bool = False use_ipex: bool = False bf16: bool = False fp16: bool = False fp16_opt_level: str = 'O1' half_precision_backend: str = 'auto' bf16_full_eval: bool = False fp16_full_eval: bool = False tf32: Optional = None local_rank: int = -1 ddp_backend: Optional = None tpu_num_cores: Optional = None tpu_metrics_debug: bool = False debug: Union = '' dataloader_drop_last: bool = False eval_steps: Optional = None dataloader_num_workers: int = 0 dataloader_prefetch_factor: Optional = None past_index: int = -1 run_name: Optional = None disable_tqdm: Optional = None remove_unused_columns: Optional = True label_names: Optional = None load_best_model_at_end: Optional = False metric_for_best_model: Optional = None greater_is_better: Optional = None ignore_data_skip: bool = False fsdp: Union = '' fsdp_min_num_params: int = 0 fsdp_config: Union = None fsdp_transformer_layer_cls_to_wrap: Optional = None accelerator_config: Union = None deepspeed: Union = None label_smoothing_factor: float = 0.0 optim: Union = 'adamw_torch' optim_args: Optional = None adafactor: bool = False group_by_length: bool = False length_column_name: Optional = 'length' report_to: Union = None ddp_find_unused_parameters: Optional = None ddp_bucket_cap_mb: Optional = None ddp_broadcast_buffers: Optional = 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: Optional = None hub_model_id: Optional = None hub_strategy: Union = 'every_save' hub_token: Optional = None hub_private_repo: bool = False hub_always_push: bool = False gradient_checkpointing: bool = False gradient_checkpointing_kwargs: Union = None include_inputs_for_metrics: bool = False include_for_metrics: List = <factory> eval_do_concat_batches: bool = True fp16_backend: str = 'auto' evaluation_strategy: Union = None push_to_hub_model_id: Optional = None push_to_hub_organization: Optional = None push_to_hub_token: Optional = None mp_parameters: str = '' auto_find_batch_size: bool = False full_determinism: bool = False torchdynamo: Optional = None ray_scope: Optional = 'last' ddp_timeout: Optional = 1800 torch_compile: bool = False torch_compile_backend: Optional = None torch_compile_mode: Optional = None dispatch_batches: Optional = None split_batches: Optional = None include_tokens_per_second: Optional = False include_num_input_tokens_seen: Optional = False neftune_noise_alpha: Optional = None optim_target_modules: Union = None batch_eval_metrics: bool = False eval_on_start: bool = False use_liger_kernel: Optional = False eval_use_gather_object: Optional = False beta: float = 0.1 label_smoothing: float = 0.0 loss_type: Literal = 'sigmoid' label_pad_token_id: int = -100 padding_value: Optional = None truncation_mode: str = 'keep_end' max_length: Optional = None max_prompt_length: Optional = None max_target_length: Optional = None max_completion_length: Optional = None is_encoder_decoder: Optional = None disable_dropout: bool = True generate_during_eval: bool = False precompute_ref_log_probs: bool = False dataset_num_proc: Optional = None model_init_kwargs: Optional = None ref_model_init_kwargs: Optional = None model_adapter_name: Optional = None ref_adapter_name: Optional = None reference_free: bool = False force_use_ref_model: bool = False f_divergence_type: FDivergenceType = <FDivergenceType.REVERSE_KL: 'reverse_kl'> f_alpha_divergence_coef: float = 1.0 sync_ref_model: bool = False ref_model_mixup_alpha: float = 0.9 ref_model_sync_steps: int = 64 rpo_alpha: Optional = None )

参数

beta (float, 可选，默认为 0.1) — 控制与参考模型偏差的参数。较高的 β 表示与参考模型的偏差较小。对于 IPO 损失（loss_type="ipo"），β 是论文中表示为 τ 的正则化参数。
label_smoothing (float, 可选，默认为 0.0) — 来自 cDPO 报告和 Robust DPO 论文的鲁棒 DPO 标签平滑参数，应介于 0.0 和 0.5 之间。
label_pad_token_id (int，可选，默认为 -100) — 标签填充 token ID。如果您想使用默认的数据整理器，则需要此参数。
padding_value (Optional[int]，可选，默认为 None) — 要使用的填充值。如果为 None，则使用分词器的填充值。
truncation_mode (str，可选，默认为 "keep_end") — 要使用的截断模式，可以是 keep_end 或 keep_start。如果您想使用默认的数据整理器，则需要此参数。
max_length (Optional[int]，可选，默认为 None) — 批次中序列（提示 + 补全）的最大长度。如果您想使用默认的数据整理器，则需要此参数。
max_prompt_length (Optional[int]，可选，默认为 None) — 提示的最大长度。如果您想使用默认的数据整理器，则需要此参数。
max_completion_length (Optional[int]，可选，默认为 None) — 目标的最大长度。如果您想使用默认的数据整理器并且您的模型是编码器-解码器，则需要此参数。
is_encoder_decoder(Optional[int]， 可选，默认为 None) — 当使用 model_init 参数（可调用）来实例化模型而不是 model 参数时，您需要指定可调用返回的模型是否为编码器-解码器模型。
disable_dropout (bool，可选，默认为 True) — 是否在模型和参考模型中禁用 dropout。
generate_during_eval (bool，可选，默认为 False) — 当提示过长时使用的截断模式。可能的值为 "keep_end" 或 "keep_start"。如果您想使用默认的数据整理器，则需要此参数。
precompute_ref_log_probs (bool，可选，默认为 False) — 是否预计算训练和评估数据集的参考模型对数概率。这在没有参考模型的情况下进行训练时很有用，可以减少所需的总 GPU 内存。
model_init_kwargs (Optional[Dict[str, Any]]，可选，默认为 None) — 在从字符串实例化模型时，传递给 AutoModelForCausalLM.from_pretrained 的关键字参数。
ref_model_init_kwargs (Optional[Dict[str, Any]]，可选，默认为 None) — 在从字符串实例化参考模型时，传递给 AutoModelForCausalLM.from_pretrained 的关键字参数。
model_adapter_name (Optional[str]，可选，默认为 None) — 使用 LoRA 和多个适配器时，训练目标 PEFT 适配器的名称。
ref_adapter_name (Optional[str]，可选，默认为 None) — 使用 LoRA 和多个适配器时，参考 PEFT 适配器的名称。
reference_free (bool，可选，默认为 False) — 如果为 True，我们将忽略提供的参考模型，并隐式地使用一个为所有响应分配相等概率的参考模型。
force_use_ref_model (bool，可选，默认为 False) — 如果为活动模型传递了 PEFT 模型，并且您想为 ref_model 使用不同的模型，请将此标志设置为 True。
f_divergence_type (str，可选，默认为 FDivergenceType.REVERSE_KL) — 用于计算策略和参考模型之间差异的 f 散度正则化函数的类型。
f_alpha_divergence_coef (float，可选，默认为 1.0) — DPO 损失的 α 散度{@html " $u^{-\\\\alpha}$
sync_ref_model (bool，可选，默认为 False) — 当设置为 True 时，参考模型将每隔 ref_model_sync_steps 步与活动模型同步，使用 ref_model_mixup_alpha 参数。此同步源自 TR-DPO 论文。
ref_model_mix
ref_model_sync_steps (int，可选，默认为 64) — TR-DPO 论文中的 τ 参数，用于确定当前策略与参考策略同步的频率。要使用此参数，必须将 sync_ref_model 设置为 True。
rpo_alpha (float，可选，默认为 None) — RPO（v3）论文中的 α 参数，用于控制损失中 NLL 项的权重。如果为 None，则不应用权重，损失与 DPO 损失相同。论文建议 rpo_alpha=1.0。

DPOTrainer 的配置类。

使用 HfArgumentParser，我们可以将此类转换为 argparse 参数，这些参数可以在命令行中指定。

< > 在 GitHub 上更新