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"

训练器

类 transformers.Trainer

< >

( model: Union = None args: TrainingArguments = None data_collator: Optional = None train_dataset: Union = None eval_dataset: Union = None tokenizer: Optional = None model_init: Optional = None compute_metrics: Optional = None callbacks: Optional = None optimizers: Tuple = (None, None) preprocess_logits_for_metrics: Optional = 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 的元素列表中形成批次的函数。如果没有提供 tokenizer，则默认为 default_data_collator()，否则为 DataCollatorWithPadding 的实例。
  • train_dataset (Union[torch.utils.data.Dataset, torch.utils.data.IterableDataset, datasets.Dataset], 可选) — 用于训练的数据集。如果它是 Dataset，则 model.forward() 方法不接受的列将被自动删除。

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

  • eval_dataset (Union[torch.utils.data.Dataset, Dict[str, torch.utils.data.Dataset, datasets.Dataset]), 可选) — 用于评估的数据集。如果它是 Dataset，则 model.forward() 方法不接受的列将被自动删除。如果它是一个字典，它将在每个数据集上进行评估，并将字典键添加到指标名称的前面。
  • tokenizer (PreTrainedTokenizerBase, 可选) — 用于预处理数据的分词器。如果提供，将在对输入进行批处理时自动将输入填充到最大长度，并且它将与模型一起保存，以便更容易地重新运行中断的训练或重用微调模型。
  • model_init (Callable[[], PreTrainedModel], 可选) — 实例化要使用的模型的函数。如果提供，每次调用 train() 将从此函数给出的模型的新实例开始。

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

  • compute_metrics (Callable[[EvalPrediction], Dict], 可选) — 用于在评估时计算指标的函数。必须接受一个 EvalPrediction 并返回一个字符串到指标值的字典。注意 当传递带有 batch_eval_metrics 设置为 True 的 TrainingArgs 时，你的 compute_metrics 函数必须接受一个布尔值 compute_result 参数。这将在最后一个评估批次之后触发，以指示该函数需要计算并返回全局汇总统计信息，而不是累积批次级别的统计信息。
  • callbacks (TrainerCallback 列表, 可选) — 用于自定义训练循环的回调列表。将把这些添加到 此处 详细介绍的默认回调列表中。

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

  • optimizers (Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR], 可选, 默认为 (None, None)) — 包含要使用的优化器和调度器的元组。将默认为你的模型上的 AdamW 实例和由 args 控制的 get_linear_schedule_with_warmup() 给出的调度器。
  • 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 时）

add_callback

< >

( callback )

参数

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

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

autocast_smart_context_manager

< >

( cache_enabled: Optional = True )

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

compute_loss

< >

( model inputs return_outputs = False )

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

子类化并覆盖以实现自定义行为。

compute_loss_context_manager

< >

( )

一个辅助包装器，用于将上下文管理器组合在一起。

create_model_card

< >

( language: Optional = None license: Optional = None tags: Union = None model_name: Optional = None finetuned_from: Optional = None tasks: Union = None dataset_tags: Union = None dataset: Union = None dataset_args: Union = 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 可用的信息创建模型卡片草稿。

create_optimizer

< >

( )

设置优化器。

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

create_optimizer_and_scheduler

< >

( num_training_steps: int )

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

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

create_scheduler

< >

( num_training_steps: int optimizer: Optimizer = None )

参数

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

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

evaluate

< >

( eval_dataset: Union = None ignore_keys: Optional = None metric_key_prefix: str = 'eval' )

参数

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

    如果您传递一个字典，其中数据集的名称作为键，数据集作为值，则 evaluate 将在每个数据集上运行单独的评估。这对于监控训练如何影响其他数据集或简单地获得更细粒度的评估很有用。与 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: Optional = None ignore_keys: Optional = None metric_key_prefix: str = 'eval' )

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

无论是否有标签都可以工作。

floating_point_ops

< >

( inputs: Dict ) → int

参数

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

返回值

int

浮点运算次数。

对于继承自 PreTrainedModel 的模型，使用该方法计算每次反向 + 正向传递的浮点运算次数。如果使用其他模型，请在模型中实现此类方法或创建子类并覆盖此方法。

get_decay_parameter_names

< >

( model )

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

请注意，某些模型实现了自己的层归一化，而不是调用 nn.LayerNorm，权重衰减仍然可以应用于这些模块，因为此函数只过滤掉 nn.LayerNorm 的实例

get_eval_dataloader

< >

( eval_dataset: Union = 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: Optional = None )

参数

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

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

get_optimizer_group

< >

( param: Union = 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_train_dataloader

< >

( )

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

如果 train_dataset 没有实现 __len__ 方法，则不使用任何采样器；否则，将使用随机采样器（如果需要，将适配分布式训练）。

如果要注入一些自定义行为，请创建子类并覆盖此方法。

超参数搜索

< >

( hp_space: Optional = None compute_objective: Optional = None n_trials: int = 20 direction: Union = 'minimize' backend: Union = None hp_name: Optional = 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") — 如果是单目标优化，direction 是 str 类型，可以是 "minimize" 或 "maximize"，当优化验证损失时，您应该选择 "minimize"，当优化一个或多个指标时，您应该选择 "maximize"。如果是多目标优化，direction 是 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]，可选) — 传递给 optuna.create_study 或 ray.tune.run 的其他关键字参数。更多信息请参见：

返回值

[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: Optional = None )

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

is_local_process_zero

< >

( )

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

is_world_process_zero

< >

( )

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

log

< >

( logs: Dict )

参数

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

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

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

log_metrics

< >

( split metrics )

参数

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

以特殊格式记录指标

在分布式环境下，这仅针对等级为 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 的梯度和优化器状态。也许将来这些报告会发展到也测量这些。

CPU RAM 指标测量 RSS（常驻集大小）包括进程独有的内存和与其他进程共享的内存。需要注意的是，它不包括换出的内存，因此报告可能不准确。

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 调用之外的内存分配。

由于 evaluation 调用可能在 train 期间发生，我们无法处理嵌套调用，因为 torch.cuda.max_memory_allocated 是单个计数器，因此如果它被嵌套的 eval 调用重置，train 的跟踪器将报告错误信息。如果此 PyTorch 问题 得到解决，则可以将此类更改为可重入。在此之前，我们将仅跟踪 train、evaluate 和 predict 方法的外部级别。这意味着如果在 train 期间调用 eval，则后者将考虑其内存使用情况以及前者的内存使用情况。

这也意味着，如果与 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]) — 从 train/evaluate/predict 返回的指标

返回值

metrics (Dict[str, float])

重新格式化的指标

将 Trainer 指标值重新格式化为人类可读的格式

num_examples

< >

( dataloader: DataLoader )

通过访问其数据集，获取 ~torch.utils.data.DataLoader 中样本数量的辅助函数。当 dataloader.dataset 不存在或没有长度时，尽可能进行估计

num_tokens

< >

( train_dl: DataLoader max_steps: Optional = None )

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

pop_callback

< >

( callback ) → TrainerCallback

参数

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

返回值

TrainerCallback

如果找到，则移除回调。

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

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

predict

< >

( test_dataset: Dataset ignore_keys: Optional = 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() 中所示。

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

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

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

prediction_loop

< >

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

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

无论是否有标签都可以工作。

prediction_step

< >

( model: Module inputs: Dict prediction_loss_only: bool ignore_keys: Optional = None ) → Tuple[Optional[torch.Tensor], Optional[torch.Tensor], Optional[torch.Tensor]]

参数

  • model (nn.Module) — 要评估的模型。
  • inputs (Dict[str, Union[torch.Tensor, Any]]) — 模型的输入和目标。

    字典将在被馈送到模型之前被解包。大多数模型期望目标在参数 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: Optional = 'End of training' blocking: bool = True token: Optional = None revision: Optional = 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.tokenizer 上传到 🤗 模型中心的 self.args.hub_model_id 仓库。

remove_callback

< >

( callback )

参数

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

从当前 TrainerCallback 列表中删除一个回调。

save_metrics

< >

( split metrics combined = True )

参数

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

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

在分布式环境下，这仅针对等级为 0 的进程执行。

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

save_model

< >

( output_dir: Optional = None _internal_call: bool = False )

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

只会从主进程保存。

save_state

< >

( )

保存 Trainer 状态，因为 Trainer.save_model 只保存模型的 tokenizer。

在分布式环境下，这仅针对等级为 0 的进程执行。

train

< >

( resume_from_checkpoint: Union = None trial: Union = None ignore_keys_for_eval: Optional = None **kwargs )

参数

  • resume_from_checkpoint (str 或 bool，可选) — 如果是 str，则为先前 Trainer 实例保存的已保存检查点的本地路径。如果是 bool 且等于 True，则加载 args.output_dir 中先前 Trainer 实例保存的最后一个检查点。如果存在，训练将从这里加载的模型/优化器/调度器状态恢复。
  • trial (optuna.Trial 或 Dict[str, Any]，可选) — 用于超参数搜索的试运行或超参数字典。
  • ignore_keys_for_eval (List[str]，可选) — 模型输出（如果它是字典）中应该在训练期间收集用于评估的预测时忽略的键列表。
  • kwargs (Dict[str, Any], 可选) — 用于隐藏弃用参数的附加关键字参数

主要的训练入口点。

training_step

< >

( model: Module inputs: Dict ) → torch.Tensor

参数

  • model (nn.Module) — 要训练的模型。
  • inputs (Dict[str, Union[torch.Tensor, Any]]) — 模型的输入和目标。

    字典将在馈送到模型之前被解包。大多数模型期望目标在参数 labels 下。查看模型的文档以了解所有可接受的参数。

返回值

torch.Tensor

此批次的训练损失张量。

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

子类化并覆盖以注入自定义行为。

Seq2SeqTrainer

类 transformers.Seq2SeqTrainer

< >

( model: Union = None args: TrainingArguments = None data_collator: Optional = None train_dataset: Optional = None eval_dataset: Union = None tokenizer: Optional = None model_init: Optional = None compute_metrics: Optional = None callbacks: Optional = None optimizers: Tuple = (None, None) preprocess_logits_for_metrics: Optional = None )

evaluate

< >

( eval_dataset: Optional = None ignore_keys: Optional = 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 的 kwargs。

运行评估并返回指标。

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

您还可以创建子类并覆盖此方法以注入自定义行为。

predict

< >

( test_dataset: Dataset ignore_keys: Optional = None metric_key_prefix: str = 'test' **gen_kwargs )

参数

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

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

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

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

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

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

训练参数

类 transformers.TrainingArguments

< >

( output_dir: str overwrite_output_dir: bool = False do_train: bool = False do_eval: bool = False do_predict: bool = False eval_strategy: Union = 'no' prediction_loss_only: bool = False per_device_train_batch_size: int = 8 per_device_eval_batch_size: int = 8 per_gpu_train_batch_size: Optional = None per_gpu_eval_batch_size: Optional = None gradient_accumulation_steps: int = 1 eval_accumulation_steps: Optional = None eval_delay: Optional = 0 torch_empty_cache_steps: Optional = None learning_rate: float = 5e-05 weight_decay: float = 0.0 adam_beta1: float = 0.9 adam_beta2: float = 0.999 adam_epsilon: float = 1e-08 max_grad_norm: float = 1.0 num_train_epochs: float = 3.0 max_steps: int = -1 lr_scheduler_type: Union = 'linear' lr_scheduler_kwargs: Union = <factory> warmup_ratio: float = 0.0 warmup_steps: int = 0 log_level: Optional = 'passive' log_level_replica: Optional = 'warning' log_on_each_node: bool = True logging_dir: Optional = None logging_strategy: Union = 'steps' logging_first_step: bool = False logging_steps: float = 500 logging_nan_inf_filter: bool = True save_strategy: Union = 'steps' save_steps: float = 500 save_total_limit: Optional = None save_safetensors: Optional = True save_on_each_node: bool = False save_only_model: bool = False restore_callback_states_from_checkpoint: bool = False no_cuda: bool = False use_cpu: bool = False use_mps_device: bool = False seed: int = 42 data_seed: Optional = None jit_mode_eval: bool = False use_ipex: bool = False bf16: bool = False fp16: bool = False fp16_opt_level: str = 'O1' half_precision_backend: str = 'auto' bf16_full_eval: bool = False fp16_full_eval: bool = False tf32: Optional = None local_rank: int = -1 ddp_backend: Optional = None tpu_num_cores: Optional = None tpu_metrics_debug: bool = False debug: Union = '' dataloader_drop_last: bool = False eval_steps: Optional = None dataloader_num_workers: int = 0 dataloader_prefetch_factor: Optional = None past_index: int = -1 run_name: Optional = None disable_tqdm: Optional = None remove_unused_columns: Optional = True label_names: Optional = None load_best_model_at_end: Optional = False metric_for_best_model: Optional = None greater_is_better: Optional = None ignore_data_skip: bool = False fsdp: Union = '' fsdp_min_num_params: int = 0 fsdp_config: Union = None fsdp_transformer_layer_cls_to_wrap: Optional = None accelerator_config: Union = None deepspeed: Union = None label_smoothing_factor: float = 0.0 optim: Union = 'adamw_torch' optim_args: Optional = None adafactor: bool = False group_by_length: bool = False length_column_name: Optional = 'length' report_to: Union = None ddp_find_unused_parameters: Optional = None ddp_bucket_cap_mb: Optional = None ddp_broadcast_buffers: Optional = None dataloader_pin_memory: bool = True dataloader_persistent_workers: bool = False skip_memory_metrics: bool = True use_legacy_prediction_loop: bool = False push_to_hub: bool = False resume_from_checkpoint: Optional = None hub_model_id: Optional = None hub_strategy: Union = 'every_save' hub_token: Optional = None hub_private_repo: bool = False hub_always_push: bool = False gradient_checkpointing: bool = False gradient_checkpointing_kwargs: Union = None include_inputs_for_metrics: bool = False eval_do_concat_batches: bool = True fp16_backend: str = 'auto' evaluation_strategy: Union = None push_to_hub_model_id: Optional = None push_to_hub_organization: Optional = None push_to_hub_token: Optional = None mp_parameters: str = '' auto_find_batch_size: bool = False full_determinism: bool = False torchdynamo: Optional = None ray_scope: Optional = 'last' ddp_timeout: Optional = 1800 torch_compile: bool = False torch_compile_backend: Optional = None torch_compile_mode: Optional = None dispatch_batches: Optional = None split_batches: Optional = None include_tokens_per_second: Optional = False include_num_input_tokens_seen: Optional = False neftune_noise_alpha: Optional = None optim_target_modules: Union = None batch_eval_metrics: bool = False eval_on_start: bool = False use_liger_kernel: Optional = False eval_use_gather_object: Optional = False )

参数

  • output_dir (str) — 模型预测和检查点将写入的输出目录。
  • 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"：在每个时期结束时进行评估。
  • prediction_loss_only (bool，可选，默认为 False) — 在执行评估和生成预测时，仅返回损失。
  • per_device_train_batch_size (int，可选，默认为 8) — 训练时每个 GPU/XPU/TPU/MPS/NPU 核心/CPU 的批次大小。
  • per_device_eval_batch_size (int，可选，默认为 8) — 评估时每个 GPU/XPU/TPU/MPS/NPU 核心/CPU 的批次大小。
  • gradient_accumulation_steps (int，可选，默认为 1) — 在执行反向传播/更新步骤之前累积梯度的更新步骤数。

    使用梯度累积时，一步被计为一步反向传播。因此，日志记录、评估、保存将在每 gradient_accumulation_steps * xxx_step 个训练样本后进行。
  • eval_accumulation_steps (int，可选) — 在将结果移至 CPU 之前累积输出张量的预测步骤数。如果未设置，则所有预测将在 GPU/NPU/TPU 上累积，然后再移至 CPU（更快，但需要更多内存）。
  • eval_delay (float，可选) — 在执行第一次评估之前要等待的时期数或步骤数，具体取决于 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) — 要执行的训练 epochs 总数（如果不是整数，则在停止训练之前执行最后一个 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"：在每个时期结束时进行日志记录。
    • "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 或 IntervalStrategy，可选，默认为 "steps") — 训练期间采用的检查点保存策略。可能的值为：

    • "no"：训练期间不进行保存。
    • "epoch"：在每个时期结束时保存。
    • "steps"：每 save_steps 步保存一次。

    如果选择 "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) — 检查点时，是只保存模型，还是也保存优化器、调度器和随机数生成器状态。请注意，如果此选项为 true，您将无法从检查点恢复训练。这使您能够通过不存储优化器、调度器和随机数生成器状态来节省存储空间。您只能在将此选项设置为 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。 IPEX 安装。
  • bf16 (bool, 可选, 默认为 False) — 是否使用 bf16 16 位（混合）精度训练代替 32 位训练。需要 Ampere 或更高版本的 NVIDIA 架构或使用 CPU (use_cpu) 或 Ascend NPU。这是一个实验性 API，可能会发生变化。
  • fp16 (bool, 可选, 默认为 False) — 是否使用 fp16 16 位（混合）精度训练代替 32 位训练。
  • fp16_opt_level (str, 可选, 默认为 ‘O1’) — 对于 fp16 训练，Apex AMP 优化级别在 [‘O0’, ‘O1’, ‘O2’, and ‘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 日志记录。如果未指定，将与 output_dir 相同。
  • disable_tqdm (bool, 可选) — 是否禁用 Jupyter Notebook 中 ~notebook.NotebookTrainingTracker 生成的 tqdm 进度条和指标表。如果日志记录级别设置为警告或更低（默认），则默认为 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（使用评估损失），则默认为 "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) — 恢复训练时，是否跳过时期和批次以使数据加载与先前训练中的阶段相同。如果设置为 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 实现的配置。该值可以是加速器 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_hf”、“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"、"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，数据加载器在数据集被使用一次后不会关闭工作进程。这允许保持工作进程的数据集实例处于活动状态。可以潜在地加快训练速度，但会增加 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() 方法时，推送模型、其配置、分词器（如果传递给 Trainer）和模型卡片草稿。
    • "every_save"：每次保存模型时，推送模型、其配置、分词器（如果传递给 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，可选，默认为 False) — 如果为 True，则 Hub 存储库将设置为私有。
  • hub_always_push (bool，可选，默认为 False) — 除非此值为 True，否则当上一次推送未完成时，Trainer 将跳过推送检查点。
  • gradient_checkpointing (bool，可选，默认为 False) — 如果为 True，则使用梯度检查点来节省内存，但会降低反向传播速度。
  • gradient_checkpointing_kwargs (dict，可选，默认为 None) — 要传递给 gradient_checkpointing_enable 方法的关键字参数。
  • include_inputs_for_metrics (bool，可选，默认为 False) — 输入是否将传递给 compute_metrics 函数。这适用于需要输入、预测和参考进行评分计算的指标类。
  • 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 版本之间发生变化。

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

  • split_batches (bool, 可选) — 在分布式训练期间，加速器是否应该在设备之间拆分数据加载器生成的批次。如果

    设置为 True，则在任何类型的分布式进程上使用的实际批次大小都相同，但它必须是您正在使用的进程数（例如 GPU）的整数倍。

  • include_tokens_per_second (bool, 可选) — 是否计算每个设备每秒的标记数，以获得训练速度指标。

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

    并将减慢整个过程。

  • include_num_input_tokens_seen (bool, 可选) — 是否跟踪在整个训练过程中看到的输入标记数。

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

  • neftune_noise_alpha (Optional[float]) — 如果不为 None，这将激活 NEFTune 噪声嵌入。这可以极大地提高指令微调的模型性能。查看原始论文和原始代码。支持 transformers PreTrainedModel 以及来自 peft 的 PeftModel。原始论文使用的值范围为 [5.0, 15.0]。
  • optim_target_modules (Union[str, List[str]], 可选) — 要优化的目标模块，即您想要训练的模块名称，目前这仅用于 GaLore 算法 https://arxiv.org/abs/2403.03507 参见：https://github.com/jiaweizzhao/GaLore 了解更多详细信息。您需要确保传递有效的 GaloRe 优化器，例如： “galore_adamw”、“galore_adamw_8bit”、“galore_adafactor”，并确保目标模块仅为 nn.Linear 模块。
  • batch_eval_metrics (Optional[bool]，默认为 False) — 如果设置为 True，评估将在每个批次结束时调用 compute_metrics 以累积统计信息，而不是将所有评估 logits 保存在内存中。当设置为 True 时，您必须传递一个带有布尔参数 compute_result 的 compute_metrics 函数，当传递 True 时，它将根据您在评估集上累积的批次级汇总统计信息触发最终的全局汇总统计信息。
  • eval_on_start (bool, 可选, 默认为 False) — 是否在训练前执行评估步骤（健全性检查）以确保验证步骤正常工作。
  • eval_use_gather_object (bool, 可选, 默认为 False) — 是否在所有设备的对象的嵌套列表/元组/字典中递归运行 gather 对象。仅当用户不仅仅返回张量时才应启用此功能，并且 PyTorch 积极 discourage 这样做。
  • use_liger_kernel (bool, 可选, 默认为 False) — 是否启用 Liger Kernel 进行 LLM 模型训练。它可以有效地将多 GPU 训练吞吐量提高约 20%，并将内存使用量减少约 60%，开箱即用地支持闪存注意力、PyTorch FSDP 和 Microsoft DeepSpeed。目前，它支持 llama、mistral、mixtral 和 gemma 模型。

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

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

获取进程日志级别

< >

( )

根据此进程是节点 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，可选，默认为 True) — 如果为 True，则表示每个节点的排名为 0 的第一个进程；如果为 False，则表示节点排名为 0 的排名为 0 的第一个进程。在具有共享文件系统的多节点环境中，您很可能希望使用 local=False，以便只有第一个节点的主进程进行处理。但是，如果文件系统不共享，则每个节点的主进程都需要进行处理，这是默认行为。
  • desc (str，可选，默认为 "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: Optional = None auto_find_batch_size: bool = False ignore_data_skip: bool = False sampler_seed: Optional = None )

参数

  • drop_last (bool，可选，默认为 False) — 是否丢弃最后一个不完整的批次（如果数据集的长度不能被批次大小整除）。
  • num_workers (int，可选，默认为 0) — 用于数据加载的子进程数（仅限 PyTorch）。0 表示数据将在主进程中加载。
  • pin_memory (bool，可选，默认为 True) — 是否要在数据加载器中固定内存。默认为 True。
  • persistent_workers (bool，可选，默认为 False) — 如果为 True，则数据加载器在数据集被消费一次后不会关闭工作进程。这允许保持工作进程的数据集实例处于活动状态。可以潜在地加快训练速度，但会增加 RAM 使用量。默认为 False。
  • prefetch_factor (int，可选) — 每个工作进程预先加载的批次数。2 表示所有工作进程总共预取 2 * num_workers 个批次。
  • auto_find_batch_size (bool，可选，默认为 False) — 是否通过指数衰减自动查找适合内存的批次大小，避免 CUDA 内存不足错误。需要安装 accelerate (pip install accelerate)
  • ignore_data_skip (bool, 可选, 默认为 False) — 恢复训练时，是否跳过周期和批次以使数据加载到与先前训练相同的阶段。如果设置为 True，训练将开始得更快（因为跳过步骤可能需要很长时间），但不会产生与中断训练相同的结果。
  • sampler_seed (int, 可选) — 用于数据采样器的随机种子。如果未设置，则数据采样的随机生成器将使用与 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: Union = 'no' steps: int = 500 batch_size: int = 8 accumulation_steps: Optional = None delay: Optional = None loss_only: bool = False jit_mode: bool = False )

参数

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

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

    将 strategy 设置为不同于 "no" 的值将使 self.do_eval 设置为 True。

  • steps (int, 可选, 默认为 500) — 如果 strategy="steps"，则两次评估之间的更新步骤数。
  • batch_size (int 可选, 默认为 8) — 用于评估的每个设备（GPU/TPU 核心/CPU...）的批次大小。
  • accumulation_steps (int，可选) — 在将结果移动到 CPU 之前，累积输出张量的预测步骤数。如果未设置，则在移动到 CPU 之前，整个预测将在 GPU/TPU 上累积（速度更快，但需要更多内存）。
  • delay (float，可选) — 在执行第一次评估之前要等待的 epoch 数或步骤数，具体取决于 eval_strategy。
  • loss_only (bool，可选，默认为 False) — 忽略除损失以外的所有输出。
  • jit_mode (bool，可选) — 是否使用 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: Union = 'steps' steps: int = 500 report_to: Union = '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"、"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

设置学习率调度器

< >

( name: Union = '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) — 要执行的训练轮数总计（如果不是整数，则在停止训练之前执行最后一个轮次的十进制部分百分比）。
  • 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

设置优化器

< >

( name: Union = 'adamw_torch' learning_rate: float = 5e-05 weight_decay: float = 0 beta1: float = 0.9 beta2: float = 0.999 epsilon: float = 1e-08 args: Optional = None )

参数

  • name (str 或 training_args.OptimizerNames，可选，默认为 "adamw_torch") — 要使用的优化器："adamw_hf"、"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: Union = 'every_save' token: Optional = None private_repo: bool = False always_push: bool = False )

参数

  • 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) — 如果为 True，则 Hub 存储库将设置为私有。
  • always_push (bool, 可选, 默认为 False) — 除非此值为 True，否则当上一次推送未完成时，Trainer 将跳过推送检查点。

一种将所有与将检查点与 Hub 同步相关的参数重新组合的方法。

调用此方法会将 self.push_to_hub 设置为 True，这意味着 output_dir 将启动一个与仓库（由 model_id 确定）同步的 git 目录，并且每次触发保存时都会推送内容（取决于您的 self.save_strategy）。调用 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: Union = 'steps' steps: int = 500 total_limit: Optional = 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 核心/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 核心/CPU…）的批量大小。
  • weight_decay (float，可选，默认为 0) — 在优化器中应用于除所有偏差和 LayerNorm 权重之外的所有层的权重衰减（如果不为零）。
  • num_train_epochs(float， 可选，默认为 3.0) — 要执行的训练 epochs 总数（如果不是整数，将在停止训练前执行最后一个 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

类 transformers.Seq2SeqTrainingArguments

< >

( output_dir: str overwrite_output_dir: bool = False do_train: bool = False do_eval: bool = False do_predict: bool = False eval_strategy: Union = 'no' prediction_loss_only: bool = False per_device_train_batch_size: int = 8 per_device_eval_batch_size: int = 8 per_gpu_train_batch_size: Optional = None per_gpu_eval_batch_size: Optional = None gradient_accumulation_steps: int = 1 eval_accumulation_steps: Optional = None eval_delay: Optional = 0 torch_empty_cache_steps: Optional = None learning_rate: float = 5e-05 weight_decay: float = 0.0 adam_beta1: float = 0.9 adam_beta2: float = 0.999 adam_epsilon: float = 1e-08 max_grad_norm: float = 1.0 num_train_epochs: float = 3.0 max_steps: int = -1 lr_scheduler_type: Union = 'linear' lr_scheduler_kwargs: Union = <factory> warmup_ratio: float = 0.0 warmup_steps: int = 0 log_level: Optional = 'passive' log_level_replica: Optional = 'warning' log_on_each_node: bool = True logging_dir: Optional = None logging_strategy: Union = 'steps' logging_first_step: bool = False logging_steps: float = 500 logging_nan_inf_filter: bool = True save_strategy: Union = 'steps' save_steps: float = 500 save_total_limit: Optional = None save_safetensors: Optional = True save_on_each_node: bool = False save_only_model: bool = False restore_callback_states_from_checkpoint: bool = False no_cuda: bool = False use_cpu: bool = False use_mps_device: bool = False seed: int = 42 data_seed: Optional = None jit_mode_eval: bool = False use_ipex: bool = False bf16: bool = False fp16: bool = False fp16_opt_level: str = 'O1' half_precision_backend: str = 'auto' bf16_full_eval: bool = False fp16_full_eval: bool = False tf32: Optional = None local_rank: int = -1 ddp_backend: Optional = None tpu_num_cores: Optional = None tpu_metrics_debug: bool = False debug: Union = '' dataloader_drop_last: bool = False eval_steps: Optional = None dataloader_num_workers: int = 0 dataloader_prefetch_factor: Optional = None past_index: int = -1 run_name: Optional = None disable_tqdm: Optional = None remove_unused_columns: Optional = True label_names: Optional = None load_best_model_at_end: Optional = False metric_for_best_model: Optional = None greater_is_better: Optional = None ignore_data_skip: bool = False fsdp: Union = '' fsdp_min_num_params: int = 0 fsdp_config: Union = None fsdp_transformer_layer_cls_to_wrap: Optional = None accelerator_config: Union = None deepspeed: Union = None label_smoothing_factor: float = 0.0 optim: Union = 'adamw_torch' optim_args: Optional = None adafactor: bool = False group_by_length: bool = False length_column_name: Optional = 'length' report_to: Union = None ddp_find_unused_parameters: Optional = None ddp_bucket_cap_mb: Optional = None ddp_broadcast_buffers: Optional = None dataloader_pin_memory: bool = True dataloader_persistent_workers: bool = False skip_memory_metrics: bool = True use_legacy_prediction_loop: bool = False push_to_hub: bool = False resume_from_checkpoint: Optional = None hub_model_id: Optional = None hub_strategy: Union = 'every_save' hub_token: Optional = None hub_private_repo: bool = False hub_always_push: bool = False gradient_checkpointing: bool = False gradient_checkpointing_kwargs: Union = None include_inputs_for_metrics: bool = False eval_do_concat_batches: bool = True fp16_backend: str = 'auto' evaluation_strategy: Union = None push_to_hub_model_id: Optional = None push_to_hub_organization: Optional = None push_to_hub_token: Optional = None mp_parameters: str = '' auto_find_batch_size: bool = False full_determinism: bool = False torchdynamo: Optional = None ray_scope: Optional = 'last' ddp_timeout: Optional = 1800 torch_compile: bool = False torch_compile_backend: Optional = None torch_compile_mode: Optional = None dispatch_batches: Optional = None split_batches: Optional = None include_tokens_per_second: Optional = False include_num_input_tokens_seen: Optional = False neftune_noise_alpha: Optional = None optim_target_modules: Union = None batch_eval_metrics: bool = False eval_on_start: bool = False use_liger_kernel: Optional = False eval_use_gather_object: Optional = False sortish_sampler: bool = False predict_with_generate: bool = False generation_max_length: Optional = None generation_num_beams: Optional = None generation_config: Union = None )

参数

  • output_dir (str) — 模型预测和检查点将写入的输出目录。
  • 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) — 训练时每个 GPU/XPU/TPU/MPS/NPU 核心/CPU 的批次大小。
  • per_device_eval_batch_size (int, 可选, 默认为 8) — 评估时每个 GPU/XPU/TPU/MPS/NPU 核心/CPU 的批次大小。
  • gradient_accumulation_steps (int, 可选, 默认为 1) — 在执行反向传播/更新步骤之前累积梯度的更新步骤数。

    使用梯度累积时，一步计为一步反向传播。因此，日志记录、评估、保存将在每 gradient_accumulation_steps * xxx_step 个训练样本后进行。
  • eval_accumulation_steps (int, 可选) — 将结果移动到 CPU 之前累积输出张量的预测步骤数。如果未设置，则在移动到 CPU 之前，所有预测都会在 GPU/NPU/TPU 上累积（速度更快，但需要更多内存）。
  • 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) — 要执行的训练 epochs 总数（如果不是整数，则在停止训练之前执行最后一个 epoch 的小数部分百分比）。
  • max_steps (int，可选，默认为 -1) — 如果设置为正数，则为要执行的训练步数总数。 覆盖 num_train_epochs。 对于有限数据集，训练会通过数据集重复（如果所有数据都已用尽）直到达到 max_steps。
  • lr_scheduler_type (str 或 SchedulerType, 可选, 默认为 "linear") — 要使用的调度器类型。有关所有可能的值，请参阅 SchedulerType 的文档。
  • lr_scheduler_kwargs (‘dict’, 可选, 默认为 {}) — lr_scheduler 的额外参数。有关可能的值，请参阅每个调度器的文档。
  • 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 或 IntervalStrategy，可选，默认为 "steps") — 训练期间采用的检查点保存策略。可能的值为：

    • "no"：训练期间不保存。
    • "epoch"：在每个 epoch 结束时保存。
    • "steps"：每 save_steps 步保存一次。

    如果选择 "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 架构或使用 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 日志记录。如果未指定，将与 output_dir 相同。
  • disable_tqdm (bool, 可选) — 是否禁用 Jupyter Notebook 中 ~notebook.NotebookTrainingTracker 生成的 tqdm 进度条和指标表。如果日志级别设置为警告或更低（默认），则默认为 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（使用评估损失），则默认为 "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 和 batch 以使数据加载到与先前训练相同的阶段。如果设置为 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”

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

    配置及其选项列表：

    • split_batches (bool，可选，默认为 False)：加速器是否应该将数据加载器生成的批次拆分到各个设备上。如果为 True，则在任何类型的分布式进程上使用的实际批次大小都相同，但它必须是您正在使用的 num_processes 的整数倍。如果为 False，则使用的实际批次大小将是您在脚本中设置的值乘以进程数。
    • dispatch_batches (bool，可选)：如果设置为 True，则加速器准备的数据加载器仅在主进程上迭代，然后将批次拆分并广播到每个进程。对于底层数据集为 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_hf”、“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"、"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，则数据加载器在数据集被使用一次后不会关闭工作进程。这允许保持工作进程的数据集实例处于活动状态。可以潜在地加快训练速度，但会增加内存使用量。默认为 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() 方法时，推送模型、其配置、分词器（如果传递给 Trainer）和模型卡片草稿。
    • "every_save"：每次保存模型时，推送模型、其配置、分词器（如果传递给 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，可选，默认为 False) — 如果为 True，则 Hub 仓库将设置为私有。
  • hub_always_push (bool，可选，默认为 False) — 除非此值为 True，否则当上一次推送未完成时，Trainer 将跳过推送检查点。
  • gradient_checkpointing (bool，可选，默认为 False) — 如果为 True，则使用梯度检查点来节省内存，但会降低反向传播速度。
  • gradient_checkpointing_kwargs (dict，可选，默认为 None) — 要传递给 gradient_checkpointing_enable 方法的关键字参数。
  • include_inputs_for_metrics (bool，可选，默认为 False) — 是否将输入传递给 compute_metrics 函数。这适用于需要输入、预测和参考进行评分计算的指标类。
  • 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 版本中发生变化。

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

  • split_batches (bool，可选) — 是否加速器应该在分布式训练期间跨设备拆分数据加载器产生的批次。如果

    设置为 True，则在任何类型的分布式进程上使用的实际批次大小都相同，但它必须是您正在使用的进程数量（例如 GPU）的整数倍。

  • include_tokens_per_second (bool, 可选) — 是否计算每个设备每秒的标记数以获取训练速度指标。

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

    并且会减慢整个过程。

  • include_num_input_tokens_seen (bool, 可选) — 是否在整个训练过程中跟踪已看到的输入标记数。

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

  • neftune_noise_alpha (Optional[float]) — 如果不是 None，这将激活 NEFTune 噪声嵌入。这可以大大提高指令微调的模型性能。查看原始论文和原始代码。支持 transformers PreTrainedModel 以及来自 peft 的 PeftModel。原始论文使用的值范围为 [5.0, 15.0]。
  • optim_target_modules (Union[str, List[str]], 可选) — 要优化的目标模块，即您想要训练的模块名称，目前这仅用于 GaLore 算法 https://arxiv.org/abs/2403.03507 参见：https://github.com/jiaweizzhao/GaLore 获取更多详细信息。您需要确保传递一个有效的 GaloRe 优化器，例如：“galore_adamw”、“galore_adamw_8bit”、“galore_adafactor”中的一个，并确保目标模块仅为 nn.Linear 模块。
  • batch_eval_metrics (Optional[bool], 默认为 False) — 如果设置为 True，评估将在每个批次结束时调用 compute_metrics 来累积统计信息，而不是将所有评估 logits 保存在内存中。当设置为 True 时，您必须传递一个带有布尔参数 compute_result 的 compute_metrics 函数，当传递 True 时，将从您在评估集上累积的批次级汇总统计信息中触发最终的全局汇总统计信息。
  • eval_on_start (bool, 可选, 默认为 False) — 是否在训练开始前执行评估步骤（健全性检查）以确保验证步骤正常工作。
  • eval_use_gather_object (bool, 可选, 默认为 False) — 是否在嵌套列表/元组/对象字典中从所有设备递归运行收集对象。仅当用户不只是返回张量时才应启用此功能，并且 PyTorch 积极不鼓励这样做。
  • use_liger_kernel (bool，可选，默认为 False) — 是否启用 Liger 内核进行 LLM 模型训练。它可以有效地将多 GPU 训练吞吐量提高约 20%，并将内存使用量减少约 60%，可与 Flash Attention、PyTorch FSDP 和 Microsoft DeepSpeed 开箱即用。目前，它支持 llama、mistral、mixtral 和 gemma 模型。
  • sortish_sampler (bool，可选，默认为 False) — 是否使用类排序采样器。目前只有当底层数据集是 Seq2SeqDataset 时才有可能，但在不久的将来会普遍可用。

    它根据长度对输入进行排序，以最小化填充大小，并为训练集添加一些随机性。

  • predict_with_generate (bool，可选，默认为 False) — 是否使用 generate 计算生成指标（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→