训练参数

CrossEncoderTrainingArguments

class sentence_transformers.cross_encoder.training_args.CrossEncoderTrainingArguments(output_dir: str, overwrite_output_dir: bool = False, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, eval_strategy: ~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: int | None = None, per_gpu_eval_batch_size: int | None = None, gradient_accumulation_steps: int = 1, eval_accumulation_steps: int | None = None, eval_delay: float | None = 0, torch_empty_cache_steps: int | None = 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: ~transformers.trainer_utils.SchedulerType | str = 'linear', lr_scheduler_kwargs: dict | str | None = <factory>, warmup_ratio: float = 0.0, warmup_steps: int = 0, log_level: str | None = 'passive', log_level_replica: str | None = 'warning', log_on_each_node: bool = True, logging_dir: str | None = None, logging_strategy: ~transformers.trainer_utils.IntervalStrategy | str = 'steps', logging_first_step: bool = False, logging_steps: float = 500, logging_nan_inf_filter: bool = True, save_strategy: ~transformers.trainer_utils.IntervalStrategy | str = 'steps', save_steps: float = 500, save_total_limit: int | None = None, save_safetensors: bool | None = 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: int | None = 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: bool | None = None, local_rank: int = -1, ddp_backend: str | None = None, tpu_num_cores: int | None = None, tpu_metrics_debug: bool = False, debug: str | ~typing.List[~transformers.debug_utils.DebugOption] = '', dataloader_drop_last: bool = False, eval_steps: float | None = None, dataloader_num_workers: int = 0, dataloader_prefetch_factor: int | None = None, past_index: int = -1, run_name: str | None = None, disable_tqdm: bool | None = None, remove_unused_columns: bool | None = True, label_names: ~typing.List[str] | None = None, load_best_model_at_end: bool | None = False, metric_for_best_model: str | None = None, greater_is_better: bool | None = None, ignore_data_skip: bool = False, fsdp: ~typing.List[~transformers.trainer_utils.FSDPOption] | str | None = '', fsdp_min_num_params: int = 0, fsdp_config: dict | str | None = None, fsdp_transformer_layer_cls_to_wrap: str | None = None, accelerator_config: dict | str | None = None, deepspeed: dict | str | None = None, label_smoothing_factor: float = 0.0, optim: ~transformers.training_args.OptimizerNames | str = 'adamw_torch', optim_args: str | None = None, adafactor: bool = False, group_by_length: bool = False, length_column_name: str | None = 'length', report_to: None | str | ~typing.List[str] = None, ddp_find_unused_parameters: bool | None = None, ddp_bucket_cap_mb: int | None = None, ddp_broadcast_buffers: bool | None = 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: str | None = None, hub_model_id: str | None = None, hub_strategy: ~transformers.trainer_utils.HubStrategy | str = 'every_save', hub_token: str | None = None, hub_private_repo: bool = False, hub_always_push: bool = False, gradient_checkpointing: bool = False, gradient_checkpointing_kwargs: dict | str | None = None, include_inputs_for_metrics: bool = False, eval_do_concat_batches: bool = True, fp16_backend: str = 'auto', evaluation_strategy: ~transformers.trainer_utils.IntervalStrategy | str | None = None, push_to_hub_model_id: str | None = None, push_to_hub_organization: str | None = None, push_to_hub_token: str | None = None, mp_parameters: str = '', auto_find_batch_size: bool = False, full_determinism: bool = False, torchdynamo: str | None = None, ray_scope: str | None = 'last', ddp_timeout: int | None = 1800, torch_compile: bool = False, torch_compile_backend: str | None = None, torch_compile_mode: str | None = None, dispatch_batches: bool | None = None, split_batches: bool | None = None, include_tokens_per_second: bool | None = False, include_num_input_tokens_seen: bool | None = False, neftune_noise_alpha: float | None = None, optim_target_modules: None | str | ~typing.List[str] = None, batch_eval_metrics: bool = False, eval_on_start: bool = False, eval_use_gather_object: bool | None = False, prompts: str | None = None, batch_sampler: ~sentence_transformers.training_args.BatchSamplers | str = BatchSamplers.BATCH_SAMPLER, multi_dataset_batch_sampler: ~sentence_transformers.training_args.MultiDatasetBatchSamplers | str = MultiDatasetBatchSamplers.PROPORTIONAL)[source]

CrossEncoderTrainingArguments 扩展了 TrainingArguments，并添加了 Sentence Transformers 特有的参数。有关可用参数的完整列表，请参阅 TrainingArguments。

参数:

output_dir (str) – 模型检查点将被写入的输出目录。
prompts (Union[Dict[str, Dict[str, str]], Dict[str, str], str], 可选) –
用于训练、评估和测试数据集的每一列的 prompts。接受四种格式
1. str：用于数据集所有列的单个 prompt，无论训练/评估/测试数据集是 datasets.Dataset 还是 datasets.DatasetDict。
2. Dict[str, str]：将列名映射到 prompts 的字典，无论训练/评估/测试数据集是 datasets.Dataset 还是 datasets.DatasetDict。
3. Dict[str, str]: 字典，将数据集名称映射到提示（prompts）。仅当您的训练/评估/测试数据集是 datasets.DatasetDict 或 datasets.Dataset 字典时，才应使用此项。
4. Dict[str, Dict[str, str]]: 字典，将数据集名称映射到字典，而这些字典又将列名称映射到提示（prompts）。仅当您的训练/评估/测试数据集是 datasets.DatasetDict 或 datasets.Dataset 字典时，才应使用此项。
batch_sampler (Union[BatchSamplers, str], 可选) – 要使用的批采样器（batch sampler）。有关有效选项，请参阅 BatchSamplers。默认为 BatchSamplers.BATCH_SAMPLER。
multi_dataset_batch_sampler (Union[MultiDatasetBatchSamplers, str], 可选) – 要使用的多数据集批采样器（multi-dataset batch sampler）。有关有效选项，请参阅 MultiDatasetBatchSamplers。默认为 MultiDatasetBatchSamplers.PROPORTIONAL。

property ddp_timeout_delta: timedelta: torch.distributed.init_process_group 的实际超时时间，因为它需要一个 timedelta 变量。

property device: device: 此进程使用的设备。

property eval_batch_size: int: 评估的实际批大小（可能与分布式训练中的 per_gpu_eval_batch_size 不同）。

get_process_log_level()

返回要使用的日志级别，具体取决于此进程是节点 0 的主进程、非节点 0 的主进程还是非主进程。

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

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

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

get_warmup_steps(num_training_steps: int): 获取用于线性预热（linear warmup）的步数。

property local_process_index: 使用的本地进程的索引。

main_process_first(local=True, desc='work')

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

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

参数:

local (bool, 可选, 默认为 True) – 如果 True，则 first 表示每个节点的 rank 0 进程；如果 False，则 first 表示节点 rank 0 的 rank 0 进程。在具有共享文件系统的多节点环境中，您很可能希望使用 local=False，以便只有第一个节点的主进程执行处理。但是，如果文件系统未共享，则每个节点的主进程都需要执行处理，这是默认行为。
desc (str, 可选, 默认为 “work”) – 用于调试日志的工作描述

property n_gpu: 此进程使用的 GPU 数量。

注意

仅当您有多个可用的 GPU 但未使用分布式训练时，此值才会大于 1。对于分布式训练，它始终为 1。

property parallel_mode

如果多个 GPU/TPU 核心可用，则当前用于并行化的模式。以下之一：

ParallelMode.NOT_PARALLEL: 无并行化（CPU 或单个 GPU）。
ParallelMode.NOT_DISTRIBUTED: 单个进程中的多个 GPU（使用 torch.nn.DataParallel）。
ParallelMode.DISTRIBUTED: 多个 GPU，每个 GPU 都有自己的进程（使用 torch.nn.DistributedDataParallel）。
ParallelMode.TPU: 多个 TPU 核心。

property place_model_on_device: 可以被子类化和重写，用于某些特定的集成。

property process_index: 当前使用的进程的索引。

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: int | None = None, auto_find_batch_size: bool = False, ignore_data_skip: bool = False, sampler_seed: int | None = None)

一种方法，用于将所有链接到数据加载器创建的参数重新分组。

参数:

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

示例

```py >>> 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: str | IntervalStrategy = 'no', steps: int = 500, batch_size: int = 8, accumulation_steps: int | None = None, delay: float | None = None, loss_only: bool = False, jit_mode: bool = False)

一种方法，用于将所有链接到评估的参数重新分组。

参数:

strategy (str 或 [~trainer_utils.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 跟踪。

示例

```py >>> from transformers import TrainingArguments

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

set_logging(strategy: str | IntervalStrategy = 'steps', steps: int = 500, report_to: 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 或 [~trainer_utils.IntervalStrategy], 可选, 默认为 “steps”) –
训练期间要采用的日志记录策略。可能的值为：
- ”no”: 训练期间不进行日志记录。
- ”epoch”: 在每个 epoch 结束时进行日志记录。
- ”steps”: 每 logging_steps 步进行日志记录。
steps (int, 可选, 默认为 500) – 如果 strategy=”steps”，则两次日志记录之间的更新步数。
level (str, 可选, 默认为 “passive”) – 要在主进程上使用的记录器日志级别。可能的选择是日志级别字符串：“debug”、“info”、“warning”、“error” 和 “critical”，以及一个 “passive” 级别，该级别不设置任何内容，而是让应用程序设置级别。
report_to (str 或 List[str], 可选, 默认为 “all”) – 用于报告结果和日志的集成列表。支持的平台为 “azure_ml”、“clearml”、“codecarbon”、“comet_ml”、“dagshub”、“dvclive”、“flyte”、“mlflow”、“neptune”、“tensorboard” 和 “wandb”。使用 “all” 报告给所有已安装的集成，使用 “none” 不使用任何集成。
first_step (bool, 可选, 默认为 False) – 是否记录和评估第一个 global_step。
nan_inf_filter (bool, 可选, 默认为 True) –
是否过滤用于日志记录的 nan 和 inf 损失。如果设置为 True，则过滤每个为 nan 或 inf 的步骤的损失，并改为取当前日志记录窗口的平均损失。

<Tip>

nan_inf_filter 仅影响损失值的日志记录，它不会更改梯度计算或应用于模型的行为。

</Tip>
on_each_node (bool, 可选, 默认为 True) – 在多节点分布式训练中，是使用 log_level 为每个节点记录一次日志，还是仅在主节点上记录日志。
replica_level (str, 可选, 默认为 “passive”) – 要在副本上使用的记录器日志级别。与 log_level 相同的选择

示例

```py >>> from transformers import TrainingArguments

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

set_lr_scheduler(name: str | 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 的任何影响。

示例

```py >>> 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: str | 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: str | None = None)

一种方法，用于将所有链接到优化器及其超参数的参数重新分组。

参数:

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

示例

```py >>> 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: str | HubStrategy = 'every_save', token: str | None = None, private_repo: bool = False, always_push: bool = False)

一种方法，用于将所有链接到与 Hub 同步检查点的参数重新分组。

<Tip>

调用此方法会将 self.push_to_hub 设置为 True，这意味着 output_dir 将开始一个与仓库（由 model_id 确定）同步的 git 目录，并且每次触发保存时都会推送内容（取决于您的 self.save_strategy）。调用 [~Trainer.save_model] 也会触发推送。

</Tip>

参数:

model_id (str) – 要与本地 output_dir 同步的仓库的名称。它可以是一个简单的模型 ID，在这种情况下，模型将推送到您的命名空间中。否则，它应该是完整的仓库名称，例如 “user_name/model”，这允许您推送到您是成员的组织，使用 “organization_name/model”。
strategy (str 或 [~trainer_utils.HubStrategy], 可选, 默认为 “every_save”) –
定义推送到 Hub 的内容范围和时间。可能的值为：
- ”end”: 当调用 [~Trainer.save_model] 方法时，推送模型、其配置、tokenizer（如果已传递给 [Trainer]）和模型卡的草稿。
- “every_save”: 每次模型保存时，推送模型、其配置、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) – 如果为 True，则 Hub 仓库将设置为私有。
always_push (bool, 可选, 默认为 False) – 除非此项为 True，否则当上一次推送未完成时，Trainer 将跳过推送检查点。

示例

```py >>> 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: str | IntervalStrategy = 'steps', steps: int = 500, total_limit: int | None = None, on_each_node: bool = False)

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

参数:

strategy (str 或 [~trainer_utils.IntervalStrategy], 可选, 默认为 “steps”) –
训练期间采用的检查点保存策略。可能的值包括
- ”no”: 训练期间不进行保存。
- ”epoch”: 在每个 epoch 结束时进行保存。
- ”steps”: 每 save_steps 步进行保存。
steps (int, 可选, 默认为 500) – 如果 strategy=”steps”，则为两次检查点保存之间的更新步数。
total_limit (int, 可选) – 如果传递一个值，将限制检查点的总数量。删除 output_dir 中较旧的检查点。
on_each_node (bool, 可选, 默认为 False) –
当进行多节点分布式训练时，是否在每个节点上保存模型和检查点，还是仅在主节点上保存。

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

示例

```py >>> 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)

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

<Tip>

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

</Tip>

参数:

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

示例

```py >>> 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)

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

<Tip>

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

</Tip>

参数:

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

<Tip warning={true}>

当使用梯度累积时，一步被计为带反向传播的一步。因此，日志记录、评估、保存将每 gradient_accumulation_steps * xxx_step 个训练示例进行一次。

</Tip>
seed (int, 可选, 默认为 42) – 将在训练开始时设置的随机种子。为了确保跨运行的可重复性，如果模型具有一些随机初始化的参数，请使用 [~Trainer.model_init] 函数来实例化模型。
gradient_checkpointing (bool, 可选, 默认为 False) – 如果为 True，则使用梯度检查点以节省内存，但会牺牲较慢的反向传播速度。

示例

```py >>> from transformers import TrainingArguments

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

property should_log: 当前进程是否应生成日志。

property should_save: 当前进程是否应写入磁盘，例如，保存模型和检查点。

to_dict(): 序列化此实例，同时将 Enum 替换为其值（以支持 JSON 序列化）。它通过删除 token 值来混淆它们的值。

to_json_string(): 将此实例序列化为 JSON 字符串。

to_sanitized_dict() → Dict[str, Any]: 用于 TensorBoard 的 hparams 的经过清理的序列化

property train_batch_size: int: 实际的训练批次大小（可能与分布式训练中的 per_gpu_train_batch_size 不同）。

property world_size: 并行使用的进程数。