在线 DPO 训练器

概述

在线 DPO 由 Shangmin Guo, Biao Zhang, Tianlin Liu, Tianqi Liu, Misha Khalman, Felipe Llinares, Alexandre Rame, Thomas Mesnard, Yao Zhao, Bilal Piot, Johan Ferret, 和 Mathieu Blondel 在论文《Direct Language Model Alignment from Online AI Feedback》中提出。

论文摘要如下：

直接从偏好对齐（DAP）的方法，如 DPO，最近已成为从人类反馈中进行强化学习（RLHF）的有效替代方案，并且不需要一个独立的奖励模型。然而，DAP 方法中使用的偏好数据集通常在训练前收集并且从不更新，因此反馈是纯离线的。此外，这些数据集中的响应通常是从一个与正在对齐的语言模型不同的模型中采样的，并且由于模型在训练过程中不断演变，对齐阶段不可避免地是离策略的。在这项研究中，我们认为在线反馈是关键，并且能够改进 DAP 方法。我们的方法，即在线 AI 反馈（OAIF），使用一个大语言模型（LLM）作为标注器：在每次训练迭代中，我们从当前模型中采样两个响应，并提示 LLM 标注器选择哪个更受偏好，从而提供在线反馈。尽管方法简单，我们通过在多个任务上的人工评估证明，OAIF 的表现优于离线 DAP 和 RLHF 方法。我们进一步表明，通过向 LLM 标注器提供指令性提示，OAIF 中利用的反馈是易于控制的。

该后训练方法由 Michael Noukhovitch、Shengyi Costa Huang、Quentin Gallouédec 和 Edward Beeching 贡献。

快速入门

此示例演示如何使用在线 DPO 方法训练模型。我们使用 Qwen 0.5B 模型作为基础模型，并使用 PairRMJudge 作为评判模型。我们使用来自 UltraFeedback 数据集的提示。你可以在此处查看数据集中的提示。

以下是训练模型的脚本

# train_online_dpo.py
from datasets import load_dataset
from trl import OnlineDPOConfig, OnlineDPOTrainer, PairRMJudge
from transformers import AutoModelForCausalLM, AutoTokenizer

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

training_args = OnlineDPOConfig(output_dir="Qwen2-0.5B-OnlineDPO")
trainer = OnlineDPOTrainer(
    model=model, judge=judge, args=training_args, processing_class=tokenizer, train_dataset=train_dataset
)
trainer.train()

使用以下命令执行脚本

accelerate launch train_online_dpo.py

在 8 个 GPU 上分布式训练，大约需要 1 小时。你可以通过检查奖励图来验证训练进度。被拒绝和被选择的补全奖励都呈上升趋势，表明模型正在改进并随着时间的推移生成更好的响应。

要查看训练后的模型的表现，您可以使用 Transformers Chat CLI。

$ transformers chat trl-lib/Qwen2-0.5B-OnlineDPO
<quentin_gallouedec>:
What is the best programming language?

<trl-lib/Qwen2-0.5B-OnlineDPO>:
The best programming language depends on your specific needs and priorities. Some people prefer imperative programming languages (like Haskell or Lisp), while others prefer functional programming languages (like Scala or Python). It's important to consider your work style, programming environment, and project requirements when choosing a programming language.

期望的数据集类型

在线 DPO 仅需要一个仅包含提示的数据集（与离线 DPO 不同，离线 DPO 需要偏好数据集）。OnlineDPOTrainer 支持对话格式和标准格式的数据集。当提供对话格式的数据集时，训练器会自动将聊天模板应用于数据集。

使用技巧

使用奖励模型

除了评判模型，您还可以选择使用奖励模型——请参阅 Reward Bench，这是一个可供使用的公开模型排行榜。下面是一个代码示例，展示了如何用 trl-lib/Qwen2-0.5B-Reward 模型替换评判模型。

- from trl import PairRMJudge
+ from transformers import AutoModelForSequenceClassification

- judge = PairRMJudge()
+ reward_model = AutoModelForSequenceClassification.from_pretrained("trl-lib/Qwen2-0.5B-Reward", num_labels=1)
+ reward_tokenizer = AutoTokenizer.from_pretrained("trl-lib/Qwen2-0.5B-Reward")

  trainer = OnlineDPOTrainer(
      ...
-     judge=judge,
+     reward_model=reward_model,
+     reward_processing_class=reward_tokenizer,
      ...
  )

鼓励生成 EOS 标记

在使用奖励模型时，我们可能希望模型在给定的长度内生成补全。在训练期间，模型将生成补全，其最大长度由 OnlineDPOConfig 的 `max_new_tokens` 参数指定。如果您想惩罚模型在达到最大长度之前未生成 EOS 标记的情况，可以使用 OnlineDPOConfig 的 `missing_eos_penalty` 参数。

training_args = OnlineDPOConfig(..., max_new_tokens=128, missing_eos_penalty=1.0)

记录补全

为了更好地理解模型在训练过程中的行为，您可以使用 LogCompletionsCallback 定期记录样本补全。

trainer = OnlineDPOTrainer(..., eval_dataset=eval_dataset)
completions_callback = LogCompletionsCallback(trainer, num_prompts=8)
trainer.add_callback(completions_callback)

此回调函数直接将模型生成的补全记录到 Weights & Biases。

Logged Completions

示例脚本

我们提供了一个示例脚本，用于使用在线 DPO 方法训练模型。该脚本位于 `examples/scripts/dpo_online.py`

要在 UltraFeedback 数据集上测试使用 Qwen2.5 0.5B 模型的在线 DPO 脚本，请运行以下命令

python examples/scripts/dpo_online.py \
    --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \
    --judge pair_rm \
    --dataset_name trl-lib/ultrafeedback-prompt \
    --learning_rate 5.0e-7 \
    --output_dir Qwen2.5-0.5B-Online-DPO-PairRM \
    --warmup_ratio 0.1 \
    --push_to_hub

记录的指标

记录的指标如下。这是一个在 Weights and Biases 上跟踪的运行示例

`objective/kl`：当前模型与参考模型之间的平均 Kullback-Leibler (KL) 散度。
`objective/entropy`：模型的平均熵，表示模型选择的动作的随机性。
objective/non_score_reward: 来自非分数相关来源的平均奖励，基本上是 beta * kl.sum(1)，其中 beta 是 KL 惩罚系数，kl 是每个词元的 KL 散度。
`objective/rlhf_reward`：平均 RLHF 奖励，即 `scores - non_score_reward`。`rlhf_reward` 是在线 DPO 训练的最终目标。如果训练按预期进行，该指标应持续上升。
`objective/scores`：奖励模型返回的平均分数。
`objective/scores_margin`：被选择和被拒绝的补全之间的平均分数差（根据外部奖励模型）。
`rewards/chosen`：被选择的补全的平均奖励（根据在线 DPO 的隐式奖励模型）。
`rewards/rejected`：被拒绝的补全的平均奖励（根据在线 DPO 的隐式奖励模型）。
`rewards/accuracies`：在线 DPO 的隐式奖励模型的准确率。
`rewards/margins`：被选择和被拒绝的补全之间的平均奖励差（根据在线 DPO 的隐式奖励模型）。
logps/chosen：被选中补全的平均对数概率。
`logps/rejected`：被拒绝的补全的平均对数概率。
`val/contain_eos_token`：包含 EOS 标记的补全所占的比例。
`beta`：控制表示与参考模型偏差的损失项权重的参数。通常是固定的，但可以通过向 OnlineDPOConfig 传递一个列表来使其动态化。

基准实验

为了验证在线 DPO 的实现是否有效，我们在单个 8 x H100s 节点上使用 Pythia 1B、2.8B 和 6.9B 模型进行了实验。以下是我们用来运行实验的命令。我们直接从 The N+ Implementation Details of RLHF with PPO: A Case Study on TL;DR Summarization 中获取 SFT / RM 模型。

# 1B Online DPO experiment
accelerate launch --config_file examples/accelerate_configs/multi_gpu.yaml \
    examples/scripts/dpo_online.py \
    --model_name_or_path trl-lib/pythia-1b-deduped-tldr-sft  \
    --reward_model_path trl-lib/pythia-1b-deduped-tldr-rm \
    --dataset_name trl-lib/tldr \
    --learning_rate 5.0e-7 \
    --output_dir pythia-1b-deduped-tldr-online-dpo \
    --beta 0.1 \
    --per_device_train_batch_size 8 \
    --gradient_accumulation_steps 2 \
    --num_train_epochs 3 \
    --max_new_tokens 53 \
    --warmup_ratio 0.1 \
    --missing_eos_penalty 1.0 \
    --save_steps 0.1 \
    --push_to_hub

# 2.8B Online DPO experiment
accelerate launch --config_file examples/accelerate_configs/deepspeed_zero2.yaml \
    examples/scripts/dpo_online.py \
    --model_name_or_path trl-lib/pythia-2.8b-deduped-tldr-sft  \
    --reward_model_path trl-lib/pythia-2.8b-deduped-tldr-rm \
    --dataset_name trl-lib/tldr \
    --learning_rate 5.0e-7 \
    --output_dir pythia-2.8b-deduped-tldr-online-dpo \
    --beta 0.1 \
    --per_device_train_batch_size 8 \
    --gradient_accumulation_steps 2 \
    --num_train_epochs 3 \
    --max_new_tokens 53 \
    --warmup_ratio 0.1 \
    --missing_eos_penalty 1.0 \
    --save_steps 0.1 \
    --push_to_hub

# 6.9B Online DPO experiment
accelerate launch --config_file examples/accelerate_configs/deepspeed_zero2.yaml \
    examples/scripts/dpo_online.py \
    --model_name_or_path trl-lib/pythia-6.9b-deduped-tldr-sft  \
    --reward_model_path trl-lib/pythia-6.9b-deduped-tldr-rm \
    --dataset_name trl-lib/tldr \
    --learning_rate 5.0e-7 \
    --output_dir pythia-6.9b-deduped-tldr-online-dpo \
    --beta 0.1 \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 4 \
    --num_train_epochs 3 \
    --max_new_tokens 53 \
    --warmup_ratio 0.1 \
    --missing_eos_penalty 1.0 \
    --gradient_checkpointing \
    --save_steps 0.1 \
    --push_to_hub

检查点和实验跟踪可在以下链接查看：

为了进行评估，我们使用 vLLM 来加载检查点，并使用 GPT-4o mini 作为评判模型来评估生成的 TL;DR 与参考 TL;DR。有关如何使用评判模型的更多信息，请参阅评判模型。

$ python examples/scripts/evals/judge_tldr.py --model_name_or_path trl-lib/pythia-1b-deduped-tldr-sft --judge_model gpt-4o-mini --num_examples 1000
Model win rate: 33.00%
python examples/scripts/evals/judge_tldr.py --model_name_or_path trl-lib/pythia-6.9b-deduped-tldr-sft --judge_model gpt-4o-mini --num_examples 1000
Model win rate: 41.50%
python examples/scripts/evals/judge_tldr.py --model_name_or_path trl-lib/pythia-1b-deduped-tldr-online-dpo --judge_model gpt-4o-mini --num_examples 1000
Model win rate: 62.60%
python examples/scripts/evals/judge_tldr.py --model_name_or_path trl-lib/pythia-6.9b-deduped-tldr-online-dpo --judge_model gpt-4o-mini --num_examples 1000
Model win rate: 74.20%

然后我们可以绘制 RLHF 扩展图。

import matplotlib.pyplot as plt

results = {
    "SFT": {1.0e9: 0.21, 2.8e9: 0.27, 6.9e9: 0.316},
    "online-dpo": {1.0e9: 0.542, 2.8e9: 0.746, 6.9e9: 0.796},
    "offline-dpo": {1.0e9: 0.422, 2.8e9: 0.517, 6.9e9: 0.701},
}


plt.plot(results["SFT"].keys(), results["SFT"].values(), label="SFT", marker="o")
plt.plot(results["online-dpo"].keys(), results["online-dpo"].values(), label="Online-dpo with RM judge", marker="o")
plt.plot(results["offline-dpo"].keys(), results["offline-dpo"].values(), label="Offline-dpo", marker="o")
plt.axhline(y=0.5, color="black", linestyle="-.", label="Human reference summary")
plt.xscale("log")
plt.xlabel("Model size")
plt.ylabel("Win rate against reference summaries\n(according to GPT-4-0613)")
plt.title("DPO scaling by model size")
plt.legend()
plt.xlim(5e8, 1.2e10)
plt.xticks([1e9, 3e9, 1e10], ["1B", "3B", "10B"])
plt.grid(True, which="both", ls="--", c="0.7")
plt.tight_layout()
plt.show()

随着我们扩大模型规模，在线 DPO 检查点获得了越来越高的胜率。这是一个好迹象，表明在线 DPO 的实现按预期工作。

OnlineDPOTrainer

class trl.OnlineDPOTrainer

< 源代码 >

( model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.modules.module.Module, str] ref_model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.modules.module.Module, NoneType] = None reward_model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.modules.module.Module, NoneType] = None judge: typing.Optional[trl.trainer.judges.BasePairwiseJudge] = None args: typing.Optional[trl.trainer.online_dpo_config.OnlineDPOConfig] = None data_collator: typing.Optional[transformers.data.data_collator.DataCollator] = None train_dataset: typing.Union[datasets.arrow_dataset.Dataset, torch.utils.data.dataset.IterableDataset, ForwardRef('datasets.Dataset'), NoneType] = None eval_dataset: typing.Union[datasets.arrow_dataset.Dataset, dict[str, datasets.arrow_dataset.Dataset], ForwardRef('datasets.Dataset'), 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 reward_processing_class: typing.Optional[transformers.tokenization_utils_base.PreTrainedTokenizerBase] = None peft_config: typing.Optional[dict] = None compute_metrics: typing.Optional[typing.Callable[[transformers.trainer_utils.EvalPrediction], dict]] = None callbacks: typing.Optional[list[transformers.trainer_callback.TrainerCallback]] = None optimizers: tuple = (None, None) preprocess_logits_for_metrics: typing.Optional[typing.Callable[[torch.Tensor, torch.Tensor], torch.Tensor]] = None )

参数

model (Union[str, nn.Module, PreTrainedModel]) — 要训练的模型。可以是：
- 一个字符串，作为托管在 huggingface.co 模型库中的预训练模型的*模型 ID*，或一个包含使用 `save_pretrained` 保存的模型权重的*目录*路径，例如 `'./my_model_directory/'`。模型使用 `from_pretrained` 并附带 `args.model_init_kwargs` 中的关键字参数加载。
- 一个 `PreTrainedModel` 对象。仅支持因果语言模型。
ref_model (transformers.PreTrainedModel or torch.nn.Module or None) — 用于训练的参考模型。如果指定为 None，将从模型创建参考模型。
reward_model (transformers.PreTrainedModel or torch.nn.Module or None) — 用于对补全进行评分的奖励模型，最好是 `AutoModelForSequenceClassification`。
judge (BasePairwiseJudge) — 用于对模型补全进行成对比较的评判模型。
args (OnlineDPOConfig) — 用于训练的在线 DPO 配置参数。
data_collator (transformers.DataCollator) — 用于训练的数据整理器。如果指定为 None，将使用默认的数据整理器 (`DPODataCollatorWithPadding`)，它会根据批次中序列的最大长度对序列进行填充，给定一个成对序列的数据集。
train_dataset (datasets.Dataset) — 用于训练的数据集。
eval_dataset (datasets.Dataset) — 用于评估的数据集。
processing_class (PreTrainedTokenizerBase, BaseImageProcessor, FeatureExtractionMixin or ProcessorMixin, *optional*, defaults to None) — 用于处理数据的处理类。如果提供，将用于自动处理模型的输入，并与模型一起保存，以便更容易地重新运行中断的训练或重用微调后的模型。
peft_config (dict) — 用于训练的 peft 配置。
compute_metrics (Callable[[EvalPrediction], dict], *optional*) — 用于计算指标的函数。必须接受一个 `EvalPrediction` 并返回一个从字符串到指标值的字典。
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 的函数。

初始化 OnlineDPOTrainer。

train

< 源代码 >

( 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 or bool, *optional*) — 如果是 `str`，则为 `Trainer` 的前一个实例保存的检查点的本地路径。如果是 `bool` 且等于 `True`，则加载 `args.output_dir` 中由 `Trainer` 的前一个实例保存的最后一个检查点。如果存在，训练将从此处加载的模型/优化器/调度器状态恢复。
trial (optuna.Trial or dict[str, Any], *optional*) — 用于超参数搜索的试验运行或超参数字典。
ignore_keys_for_eval (list[str], *optional*) — 模型输出中（如果它是一个字典）应在训练期间收集评估预测时忽略的键列表。
kwargs (dict[str, Any], *optional*) — 用于隐藏已弃用参数的附加关键字参数。

主训练入口点。

save_model

< 源代码 >

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

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

仅从主进程保存。

push_to_hub

< 源代码 >

( 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, *optional*, defaults to "End of training") — 推送时提交的消息。
blocking (bool, *optional*, defaults to True) — 该函数是否应仅在 `git push` 完成后返回。
token (str, *optional*, defaults to None) — 具有写权限的令牌，用于覆盖 Trainer 的原始参数。
revision (str, *optional*) — 要提交的 git 修订版本。默认为“main”分支的头部。
kwargs (dict[str, Any], *optional*) — 传递给 `~Trainer.create_model_card` 的附加关键字参数。

将 `self.model` 和 `self.processing_class` 上传到 🤗 模型中心的 `self.args.hub_model_id` 存储库。

OnlineDPOConfig

class trl.OnlineDPOConfig

< 源代码 >

( 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 = 5e-07 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 reward_model_path: typing.Optional[str] = None judge: typing.Optional[str] = None max_new_tokens: int = 64 max_length: int = 512 temperature: float = 0.9 missing_eos_penalty: typing.Optional[float] = None beta: list = <factory> loss_type: str = 'sigmoid' dataset_num_proc: typing.Optional[int] = None disable_dropout: bool = True use_vllm: bool = False vllm_model_impl: str = 'vllm' gpu_memory_utilization: typing.Optional[float] = 0.55 ds3_gather_for_generation: bool = True model_init_kwargs: typing.Optional[dict[str, typing.Any]] = None )

参数

reward_model_path (str 或 None, 可选, 默认为 None) — 奖励模型的路径。必须设置 judge 或 reward_model_path，但不能同时设置。
judge (str 或 None, 可选, 默认为 None) — 要使用的裁判（judge）名称。必须设置 judge 或 reward_model_path，但不能同时设置。
max_new_tokens (int, 可选, 默认为 64) — 每次补全（completion）生成的最大词元数（token）。
max_length (int, 可选, 默认为 256) — 用于计算对数概率的序列（提示 + 补全）的最大总长度。如果序列超过此限制，将截断最左侧的词元，以尽可能多地保留补全部分。
temperature (float, 可选, 默认为 0.9) — 用于采样的温度。温度越高，补全结果越随机。
missing_eos_penalty (float 或 None, 可选, 默认为 None) — 当模型未能生成 EOS（序列结束）词元时应用于分数的惩罚。这有助于鼓励模型生成比最大长度（max_new_tokens）更短的补全。惩罚值必须为正数。
beta (float 或 list[float], 可选, 默认为 0.1) — 控制与参考模型偏差的参数。较高的 β 意味着与参考模型的偏差较小。对于 IPO 损失（loss_type="ipo"），β 是论文中表示为 τ 的正则化参数。如果提供了一个浮点数列表，则会为每个新的 epoch 选择一个 β，并且最后一个 β 将用于剩余的 epoch。
loss_type (str, 可选, 默认为 "sigmoid") — 要使用的损失类型。可能的值有：
- "sigmoid": 来自原始 DPO 论文的 sigmoid 损失。
- "ipo": 来自 IPO 论文的 IPO 损失。
dataset_num_proc (int 或 None, 可选, 默认为 None) — 用于处理数据集的进程数。
disable_dropout (bool, 可选, 默认为 True) — 是否在模型和参考模型中禁用 dropout。
use_vllm (bool, 可选, 默认为 False) — 是否使用 vLLM 生成补全。需要安装 vLLM（pip install vllm）。
vllm_model_impl (str, 可选, 默认为 "vllm") — 用于 vLLM 的模型实现。必须是 "transformers" 或 "vllm" 之一。"transformers": 使用 transformers 后端进行模型实现。"vllm": 使用 vllm 库进行模型实现。
gpu_memory_utilization (float, 可选, 默认为 0.55) — vLLM 显存利用率。默认值为 0.55。
ds3_gather_for_generation (bool, 可选, 默认为 True) — 此设置适用于 DeepSpeed ZeRO-3。如果启用，策略模型的权重将在生成时被聚合，从而提高生成速度。然而，禁用此选项可以训练超过单个 GPU 显存容量的模型，但代价是生成速度较慢。
model_init_kwargs (dict[str, Any] 或 None, 可选, 默认为 None) — 当从字符串实例化模型时，传递给 AutoModelForCausalLM.from_pretrained 的关键字参数。

OnlineDPOTrainer 的配置类。

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

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

< > 在 GitHub 上更新

TRL

在线 DPO 训练器

概述

快速入门

期望的数据集类型

使用技巧

使用奖励模型

鼓励生成 EOS 标记

记录补全

示例脚本

记录的指标

基准实验

OnlineDPOTrainer

class trl.OnlineDPOTrainer

train

save_model

push_to_hub

OnlineDPOConfig

class trl.OnlineDPOConfig