训练参数

SparseEncoderTrainingArguments

class sentence_transformers.sparse_encoder.training_args.SparseEncoderTrainingArguments(output_dir: str | None = None, 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.SaveStrategy | 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 | 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: 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: list[~transformers.trainer_utils.FSDPOption] | str | None = '', fsdp_min_num_params: int = 0, fsdp_config: dict | str | None = None, tp_size: int | None = 0, 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 | 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 | None = None, hub_always_push: bool = False, gradient_checkpointing: bool = False, gradient_checkpointing_kwargs: dict | str | None = None, include_inputs_for_metrics: bool = False, include_for_metrics: list[str] = <factory>, eval_do_concat_batches: bool = True, fp16_backend: str = 'auto', 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, 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 | list[str] = None, batch_eval_metrics: bool = False, eval_on_start: bool = False, use_liger_kernel: bool | None = False, eval_use_gather_object: bool | None = False, average_tokens_across_devices: bool | None = False, prompts: Optional[str] = None, batch_sampler: Union[BatchSamplers, str] = BatchSamplers.BATCH_SAMPLER, multi_dataset_batch_sampler: Union[MultiDatasetBatchSamplers, str] = MultiDatasetBatchSamplers.PROPORTIONAL, router_mapping: Optional[dict[str, str]] = <factory>, learning_rate_mapping: Optional[dict[str, float]] = <factory>)[source]

SparseEncoderTrainingArguments 扩展了 SentenceTransformerTrainingArguments，后者又扩展了 TrainingArguments，并增加了 Sentence Transformers 特有的参数。有关所有可用参数的完整列表，请参阅 TrainingArguments。

参数:

output_dir (str) – 模型检查点将写入的输出目录。
prompts (Union[Dict[str, Dict[str, str]], Dict[str, str], str]，可选) –
用于训练、评估和测试数据集中每列的提示。接受四种格式：
1. str: 用于数据集中所有列的单个提示，无论训练/评估/测试数据集是 datasets.Dataset 还是 datasets.DatasetDict。
2. Dict[str, str]: 一个将列名映射到提示的字典，无论训练/评估/测试数据集是 datasets.Dataset 还是 datasets.DatasetDict。
3. Dict[str, str]: 一个将数据集名称映射到提示的字典。此格式仅在您的训练/评估/测试数据集是 datasets.DatasetDict 或 datasets.Dataset 的字典时使用。
4. Dict[str, Dict[str, str]]: 一个将数据集名称映射到（将列名映射到提示的）字典的字典。此格式仅在您的训练/评估/测试数据集是 datasets.DatasetDict 或 datasets.Dataset 的字典时使用。
batch_sampler (Union[BatchSamplers, str]，可选) – 要使用的批次采样器。有关有效选项，请参阅 BatchSamplers。默认为 BatchSamplers.BATCH_SAMPLER。
multi_dataset_batch_sampler (Union[MultiDatasetBatchSamplers, str]，可选) – 要使用的多数据集批次采样器。有关有效选项，请参阅 MultiDatasetBatchSamplers。默认为 MultiDatasetBatchSamplers.PROPORTIONAL。
router_mapping (Optional[Dict[str, str]]，可选) –
将数据集列名映射到 Router 路由（例如“query”或“document”）。这用于指定每个数据集要使用的 Router 子模块。接受两种格式：
1. Dict[str, str]: 将列名映射到路由。
2. Dict[str, Dict[str, str]]: 用于多数据集训练/评估的，将数据集名称映射到（将列名映射到路由的）字典。
learning_rate_mapping (Optional[Dict[str, float]]，可选) – 将参数名称正则表达式映射到学习率。这允许您为模型的不同部分设置不同的学习率，例如，对于 SparseStaticEmbedding 模块，可以使用 {‘SparseStaticEmbedding.*’: 1e-3}。当您希望使用不同的学习率微调模型的特定部分时，此功能非常有用。

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): 获取用于线性预热的步数。

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

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

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

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

参数:

local (bool，可选，默认为 True) – 如果为 True，则表示每个节点的 rank 0 进程；如果为 False，则表示节点 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，每个都有自己的进程（使用 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，可选) – 每个工作进程预加载的批次数量。2 表示所有工作进程总共预取 2 * num_workers 个批次。
auto_find_batch_size (bool，可选，默认为 False) – 是否通过指数衰减自动查找适合内存的批次大小，从而避免 CUDA 内存不足错误。需要安装 accelerate (pip install accelerate)
ignore_data_skip (bool，可选，默认为 False) – 恢复训练时，是否跳过周期和批次，使数据加载与之前的训练处于同一阶段。如果设置为 True，训练将更快开始（因为跳过步骤可能需要很长时间），但不会产生与中断训练相同的结果。
sampler_seed (int，可选) – 用于数据采样器的随机种子。如果未设置，数据采样的随机生成器将使用与 self.seed 相同的种子。这可用于确保数据采样的可复现性，与模型种子无关。

示例

```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”：在每个周期结束时进行评估。
设置不同于 “no” 的 strategy 会将 self.do_eval 设置为 True。
steps (int，可选，默认为 500) – 如果 strategy=”steps”，两次评估之间的更新步数。
batch_size (int，可选，默认为 8) – 用于评估的每个设备（GPU/TPU 核心/CPU…）的批次大小。
accumulation_steps (int，可选) – 在将结果移动到 CPU 之前，累积输出张量的预测步数。如果未设置，则整个预测在移动到 CPU 之前会在 GPU/TPU 上累积（更快但需要更多内存）。
delay (float，可选) – 根据 eval_strategy，在第一次评估执行前等待的周期数或步数。
loss_only (bool，可选，默认为 False) – 忽略除损失之外的所有输出。
jit_mode (bool，可选) – 是否使用 PyTorch jit trace 进行推理。

示例

```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”：在每个周期结束时进行日志记录。
- ”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 的步长的损失，并使用当前日志窗口的平均损失代替。

<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) – 要执行的训练周期总数（如果不是整数，则在停止训练前执行最后一个周期的小数部分百分比）。
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_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 | None = None, 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] 方法被调用时，推送模型、其配置、处理类（例如分词器，如果传递给 [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 将在上次推送未完成时跳过推送检查点。

示例

```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”：在每个周期结束时进行保存。
- ”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 trace 进行推理。

示例

```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) – 应用于优化器中除所有偏置和 LayerNorm 权重之外的所有层的权重衰减（如果非零）。
num_train_epochs (float，可选，默认为 3.0) – 要执行的训练周期总数（如果不是整数，则在停止训练前执行最后一个周期的小数部分百分比）。
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()[source]: 序列化此实例，同时将 Enum 替换为其值（为了支持 JSON 序列化）。它通过移除令牌值来混淆令牌值。

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: 并行使用的进程数量。