TRL documentation

KTO 训练器

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

KTO 训练器

All_models-KTO-blue

概述

TRL 支持 Kahneman-Tversky 优化(KTO)Trainer,用于训练语言模型,如 Kawin Ethayarajh、Winnie Xu、Niklas Muennighoff、Dan Jurafsky 和 Douwe Kiela 在论文 KTO: Model Alignment as Prospect Theoretic Optimization 中所述。

该论文的摘要如下:

Kahneman & Tversky 的前景理论指出,人类以有偏但定义明确的方式感知随机变量;例如,人类以损失厌恶而闻名。我们表明,用于将 LLM 与人类反馈对齐的目标函数隐式地融入了许多此类偏差——这些目标函数(例如 DPO)相较于交叉熵最小化的成功,部分可归因于它们是人类感知的损失函数(HALOs)。然而,这些方法所赋予人类的效用函数仍与前景理论文献中的效用函数存在差异。利用 Kahneman-Tversky 人类效用模型,我们提出了一种 HALO,它直接最大化生成的效用,而非像当前方法那样最大化偏好的对数似然。我们将这种方法称为 Kahneman-Tversky 优化(KTO),在 1B 到 30B 的规模上,其性能与基于偏好的方法相当或更优。至关重要的是,KTO 不需要偏好数据——对于给定输入,它只需要一个二元信号,表明输出是可取的还是不可取的。这使得它在偏好数据稀缺且昂贵的现实世界中更容易使用。

官方代码可在 ContextualAI/HALOs 中找到。

此训练后方法由 Kashif Rasul、Younes Belkada、Lewis Tunstall、Pablo Vicente 贡献,之后由 Albert Villanova del Moral 进行了重构。

快速入门

本示例演示了如何使用 KTO 方法训练模型。我们使用 Qwen 0.5B 模型 作为基础模型。我们使用来自 KTO Mix 14k 的偏好数据。您可以在以下位置查看该数据集:

以下是用于训练模型的脚本:

# train_kto.py
from datasets import load_dataset
from trl import KTOConfig, KTOTrainer
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/kto-mix-14k", split="train")

training_args = KTOConfig(output_dir="Qwen2-0.5B-KTO")
trainer = KTOTrainer(model=model, args=training_args, processing_class=tokenizer, train_dataset=train_dataset)
trainer.train()

使用以下命令执行该脚本:

torchrun --nproc_per_node 8 train_kto.py

在 8 块 H100 GPU 上分布式训练,大约需要 30 分钟。您可以通过查看奖励曲线来验证训练进度。奖励差值呈上升趋势表明模型正在改进,并随时间推移生成更好的响应。

kto qwen2 reward margin

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

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

<trl-lib/Qwen2-0.5B-KTO>:
The best programming language can vary depending on individual preferences, industry-specific requirements, technical skills, and familiarity with the specific use case or task. Here are some widely-used programming languages that have been noted as popular and widely used:

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

 1 JavaScript: JavaScript is at the heart of the web and can be used for building web applications, APIs, and interactive front-end applications like frameworks like React and Angular. It's similar to C, C++, and F# in syntax structure and is accessible and easy to learn, making it a popular choice for beginners and professionals alike.
 2 Java: Known for its object-oriented programming (OOP) and support for Java 8 and .NET, Java is used for developing enterprise-level software applications, high-performance games, as well as mobile apps, game development, and desktop applications.
 3 C++: Known for its flexibility and scalability, C++ offers comprehensive object-oriented programming and is a popular choice for high-performance computing and other technical fields. It's a powerful platform for building real-world applications and games at scale.
 4 Python: Developed by Guido van Rossum in 1991, Python is a high-level, interpreted, and dynamically typed language known for its simplicity, readability, and versatility.

预期的数据集类型和格式

KTO 需要一个非配对偏好数据集。或者,您也可以提供一个配对偏好数据集(通常简称为偏好数据集)。在这种情况下,训练器会自动将其转换为非配对格式,方法是分离被选中(chosen)和被拒绝(rejected)的回复,并为被选中的补全分配label = True,为被拒绝的补全分配label = False。

KTOTrainer 同时兼容 标准 和 对话 数据集格式。当提供对话数据集时,训练器会自动将聊天模板应用于该数据集。

# Standard format
unpaired_preference_example = {"prompt": "The sky is", "completion": " blue.", "label": True}

# Conversational format
unpaired_preference_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                               "completion": [{"role": "assistant", "content": "It is blue."}],
                               "label": True}

理论上,数据集应至少包含一条被选中的补全和一条被拒绝的补全。不过,一些用户已成功使用仅包含被选中数据或仅包含被拒绝数据的集运行 KTO。如果仅使用被拒绝的数据,建议采用较为保守的学习率。

深入了解 KTO 方法

Kahneman-Tversky 优化(KTO)是一种训练方法,旨在仅使用给定输入的输出是可取的还是不可取的这一二元信号来对齐语言模型,而不是使用偏好/非偏好补全对。该方法借鉴了 Kahneman 和 Tversky 的前景理论,定义了一种人类感知损失(HALO),直接最大化生成的效用,并通过对可取和不可取示例进行非对称加权来反映人类的损失厌恶。

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

预处理和分词

在训练期间,每个样本应包含一个提示(prompt)、一个completion以及一个布尔值label,用于指示该补全是否可取(True)或不可取(False)。有关预期格式的详细信息,请参阅数据集格式。 KTOTrainer 会使用模型的 tokenizer 对每个输入进行分词。

计算损失

KTO 损失函数中使用的 KL 散度项是通过将每个提示词与从批次其他位置抽取的不匹配补全进行配对来估计的。因此,估计 KL 项的损失类型(除 apo_zero_unpaired 外的所有类型)都需要每个设备的训练批次大小大于 1,并采用顺序采样策略,以确保不匹配对在批次内保持稳定。

KTO 中使用的损失( 论文) 中的公式 7)定义如下: LKTO(θ)=E(x,y) ⁣[w(y)(1−v(x,y))] \mathcal{L}_{\mathrm{KTO}}(\theta) = \mathbb{E}_{(x,y)}\!\left[ w(y)\Big(1 - v(x, y)\Big) \right]

其中值 v(x,y) v(x, y) 为 v(x,y)={σ ⁣(β(log⁡πθ(y∣x)πref(y∣x)−KL))if y is desirableσ ⁣(β(KL−log⁡πθ(y∣x)πref(y∣x)))if y is undesirable v(x, y) = \begin{cases} \sigma\!\left(\beta\big(\log\frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)} - \mathrm{KL}\big)\right) & \text{if } y \text{ is desirable} \\ \sigma\!\left(\beta\big(\mathrm{KL} - \log\frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)}\big)\right) & \text{if } y \text{ is undesirable} \end{cases}

此处 x x 是提示词, y y 是补全, πθ \pi_{\theta} 是正在训练的策略模型, πref \pi_{\mathrm{ref}} 是参考模型, σ \sigma 是 sigmoid 函数, β>0 \beta > 0 控制与参考模型的偏差,而 KL \mathrm{KL} 是估计的 KL 散度项。权重 w(y) w(y) 对于期望的补全为 desirable_weight ,对于非期望的补全为 undesirable_weight ,用于抵消期望与非期望示例数量之间的不平衡。

损失类型

loss_type=描述
"kto"(默认)来自 KTO 论文的 KTO 损失。这是一种基于卡尼曼-特沃斯基前景理论的人类感知损失(HALO),它使用估计的 KL 散度项作为参考点,以最大化理想补全的效用并最小化不理想补全的效用。
"apo_zero_unpaired"APO 论文中 APO-zero 损失的无配对变体。它在不估计 KL 散度项的情况下,提高理想补全的似然并降低不理想补全的似然。当您认为理想补全优于模型的默认输出时,请使用此损失。

记录的指标

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

  • global_step:迄今为止已执行的优化器步数总数。
  • epoch:当前 epoch 编号,基于数据集迭代。
  • num_tokens:迄今为止处理的 token 总数。
  • loss:当前日志记录区间内的平均 KTO 损失。
  • entropy:模型在未屏蔽 token 上的预测 token 分布的平均熵。
  • aux_loss:混合专家(Mixture-of-Experts)模型的负载均衡辅助损失,在乘以 router_aux_loss_coef 并加到总损失之前。仅当模型为 MoE 模型且 router_aux_loss_coef 非零时记录。
  • kl:策略模型与参考模型之间平均估计的 KL 散度,用作 KTO 损失中的参考点。
  • 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:所选完成项与被拒绝完成项之间的平均隐式奖励差值。

自定义

兼容性与约束

当前 KTOTrainer 实现中,部分参数组合被有意限制:

  • 针对 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(训练或评估)或视觉数据集一起使用。
  • 用于估计 KL 散度项的损失类型(除 "apo_zero_unpaired" 外的所有类型)都需要 train_sampling_strategy="sequential",并且每个设备的训练批次大小必须大于 1。

模型初始化

您可以直接将from_pretrained()方法的kwargs传递给KTOConfig。例如,如果您想以不同的精度加载模型,类似于

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct", dtype=torch.bfloat16)

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

from trl import KTOConfig

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

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

使用 PEFT 训练适配器

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

from datasets import load_dataset
from trl import KTOTrainer
from peft import LoraConfig

dataset = load_dataset("trl-lib/kto-mix-14k", split="train")

trainer = KTOTrainer(
    "Qwen/Qwen2-0.5B-Instruct",
    train_dataset=dataset,
    peft_config=LoraConfig(),
)

trainer.train()

您还可以继续训练您的 PeftModel。为此,首先在 KTOTrainer 外部加载一个 PeftModel,然后将其直接传递给 trainer,而不传入 peft_config 参数。

在训练适配器时,由于只学习新参数,通常会使用比全量微调更高的学习率。

使用 KTO 进行工具调用

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

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

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

训练视觉语言模型

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

from trl import KTOConfig, KTOTrainer
from datasets import load_dataset

trainer = KTOTrainer(
    model="Qwen/Qwen2.5-VL-3B-Instruct",
    args=KTOConfig(max_length=None),
    train_dataset=load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", split="train"),
)
trainer.train()

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

KTOConfig(max_length=None, ...)

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

示例脚本

我们提供了一个使用 KTO 方法训练模型的示例脚本。该脚本位于 trl/scripts/kto.py

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

torchrun --nproc_per_node 8 trl/scripts/kto.py \
    --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
    --dataset_name trl-lib/kto-mix-14k \
    --num_train_epochs 1 \
    --output_dir Qwen2-0.5B-KTO

使用技巧

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

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

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

批量大小建议

请使用至少为 4 的每步批大小(per-step batch size),以及介于 16 到 128 之间的有效批大小(effective batch size)。即使有效批大小很大,如果每步批大小设置不当,KTO 中的 KL 估计也会不准确。

学习率建议

每个 beta 取值都有一个可承受的最大学习率,超过该值后训练性能会下降。对于默认设置 beta = 0.1,大多数模型的学习率通常不应超过 1e-6。随着 beta 减小,学习率也应相应降低。总体而言,我们强烈建议将学习率保持在 5e-7 到 5e-6 之间。即使数据集较小,也不建议使用超出此范围的学习率。相反,应增加训练轮数以获得更好的效果。

数据不平衡

的 desirable_weight 和 undesirable_weight 中的 KTOConfig 分别指分配给理想/正样本和不理想/负样本损失的权重。 默认情况下,两者均为 1。但是,如果其中一种样本的数量明显多于另一种,则应提高数量较少类型的权重,使得(desirable_weight ×\times 正样本数量)与(undesirable_weight ×\times 负样本数量)的比例保持在 1:1 到 4:3 之间。

KTOTrainer

类 trl.KTOTrainer

< >

( model: str | PreTrainedModel | PeftModelref_model: transformers.modeling_utils.PreTrainedModel | None = Noneargs: trl.trainer.kto_config.KTOConfig | 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 对应的初始策略,即 KTO 训练开始前的模型状态。
    • 如果提供了该参数,此模型将直接用作参考策略。它不能是 PeftModel。
    • 如果为 None,训练器将自动使用与 model 对应的初始策略,即 KTO 训练开始前的模型状态。
  • args (KTOConfig,可选) — 此训练器的配置。如果为 None,则使用默认配置。
  • data_collator (DataCollator, 可选) — 用于将处理后的 train_dataset 或 eval_dataset 中的元素列表组合成批次的函数。 如果模型是语言模型,则默认为 DataCollatorForUnpairedPreference;如果模型是视觉语言模型,则默认为 DataCollatorForVisionUnpairedPreference。自定义的 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,则不包装模型。

用于 Kahneman-Tversky 优化(KTO)方法的 Trainer。该算法最初在论文 KTO: Model Alignment as Prospect Theoretic Optimization 中提出。此类是 Trainer 类的封装,并继承其所有属性和方法。

示例:

>>> from trl import KTOTrainer
>>> from datasets import load_dataset

>>> dataset = load_dataset("trl-lib/kto-mix-14k", split="train")

>>> trainer = KTOTrainer(
...     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。

KTOConfig

类 trl.KTOConfig

< >

( 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 = Truegradient_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 = 'sequential'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 = 1024pad_to_multiple_of: int | str | None = 'auto'precompute_ref_log_probs: bool = Falseprecompute_ref_batch_size: int | None = Noneloss_type: str = 'kto'beta: float = 0.1desirable_weight: float = 1.0undesirable_weight: float = 1.0activation_offloading: bool = Falsesync_ref_model: bool = Falseref_model_mixup_alpha: float = 0.6ref_model_sync_steps: int = 512 )

控制模型的参数

  • model_init_kwargs (dict[str, Any], 可选) — 用于 from_pretrained 的关键字参数,当 KTOTrainer 的 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 的序列将从右侧截断。 如果为 None,则不应用截断。
  • 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 (str, 可选, 默认为 "kto") — 要使用的损失类型。可能的值包括:
    • "kto":来自 KTO 论文的 KTO 损失。
    • "apo_zero_unpaired":APO论文中 APO-zero 损失的非配对变体。
  • beta (float,可选,默认为 0.1) — 控制与参考模型偏差的参数。β 值越高,与参考模型的偏差越小。
  • desirable_weight (float,可选,默认为 1.0) — 期望损失会乘以该因子,以抵消期望对与非期望对数量不均衡的影响。
  • undesirable_weight (float,可选,默认为 1.0) — 不期望的损失会乘以该因子,以抵消期望对与不期望对数量不均衡的影响。
  • 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。

KTOTrainer 的配置类。

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

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

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

  • logging_steps:默认值为 10,而非 500。
  • gradient_checkpointing:默认值为 True,而非 False。
  • bf16:如果未设置 fp16,则默认值为 True,而不是 False。
  • learning_rate:默认值为 1e-6,而非 5e-5。
  • train_sampling_strategy:默认值为 "sequential",而非 "random"。 用于估计 KL 散度项的损失类型(除 "apo_zero_unpaired" 外的所有类型)都需要顺序采样,因为每个样本的 KL 补全项都是针对固定顺序批次中的相邻样本预先计算的;任何其他采样策略都会破坏这种配对关系。
Update on GitHub