Hugging Face 的 LOGO

Transformers 文件

訓練器

Hugging Face's logo
加入 Hugging Face 社群

並獲得增強的文件體驗

開始使用

訓練器

Trainer 類為 PyTorch 提供了功能齊全的訓練 API，並支援多 GPU/TPU 上的分散式訓練，支援 NVIDIA GPU、AMD GPU 的混合精度，以及 PyTorch 的 torch.amp。 Trainer 與 TrainingArguments 類相輔相成，後者提供了多種選項來自定義模型訓練方式。 這兩個類共同提供了一個完整的訓練 API。

Seq2SeqTrainer 和 Seq2SeqTrainingArguments 繼承自 Trainer 和 TrainingArguments 類，它們適用於訓練摘要或翻譯等序列到序列任務的模型。

Trainer 類針對 🤗 Transformers 模型進行了最佳化，當與其他模型一起使用時可能會出現令人驚訝的行為。當與您自己的模型一起使用時，請確保

  • 您的模型始終返回元組或 ModelOutput 的子類
  • 如果提供了 labels 引數，您的模型可以計算損失，並且該損失作為元組的第一個元素返回（如果您的模型返回元組）
  • 您的模型可以接受多個標籤引數（在 TrainingArguments 中使用 label_names 向 Trainer 指示它們的名稱），但它們都不能命名為 "label"

Trainer

類 transformers.Trainer

< >

( model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.modules.module.Module, NoneType] = None args: TrainingArguments = None data_collator: typing.Optional[transformers.data.data_collator.DataCollator] = None train_dataset: typing.Union[torch.utils.data.dataset.Dataset, torch.utils.data.dataset.IterableDataset, ForwardRef('datasets.Dataset'), NoneType] = None eval_dataset: typing.Union[torch.utils.data.dataset.Dataset, dict[str, torch.utils.data.dataset.Dataset], ForwardRef('datasets.Dataset'), NoneType] = None processing_class: typing.Union[transformers.tokenization_utils_base.PreTrainedTokenizerBase, transformers.image_processing_utils.BaseImageProcessor, transformers.feature_extraction_utils.FeatureExtractionMixin, transformers.processing_utils.ProcessorMixin, NoneType] = None model_init: typing.Optional[typing.Callable[[], transformers.modeling_utils.PreTrainedModel]] = None compute_loss_func: typing.Optional[typing.Callable] = None compute_metrics: typing.Optional[typing.Callable[[transformers.trainer_utils.EvalPrediction], dict]] = None callbacks: typing.Optional[list[transformers.trainer_callback.TrainerCallback]] = None optimizers: tuple = (None, None) optimizer_cls_and_kwargs: typing.Optional[tuple[type[torch.optim.optimizer.Optimizer], dict[str, typing.Any]]] = None preprocess_logits_for_metrics: typing.Optional[typing.Callable[[torch.Tensor, torch.Tensor], torch.Tensor]] = None )

引數

  • model (PreTrainedModel 或 torch.nn.Module, 可選) — 用於訓練、評估或預測的模型。如果未提供，則必須傳入 model_init。

    Trainer 最佳化為與庫提供的 PreTrainedModel 配合使用。您仍然可以使用您自己的定義為 torch.nn.Module 的模型，只要它們與 🤗 Transformers 模型的工作方式相同。
  • args (TrainingArguments, 可選) — 訓練引數。如果未提供，將預設使用 TrainingArguments 的基本例項，其中 output_dir 設定為當前目錄中名為 tmp_trainer 的目錄。
  • data_collator (DataCollator, 可選) — 用於從 train_dataset 或 eval_dataset 元素列表中形成批次的功能。如果未提供 processing_class，則預設使用 default_data_collator()；否則，如果 processing_class 是特徵提取器或分詞器，則預設使用 DataCollatorWithPadding 的例項。
  • train_dataset (Union[torch.utils.data.Dataset, torch.utils.data.IterableDataset, datasets.Dataset], 可選) — 用於訓練的資料集。如果是 Dataset，則會自動刪除 model.forward() 方法不接受的列。

    請注意，如果它是帶有某些隨機化的 torch.utils.data.IterableDataset 並且您正在分散式訓練，則您的可迭代資料集應使用內部屬性 generator，該屬性是用於隨機化的 torch.Generator，在所有程序上必須相同（訓練器將在每個 epoch 手動設定此 generator 的種子），或者具有一個 set_epoch() 方法，該方法在內部設定使用的 RNG 的種子。

  • eval_dataset (Union[torch.utils.data.Dataset, dict[str, torch.utils.data.Dataset, datasets.Dataset]), 可選) — 用於評估的資料集。如果是 Dataset，則會自動刪除 model.forward() 方法不接受的列。如果是一個字典，它將對每個資料集進行評估，並將字典鍵新增到指標名稱之前。
  • processing_class (PreTrainedTokenizerBase 或 BaseImageProcessor 或 FeatureExtractionMixin 或 ProcessorMixin, 可選) — 用於處理資料的處理類。如果提供，將用於自動處理模型的輸入，並將與模型一起儲存，以便於重新執行中斷的訓練或重新使用微調後的模型。這取代了現在已棄用的 tokenizer 引數。
  • model_init (Callable[[], PreTrainedModel], 可選) — 例項化要使用的模型的功能。如果提供，每次呼叫 train() 都將從此函式給定的模型新例項開始。

    該函式可以沒有引數，也可以有一個引數，包含 optuna/Ray Tune/SigOpt 試驗物件，以便根據超引數（例如層數、內部層大小、dropout 機率等）選擇不同的架構。

  • compute_loss_func (Callable, 可選) — 一個函式，它接受原始模型輸出、標籤以及整個累積批次（batch_size * 梯度累積步數）中的專案數量，並返回損失。例如，請參見 Trainer 使用的預設損失函式。
  • compute_metrics (Callable[[EvalPrediction], Dict], 可選) — 將用於計算評估指標的函式。必須接受 EvalPrediction 並返回一個從字串到度量值的字典。注意：當傳遞 batch_eval_metrics 設定為 True 的 TrainingArgs 時，您的 compute_metrics 函式必須接受一個布林 compute_result 引數。這將在最後一個評估批次之後觸發，以指示該函式需要計算並返回全域性彙總統計資訊，而不是累積批次級別的統計資訊。
  • callbacks (List of TrainerCallback, 可選) — 回撥列表，用於自定義訓練迴圈。將新增到 此處 詳細描述的預設回撥列表中。

    如果您想刪除使用的預設回撥之一，請使用 Trainer.remove_callback() 方法。

  • optimizers (tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR], 可選, 預設為 (None, None)) — 包含要使用的最佳化器和排程器的元組。如果未提供，將預設使用模型上的 AdamW 例項和由 args 控制的 get_linear_schedule_with_warmup() 給出的排程器。
  • optimizer_cls_and_kwargs (tuple[Type[torch.optim.Optimizer], dict[str, Any]], 可選) — 包含最佳化器類和要使用的關鍵字引數的元組。它會覆蓋 args 中的 optim 和 optim_args。與 optimizers 引數不相容。

    與 optimizers 不同，此引數避免了在初始化 Trainer 之前將模型引數放置在正確裝置上的需要。

  • preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor], 可選) — 一個函式，用於在每個評估步驟快取 logits 之前對其進行預處理。必須接受兩個張量，即 logits 和標籤，並返回處理後的 logits。此函式所做的修改將反映在 compute_metrics 接收到的預測中。

    請注意，如果資料集中沒有標籤，則標籤（第二個引數）將為 None。

Trainer 是一個簡單但功能齊全的 PyTorch 訓練和評估迴圈，針對 🤗 Transformers 進行了最佳化。

重要屬性

  • model — 始終指向核心模型。如果使用 transformers 模型，它將是 PreTrainedModel 子類。
  • model_wrapped — 如果一個或多個其他模組包裝了原始模型，則始終指向最外部的模型。這是應該用於前向傳播的模型。例如，在 DeepSpeed 下，內部模型被包裝在 DeepSpeed 中，然後再次包裝在 torch.nn.DistributedDataParallel 中。如果內部模型未被包裝，則 self.model_wrapped 與 self.model 相同。
  • is_model_parallel — 模型是否已切換到模型並行模式（與資料並行不同，這意味著一些模型層分佈在不同的 GPU 上）。
  • place_model_on_device — 是否自動將模型放置在裝置上——如果使用模型並行或 deepspeed，或者如果預設的 TrainingArguments.place_model_on_device 被覆蓋為返回 False，則將其設定為 False。
  • is_in_train — 模型當前是否正在執行 train（例如，當在 train 中呼叫 evaluate 時）

添加回調

< >

( callback )

引數

  • callback (type 或 [`~transformers.TrainerCallback]`) — 一個 TrainerCallback 類或 TrainerCallback 的例項。在第一種情況下，將例項化該類的一個成員。

將回調新增到當前 TrainerCallback 列表中。

autocast_smart_context_manager

< >

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

一個輔助包裝器，用於根據情況建立適當的 autocast 上下文管理器，並向其提供所需的引數。

計算損失

< >

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

引數

  • model (nn.Module) — 用於計算損失的模型。
  • inputs (dict[str, Union[torch.Tensor, Any]]) — 模型的輸入資料。
  • return_outputs (bool, 可選, 預設為 False) — 是否返回模型輸出以及損失。
  • num_items_in_batch (Optional[torch.Tensor], 可選) — 批次中的專案數。如果未傳遞 num_items_in_batch，

Trainer 計算損失的方式。預設情況下，所有模型都在第一個元素中返回損失。

為了自定義行為，請繼承並覆蓋此方法。如果您在計算損失時不使用 num_items_in_batch，請確保將 self.model_accepts_loss_kwargs 設定為 False。否則，在執行梯度累積時，損失計算可能會略微不準確。

compute_loss_context_manager

< >

( )

用於將上下文管理器分組的輔助包裝器。

建立模型卡片

< >

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

引數

  • language (str, 可選) — 模型語言（如果適用）
  • license (str, 可選) — 模型的許可。如果提供給 Trainer 的原始模型來自 Hub 上的儲存庫，則預設使用預訓練模型的許可。
  • tags (str 或 list[str], 可選) — 要包含在模型卡片元資料中的標籤。
  • model_name (str, 可選) — 模型名稱。
  • finetuned_from (str, 可選) — 用於微調此模型的模型名稱（如果適用）。如果提供給 Trainer 的原始模型來自 Hub，則預設使用該模型的儲存庫名稱。
  • tasks (str 或 list[str], 可選) — 一個或多個任務識別符號，將包含在模型卡片的元資料中。
  • dataset_tags (str 或 list[str], 可選) — 一個或多個數據集標籤，將包含在模型卡片元資料中。
  • dataset (str 或 list[str], 可選) — 一個或多個數據集識別符號，將包含在模型卡片元資料中。
  • dataset_args (str 或 list[str], 可選) — 一個或多個數據集引數，將包含在模型卡片元資料中。

使用 Trainer 可用的資訊建立模型卡片的草稿。

建立最佳化器

< >

( )

設定最佳化器。

我們提供了一個合理的預設值，效果很好。如果您想使用其他東西，可以透過 optimizers 在 Trainer 的初始化中傳入一個元組，或者在子類中繼承並覆蓋此方法。

建立最佳化器和排程器

< >

( num_training_steps: int )

設定最佳化器和學習率排程器。

我們提供了一個合理的預設值，效果很好。如果您想使用其他東西，可以透過 optimizers 在 Trainer 的初始化中傳入一個元組，或者在子類中繼承並覆蓋此方法（或 create_optimizer 和/或 create_scheduler）。

建立排程器

< >

( num_training_steps: int optimizer: Optimizer = None )

引數

  • num_training_steps (int) — 要執行的訓練步數。

設定排程器。訓練器的最佳化器必須在此方法呼叫之前或作為引數傳入之前已設定。

評估

< >

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

引數

  • eval_dataset (Union[Dataset, dict[str, Dataset]), 可選) — 如果您希望覆蓋 self.eval_dataset，請傳遞一個數據集。如果它是 Dataset，則會自動刪除 model.forward() 方法不接受的列。如果它是一個字典，它將對每個資料集進行評估，並將字典鍵新增到指標名稱之前。資料集必須實現 __len__ 方法。

    如果您傳入一個以資料集名稱為鍵、以資料集為值的字典，則評估將在每個資料集上獨立執行。這對於監控訓練如何影響其他資料集或僅獲得更細粒度的評估非常有用。當與 load_best_model_at_end 一起使用時，請確保 metric_for_best_model 精確引用其中一個數據集。例如，如果您為兩個資料集 data1 和 data2 傳入 {"data1": data1, "data2": data2}，則可以指定 metric_for_best_model="eval_data1_loss" 以使用 data1 上的損失，或 metric_for_best_model="eval_data2_loss" 以使用 data2 上的損失。
  • ignore_keys (list[str], 可選) — 模型輸出（如果是字典）中應在收集預測時忽略的鍵列表。
  • metric_key_prefix (str, 可選, 預設為 "eval") — 可選字首，用作度量鍵字首。例如，如果字首為“eval”（預設），則度量“bleu”將被命名為“eval_bleu”

執行評估並返回指標。

呼叫指令碼將負責提供計算指標的方法，因為它們是任務相關的（將其傳遞給 init compute_metrics 引數）。

您也可以繼承並覆蓋此方法以注入自定義行為。

evaluation_loop

< >

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

預測/評估迴圈，由 Trainer.evaluate() 和 Trainer.predict() 共享。

無論有無標籤均可工作。

浮點運算

< >

( inputs: dict ) → int

引數

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

返回

int

浮點運算次數。

對於繼承自 PreTrainedModel 的模型，使用該方法計算每次反向傳播和前向傳播的浮點運算次數。如果使用其他模型，請在該模型中實現該方法或子類化並重寫此方法。

get_batch_samples

< >

( epoch_iterator: Iterator num_batches: int device: device )

從 epoch 迭代器中收集指定數量的批次，並可選地計算批次中的專案數以正確地縮放損失。

get_decay_parameter_names

< >

( model )

獲取所有將應用權重衰減的引數名稱。

此函式透過兩種方式過濾引數：

  1. 按層型別（ALL_LAYERNORM_LAYERS 中指定的層例項）
  2. 按引數名稱模式（包含“bias”或“norm”的變體）

get_eval_dataloader

< >

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

引數

  • eval_dataset (str 或 torch.utils.data.Dataset, 可選) — 如果是 str，將使用 self.eval_dataset[eval_dataset] 作為評估資料集。如果是 Dataset，將覆蓋 self.eval_dataset 並且必須實現 __len__。如果是 Dataset，則會自動移除 model.forward() 方法不接受的列。

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

如果想注入自定義行為，請子類化並重寫此方法。

get_learning_rates

< >

( )

從 self.optimizer 中返回每個引數的學習率。

get_num_trainable_parameters

< >

( )

獲取可訓練引數的數量。

get_optimizer_cls_and_kwargs

< >

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

引數

  • args (transformers.training_args.TrainingArguments) — 訓練會話的訓練引數。

根據訓練引數返回最佳化器類和最佳化器引數。

get_optimizer_group

< >

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

引數

  • param (str 或 torch.nn.parameter.Parameter, 可選) — 需要返回最佳化器組的引數。

如果給定引數，返回該引數的最佳化器組，否則返回所有引數的最佳化器組。

get_test_dataloader

< >

( test_dataset: Dataset )

引數

  • test_dataset (torch.utils.data.Dataset, 可選) — 要使用的測試資料集。如果是 Dataset，則會自動移除 model.forward() 方法不接受的列。必須實現 __len__。

返回測試 ~torch.utils.data.DataLoader。

如果想注入自定義行為，請子類化並重寫此方法。

get_total_train_batch_size

< >

( args )

計算總批次大小（微批次 * 梯度累積 * 分散式並行世界大小）。

注意：僅考慮資料並行和張量並行（dp_world_size = world_size // tp_size）。

get_tp_size

< >

( )

從模型或 DeepSpeed 配置中獲取張量並行大小。

get_train_dataloader

< >

( )

返回訓練 ~torch.utils.data.DataLoader。

如果 train_dataset 未實現 __len__，則不使用取樣器；否則使用隨機取樣器（如果需要，適應分散式訓練）。

如果想注入自定義行為，請子類化並重寫此方法。

hyperparameter_search

< >

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

引數

  • hp_space (Callable[["optuna.Trial"], dict[str, float]], 可選) — 定義超引數搜尋空間的函式。預設值取決於您的後端，可以是 default_hp_space_optuna()、default_hp_space_ray() 或 default_hp_space_sigopt()。
  • compute_objective (Callable[[dict[str, float]], float], 可選) — 一個函式，根據 evaluate 方法返回的指標計算要最小化或最大化的目標。預設值為 default_compute_objective()。
  • n_trials (int, 可選, 預設為 100) — 要測試的試執行次數。
  • direction (str 或 list[str], 可選, 預設為 "minimize") — 如果是單目標最佳化，方向為 str，可以是 "minimize" 或 "maximize"，最佳化驗證損失時應選擇 "minimize"，最佳化一個或多個指標時應選擇 "maximize"。如果是多目標最佳化，方向為 list[str]，可以是 "minimize" 和 "maximize" 的列表，最佳化驗證損失時應選擇 "minimize"，最佳化一個或多個指標時應選擇 "maximize"。
  • backend (str 或 ~training_utils.HPSearchBackend, 可選) — 用於超引數搜尋的後端。預設值為 optuna、Ray Tune 或 SigOpt，具體取決於安裝了哪個。如果全部安裝，則預設為 optuna。
  • hp_name (Callable[["optuna.Trial"], str]], 可選) — 定義試驗/執行名稱的函式。預設值為 None。
  • kwargs (dict[str, Any], 可選) — 每個後端的附加關鍵字引數：

返回

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

關於多目標最佳化的最佳執行或最佳執行的所有資訊。實驗摘要可在 Ray 後端的 run_summary 屬性中找到。

使用 optuna 或 Ray Tune 或 SigOpt 啟動超引數搜尋。最佳化量由 compute_objective 決定，如果未提供指標，則預設為返回評估損失的函式，否則為所有指標的總和。

要使用此方法，您需要在初始化 Trainer 時提供 model_init：我們需要在每次新執行時重新初始化模型。這與 optimizers 引數不相容，因此您需要子類化 Trainer 並重寫 create_optimizer_and_scheduler() 方法以實現自定義最佳化器/排程器。

init_hf_repo

< >

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

在 self.args.hub_model_id 中初始化一個 git 倉庫。

is_local_process_zero

< >

( )

此程序是否為本地（例如，如果在多臺機器上分散式訓練，則為一臺機器上）主程序。

is_world_process_zero

< >

( )

此程序是否為全域性主程序（當在多臺機器上分散式訓練時，這僅對一個程序為 True）。

log

< >

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

引數

  • logs (dict[str, float]) — 要記錄的值。
  • start_time (Optional[float]) — 訓練開始時間。

在各種監聽訓練的物件上記錄 logs。

子類化並重寫此方法以注入自定義行為。

log_metrics

< >

( split metrics )

引數

  • split (str) — 模式/分割名稱：train、eval、test 之一
  • metrics (dict[str, float]) — 從訓練/評估/預測返回的指標：指標字典

以特殊格式記錄指標。

在分散式環境中，這隻對秩為 0 的程序執行。

記憶體報告注意事項

要獲取記憶體使用報告，您需要安裝 psutil。您可以使用 pip install psutil 進行安裝。

現在，當此方法執行時，您將看到一個報告，其中包含

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

理解報告

  • 第一部分，例如 train__，告訴您指標所屬的階段。以 init_ 開頭的報告將新增到第一個執行階段。因此，如果只執行評估，則 __init__ 的記憶體使用量將與 eval_ 指標一起報告。
  • 第三部分是 cpu 或 gpu，告訴您是通用 RAM 還是 gpu0 記憶體指標。
  • *_alloc_delta - 是階段結束和開始之間已用/分配記憶體計數器的差異 - 如果函式釋放的記憶體多於分配的記憶體，則可能為負。
  • *_peaked_delta - 是任何額外消耗然後釋放的記憶體 - 相對於當前分配的記憶體計數器 - 它永遠不會是負數。當您檢視任何階段的指標時，將 alloc_delta + peaked_delta 相加，您就知道完成該階段需要多少記憶體。

報告僅針對秩為 0 的程序和 GPU 0（如果有 GPU）進行。通常這已足夠，因為主程序執行了大部分工作，但如果使用了模型並行，則其他 GPU 可能使用不同的 GPU 記憶體量，這時可能就不夠了。在 DataParallel 下也不同，其中 gpu0 可能需要比其餘 GPU 多得多的記憶體，因為它儲存了所有參與 GPU 的梯度和最佳化器狀態。也許將來這些報告也會發展到測量這些方面。

CPU RAM 指標測量 RSS（Resident Set Size），包括程序獨有的記憶體和與其他程序共享的記憶體。需要注意的是，它不包括交換出去的記憶體，因此報告可能不精確。

CPU 峰值記憶體使用取樣執行緒測量。由於 Python 的 GIL，如果該執行緒在最高記憶體使用時沒有機會執行，它可能會錯過一些峰值記憶體。因此，此報告可能低於實際值。使用 tracemalloc 將報告精確的峰值記憶體，但它不報告 Python 之外的記憶體分配。因此，如果某些 C++ CUDA 擴充套件分配了自己的記憶體，則不會報告。因此，它被放棄，轉而使用記憶體取樣方法，該方法讀取當前程序的記憶體使用情況。

GPU 已分配和峰值記憶體報告透過 torch.cuda.memory_allocated() 和 torch.cuda.max_memory_allocated() 完成。此指標僅報告 PyTorch 特定分配的“增量”，因為 torch.cuda 記憶體管理系統不跟蹤 PyTorch 之外的任何已分配記憶體。例如，第一個 CUDA 呼叫通常會載入 CUDA 核心，這可能佔用 0.5 到 2GB 的 GPU 記憶體。

請注意，此跟蹤器不計算 Trainer 的 __init__、train、evaluate 和 predict 呼叫之外的記憶體分配。

由於評估呼叫可能在訓練期間發生，我們無法處理巢狀呼叫，因為 torch.cuda.max_memory_allocated 是一個單一計數器，因此如果它被巢狀的評估呼叫重置，訓練的跟蹤器將報告不正確的資訊。如果此 PyTorch 問題 得到解決，則此類別將能夠重新進入。在此之前，我們只會跟蹤 train、evaluate 和 predict 方法的外部級別。這意味著如果在訓練期間呼叫評估，則後者將計算其記憶體使用量以及前者的記憶體使用量。

這也意味著，如果與 Trainer 一起使用的任何其他工具呼叫 torch.cuda.reset_peak_memory_stats，則 GPU 峰值記憶體統計資訊可能無效。並且 Trainer 將干擾依賴於自身呼叫 torch.cuda.reset_peak_memory_stats 的任何此類工具的正常行為。

為了獲得最佳效能，您可能需要考慮在生產執行中關閉記憶體分析。

metrics_format

< >

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

引數

  • metrics (dict[str, float]) — 從訓練/評估/預測返回的指標

返回

指標 (dict[str, float])

重新格式化的指標

將訓練器指標值重新格式化為人類可讀的格式。

num_examples

< >

( dataloader: DataLoader )

輔助函式，透過訪問 DataLoader 的資料集來獲取其中的樣本數量。當 dataloader.dataset 不存在或沒有長度時，盡力估計。

num_tokens

< >

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

輔助函式，透過列舉資料載入器來獲取 ~torch.utils.data.DataLoader 中的 token 數量。

pop_callback

< >

( callback ) → TrainerCallback

引數

  • callback (type 或 [`~transformers.TrainerCallback]) — 一個 TrainerCallback 類或 TrainerCallback 的例項。在第一種情況下，將彈出在回撥列表中找到的該類的第一個成員。

返回

TrainerCallback

移除的回撥，如果找到。

從當前 TrainerCallback 列表中移除回撥並返回它。

如果找不到回撥，則返回 None（並且不引發錯誤）。

predict

< >

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

引數

  • test_dataset (Dataset) — 要執行預測的資料集。如果它是 datasets.Dataset，則會自動移除 model.forward() 方法不接受的列。必須實現 __len__。
  • ignore_keys (list[str], 可選) — 模型輸出（如果是字典）中應在收集預測時忽略的鍵列表。
  • metric_key_prefix (str, 可選, 預設為 "test") — 用作指標鍵字首的可選字首。例如，如果字首是“test”（預設值），則指標“bleu”將命名為“test_bleu”。

執行預測並返回預測和潛在指標。

根據資料集和您的用例，您的測試資料集可能包含標籤。在這種情況下，此方法也將返回指標，就像在 evaluate() 中一樣。

如果您的預測或標籤具有不同的序列長度（例如，因為您在 token 分類任務中進行動態填充），則預測將被填充（在右側）以允許連線成一個數組。填充索引為 -100。

返回：NamedTuple 具有以下鍵的命名元組

  • predictions (np.ndarray)：對 test_dataset 的預測。
  • label_ids (np.ndarray, 可選)：標籤（如果資料集包含）。
  • metrics (dict[str, float], 可選)：潛在的指標字典（如果資料集包含標籤）。

prediction_loop

< >

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

預測/評估迴圈，由 Trainer.evaluate() 和 Trainer.predict() 共享。

無論有無標籤均可工作。

prediction_step

< >

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

引數

  • model (nn.Module) — 要評估的模型。
  • 字典將在輸入到模型之前解包。大多數模型期望在 `labels` 引數下找到目標。請查閱模型的文件以瞭解所有接受的引數。
  • prediction_loss_only (bool) — 是否僅返回損失。
  • ignore_keys (list[str], 可選) — 模型輸出中（如果為字典）應在收集預測時忽略的鍵列表。

返回

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

包含損失、logits和標籤的元組（每個都是可選的）。

使用 `inputs` 對 `model` 執行評估步驟。

子類並重寫以注入自定義行為。

propagate_args_to_deepspeed

< >

( auto_find_batch_size = False )

根據 Trainer 引數設定 deepspeed 外掛中的值

push_to_hub

< >

( commit_message: typing.Optional[str] = 'End of training' blocking: bool = True token: typing.Optional[str] = None revision: typing.Optional[str] = None **kwargs )

引數

  • commit_message (str, 可選, 預設為 "End of training") — 推送時提交的訊息。
  • blocking (bool, 可選, 預設為 True) — 函式是否應在 `git push` 完成後才返回。
  • token (str, 可選, 預設為 None) — 具有寫入許可權的令牌，用於覆蓋 Trainer 的原始引數。
  • revision (str, 可選) — 提交的 git 版本。預設為“main”分支的頭部。
  • kwargs (dict[str, Any], 可選) — 傳遞給 `create_model_card()` 的額外關鍵字引數。

將 `self.model` 和 `self.processing_class` 上傳到 🤗 模型中心的 `self.args.hub_model_id` 儲存庫。

remove_callback

< >

( callback )

引數

  • callback (type 或 [`~transformers.TrainerCallback`]) — 一個 TrainerCallback 類或 TrainerCallback 的例項。在前一種情況下，將移除在回撥列表中找到的該類的第一個成員。

從當前的 `TrainerCallback` 列表中移除一個回撥。

save_metrics

< >

( split metrics combined = True )

引數

  • split (str) — 模式/分割名稱：`train`、`eval`、`test`、`all` 中的一個
  • metrics (dict[str, float]) — 訓練/評估/預測返回的指標
  • combined (bool, 可選, 預設為 True) — 透過使用此呼叫的指標更新 `all_results.json` 來建立組合指標

將指標儲存到該分割的 JSON 檔案中，例如 `train_results.json`。

在分散式環境中，這隻對秩為 0 的程序執行。

要了解指標，請閱讀 `log_metrics()` 的文件字串。唯一的區別是原始未格式化的數字儲存在當前方法中。

save_model

< >

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

將儲存模型，以便您可以使用 `from_pretrained()` 重新載入它。

僅從主程序儲存。

save_state

< >

( )

儲存 Trainer 狀態，因為 Trainer.save_model 只儲存分詞器和模型。

在分散式環境中，這隻對秩為 0 的程序執行。

set_initial_training_values

< >

( args: TrainingArguments dataloader: DataLoader total_train_batch_size: int )

計算並返回以下值

  • 訓練週期數
  • num_update_steps_per_epoch
  • num_examples
  • num_train_samples
  • epoch_based
  • len_dataloader
  • max_steps

train

< >

( resume_from_checkpoint: typing.Union[str, bool, NoneType] = None trial: typing.Union[ForwardRef('optuna.Trial'), dict[str, typing.Any], NoneType] = None ignore_keys_for_eval: typing.Optional[list[str]] = None **kwargs )

引數

  • resume_from_checkpoint (str 或 bool, 可選) — 如果是 `str`，則為由 `Trainer` 例項儲存的檢查點的本地路徑。如果是 `bool` 且為 `True`，則載入由 `Trainer` 例項儲存的 `args.output_dir` 中的最新檢查點。如果存在，訓練將從此處載入的模型/最佳化器/排程器狀態恢復。
  • trial (optuna.Trial 或 dict[str, Any], 可選) — 試執行或超引數搜尋的超引數字典。
  • ignore_keys_for_eval (list[str], 可選) — 模型輸出中（如果為字典）應在訓練期間收集評估預測時忽略的鍵列表。
  • kwargs (dict[str, Any], 可選) — 用於隱藏已棄用引數的額外關鍵字引數

主訓練入口點。

training_step

< >

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

引數

  • model (nn.Module) — 要訓練的模型。
  • 字典將在輸入到模型之前解包。大多數模型期望在 `labels` 引數下找到目標。請查閱模型的文件以瞭解所有接受的引數。

返回

torch.Tensor

此批次的訓練損失張量。

對一批輸入執行訓練步驟。

子類並重寫以注入自定義行為。

Seq2SeqTrainer

class transformers.Seq2SeqTrainer

< >

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

評估

< >

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

引數

  • eval_dataset (Dataset, 可選) — 如果您希望覆蓋 `self.eval_dataset`，請傳遞資料集。如果它是 `Dataset`，則 `model.forward()` 方法不接受的列將自動移除。它必須實現 `__len__` 方法。
  • ignore_keys (list[str], 可選) — 模型輸出中（如果為字典）應在收集預測時忽略的鍵列表。
  • metric_key_prefix (str, 可選, 預設為 "eval") — 一個可選的字首，用作指標鍵的字首。例如，如果字首是 `"eval"`（預設），指標“bleu”將被命名為“eval_bleu”
  • max_length (int, 可選) — 使用生成方法預測時使用的最大目標長度。
  • num_beams (int, 可選) — 使用生成方法預測時使用的束搜尋的束數量。1表示沒有束搜尋。
  • gen_kwargs — 額外與 `generate` 相關的關鍵字引數。

執行評估並返回指標。

呼叫指令碼將負責提供計算指標的方法，因為它們是任務相關的（將其傳遞給 init compute_metrics 引數）。

您也可以繼承並覆蓋此方法以注入自定義行為。

predict

< >

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

引數

  • test_dataset (Dataset) — 用於執行預測的資料集。如果它是 `Dataset`，則 `model.forward()` 方法不接受的列將自動移除。它必須實現 `__len__` 方法。
  • ignore_keys (list[str], 可選) — 模型輸出中（如果為字典）應在收集預測時忽略的鍵列表。
  • metric_key_prefix (str, 可選, 預設為 "eval") — 一個可選的字首，用作指標鍵的字首。例如，如果字首是 ` "eval"`（預設），指標“bleu”將被命名為“eval_bleu”
  • max_length (int, 可選) — 使用生成方法預測時使用的最大目標長度。
  • num_beams (int, 可選) — 使用生成方法預測時使用的束搜尋的束數量。1表示沒有束搜尋。
  • gen_kwargs — 額外與 `generate` 相關的關鍵字引數。

執行預測並返回預測和潛在指標。

根據資料集和您的用例，您的測試資料集可能包含標籤。在這種情況下，此方法也將返回指標，就像在 evaluate() 中一樣。

如果您的預測或標籤具有不同的序列長度（例如，因為您在令牌分類任務中進行動態填充），則預測將被填充（在右側）以允許連線成一個數組。填充索引為 -100。

返回：NamedTuple 具有以下鍵的命名元組

  • predictions (np.ndarray)：對 test_dataset 的預測。
  • label_ids (np.ndarray, 可選)：標籤（如果資料集包含）。
  • metrics (dict[str, float], 可選)：潛在的指標字典（如果資料集包含標籤）。

TrainingArguments

class transformers.TrainingArguments

< >

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

引數

  • output_dir (str, 可選, 預設為 "trainer_output") — 模型預測和檢查點將寫入的輸出目錄。
  • overwrite_output_dir (bool, 可選, 預設為 False) — 如果為 True，則覆蓋輸出目錄的內容。如果 output_dir 指向檢查點目錄，則使用此選項繼續訓練。
  • do_train (bool, 可選, 預設為 False) — 是否執行訓練。此引數未由 Trainer 直接使用，它旨在由您的訓練/評估指令碼使用。有關更多詳細資訊，請參閱示例指令碼。
  • do_eval (bool, 可選) — 是否在驗證集上執行評估。如果 eval_strategy 與 "no" 不同，則將設定為 True。此引數未由 Trainer 直接使用，它旨在由您的訓練/評估指令碼使用。有關更多詳細資訊，請參閱示例指令碼。
  • do_predict (bool, 可選, 預設為 False) — 是否在測試集上執行預測。此引數未由 Trainer 直接使用，它旨在由您的訓練/評估指令碼使用。有關更多詳細資訊，請參閱示例指令碼。
  • eval_strategy (str 或 IntervalStrategy, 可選, 預設為 "no") — 訓練期間採用的評估策略。可能的值為：

    • "no"：訓練期間不進行評估。
    • "steps"：每 eval_steps 步進行評估（並記錄）。
    • "epoch"：在每個 epoch 結束時進行評估。
  • prediction_loss_only (bool, 可選, 預設為 False) — 在執行評估和生成預測時，只返回損失。
  • per_device_train_batch_size (int, 可選, 預設為 8) — 每個裝置加速器核心/CPU 用於訓練的批處理大小。
  • per_device_eval_batch_size (int, 可選, 預設為 8) — 每個裝置加速器核心/CPU 用於評估的批處理大小。
  • gradient_accumulation_steps (int, 可選, 預設為 1) — 在執行反向/更新傳遞之前，用於累積梯度的更新步數。

    當使用梯度累積時，一步被計為一個帶有反向傳遞的步驟。因此，日誌記錄、評估、儲存將在每 gradient_accumulation_steps * xxx_step 訓練樣本後進行。
  • eval_accumulation_steps (int, 可選) — 在將結果移動到 CPU 之前，用於累積輸出張量的預測步數。如果未設定，則整個預測將在裝置加速器上累積，然後才移動到 CPU（速度更快但需要更多記憶體）。
  • eval_delay (float, 可選) — 在執行第一次評估之前需要等待的 epoch 或步數，具體取決於 eval_strategy。
  • torch_empty_cache_steps (int, 可選) — 在呼叫 torch.<device>.empty_cache() 之前等待的步數。如果未設定或設定為 None，則不會清空快取。

    這可以透過降低峰值 VRAM 使用量來避免 CUDA 記憶體不足錯誤，但代價是效能大約降低 10%。
  • learning_rate (float, 可選, 預設為 5e-5) — AdamW 最佳化器的初始學習率。
  • weight_decay (float, 可選, 預設為 0) — 對 AdamW 最佳化器中除所有偏差和 LayerNorm 權重之外的所有層應用的權重衰減（如果不為零）。
  • adam_beta1 (float, 可選, 預設為 0.9) — AdamW 最佳化器的 beta1 超引數。
  • adam_beta2 (float, 可選, 預設為 0.999) — AdamW 最佳化器的 beta2 超引數。
  • adam_epsilon (float, 可選, 預設為 1e-8) — AdamW 最佳化器的 epsilon 超引數。
  • max_grad_norm (float, 可選, 預設為 1.0) — 最大梯度範數（用於梯度裁剪）。
  • num_train_epochs (float, 可選, 預設為 3.0) — 要執行的訓練 epoch 總數（如果不是整數，則在停止訓練前執行最後一個 epoch 的小數部分百分比）。
  • max_steps (int, 可選, 預設為 -1) — 如果設定為正數，則為要執行的訓練步數總數。它會覆蓋 num_train_epochs。對於有限資料集，訓練將重複遍歷資料集（如果所有資料都已用盡）直到達到 max_steps。
  • lr_scheduler_type (str 或 SchedulerType, 可選, 預設為 "linear") — 要使用的排程器型別。有關所有可能的值，請參閱 SchedulerType 的文件。
  • lr_scheduler_kwargs (dict, 可選, 預設為 {}) — 學習率排程器的額外引數。有關可能的值，請參閱每個排程器的文件。
  • warmup_ratio (float, 可選, 預設為 0.0) — 用於從 0 到 learning_rate 進行線性預熱的總訓練步數的比例。
  • warmup_steps (int, 可選, 預設為 0) — 用於從 0 到 learning_rate 進行線性預熱的步數。覆蓋 warmup_ratio 的任何效果。
  • log_level (str, 可選, 預設為 passive) — 在主程序上使用的日誌級別。可能的值為字串形式的日誌級別：'debug'、'info'、'warning'、'error' 和 'critical'，以及一個 'passive' 級別，該級別不設定任何內容，並保持 Transformers 庫的當前日誌級別（預設為 "warning"）。
  • log_level_replica (str, 可選, 預設為 "warning") — 在副本上使用的日誌級別。與 log_level 具有相同的選項。
  • log_on_each_node (bool, 可選, 預設為 True) — 在多節點分散式訓練中，是每個節點記錄一次 log_level，還是僅在主節點記錄。
  • logging_dir (str, 可選) — TensorBoard 日誌目錄。預設為 *output_dir/runs/CURRENT_DATETIME_HOSTNAME*。
  • logging_strategy (str 或 IntervalStrategy, 可選, 預設為 "steps") — 訓練期間採用的日誌記錄策略。可能的值為：

    • "no"：訓練期間不進行日誌記錄。
    • "epoch"：在每個 epoch 結束時進行日誌記錄。
    • "steps"：每 logging_steps 步進行日誌記錄。
  • logging_first_step (bool, 可選, 預設為 False) — 是否記錄第一個 global_step。
  • logging_steps (int 或 float, 可選, 預設為 500) — 如果 logging_strategy="steps"，則兩次日誌記錄之間的更新步數。應該是整數或範圍 [0,1) 中的浮點數。如果小於 1，則將被解釋為總訓練步數的比例。
  • logging_nan_inf_filter (bool, 可選, 預設為 True) — 是否過濾 nan 和 inf 損失以進行日誌記錄。如果設定為 True，則每個 nan 或 inf 的步驟損失將被過濾，並改為採用當前日誌記錄視窗的平均損失。

    logging_nan_inf_filter 隻影響損失值的日誌記錄，它不改變梯度計算或應用於模型的行為。
  • save_strategy (str 或 SaveStrategy, 可選, 預設為 "steps") — 訓練期間採用的檢查點儲存策略。可能的值為：

    • "no"：訓練期間不進行儲存。
    • "epoch"：在每個 epoch 結束時進行儲存。
    • "steps"：每 save_steps 步進行儲存。
    • "best"：當達到新的 best_metric 時進行儲存。

    如果選擇 "epoch" 或 "steps"，訓練結束時也總是會執行儲存。

  • save_steps (int 或 float, 可選, 預設為 500) — 如果 save_strategy="steps"，則兩次檢查點儲存之間的更新步數。應該是整數或範圍 [0,1) 中的浮點數。如果小於 1，則將被解釋為總訓練步數的比例。
  • save_total_limit (int, 可選) — 如果傳入一個值，將限制檢查點的總數量。刪除 output_dir 中較舊的檢查點。當啟用 load_best_model_at_end 時，除了最新的檢查點外，根據 metric_for_best_model 的“最佳”檢查點將始終保留。例如，對於 save_total_limit=5 和 load_best_model_at_end，最後四個檢查點將始終與最佳模型一起保留。當 save_total_limit=1 和 load_best_model_at_end 時，可能會儲存兩個檢查點：最後一個和最佳一個（如果它們不同）。
  • save_safetensors (bool, 可選, 預設為 True) — 使用 safetensors 儲存和載入狀態字典，而不是預設的 torch.load 和 torch.save。
  • save_on_each_node (bool, 可選, 預設為 False) — 在多節點分散式訓練時，是否在每個節點上儲存模型和檢查點，還是隻在主節點上儲存。

    當不同節點使用相同的儲存時，不應啟用此選項，因為檔案將以相同的名稱儲存在每個節點上。

  • save_only_model (bool, 可選, 預設為 False) — 在檢查點儲存時，是隻儲存模型，還是同時儲存最佳化器、排程器和 rng 狀態。請注意，如果設定為 True，則無法從檢查點恢復訓練。這使您可以透過不儲存最佳化器、排程器和 rng 狀態來節省儲存空間。只有在此選項設定為 True 時，才能使用 from_pretrained 載入模型。
  • restore_callback_states_from_checkpoint (bool, 可選, 預設為 False) — 是否從檢查點恢復回撥狀態。如果為 True，如果檢查點中存在回撥，則會覆蓋傳遞給 Trainer 的回撥。
  • use_cpu (bool, 可選, 預設為 False) — 是否使用 CPU。如果設定為 False，我們將使用可用的 CUDA 或 MPS 裝置。
  • seed (int, 可選, 預設為 42) — 訓練開始時將設定的隨機種子。為確保跨執行的可重現性，如果模型具有一些隨機初始化的引數，請使用 ~Trainer.model_init 函式例項化模型。
  • data_seed (int, 可選) — 用於資料取樣器的隨機種子。如果未設定，資料取樣的隨機生成器將使用與 seed 相同的種子。這可用於確保資料取樣的可重現性，與模型種子無關。
  • jit_mode_eval (bool, 可選, 預設為 False) — 推斷時是否使用 PyTorch jit trace。
  • use_ipex (bool, 可選, 預設為 False) — 在 Intel Extension for PyTorch 可用時使用它。IPEX 安裝。
  • bf16 (bool, 可選, 預設為 False) — 是否使用 bf16 16 位（混合）精度訓練而非 32 位訓練。需要 Ampere 或更高版本的 NVIDIA 架構、Intel XPU 或使用 CPU (use_cpu) 或 Ascend NPU。這是一個實驗性 API，可能會發生變化。
  • fp16 (bool, 可選, 預設為 False) — 是否使用 fp16 16 位（混合）精度訓練而非 32 位訓練。
  • fp16_opt_level (str, 可選, 預設為 ‘O1’) — 對於 fp16 訓練，Apex AMP 最佳化級別選擇在 [‘O0’、‘O1’、‘O2’ 和 ‘O3’] 中。詳情請參閱 Apex 文件。
  • fp16_backend (str, 可選, 預設為 "auto") — 此引數已棄用。請改用 half_precision_backend。
  • half_precision_backend (str, 可選, 預設為 "auto") — 用於混合精度訓練的後端。必須是 "auto"、"apex"、"cpu_amp" 之一。 "auto" 將根據檢測到的 PyTorch 版本使用 CPU/CUDA AMP 或 APEX，而其他選項將強制使用請求的後端。
  • bf16_full_eval (bool, 可選, 預設為 False) — 是否使用完整的 bfloat16 評估而不是 32 位。這將更快並節省記憶體，但可能會損害指標值。這是一個實驗性 API，可能會發生變化。
  • fp16_full_eval (bool, 可選, 預設為 False) — 是否使用完整的 float16 評估而不是 32 位。這將更快並節省記憶體，但可能會損害指標值。
  • tf32 (bool, 可選) — 是否啟用 TF32 模式，該模式在 Ampere 及更新的 GPU 架構中可用。預設值取決於 PyTorch 的 torch.backends.cuda.matmul.allow_tf32 的預設版本。更多詳情請參閱 TF32 文件。這是一個實驗性 API，可能會發生變化。
  • local_rank (int, 可選, 預設為 -1) — 分散式訓練過程中程序的等級。
  • ddp_backend (str, 可選) — 用於分散式訓練的後端。必須是 "nccl"、"mpi"、"ccl"、"gloo"、"hccl" 之一。
  • tpu_num_cores (int, 可選) — 在 TPU 上訓練時，TPU 核心的數量（由啟動指令碼自動傳遞）。
  • dataloader_drop_last (bool, 可選, 預設為 False) — 是否丟棄最後一個不完整的批次（如果資料集的長度不能被批次大小整除）。
  • eval_steps (int 或 float, 可選) — 如果 eval_strategy="steps"，則兩次評估之間的更新步數。如果未設定，將預設為 logging_steps 的相同值。應為整數或範圍 [0,1) 中的浮點數。如果小於 1，將被解釋為總訓練步數的比例。
  • dataloader_num_workers (int, 可選, 預設為 0) — 用於資料載入的子程序數（僅限 PyTorch）。0 表示資料將在主程序中載入。
  • past_index (int, 可選, 預設為 -1) — 某些模型，如 TransformerXL 或 XLNet，可以利用過去的隱藏狀態進行預測。如果此引數設定為正整數，則 Trainer 將使用相應的輸出（通常為索引 2）作為過去狀態，並在下一個訓練步驟中將其作為關鍵字引數 mems 饋入模型。
  • run_name (str, 可選, 預設為 output_dir) — 執行的描述符。通常用於 wandb、mlflow、comet 和 swanlab 日誌記錄。如果未指定，將與 output_dir 相同。
  • disable_tqdm (bool, 可選) — 是否停用 tqdm 進度條以及 Jupyter Notebook 中 ~notebook.NotebookTrainingTracker 生成的指標表。如果日誌級別設定為警告或更低（預設），則預設為 True，否則為 False。
  • remove_unused_columns (bool, 可選, 預設為 True) — 是否自動刪除模型前向方法未使用的列。
  • label_names (list[str], 可選) — 輸入字典中對應標籤的鍵列表。

    最終將預設為模型接受的包含“label”一詞的引數名稱列表，除非使用的模型是 XxxForQuestionAnswering 之一，在這種情況下，它還將包括 ["start_positions", "end_positions"] 鍵。

  • load_best_model_at_end (bool, 可選, 預設為 False) — 訓練結束時是否載入訓練過程中找到的最佳模型。啟用此選項後，最佳檢查點將始終儲存。更多資訊請參見 save_total_limit。

    設定為 True 時，引數 save_strategy 需要與 eval_strategy 相同，並且在它是“steps”的情況下，save_steps 必須是 eval_steps 的整數倍。
  • metric_for_best_model (str, 可選) — 與 load_best_model_at_end 結合使用，指定用於比較兩個不同模型的指標。必須是評估返回的指標名稱，帶或不帶字首 "eval_"。

    如果未指定，當 load_best_model_at_end == True 或 lr_scheduler_type == SchedulerType.REDUCE_ON_PLATEAU（以使用評估損失）時，這將預設為 "loss"。

    如果您設定此值，greater_is_better 將預設為 True，除非名稱以“loss”結尾。如果您的指標越低越好，請不要忘記將其設定為 False。

  • greater_is_better (bool, 可選) — 與 load_best_model_at_end 和 metric_for_best_model 結合使用，指定更好的模型是否應該具有更高的指標。將預設為：

    • 如果 metric_for_best_model 設定為不以 "loss" 結尾的值，則為 True。
    • 如果 metric_for_best_model 未設定，或設定為以 "loss" 結尾的值，則為 False。
  • ignore_data_skip (bool, 可選, 預設為 False) — 恢復訓練時，是否跳過 epoch 和批次以使資料載入處於與先前訓練相同的階段。如果設定為 True，訓練將更快開始（因為跳過步驟可能需要很長時間），但不會產生與中斷訓練相同的結果。
  • fsdp (bool, str 或 FSDPOption 列表, 可選, 預設為 '') — 使用 PyTorch 分散式並行訓練（僅限分散式訓練）。

    以下選項列表：

    • "full_shard": 分片引數、梯度和最佳化器狀態。
    • "shard_grad_op": 分片最佳化器狀態和梯度。
    • "hybrid_shard": 在節點內應用 FULL_SHARD，並在節點間複製引數。
    • "hybrid_shard_zero2": 在節點內應用 SHARD_GRAD_OP，並在節點間複製引數。
    • "offload": 將引數和梯度解除安裝到 CPU（僅與 "full_shard" 和 "shard_grad_op" 相容）。
    • "auto_wrap": 使用 default_auto_wrap_policy 自動遞迴地用 FSDP 包裝層。
  • fsdp_config (str 或 dict, 可選) — 與 fsdp (Pytorch 分散式並行訓練) 一起使用的配置。該值可以是 fsdp json 配置檔案的位置 (例如 fsdp_config.json)，也可以是已載入的 json 檔案作為 dict。

    配置及其選項列表：

    • min_num_params (int, 可選, 預設為 0): FSDP 預設自動包裝的最小引數數量。（僅在傳遞 fsdp 欄位時有用）。

    • transformer_layer_cls_to_wrap (list[str], 可選): 要包裝的 Transformer 層類名列表（區分大小寫），例如 BertLayer、GPTJBlock、T5Block…（僅在傳遞 fsdp 標誌時有用）。

    • backward_prefetch (str, 可選) FSDP 的向後預取模式。控制何時預取下一組引數（僅在傳遞 fsdp 欄位時有用）。

      以下選項列表：

      • "backward_pre": 在當前引數集的梯度計算之前預取下一組引數。
      • "backward_post": 在當前引數集的梯度計算之後預取下一組引數。

    • forward_prefetch (bool, 可選, 預設為 False) FSDP 的前向預取模式（僅在傳遞 fsdp 欄位時有用）。如果 "True"，則 FSDP 在前向傳遞執行期間明確預取下一個即將到來的 all-gather。

    • limit_all_gathers (bool, 可選, 預設為 False) FSDP 的 limit_all_gathers（僅在傳遞 fsdp 欄位時有用）。如果 "True"，FSDP 明確同步 CPU 執行緒以防止過多的飛行中的 all-gather。

    • use_orig_params (bool, 可選, 預設為 True) 如果 "True"，允許在初始化期間進行非均勻 requires_grad，這意味著支援交錯的凍結和可訓練引數。在引數高效微調等情況下很有用。請參閱此 [部落格](https://dev-discuss.pytorch.org/t/rethinking-pytorch-fully-sharded-data-parallel-fsdp-from-first-principles/1019

    • sync_module_states (bool, 可選, 預設為 True) 如果 "True"，每個單獨包裝的 FSDP 單元將從 rank 0 廣播模組引數，以確保它們在初始化後在所有 rank 上相同。

    • cpu_ram_efficient_loading (bool, 可選, 預設為 False) 如果 "True"，只有第一個程序載入預訓練模型檢查點，而所有其他程序具有空權重。當此設定設定為 "True" 時，sync_module_states 也必須為 "True"，否則除主程序外的所有程序將具有隨機權重，導致訓練期間出現意外行為。

    • activation_checkpointing (bool, 可選, 預設為 False): 如果 "True"，啟用檢查點是一種透過清除某些層的啟用並在反向傳遞期間重新計算它們來減少記憶體使用的技術。實際上，這會以額外計算時間換取更低的記憶體使用。

    • xla (bool, 可選, 預設為 False): 是否使用 PyTorch/XLA 完全分片資料並行訓練。這是一個實驗性功能，其 API 未來可能會發展。

    • xla_fsdp_settings (dict, 可選) 該值是一個字典，用於儲存 XLA FSDP 包裝引數。

      有關選項的完整列表，請參閱 此處。

    • xla_fsdp_grad_ckpt (bool, 可選, 預設為 False): 將對每個巢狀的 XLA FSDP 包裝層使用梯度檢查點。此設定僅在 xla 標誌設定為 true 且透過 fsdp_min_num_params 或 fsdp_transformer_layer_cls_to_wrap 指定了自動包裝策略時才能使用。
  • deepspeed (str 或 dict, 可選) — 使用 Deepspeed。這是一個實驗性功能，其 API 未來可能會發展。該值可以是 DeepSpeed json 配置檔案的位置 (例如 ds_config.json)，也可以是已載入的 json 檔案作為 dict。

    如果啟用任何 Zero-init，請確保您的模型在初始化 TrainingArguments *之後*才進行初始化，否則將不會應用。
  • accelerator_config (str, dict, 或 AcceleratorConfig, 可選) — 與內部 Accelerator 實現一起使用的配置。該值可以是 accelerator json 配置檔案的位置 (例如 accelerator_config.json)，已載入的 json 檔案作為 dict，或 AcceleratorConfig 的例項。

    配置及其選項列表：

    • split_batches (bool, 可選, 預設為 False): 加速器是否應該在裝置之間拆分資料載入器生成的批次。如果為 True，則實際使用的批次大小在任何型別的分散式程序上都將相同，但它必須是您正在使用的 num_processes 的整數倍。如果為 False，則實際使用的批次大小將是您指令碼中設定的批次大小乘以程序數。
    • dispatch_batches (bool, 可選): 如果設定為 True，則由 Accelerator 準備的資料載入器僅在主程序中迭代，然後批次被拆分並廣播到每個程序。對於底層資料集是 IterableDataset 的 DataLoader，將預設為 True，否則為 False。
    • even_batches (bool, 可選, 預設為 True): 如果設定為 True，在所有程序的總批次大小不能精確地整除資料集的情況下，資料集開頭的樣本將被複制，以便批次可以在所有 worker 之間平均分配。
    • use_seedable_sampler (bool, 可選, 預設為 True): 是否使用完全可播種的隨機取樣器 (accelerate.data_loader.SeedableRandomSampler)。確保使用不同的取樣技術時訓練結果完全可重現。雖然種子到種子的結果可能不同，但平均而言，當使用多個不同的種子進行比較時，差異可以忽略不計。也應與 ~utils.set_seed 一起執行以獲得最佳結果。
    • use_configured_state (bool, 可選, 預設為 False): 是否使用在呼叫 TrainingArguments 之前定義的預配置 AcceleratorState 或 PartialState。如果為 True，則必須初始化 Accelerator 或 PartialState。請注意，這樣做可能會導致超引數調整問題。
  • label_smoothing_factor (float, 可選, 預設為 0.0) — 要使用的標籤平滑因子。零表示沒有標籤平滑，否則底層的獨熱編碼標籤將從 0 和 1 分別更改為 label_smoothing_factor/num_labels 和 1 - label_smoothing_factor + label_smoothing_factor/num_labels。
  • debug (str 或 DebugOption 列表, 可選, 預設為 "") — 啟用一個或多個除錯功能。這是一個實驗性功能。

    可能選項如下：

    • "underflow_overflow": 檢測模型輸入/輸出中的溢位並報告導致事件的最後幀
    • "tpu_metrics_debug": 在 TPU 上列印除錯指標

    選項應以空格分隔。

  • optim (str 或 training_args.OptimizerNames, 可選, 預設為 "adamw_torch") — 要使用的最佳化器，例如“adamw_torch”、“adamw_torch_fused”、“adamw_apex_fused”、“adamw_anyprecision”、“adafactor”。有關最佳化器的完整列表，請參閱 training_args.py 中的 OptimizerNames。
  • optim_args (str, 可選) — 提供給最佳化器（如 AnyPrecisionAdamW、AdEMAMix 和 GaLore）的可選引數。
  • group_by_length (bool, 可選, 預設為 False) — 是否將訓練資料集中長度大致相同的樣本分組在一起（以最小化填充並提高效率）。僅在應用動態填充時有用。
  • length_column_name (str, 可選, 預設為 "length") — 預計算長度的列名。如果該列存在，按長度分組將使用這些值而不是在訓練啟動時計算它們。除非 group_by_length 為 True 且資料集是 Dataset 的例項，否則將被忽略。
  • report_to (str 或 list[str], 可選, 預設為 "all") — 要報告結果和日誌的整合列表。支援的平臺有 "azure_ml"、"clearml"、"codecarbon"、"comet_ml"、"dagshub"、"dvclive"、"flyte"、"mlflow"、"neptune"、"swanlab"、"tensorboard" 和 "wandb"。使用 "all" 報告給所有已安裝的整合，"none" 則不報告給任何整合。
  • ddp_find_unused_parameters (bool, 可選) — 使用分散式訓練時，傳遞給 DistributedDataParallel 的 find_unused_parameters 標誌的值。如果使用梯度檢查點，則預設為 False，否則為 True。
  • ddp_bucket_cap_mb (int, 可選) — 使用分散式訓練時，傳遞給 DistributedDataParallel 的 bucket_cap_mb 標誌的值。
  • ddp_broadcast_buffers (bool, 可選) — 使用分散式訓練時，傳遞給 DistributedDataParallel 的 broadcast_buffers 標誌的值。如果使用梯度檢查點，則預設為 False，否則為 True。
  • dataloader_pin_memory (bool, 可選, 預設為 True) — 是否在資料載入器中固定記憶體。預設為 True。
  • dataloader_persistent_workers (bool, 可選, 預設為 False) — 如果為 True，資料載入器在資料集消耗一次後不會關閉 worker 程序。這允許保持 worker Dataset 例項的活躍。可能會加速訓練，但會增加 RAM 使用。預設為 False。
  • dataloader_prefetch_factor (int, 可選) — 每個 worker 預先載入的批次數量。2 表示所有 worker 總共預取 2 * num_workers 個批次。
  • skip_memory_metrics (bool, 可選, 預設為 True) — 是否跳過將記憶體分析器報告新增到指標。預設情況下會跳過，因為它會降低訓練和評估速度。
  • push_to_hub (bool, optional,預設為 False) — 是否在每次儲存模型時將模型推送到Hub。如果啟用，output_dir將成為一個與倉庫（由hub_model_id決定）同步的git目錄，並且每次觸發儲存時（取決於您的save_strategy）內容都會被推送。呼叫save_model()也將觸發推送。

    如果 output_dir 存在，它需要是 Trainer 將要推送的倉庫的本地克隆。
  • resume_from_checkpoint (str, optional) — 包含模型有效檢查點的資料夾路徑。此引數不直接由 Trainer 使用，而是旨在由您的訓練/評估指令碼使用。有關更多詳細資訊，請參閱 示例指令碼。
  • hub_model_id (str, optional) — 與本地output_dir保持同步的倉庫名稱。它可以是一個簡單的模型ID，在這種情況下模型將被推送到您的名稱空間。否則，它應該是完整的倉庫名稱，例如"user_name/model"，這允許您推送到您所屬的組織，例如"organization_name/model"。預設為user_name/output_dir_name，其中output_dir_name是output_dir的名稱。

    將預設為output_dir的名稱。

  • hub_strategy (str 或 HubStrategy, optional, 預設為 "every_save") — 定義推送到Hub的範圍和時間。可能的值有：

    • "end": 在呼叫 save_model() 方法時，推送模型、其配置、處理類（例如tokenizer，如果傳遞給Trainer）以及模型卡草稿。
    • "every_save": 每次儲存模型時，推送模型、其配置、處理類（例如tokenizer，如果傳遞給Trainer）以及模型卡草稿。推送是非同步的，以避免阻塞訓練，如果儲存非常頻繁，則只有在前一次推送完成後才嘗試新的推送。訓練結束時，將最後一次推送最終模型。
    • "checkpoint": 與 "every_save" 類似，但最新的檢查點也會推送到一個名為 last-checkpoint 的子資料夾中，方便您使用 trainer.train(resume_from_checkpoint="last-checkpoint") 輕鬆恢復訓練。
    • "all_checkpoints": 與 "checkpoint" 類似，但所有檢查點都按其在輸出資料夾中的方式推送（因此您將在最終倉庫中獲得每個資料夾的檢查點資料夾）
  • hub_token (str, optional) — 用於將模型推送到Hub的令牌。預設為透過 huggingface-cli login 獲取的快取資料夾中的令牌。
  • hub_private_repo (bool, optional) — 是否將倉庫設為私有。如果為 None（預設），則除非組織的預設設定為私有，否則倉庫將是公共的。如果倉庫已存在，此值將被忽略。
  • hub_always_push (bool, optional, 預設為 False) — 除非此引數為 True，否則 Trainer 將在上次推送未完成時跳過推送檢查點。
  • hub_revision (str, optional) — 推送到Hub時使用的修訂版本。可以是分支名稱、標籤或提交雜湊。
  • gradient_checkpointing (bool, optional, 預設為 False) — 如果為 True，則使用梯度檢查點來節省記憶體，代價是反向傳播速度較慢。
  • gradient_checkpointing_kwargs (dict, optional, 預設為 None) — 將傳遞給 gradient_checkpointing_enable 方法的關鍵字引數。
  • include_inputs_for_metrics (bool, optional, 預設為 False) — 此引數已棄用。請改用 include_for_metrics，例如 include_for_metrics = ["inputs"]。
  • include_for_metrics (list[str], optional, 預設為 []) — 如果需要計算指標，則在 compute_metrics 函式中包含附加資料。可新增到 include_for_metrics 列表的選項：

    • "inputs": 傳遞給模型的輸入資料，用於計算依賴於輸入的指標。
    • "loss": 評估期間計算的損失值，用於計算依賴於損失的指標。
  • eval_do_concat_batches (bool, optional, 預設為 True) — 是否在批次間遞迴連線輸入/損失/標籤/預測。如果為 False，則會將它們儲存為列表，每個批次單獨儲存。
  • auto_find_batch_size (bool, optional, 預設為 False) — 是否透過指數衰減自動查詢適合記憶體的批次大小，避免CUDA記憶體不足錯誤。需要安裝accelerate（pip install accelerate）。
  • full_determinism (bool, optional, 預設為 False) — 如果為 True，則呼叫 enable_full_determinism() 而非 set_seed() 以確保分散式訓練中的可重現結果。重要提示：這將對效能產生負面影響，因此僅用於除錯。
  • torchdynamo (str, optional) — 如果設定，則為TorchDynamo的後端編譯器。可能的選擇有 "eager"、"aot_eager"、"inductor"、"nvfuser"、"aot_nvfuser"、"aot_cudagraphs"、"ofi"、"fx2trt"、"onnxrt" 和 "ipex"。
  • ray_scope (str, optional, 預設為 "last") — 使用Ray進行超引數搜尋時使用的範圍。預設情況下，將使用 "last"。Ray將使用所有試驗的最後一個檢查點，比較它們並選擇最佳的。但是，也提供了其他選項。有關更多選項，請參閱 Ray文件。
  • ddp_timeout (int, optional, 預設為 1800) — torch.distributed.init_process_group 呼叫的超時時間，用於避免在分散式執行時執行慢速操作時出現的GPU套接字超時。有關更多資訊，請參閱 [PyTorch 文件] (https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group)。
  • use_mps_device (bool, optional, 預設為 False) — 此引數已棄用。如果可用，mps 裝置將類似於 cuda 裝置被使用。
  • torch_compile (bool, optional, 預設為 False) — 是否使用 PyTorch 2.0 torch.compile 編譯模型。

    這將使用 torch.compile API 的最佳預設值。您可以使用引數 torch_compile_backend 和 torch_compile_mode 自定義預設值，但我們不保證它們都能正常工作，因為 PyTorch 中正在逐步推出支援。

    此標誌和整個編譯 API 是實驗性的，未來版本中可能會發生變化。

  • torch_compile_backend (str, optional) — 在 torch.compile 中使用的後端。如果設定為任何值，torch_compile 將設定為 True。

    有關可能的值，請參閱 PyTorch 文件，並注意它們可能會因 PyTorch 版本而異。

    此標誌是實驗性的，未來版本中可能會發生變化。

  • torch_compile_mode (str, optional) — 在 torch.compile 中使用的模式。如果設定為任何值，torch_compile 將設定為 True。

    有關可能的值，請參閱 PyTorch 文件，並注意它們可能會因 PyTorch 版本而異。

    此標誌是實驗性的，未來版本中可能會發生變化。

  • include_tokens_per_second (bool, optional) — 是否計算每秒每裝置訓練速度指標的token數。

    這將預先迭代整個訓練資料載入器一次，

    並會減慢整個過程。

  • include_num_input_tokens_seen (bool, optional) — 是否跟蹤訓練過程中看到的輸入token數。

    在分散式訓練中可能會較慢，因為必須呼叫 gather 操作。

  • neftune_noise_alpha (Optional[float]) — 如果不是 None，這將啟用 NEFTune 噪聲嵌入。這可以顯著提高指令微調的模型效能。請查閱原始論文和原始程式碼。支援 transformers PreTrainedModel 以及 peft 中的 PeftModel。原始論文使用的值範圍為 [5.0, 15.0]。
  • optim_target_modules (Union[str, list[str]], optional) — 要最佳化的目標模組，即您希望訓練的模組名稱。目前用於 GaLore 演算法 (https://huggingface.co/papers/2403.03507) 和 APOLLO 演算法 (https://huggingface.co/papers/2412.05270)。有關更多詳細資訊，請參閱 GaLore 實現 (https://github.com/jiaweizzhao/GaLore) 和 APOLLO 實現 (https://github.com/zhuhanqing/APOLLO)。您需要確保傳遞有效的 GaLore 或 APOLLO 最佳化器，例如以下之一：“apollo_adamw”、“galore_adamw”、“galore_adamw_8bit”、“galore_adafactor”，並確保目標模組僅為 nn.Linear 模組。
  • batch_eval_metrics (Optional[bool], 預設為 False) — 如果設定為 True，評估將在每個批次結束時呼叫 compute_metrics 以累積統計資訊，而不是將所有評估日誌儲存在記憶體中。當設定為 True 時，您必須傳遞一個 compute_metrics 函式，該函式接受一個布林引數 compute_result，當傳入 True 時，它將從您在評估集上累積的批次級別統計資訊中觸發最終的全域性摘要統計資訊。
  • eval_on_start (bool, optional, 預設為 False) — 是否在訓練前執行評估步驟（健全性檢查），以確保驗證步驟正常工作。
  • eval_use_gather_object (bool, optional, 預設為 False) — 是否從所有裝置遞迴收集巢狀列表/元組/字典中的物件。這僅在使用者不只返回張量時才應啟用，並且 PyTorch 積極不鼓勵這樣做。
  • use_liger_kernel (bool, optional, 預設為 False) — 是否為LLM模型訓練啟用 Liger 核心。它可以有效提高多GPU訓練吞吐量約20%，並減少記憶體使用約60%，與flash attention、PyTorch FSDP和Microsoft DeepSpeed開箱即用。目前，它支援llama、mistral、mixtral和gemma模型。
  • liger_kernel_config (Optional[dict], optional) — 用於 Liger 核心的配置。當 use_liger_kernel=True 時，此字典作為關鍵字引數傳遞給 _apply_liger_kernel_to_instance 函式，該函式指定要應用哪些核心。可用選項因模型而異，但通常包括：‘rope’、‘swiglu’、‘cross_entropy’、‘fused_linear_cross_entropy’、‘rms_norm’ 等。如果為 None，則使用預設核心配置。
  • average_tokens_across_devices (bool, optional, 預設為 False) — 是否在裝置間平均token。如果啟用，將使用 all_reduce 來同步 num_tokens_in_batch 以進行精確的損失計算。參考：https://github.com/huggingface/transformers/issues/34242

TrainingArguments 是我們在示例指令碼中使用的引數子集，它們與訓練迴圈本身相關。

使用 HfArgumentParser，我們可以將此類轉換為可在命令列中指定的 argparse 引數。

get_process_log_level

< >

( )

根據此程序是否為節點0的主程序、非節點0的主程序或非主程序，返回要使用的日誌級別。

對於主程序，日誌級別預設為已設定的日誌級別（如果您未做任何操作，則為logging.WARNING），除非被log_level引數覆蓋。

對於副本程序，日誌級別預設為logging.WARNING，除非被log_level_replica引數覆蓋。

主程序和副本程序設定之間的選擇根據should_log的返回值進行。

get_warmup_steps

< >

( num_training_steps: int )

獲取用於線性預熱的步數。

main_process_first

< >

( local = True desc = 'work' )

引數

  • local (bool, optional, 預設為 True) — 如果 True，則首先指每個節點上排名為0的程序；如果 False，則首先指節點排名為0的程序。在具有共享檔案系統的多節點環境中，您很可能希望使用 local=False，這樣只有第一個節點的主程序會進行處理。但是，如果檔案系統不共享，則每個節點的主程序都需要進行處理，這是預設行為。
  • desc (str, optional, 預設為 "work") — 將用於除錯日誌的工作描述

一個用於torch分散式環境的上下文管理器，其中需要在主程序上執行某些操作，同時阻塞副本，並在完成後釋放副本。

其中一個用途是datasets的map功能，為了高效，它應該在主程序上執行一次，完成後儲存結果的快取版本，然後由副本自動載入。

set_dataloader

< >

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

引數

  • drop_last (bool, optional, 預設為 False) — 是否丟棄最後一個不完整的批次（如果資料集的長度不能被批次大小整除）。
  • num_workers (int, optional, 預設為 0) — 用於資料載入的子程序數（僅限 PyTorch）。0 表示資料將在主程序中載入。
  • pin_memory (bool, optional, 預設為 True) — 是否在資料載入器中鎖定記憶體。預設為 True。
  • persistent_workers (bool, optional, 預設為 False) — 如果為 True，則資料載入器在資料集消耗一次後不會關閉工作程序。這允許保持工作程序資料集例項的活動。可能潛在地加快訓練速度，但會增加RAM使用。預設為 False。
  • prefetch_factor (int, optional) — 每個 worker 提前載入的批次數量。2 表示所有 worker 總共預取 2 * num_workers 個批次。
  • auto_find_batch_size (bool, optional, 預設為 False) — 是否透過指數衰減自動查詢適合記憶體的批次大小，避免CUDA記憶體不足錯誤。需要安裝accelerate（pip install accelerate）。
  • ignore_data_skip (bool, optional, 預設為 False) — 恢復訓練時，是否跳過 epoch 和批次，以使資料載入與之前的訓練處於相同階段。如果設定為 True，訓練將更快開始（因為跳過步驟可能需要很長時間），但結果將與中斷的訓練結果不同。
  • sampler_seed (int, optional) — 與資料取樣器一起使用的隨機種子。如果未設定，資料取樣的隨機生成器將使用與 self.seed 相同的種子。這可用於確保資料取樣的可重現性，與模型種子無關。

將所有與資料載入器建立相關的引數進行分組的方法。

示例

>>> from transformers import TrainingArguments

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

set_evaluate

< >

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

引數

  • strategy (str 或 IntervalStrategy, optional, 預設為 "no") — 訓練期間採用的評估策略。可能的值為：

    • "no": 訓練期間不進行評估。
    • "steps": 每 steps 步進行一次評估（並記錄）。
    • "epoch": 每個 epoch 結束時進行評估。

    設定 strategy 不同於 "no" 將會把 self.do_eval 設定為 True。

  • steps (int, optional, 預設為 500) — 如果 strategy="steps"，兩次評估之間的更新步數。
  • batch_size (int optional, 預設為 8) — 用於評估的每個裝置（GPU/TPU 核心/CPU…）的批次大小。
  • accumulation_steps (int, optional) — 在將結果移動到CPU之前，用於累積輸出張量的預測步數。如果未設定，則整個預測都會在GPU/TPU上累積，然後移動到CPU（速度更快但需要更多記憶體）。
  • delay (float, optional) — 在第一次評估執行之前等待的 epoch 數或步數，取決於 eval_strategy。
  • loss_only (bool, optional, 預設為 False) — 忽略除損失之外的所有輸出。
  • jit_mode (bool, optional) — 推理時是否使用 PyTorch jit trace。

將所有與評估相關的引數進行分組的方法。

示例

>>> from transformers import TrainingArguments

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

set_logging

< >

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

引數

  • strategy (str 或 IntervalStrategy, 可選, 預設為 "steps") — 訓練期間採用的日誌記錄策略。可能的值為：

    • "no": 訓練期間不進行日誌記錄。
    • "epoch": 在每個 epoch 結束時進行日誌記錄。
    • "steps": 每隔 logging_steps 步進行日誌記錄。
  • steps (int, 可選, 預設為 500) — 如果 strategy="steps"，兩次日誌記錄之間更新步數。
  • level (str, 可選, 預設為 "passive") — 在主程序上使用的日誌級別。可能的值為字串形式的日誌級別："debug"、"info"、"warning"、"error" 和 "critical"，以及一個不設定任何內容並讓應用程式設定級別的 "passive" 級別。
  • report_to (str 或 list[str], 可選, 預設為 "all") — 用於報告結果和日誌的整合列表。支援的平臺有 "azure_ml"、"clearml"、"codecarbon"、"comet_ml"、"dagshub"、"dvclive"、"flyte"、"mlflow"、"neptune"、"swanlab"、"tensorboard" 和 "wandb"。使用 "all" 報告給所有已安裝的整合，使用 "none" 表示不使用任何整合。
  • first_step (bool, 可選, 預設為 False) — 是否記錄和評估第一個 global_step。
  • nan_inf_filter (bool, 可選, 預設為 True) — 是否過濾日誌中的 nan 和 inf 損失。如果設定為 True，則過濾每個 nan 或 inf 步的損失，並取當前日誌記錄視窗的平均損失。

    nan_inf_filter 隻影響損失值的日誌記錄，它不改變梯度計算或應用於模型的行為。
  • on_each_node (bool, 可選, 預設為 True) — 在多節點分散式訓練中，是否在每個節點上使用 log_level 記錄，或僅在主節點上記錄。
  • replica_level (str, 可選, 預設為 "passive") — 副本上使用的日誌級別。選擇與 log_level 相同。

一個將所有與日誌記錄相關的引數歸組的方法。

示例

>>> from transformers import TrainingArguments

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

set_lr_scheduler

< >

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

引數

  • name (str 或 SchedulerType, 可選, 預設為 "linear") — 要使用的排程器型別。有關所有可能的值，請參閱 SchedulerType 的文件。
  • num_epochs(float, 可選, 預設為 3.0) — 要執行的訓練 epoch 總數（如果不是整數，將在停止訓練前執行最後一個 epoch 的小數部分百分比）。
  • max_steps (int, 可選, 預設為 -1) — 如果設定為正數，則為要執行的訓練步數總和。覆蓋 num_train_epochs。對於有限資料集，訓練將在資料集上迭代（如果所有資料都已用完），直到達到 max_steps。
  • warmup_ratio (float, 可選, 預設為 0.0) — 用於從 0 到 learning_rate 的線性預熱的訓練步數總比例。
  • warmup_steps (int, 可選, 預設為 0) — 用於從 0 到 learning_rate 的線性預熱的步數。覆蓋 warmup_ratio 的任何效果。

一個將所有與學習率排程器及其超引數相關的引數歸組的方法。

示例

>>> from transformers import TrainingArguments

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

set_optimizer

< >

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

引數

  • name (str 或 training_args.OptimizerNames, 可選, 預設為 "adamw_torch") — 要使用的最佳化器："adamw_torch"、"adamw_torch_fused"、"adamw_apex_fused"、"adamw_anyprecision" 或 "adafactor"。
  • learning_rate (float, 可選, 預設為 5e-5) — 初始學習率。
  • weight_decay (float, 可選, 預設為 0) — 應用於除所有偏置和 LayerNorm 權重之外的所有層的權重衰減（如果不為零）。
  • beta1 (float, 可選, 預設為 0.9) — Adam 最佳化器或其變體的 beta1 超引數。
  • beta2 (float, 可選, 預設為 0.999) — Adam 最佳化器或其變體的 beta2 超引數。
  • epsilon (float, 可選, 預設為 1e-8) — Adam 最佳化器或其變體的 epsilon 超引數。
  • args (str, 可選) — 供給 AnyPrecisionAdamW 的可選引數（僅在 optim="adamw_anyprecision" 時有用）。

一個將所有與最佳化器及其超引數相關的引數歸組的方法。

示例

>>> from transformers import TrainingArguments

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

set_push_to_hub

< >

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

引數

  • model_id (str) — 要與本地 output_dir 保持同步的儲存庫名稱。它可以是一個簡單的模型 ID，在這種情況下，模型將被推送到您的名稱空間中。否則，它應該是一個完整的儲存庫名稱，例如 "user_name/model"，這樣您就可以推送到您是成員的組織，例如 "organization_name/model"。
  • strategy (str 或 HubStrategy, 可選, 預設為 "every_save") — 定義推送到 Hub 的範圍和時間。可能的值為：

    • "end": 當呼叫 save_model() 方法時，推送模型、其配置、處理類（例如分詞器，如果傳遞給 Trainer）和模型卡草稿。
    • "every_save": 每次模型儲存時，推送模型、其配置、處理類（例如分詞器，如果傳遞給 Trainer）和模型卡草稿。推送是非同步的，以避免阻塞訓練，如果儲存非常頻繁，只有在前一次推送完成後才會嘗試新的推送。訓練結束時，將推送最終模型。
    • "checkpoint": 類似於 "every_save"，但最新的檢查點也會推送到名為 last-checkpoint 的子資料夾中，這樣您就可以輕鬆地使用 trainer.train(resume_from_checkpoint="last-checkpoint") 恢復訓練。
    • "all_checkpoints": 類似於 "checkpoint"，但所有檢查點都按它們在輸出資料夾中出現的方式推送（因此您的最終儲存庫中每個資料夾都會有一個檢查點資料夾）。
  • token (str, 可選) — 用於將模型推送到 Hub 的令牌。預設為使用 huggingface-cli login 獲得的快取資料夾中的令牌。
  • private_repo (bool, 可選, 預設為 False) — 是否將儲存庫設為私有。如果為 None（預設），儲存庫將是公共的，除非組織的預設設定為私有。如果儲存庫已存在，此值將被忽略。
  • always_push (bool, 可選, 預設為 False) — 除非此項為 True，否則 Trainer 將跳過在上次推送未完成時推送檢查點。
  • revision (str, 可選) — 推送到 Hub 時使用的修訂版本。可以是分支名稱、標籤或提交雜湊。

一個將所有與檢查點與 Hub 同步相關的引數歸組的方法。

呼叫此方法會將 self.push_to_hub 設定為 True，這意味著 output_dir 將成為與儲存庫（由 model_id 決定）同步的 git 目錄，並且每次觸發儲存時（取決於您的 self.save_strategy）內容都將被推送到 Hub。呼叫 save_model() 也會觸發推送。

示例

>>> from transformers import TrainingArguments

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

set_save

< >

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

引數

  • strategy (str 或 IntervalStrategy, 可選, 預設為 "steps") — 訓練期間採用的檢查點儲存策略。可能的值為：

    • "no": 訓練期間不進行儲存。
    • "epoch": 在每個 epoch 結束時進行儲存。
    • "steps": 每隔 save_steps 步進行儲存。
  • steps (int, 可選, 預設為 500) — 如果 strategy="steps"，兩次檢查點儲存之間更新步數。
  • total_limit (int, 可選) — 如果傳遞一個值，將限制檢查點的總數。刪除 output_dir 中較舊的檢查點。
  • on_each_node (bool, 可選, 預設為 False) — 在多節點分散式訓練時，是否在每個節點上儲存模型和檢查點，或僅在主節點上儲存。

    當不同節點使用相同的儲存時，不應啟用此項，因為檔案將以相同的名稱儲存在每個節點上。

一個將所有與檢查點儲存相關的引數歸組的方法。

示例

>>> from transformers import TrainingArguments

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

set_testing

< >

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

引數

  • batch_size (int 可選, 預設為 8) — 用於測試的每個裝置（GPU/TPU core/CPU...）的批次大小。
  • loss_only (bool, 可選, 預設為 False) — 忽略除損失之外的所有輸出。
  • jit_mode (bool, 可選) — 是否使用 PyTorch jit trace 進行推理。

一個將所有與在保留資料集上進行測試相關的基本引數歸組的方法。

呼叫此方法將自動將 self.do_predict 設定為 True。

示例

>>> from transformers import TrainingArguments

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

set_training

< >

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

引數

  • learning_rate (float, 可選, 預設為 5e-5) — 最佳化器的初始學習率。
  • batch_size (int 可選, 預設為 8) — 用於訓練的每個裝置（GPU/TPU core/CPU...）的批次大小。
  • weight_decay (float, 可選, 預設為 0) — 應用於除所有偏置和 LayerNorm 權重之外的所有層的權重衰減（如果不為零）。
  • num_train_epochs(float, 可選, 預設為 3.0) — 要執行的訓練 epoch 總數（如果不是整數，將在停止訓練前執行最後一個 epoch 的小數部分百分比）。
  • max_steps (int, 可選, 預設為 -1) — 如果設定為正數，則為要執行的訓練步數總和。覆蓋 num_train_epochs。對於有限資料集，訓練將在資料集上迭代（如果所有資料都已用完），直到達到 max_steps。
  • gradient_accumulation_steps (int, 可選, 預設為 1) — 梯度累積的更新步數，然後執行反向/更新傳遞。

    當使用梯度累積時，一步算作一步反向傳遞。因此，日誌記錄、評估、儲存將在每 gradient_accumulation_steps * xxx_step 個訓練樣本後進行。
  • seed (int, 可選, 預設為 42) — 在訓練開始時設定的隨機種子。為確保跨執行的可重現性，如果模型有一些隨機初始化引數，請使用 ~Trainer.model_init 函式來例項化模型。
  • gradient_checkpointing (bool, 可選, 預設為 False) — 如果為 True，則使用梯度檢查點來節省記憶體，但會犧牲反向傳播速度。

一個將所有與訓練相關的基本引數歸組的方法。

呼叫此方法將自動將 self.do_train 設定為 True。

示例

>>> from transformers import TrainingArguments

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

to_dict

< >

( )

序列化此例項，同時將 Enum 替換為其值（為了支援 JSON 序列化）。它透過移除令牌值來混淆令牌值。

to_json_string

< >

( )

將此例項序列化為 JSON 字串。

to_sanitized_dict

< >

( )

用於 TensorBoard hparams 的淨化序列化。

Seq2SeqTrainingArguments

class transformers.Seq2SeqTrainingArguments

< >

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

引數

  • output_dir (str, 可選, 預設為 "trainer_output") — 模型預測和檢查點將寫入的輸出目錄。
  • overwrite_output_dir (bool, 可選, 預設為 False) — 如果為 True，則覆蓋輸出目錄的內容。如果 output_dir 指向檢查點目錄，則使用此選項繼續訓練。
  • do_train (bool, 可選, 預設為 False) — 是否執行訓練。此引數不直接由 Trainer 使用，而是旨在供您的訓練/評估指令碼使用。有關更多詳細資訊，請參閱示例指令碼。
  • do_eval (bool, 可選) — 是否在驗證集上執行評估。如果 eval_strategy 不同於 "no"，則將其設定為 True。此引數不直接由 Trainer 使用，而是旨在供您的訓練/評估指令碼使用。有關更多詳細資訊，請參閱示例指令碼。
  • do_predict (bool, 可選, 預設為 False) — 是否在測試集上執行預測。此引數不直接由 Trainer 使用，而是旨在供您的訓練/評估指令碼使用。有關更多詳細資訊，請參閱示例指令碼。
  • eval_strategy (str 或 IntervalStrategy, 可選, 預設為 "no") — 訓練期間採用的評估策略。可能的值為：

    • "no": 訓練期間不進行評估。
    • "steps": 每 eval_steps 評估一次（並記錄）。
    • "epoch": 每個 epoch 結束時進行評估。
  • prediction_loss_only (bool, 可選, 預設為 False) — 執行評估和生成預測時，僅返回損失。
  • per_device_train_batch_size (int, 可選, 預設為 8) — 每個裝置加速器核心/CPU 的訓練批次大小。
  • per_device_eval_batch_size (int, 可選, 預設為 8) — 每個裝置加速器核心/CPU 的評估批次大小。
  • gradient_accumulation_steps (int, 可選, 預設為 1) — 在執行反向/更新傳遞之前，用於累積梯度的更新步數。

    使用梯度累積時，一步被視為一個帶有反向傳播的步驟。因此，日誌記錄、評估和儲存將在每 gradient_accumulation_steps * xxx_step 個訓練樣本後進行。
  • eval_accumulation_steps (int, 可選) — 累積輸出張量進行預測的步數，然後將結果移動到 CPU。如果未設定，則整個預測都會在裝置加速器上累積，然後才移動到 CPU（速度更快但需要更多記憶體）。
  • eval_delay (float, 可選) — 在執行第一次評估之前需要等待的 epoch 或步數，具體取決於 eval_strategy。
  • torch_empty_cache_steps (int, 可選) — 在呼叫 torch..empty_cache() 之前要等待的步數。如果未設定或設定為 None，則不會清空快取。

    這可以透過降低峰值 VRAM 使用量來幫助避免 CUDA 記憶體不足錯誤，但代價是效能會降低約 10%。
  • learning_rate (float, 可選, 預設為 5e-5) — AdamW 最佳化器的初始學習率。
  • weight_decay (float, 可選, 預設為 0) — 除了 AdamW 最佳化器中的所有偏差和 LayerNorm 權重外，對所有層應用的權重衰減（如果不為零）。
  • adam_beta1 (float, 可選, 預設為 0.9) — AdamW 最佳化器的 beta1 超引數。
  • adam_beta2 (float, 可選, 預設為 0.999) — AdamW 最佳化器的 beta2 超引數。
  • adam_epsilon (float, 可選, 預設為 1e-8) — AdamW 最佳化器的 epsilon 超引數。
  • max_grad_norm (float, 可選, 預設為 1.0) — 最大梯度範數（用於梯度裁剪）。
  • num_train_epochs(float, 可選, 預設為 3.0) — 要執行的訓練總 epoch 數（如果不是整數，則在停止訓練之前執行最後一個 epoch 的小數部分百分比）。
  • max_steps (int, 可選, 預設為 -1) — 如果設定為正數，則為要執行的訓練總步數。覆蓋 num_train_epochs。對於有限資料集，訓練將透過資料集（如果所有資料都已耗盡）重複進行，直到達到 max_steps。
  • lr_scheduler_type (str 或 SchedulerType, 可選, 預設為 "linear") — 要使用的排程器型別。有關所有可能的值，請參閱 SchedulerType 的文件。
  • lr_scheduler_kwargs (‘dict’, 可選, 預設為 {}) — 學習率排程器的額外引數。有關可能的值，請參閱每個排程器的文件。
  • warmup_ratio (float, 可選, 預設為 0.0) — 用於從 0 到 learning_rate 線性預熱的總訓練步數的比例。
  • warmup_steps (int, 可選, 預設為 0) — 用於從 0 到 learning_rate 線性預熱的步數。覆蓋 warmup_ratio 的任何效果。
  • log_level (str, 可選, 預設為 passive) — 在主程序上使用的日誌級別。可能的選擇是字串形式的日誌級別：'debug'、'info'、'warning'、'error' 和 'critical'，以及一個 'passive' 級別，該級別不設定任何內容並保持 Transformers 庫的當前日誌級別（預設情況下為 "warning"）。
  • log_level_replica (str, 可選, 預設為 "warning") — 在副本上使用的日誌級別。與 log_level 具有相同的選擇。
  • log_on_each_node (bool, 可選, 預設為 True) — 在多節點分散式訓練中，是否每個節點使用 log_level 記錄一次，或者僅在主節點上記錄。
  • logging_dir (str, 可選) — TensorBoard 日誌目錄。預設為 *output_dir/runs/CURRENT_DATETIME_HOSTNAME*。
  • logging_strategy (str 或 IntervalStrategy, 可選, 預設為 "steps") — 訓練期間採用的日誌記錄策略。可能的值為：

    • "no": 訓練期間不進行日誌記錄。
    • "epoch": 每個 epoch 結束時進行日誌記錄。
    • "steps": 每 logging_steps 記錄一次。
  • logging_first_step (bool, 可選, 預設為 False) — 是否記錄第一個 global_step。
  • logging_steps (int 或 float, 可選, 預設為 500) — 如果 logging_strategy="steps"，則兩次日誌記錄之間的更新步數。應為整數或在 [0,1) 範圍內的浮點數。如果小於 1，則將其解釋為總訓練步數的比例。
  • logging_nan_inf_filter (bool, 可選, 預設為 True) — 是否過濾 nan 和 inf 損失以進行日誌記錄。如果設定為 True，則過濾掉每個步驟中為 nan 或 inf 的損失，並取當前日誌視窗的平均損失。

    logging_nan_inf_filter 僅影響損失值的日誌記錄，它不改變梯度計算或應用於模型的行為。
  • save_strategy (str 或 SaveStrategy, 可選, 預設為 "steps") — 訓練期間採用的檢查點儲存策略。可能的值為：

    • "no"：訓練期間不儲存。
    • "epoch"：在每個 epoch 結束時儲存。
    • "steps"：每 save_steps 儲存一次。
    • "best"：每當達到新的 best_metric 時儲存。

    如果選擇 "epoch" 或 "steps"，也總會在訓練結束時執行儲存。

  • save_steps (int 或 float, 可選, 預設為 500) — 如果 save_strategy="steps"，則兩次檢查點儲存之間的更新步數。應為整數或範圍 [0,1) 內的浮點數。如果小於 1，則解釋為總訓練步數的比例。
  • save_total_limit (int, 可選) — 如果傳入值，將限制檢查點的總數量。刪除 output_dir 中較舊的檢查點。當啟用 load_best_model_at_end 時，除了最新的檢查點外，根據 metric_for_best_model 的“最佳”檢查點將始終保留。例如，對於 save_total_limit=5 和 load_best_model_at_end，將始終保留最後四個檢查點以及最佳模型。當 save_total_limit=1 和 load_best_model_at_end 時，可能會儲存兩個檢查點：最後一個和最佳一個（如果它們不同）。
  • save_safetensors (bool, 可選, 預設為 True) — 對狀態字典使用 safetensors 儲存和載入，而不是預設的 torch.load 和 torch.save。
  • save_on_each_node (bool, 可選, 預設為 False) — 進行多節點分散式訓練時，是否在每個節點上儲存模型和檢查點，或者僅在主節點上儲存。

    當不同節點使用相同的儲存時，不應啟用此選項，因為檔案將以相同的名稱儲存到每個節點。

  • save_only_model (bool, 可選, 預設為 False) — 在檢查點時，是隻儲存模型，還是同時儲存最佳化器、排程器和 rng 狀態。請注意，如果設定為 True，則無法從檢查點恢復訓練。這使您可以透過不儲存最佳化器、排程器和 rng 狀態來節省儲存空間。此選項設定為 True 時，只能使用 from_pretrained 載入模型。
  • restore_callback_states_from_checkpoint (bool, 可選, 預設為 False) — 是否從檢查點恢復回撥狀態。如果為 True，則如果檢查點中存在回撥，將覆蓋傳遞給 Trainer 的回撥。
  • use_cpu (bool, 可選, 預設為 False) — 是否使用 CPU。如果設定為 False，我們將使用可用的 cuda 或 mps 裝置。
  • seed (int, 可選, 預設為 42) — 訓練開始時設定的隨機種子。為了確保跨執行的可復現性，如果模型具有一些隨機初始化的引數，請使用 ~Trainer.model_init 函式例項化模型。
  • data_seed (int, 可選) — 用於資料取樣器的隨機種子。如果未設定，資料取樣的隨機生成器將使用與 seed 相同的種子。這可用於確保資料取樣的可復現性，與模型種子無關。
  • jit_mode_eval (bool, 可選, 預設為 False) — 是否使用 PyTorch jit trace 進行推理。
  • use_ipex (bool, 可選, 預設為 False) — 在可用時使用 PyTorch 的 Intel 擴充套件。IPEX 安裝。
  • bf16 (bool, 可選, 預設為 False) — 是否使用 bf16 16 位（混合）精度訓練而不是 32 位訓練。需要 Ampere 或更高版本的 NVIDIA 架構、Intel XPU、使用 CPU (use_cpu) 或 Ascend NPU。這是一個實驗性 API，可能會發生變化。
  • fp16 (bool, 可選, 預設為 False) — 是否使用 fp16 16 位（混合）精度訓練而不是 32 位訓練。
  • fp16_opt_level (str, 可選, 預設為 'O1') — 對於 fp16 訓練，Apex AMP 最佳化級別選擇在 ['O0', 'O1', 'O2', 'O3'] 中。有關詳細資訊，請參閱 Apex 文件。
  • fp16_backend (str, 可選, 預設為 "auto") — 此引數已棄用。請改用 half_precision_backend。
  • half_precision_backend (str, 可選, 預設為 "auto") — 用於混合精度訓練的後端。必須是 "auto", "apex", "cpu_amp" 之一。 "auto" 將根據檢測到的 PyTorch 版本使用 CPU/CUDA AMP 或 APEX，而其他選項將強制使用請求的後端。
  • bf16_full_eval (bool, 可選, 預設為 False) — 是否使用完整的 bfloat16 評估而不是 32 位。這將更快並節省記憶體，但可能會損害度量值。這是一個實驗性 API，可能會發生變化。
  • fp16_full_eval (bool, 可選, 預設為 False) — 是否使用完整的 float16 評估而不是 32 位。這將更快並節省記憶體，但可能會損害度量值。
  • tf32 (bool, 可選) — 是否啟用 TF32 模式，該模式在 Ampere 及更高版本的 GPU 架構中可用。預設值取決於 PyTorch 的 torch.backends.cuda.matmul.allow_tf32 的預設版本。更多詳細資訊請參閱 TF32 文件。這是一個實驗性 API，可能會發生變化。
  • local_rank (int, 可選, 預設為 -1) — 分散式訓練期間的程序排名。
  • ddp_backend (str, 可選) — 用於分散式訓練的後端。必須是 "nccl"、"mpi"、"ccl"、"gloo"、"hccl" 之一。
  • tpu_num_cores (int, 可選) — 在 TPU 上訓練時，TPU 核心的數量（由啟動器指令碼自動傳入）。
  • dataloader_drop_last (bool, 可選, 預設為 False) — 是否丟棄最後一個不完整的批次（如果資料集的長度不能被批次大小整除）。
  • eval_steps (int 或 float, 可選) — 如果 eval_strategy="steps"，則兩次評估之間的更新步數。如果未設定，將預設為與 logging_steps 相同的值。應為整數或範圍 [0,1) 內的浮點數。如果小於 1，則解釋為總訓練步數的比例。
  • dataloader_num_workers (int, 可選, 預設為 0) — 用於資料載入的子程序數量（僅限 PyTorch）。0 表示資料將在主程序中載入。
  • past_index (int, 可選, 預設為 -1) — 某些模型，如 TransformerXL 或 XLNet，可以利用過去的隱藏狀態進行預測。如果此引數設定為正整數，則 Trainer 將使用相應的輸出（通常是索引 2）作為過去狀態，並在下一個訓練步驟中將其作為關鍵字引數 mems 饋送給模型。
  • run_name (str, 可選, 預設為 output_dir) — 執行的描述符。通常用於 wandb、mlflow、comet 和 swanlab 日誌記錄。如果未指定，將與 output_dir 相同。
  • disable_tqdm (bool, 可選) — 是否停用 tqdm 進度條和 Jupyter Notebooks 中 ~notebook.NotebookTrainingTracker 生成的指標表。如果日誌級別設定為警告或更低（預設），則預設為 True，否則為 False。
  • remove_unused_columns (bool, 可選, 預設為 True) — 是否自動刪除模型 forward 方法未使用的列。
  • label_names (list[str], 可選) — 輸入字典中與標籤對應的鍵列表。

    最終將預設為模型接受的包含“label”字樣的引數名稱列表，但如果使用的模型是 XxxForQuestionAnswering 中的一個，則還將包括 ["start_positions", "end_positions"] 鍵。

  • load_best_model_at_end (bool, 可選, 預設為 False) — 是否在訓練結束時載入訓練期間找到的最佳模型。啟用此選項後，最佳檢查點將始終被儲存。更多資訊請參閱 save_total_limit。

    當設定為 True 時，引數 save_strategy 需要與 eval_strategy 相同，如果為“steps”，則 save_steps 必須是 eval_steps 的整數倍。
  • metric_for_best_model (str, 可選) — 與 load_best_model_at_end 結合使用，以指定用於比較兩個不同模型的指標。必須是評估返回的指標名稱，可以帶或不帶字首 "eval_"。

    如果未指定，當 load_best_model_at_end == True 或 lr_scheduler_type == SchedulerType.REDUCE_ON_PLATEAU 時，此項將預設為 "loss"（以使用評估損失）。

    如果設定此值，除非名稱以“loss”結尾，否則 greater_is_better 將預設為 True。如果您的指標越低越好，請務必將其設定為 False。

  • greater_is_better (bool, 可選) — 與 load_best_model_at_end 和 metric_for_best_model 結合使用，以指定更好的模型是否應具有更大的指標值。將預設為：

    • 如果 metric_for_best_model 設定為不以 "loss" 結尾的值，則為 True。
    • 如果 metric_for_best_model 未設定，或設定為以 "loss" 結尾的值，則為 False。
  • ignore_data_skip (bool, 可選, 預設為 False) — 恢復訓練時，是否跳過 epoch 和批次以使資料載入與之前的訓練處於同一階段。如果設定為 True，訓練將更快開始（因為跳過步驟可能需要很長時間），但不會產生與中斷訓練相同的結果。
  • fsdp (bool, str 或 FSDPOption 列表, 可選, 預設為 '') — 使用 PyTorch 分散式並行訓練（僅限分散式訓練）。

    以下選項列表：

    • "full_shard"：分片引數、梯度和最佳化器狀態。
    • "shard_grad_op"：分片最佳化器狀態和梯度。
    • "hybrid_shard"：在節點內應用 FULL_SHARD，並在節點間複製引數。
    • "hybrid_shard_zero2"：在節點內應用 SHARD_GRAD_OP，並在節點間複製引數。
    • "offload"：將引數和梯度解除安裝到 CPU（僅與 "full_shard" 和 "shard_grad_op" 相容）。
    • "auto_wrap"：使用 default_auto_wrap_policy 自動遞迴包裝層，並使用 FSDP。
  • fsdp_config (str 或 dict, 可選) — 用於 fsdp（PyTorch 分散式並行訓練）的配置。該值可以是 fsdp json 配置檔案（例如，fsdp_config.json）的位置，也可以是已載入的 json 檔案（以 dict 形式）。

    配置及其選項列表：

    • min_num_params (int, 可選, 預設為 0)：FSDP 預設自動包裝的最小引數數量。（僅在傳遞 fsdp 欄位時有用）。

    • transformer_layer_cls_to_wrap (list[str], 可選)：要包裝的 Transformer 層類名列表（區分大小寫），例如 BertLayer、GPTJBlock、T5Block 等（僅在傳遞 fsdp 標誌時有用）。

    • backward_prefetch (str, 可選)：FSDP 的後向預取模式。控制何時預取下一組引數（僅在傳遞 fsdp 欄位時有用）。

      以下選項列表：

      • "backward_pre"：在當前引數集的梯度計算之前預取下一組引數。
      • "backward_post"：在當前引數集的梯度計算之後預取下一組引數。

    • forward_prefetch (bool, 可選, 預設為 False)：FSDP 的前向預取模式（僅在傳遞 fsdp 欄位時有用）。如果為 "True"，則 FSDP 在前向傳播期間執行時明確預取下一個即將到來的 all-gather。

    • limit_all_gathers (bool, 可選, 預設為 False)：FSDP 的 limit_all_gathers（僅在傳遞 fsdp 欄位時有用）。如果為 "True"，FSDP 明確同步 CPU 執行緒以防止過多的飛行中的 all-gather。

    • use_orig_params (bool, 可選, 預設為 True)：如果為 "True"，則允許在初始化期間使用非統一的 requires_grad，這意味著支援交錯的凍結和可訓練引數。在引數高效微調等情況下很有用。請參閱此 [部落格](https://dev-discuss.pytorch.org/t/rethinking-pytorch-fully-sharded-data-parallel-fsdp-from-first-principles/1019)

    • sync_module_states (bool, 可選, 預設為 True)：如果為 "True"，則每個單獨包裝的 FSDP 單元將從 rank 0 廣播模組引數，以確保它們在初始化後在所有 rank 上都相同。

    • cpu_ram_efficient_loading (bool, 可選, 預設為 False)：如果為 "True"，則只有第一個程序載入預訓練模型檢查點，而所有其他程序的權重為空。當此設定為 "True" 時，sync_module_states 也必須設定為 "True"，否則除主程序外的所有程序都將具有隨機權重，導致訓練期間出現意外行為。

    • activation_checkpointing (bool, 可選, 預設為 False)：如果為 "True"，則啟用檢查點是一種透過清除某些層的啟用並在反向傳播期間重新計算它們來減少記憶體使用量的技術。實際上，這會犧牲額外的計算時間來減少記憶體使用量。

    • xla (bool, 可選, 預設為 False)：是否使用 PyTorch/XLA 完全分片資料並行訓練。這是一個實驗性功能，其 API 未來可能會發生變化。

    • xla_fsdp_settings (dict, 可選)：該值是一個字典，儲存 XLA FSDP 包裝引數。

      有關選項的完整列表，請參閱此處。

    • xla_fsdp_grad_ckpt (bool, 可選, 預設為 False)：將在每個巢狀的 XLA FSDP 包裝層上使用梯度檢查點。此設定僅在 xla 標誌設定為 true 且透過 fsdp_min_num_params 或 fsdp_transformer_layer_cls_to_wrap 指定了自動包裝策略時才能使用。
  • deepspeed (str 或 dict, 可選) — 使用 Deepspeed。這是一個實驗性功能，其 API 未來可能會發生變化。該值可以是 DeepSpeed json 配置檔案（例如，ds_config.json）的位置，也可以是已載入的 json 檔案（以 dict 形式）。

    如果啟用任何 Zero-init，請確保在初始化 `TrainingArguments` *之後* 才初始化模型，否則它將不被應用。
  • accelerator_config (str, dict 或 AcceleratorConfig, 可選) — 用於內部 Accelerator 實現的配置。該值可以是 accelerator json 配置檔案（例如，accelerator_config.json）的位置，也可以是已載入的 json 檔案（以 dict 形式），或者是 AcceleratorConfig 的例項。

    配置及其選項列表：

    • split_batches (bool, 可選, 預設為 False)：加速器是否應將資料載入器生成的批次拆分到各個裝置上。如果為 True，則實際使用的批次大小在任何型別的分散式程序上都將相同，但它必須是您正在使用的 num_processes 的整數倍。如果為 False，則實際使用的批次大小將是您指令碼中設定的批次大小乘以程序數。
    • dispatch_batches (bool, 可選)：如果設定為 True，則 Accelerator 準備的資料載入器僅在主程序上迭代，然後批次被拆分並廣播到每個程序。對於底層資料集是 IterableDataset 的 DataLoader，預設值為 True，否則為 False。
    • even_batches (bool, 可選, 預設為 True)：如果設定為 True，在所有程序的總批次大小不能精確地除以資料集的情況下，資料集開頭的樣本將被複制，以便批次可以均勻地分配給所有工作程序。
    • use_seedable_sampler (bool, 可選, 預設為 True)：是否使用完全可種子化的隨機取樣器 (accelerate.data_loader.SeedableRandomSampler)。確保訓練結果可以使用不同的取樣技術完全重現。雖然種子到種子的結果可能不同，但在使用多個不同種子進行比較時，差異平均可忽略不計。為了獲得最佳結果，還應與 ~utils.set_seed 一起執行。
    • use_configured_state (bool, 可選, 預設為 False)：是否使用在呼叫 TrainingArguments 之前定義的預配置 AcceleratorState 或 PartialState。如果為 True，則必須初始化 Accelerator 或 PartialState。請注意，這樣做可能會導致超引數調整出現問題。
  • label_smoothing_factor (float, 可選, 預設為 0.0) — 要使用的標籤平滑因子。零表示不進行標籤平滑，否則底層獨熱編碼標籤將分別從 0 和 1 更改為 label_smoothing_factor/num_labels 和 1 - label_smoothing_factor + label_smoothing_factor/num_labels。
  • debug (str 或 DebugOption 列表, 可選, 預設為 "") — 啟用一個或多個除錯功能。這是一個實驗性功能。

    可能的選項有：

    • "underflow_overflow"：檢測模型輸入/輸出中的溢位，並報告導致該事件的最後幾幀
    • "tpu_metrics_debug"：在 TPU 上列印除錯指標

    選項應由空格分隔。

  • optim (str 或 training_args.OptimizerNames, 可選, 預設為 "adamw_torch") — 要使用的最佳化器，例如“adamw_torch”、“adamw_torch_fused”、“adamw_apex_fused”、“adamw_anyprecision”、“adafactor”。有關最佳化器的完整列表，請參閱 training_args.py 中的 OptimizerNames。
  • optim_args (str, 可選) — 提供給最佳化器（如 AnyPrecisionAdamW、AdEMAMix 和 GaLore）的可選引數。
  • group_by_length (bool, 可選, 預設為 False) — 是否在訓練資料集中將大致相同長度的樣本分組在一起（以最小化填充並提高效率）。僅在應用動態填充時有用。
  • length_column_name (str, 可選, 預設為 "length") — 預計算長度的列名。如果該列存在，按長度分組將使用這些值，而不是在訓練啟動時計算它們。除非 group_by_length 為 True 且資料集是 Dataset 的例項，否則此引數將被忽略。
  • report_to (str 或 list[str], 可選, 預設為 "all") — 用於報告結果和日誌的整合列表。支援的平臺有 "azure_ml"、"clearml"、"codecarbon"、"comet_ml"、"dagshub"、"dvclive"、"flyte"、"mlflow"、"neptune"、"swanlab"、"tensorboard" 和 "wandb"。使用 "all" 表示向所有已安裝的整合報告，使用 "none" 表示不報告任何整合。
  • ddp_find_unused_parameters (bool, 可選) — 使用分散式訓練時，傳遞給 DistributedDataParallel 的 find_unused_parameters 標誌的值。如果使用梯度檢查點，則預設為 False，否則為 True。
  • ddp_bucket_cap_mb (int, 可選) — 使用分散式訓練時，傳遞給 DistributedDataParallel 的 bucket_cap_mb 標誌的值。
  • ddp_broadcast_buffers (bool, 可選) — 使用分散式訓練時，傳遞給 DistributedDataParallel 的 broadcast_buffers 標誌的值。如果使用梯度檢查點，則預設為 False，否則為 True。
  • dataloader_pin_memory (bool, 可選, 預設為 True) — 是否要在資料載入器中固定記憶體。預設為 True。
  • dataloader_persistent_workers (bool, 可選, 預設為 False) — 如果為 True，資料載入器在資料集消耗一次後不會關閉工作程序。這允許保持工作程序的 Dataset 例項處於活動狀態。這可能會加速訓練，但會增加 RAM 使用量。預設為 False。
  • dataloader_prefetch_factor (int, 可選) — 每個工作程序預載入的批次數量。2 表示所有工作程序總共預載入 2 * num_workers 個批次。
  • skip_memory_metrics (bool, 可選, 預設為 True) — 是否跳過將記憶體分析器報告新增到指標中。預設情況下跳過此操作，因為它會降低訓練和評估速度。
  • push_to_hub (bool, 可選, 預設為 False) — 每次儲存模型時是否將模型推送到 Hub。如果啟用此功能，output_dir 將成為與儲存庫（由 hub_model_id 確定）同步的 Git 目錄，並且每次觸發儲存時（取決於您的 save_strategy）都會推送內容。呼叫 save_model() 也會觸發推送。

    如果 output_dir 存在，它需要是與 Trainer 將被推送到的儲存庫的本地克隆。
  • resume_from_checkpoint (str, 可選) — 包含模型有效檢查點的資料夾路徑。此引數不直接由 Trainer 使用，而是旨在由您的訓練/評估指令碼使用。有關更多詳細資訊，請參閱示例指令碼。
  • hub_model_id (str, 可選) — 與本地 output_dir 同步的儲存庫名稱。它可以是一個簡單的模型 ID，在這種情況下，模型將被推送到您的名稱空間中。否則，它應該是一個完整的儲存庫名稱，例如 "user_name/model"，這允許您將模型推送到您作為成員的組織，例如 "organization_name/model"。預設為 user_name/output_dir_name，其中 output_dir_name 是 output_dir 的名稱。

    預設為 output_dir 的名稱。

  • hub_strategy (str 或 HubStrategy, 可選, 預設為 "every_save") — 定義推送到 Hub 的範圍和時間。可能的值有：

    • "end": 呼叫 save_model() 方法時，推送模型、其配置、處理類（例如 tokenizer，如果傳遞給 Trainer）和模型卡的草稿。
    • "every_save": 每次儲存模型時，推送模型、其配置、處理類（例如 tokenizer，如果傳遞給 Trainer）和模型卡的草稿。推送是非同步的，以避免阻塞訓練，如果儲存非常頻繁，只有在前一次推送完成後才會嘗試新的推送。訓練結束時，會用最終模型進行最後一次推送。
    • "checkpoint": 與 "every_save" 類似，但最新的檢查點也會推送到名為 last-checkpoint 的子資料夾中，允許您使用 trainer.train(resume_from_checkpoint="last-checkpoint") 輕鬆恢復訓練。
    • "all_checkpoints": 與 "checkpoint" 類似，但所有檢查點都會按其在輸出資料夾中的顯示方式推送（因此您最終的儲存庫中每個資料夾都會有一個檢查點資料夾）
  • hub_token (str, 可選) — 用於將模型推送到 Hub 的令牌。預設為使用 huggingface-cli login 獲取的快取資料夾中的令牌。
  • hub_private_repo (bool, 可選) — 是否將儲存庫設為私有。如果為 None（預設），則除非組織預設設定為私有，否則儲存庫將是公開的。如果儲存庫已存在，則此值將被忽略。
  • hub_always_push (bool, 可選, 預設為 False) — 除非此項為 True，否則 Trainer 將跳過在上次推送未完成時推送檢查點。
  • hub_revision (str, 可選) — 推送到 Hub 時使用的修訂版本。可以是分支名稱、標籤或提交雜湊。
  • gradient_checkpointing (bool, 可選, 預設為 False) — 如果為 True，使用梯度檢查點來節省記憶體，代價是反向傳播速度較慢。
  • gradient_checkpointing_kwargs (dict, 可選, 預設為 None) — 將傳遞給 gradient_checkpointing_enable 方法的關鍵字引數。
  • include_inputs_for_metrics (bool, 可選, 預設為 False) — 此引數已棄用。請改用 include_for_metrics，例如 include_for_metrics = ["inputs"]。
  • include_for_metrics (list[str], 可選, 預設為 []) — 如果需要計算指標，則在 compute_metrics 函式中包含額外資料。可以新增到 include_for_metrics 列表的可能選項有：

    • "inputs": 傳遞給模型的輸入資料，用於計算依賴於輸入的指標。
    • "loss": 評估期間計算的損失值，用於計算依賴於損失的指標。
  • eval_do_concat_batches (bool, 可選, 預設為 True) — 是否在批次之間遞迴連線輸入/損失/標籤/預測。如果為 False，則會將它們儲存為列表，每個批次保持獨立。
  • auto_find_batch_size (bool, 可選, 預設為 False) — 是否透過指數衰減自動查詢適合記憶體的批次大小，避免 CUDA 記憶體不足錯誤。需要安裝 accelerate（pip install accelerate）。
  • full_determinism (bool, 可選, 預設為 False) — 如果為 True，則呼叫 enable_full_determinism() 而不是 set_seed() 以確保分散式訓練中的可重現結果。重要提示：這將對效能產生負面影響，因此僅用於除錯。
  • torchdynamo (str, 可選) — 如果設定，則為 TorchDynamo 的後端編譯器。可能的選項有 "eager"、"aot_eager"、"inductor"、"nvfuser"、"aot_nvfuser"、"aot_cudagraphs"、"ofi"、"fx2trt"、"onnxrt" 和 "ipex"。
  • ray_scope (str, 可選, 預設為 "last") — 使用 Ray 進行超引數搜尋時使用的範圍。預設情況下，將使用 "last"。Ray 將使用所有試驗的最後一個檢查點，進行比較，並選擇最佳的。但是，還有其他選項可用。有關更多選項，請參閱 Ray 文件。
  • ddp_timeout (int, 可選, 預設為 1800) — torch.distributed.init_process_group 呼叫的超時時間，用於在分散式執行中執行慢速操作時避免 GPU 套接字超時。有關更多資訊，請參閱 [PyTorch 文件] (https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group)。
  • use_mps_device (bool, 可選, 預設為 False) — 此引數已棄用。如果可用，將使用 mps 裝置，類似於 cuda 裝置。
  • torch_compile (bool, 可選, 預設為 False) — 是否使用 PyTorch 2.0 torch.compile 編譯模型。

    這將使用 torch.compile API 的最佳預設設定。您可以使用引數 torch_compile_backend 和 torch_compile_mode 自定義預設設定，但我們不保證它們中的任何一個都能正常工作，因為 PyTorch 正在逐步推出支援。

    此標誌和整個編譯 API 是實驗性的，未來版本可能會更改。

  • torch_compile_backend (str, 可選) — torch.compile 中使用的後端。如果設定為任何值，torch_compile 將設定為 True。

    有關可能的值，請參閱 PyTorch 文件，並注意它們可能因 PyTorch 版本而異。

    此標誌是實驗性的，未來版本可能會更改。

  • torch_compile_mode (str, 可選) — torch.compile 中使用的模式。如果設定為任何值，torch_compile 將設定為 True。

    有關可能的值，請參閱 PyTorch 文件，並注意它們可能因 PyTorch 版本而異。

    此標誌是實驗性的，未來版本可能會更改。

  • include_tokens_per_second (bool, 可選) — 是否計算每個裝置每秒的 token 數量以衡量訓練速度。

    這將預先迭代整個訓練資料載入器一次，

    並將減慢整個過程。

  • include_num_input_tokens_seen (bool, 可選) — 是否跟蹤訓練過程中看到的輸入 token 數量。

    在分散式訓練中可能較慢，因為必須呼叫 gather 操作。

  • neftune_noise_alpha (Optional[float]) — 如果不是 None，這將啟用 NEFTune 噪聲嵌入。這可以顯著提高指令微調的模型效能。請檢視原始論文和原始程式碼。支援 transformers PreTrainedModel 以及 peft 中的 PeftModel。原始論文中使用的值範圍是 [5.0, 15.0]。
  • optim_target_modules (Union[str, list[str]], 可選) — 要最佳化的目標模組，即您希望訓練的模組名稱。目前用於 GaLore 演算法（https://huggingface.co/papers/2403.03507）和 APOLLO 演算法（https://huggingface.co/papers/2412.05270）。有關更多詳細資訊，請參閱 GaLore 實現（https://github.com/jiaweizzhao/GaLore）和 APOLLO 實現（https://github.com/zhuhanqing/APOLLO）。您需要確保傳遞有效的 GaLore 或 APOLLO 最佳化器，例如：“apollo_adamw”、“galore_adamw”、“galore_adamw_8bit”、“galore_adafactor”，並確保目標模組僅為 nn.Linear 模組。
  • batch_eval_metrics (Optional[bool], 預設為 False) — 如果設定為 True，評估將在每個批次結束時呼叫 compute_metrics 以累積統計資訊，而不是將所有評估 logits 儲存在記憶體中。當設定為 True 時，您必須傳遞一個 compute_metrics 函式，該函式接受一個布林引數 compute_result，當傳入 True 時，將從您在評估集上累積的批次級摘要統計資訊中觸發最終的全域性摘要統計資訊。
  • eval_on_start (bool, 可選, 預設為 False) — 是否在訓練前執行評估步驟（健全性檢查），以確保驗證步驟正常工作。
  • eval_use_gather_object (bool, 可選, 預設為 False) — 是否在巢狀列表/元組/字典物件中遞迴收集所有裝置的物件。只有當用戶不只是返回張量時才應啟用此功能，PyTorch 積極不鼓勵這樣做。
  • use_liger_kernel (bool, 可選, 預設為 False) — 是否為 LLM 模型訓練啟用 Liger 核心。它能有效提高多 GPU 訓練吞吐量約 20%，並減少記憶體使用約 60%，可與 flash attention、PyTorch FSDP 和 Microsoft DeepSpeed 開箱即用。目前，它支援 llama、mistral、mixtral 和 gemma 模型。
  • liger_kernel_config (Optional[dict], 可選) — 用於 Liger 核心的配置。當 use_liger_kernel=True 時，此字典將作為關鍵字引數傳遞給 _apply_liger_kernel_to_instance 函式，該函式指定要應用哪些核心。可用選項因模型而異，但通常包括：‘rope’、‘swiglu’、‘cross_entropy’、‘fused_linear_cross_entropy’、‘rms_norm’ 等。如果為 None，則使用預設核心配置。
  • average_tokens_across_devices (bool, 可選, 預設為 False) — 是否跨裝置平均 token。如果啟用，將使用 all_reduce 同步 num_tokens_in_batch 以進行精確的損失計算。參考：https://github.com/huggingface/transformers/issues/34242
  • predict_with_generate (bool, 可選, 預設為 False) — 是否使用生成來計算生成指標（ROUGE、BLEU）。
  • generation_max_length (int, 可選) — 當 predict_with_generate=True 時，每個評估迴圈中使用的 max_length。將預設為模型配置的 max_length 值。
  • generation_num_beams (int, 可選) — 當 predict_with_generate=True 時，每個評估迴圈中使用的 num_beams。將預設為模型配置的 num_beams 值。
  • generation_config (str 或 Path 或 GenerationConfig, 可選) — 允許從 from_pretrained 方法載入 GenerationConfig。它可以是：

    • 一個字串，huggingface.co 上模型倉庫中預訓練模型配置的 模型 ID。
    • 一個 目錄 的路徑，其中包含使用 save_pretrained() 方法儲存的配置檔案，例如 ./my_model_directory/。
    • 一個 GenerationConfig 物件。

TrainingArguments 是我們在示例指令碼中使用的引數子集，它們與訓練迴圈本身相關。

使用 HfArgumentParser，我們可以將此類轉換為可在命令列中指定的 argparse 引數。

to_dict

< >

( )

此例項序列化時，將 Enum 替換為其值，將 GenerationConfig 替換為字典（為了支援 JSON 序列化）。它透過移除其值來混淆令牌值。

< > 在 GitHub 上更新

←分詞器 DeepSpeed→
© . This site is unofficial and not affiliated with Hugging Face, Inc.