Transformers 文档

训练器

Transformers

加入 Hugging Face 社区

并获得增强的文档体验

协作开发模型、数据集和 Spaces

通过加速推理获得更快的示例

切换文档主题

开始使用

训练器

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

class transformers.Trainer

( model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.modules.module.Module] = 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，用于在所有进程上必须相同的随机化（Trainer 将在每个 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 trial 对象的参数，以便能够根据超参数（例如层数、内部层的大小、dropout 概率等）选择不同的架构。
compute_loss_func (Callable, 可选) — 接受原始模型输出、标签和整个累积批次中的项目数（batch_size * gradient_accumulation_steps）并返回损失的函数。例如，请参阅 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 和 labels，并返回处理后的 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: typing.Optional[bool] = True )

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

compute_loss

( model inputs return_outputs = False num_items_in_batch = None )

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

子类化和重写以实现自定义行为。

compute_loss_context_manager

( )

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

create_model_card

( 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 可用的信息创建模型卡的草稿。

create_optimizer

( )

设置优化器。

我们提供了一个合理的默认值，效果良好。如果你想使用其他东西，你可以在 Trainer 的 init 中通过 optimizers 传递一个元组，或者在子类中子类化和重写此方法。

create_optimizer_and_scheduler

( num_training_steps: int )

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

我们提供了一个合理的默认值，效果良好。如果你想使用其他东西，你可以在 Trainer 的 init 中通过 optimizers 传递一个元组，或者在子类中子类化和重写此方法（或 create_optimizer 和/或 create_scheduler）。

create_scheduler

( num_training_steps: int optimizer: Optimizer = None )

参数

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

设置调度器。 Trainer 的优化器必须在此方法被调用之前设置好，或者作为参数传递。

evaluate

( 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__ 方法。

如果您传递一个字典，其中数据集名称作为键，数据集作为值，则 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: typing.Optional[bool] = None ignore_keys: typing.Optional[list[str]] = 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 )

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

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

按层类型（ALL_LAYERNORM_LAYERS 中指定的层的实例）
按参数名称模式（包含 'bias'、'layernorm' 或 'rmsnorm'）

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_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 or 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: 来自 optuna.study.create_study 的参数，以及来自 optuna.study.Study.optimize 的参数 timeout、n_jobs 和 gc_after_trial
- ray: 来自 tune.run 的参数。如果 kwargs 中未设置 resources_per_trial，则默认为 1 个 CPU 核心和 1 个 GPU（如果可用）。如果 kwargs 中未设置 progress_reporter，则使用 ray.tune.CLIReporter。
- sigopt: 来自 sigopt.Connection.set_proxies 的参数 proxies。

返回值

[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]) — 从 train/evaluate/predict 返回的指标：指标字典

以特殊格式记录指标

在分布式环境下，这仅对 rank 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 相加，您就知道完成该阶段需要多少内存。

报告仅针对 rank 0 的进程和 gpu 0（如果有 gpu）进行。通常这已足够，因为主进程完成了大部分工作，但如果使用模型并行，则可能并非如此，其他 GPU 可能会使用不同的 gpu 内存量。在 DataParallel 下情况也不同，gpu0 可能需要比其余 GPU 更多的内存，因为它存储了所有参与 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: typing.Optional[int] = None )

通过枚举 dataloader，帮助获取 ~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_loop

( 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) — 用于评估的模型。
inputs (Dict[str, Union[torch.Tensor, Any]]) — 模型的输入和目标。

字典将在被馈送到模型之前解包。大多数模型期望目标在 labels 参数下。请查看您模型的文档以获取所有接受的参数。
prediction_loss_only (bool) — 是否仅返回损失。
ignore_keys (List[str], optional) — 模型输出（如果是一个字典）中应该被忽略，以避免收集预测结果的键列表。

返回值

Tuple[Optional[torch.Tensor], Optional[torch.Tensor], Optional[torch.Tensor]]

包含 loss、logits 和 labels 的元组（每个都是可选的）。

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

将 self.model 和 self.processing_class 上传到 🤗 模型中心，仓库为 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]) — 从 train/evaluate/predict 返回的指标
combined (bool, optional, defaults to True) — 通过使用此调用的指标更新 all_results.json 来创建组合指标

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

在分布式环境下，这仅对 rank 0 的进程执行。

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

save_model

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

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

仅从主进程保存。

save_state

( )

保存 Trainer 状态，因为 Trainer.save_model 仅保存 tokenizer 和模型

在分布式环境下，这仅对 rank 0 的进程执行。

set_initial_training_values

( args: TrainingArguments dataloader: DataLoader total_train_batch_size: int )

计算并返回以下值

num_train_epochs
num_update_steps_per_epoch
num_examples
num_train_samples
epoch_based
len_dataloader
max_steps

train

( resume_from_checkpoint: typing.Union[bool, str, NoneType] = None trial: typing.Union[ForwardRef('optuna.Trial'), dict[str, typing.Any]] = 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], 可选) — 用于超参数搜索的 trial 运行或超参数字典。
ignore_keys_for_eval (List[str], 可选) — 模型输出（如果是一个字典）中在训练期间收集评估预测时应忽略的键列表。
kwargs (Dict[str, Any], 可选) — 用于隐藏已弃用参数的附加关键字参数

主要训练入口点。

training_step

( model: Module inputs: dict num_items_in_batch = None ) → torch.Tensor

参数

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

字典将在馈送到模型之前解包。大多数模型期望在参数 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 )

evaluate

( 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, 可选) — 使用 generate 方法进行预测时使用的最大目标长度。
num_beams (int, 可选) — 使用 generate 方法进行预测时将使用的 beam search 的 beam 数量。 1 表示不使用 beam search。
gen_kwargs — 额外的 generate 特定 kwargs。

运行评估并返回指标。

调用脚本将负责提供一种计算指标的方法，因为这些指标是任务相关的（将其传递给 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, 可选) — 使用 generate 方法进行预测时使用的最大目标长度。
num_beams (int, 可选) — 使用 generate 方法进行预测时将使用的 beam search 的 beam 数量。 1 表示不使用 beam search。
gen_kwargs — 额外的 generate 特定 kwargs。

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

根据数据集和您的用例，您的测试数据集可能包含标签。在这种情况下，此方法还将返回指标，就像在 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, NoneType] = <factory> warmup_ratio: float = 0.0 warmup_steps: int = 0 log_level: typing.Optional[str] = 'passive' log_level_replica: typing.Optional[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, typing.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[typing.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[typing.List[transformers.trainer_utils.FSDPOption], str, NoneType] = '' fsdp_min_num_params: int = 0 fsdp_config: typing.Union[dict, str, NoneType] = None tp_size: typing.Optional[int] = 0 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, typing.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 gradient_checkpointing: bool = False gradient_checkpointing_kwargs: typing.Union[dict, str, NoneType] = None include_inputs_for_metrics: bool = False include_for_metrics: typing.List[str] = <factory> eval_do_concat_batches: bool = True fp16_backend: str = 'auto' evaluation_strategy: typing.Union[transformers.trainer_utils.IntervalStrategy, str] = None 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: typing.Optional[int] = 1800 torch_compile: bool = False torch_compile_backend: typing.Optional[str] = None torch_compile_mode: typing.Optional[str] = None dispatch_batches: typing.Optional[bool] = None split_batches: typing.Optional[bool] = 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, typing.List[str]] = None batch_eval_metrics: bool = False eval_on_start: bool = False use_liger_kernel: typing.Optional[bool] = False eval_use_gather_object: typing.Optional[bool] = False average_tokens_across_devices: typing.Optional[bool] = False )

参数

output_dir (str, optional, defaults to "trainer_output") — 模型预测和检查点将被写入的输出目录。
overwrite_output_dir (bool, optional, defaults to False) — 如果为 True，则覆盖输出目录的内容。如果 output_dir 指向检查点目录，请使用此选项以继续训练。
do_train (bool, optional, defaults to False) — 是否运行训练。此参数不由 Trainer 直接使用，而是供您的训练/评估脚本使用。有关更多详细信息，请参见示例脚本。
do_eval (bool, optional) — 是否在验证集上运行评估。如果 eval_strategy 与 "no" 不同，则将设置为 True。此参数不由 Trainer 直接使用，而是供您的训练/评估脚本使用。有关更多详细信息，请参见示例脚本。
do_predict (bool, optional, defaults to False) — 是否在测试集上运行预测。此参数不由 Trainer 直接使用，而是供您的训练/评估脚本使用。有关更多详细信息，请参见示例脚本。
eval_strategy (str 或 IntervalStrategy, optional, defaults to "no") — 训练期间采用的评估策略。可能的值为：
- "no"：训练期间不进行评估。
- "steps"：每 eval_steps 步进行评估（并记录）。
- "epoch"：在每个 epoch 结束时进行评估。
prediction_loss_only (bool, optional, defaults to False) — 在执行评估和生成预测时，仅返回损失值。
per_device_train_batch_size (int, optional, defaults to 8) — 每个设备加速器核心/CPU 用于训练的批量大小。
per_device_eval_batch_size (int, optional, defaults to 8) — 每个设备加速器核心/CPU 用于评估的批量大小。
gradient_accumulation_steps (int, optional, defaults to 1) — 在执行反向传播/更新步骤之前，累积梯度的更新步骤数。

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

这可以帮助避免 CUDA 内存溢出错误，通过降低峰值 VRAM 使用量，但会牺牲大约 10% 的性能。
learning_rate (float, 可选, 默认为 5e-5) — AdamW 优化器的初始学习率。
weight_decay (float, 可选, 默认为 0) — 应用于 AdamW 优化器中除所有 bias 和 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’, 可选, 默认为 {}) — lr_scheduler 的额外参数。有关可能的值，请参阅每个调度器的文档。
warmup_ratio (float, 可选, 默认为 0.0) — 用于从 0 线性预热到 learning_rate 的总训练步骤的比例。
warmup_steps (int, 可选, 默认为 0) — 用于从 0 线性预热到 learning_rate 的步数。覆盖 warmup_ratio 的任何效果。
log_level (str, 可选, 默认为 passive) — 要在主进程上使用的 Logger 日志级别。可能的选择是日志级别字符串：“debug”、“info”、“warning”、“error”和“critical”，以及一个“passive”级别，该级别不设置任何内容，并保持 Transformers 库的当前日志级别（默认为 "warning"）。
log_level_replica (str, 可选, 默认为 "warning") — 要在副本上使用的 Logger 日志级别。与 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 状态来节省存储空间。您只能使用 from_pretrained 加载模型，并且此选项必须设置为 True。
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 训练，在 [‘O0’, ‘O1’, ‘O2’ 和 ‘O3’] 中选择的 Apex AMP 优化级别。详见 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) — 分布式训练期间进程的 rank。
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 生成的指标表。如果日志记录级别设置为 warn 或更低（默认），则默认为 True，否则为 False。
remove_unused_columns (bool, 可选, 默认为 True) — 是否自动删除模型 forward 方法未使用的列。
label_names (List[str], optional) — 标签名称（List[str]，可选）— 输入字典中对应标签的键列表。

最终将默认为模型接受的参数名称列表中包含“label”一词的参数名，除非使用的模型是 XxxForQuestionAnswering 中的一个，在这种情况下，它还将包括 ["start_positions", "end_positions"] 键。
load_best_model_at_end (bool, optional, defaults to False) — 训练结束时加载最佳模型（bool，可选，默认为 False）— 是否在训练结束时加载训练期间找到的最佳模型。启用此选项后，将始终保存最佳检查点。有关更多信息，请参阅 save_total_limit。

当设置为 True 时，参数 save_strategy 需要与 eval_strategy 相同，并且如果它是 “steps”，则 save_steps 必须是 eval_steps 的整数倍。
metric_for_best_model (str, optional) — 最佳模型的评估指标（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, optional) — 指标值越高模型越好（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, optional, defaults to False) — 忽略数据跳过（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）的位置，也可以是已加载为 dict 的 json 文件。

配置及其选项列表：
- 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 线程以防止过多的 in-flight 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 指定自动包装策略时使用。
tp_size (int, optional) — 张量并行大小（int，可选）— 使用 tp_size 启用 PyTorch 张量并行。张量并行支持仅适用于在其各自的配置类中具有 base_tp_plan 的模型。设置大于 1 的值以激活 TP。相同的参数用于在内部准备设备网格。需要 accelerate>1.3.0。
deepspeed (str 或 dict，可选) — 使用 Deepspeed。这是一个实验性功能，其 API 将来可能会发生变化。该值可以是 DeepSpeed json 配置文件（例如，ds_config.json）的位置，也可以是已加载为 dict 的 json 文件。

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

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

可能的选项有：
- "underflow_overflow"：检测模型输入/输出中的下溢/溢出，并报告导致该事件的最后一个帧
- "tpu_metrics_debug"：在 TPU 上打印调试指标
选项应以空格分隔。
optim (str 或 training_args.OptimizerNames, optional, defaults to "adamw_torch") — 优化器（str 或 training_args.OptimizerNames，可选，默认为 "adamw_torch"）— 要使用的优化器，例如 “adamw_torch”、“adamw_torch_fused”、“adamw_apex_fused”、“adamw_anyprecision”、“adafactor”。有关优化器的完整列表，请参阅 training_args.py 中的 OptimizerNames。
optim_args (str, optional) — 优化器参数（str，可选）— 提供给优化器的可选参数，例如 AnyPrecisionAdamW、AdEMAMix 和 GaLore。
group_by_length (bool, optional, defaults to False) — 按长度分组（bool，可选，默认为 False）— 是否在训练数据集中将长度大致相同的样本分组在一起（以最大限度地减少应用的填充并提高效率）。仅在应用动态填充时有用。
length_column_name (str, optional, defaults to "length") — 长度列名（str，可选，默认为 "length"）— 预计算长度的列名。如果该列存在，则按长度分组将使用这些值，而不是在训练启动时计算它们。仅当 group_by_length 为 True 且数据集是 Dataset 的实例时才会被忽略。
report_to (str 或 List[str], optional, defaults to "all") — 报告到（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, optional) — ddp_find_unused_parameters（bool，可选）— 当使用分布式训练时，传递给 DistributedDataParallel 的标志 find_unused_parameters 的值。如果使用梯度检查点，则默认为 False，否则为 True。
ddp_bucket_cap_mb (int, optional) — ddp_bucket_cap_mb（int，可选）— 当使用分布式训练时，传递给 DistributedDataParallel 的标志 bucket_cap_mb 的值。
ddp_broadcast_buffers (bool, optional) — 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，可选，默认为 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 将跳过推送检查点。
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) — 是否跨批次递归连接 inputs/losses/labels/predictions。如果为 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，可选) — 是否计算每个设备每秒的 token 数，以用于训练速度指标。

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

并且会减慢整个过程。
include_num_input_tokens_seen (bool, optional) — 是否追踪整个训练过程中已看到的输入 tokens 的数量。

在分布式训练中可能会较慢，因为需要调用 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://arxiv.org/abs/2403.03507) 和 APOLLO 算法 (https://arxiv.org/abs/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], defaults to False) — 如果设置为 True，评估将在每个批次结束时调用 compute_metrics 来累积统计信息，而不是将所有评估 logits 保存在内存中。当设置为 True 时，您必须传递一个 compute_metrics 函数，该函数接受一个布尔参数 compute_result，当传递 True 时，将触发来自您在评估集上累积的批次级别摘要统计信息的最终全局摘要统计信息。
eval_on_start (bool, optional, defaults to False) — 是否在训练前执行评估步骤（健全性检查），以确保验证步骤正常工作。
eval_use_gather_object (bool, optional, defaults to False) — 是否在所有设备上递归地收集嵌套列表/元组/对象字典中的对象。仅当用户不仅仅返回张量时才应启用此功能，并且 PyTorch 积极不鼓励这样做。
use_liger_kernel (bool, optional, defaults to False) — 是否启用 Liger Kernel 用于 LLM 模型训练。它可以有效地将多 GPU 训练吞吐量提高约 20%，并将内存使用量减少约 60%，开箱即用，支持 flash attention、PyTorch FSDP 和 Microsoft DeepSpeed。目前，它支持 llama、mistral、mixtral 和 gemma 模型。
average_tokens_across_devices (bool, optional, defaults to False) — 是否在设备之间平均 tokens。如果启用，将使用 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, defaults to True) — 如果 True，则 “first” 指的是每个节点的 rank 0 进程；如果 False，则 “first” 指的是节点 rank 0 的 rank 0 进程。在具有共享文件系统的多节点环境中，您很可能希望使用 local=False，以便只有第一个节点的主进程会执行处理。但是，如果文件系统未共享，则每个节点的主进程都需要执行处理，这是默认行为。
desc (str, optional, defaults to "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, defaults to False) — 是否丢弃最后一个不完整的批次（如果数据集的长度不能被批次大小整除）。
num_workers (int, optional, defaults to 0) — 用于数据加载的子进程数（仅限 PyTorch）。0 表示数据将在主进程中加载。
pin_memory (bool, optional, defaults to True) — 是否要将内存固定在数据加载器中。默认值为 True。
persistent_workers (bool, optional, defaults to False) — 如果为 True，则数据加载器在数据集被消耗一次后不会关闭 worker 进程。这允许保持 worker 的 Dataset 实例处于活动状态。可能会加快训练速度，但会增加 RAM 使用量。默认值为 False。
prefetch_factor (int, optional) — 每个 worker 预先加载的批次数。2 表示所有 worker 总共将预取 2 * num_workers 个批次。
auto_find_batch_size (bool, optional, defaults to False) — 是否通过指数衰减自动查找适合内存的批次大小，从而避免 CUDA 内存不足错误。需要安装 accelerate (pip install accelerate)
ignore_data_skip (bool, optional, defaults to 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, 可选, 默认为 "no") — 训练期间采用的评估策略。可能的值包括：
- "no": 训练期间不进行评估。
- "steps": 每 steps 步进行评估（并记录）。
- "epoch": 在每个 epoch 结束时进行评估。
设置与 "no" 不同的 strategy 将把 self.do_eval 设置为 True。
steps (int, 可选, 默认为 500) — 如果 strategy="steps"，则为两次评估之间的更新步数。
batch_size (int 可选, 默认为 8) — 每个设备（GPU/TPU 核心/CPU...）用于评估的批次大小。
accumulation_steps (int, 可选) — 在将结果移至 CPU 之前，累积输出张量的预测步数。如果未设置，则整个预测将在 GPU/TPU 上累积，然后再移至 CPU（速度更快但需要更多内存）。
delay (float, 可选) — 在可以执行首次评估之前等待的 epoch 或步数，具体取决于 eval_strategy。
loss_only (bool, 可选, 默认为 False) — 忽略除损失之外的所有输出。
jit_mode (bool, 可选) — 是否对推理使用 PyTorch jit 跟踪。

一种将所有与评估相关的参数重新分组的方法。

示例

>>> 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, typing.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 )

参数

model_id (str) — 要与本地 output_dir 保持同步的仓库名称。它可以是一个简单的模型 ID，在这种情况下，模型将被推送到您的命名空间中。否则，它应该是完整的仓库名称，例如 "user_name/model"，这允许您推送到您所属的组织，使用 "organization_name/model"。
strategy (str 或 HubStrategy, 可选, 默认为 "every_save") — 定义推送到 Hub 的内容范围和时间。可能的值为：
- "end": 当调用 save_model() 方法时，推送模型、其配置、processing_class 例如 tokenizer（如果传递给 Trainer）和模型卡的草稿。
- "every_save": 每次保存模型时，推送模型、其配置、processing_class 例如 tokenizer（如果传递给 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 将跳过推送检查点。

一个将所有与 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: 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 核心/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) — 要执行的训练 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, NoneType] = <factory> warmup_ratio: float = 0.0 warmup_steps: int = 0 log_level: typing.Optional[str] = 'passive' log_level_replica: typing.Optional[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, typing.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[typing.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[typing.List[transformers.trainer_utils.FSDPOption], str, NoneType] = '' fsdp_min_num_params: int = 0 fsdp_config: typing.Union[dict, str, NoneType] = None tp_size: typing.Optional[int] = 0 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, typing.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 gradient_checkpointing: bool = False gradient_checkpointing_kwargs: typing.Union[dict, str, NoneType] = None include_inputs_for_metrics: bool = False include_for_metrics: typing.List[str] = <factory> eval_do_concat_batches: bool = True fp16_backend: str = 'auto' evaluation_strategy: typing.Union[transformers.trainer_utils.IntervalStrategy, str] = None 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: typing.Optional[int] = 1800 torch_compile: bool = False torch_compile_backend: typing.Optional[str] = None torch_compile_mode: typing.Optional[str] = None dispatch_batches: typing.Optional[bool] = None split_batches: typing.Optional[bool] = 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, typing.List[str]] = None batch_eval_metrics: bool = False eval_on_start: bool = False use_liger_kernel: typing.Optional[bool] = False 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, 可选) — 在首次执行评估之前需要等待的轮次 (epochs) 或步数 (steps) 数量，具体取决于 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 优化器中除所有偏差 (bias) 和 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) — 要执行的训练总轮数（如果不是整数，将在停止训练前执行最后一轮的小数部分百分比）。
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 或 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, optional, defaults to False) — 当进行多节点分布式训练时，是否在每个节点上保存模型和检查点，或者仅在主节点上保存。

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

最终将默认为模型接受的参数名称列表中包含 “label” 单词的那些，除非使用的模型是 XxxForQuestionAnswering 中的一种，在这种情况下，它还将包括 ["start_positions", "end_positions"] 键。
load_best_model_at_end (bool, optional, defaults to False) — 是否在训练结束时加载训练期间找到的最佳模型。启用此选项后，将始终保存最佳检查点。有关更多信息，请参阅 save_total_limit。

当设置为 True 时，参数 save_strategy 需要与 eval_strategy 相同，并且在“steps”的情况下，save_steps 必须是 eval_steps 的整数倍。
metric_for_best_model (str, optional) — 与 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, optional) — 与 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, optional, defaults to False) — 当恢复训练时，是否跳过 epoch 和批次，以使数据加载与之前的训练阶段相同。如果设置为 True，训练将更快开始（因为跳过步骤可能需要很长时间），但不会产生与中断的训练相同的结果。
fsdp (bool, str 或 FSDPOption 列表, optional, defaults to '') — 使用 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, optional) — 与 fsdp (Pytorch 分布式并行训练) 一起使用的配置。该值可以是 fsdp json 配置文件的位置（例如，fsdp_config.json），也可以是已加载为 dict 的 json 文件。

配置及其选项列表：
- min_num_params (int, optional, defaults to 0): FSDP 默认自动包装的最小参数数量。（仅当传递 fsdp 字段时有用）。
- transformer_layer_cls_to_wrap (List[str], optional): 要包装的 Transformer 层类名称（区分大小写）列表，例如，BertLayer、GPTJBlock、T5Block ...（仅当传递 fsdp 标志时有用）。
- backward_prefetch (str, optional) FSDP 的反向预取模式。控制何时预取下一组参数（仅当传递 fsdp 字段时有用）。
  
  以下选项列表：
  - "backward_pre" : 在当前参数集的梯度计算之前预取下一组参数。
  - "backward_post" : 在当前参数集的梯度计算之后预取下一组参数。
- forward_prefetch (bool, optional, defaults to False) FSDP 的前向预取模式（仅当传递 fsdp 字段时有用）。如果为 "True"，则 FSDP 在前向传递中显式预取即将到来的 all-gather。
- limit_all_gathers (bool, optional, defaults to False) FSDP 的 limit_all_gathers（仅当传递 fsdp 字段时有用）。如果为 "True"，则 FSDP 显式同步 CPU 线程以防止过多的 in-flight all-gather。
- use_orig_params (bool, optional, defaults to 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, optional, defaults to True) 如果为 "True"，则每个单独包装的 FSDP 单元将从 rank 0 广播模块参数，以确保它们在初始化后在所有 rank 中都相同
- cpu_ram_efficient_loading (bool, optional, defaults to False) 如果为 "True"，则只有第一个进程加载预训练模型检查点，而所有其他进程都具有空权重。当此设置设置为 "True" 时，sync_module_states 也必须为 "True"，否则除主进程外的所有进程都将具有随机权重，从而导致训练期间出现意外行为。
- activation_checkpointing (bool, optional, defaults to False): 如果为 "True"，激活检查点是一种通过清除某些层的激活并在反向传递期间重新计算它们来减少内存使用量的技术。实际上，这牺牲了额外的计算时间来减少内存使用量。
- xla (bool, optional, defaults to False): 是否使用 PyTorch/XLA 完全分片数据并行训练。这是一个实验性功能，其 API 未来可能会发展。
- xla_fsdp_settings (dict, optional) 该值是一个字典，用于存储 XLA FSDP 包装参数。
  
  有关选项的完整列表，请参阅这里。
- xla_fsdp_grad_ckpt (bool, optional, defaults to False): 将在每个嵌套的 XLA FSDP 包装层上使用梯度检查点。此设置只能在 xla 标志设置为 true，并且通过 fsdp_min_num_params 或 fsdp_transformer_layer_cls_to_wrap 指定自动包装策略时使用。
tp_size (int, optional) — 使用 tp_size 启用 PyTorch 张量并行。张量并行支持仅适用于在其各自的配置类中具有 base_tp_plan 的模型。设置大于 1 的值以激活 TP。相同的设置也用于在内部准备设备网格。需要 accelerate>1.3.0。
deepspeed (str 或 dict, optional) — 使用 Deepspeed。这是一个实验性功能，其 API 未来可能会发展。该值可以是 DeepSpeed json 配置文件的位置（例如，ds_config.json），也可以是已加载为 dict 的 json 文件”。

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

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

可能的选项包括：
- "underflow_overflow"：检测模型输入/输出中的下溢/溢出，并报告导致该事件的最后帧
- "tpu_metrics_debug"：在 TPU 上打印调试指标
选项应以空格分隔。
optim (str 或 training_args.OptimizerNames, optional, defaults to "adamw_torch") — 要使用的优化器，例如 “adamw_torch”、“adamw_torch_fused”、“adamw_apex_fused”、“adamw_anyprecision”、“adafactor”。有关优化器的完整列表，请参阅 training_args.py 中的 OptimizerNames。
optim_args (str, optional) — 可选参数，提供给优化器，例如 AnyPrecisionAdamW、AdEMAMix 和 GaLore。
group_by_length (bool, optional, defaults to False) — 是否在训练数据集中将长度大致相同的样本分组在一起（以最大限度地减少应用的填充并提高效率）。仅在应用动态填充时有用。
length_column_name (str, optional, defaults to "length") — 预先计算长度的列名。如果该列存在，则按长度分组将使用这些值，而不是在训练开始时计算它们。除非 group_by_length 为 True 且数据集是 Dataset 的实例，否则将被忽略。
report_to (str 或 List[str], optional, defaults to "all") — 要将结果和日志报告到的集成列表。支持的平台包括 "azure_ml"、"clearml"、"codecarbon"、"comet_ml"、"dagshub"、"dvclive"、"flyte"、"mlflow"、"neptune"、"swanlab"、"tensorboard" 和 "wandb"。使用 "all" 报告给所有已安装的集成，使用 "none" 不进行任何集成。
ddp_find_unused_parameters (bool, optional) — 当使用分布式训练时，传递给 DistributedDataParallel 的标志 find_unused_parameters 的值。如果使用梯度检查点，则默认为 False，否则为 True。
ddp_bucket_cap_mb (int, optional) — 当使用分布式训练时，传递给 DistributedDataParallel 的标志 bucket_cap_mb 的值。
ddp_broadcast_buffers (bool, optional) — 当使用分布式训练时，传递给 DistributedDataParallel 的标志 broadcast_buffers 的值。如果使用梯度检查点，则默认为 False，否则为 True。
dataloader_pin_memory (bool, optional, defaults to True) — 是否要在数据加载器中锁定内存。将默认为 True。
dataloader_persistent_workers (bool, optional, defaults to False) — 如果为 True，则数据加载器在数据集被消耗一次后不会关闭工作进程。这允许保持工作进程的 Dataset 实例处于活动状态。可以潜在地加速训练，但会增加 RAM 使用量。将默认为 False。
dataloader_prefetch_factor (int, optional) — 每个 worker 预先加载的批次数。2 表示所有 worker 将总共预取 2 * num_workers 个批次。
skip_memory_metrics (bool, optional, defaults to True) — 是否跳过将内存分析器报告添加到指标。默认情况下会跳过此项，因为它会降低训练和评估速度。
push_to_hub (bool, optional, defaults to 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 or HubStrategy, optional, defaults to "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, defaults to False) — 除非此项为 True，否则当上一次推送未完成时，Trainer 将跳过推送检查点。
gradient_checkpointing (bool, optional, defaults to False) — 如果为 True，则使用梯度检查点以节省内存，但会牺牲较慢的反向传播速度。
gradient_checkpointing_kwargs (dict, optional, defaults to None) — 要传递给 gradient_checkpointing_enable 方法的关键字参数。
include_inputs_for_metrics (bool, optional, defaults to False) — 此参数已弃用。请改用 include_for_metrics，例如，include_for_metrics = ["inputs"]。
include_for_metrics (List[str], optional, defaults to []) — 如果需要进行指标计算，则在 compute_metrics 函数中包含其他数据。可以添加到 include_for_metrics 列表的可能选项：
- "inputs": 传递给模型的输入数据，用于计算依赖于输入的指标。
- "loss": 评估期间计算的损失值，用于计算依赖于损失的指标。
eval_do_concat_batches (bool, optional, defaults to True) — 是否递归地连接跨批次的输入/损失/标签/预测。如果为 False，则会将它们存储为列表，每个批次保持分离。
auto_find_batch_size (bool, optional, defaults to False) — 是否通过指数衰减自动查找适合内存的批次大小，从而避免 CUDA 内存溢出错误。需要安装 accelerate (pip install accelerate)
full_determinism (bool, optional, defaults to 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, defaults to "last") — 使用 Ray 进行超参数搜索时使用的范围。默认情况下，将使用 "last"。Ray 将使用所有试验的最后一个检查点，比较这些检查点，并选择最佳的那个。但是，还有其他选项可用。有关更多选项，请参阅 Ray 文档。
ddp_timeout (int, optional, defaults to 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, defaults to False) — 此参数已弃用。如果 mps 设备可用，则将使用它，类似于 cuda 设备。
torch_compile (bool, optional, defaults to False) — 是否使用 PyTorch 2.0 torch.compile 编译模型。

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

此标志和整个 compile 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 版本而异。

此标志是实验性的，并且在未来的版本中可能会发生更改。
split_batches (bool, optional) — 是否加速器应在分布式训练期间跨设备拆分数据加载器产生的数据批次。如果

设置为 True，则在任何类型的分布式进程中使用的实际批次大小都将相同，但它必须是

您正在使用的进程数（例如 GPU）的整数倍。
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://arxiv.org/abs/2403.03507) 和 APOLLO 算法 (https://arxiv.org/abs/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, optional, 默认为 False) — 是否在训练之前执行评估步骤（健全性检查），以确保验证步骤正常工作。
eval_use_gather_object (bool, optional, 默认为 False) — 是否在所有设备上对嵌套列表/元组/对象字典中的对象递归运行 gather object。仅当用户不只是返回张量时才应启用此选项，PyTorch 强烈建议不要这样做。
use_liger_kernel (bool, optional, 默认为 False) — 是否启用 Liger Kernel 用于 LLM 模型训练。它可以有效地将多 GPU 训练吞吐量提高约 20%，并将内存使用量减少约 60%，开箱即用地与 flash attention、PyTorch FSDP 和 Microsoft DeepSpeed 配合使用。目前，它支持 llama、mistral、mixtral 和 gemma 模型。
average_tokens_across_devices (bool, optional, 默认为 False) — 是否平均跨设备的 token。如果启用，将使用 all_reduce 来同步 num_tokens_in_batch 以进行精确的损失计算。参考： https://github.com/huggingface/transformers/issues/34242
predict_with_generate (bool, optional, 默认为 False) — 是否使用 generate 来计算生成式指标（ROUGE、BLEU）。
generation_max_length (int, optional) — 当 predict_with_generate=True 时，在每次评估循环中使用的 max_length。将默认为模型配置的 max_length 值。
generation_num_beams (int, optional) — 当 predict_with_generate=True 时，在每次评估循环中使用的 num_beams。将默认为模型配置的 num_beams 值。
generation_config (str 或 Path 或 GenerationConfig, optional) — 允许从 from_pretrained 方法加载 GenerationConfig。这可以是：
- 字符串，托管在 huggingface.co 模型仓库中的预训练模型配置的模型 ID。
- 包含使用 save_pretrained() 方法保存的配置文件的目录路径，例如，./my_model_directory/。
- GenerationConfig 对象。

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

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

to_dict

( )

序列化此实例，同时将 Enum 替换为其值，并将 GenerationConfig 替换为字典（为了支持 JSON 序列化）。它通过删除 token 值来模糊化 token 值。

< > 在 GitHub 上更新

←Tokenizer DeepSpeed→