ORPO 训练器

概述

优势比偏好优化（Odds Ratio Preference Optimization, ORPO）由 Jiwoo Hong、Noah Lee 和 James Thorne 在论文《ORPO：无需参考模型的单阶段偏好优化》中提出。

论文摘要如下：

虽然近期针对语言模型的偏好对齐算法取得了喜人的成果，但监督式微调（SFT）对于实现成功收敛仍然至关重要。在本文中，我们研究了 SFT 在偏好对齐背景下的关键作用，强调对不受欢迎的生成风格施加微小惩罚就足以实现偏好对齐的 SFT。基于此，我们提出了一种简单创新的、无需参考模型的单阶段优势比偏好优化算法——ORPO，从而省去了额外的偏好对齐阶段。我们在经验和理论上证明，在 125M 到 7B 的各种模型规模上，优势比是 SFT 过程中对比受欢迎和不受欢迎风格的明智选择。具体而言，仅在 UltraFeedback 数据集上使用 ORPO 微调 Phi-2 (2.7B)、Llama-2 (7B) 和 Mistral (7B) 的性能，就超过了参数量超过 7B 和 13B 的最先进语言模型：在 AlpacaEval_{2.0} 上最高提升 12.20%（图 1），在 IFEval 上达到 66.19%（指令级宽松，表 6），在 MT-Bench 上达到 7.32 分（图 12）。我们发布了 Mistral-ORPO-alpha (7B) 和 Mistral-ORPO-beta (7B) 的代码和模型检查点。

它研究了 SFT 在偏好对齐背景下的关键作用。该方法使用偏好数据，并提出：对不偏好的生成施加轻微惩罚，同时通过一个简单的、附加到负对数似然（NLL）损失的对数优势比项，为所选响应提供强烈的适应信号，这对于偏好对齐的 SFT 来说已经足够。

因此，ORPO 是一种无需参考模型的偏好优化算法，它省去了额外的偏好对齐阶段，从而节省了计算资源和内存。

官方代码可在 xfactlab/orpo 找到。

该后训练方法由 Kashif Rasul、Lewis Tunstall 和 Alvaro Bartolome 贡献。

快速入门

本示例演示了如何使用 ORPO 方法训练模型。我们使用 Qwen 0.5B 模型作为基础模型。我们使用来自 UltraFeedback 数据集的偏好数据。你可以在数据集中查看数据。

以下是训练模型的脚本

# train_orpo.py
from datasets import load_dataset
from trl import ORPOConfig, ORPOTrainer
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 = ORPOConfig(output_dir="Qwen2-0.5B-ORPO")
trainer = ORPOTrainer(model=model, args=training_args, processing_class=tokenizer, train_dataset=train_dataset)
trainer.train()

使用以下命令执行脚本

accelerate launch train_orpo.py

在 8 个 GPU 上进行分布式训练，大约需要 30 分钟。您可以通过查看奖励图来验证训练进度。奖励边际的增长趋势表明模型正在改进并随时间生成更好的响应。

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

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

<trl-lib/Qwen2-0.5B-ORPO>:
It's challenging to determine the best programming language as no one language is perfect, as the complexity of a task and the type of project are significant factors. Some popular languages include Java, Python, JavaScript, and
C++. If you have specific needs or requirements for a specific project, it's important to choose the language that best suits those needs.                                                                                          

Here are some other factors to consider when choosing a programming language for a project:

 • Language proficiency: A good programming language is more likely to be easy to understand and use, and will allow developers to collaborate on projects more efficiently.                                     
 • Ease of use: There are tools and libraries available to make programming more accessible, so developers should choose a language that can help them get started easier.
 • Code readability: A clear and concise codebase should be easy to read and understand, especially when working with large projects.
 • Tool and framework support: There are numerous libraries available for Python, Java, and JavaScript, along with tools like IDEs and static code analysis tools.
 • Accessibility: Some languages and tools have features that make them more accessible to developers with disabilities, such as support for screen readers.
 • Version control: As your projects grow and complexity increases, version control tools can be beneficial for tracking changes.

预期的数据集类型

ORPO 需要一个偏好数据集。 ORPOTrainer 同时支持对话式和标准数据集格式。当提供对话式数据集时，训练器会自动将聊天模板应用于数据集。

尽管 ORPOTrainer 支持显式和隐式提示，但我们建议使用显式提示。如果提供隐式提示数据集，训练器将自动从 "chosen" 和 "rejected" 列中提取提示。更多信息，请参阅偏好风格部分。

示例脚本

我们提供一个示例脚本来使用 ORPO 方法训练模型。该脚本位于 examples/scripts/orpo.py

要使用 Qwen2 0.5B 模型在 UltraFeedback 数据集上测试 ORPO 脚本，请运行以下命令：

accelerate launch examples/scripts/orpo.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-ORPO

使用技巧

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

如果负载在专家之间大致均匀分布，MOE（专家混合模型）效率最高。
为了确保在偏好调整期间类似地训练 MOE，将负载均衡器的辅助损失添加到最终损失中是有益的。

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

记录的指标

在训练和评估期间，我们记录以下奖励指标

rewards/chosen：策略模型对所选响应的平均对数概率，按 beta 缩放
rewards/rejected：策略模型对拒绝响应的平均对数概率，按 beta 缩放
rewards/accuracies：所选奖励大于相应被拒奖励的频率的平均值
rewards/margins：选中奖励和相应拒绝奖励之间的平均差异
log_odds_chosen：所选响应相对于拒绝响应的平均对数优势比
log_odds_ratio：`log(sigmoid(log_odds_chosen))` 的平均值
nll_loss：来自损失的 SFT 部分的、关于所选响应的平均负对数似然损失

ORPOTrainer

class trl.ORPOTrainer

< 来源 >

( model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.modules.module.Module, str, NoneType] = None args: typing.Optional[trl.trainer.orpo_config.ORPOConfig] = None data_collator: typing.Optional[transformers.data.data_collator.DataCollator] = None train_dataset: typing.Optional[datasets.arrow_dataset.Dataset] = None eval_dataset: typing.Union[datasets.arrow_dataset.Dataset, dict[str, datasets.arrow_dataset.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 model_init: typing.Optional[typing.Callable[[], transformers.modeling_utils.PreTrainedModel]] = 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 peft_config: typing.Optional[dict] = None compute_metrics: typing.Optional[typing.Callable[[transformers.trainer_utils.EvalLoopOutput], dict]] = None )

参数

model (transformers.PreTrainedModel) — 用于训练的模型，最好是 AutoModelForSequenceClassification。
args (ORPOConfig) — 用于训练的 ORPO 配置参数。
data_collator (transformers.DataCollator) — 用于训练的数据整理器。如果未指定，将使用默认的数据整理器 (DPODataCollatorWithPadding)，它会将批次中的序列填充到该批次序列的最大长度，适用于成对序列的数据集。
train_dataset (datasets.Dataset) — 用于训练的数据集。
eval_dataset (datasets.Dataset) — 用于评估的数据集。
processing_class (PreTrainedTokenizerBase, BaseImageProcessor, FeatureExtractionMixin 或 ProcessorMixin, 可选, 默认为 None) — 用于处理数据的处理类。如果提供，将用于自动处理模型的输入，并与模型一同保存，以便于重新运行中断的训练或重用微调后的模型。
model_init (Callable[[], transformers.PreTrainedModel]) — 用于训练的模型初始化器。如果未指定，将使用默认的模型初始化器。
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 对象并返回一个字符串到指标值的字典。

初始化 ORPOTrainer。

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 或 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

< 来源 >

( 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, 可选, 默认为 "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` 存储库。

ORPOConfig

class trl.ORPOConfig

< 来源 >

( 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 max_length: typing.Optional[int] = 1024 max_prompt_length: typing.Optional[int] = 512 max_completion_length: typing.Optional[int] = None beta: float = 0.1 disable_dropout: bool = True label_pad_token_id: int = -100 padding_value: typing.Optional[int] = None truncation_mode: str = 'keep_end' generate_during_eval: bool = False is_encoder_decoder: typing.Optional[bool] = None model_init_kwargs: typing.Optional[dict[str, typing.Any]] = None dataset_num_proc: typing.Optional[int] = None )

参数

max_length (int 或 None，可选，默认为 1024) — 批次中序列（提示 + 补全）的最大长度。如果要使用默认的数据整理器，则此参数是必需的。
max_prompt_length (int 或 None，可选，默认为 512) — 提示的最大长度。如果要使用默认的数据整理器，则此参数是必需的。
max_completion_length (int 或 None，可选，默认为 None) — 补全的最大长度。如果要使用默认的数据整理器且模型是编码器-解码器模型，则此参数是必需的。
beta (float，可选，默认为 0.1) — 在ORPO损失中控制相对比率损失权重的参数。在论文中，它表示为 λ。在代码中，它表示为 alpha。
disable_dropout (bool，可选，默认为 True) — 是否在模型中禁用 dropout。
label_pad_token_id (int，可选，默认为 -100) — 标签填充标记的ID。如果要使用默认的数据整理器，则此参数是必需的。
padding_value (int 或 None，可选，默认为 None) — 要使用的填充值。如果为 None，则使用分词器的填充值。
truncation_mode (str，可选，默认为 "keep_end") — 当提示过长时使用的截断模式。可能的值为 "keep_end" 或 "keep_start"。如果要使用默认的数据整理器，则此参数是必需的。
generate_during_eval (bool，可选，默认为 False) — 如果为 True，则在评估期间生成模型的补全并记录到 W&B 或 Comet。
is_encoder_decoder (bool 或 None，可选，默认为 None) — 当使用 model_init 参数（可调用函数）实例化模型而不是 model 参数时，您需要指定可调用函数返回的模型是否为编码器-解码器模型。
model_init_kwargs (dict[str, Any] 或 None，可选，默认为 None) — 当从字符串实例化模型时，传递给 AutoModelForCausalLM.from_pretrained 的关键字参数。
dataset_num_proc (int 或 None，可选，默认为 None) — 用于处理数据集的进程数。

ORPOTrainer 的配置类。

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

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

< > 在 GitHub 上更新

TRL

ORPO 训练器

概述

快速入门

预期的数据集类型

示例脚本

使用技巧

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

记录的指标

ORPOTrainer

class trl.ORPOTrainer

train

save_model

push_to_hub

ORPOConfig

class trl.ORPOConfig