Hugging Face 的 LOGO

Transformers 文档

训练器

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

训练器

Trainer 类为 PyTorch 提供了功能齐全的训练 API，并支持多 GPU/TPU 上的分布式训练，支持 NVIDIA GPU、AMD GPU 的混合精度，以及 PyTorch 的 torch.amp。 Trainer 与 TrainingArguments 类相辅相成，后者提供了多种选项来自定义模型训练方式。 这两个类共同提供了一个完整的训练 API。

Seq2SeqTrainer 和 Seq2SeqTrainingArguments 继承自 Trainer 和 TrainingArguments 类，它们适用于训练摘要或翻译等序列到序列任务的模型。

Trainer 类针对 🤗 Transformers 模型进行了优化，当与其他模型一起使用时可能会出现令人惊讶的行为。当与您自己的模型一起使用时，请确保

  • 您的模型始终返回元组或 ModelOutput 的子类
  • 如果提供了 labels 参数，您的模型可以计算损失，并且该损失作为元组的第一个元素返回（如果您的模型返回元组）
  • 您的模型可以接受多个标签参数（在 TrainingArguments 中使用 label_names 向 Trainer 指示它们的名称），但它们都不能命名为 "label"

Trainer

类 transformers.Trainer

< >

( model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.modules.module.Module, NoneType] = None args: TrainingArguments = None data_collator: typing.Optional[transformers.data.data_collator.DataCollator] = None train_dataset: typing.Union[torch.utils.data.dataset.Dataset, torch.utils.data.dataset.IterableDataset, ForwardRef('datasets.Dataset'), NoneType] = None eval_dataset: typing.Union[torch.utils.data.dataset.Dataset, dict[str, torch.utils.data.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 model_init: typing.Optional[typing.Callable[[], transformers.modeling_utils.PreTrainedModel]] = None compute_loss_func: typing.Optional[typing.Callable] = 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) optimizer_cls_and_kwargs: typing.Optional[tuple[type[torch.optim.optimizer.Optimizer], dict[str, typing.Any]]] = None preprocess_logits_for_metrics: typing.Optional[typing.Callable[[torch.Tensor, torch.Tensor], torch.Tensor]] = None )

参数

  • model (PreTrainedModel 或 torch.nn.Module, 可选) — 用于训练、评估或预测的模型。如果未提供，则必须传入 model_init。

    Trainer 优化为与库提供的 PreTrainedModel 配合使用。您仍然可以使用您自己的定义为 torch.nn.Module 的模型，只要它们与 🤗 Transformers 模型的工作方式相同。
  • args (TrainingArguments, 可选) — 训练参数。如果未提供，将默认使用 TrainingArguments 的基本实例，其中 output_dir 设置为当前目录中名为 tmp_trainer 的目录。
  • data_collator (DataCollator, 可选) — 用于从 train_dataset 或 eval_dataset 元素列表中形成批次的功能。如果未提供 processing_class，则默认使用 default_data_collator()；否则，如果 processing_class 是特征提取器或分词器，则默认使用 DataCollatorWithPadding 的实例。
  • train_dataset (Union[torch.utils.data.Dataset, torch.utils.data.IterableDataset, datasets.Dataset], 可选) — 用于训练的数据集。如果是 Dataset，则会自动删除 model.forward() 方法不接受的列。

    请注意，如果它是带有某些随机化的 torch.utils.data.IterableDataset 并且您正在分布式训练，则您的可迭代数据集应使用内部属性 generator，该属性是用于随机化的 torch.Generator，在所有进程上必须相同（训练器将在每个 epoch 手动设置此 generator 的种子），或者具有一个 set_epoch() 方法，该方法在内部设置使用的 RNG 的种子。

  • eval_dataset (Union[torch.utils.data.Dataset, dict[str, torch.utils.data.Dataset, datasets.Dataset]), 可选) — 用于评估的数据集。如果是 Dataset，则会自动删除 model.forward() 方法不接受的列。如果是一个字典，它将对每个数据集进行评估，并将字典键添加到指标名称之前。
  • processing_class (PreTrainedTokenizerBase 或 BaseImageProcessor 或 FeatureExtractionMixin 或 ProcessorMixin, 可选) — 用于处理数据的处理类。如果提供，将用于自动处理模型的输入，并将与模型一起保存，以便于重新运行中断的训练或重新使用微调后的模型。这取代了现在已弃用的 tokenizer 参数。
  • model_init (Callable[[], PreTrainedModel], 可选) — 实例化要使用的模型的功能。如果提供，每次调用 train() 都将从此函数给定的模型新实例开始。

    该函数可以没有参数，也可以有一个参数，包含 optuna/Ray Tune/SigOpt 试验对象，以便根据超参数（例如层数、内部层大小、dropout 概率等）选择不同的架构。

  • compute_loss_func (Callable, 可选) — 一个函数，它接受原始模型输出、标签以及整个累积批次（batch_size * 梯度累积步数）中的项目数量，并返回损失。例如，请参见 Trainer 使用的默认损失函数。
  • compute_metrics (Callable[[EvalPrediction], Dict], 可选) — 将用于计算评估指标的函数。必须接受 EvalPrediction 并返回一个从字符串到度量值的字典。注意：当传递 batch_eval_metrics 设置为 True 的 TrainingArgs 时，您的 compute_metrics 函数必须接受一个布尔 compute_result 参数。这将在最后一个评估批次之后触发，以指示该函数需要计算并返回全局汇总统计信息，而不是累积批次级别的统计信息。
  • callbacks (List of TrainerCallback, 可选) — 回调列表，用于自定义训练循环。将添加到 此处 详细描述的默认回调列表中。

    如果您想删除使用的默认回调之一，请使用 Trainer.remove_callback() 方法。

  • optimizers (tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR], 可选, 默认为 (None, None)) — 包含要使用的优化器和调度器的元组。如果未提供，将默认使用模型上的 AdamW 实例和由 args 控制的 get_linear_schedule_with_warmup() 给出的调度器。
  • optimizer_cls_and_kwargs (tuple[Type[torch.optim.Optimizer], dict[str, Any]], 可选) — 包含优化器类和要使用的关键字参数的元组。它会覆盖 args 中的 optim 和 optim_args。与 optimizers 参数不兼容。

    与 optimizers 不同，此参数避免了在初始化 Trainer 之前将模型参数放置在正确设备上的需要。

  • preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor], 可选) — 一个函数，用于在每个评估步骤缓存 logits 之前对其进行预处理。必须接受两个张量，即 logits 和标签，并返回处理后的 logits。此函数所做的修改将反映在 compute_metrics 接收到的预测中。

    请注意，如果数据集中没有标签，则标签（第二个参数）将为 None。

Trainer 是一个简单但功能齐全的 PyTorch 训练和评估循环，针对 🤗 Transformers 进行了优化。

重要属性

  • model — 始终指向核心模型。如果使用 transformers 模型，它将是 PreTrainedModel 子类。
  • model_wrapped — 如果一个或多个其他模块包装了原始模型，则始终指向最外部的模型。这是应该用于前向传播的模型。例如，在 DeepSpeed 下，内部模型被包装在 DeepSpeed 中，然后再次包装在 torch.nn.DistributedDataParallel 中。如果内部模型未被包装，则 self.model_wrapped 与 self.model 相同。
  • is_model_parallel — 模型是否已切换到模型并行模式（与数据并行不同，这意味着一些模型层分布在不同的 GPU 上）。
  • place_model_on_device — 是否自动将模型放置在设备上——如果使用模型并行或 deepspeed，或者如果默认的 TrainingArguments.place_model_on_device 被覆盖为返回 False，则将其设置为 False。
  • is_in_train — 模型当前是否正在运行 train（例如，当在 train 中调用 evaluate 时）

添加回调

< >

( callback )

参数

  • callback (type 或 [`~transformers.TrainerCallback]`) — 一个 TrainerCallback 类或 TrainerCallback 的实例。在第一种情况下，将实例化该类的一个成员。

将回调添加到当前 TrainerCallback 列表中。

autocast_smart_context_manager

< >

( cache_enabled: typing.Optional[bool] = True )

一个辅助包装器，用于根据情况创建适当的 autocast 上下文管理器，并向其提供所需的参数。

计算损失

< >

( model: Module inputs: dict return_outputs: bool = False num_items_in_batch: typing.Optional[torch.Tensor] = None )

参数

  • model (nn.Module) — 用于计算损失的模型。
  • inputs (dict[str, Union[torch.Tensor, Any]]) — 模型的输入数据。
  • return_outputs (bool, 可选, 默认为 False) — 是否返回模型输出以及损失。
  • num_items_in_batch (Optional[torch.Tensor], 可选) — 批次中的项目数。如果未传递 num_items_in_batch，

Trainer 计算损失的方式。默认情况下，所有模型都在第一个元素中返回损失。

为了自定义行为，请继承并覆盖此方法。如果您在计算损失时不使用 num_items_in_batch，请确保将 self.model_accepts_loss_kwargs 设置为 False。否则，在执行梯度累积时，损失计算可能会略微不准确。

compute_loss_context_manager

< >

( )

用于将上下文管理器分组的辅助包装器。

创建模型卡片

< >

( language: typing.Optional[str] = None license: typing.Optional[str] = None tags: typing.Union[str, list[str], NoneType] = None model_name: typing.Optional[str] = None finetuned_from: typing.Optional[str] = None tasks: typing.Union[str, list[str], NoneType] = None dataset_tags: typing.Union[str, list[str], NoneType] = None dataset: typing.Union[str, list[str], NoneType] = None dataset_args: typing.Union[str, list[str], NoneType] = None )

参数

  • language (str, 可选) — 模型语言（如果适用）
  • license (str, 可选) — 模型的许可。如果提供给 Trainer 的原始模型来自 Hub 上的存储库，则默认使用预训练模型的许可。
  • tags (str 或 list[str], 可选) — 要包含在模型卡片元数据中的标签。
  • model_name (str, 可选) — 模型名称。
  • finetuned_from (str, 可选) — 用于微调此模型的模型名称（如果适用）。如果提供给 Trainer 的原始模型来自 Hub，则默认使用该模型的存储库名称。
  • tasks (str 或 list[str], 可选) — 一个或多个任务标识符，将包含在模型卡片的元数据中。
  • dataset_tags (str 或 list[str], 可选) — 一个或多个数据集标签，将包含在模型卡片元数据中。
  • dataset (str 或 list[str], 可选) — 一个或多个数据集标识符，将包含在模型卡片元数据中。
  • dataset_args (str 或 list[str], 可选) — 一个或多个数据集参数，将包含在模型卡片元数据中。

使用 Trainer 可用的信息创建模型卡片的草稿。

创建优化器

< >

( )

设置优化器。

我们提供了一个合理的默认值，效果很好。如果您想使用其他东西，可以通过 optimizers 在 Trainer 的初始化中传入一个元组，或者在子类中继承并覆盖此方法。

创建优化器和调度器

< >

( num_training_steps: int )

设置优化器和学习率调度器。

我们提供了一个合理的默认值，效果很好。如果您想使用其他东西，可以通过 optimizers 在 Trainer 的初始化中传入一个元组，或者在子类中继承并覆盖此方法（或 create_optimizer 和/或 create_scheduler）。

创建调度器

< >

( num_training_steps: int optimizer: Optimizer = None )

参数

  • num_training_steps (int) — 要执行的训练步数。

设置调度器。训练器的优化器必须在此方法调用之前或作为参数传入之前已设置。

评估

< >

( eval_dataset: typing.Union[torch.utils.data.dataset.Dataset, dict[str, torch.utils.data.dataset.Dataset], NoneType] = None ignore_keys: typing.Optional[list[str]] = None metric_key_prefix: str = 'eval' )

参数

  • eval_dataset (Union[Dataset, dict[str, Dataset]), 可选) — 如果您希望覆盖 self.eval_dataset，请传递一个数据集。如果它是 Dataset，则会自动删除 model.forward() 方法不接受的列。如果它是一个字典，它将对每个数据集进行评估，并将字典键添加到指标名称之前。数据集必须实现 __len__ 方法。

    如果您传入一个以数据集名称为键、以数据集为值的字典，则评估将在每个数据集上独立运行。这对于监控训练如何影响其他数据集或仅获得更细粒度的评估非常有用。当与 load_best_model_at_end 一起使用时，请确保 metric_for_best_model 精确引用其中一个数据集。例如，如果您为两个数据集 data1 和 data2 传入 {"data1": data1, "data2": data2}，则可以指定 metric_for_best_model="eval_data1_loss" 以使用 data1 上的损失，或 metric_for_best_model="eval_data2_loss" 以使用 data2 上的损失。
  • ignore_keys (list[str], 可选) — 模型输出（如果是字典）中应在收集预测时忽略的键列表。
  • metric_key_prefix (str, 可选, 默认为 "eval") — 可选前缀，用作度量键前缀。例如，如果前缀为“eval”（默认），则度量“bleu”将被命名为“eval_bleu”

运行评估并返回指标。

调用脚本将负责提供计算指标的方法，因为它们是任务相关的（将其传递给 init compute_metrics 参数）。

您也可以继承并覆盖此方法以注入自定义行为。

evaluation_loop

< >

( dataloader: DataLoader description: str prediction_loss_only: typing.Optional[bool] = None ignore_keys: typing.Optional[list[str]] = None metric_key_prefix: str = 'eval' )

预测/评估循环，由 Trainer.evaluate() 和 Trainer.predict() 共享。

无论有无标签均可工作。

浮点运算

< >

( inputs: dict ) → int

参数

  • inputs (dict[str, Union[torch.Tensor, Any]]) — 模型的输入和目标。

返回

int

浮点运算次数。

对于继承自 PreTrainedModel 的模型，使用该方法计算每次反向传播和前向传播的浮点运算次数。如果使用其他模型，请在该模型中实现该方法或子类化并重写此方法。

get_batch_samples

< >

( epoch_iterator: Iterator num_batches: int device: device )

从 epoch 迭代器中收集指定数量的批次，并可选地计算批次中的项目数以正确地缩放损失。

get_decay_parameter_names

< >

( model )

获取所有将应用权重衰减的参数名称。

此函数通过两种方式过滤参数：

  1. 按层类型（ALL_LAYERNORM_LAYERS 中指定的层实例）
  2. 按参数名称模式（包含“bias”或“norm”的变体）

get_eval_dataloader

< >

( eval_dataset: typing.Union[str, torch.utils.data.dataset.Dataset, NoneType] = None )

参数

  • eval_dataset (str 或 torch.utils.data.Dataset, 可选) — 如果是 str，将使用 self.eval_dataset[eval_dataset] 作为评估数据集。如果是 Dataset，将覆盖 self.eval_dataset 并且必须实现 __len__。如果是 Dataset，则会自动移除 model.forward() 方法不接受的列。

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

如果想注入自定义行为，请子类化并重写此方法。

get_learning_rates

< >

( )

从 self.optimizer 中返回每个参数的学习率。

get_num_trainable_parameters

< >

( )

获取可训练参数的数量。

get_optimizer_cls_and_kwargs

< >

( args: TrainingArguments model: typing.Optional[transformers.modeling_utils.PreTrainedModel] = None )

参数

  • args (transformers.training_args.TrainingArguments) — 训练会话的训练参数。

根据训练参数返回优化器类和优化器参数。

get_optimizer_group

< >

( param: typing.Union[str, torch.nn.parameter.Parameter, NoneType] = None )

参数

  • param (str 或 torch.nn.parameter.Parameter, 可选) — 需要返回优化器组的参数。

如果给定参数，返回该参数的优化器组，否则返回所有参数的优化器组。

get_test_dataloader

< >

( test_dataset: Dataset )

参数

  • test_dataset (torch.utils.data.Dataset, 可选) — 要使用的测试数据集。如果是 Dataset，则会自动移除 model.forward() 方法不接受的列。必须实现 __len__。

返回测试 ~torch.utils.data.DataLoader。

如果想注入自定义行为，请子类化并重写此方法。

get_total_train_batch_size

< >

( args )

计算总批次大小（微批次 * 梯度累积 * 分布式并行世界大小）。

注意：仅考虑数据并行和张量并行（dp_world_size = world_size // tp_size）。

get_tp_size

< >

( )

从模型或 DeepSpeed 配置中获取张量并行大小。

get_train_dataloader

< >

( )

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

如果 train_dataset 未实现 __len__，则不使用采样器；否则使用随机采样器（如果需要，适应分布式训练）。

如果想注入自定义行为，请子类化并重写此方法。

hyperparameter_search

< >

( hp_space: typing.Optional[typing.Callable[[ForwardRef('optuna.Trial')], dict[str, float]]] = None compute_objective: typing.Optional[typing.Callable[[dict[str, float]], float]] = None n_trials: int = 20 direction: typing.Union[str, list[str]] = 'minimize' backend: typing.Union[ForwardRef('str'), transformers.trainer_utils.HPSearchBackend, NoneType] = None hp_name: typing.Optional[typing.Callable[[ForwardRef('optuna.Trial')], str]] = None **kwargs ) → [trainer_utils.BestRun 或 list[trainer_utils.BestRun]]

参数

  • hp_space (Callable[["optuna.Trial"], dict[str, float]], 可选) — 定义超参数搜索空间的函数。默认值取决于您的后端，可以是 default_hp_space_optuna()、default_hp_space_ray() 或 default_hp_space_sigopt()。
  • compute_objective (Callable[[dict[str, float]], float], 可选) — 一个函数，根据 evaluate 方法返回的指标计算要最小化或最大化的目标。默认值为 default_compute_objective()。
  • n_trials (int, 可选, 默认为 100) — 要测试的试运行次数。
  • direction (str 或 list[str], 可选, 默认为 "minimize") — 如果是单目标优化，方向为 str，可以是 "minimize" 或 "maximize"，优化验证损失时应选择 "minimize"，优化一个或多个指标时应选择 "maximize"。如果是多目标优化，方向为 list[str]，可以是 "minimize" 和 "maximize" 的列表，优化验证损失时应选择 "minimize"，优化一个或多个指标时应选择 "maximize"。
  • backend (str 或 ~training_utils.HPSearchBackend, 可选) — 用于超参数搜索的后端。默认值为 optuna、Ray Tune 或 SigOpt，具体取决于安装了哪个。如果全部安装，则默认为 optuna。
  • hp_name (Callable[["optuna.Trial"], str]], 可选) — 定义试验/运行名称的函数。默认值为 None。
  • kwargs (dict[str, Any], 可选) — 每个后端的附加关键字参数：

返回

[trainer_utils.BestRun 或 list[trainer_utils.BestRun]]

关于多目标优化的最佳运行或最佳运行的所有信息。实验摘要可在 Ray 后端的 run_summary 属性中找到。

使用 optuna 或 Ray Tune 或 SigOpt 启动超参数搜索。优化量由 compute_objective 决定，如果未提供指标，则默认为返回评估损失的函数，否则为所有指标的总和。

要使用此方法，您需要在初始化 Trainer 时提供 model_init：我们需要在每次新运行时重新初始化模型。这与 optimizers 参数不兼容，因此您需要子类化 Trainer 并重写 create_optimizer_and_scheduler() 方法以实现自定义优化器/调度器。

init_hf_repo

< >

( token: typing.Optional[str] = None )

在 self.args.hub_model_id 中初始化一个 git 仓库。

is_local_process_zero

< >

( )

此进程是否为本地（例如，如果在多台机器上分布式训练，则为一台机器上）主进程。

is_world_process_zero

< >

( )

此进程是否为全局主进程（当在多台机器上分布式训练时，这仅对一个进程为 True）。

log

< >

( logs: dict start_time: typing.Optional[float] = None )

参数

  • logs (dict[str, float]) — 要记录的值。
  • start_time (Optional[float]) — 训练开始时间。

在各种监听训练的对象上记录 logs。

子类化并重写此方法以注入自定义行为。

log_metrics

< >

( split metrics )

参数

  • split (str) — 模式/分割名称：train、eval、test 之一
  • metrics (dict[str, float]) — 从训练/评估/预测返回的指标：指标字典

以特殊格式记录指标。

在分布式环境中，这只对秩为 0 的进程执行。

内存报告注意事项

要获取内存使用报告，您需要安装 psutil。您可以使用 pip install psutil 进行安装。

现在，当此方法运行时，您将看到一个报告，其中包含

init_mem_cpu_alloc_delta   =     1301MB
init_mem_cpu_peaked_delta  =      154MB
init_mem_gpu_alloc_delta   =      230MB
init_mem_gpu_peaked_delta  =        0MB
train_mem_cpu_alloc_delta  =     1345MB
train_mem_cpu_peaked_delta =        0MB
train_mem_gpu_alloc_delta  =      693MB
train_mem_gpu_peaked_delta =        7MB

理解报告

  • 第一部分，例如 train__，告诉您指标所属的阶段。以 init_ 开头的报告将添加到第一个运行阶段。因此，如果只运行评估，则 __init__ 的内存使用量将与 eval_ 指标一起报告。
  • 第三部分是 cpu 或 gpu，告诉您是通用 RAM 还是 gpu0 内存指标。
  • *_alloc_delta - 是阶段结束和开始之间已用/分配内存计数器的差异 - 如果函数释放的内存多于分配的内存，则可能为负。
  • *_peaked_delta - 是任何额外消耗然后释放的内存 - 相对于当前分配的内存计数器 - 它永远不会是负数。当您查看任何阶段的指标时，将 alloc_delta + peaked_delta 相加，您就知道完成该阶段需要多少内存。

报告仅针对秩为 0 的进程和 GPU 0（如果有 GPU）进行。通常这已足够，因为主进程执行了大部分工作，但如果使用了模型并行，则其他 GPU 可能使用不同的 GPU 内存量，这时可能就不够了。在 DataParallel 下也不同，其中 gpu0 可能需要比其余 GPU 多得多的内存，因为它存储了所有参与 GPU 的梯度和优化器状态。也许将来这些报告也会发展到测量这些方面。

CPU RAM 指标测量 RSS（Resident Set Size），包括进程独有的内存和与其他进程共享的内存。需要注意的是，它不包括交换出去的内存，因此报告可能不精确。

CPU 峰值内存使用采样线程测量。由于 Python 的 GIL，如果该线程在最高内存使用时没有机会运行，它可能会错过一些峰值内存。因此，此报告可能低于实际值。使用 tracemalloc 将报告精确的峰值内存，但它不报告 Python 之外的内存分配。因此，如果某些 C++ CUDA 扩展分配了自己的内存，则不会报告。因此，它被放弃，转而使用内存采样方法，该方法读取当前进程的内存使用情况。

GPU 已分配和峰值内存报告通过 torch.cuda.memory_allocated() 和 torch.cuda.max_memory_allocated() 完成。此指标仅报告 PyTorch 特定分配的“增量”，因为 torch.cuda 内存管理系统不跟踪 PyTorch 之外的任何已分配内存。例如，第一个 CUDA 调用通常会加载 CUDA 内核，这可能占用 0.5 到 2GB 的 GPU 内存。

请注意，此跟踪器不计算 Trainer 的 __init__、train、evaluate 和 predict 调用之外的内存分配。

由于评估调用可能在训练期间发生，我们无法处理嵌套调用，因为 torch.cuda.max_memory_allocated 是一个单一计数器，因此如果它被嵌套的评估调用重置，训练的跟踪器将报告不正确的信息。如果此 PyTorch 问题 得到解决，则此类别将能够重新进入。在此之前，我们只会跟踪 train、evaluate 和 predict 方法的外部级别。这意味着如果在训练期间调用评估，则后者将计算其内存使用量以及前者的内存使用量。

这也意味着，如果与 Trainer 一起使用的任何其他工具调用 torch.cuda.reset_peak_memory_stats，则 GPU 峰值内存统计信息可能无效。并且 Trainer 将干扰依赖于自身调用 torch.cuda.reset_peak_memory_stats 的任何此类工具的正常行为。

为了获得最佳性能，您可能需要考虑在生产运行中关闭内存分析。

metrics_format

< >

( metrics: dict ) → metrics (dict[str, float])

参数

  • metrics (dict[str, float]) — 从训练/评估/预测返回的指标

返回

指标 (dict[str, float])

重新格式化的指标

将训练器指标值重新格式化为人类可读的格式。

num_examples

< >

( dataloader: DataLoader )

辅助函数，通过访问 DataLoader 的数据集来获取其中的样本数量。当 dataloader.dataset 不存在或没有长度时，尽力估计。

num_tokens

< >

( train_dl: DataLoader max_steps: typing.Optional[int] = None )

辅助函数，通过枚举数据加载器来获取 ~torch.utils.data.DataLoader 中的 token 数量。

pop_callback

< >

( callback ) → TrainerCallback

参数

  • callback (type 或 [`~transformers.TrainerCallback]) — 一个 TrainerCallback 类或 TrainerCallback 的实例。在第一种情况下，将弹出在回调列表中找到的该类的第一个成员。

返回

TrainerCallback

移除的回调，如果找到。

从当前 TrainerCallback 列表中移除回调并返回它。

如果找不到回调，则返回 None（并且不引发错误）。

predict

< >

( test_dataset: Dataset ignore_keys: typing.Optional[list[str]] = None metric_key_prefix: str = 'test' )

参数

  • test_dataset (Dataset) — 要运行预测的数据集。如果它是 datasets.Dataset，则会自动移除 model.forward() 方法不接受的列。必须实现 __len__。
  • ignore_keys (list[str], 可选) — 模型输出（如果是字典）中应在收集预测时忽略的键列表。
  • metric_key_prefix (str, 可选, 默认为 "test") — 用作指标键前缀的可选前缀。例如，如果前缀是“test”（默认值），则指标“bleu”将命名为“test_bleu”。

运行预测并返回预测和潜在指标。

根据数据集和您的用例，您的测试数据集可能包含标签。在这种情况下，此方法也将返回指标，就像在 evaluate() 中一样。

如果您的预测或标签具有不同的序列长度（例如，因为您在 token 分类任务中进行动态填充），则预测将被填充（在右侧）以允许连接成一个数组。填充索引为 -100。

返回：NamedTuple 具有以下键的命名元组

  • predictions (np.ndarray)：对 test_dataset 的预测。
  • label_ids (np.ndarray, 可选)：标签（如果数据集包含）。
  • metrics (dict[str, float], 可选)：潜在的指标字典（如果数据集包含标签）。

prediction_loop

< >

( dataloader: DataLoader description: str prediction_loss_only: typing.Optional[bool] = None ignore_keys: typing.Optional[list[str]] = None metric_key_prefix: str = 'eval' )

预测/评估循环，由 Trainer.evaluate() 和 Trainer.predict() 共享。

无论有无标签均可工作。

prediction_step

< >

( model: Module inputs: dict prediction_loss_only: bool ignore_keys: typing.Optional[list[str]] = None ) → tuple[Optional[torch.Tensor], Optional[torch.Tensor], Optional[torch.Tensor]]

参数

  • model (nn.Module) — 要评估的模型。
  • 字典将在输入到模型之前解包。大多数模型期望在 `labels` 参数下找到目标。请查阅模型的文档以了解所有接受的参数。
  • prediction_loss_only (bool) — 是否仅返回损失。
  • ignore_keys (list[str], 可选) — 模型输出中（如果为字典）应在收集预测时忽略的键列表。

返回

tuple[Optional[torch.Tensor], Optional[torch.Tensor], Optional[torch.Tensor]]

包含损失、logits和标签的元组（每个都是可选的）。

使用 `inputs` 对 `model` 执行评估步骤。

子类并重写以注入自定义行为。

propagate_args_to_deepspeed

< >

( auto_find_batch_size = False )

根据 Trainer 参数设置 deepspeed 插件中的值

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], 可选) — 传递给 `create_model_card()` 的额外关键字参数。

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

remove_callback

< >

( callback )

参数

  • callback (type 或 [`~transformers.TrainerCallback`]) — 一个 TrainerCallback 类或 TrainerCallback 的实例。在前一种情况下，将移除在回调列表中找到的该类的第一个成员。

从当前的 `TrainerCallback` 列表中移除一个回调。

save_metrics

< >

( split metrics combined = True )

参数

  • split (str) — 模式/分割名称：`train`、`eval`、`test`、`all` 中的一个
  • metrics (dict[str, float]) — 训练/评估/预测返回的指标
  • combined (bool, 可选, 默认为 True) — 通过使用此调用的指标更新 `all_results.json` 来创建组合指标

将指标保存到该分割的 JSON 文件中，例如 `train_results.json`。

在分布式环境中，这只对秩为 0 的进程执行。

要了解指标，请阅读 `log_metrics()` 的文档字符串。唯一的区别是原始未格式化的数字保存在当前方法中。

save_model

< >

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

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

仅从主进程保存。

save_state

< >

( )

保存 Trainer 状态，因为 Trainer.save_model 只保存分词器和模型。

在分布式环境中，这只对秩为 0 的进程执行。

set_initial_training_values

< >

( args: TrainingArguments dataloader: DataLoader total_train_batch_size: int )

计算并返回以下值

  • 训练周期数
  • num_update_steps_per_epoch
  • num_examples
  • num_train_samples
  • epoch_based
  • len_dataloader
  • max_steps

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], 可选) — 用于隐藏已弃用参数的额外关键字参数

主训练入口点。

training_step

< >

( model: Module inputs: dict num_items_in_batch: typing.Optional[torch.Tensor] = None ) → torch.Tensor

参数

  • model (nn.Module) — 要训练的模型。
  • 字典将在输入到模型之前解包。大多数模型期望在 `labels` 参数下找到目标。请查阅模型的文档以了解所有接受的参数。

返回

torch.Tensor

此批次的训练损失张量。

对一批输入执行训练步骤。

子类并重写以注入自定义行为。

Seq2SeqTrainer

class transformers.Seq2SeqTrainer

< >

( model: typing.Union[ForwardRef('PreTrainedModel'), torch.nn.modules.module.Module] = None args: TrainingArguments = None data_collator: typing.Optional[ForwardRef('DataCollator')] = None train_dataset: typing.Union[torch.utils.data.dataset.Dataset, ForwardRef('IterableDataset'), ForwardRef('datasets.Dataset'), NoneType] = None eval_dataset: typing.Union[torch.utils.data.dataset.Dataset, dict[str, torch.utils.data.dataset.Dataset], NoneType] = None processing_class: typing.Union[ForwardRef('PreTrainedTokenizerBase'), ForwardRef('BaseImageProcessor'), ForwardRef('FeatureExtractionMixin'), ForwardRef('ProcessorMixin'), NoneType] = None model_init: typing.Optional[typing.Callable[[], ForwardRef('PreTrainedModel')]] = None compute_loss_func: typing.Optional[typing.Callable] = None compute_metrics: typing.Optional[typing.Callable[[ForwardRef('EvalPrediction')], dict]] = None callbacks: typing.Optional[list['TrainerCallback']] = None optimizers: tuple = (None, None) preprocess_logits_for_metrics: typing.Optional[typing.Callable[[torch.Tensor, torch.Tensor], torch.Tensor]] = None )

评估

< >

( eval_dataset: typing.Optional[torch.utils.data.dataset.Dataset] = None ignore_keys: typing.Optional[list[str]] = None metric_key_prefix: str = 'eval' **gen_kwargs )

参数

  • eval_dataset (Dataset, 可选) — 如果您希望覆盖 `self.eval_dataset`，请传递数据集。如果它是 `Dataset`，则 `model.forward()` 方法不接受的列将自动移除。它必须实现 `__len__` 方法。
  • ignore_keys (list[str], 可选) — 模型输出中（如果为字典）应在收集预测时忽略的键列表。
  • metric_key_prefix (str, 可选, 默认为 "eval") — 一个可选的前缀，用作指标键的前缀。例如，如果前缀是 `"eval"`（默认），指标“bleu”将被命名为“eval_bleu”
  • max_length (int, 可选) — 使用生成方法预测时使用的最大目标长度。
  • num_beams (int, 可选) — 使用生成方法预测时使用的束搜索的束数量。1表示没有束搜索。
  • gen_kwargs — 额外与 `generate` 相关的关键字参数。

运行评估并返回指标。

调用脚本将负责提供计算指标的方法，因为它们是任务相关的（将其传递给 init compute_metrics 参数）。

您也可以继承并覆盖此方法以注入自定义行为。

predict

< >

( test_dataset: Dataset ignore_keys: typing.Optional[list[str]] = None metric_key_prefix: str = 'test' **gen_kwargs )

参数

  • test_dataset (Dataset) — 用于运行预测的数据集。如果它是 `Dataset`，则 `model.forward()` 方法不接受的列将自动移除。它必须实现 `__len__` 方法。
  • ignore_keys (list[str], 可选) — 模型输出中（如果为字典）应在收集预测时忽略的键列表。
  • metric_key_prefix (str, 可选, 默认为 "eval") — 一个可选的前缀，用作指标键的前缀。例如，如果前缀是 ` "eval"`（默认），指标“bleu”将被命名为“eval_bleu”
  • max_length (int, 可选) — 使用生成方法预测时使用的最大目标长度。
  • num_beams (int, 可选) — 使用生成方法预测时使用的束搜索的束数量。1表示没有束搜索。
  • gen_kwargs — 额外与 `generate` 相关的关键字参数。

运行预测并返回预测和潜在指标。

根据数据集和您的用例，您的测试数据集可能包含标签。在这种情况下，此方法也将返回指标，就像在 evaluate() 中一样。

如果您的预测或标签具有不同的序列长度（例如，因为您在令牌分类任务中进行动态填充），则预测将被填充（在右侧）以允许连接成一个数组。填充索引为 -100。

返回：NamedTuple 具有以下键的命名元组

  • predictions (np.ndarray)：对 test_dataset 的预测。
  • label_ids (np.ndarray, 可选)：标签（如果数据集包含）。
  • metrics (dict[str, float], 可选)：潜在的指标字典（如果数据集包含标签）。

TrainingArguments

class transformers.TrainingArguments

< >

( 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-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: 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 = 500 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: 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: 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] = False )

参数

  • output_dir (str, 可选, 默认为 "trainer_output") — 模型预测和检查点将写入的输出目录。
  • overwrite_output_dir (bool, 可选, 默认为 False) — 如果为 True，则覆盖输出目录的内容。如果 output_dir 指向检查点目录，则使用此选项继续训练。
  • do_train (bool, 可选, 默认为 False) — 是否运行训练。此参数未由 Trainer 直接使用，它旨在由您的训练/评估脚本使用。有关更多详细信息，请参阅示例脚本。
  • do_eval (bool, 可选) — 是否在验证集上运行评估。如果 eval_strategy 与 "no" 不同，则将设置为 True。此参数未由 Trainer 直接使用，它旨在由您的训练/评估脚本使用。有关更多详细信息，请参阅示例脚本。
  • do_predict (bool, 可选, 默认为 False) — 是否在测试集上运行预测。此参数未由 Trainer 直接使用，它旨在由您的训练/评估脚本使用。有关更多详细信息，请参阅示例脚本。
  • eval_strategy (str 或 IntervalStrategy, 可选, 默认为 "no") — 训练期间采用的评估策略。可能的值为：

    • "no"：训练期间不进行评估。
    • "steps"：每 eval_steps 步进行评估（并记录）。
    • "epoch"：在每个 epoch 结束时进行评估。
  • prediction_loss_only (bool, 可选, 默认为 False) — 在执行评估和生成预测时，只返回损失。
  • per_device_train_batch_size (int, 可选, 默认为 8) — 每个设备加速器核心/CPU 用于训练的批处理大小。
  • per_device_eval_batch_size (int, 可选, 默认为 8) — 每个设备加速器核心/CPU 用于评估的批处理大小。
  • gradient_accumulation_steps (int, 可选, 默认为 1) — 在执行反向/更新传递之前，用于累积梯度的更新步数。

    当使用梯度累积时，一步被计为一个带有反向传递的步骤。因此，日志记录、评估、保存将在每 gradient_accumulation_steps * xxx_step 训练样本后进行。
  • eval_accumulation_steps (int, 可选) — 在将结果移动到 CPU 之前，用于累积输出张量的预测步数。如果未设置，则整个预测将在设备加速器上累积，然后才移动到 CPU（速度更快但需要更多内存）。
  • eval_delay (float, 可选) — 在执行第一次评估之前需要等待的 epoch 或步数，具体取决于 eval_strategy。
  • torch_empty_cache_steps (int, 可选) — 在调用 torch.<device>.empty_cache() 之前等待的步数。如果未设置或设置为 None，则不会清空缓存。

    这可以通过降低峰值 VRAM 使用量来避免 CUDA 内存不足错误，但代价是性能大约降低 10%。
  • learning_rate (float, 可选, 默认为 5e-5) — AdamW 优化器的初始学习率。
  • weight_decay (float, 可选, 默认为 0) — 对 AdamW 优化器中除所有偏差和 LayerNorm 权重之外的所有层应用的权重衰减（如果不为零）。
  • adam_beta1 (float, 可选, 默认为 0.9) — AdamW 优化器的 beta1 超参数。
  • adam_beta2 (float, 可选, 默认为 0.999) — AdamW 优化器的 beta2 超参数。
  • adam_epsilon (float, 可选, 默认为 1e-8) — AdamW 优化器的 epsilon 超参数。
  • max_grad_norm (float, 可选, 默认为 1.0) — 最大梯度范数（用于梯度裁剪）。
  • num_train_epochs (float, 可选, 默认为 3.0) — 要执行的训练 epoch 总数（如果不是整数，则在停止训练前执行最后一个 epoch 的小数部分百分比）。
  • max_steps (int, 可选, 默认为 -1) — 如果设置为正数，则为要执行的训练步数总数。它会覆盖 num_train_epochs。对于有限数据集，训练将重复遍历数据集（如果所有数据都已用尽）直到达到 max_steps。
  • lr_scheduler_type (str 或 SchedulerType, 可选, 默认为 "linear") — 要使用的调度器类型。有关所有可能的值，请参阅 SchedulerType 的文档。
  • lr_scheduler_kwargs (dict, 可选, 默认为 {}) — 学习率调度器的额外参数。有关可能的值，请参阅每个调度器的文档。
  • warmup_ratio (float, 可选, 默认为 0.0) — 用于从 0 到 learning_rate 进行线性预热的总训练步数的比例。
  • warmup_steps (int, 可选, 默认为 0) — 用于从 0 到 learning_rate 进行线性预热的步数。覆盖 warmup_ratio 的任何效果。
  • log_level (str, 可选, 默认为 passive) — 在主进程上使用的日志级别。可能的值为字符串形式的日志级别：'debug'、'info'、'warning'、'error' 和 'critical'，以及一个 'passive' 级别，该级别不设置任何内容，并保持 Transformers 库的当前日志级别（默认为 "warning"）。
  • log_level_replica (str, 可选, 默认为 "warning") — 在副本上使用的日志级别。与 log_level 具有相同的选项。
  • log_on_each_node (bool, 可选, 默认为 True) — 在多节点分布式训练中，是每个节点记录一次 log_level，还是仅在主节点记录。
  • logging_dir (str, 可选) — TensorBoard 日志目录。默认为 *output_dir/runs/CURRENT_DATETIME_HOSTNAME*。
  • logging_strategy (str 或 IntervalStrategy, 可选, 默认为 "steps") — 训练期间采用的日志记录策略。可能的值为：

    • "no"：训练期间不进行日志记录。
    • "epoch"：在每个 epoch 结束时进行日志记录。
    • "steps"：每 logging_steps 步进行日志记录。
  • logging_first_step (bool, 可选, 默认为 False) — 是否记录第一个 global_step。
  • logging_steps (int 或 float, 可选, 默认为 500) — 如果 logging_strategy="steps"，则两次日志记录之间的更新步数。应该是整数或范围 [0,1) 中的浮点数。如果小于 1，则将被解释为总训练步数的比例。
  • logging_nan_inf_filter (bool, 可选, 默认为 True) — 是否过滤 nan 和 inf 损失以进行日志记录。如果设置为 True，则每个 nan 或 inf 的步骤损失将被过滤，并改为采用当前日志记录窗口的平均损失。

    logging_nan_inf_filter 只影响损失值的日志记录，它不改变梯度计算或应用于模型的行为。
  • save_strategy (str 或 SaveStrategy, 可选, 默认为 "steps") — 训练期间采用的检查点保存策略。可能的值为：

    • "no"：训练期间不进行保存。
    • "epoch"：在每个 epoch 结束时进行保存。
    • "steps"：每 save_steps 步进行保存。
    • "best"：当达到新的 best_metric 时进行保存。

    如果选择 "epoch" 或 "steps"，训练结束时也总是会执行保存。

  • save_steps (int 或 float, 可选, 默认为 500) — 如果 save_strategy="steps"，则两次检查点保存之间的更新步数。应该是整数或范围 [0,1) 中的浮点数。如果小于 1，则将被解释为总训练步数的比例。
  • save_total_limit (int, 可选) — 如果传入一个值，将限制检查点的总数量。删除 output_dir 中较旧的检查点。当启用 load_best_model_at_end 时，除了最新的检查点外，根据 metric_for_best_model 的“最佳”检查点将始终保留。例如，对于 save_total_limit=5 和 load_best_model_at_end，最后四个检查点将始终与最佳模型一起保留。当 save_total_limit=1 和 load_best_model_at_end 时，可能会保存两个检查点：最后一个和最佳一个（如果它们不同）。
  • save_safetensors (bool, 可选, 默认为 True) — 使用 safetensors 保存和加载状态字典，而不是默认的 torch.load 和 torch.save。
  • save_on_each_node (bool, 可选, 默认为 False) — 在多节点分布式训练时，是否在每个节点上保存模型和检查点，还是只在主节点上保存。

    当不同节点使用相同的存储时，不应激活此选项，因为文件将以相同的名称保存在每个节点上。

  • save_only_model (bool, 可选, 默认为 False) — 在检查点保存时，是只保存模型，还是同时保存优化器、调度器和 rng 状态。请注意，如果设置为 True，则无法从检查点恢复训练。这使您可以通过不存储优化器、调度器和 rng 状态来节省存储空间。只有在此选项设置为 True 时，才能使用 from_pretrained 加载模型。
  • restore_callback_states_from_checkpoint (bool, 可选, 默认为 False) — 是否从检查点恢复回调状态。如果为 True，如果检查点中存在回调，则会覆盖传递给 Trainer 的回调。
  • use_cpu (bool, 可选, 默认为 False) — 是否使用 CPU。如果设置为 False，我们将使用可用的 CUDA 或 MPS 设备。
  • seed (int, 可选, 默认为 42) — 训练开始时将设置的随机种子。为确保跨运行的可重现性，如果模型具有一些随机初始化的参数，请使用 ~Trainer.model_init 函数实例化模型。
  • data_seed (int, 可选) — 用于数据采样器的随机种子。如果未设置，数据采样的随机生成器将使用与 seed 相同的种子。这可用于确保数据采样的可重现性，与模型种子无关。
  • jit_mode_eval (bool, 可选, 默认为 False) — 推断时是否使用 PyTorch jit trace。
  • use_ipex (bool, 可选, 默认为 False) — 在 Intel Extension for PyTorch 可用时使用它。IPEX 安装。
  • bf16 (bool, 可选, 默认为 False) — 是否使用 bf16 16 位（混合）精度训练而非 32 位训练。需要 Ampere 或更高版本的 NVIDIA 架构、Intel XPU 或使用 CPU (use_cpu) 或 Ascend NPU。这是一个实验性 API，可能会发生变化。
  • fp16 (bool, 可选, 默认为 False) — 是否使用 fp16 16 位（混合）精度训练而非 32 位训练。
  • fp16_opt_level (str, 可选, 默认为 ‘O1’) — 对于 fp16 训练，Apex AMP 优化级别选择在 [‘O0’、‘O1’、‘O2’ 和 ‘O3’] 中。详情请参阅 Apex 文档。
  • fp16_backend (str, 可选, 默认为 "auto") — 此参数已弃用。请改用 half_precision_backend。
  • half_precision_backend (str, 可选, 默认为 "auto") — 用于混合精度训练的后端。必须是 "auto"、"apex"、"cpu_amp" 之一。 "auto" 将根据检测到的 PyTorch 版本使用 CPU/CUDA AMP 或 APEX，而其他选项将强制使用请求的后端。
  • bf16_full_eval (bool, 可选, 默认为 False) — 是否使用完整的 bfloat16 评估而不是 32 位。这将更快并节省内存，但可能会损害指标值。这是一个实验性 API，可能会发生变化。
  • fp16_full_eval (bool, 可选, 默认为 False) — 是否使用完整的 float16 评估而不是 32 位。这将更快并节省内存，但可能会损害指标值。
  • tf32 (bool, 可选) — 是否启用 TF32 模式，该模式在 Ampere 及更新的 GPU 架构中可用。默认值取决于 PyTorch 的 torch.backends.cuda.matmul.allow_tf32 的默认版本。更多详情请参阅 TF32 文档。这是一个实验性 API，可能会发生变化。
  • local_rank (int, 可选, 默认为 -1) — 分布式训练过程中进程的等级。
  • ddp_backend (str, 可选) — 用于分布式训练的后端。必须是 "nccl"、"mpi"、"ccl"、"gloo"、"hccl" 之一。
  • tpu_num_cores (int, 可选) — 在 TPU 上训练时，TPU 核心的数量（由启动脚本自动传递）。
  • dataloader_drop_last (bool, 可选, 默认为 False) — 是否丢弃最后一个不完整的批次（如果数据集的长度不能被批次大小整除）。
  • eval_steps (int 或 float, 可选) — 如果 eval_strategy="steps"，则两次评估之间的更新步数。如果未设置，将默认为 logging_steps 的相同值。应为整数或范围 [0,1) 中的浮点数。如果小于 1，将被解释为总训练步数的比例。
  • dataloader_num_workers (int, 可选, 默认为 0) — 用于数据加载的子进程数（仅限 PyTorch）。0 表示数据将在主进程中加载。
  • past_index (int, 可选, 默认为 -1) — 某些模型，如 TransformerXL 或 XLNet，可以利用过去的隐藏状态进行预测。如果此参数设置为正整数，则 Trainer 将使用相应的输出（通常为索引 2）作为过去状态，并在下一个训练步骤中将其作为关键字参数 mems 馈入模型。
  • run_name (str, 可选, 默认为 output_dir) — 运行的描述符。通常用于 wandb、mlflow、comet 和 swanlab 日志记录。如果未指定，将与 output_dir 相同。
  • disable_tqdm (bool, 可选) — 是否禁用 tqdm 进度条以及 Jupyter Notebook 中 ~notebook.NotebookTrainingTracker 生成的指标表。如果日志级别设置为警告或更低（默认），则默认为 True，否则为 False。
  • remove_unused_columns (bool, 可选, 默认为 True) — 是否自动删除模型前向方法未使用的列。
  • label_names (list[str], 可选) — 输入字典中对应标签的键列表。

    最终将默认为模型接受的包含“label”一词的参数名称列表，除非使用的模型是 XxxForQuestionAnswering 之一，在这种情况下，它还将包括 ["start_positions", "end_positions"] 键。

  • load_best_model_at_end (bool, 可选, 默认为 False) — 训练结束时是否加载训练过程中找到的最佳模型。启用此选项后，最佳检查点将始终保存。更多信息请参见 save_total_limit。

    设置为 True 时，参数 save_strategy 需要与 eval_strategy 相同，并且在它是“steps”的情况下，save_steps 必须是 eval_steps 的整数倍。
  • metric_for_best_model (str, 可选) — 与 load_best_model_at_end 结合使用，指定用于比较两个不同模型的指标。必须是评估返回的指标名称，带或不带前缀 "eval_"。

    如果未指定，当 load_best_model_at_end == True 或 lr_scheduler_type == SchedulerType.REDUCE_ON_PLATEAU（以使用评估损失）时，这将默认为 "loss"。

    如果您设置此值，greater_is_better 将默认为 True，除非名称以“loss”结尾。如果您的指标越低越好，请不要忘记将其设置为 False。

  • greater_is_better (bool, 可选) — 与 load_best_model_at_end 和 metric_for_best_model 结合使用，指定更好的模型是否应该具有更高的指标。将默认为：

    • 如果 metric_for_best_model 设置为不以 "loss" 结尾的值，则为 True。
    • 如果 metric_for_best_model 未设置，或设置为以 "loss" 结尾的值，则为 False。
  • ignore_data_skip (bool, 可选, 默认为 False) — 恢复训练时，是否跳过 epoch 和批次以使数据加载处于与先前训练相同的阶段。如果设置为 True，训练将更快开始（因为跳过步骤可能需要很长时间），但不会产生与中断训练相同的结果。
  • fsdp (bool, str 或 FSDPOption 列表, 可选, 默认为 '') — 使用 PyTorch 分布式并行训练（仅限分布式训练）。

    以下选项列表：

    • "full_shard": 分片参数、梯度和优化器状态。
    • "shard_grad_op": 分片优化器状态和梯度。
    • "hybrid_shard": 在节点内应用 FULL_SHARD，并在节点间复制参数。
    • "hybrid_shard_zero2": 在节点内应用 SHARD_GRAD_OP，并在节点间复制参数。
    • "offload": 将参数和梯度卸载到 CPU（仅与 "full_shard" 和 "shard_grad_op" 兼容）。
    • "auto_wrap": 使用 default_auto_wrap_policy 自动递归地用 FSDP 包装层。
  • fsdp_config (str 或 dict, 可选) — 与 fsdp (Pytorch 分布式并行训练) 一起使用的配置。该值可以是 fsdp json 配置文件的位置 (例如 fsdp_config.json)，也可以是已加载的 json 文件作为 dict。

    配置及其选项列表：

    • min_num_params (int, 可选, 默认为 0): FSDP 默认自动包装的最小参数数量。（仅在传递 fsdp 字段时有用）。

    • transformer_layer_cls_to_wrap (list[str], 可选): 要包装的 Transformer 层类名列表（区分大小写），例如 BertLayer、GPTJBlock、T5Block…（仅在传递 fsdp 标志时有用）。

    • backward_prefetch (str, 可选) FSDP 的向后预取模式。控制何时预取下一组参数（仅在传递 fsdp 字段时有用）。

      以下选项列表：

      • "backward_pre": 在当前参数集的梯度计算之前预取下一组参数。
      • "backward_post": 在当前参数集的梯度计算之后预取下一组参数。

    • forward_prefetch (bool, 可选, 默认为 False) FSDP 的前向预取模式（仅在传递 fsdp 字段时有用）。如果 "True"，则 FSDP 在前向传递执行期间明确预取下一个即将到来的 all-gather。

    • limit_all_gathers (bool, 可选, 默认为 False) FSDP 的 limit_all_gathers（仅在传递 fsdp 字段时有用）。如果 "True"，FSDP 明确同步 CPU 线程以防止过多的飞行中的 all-gather。

    • use_orig_params (bool, 可选, 默认为 True) 如果 "True"，允许在初始化期间进行非均匀 requires_grad，这意味着支持交错的冻结和可训练参数。在参数高效微调等情况下很有用。请参阅此 [博客](https://dev-discuss.pytorch.org/t/rethinking-pytorch-fully-sharded-data-parallel-fsdp-from-first-principles/1019

    • sync_module_states (bool, 可选, 默认为 True) 如果 "True"，每个单独包装的 FSDP 单元将从 rank 0 广播模块参数，以确保它们在初始化后在所有 rank 上相同。

    • cpu_ram_efficient_loading (bool, 可选, 默认为 False) 如果 "True"，只有第一个进程加载预训练模型检查点，而所有其他进程具有空权重。当此设置设置为 "True" 时，sync_module_states 也必须为 "True"，否则除主进程外的所有进程将具有随机权重，导致训练期间出现意外行为。

    • activation_checkpointing (bool, 可选, 默认为 False): 如果 "True"，激活检查点是一种通过清除某些层的激活并在反向传递期间重新计算它们来减少内存使用的技术。实际上，这会以额外计算时间换取更低的内存使用。

    • xla (bool, 可选, 默认为 False): 是否使用 PyTorch/XLA 完全分片数据并行训练。这是一个实验性功能，其 API 未来可能会发展。

    • xla_fsdp_settings (dict, 可选) 该值是一个字典，用于存储 XLA FSDP 包装参数。

      有关选项的完整列表，请参阅 此处。

    • xla_fsdp_grad_ckpt (bool, 可选, 默认为 False): 将对每个嵌套的 XLA FSDP 包装层使用梯度检查点。此设置仅在 xla 标志设置为 true 且通过 fsdp_min_num_params 或 fsdp_transformer_layer_cls_to_wrap 指定了自动包装策略时才能使用。
  • deepspeed (str 或 dict, 可选) — 使用 Deepspeed。这是一个实验性功能，其 API 未来可能会发展。该值可以是 DeepSpeed json 配置文件的位置 (例如 ds_config.json)，也可以是已加载的 json 文件作为 dict。

    如果启用任何 Zero-init，请确保您的模型在初始化 TrainingArguments *之后*才进行初始化，否则将不会应用。
  • accelerator_config (str, dict, 或 AcceleratorConfig, 可选) — 与内部 Accelerator 实现一起使用的配置。该值可以是 accelerator json 配置文件的位置 (例如 accelerator_config.json)，已加载的 json 文件作为 dict，或 AcceleratorConfig 的实例。

    配置及其选项列表：

    • split_batches (bool, 可选, 默认为 False): 加速器是否应该在设备之间拆分数据加载器生成的批次。如果为 True，则实际使用的批次大小在任何类型的分布式进程上都将相同，但它必须是您正在使用的 num_processes 的整数倍。如果为 False，则实际使用的批次大小将是您脚本中设置的批次大小乘以进程数。
    • dispatch_batches (bool, 可选): 如果设置为 True，则由 Accelerator 准备的数据加载器仅在主进程中迭代，然后批次被拆分并广播到每个进程。对于底层数据集是 IterableDataset 的 DataLoader，将默认为 True，否则为 False。
    • even_batches (bool, 可选, 默认为 True): 如果设置为 True，在所有进程的总批次大小不能精确地整除数据集的情况下，数据集开头的样本将被复制，以便批次可以在所有 worker 之间平均分配。
    • use_seedable_sampler (bool, 可选, 默认为 True): 是否使用完全可播种的随机采样器 (accelerate.data_loader.SeedableRandomSampler)。确保使用不同的采样技术时训练结果完全可重现。虽然种子到种子的结果可能不同，但平均而言，当使用多个不同的种子进行比较时，差异可以忽略不计。也应与 ~utils.set_seed 一起运行以获得最佳结果。
    • use_configured_state (bool, 可选, 默认为 False): 是否使用在调用 TrainingArguments 之前定义的预配置 AcceleratorState 或 PartialState。如果为 True，则必须初始化 Accelerator 或 PartialState。请注意，这样做可能会导致超参数调整问题。
  • label_smoothing_factor (float, 可选, 默认为 0.0) — 要使用的标签平滑因子。零表示没有标签平滑，否则底层的独热编码标签将从 0 和 1 分别更改为 label_smoothing_factor/num_labels 和 1 - label_smoothing_factor + label_smoothing_factor/num_labels。
  • debug (str 或 DebugOption 列表, 可选, 默认为 "") — 启用一个或多个调试功能。这是一个实验性功能。

    可能选项如下：

    • "underflow_overflow": 检测模型输入/输出中的溢出并报告导致事件的最后帧
    • "tpu_metrics_debug": 在 TPU 上打印调试指标

    选项应以空格分隔。

  • optim (str 或 training_args.OptimizerNames, 可选, 默认为 "adamw_torch") — 要使用的优化器，例如“adamw_torch”、“adamw_torch_fused”、“adamw_apex_fused”、“adamw_anyprecision”、“adafactor”。有关优化器的完整列表，请参阅 training_args.py 中的 OptimizerNames。
  • optim_args (str, 可选) — 提供给优化器（如 AnyPrecisionAdamW、AdEMAMix 和 GaLore）的可选参数。
  • group_by_length (bool, 可选, 默认为 False) — 是否将训练数据集中长度大致相同的样本分组在一起（以最小化填充并提高效率）。仅在应用动态填充时有用。
  • length_column_name (str, 可选, 默认为 "length") — 预计算长度的列名。如果该列存在，按长度分组将使用这些值而不是在训练启动时计算它们。除非 group_by_length 为 True 且数据集是 Dataset 的实例，否则将被忽略。
  • report_to (str 或 list[str], 可选, 默认为 "all") — 要报告结果和日志的集成列表。支持的平台有 "azure_ml"、"clearml"、"codecarbon"、"comet_ml"、"dagshub"、"dvclive"、"flyte"、"mlflow"、"neptune"、"swanlab"、"tensorboard" 和 "wandb"。使用 "all" 报告给所有已安装的集成，"none" 则不报告给任何集成。
  • ddp_find_unused_parameters (bool, 可选) — 使用分布式训练时，传递给 DistributedDataParallel 的 find_unused_parameters 标志的值。如果使用梯度检查点，则默认为 False，否则为 True。
  • ddp_bucket_cap_mb (int, 可选) — 使用分布式训练时，传递给 DistributedDataParallel 的 bucket_cap_mb 标志的值。
  • ddp_broadcast_buffers (bool, 可选) — 使用分布式训练时，传递给 DistributedDataParallel 的 broadcast_buffers 标志的值。如果使用梯度检查点，则默认为 False，否则为 True。
  • dataloader_pin_memory (bool, 可选, 默认为 True) — 是否在数据加载器中固定内存。默认为 True。
  • dataloader_persistent_workers (bool, 可选, 默认为 False) — 如果为 True，数据加载器在数据集消耗一次后不会关闭 worker 进程。这允许保持 worker Dataset 实例的活跃。可能会加速训练，但会增加 RAM 使用。默认为 False。
  • dataloader_prefetch_factor (int, 可选) — 每个 worker 预先加载的批次数量。2 表示所有 worker 总共预取 2 * num_workers 个批次。
  • skip_memory_metrics (bool, 可选, 默认为 True) — 是否跳过将内存分析器报告添加到指标。默认情况下会跳过，因为它会降低训练和评估速度。
  • push_to_hub (bool, optional,默认为 False) — 是否在每次保存模型时将模型推送到Hub。如果激活，output_dir将成为一个与仓库（由hub_model_id决定）同步的git目录，并且每次触发保存时（取决于您的save_strategy）内容都会被推送。调用save_model()也将触发推送。

    如果 output_dir 存在，它需要是 Trainer 将要推送的仓库的本地克隆。
  • resume_from_checkpoint (str, optional) — 包含模型有效检查点的文件夹路径。此参数不直接由 Trainer 使用，而是旨在由您的训练/评估脚本使用。有关更多详细信息，请参阅 示例脚本。
  • hub_model_id (str, optional) — 与本地output_dir保持同步的仓库名称。它可以是一个简单的模型ID，在这种情况下模型将被推送到您的命名空间。否则，它应该是完整的仓库名称，例如"user_name/model"，这允许您推送到您所属的组织，例如"organization_name/model"。默认为user_name/output_dir_name，其中output_dir_name是output_dir的名称。

    将默认为output_dir的名称。

  • hub_strategy (str 或 HubStrategy, optional, 默认为 "every_save") — 定义推送到Hub的范围和时间。可能的值有：

    • "end": 在调用 save_model() 方法时，推送模型、其配置、处理类（例如tokenizer，如果传递给Trainer）以及模型卡草稿。
    • "every_save": 每次保存模型时，推送模型、其配置、处理类（例如tokenizer，如果传递给Trainer）以及模型卡草稿。推送是异步的，以避免阻塞训练，如果保存非常频繁，则只有在前一次推送完成后才尝试新的推送。训练结束时，将最后一次推送最终模型。
    • "checkpoint": 与 "every_save" 类似，但最新的检查点也会推送到一个名为 last-checkpoint 的子文件夹中，方便您使用 trainer.train(resume_from_checkpoint="last-checkpoint") 轻松恢复训练。
    • "all_checkpoints": 与 "checkpoint" 类似，但所有检查点都按其在输出文件夹中的方式推送（因此您将在最终仓库中获得每个文件夹的检查点文件夹）
  • hub_token (str, optional) — 用于将模型推送到Hub的令牌。默认为通过 huggingface-cli login 获取的缓存文件夹中的令牌。
  • hub_private_repo (bool, optional) — 是否将仓库设为私有。如果为 None（默认），则除非组织的默认设置为私有，否则仓库将是公共的。如果仓库已存在，此值将被忽略。
  • hub_always_push (bool, optional, 默认为 False) — 除非此参数为 True，否则 Trainer 将在上次推送未完成时跳过推送检查点。
  • hub_revision (str, optional) — 推送到Hub时使用的修订版本。可以是分支名称、标签或提交哈希。
  • gradient_checkpointing (bool, optional, 默认为 False) — 如果为 True，则使用梯度检查点来节省内存，代价是反向传播速度较慢。
  • gradient_checkpointing_kwargs (dict, optional, 默认为 None) — 将传递给 gradient_checkpointing_enable 方法的关键字参数。
  • include_inputs_for_metrics (bool, optional, 默认为 False) — 此参数已弃用。请改用 include_for_metrics，例如 include_for_metrics = ["inputs"]。
  • include_for_metrics (list[str], optional, 默认为 []) — 如果需要计算指标，则在 compute_metrics 函数中包含附加数据。可添加到 include_for_metrics 列表的选项：

    • "inputs": 传递给模型的输入数据，用于计算依赖于输入的指标。
    • "loss": 评估期间计算的损失值，用于计算依赖于损失的指标。
  • eval_do_concat_batches (bool, optional, 默认为 True) — 是否在批次间递归连接输入/损失/标签/预测。如果为 False，则会将它们存储为列表，每个批次单独保存。
  • auto_find_batch_size (bool, optional, 默认为 False) — 是否通过指数衰减自动查找适合内存的批次大小，避免CUDA内存不足错误。需要安装accelerate（pip install accelerate）。
  • full_determinism (bool, optional, 默认为 False) — 如果为 True，则调用 enable_full_determinism() 而非 set_seed() 以确保分布式训练中的可重现结果。重要提示：这将对性能产生负面影响，因此仅用于调试。
  • torchdynamo (str, optional) — 如果设置，则为TorchDynamo的后端编译器。可能的选择有 "eager"、"aot_eager"、"inductor"、"nvfuser"、"aot_nvfuser"、"aot_cudagraphs"、"ofi"、"fx2trt"、"onnxrt" 和 "ipex"。
  • ray_scope (str, optional, 默认为 "last") — 使用Ray进行超参数搜索时使用的范围。默认情况下，将使用 "last"。Ray将使用所有试验的最后一个检查点，比较它们并选择最佳的。但是，也提供了其他选项。有关更多选项，请参阅 Ray文档。
  • ddp_timeout (int, optional, 默认为 1800) — torch.distributed.init_process_group 调用的超时时间，用于避免在分布式运行时执行慢速操作时出现的GPU套接字超时。有关更多信息，请参阅 [PyTorch 文档] (https://pytorch.ac.cn/docs/stable/distributed.html#torch.distributed.init_process_group)。
  • use_mps_device (bool, optional, 默认为 False) — 此参数已弃用。如果可用，mps 设备将类似于 cuda 设备被使用。
  • torch_compile (bool, optional, 默认为 False) — 是否使用 PyTorch 2.0 torch.compile 编译模型。

    这将使用 torch.compile API 的最佳默认值。您可以使用参数 torch_compile_backend 和 torch_compile_mode 自定义默认值，但我们不保证它们都能正常工作，因为 PyTorch 中正在逐步推出支持。

    此标志和整个编译 API 是实验性的，未来版本中可能会发生变化。

  • torch_compile_backend (str, optional) — 在 torch.compile 中使用的后端。如果设置为任何值，torch_compile 将设置为 True。

    有关可能的值，请参阅 PyTorch 文档，并注意它们可能会因 PyTorch 版本而异。

    此标志是实验性的，未来版本中可能会发生变化。

  • torch_compile_mode (str, optional) — 在 torch.compile 中使用的模式。如果设置为任何值，torch_compile 将设置为 True。

    有关可能的值，请参阅 PyTorch 文档，并注意它们可能会因 PyTorch 版本而异。

    此标志是实验性的，未来版本中可能会发生变化。

  • include_tokens_per_second (bool, optional) — 是否计算每秒每设备训练速度指标的token数。

    这将预先迭代整个训练数据加载器一次，

    并会减慢整个过程。

  • include_num_input_tokens_seen (bool, optional) — 是否跟踪训练过程中看到的输入token数。

    在分布式训练中可能会较慢，因为必须调用 gather 操作。

  • neftune_noise_alpha (Optional[float]) — 如果不是 None，这将激活 NEFTune 噪声嵌入。这可以显著提高指令微调的模型性能。请查阅原始论文和原始代码。支持 transformers PreTrainedModel 以及 peft 中的 PeftModel。原始论文使用的值范围为 [5.0, 15.0]。
  • optim_target_modules (Union[str, list[str]], optional) — 要优化的目标模块，即您希望训练的模块名称。目前用于 GaLore 算法 (https://huggingface.ac.cn/papers/2403.03507) 和 APOLLO 算法 (https://huggingface.co/papers/2412.05270)。有关更多详细信息，请参阅 GaLore 实现 (https://github.com/jiaweizzhao/GaLore) 和 APOLLO 实现 (https://github.com/zhuhanqing/APOLLO)。您需要确保传递有效的 GaLore 或 APOLLO 优化器，例如以下之一：“apollo_adamw”、“galore_adamw”、“galore_adamw_8bit”、“galore_adafactor”，并确保目标模块仅为 nn.Linear 模块。
  • batch_eval_metrics (Optional[bool], 默认为 False) — 如果设置为 True，评估将在每个批次结束时调用 compute_metrics 以累积统计信息，而不是将所有评估日志存储在内存中。当设置为 True 时，您必须传递一个 compute_metrics 函数，该函数接受一个布尔参数 compute_result，当传入 True 时，它将从您在评估集上累积的批次级别统计信息中触发最终的全局摘要统计信息。
  • eval_on_start (bool, optional, 默认为 False) — 是否在训练前执行评估步骤（健全性检查），以确保验证步骤正常工作。
  • eval_use_gather_object (bool, optional, 默认为 False) — 是否从所有设备递归收集嵌套列表/元组/字典中的对象。这仅在用户不只返回张量时才应启用，并且 PyTorch 积极不鼓励这样做。
  • use_liger_kernel (bool, optional, 默认为 False) — 是否为LLM模型训练启用 Liger 内核。它可以有效提高多GPU训练吞吐量约20%，并减少内存使用约60%，与flash attention、PyTorch FSDP和Microsoft DeepSpeed开箱即用。目前，它支持llama、mistral、mixtral和gemma模型。
  • liger_kernel_config (Optional[dict], optional) — 用于 Liger 内核的配置。当 use_liger_kernel=True 时，此字典作为关键字参数传递给 _apply_liger_kernel_to_instance 函数，该函数指定要应用哪些内核。可用选项因模型而异，但通常包括：‘rope’、‘swiglu’、‘cross_entropy’、‘fused_linear_cross_entropy’、‘rms_norm’ 等。如果为 None，则使用默认内核配置。
  • average_tokens_across_devices (bool, optional, 默认为 False) — 是否在设备间平均token。如果启用，将使用 all_reduce 来同步 num_tokens_in_batch 以进行精确的损失计算。参考：https://github.com/huggingface/transformers/issues/34242

TrainingArguments 是我们在示例脚本中使用的参数子集，它们与训练循环本身相关。

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

get_process_log_level

< >

( )

根据此进程是否为节点0的主进程、非节点0的主进程或非主进程，返回要使用的日志级别。

对于主进程，日志级别默认为已设置的日志级别（如果您未做任何操作，则为logging.WARNING），除非被log_level参数覆盖。

对于副本进程，日志级别默认为logging.WARNING，除非被log_level_replica参数覆盖。

主进程和副本进程设置之间的选择根据should_log的返回值进行。

get_warmup_steps

< >

( num_training_steps: int )

获取用于线性预热的步数。

main_process_first

< >

( local = True desc = 'work' )

参数

  • local (bool, optional, 默认为 True) — 如果 True，则首先指每个节点上排名为0的进程；如果 False，则首先指节点排名为0的进程。在具有共享文件系统的多节点环境中，您很可能希望使用 local=False，这样只有第一个节点的主进程会进行处理。但是，如果文件系统不共享，则每个节点的主进程都需要进行处理，这是默认行为。
  • desc (str, optional, 默认为 "work") — 将用于调试日志的工作描述

一个用于torch分布式环境的上下文管理器，其中需要在主进程上执行某些操作，同时阻塞副本，并在完成后释放副本。

其中一个用途是datasets的map功能，为了高效，它应该在主进程上运行一次，完成后保存结果的缓存版本，然后由副本自动加载。

set_dataloader

< >

( train_batch_size: int = 8 eval_batch_size: int = 8 drop_last: bool = False num_workers: int = 0 pin_memory: bool = True persistent_workers: bool = False prefetch_factor: typing.Optional[int] = None auto_find_batch_size: bool = False ignore_data_skip: bool = False sampler_seed: typing.Optional[int] = None )

参数

  • drop_last (bool, optional, 默认为 False) — 是否丢弃最后一个不完整的批次（如果数据集的长度不能被批次大小整除）。
  • num_workers (int, optional, 默认为 0) — 用于数据加载的子进程数（仅限 PyTorch）。0 表示数据将在主进程中加载。
  • pin_memory (bool, optional, 默认为 True) — 是否在数据加载器中锁定内存。默认为 True。
  • persistent_workers (bool, optional, 默认为 False) — 如果为 True，则数据加载器在数据集消耗一次后不会关闭工作进程。这允许保持工作进程数据集实例的活动。可能潜在地加快训练速度，但会增加RAM使用。默认为 False。
  • prefetch_factor (int, optional) — 每个 worker 提前加载的批次数量。2 表示所有 worker 总共预取 2 * num_workers 个批次。
  • auto_find_batch_size (bool, optional, 默认为 False) — 是否通过指数衰减自动查找适合内存的批次大小，避免CUDA内存不足错误。需要安装accelerate（pip install accelerate）。
  • ignore_data_skip (bool, optional, 默认为 False) — 恢复训练时，是否跳过 epoch 和批次，以使数据加载与之前的训练处于相同阶段。如果设置为 True，训练将更快开始（因为跳过步骤可能需要很长时间），但结果将与中断的训练结果不同。
  • sampler_seed (int, optional) — 与数据采样器一起使用的随机种子。如果未设置，数据采样的随机生成器将使用与 self.seed 相同的种子。这可用于确保数据采样的可重现性，与模型种子无关。

将所有与数据加载器创建相关的参数进行分组的方法。

示例

>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_dataloader(train_batch_size=16, eval_batch_size=64)
>>> args.per_device_train_batch_size
16

set_evaluate

< >

( strategy: typing.Union[str, transformers.trainer_utils.IntervalStrategy] = 'no' steps: int = 500 batch_size: int = 8 accumulation_steps: typing.Optional[int] = None delay: typing.Optional[float] = None loss_only: bool = False jit_mode: bool = False )

参数

  • strategy (str 或 IntervalStrategy, optional, 默认为 "no") — 训练期间采用的评估策略。可能的值为：

    • "no": 训练期间不进行评估。
    • "steps": 每 steps 步进行一次评估（并记录）。
    • "epoch": 每个 epoch 结束时进行评估。

    设置 strategy 不同于 "no" 将会把 self.do_eval 设置为 True。

  • steps (int, optional, 默认为 500) — 如果 strategy="steps"，两次评估之间的更新步数。
  • batch_size (int optional, 默认为 8) — 用于评估的每个设备（GPU/TPU 核心/CPU…）的批次大小。
  • accumulation_steps (int, optional) — 在将结果移动到CPU之前，用于累积输出张量的预测步数。如果未设置，则整个预测都会在GPU/TPU上累积，然后移动到CPU（速度更快但需要更多内存）。
  • delay (float, optional) — 在第一次评估执行之前等待的 epoch 数或步数，取决于 eval_strategy。
  • loss_only (bool, optional, 默认为 False) — 忽略除损失之外的所有输出。
  • jit_mode (bool, optional) — 推理时是否使用 PyTorch jit trace。

将所有与评估相关的参数进行分组的方法。

示例

>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_evaluate(strategy="steps", steps=100)
>>> args.eval_steps
100

set_logging

< >

( strategy: typing.Union[str, transformers.trainer_utils.IntervalStrategy] = 'steps' steps: int = 500 report_to: typing.Union[str, list[str]] = 'none' level: str = 'passive' first_step: bool = False nan_inf_filter: bool = False on_each_node: bool = False replica_level: str = 'passive' )

参数

  • strategy (str 或 IntervalStrategy, 可选, 默认为 "steps") — 训练期间采用的日志记录策略。可能的值为：

    • "no": 训练期间不进行日志记录。
    • "epoch": 在每个 epoch 结束时进行日志记录。
    • "steps": 每隔 logging_steps 步进行日志记录。
  • steps (int, 可选, 默认为 500) — 如果 strategy="steps"，两次日志记录之间更新步数。
  • level (str, 可选, 默认为 "passive") — 在主进程上使用的日志级别。可能的值为字符串形式的日志级别："debug"、"info"、"warning"、"error" 和 "critical"，以及一个不设置任何内容并让应用程序设置级别的 "passive" 级别。
  • report_to (str 或 list[str], 可选, 默认为 "all") — 用于报告结果和日志的集成列表。支持的平台有 "azure_ml"、"clearml"、"codecarbon"、"comet_ml"、"dagshub"、"dvclive"、"flyte"、"mlflow"、"neptune"、"swanlab"、"tensorboard" 和 "wandb"。使用 "all" 报告给所有已安装的集成，使用 "none" 表示不使用任何集成。
  • first_step (bool, 可选, 默认为 False) — 是否记录和评估第一个 global_step。
  • nan_inf_filter (bool, 可选, 默认为 True) — 是否过滤日志中的 nan 和 inf 损失。如果设置为 True，则过滤每个 nan 或 inf 步的损失，并取当前日志记录窗口的平均损失。

    nan_inf_filter 只影响损失值的日志记录，它不改变梯度计算或应用于模型的行为。
  • on_each_node (bool, 可选, 默认为 True) — 在多节点分布式训练中，是否在每个节点上使用 log_level 记录，或仅在主节点上记录。
  • replica_level (str, 可选, 默认为 "passive") — 副本上使用的日志级别。选择与 log_level 相同。

一个将所有与日志记录相关的参数归组的方法。

示例

>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_logging(strategy="steps", steps=100)
>>> args.logging_steps
100

set_lr_scheduler

< >

( name: typing.Union[str, transformers.trainer_utils.SchedulerType] = 'linear' num_epochs: float = 3.0 max_steps: int = -1 warmup_ratio: float = 0 warmup_steps: int = 0 )

参数

  • name (str 或 SchedulerType, 可选, 默认为 "linear") — 要使用的调度器类型。有关所有可能的值，请参阅 SchedulerType 的文档。
  • num_epochs(float, 可选, 默认为 3.0) — 要执行的训练 epoch 总数（如果不是整数，将在停止训练前执行最后一个 epoch 的小数部分百分比）。
  • max_steps (int, 可选, 默认为 -1) — 如果设置为正数，则为要执行的训练步数总和。覆盖 num_train_epochs。对于有限数据集，训练将在数据集上迭代（如果所有数据都已用完），直到达到 max_steps。
  • warmup_ratio (float, 可选, 默认为 0.0) — 用于从 0 到 learning_rate 的线性预热的训练步数总比例。
  • warmup_steps (int, 可选, 默认为 0) — 用于从 0 到 learning_rate 的线性预热的步数。覆盖 warmup_ratio 的任何效果。

一个将所有与学习率调度器及其超参数相关的参数归组的方法。

示例

>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_lr_scheduler(name="cosine", warmup_ratio=0.05)
>>> args.warmup_ratio
0.05

set_optimizer

< >

( name: typing.Union[str, transformers.training_args.OptimizerNames] = 'adamw_torch' learning_rate: float = 5e-05 weight_decay: float = 0 beta1: float = 0.9 beta2: float = 0.999 epsilon: float = 1e-08 args: typing.Optional[str] = None )

参数

  • name (str 或 training_args.OptimizerNames, 可选, 默认为 "adamw_torch") — 要使用的优化器："adamw_torch"、"adamw_torch_fused"、"adamw_apex_fused"、"adamw_anyprecision" 或 "adafactor"。
  • learning_rate (float, 可选, 默认为 5e-5) — 初始学习率。
  • weight_decay (float, 可选, 默认为 0) — 应用于除所有偏置和 LayerNorm 权重之外的所有层的权重衰减（如果不为零）。
  • beta1 (float, 可选, 默认为 0.9) — Adam 优化器或其变体的 beta1 超参数。
  • beta2 (float, 可选, 默认为 0.999) — Adam 优化器或其变体的 beta2 超参数。
  • epsilon (float, 可选, 默认为 1e-8) — Adam 优化器或其变体的 epsilon 超参数。
  • args (str, 可选) — 供给 AnyPrecisionAdamW 的可选参数（仅在 optim="adamw_anyprecision" 时有用）。

一个将所有与优化器及其超参数相关的参数归组的方法。

示例

>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_optimizer(name="adamw_torch", beta1=0.8)
>>> args.optim
'adamw_torch'

set_push_to_hub

< >

( model_id: str strategy: typing.Union[str, transformers.trainer_utils.HubStrategy] = 'every_save' token: typing.Optional[str] = None private_repo: typing.Optional[bool] = None always_push: bool = False revision: typing.Optional[str] = None )

参数

  • model_id (str) — 要与本地 output_dir 保持同步的存储库名称。它可以是一个简单的模型 ID，在这种情况下，模型将被推送到您的命名空间中。否则，它应该是一个完整的存储库名称，例如 "user_name/model"，这样您就可以推送到您是成员的组织，例如 "organization_name/model"。
  • strategy (str 或 HubStrategy, 可选, 默认为 "every_save") — 定义推送到 Hub 的范围和时间。可能的值为：

    • "end": 当调用 save_model() 方法时，推送模型、其配置、处理类（例如分词器，如果传递给 Trainer）和模型卡草稿。
    • "every_save": 每次模型保存时，推送模型、其配置、处理类（例如分词器，如果传递给 Trainer）和模型卡草稿。推送是异步的，以避免阻塞训练，如果保存非常频繁，只有在前一次推送完成后才会尝试新的推送。训练结束时，将推送最终模型。
    • "checkpoint": 类似于 "every_save"，但最新的检查点也会推送到名为 last-checkpoint 的子文件夹中，这样您就可以轻松地使用 trainer.train(resume_from_checkpoint="last-checkpoint") 恢复训练。
    • "all_checkpoints": 类似于 "checkpoint"，但所有检查点都按它们在输出文件夹中出现的方式推送（因此您的最终存储库中每个文件夹都会有一个检查点文件夹）。
  • token (str, 可选) — 用于将模型推送到 Hub 的令牌。默认为使用 huggingface-cli login 获得的缓存文件夹中的令牌。
  • private_repo (bool, 可选, 默认为 False) — 是否将存储库设为私有。如果为 None（默认），存储库将是公共的，除非组织的默认设置为私有。如果存储库已存在，此值将被忽略。
  • always_push (bool, 可选, 默认为 False) — 除非此项为 True，否则 Trainer 将跳过在上次推送未完成时推送检查点。
  • revision (str, 可选) — 推送到 Hub 时使用的修订版本。可以是分支名称、标签或提交哈希。

一个将所有与检查点与 Hub 同步相关的参数归组的方法。

调用此方法会将 self.push_to_hub 设置为 True，这意味着 output_dir 将成为与存储库（由 model_id 决定）同步的 git 目录，并且每次触发保存时（取决于您的 self.save_strategy）内容都将被推送到 Hub。调用 save_model() 也会触发推送。

示例

>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_push_to_hub("me/awesome-model")
>>> args.hub_model_id
'me/awesome-model'

set_save

< >

( strategy: typing.Union[str, transformers.trainer_utils.IntervalStrategy] = 'steps' steps: int = 500 total_limit: typing.Optional[int] = None on_each_node: bool = False )

参数

  • strategy (str 或 IntervalStrategy, 可选, 默认为 "steps") — 训练期间采用的检查点保存策略。可能的值为：

    • "no": 训练期间不进行保存。
    • "epoch": 在每个 epoch 结束时进行保存。
    • "steps": 每隔 save_steps 步进行保存。
  • steps (int, 可选, 默认为 500) — 如果 strategy="steps"，两次检查点保存之间更新步数。
  • total_limit (int, 可选) — 如果传递一个值，将限制检查点的总数。删除 output_dir 中较旧的检查点。
  • on_each_node (bool, 可选, 默认为 False) — 在多节点分布式训练时，是否在每个节点上保存模型和检查点，或仅在主节点上保存。

    当不同节点使用相同的存储时，不应激活此项，因为文件将以相同的名称保存在每个节点上。

一个将所有与检查点保存相关的参数归组的方法。

示例

>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_save(strategy="steps", steps=100)
>>> args.save_steps
100

set_testing

< >

( batch_size: int = 8 loss_only: bool = False jit_mode: bool = False )

参数

  • batch_size (int 可选, 默认为 8) — 用于测试的每个设备（GPU/TPU core/CPU...）的批次大小。
  • loss_only (bool, 可选, 默认为 False) — 忽略除损失之外的所有输出。
  • jit_mode (bool, 可选) — 是否使用 PyTorch jit trace 进行推理。

一个将所有与在保留数据集上进行测试相关的基本参数归组的方法。

调用此方法将自动将 self.do_predict 设置为 True。

示例

>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_testing(batch_size=32)
>>> args.per_device_eval_batch_size
32

set_training

< >

( learning_rate: float = 5e-05 batch_size: int = 8 weight_decay: float = 0 num_epochs: float = 3 max_steps: int = -1 gradient_accumulation_steps: int = 1 seed: int = 42 gradient_checkpointing: bool = False )

参数

  • learning_rate (float, 可选, 默认为 5e-5) — 优化器的初始学习率。
  • batch_size (int 可选, 默认为 8) — 用于训练的每个设备（GPU/TPU core/CPU...）的批次大小。
  • weight_decay (float, 可选, 默认为 0) — 应用于除所有偏置和 LayerNorm 权重之外的所有层的权重衰减（如果不为零）。
  • num_train_epochs(float, 可选, 默认为 3.0) — 要执行的训练 epoch 总数（如果不是整数，将在停止训练前执行最后一个 epoch 的小数部分百分比）。
  • max_steps (int, 可选, 默认为 -1) — 如果设置为正数，则为要执行的训练步数总和。覆盖 num_train_epochs。对于有限数据集，训练将在数据集上迭代（如果所有数据都已用完），直到达到 max_steps。
  • gradient_accumulation_steps (int, 可选, 默认为 1) — 梯度累积的更新步数，然后执行反向/更新传递。

    当使用梯度累积时，一步算作一步反向传递。因此，日志记录、评估、保存将在每 gradient_accumulation_steps * xxx_step 个训练样本后进行。
  • seed (int, 可选, 默认为 42) — 在训练开始时设置的随机种子。为确保跨运行的可重现性，如果模型有一些随机初始化参数，请使用 ~Trainer.model_init 函数来实例化模型。
  • gradient_checkpointing (bool, 可选, 默认为 False) — 如果为 True，则使用梯度检查点来节省内存，但会牺牲反向传播速度。

一个将所有与训练相关的基本参数归组的方法。

调用此方法将自动将 self.do_train 设置为 True。

示例

>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_training(learning_rate=1e-4, batch_size=32)
>>> args.learning_rate
1e-4

to_dict

< >

( )

序列化此实例，同时将 Enum 替换为其值（为了支持 JSON 序列化）。它通过移除令牌值来混淆令牌值。

to_json_string

< >

( )

将此实例序列化为 JSON 字符串。

to_sanitized_dict

< >

( )

用于 TensorBoard hparams 的净化序列化。

Seq2SeqTrainingArguments

class transformers.Seq2SeqTrainingArguments

< >

( 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-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: 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 = 500 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: 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: 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] = False sortish_sampler: bool = False predict_with_generate: bool = False generation_max_length: typing.Optional[int] = None generation_num_beams: typing.Optional[int] = None generation_config: typing.Union[str, pathlib.Path, transformers.generation.configuration_utils.GenerationConfig, NoneType] = None )

参数

  • output_dir (str, 可选, 默认为 "trainer_output") — 模型预测和检查点将写入的输出目录。
  • overwrite_output_dir (bool, 可选, 默认为 False) — 如果为 True，则覆盖输出目录的内容。如果 output_dir 指向检查点目录，则使用此选项继续训练。
  • do_train (bool, 可选, 默认为 False) — 是否运行训练。此参数不直接由 Trainer 使用，而是旨在供您的训练/评估脚本使用。有关更多详细信息，请参阅示例脚本。
  • do_eval (bool, 可选) — 是否在验证集上运行评估。如果 eval_strategy 不同于 "no"，则将其设置为 True。此参数不直接由 Trainer 使用，而是旨在供您的训练/评估脚本使用。有关更多详细信息，请参阅示例脚本。
  • do_predict (bool, 可选, 默认为 False) — 是否在测试集上运行预测。此参数不直接由 Trainer 使用，而是旨在供您的训练/评估脚本使用。有关更多详细信息，请参阅示例脚本。
  • eval_strategy (str 或 IntervalStrategy, 可选, 默认为 "no") — 训练期间采用的评估策略。可能的值为：

    • "no": 训练期间不进行评估。
    • "steps": 每 eval_steps 评估一次（并记录）。
    • "epoch": 每个 epoch 结束时进行评估。
  • prediction_loss_only (bool, 可选, 默认为 False) — 执行评估和生成预测时，仅返回损失。
  • per_device_train_batch_size (int, 可选, 默认为 8) — 每个设备加速器核心/CPU 的训练批次大小。
  • per_device_eval_batch_size (int, 可选, 默认为 8) — 每个设备加速器核心/CPU 的评估批次大小。
  • gradient_accumulation_steps (int, 可选, 默认为 1) — 在执行反向/更新传递之前，用于累积梯度的更新步数。

    使用梯度累积时，一步被视为一个带有反向传播的步骤。因此，日志记录、评估和保存将在每 gradient_accumulation_steps * xxx_step 个训练样本后进行。
  • eval_accumulation_steps (int, 可选) — 累积输出张量进行预测的步数，然后将结果移动到 CPU。如果未设置，则整个预测都会在设备加速器上累积，然后才移动到 CPU（速度更快但需要更多内存）。
  • eval_delay (float, 可选) — 在执行第一次评估之前需要等待的 epoch 或步数，具体取决于 eval_strategy。
  • torch_empty_cache_steps (int, 可选) — 在调用 torch..empty_cache() 之前要等待的步数。如果未设置或设置为 None，则不会清空缓存。

    这可以通过降低峰值 VRAM 使用量来帮助避免 CUDA 内存不足错误，但代价是性能会降低约 10%。
  • learning_rate (float, 可选, 默认为 5e-5) — AdamW 优化器的初始学习率。
  • weight_decay (float, 可选, 默认为 0) — 除了 AdamW 优化器中的所有偏差和 LayerNorm 权重外，对所有层应用的权重衰减（如果不为零）。
  • adam_beta1 (float, 可选, 默认为 0.9) — AdamW 优化器的 beta1 超参数。
  • adam_beta2 (float, 可选, 默认为 0.999) — AdamW 优化器的 beta2 超参数。
  • adam_epsilon (float, 可选, 默认为 1e-8) — AdamW 优化器的 epsilon 超参数。
  • max_grad_norm (float, 可选, 默认为 1.0) — 最大梯度范数（用于梯度裁剪）。
  • num_train_epochs(float, 可选, 默认为 3.0) — 要执行的训练总 epoch 数（如果不是整数，则在停止训练之前执行最后一个 epoch 的小数部分百分比）。
  • max_steps (int, 可选, 默认为 -1) — 如果设置为正数，则为要执行的训练总步数。覆盖 num_train_epochs。对于有限数据集，训练将通过数据集（如果所有数据都已耗尽）重复进行，直到达到 max_steps。
  • lr_scheduler_type (str 或 SchedulerType, 可选, 默认为 "linear") — 要使用的调度器类型。有关所有可能的值，请参阅 SchedulerType 的文档。
  • lr_scheduler_kwargs (‘dict’, 可选, 默认为 {}) — 学习率调度器的额外参数。有关可能的值，请参阅每个调度器的文档。
  • warmup_ratio (float, 可选, 默认为 0.0) — 用于从 0 到 learning_rate 线性预热的总训练步数的比例。
  • warmup_steps (int, 可选, 默认为 0) — 用于从 0 到 learning_rate 线性预热的步数。覆盖 warmup_ratio 的任何效果。
  • log_level (str, 可选, 默认为 passive) — 在主进程上使用的日志级别。可能的选择是字符串形式的日志级别：'debug'、'info'、'warning'、'error' 和 'critical'，以及一个 'passive' 级别，该级别不设置任何内容并保持 Transformers 库的当前日志级别（默认情况下为 "warning"）。
  • log_level_replica (str, 可选, 默认为 "warning") — 在副本上使用的日志级别。与 log_level 具有相同的选择。
  • log_on_each_node (bool, 可选, 默认为 True) — 在多节点分布式训练中，是否每个节点使用 log_level 记录一次，或者仅在主节点上记录。
  • logging_dir (str, 可选) — TensorBoard 日志目录。默认为 *output_dir/runs/CURRENT_DATETIME_HOSTNAME*。
  • logging_strategy (str 或 IntervalStrategy, 可选, 默认为 "steps") — 训练期间采用的日志记录策略。可能的值为：

    • "no": 训练期间不进行日志记录。
    • "epoch": 每个 epoch 结束时进行日志记录。
    • "steps": 每 logging_steps 记录一次。
  • logging_first_step (bool, 可选, 默认为 False) — 是否记录第一个 global_step。
  • logging_steps (int 或 float, 可选, 默认为 500) — 如果 logging_strategy="steps"，则两次日志记录之间的更新步数。应为整数或在 [0,1) 范围内的浮点数。如果小于 1，则将其解释为总训练步数的比例。
  • logging_nan_inf_filter (bool, 可选, 默认为 True) — 是否过滤 nan 和 inf 损失以进行日志记录。如果设置为 True，则过滤掉每个步骤中为 nan 或 inf 的损失，并取当前日志窗口的平均损失。

    logging_nan_inf_filter 仅影响损失值的日志记录，它不改变梯度计算或应用于模型的行为。
  • save_strategy (str 或 SaveStrategy, 可选, 默认为 "steps") — 训练期间采用的检查点保存策略。可能的值为：

    • "no"：训练期间不保存。
    • "epoch"：在每个 epoch 结束时保存。
    • "steps"：每 save_steps 保存一次。
    • "best"：每当达到新的 best_metric 时保存。

    如果选择 "epoch" 或 "steps"，也总会在训练结束时执行保存。

  • save_steps (int 或 float, 可选, 默认为 500) — 如果 save_strategy="steps"，则两次检查点保存之间的更新步数。应为整数或范围 [0,1) 内的浮点数。如果小于 1，则解释为总训练步数的比例。
  • save_total_limit (int, 可选) — 如果传入值，将限制检查点的总数量。删除 output_dir 中较旧的检查点。当启用 load_best_model_at_end 时，除了最新的检查点外，根据 metric_for_best_model 的“最佳”检查点将始终保留。例如，对于 save_total_limit=5 和 load_best_model_at_end，将始终保留最后四个检查点以及最佳模型。当 save_total_limit=1 和 load_best_model_at_end 时，可能会保存两个检查点：最后一个和最佳一个（如果它们不同）。
  • save_safetensors (bool, 可选, 默认为 True) — 对状态字典使用 safetensors 保存和加载，而不是默认的 torch.load 和 torch.save。
  • save_on_each_node (bool, 可选, 默认为 False) — 进行多节点分布式训练时，是否在每个节点上保存模型和检查点，或者仅在主节点上保存。

    当不同节点使用相同的存储时，不应激活此选项，因为文件将以相同的名称保存到每个节点。

  • save_only_model (bool, 可选, 默认为 False) — 在检查点时，是只保存模型，还是同时保存优化器、调度器和 rng 状态。请注意，如果设置为 True，则无法从检查点恢复训练。这使您可以通过不存储优化器、调度器和 rng 状态来节省存储空间。此选项设置为 True 时，只能使用 from_pretrained 加载模型。
  • restore_callback_states_from_checkpoint (bool, 可选, 默认为 False) — 是否从检查点恢复回调状态。如果为 True，则如果检查点中存在回调，将覆盖传递给 Trainer 的回调。
  • use_cpu (bool, 可选, 默认为 False) — 是否使用 CPU。如果设置为 False，我们将使用可用的 cuda 或 mps 设备。
  • seed (int, 可选, 默认为 42) — 训练开始时设置的随机种子。为了确保跨运行的可复现性，如果模型具有一些随机初始化的参数，请使用 ~Trainer.model_init 函数实例化模型。
  • data_seed (int, 可选) — 用于数据采样器的随机种子。如果未设置，数据采样的随机生成器将使用与 seed 相同的种子。这可用于确保数据采样的可复现性，与模型种子无关。
  • jit_mode_eval (bool, 可选, 默认为 False) — 是否使用 PyTorch jit trace 进行推理。
  • use_ipex (bool, 可选, 默认为 False) — 在可用时使用 PyTorch 的 Intel 扩展。IPEX 安装。
  • bf16 (bool, 可选, 默认为 False) — 是否使用 bf16 16 位（混合）精度训练而不是 32 位训练。需要 Ampere 或更高版本的 NVIDIA 架构、Intel XPU、使用 CPU (use_cpu) 或 Ascend NPU。这是一个实验性 API，可能会发生变化。
  • fp16 (bool, 可选, 默认为 False) — 是否使用 fp16 16 位（混合）精度训练而不是 32 位训练。
  • fp16_opt_level (str, 可选, 默认为 'O1') — 对于 fp16 训练，Apex AMP 优化级别选择在 ['O0', 'O1', 'O2', 'O3'] 中。有关详细信息，请参阅 Apex 文档。
  • fp16_backend (str, 可选, 默认为 "auto") — 此参数已弃用。请改用 half_precision_backend。
  • half_precision_backend (str, 可选, 默认为 "auto") — 用于混合精度训练的后端。必须是 "auto", "apex", "cpu_amp" 之一。 "auto" 将根据检测到的 PyTorch 版本使用 CPU/CUDA AMP 或 APEX，而其他选项将强制使用请求的后端。
  • bf16_full_eval (bool, 可选, 默认为 False) — 是否使用完整的 bfloat16 评估而不是 32 位。这将更快并节省内存，但可能会损害度量值。这是一个实验性 API，可能会发生变化。
  • fp16_full_eval (bool, 可选, 默认为 False) — 是否使用完整的 float16 评估而不是 32 位。这将更快并节省内存，但可能会损害度量值。
  • tf32 (bool, 可选) — 是否启用 TF32 模式，该模式在 Ampere 及更高版本的 GPU 架构中可用。默认值取决于 PyTorch 的 torch.backends.cuda.matmul.allow_tf32 的默认版本。更多详细信息请参阅 TF32 文档。这是一个实验性 API，可能会发生变化。
  • local_rank (int, 可选, 默认为 -1) — 分布式训练期间的进程排名。
  • ddp_backend (str, 可选) — 用于分布式训练的后端。必须是 "nccl"、"mpi"、"ccl"、"gloo"、"hccl" 之一。
  • tpu_num_cores (int, 可选) — 在 TPU 上训练时，TPU 核心的数量（由启动器脚本自动传入）。
  • dataloader_drop_last (bool, 可选, 默认为 False) — 是否丢弃最后一个不完整的批次（如果数据集的长度不能被批次大小整除）。
  • eval_steps (int 或 float, 可选) — 如果 eval_strategy="steps"，则两次评估之间的更新步数。如果未设置，将默认为与 logging_steps 相同的值。应为整数或范围 [0,1) 内的浮点数。如果小于 1，则解释为总训练步数的比例。
  • dataloader_num_workers (int, 可选, 默认为 0) — 用于数据加载的子进程数量（仅限 PyTorch）。0 表示数据将在主进程中加载。
  • past_index (int, 可选, 默认为 -1) — 某些模型，如 TransformerXL 或 XLNet，可以利用过去的隐藏状态进行预测。如果此参数设置为正整数，则 Trainer 将使用相应的输出（通常是索引 2）作为过去状态，并在下一个训练步骤中将其作为关键字参数 mems 馈送给模型。
  • run_name (str, 可选, 默认为 output_dir) — 运行的描述符。通常用于 wandb、mlflow、comet 和 swanlab 日志记录。如果未指定，将与 output_dir 相同。
  • disable_tqdm (bool, 可选) — 是否禁用 tqdm 进度条和 Jupyter Notebooks 中 ~notebook.NotebookTrainingTracker 生成的指标表。如果日志级别设置为警告或更低（默认），则默认为 True，否则为 False。
  • remove_unused_columns (bool, 可选, 默认为 True) — 是否自动删除模型 forward 方法未使用的列。
  • label_names (list[str], 可选) — 输入字典中与标签对应的键列表。

    最终将默认为模型接受的包含“label”字样的参数名称列表，但如果使用的模型是 XxxForQuestionAnswering 中的一个，则还将包括 ["start_positions", "end_positions"] 键。

  • load_best_model_at_end (bool, 可选, 默认为 False) — 是否在训练结束时加载训练期间找到的最佳模型。启用此选项后，最佳检查点将始终被保存。更多信息请参阅 save_total_limit。

    当设置为 True 时，参数 save_strategy 需要与 eval_strategy 相同，如果为“steps”，则 save_steps 必须是 eval_steps 的整数倍。
  • metric_for_best_model (str, 可选) — 与 load_best_model_at_end 结合使用，以指定用于比较两个不同模型的指标。必须是评估返回的指标名称，可以带或不带前缀 "eval_"。

    如果未指定，当 load_best_model_at_end == True 或 lr_scheduler_type == SchedulerType.REDUCE_ON_PLATEAU 时，此项将默认为 "loss"（以使用评估损失）。

    如果设置此值，除非名称以“loss”结尾，否则 greater_is_better 将默认为 True。如果您的指标越低越好，请务必将其设置为 False。

  • greater_is_better (bool, 可选) — 与 load_best_model_at_end 和 metric_for_best_model 结合使用，以指定更好的模型是否应具有更大的指标值。将默认为：

    • 如果 metric_for_best_model 设置为不以 "loss" 结尾的值，则为 True。
    • 如果 metric_for_best_model 未设置，或设置为以 "loss" 结尾的值，则为 False。
  • ignore_data_skip (bool, 可选, 默认为 False) — 恢复训练时，是否跳过 epoch 和批次以使数据加载与之前的训练处于同一阶段。如果设置为 True，训练将更快开始（因为跳过步骤可能需要很长时间），但不会产生与中断训练相同的结果。
  • fsdp (bool, str 或 FSDPOption 列表, 可选, 默认为 '') — 使用 PyTorch 分布式并行训练（仅限分布式训练）。

    以下选项列表：

    • "full_shard"：分片参数、梯度和优化器状态。
    • "shard_grad_op"：分片优化器状态和梯度。
    • "hybrid_shard"：在节点内应用 FULL_SHARD，并在节点间复制参数。
    • "hybrid_shard_zero2"：在节点内应用 SHARD_GRAD_OP，并在节点间复制参数。
    • "offload"：将参数和梯度卸载到 CPU（仅与 "full_shard" 和 "shard_grad_op" 兼容）。
    • "auto_wrap"：使用 default_auto_wrap_policy 自动递归包装层，并使用 FSDP。
  • fsdp_config (str 或 dict, 可选) — 用于 fsdp（PyTorch 分布式并行训练）的配置。该值可以是 fsdp json 配置文件（例如，fsdp_config.json）的位置，也可以是已加载的 json 文件（以 dict 形式）。

    配置及其选项列表：

    • min_num_params (int, 可选, 默认为 0)：FSDP 默认自动包装的最小参数数量。（仅在传递 fsdp 字段时有用）。

    • transformer_layer_cls_to_wrap (list[str], 可选)：要包装的 Transformer 层类名列表（区分大小写），例如 BertLayer、GPTJBlock、T5Block 等（仅在传递 fsdp 标志时有用）。

    • backward_prefetch (str, 可选)：FSDP 的后向预取模式。控制何时预取下一组参数（仅在传递 fsdp 字段时有用）。

      以下选项列表：

      • "backward_pre"：在当前参数集的梯度计算之前预取下一组参数。
      • "backward_post"：在当前参数集的梯度计算之后预取下一组参数。

    • forward_prefetch (bool, 可选, 默认为 False)：FSDP 的前向预取模式（仅在传递 fsdp 字段时有用）。如果为 "True"，则 FSDP 在前向传播期间执行时明确预取下一个即将到来的 all-gather。

    • limit_all_gathers (bool, 可选, 默认为 False)：FSDP 的 limit_all_gathers（仅在传递 fsdp 字段时有用）。如果为 "True"，FSDP 明确同步 CPU 线程以防止过多的飞行中的 all-gather。

    • use_orig_params (bool, 可选, 默认为 True)：如果为 "True"，则允许在初始化期间使用非统一的 requires_grad，这意味着支持交错的冻结和可训练参数。在参数高效微调等情况下很有用。请参阅此 [博客](https://dev-discuss.pytorch.org/t/rethinking-pytorch-fully-sharded-data-parallel-fsdp-from-first-principles/1019)

    • sync_module_states (bool, 可选, 默认为 True)：如果为 "True"，则每个单独包装的 FSDP 单元将从 rank 0 广播模块参数，以确保它们在初始化后在所有 rank 上都相同。

    • cpu_ram_efficient_loading (bool, 可选, 默认为 False)：如果为 "True"，则只有第一个进程加载预训练模型检查点，而所有其他进程的权重为空。当此设置为 "True" 时，sync_module_states 也必须设置为 "True"，否则除主进程外的所有进程都将具有随机权重，导致训练期间出现意外行为。

    • activation_checkpointing (bool, 可选, 默认为 False)：如果为 "True"，则激活检查点是一种通过清除某些层的激活并在反向传播期间重新计算它们来减少内存使用量的技术。实际上，这会牺牲额外的计算时间来减少内存使用量。

    • xla (bool, 可选, 默认为 False)：是否使用 PyTorch/XLA 完全分片数据并行训练。这是一个实验性功能，其 API 未来可能会发生变化。

    • xla_fsdp_settings (dict, 可选)：该值是一个字典，存储 XLA FSDP 包装参数。

      有关选项的完整列表，请参阅此处。

    • xla_fsdp_grad_ckpt (bool, 可选, 默认为 False)：将在每个嵌套的 XLA FSDP 包装层上使用梯度检查点。此设置仅在 xla 标志设置为 true 且通过 fsdp_min_num_params 或 fsdp_transformer_layer_cls_to_wrap 指定了自动包装策略时才能使用。
  • deepspeed (str 或 dict, 可选) — 使用 Deepspeed。这是一个实验性功能，其 API 未来可能会发生变化。该值可以是 DeepSpeed json 配置文件（例如，ds_config.json）的位置，也可以是已加载的 json 文件（以 dict 形式）。

    如果启用任何 Zero-init，请确保在初始化 `TrainingArguments` *之后* 才初始化模型，否则它将不被应用。
  • accelerator_config (str, dict 或 AcceleratorConfig, 可选) — 用于内部 Accelerator 实现的配置。该值可以是 accelerator json 配置文件（例如，accelerator_config.json）的位置，也可以是已加载的 json 文件（以 dict 形式），或者是 AcceleratorConfig 的实例。

    配置及其选项列表：

    • split_batches (bool, 可选, 默认为 False)：加速器是否应将数据加载器生成的批次拆分到各个设备上。如果为 True，则实际使用的批次大小在任何类型的分布式进程上都将相同，但它必须是您正在使用的 num_processes 的整数倍。如果为 False，则实际使用的批次大小将是您脚本中设置的批次大小乘以进程数。
    • dispatch_batches (bool, 可选)：如果设置为 True，则 Accelerator 准备的数据加载器仅在主进程上迭代，然后批次被拆分并广播到每个进程。对于底层数据集是 IterableDataset 的 DataLoader，默认值为 True，否则为 False。
    • even_batches (bool, 可选, 默认为 True)：如果设置为 True，在所有进程的总批次大小不能精确地除以数据集的情况下，数据集开头的样本将被复制，以便批次可以均匀地分配给所有工作进程。
    • use_seedable_sampler (bool, 可选, 默认为 True)：是否使用完全可种子化的随机采样器 (accelerate.data_loader.SeedableRandomSampler)。确保训练结果可以使用不同的采样技术完全重现。虽然种子到种子的结果可能不同，但在使用多个不同种子进行比较时，差异平均可忽略不计。为了获得最佳结果，还应与 ~utils.set_seed 一起运行。
    • use_configured_state (bool, 可选, 默认为 False)：是否使用在调用 TrainingArguments 之前定义的预配置 AcceleratorState 或 PartialState。如果为 True，则必须初始化 Accelerator 或 PartialState。请注意，这样做可能会导致超参数调整出现问题。
  • label_smoothing_factor (float, 可选, 默认为 0.0) — 要使用的标签平滑因子。零表示不进行标签平滑，否则底层独热编码标签将分别从 0 和 1 更改为 label_smoothing_factor/num_labels 和 1 - label_smoothing_factor + label_smoothing_factor/num_labels。
  • debug (str 或 DebugOption 列表, 可选, 默认为 "") — 启用一个或多个调试功能。这是一个实验性功能。

    可能的选项有：

    • "underflow_overflow"：检测模型输入/输出中的溢出，并报告导致该事件的最后几帧
    • "tpu_metrics_debug"：在 TPU 上打印调试指标

    选项应由空格分隔。

  • optim (str 或 training_args.OptimizerNames, 可选, 默认为 "adamw_torch") — 要使用的优化器，例如“adamw_torch”、“adamw_torch_fused”、“adamw_apex_fused”、“adamw_anyprecision”、“adafactor”。有关优化器的完整列表，请参阅 training_args.py 中的 OptimizerNames。
  • optim_args (str, 可选) — 提供给优化器（如 AnyPrecisionAdamW、AdEMAMix 和 GaLore）的可选参数。
  • group_by_length (bool, 可选, 默认为 False) — 是否在训练数据集中将大致相同长度的样本分组在一起（以最小化填充并提高效率）。仅在应用动态填充时有用。
  • length_column_name (str, 可选, 默认为 "length") — 预计算长度的列名。如果该列存在，按长度分组将使用这些值，而不是在训练启动时计算它们。除非 group_by_length 为 True 且数据集是 Dataset 的实例，否则此参数将被忽略。
  • report_to (str 或 list[str], 可选, 默认为 "all") — 用于报告结果和日志的集成列表。支持的平台有 "azure_ml"、"clearml"、"codecarbon"、"comet_ml"、"dagshub"、"dvclive"、"flyte"、"mlflow"、"neptune"、"swanlab"、"tensorboard" 和 "wandb"。使用 "all" 表示向所有已安装的集成报告，使用 "none" 表示不报告任何集成。
  • ddp_find_unused_parameters (bool, 可选) — 使用分布式训练时，传递给 DistributedDataParallel 的 find_unused_parameters 标志的值。如果使用梯度检查点，则默认为 False，否则为 True。
  • ddp_bucket_cap_mb (int, 可选) — 使用分布式训练时，传递给 DistributedDataParallel 的 bucket_cap_mb 标志的值。
  • ddp_broadcast_buffers (bool, 可选) — 使用分布式训练时，传递给 DistributedDataParallel 的 broadcast_buffers 标志的值。如果使用梯度检查点，则默认为 False，否则为 True。
  • dataloader_pin_memory (bool, 可选, 默认为 True) — 是否要在数据加载器中固定内存。默认为 True。
  • dataloader_persistent_workers (bool, 可选, 默认为 False) — 如果为 True，数据加载器在数据集消耗一次后不会关闭工作进程。这允许保持工作进程的 Dataset 实例处于活动状态。这可能会加速训练，但会增加 RAM 使用量。默认为 False。
  • dataloader_prefetch_factor (int, 可选) — 每个工作进程预加载的批次数量。2 表示所有工作进程总共预加载 2 * num_workers 个批次。
  • skip_memory_metrics (bool, 可选, 默认为 True) — 是否跳过将内存分析器报告添加到指标中。默认情况下跳过此操作，因为它会降低训练和评估速度。
  • push_to_hub (bool, 可选, 默认为 False) — 每次保存模型时是否将模型推送到 Hub。如果启用此功能，output_dir 将成为与存储库（由 hub_model_id 确定）同步的 Git 目录，并且每次触发保存时（取决于您的 save_strategy）都会推送内容。调用 save_model() 也会触发推送。

    如果 output_dir 存在，它需要是与 Trainer 将被推送到的存储库的本地克隆。
  • resume_from_checkpoint (str, 可选) — 包含模型有效检查点的文件夹路径。此参数不直接由 Trainer 使用，而是旨在由您的训练/评估脚本使用。有关更多详细信息，请参阅示例脚本。
  • hub_model_id (str, 可选) — 与本地 output_dir 同步的存储库名称。它可以是一个简单的模型 ID，在这种情况下，模型将被推送到您的命名空间中。否则，它应该是一个完整的存储库名称，例如 "user_name/model"，这允许您将模型推送到您作为成员的组织，例如 "organization_name/model"。默认为 user_name/output_dir_name，其中 output_dir_name 是 output_dir 的名称。

    默认为 output_dir 的名称。

  • hub_strategy (str 或 HubStrategy, 可选, 默认为 "every_save") — 定义推送到 Hub 的范围和时间。可能的值有：

    • "end": 调用 save_model() 方法时，推送模型、其配置、处理类（例如 tokenizer，如果传递给 Trainer）和模型卡的草稿。
    • "every_save": 每次保存模型时，推送模型、其配置、处理类（例如 tokenizer，如果传递给 Trainer）和模型卡的草稿。推送是异步的，以避免阻塞训练，如果保存非常频繁，只有在前一次推送完成后才会尝试新的推送。训练结束时，会用最终模型进行最后一次推送。
    • "checkpoint": 与 "every_save" 类似，但最新的检查点也会推送到名为 last-checkpoint 的子文件夹中，允许您使用 trainer.train(resume_from_checkpoint="last-checkpoint") 轻松恢复训练。
    • "all_checkpoints": 与 "checkpoint" 类似，但所有检查点都会按其在输出文件夹中的显示方式推送（因此您最终的存储库中每个文件夹都会有一个检查点文件夹）
  • hub_token (str, 可选) — 用于将模型推送到 Hub 的令牌。默认为使用 huggingface-cli login 获取的缓存文件夹中的令牌。
  • hub_private_repo (bool, 可选) — 是否将存储库设为私有。如果为 None（默认），则除非组织默认设置为私有，否则存储库将是公开的。如果存储库已存在，则此值将被忽略。
  • hub_always_push (bool, 可选, 默认为 False) — 除非此项为 True，否则 Trainer 将跳过在上次推送未完成时推送检查点。
  • hub_revision (str, 可选) — 推送到 Hub 时使用的修订版本。可以是分支名称、标签或提交哈希。
  • gradient_checkpointing (bool, 可选, 默认为 False) — 如果为 True，使用梯度检查点来节省内存，代价是反向传播速度较慢。
  • gradient_checkpointing_kwargs (dict, 可选, 默认为 None) — 将传递给 gradient_checkpointing_enable 方法的关键字参数。
  • include_inputs_for_metrics (bool, 可选, 默认为 False) — 此参数已弃用。请改用 include_for_metrics，例如 include_for_metrics = ["inputs"]。
  • include_for_metrics (list[str], 可选, 默认为 []) — 如果需要计算指标，则在 compute_metrics 函数中包含额外数据。可以添加到 include_for_metrics 列表的可能选项有：

    • "inputs": 传递给模型的输入数据，用于计算依赖于输入的指标。
    • "loss": 评估期间计算的损失值，用于计算依赖于损失的指标。
  • eval_do_concat_batches (bool, 可选, 默认为 True) — 是否在批次之间递归连接输入/损失/标签/预测。如果为 False，则会将它们存储为列表，每个批次保持独立。
  • auto_find_batch_size (bool, 可选, 默认为 False) — 是否通过指数衰减自动查找适合内存的批次大小，避免 CUDA 内存不足错误。需要安装 accelerate（pip install accelerate）。
  • full_determinism (bool, 可选, 默认为 False) — 如果为 True，则调用 enable_full_determinism() 而不是 set_seed() 以确保分布式训练中的可重现结果。重要提示：这将对性能产生负面影响，因此仅用于调试。
  • torchdynamo (str, 可选) — 如果设置，则为 TorchDynamo 的后端编译器。可能的选项有 "eager"、"aot_eager"、"inductor"、"nvfuser"、"aot_nvfuser"、"aot_cudagraphs"、"ofi"、"fx2trt"、"onnxrt" 和 "ipex"。
  • ray_scope (str, 可选, 默认为 "last") — 使用 Ray 进行超参数搜索时使用的范围。默认情况下，将使用 "last"。Ray 将使用所有试验的最后一个检查点，进行比较，并选择最佳的。但是，还有其他选项可用。有关更多选项，请参阅 Ray 文档。
  • ddp_timeout (int, 可选, 默认为 1800) — torch.distributed.init_process_group 调用的超时时间，用于在分布式运行中执行慢速操作时避免 GPU 套接字超时。有关更多信息，请参阅 [PyTorch 文档] (https://pytorch.ac.cn/docs/stable/distributed.html#torch.distributed.init_process_group)。
  • use_mps_device (bool, 可选, 默认为 False) — 此参数已弃用。如果可用，将使用 mps 设备，类似于 cuda 设备。
  • torch_compile (bool, 可选, 默认为 False) — 是否使用 PyTorch 2.0 torch.compile 编译模型。

    这将使用 torch.compile API 的最佳默认设置。您可以使用参数 torch_compile_backend 和 torch_compile_mode 自定义默认设置，但我们不保证它们中的任何一个都能正常工作，因为 PyTorch 正在逐步推出支持。

    此标志和整个编译 API 是实验性的，未来版本可能会更改。

  • torch_compile_backend (str, 可选) — torch.compile 中使用的后端。如果设置为任何值，torch_compile 将设置为 True。

    有关可能的值，请参阅 PyTorch 文档，并注意它们可能因 PyTorch 版本而异。

    此标志是实验性的，未来版本可能会更改。

  • torch_compile_mode (str, 可选) — torch.compile 中使用的模式。如果设置为任何值，torch_compile 将设置为 True。

    有关可能的值，请参阅 PyTorch 文档，并注意它们可能因 PyTorch 版本而异。

    此标志是实验性的，未来版本可能会更改。

  • include_tokens_per_second (bool, 可选) — 是否计算每个设备每秒的 token 数量以衡量训练速度。

    这将预先迭代整个训练数据加载器一次，

    并将减慢整个过程。

  • include_num_input_tokens_seen (bool, 可选) — 是否跟踪训练过程中看到的输入 token 数量。

    在分布式训练中可能较慢，因为必须调用 gather 操作。

  • neftune_noise_alpha (Optional[float]) — 如果不是 None，这将激活 NEFTune 噪声嵌入。这可以显著提高指令微调的模型性能。请查看原始论文和原始代码。支持 transformers PreTrainedModel 以及 peft 中的 PeftModel。原始论文中使用的值范围是 [5.0, 15.0]。
  • optim_target_modules (Union[str, list[str]], 可选) — 要优化的目标模块，即您希望训练的模块名称。目前用于 GaLore 算法（https://huggingface.ac.cn/papers/2403.03507）和 APOLLO 算法（https://huggingface.co/papers/2412.05270）。有关更多详细信息，请参阅 GaLore 实现（https://github.com/jiaweizzhao/GaLore）和 APOLLO 实现（https://github.com/zhuhanqing/APOLLO）。您需要确保传递有效的 GaLore 或 APOLLO 优化器，例如：“apollo_adamw”、“galore_adamw”、“galore_adamw_8bit”、“galore_adafactor”，并确保目标模块仅为 nn.Linear 模块。
  • batch_eval_metrics (Optional[bool], 默认为 False) — 如果设置为 True，评估将在每个批次结束时调用 compute_metrics 以累积统计信息，而不是将所有评估 logits 保存在内存中。当设置为 True 时，您必须传递一个 compute_metrics 函数，该函数接受一个布尔参数 compute_result，当传入 True 时，将从您在评估集上累积的批次级摘要统计信息中触发最终的全局摘要统计信息。
  • eval_on_start (bool, 可选, 默认为 False) — 是否在训练前执行评估步骤（健全性检查），以确保验证步骤正常工作。
  • eval_use_gather_object (bool, 可选, 默认为 False) — 是否在嵌套列表/元组/字典对象中递归收集所有设备的对象。只有当用户不只是返回张量时才应启用此功能，PyTorch 积极不鼓励这样做。
  • use_liger_kernel (bool, 可选, 默认为 False) — 是否为 LLM 模型训练启用 Liger 内核。它能有效提高多 GPU 训练吞吐量约 20%，并减少内存使用约 60%，可与 flash attention、PyTorch FSDP 和 Microsoft DeepSpeed 开箱即用。目前，它支持 llama、mistral、mixtral 和 gemma 模型。
  • liger_kernel_config (Optional[dict], 可选) — 用于 Liger 内核的配置。当 use_liger_kernel=True 时，此字典将作为关键字参数传递给 _apply_liger_kernel_to_instance 函数，该函数指定要应用哪些内核。可用选项因模型而异，但通常包括：‘rope’、‘swiglu’、‘cross_entropy’、‘fused_linear_cross_entropy’、‘rms_norm’ 等。如果为 None，则使用默认内核配置。
  • average_tokens_across_devices (bool, 可选, 默认为 False) — 是否跨设备平均 token。如果启用，将使用 all_reduce 同步 num_tokens_in_batch 以进行精确的损失计算。参考：https://github.com/huggingface/transformers/issues/34242
  • predict_with_generate (bool, 可选, 默认为 False) — 是否使用生成来计算生成指标（ROUGE、BLEU）。
  • generation_max_length (int, 可选) — 当 predict_with_generate=True 时，每个评估循环中使用的 max_length。将默认为模型配置的 max_length 值。
  • generation_num_beams (int, 可选) — 当 predict_with_generate=True 时，每个评估循环中使用的 num_beams。将默认为模型配置的 num_beams 值。
  • generation_config (str 或 Path 或 GenerationConfig, 可选) — 允许从 from_pretrained 方法加载 GenerationConfig。它可以是：

    • 一个字符串，huggingface.co 上模型仓库中预训练模型配置的 模型 ID。
    • 一个 目录 的路径，其中包含使用 save_pretrained() 方法保存的配置文件，例如 ./my_model_directory/。
    • 一个 GenerationConfig 对象。

TrainingArguments 是我们在示例脚本中使用的参数子集，它们与训练循环本身相关。

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

to_dict

< >

( )

此实例序列化时，将 Enum 替换为其值，将 GenerationConfig 替换为字典（为了支持 JSON 序列化）。它通过移除其值来混淆令牌值。

< > 在 GitHub 上更新

←分词器 DeepSpeed→