训练参数

SentenceTransformerTrainingArguments

class sentence_transformers.training_args.SentenceTransformerTrainingArguments(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: str | list[str] | None = 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: str | list[str] | None = 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: 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, router_mapping: dict[str, str] | None = <factory>, learning_rate_mapping: dict[str, float] | None = <factory>)[source]

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, DefaultBatchSampler, Callable[[…], DefaultBatchSampler]], 可选) – 要使用的批量采样器。有关有效选项，请参阅 BatchSamplers。默认为 BatchSamplers.BATCH_SAMPLER。
multi_dataset_batch_sampler (Union[MultiDatasetBatchSamplers, str, MultiDatasetDefaultBatchSampler, Callable[[…], MultiDatasetDefaultBatchSampler]], 可选) – 要使用的多数据集批量采样器。有关有效选项，请参阅 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，则“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，每个都有自己的进程（使用 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) – 恢复训练时，是否跳过 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 结束时进行评估。
将 strategy 设置为 “no” 以外的值将把 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 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”：每个 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 具有相同的选择。

示例

```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_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 同步检查点相关的参数进行分组的方法。

<提示>

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

</提示>

参数：

model_id (str) – 要与本地 output_dir 同步的仓库名称。它可以是一个简单的模型 ID，在这种情况下，模型将被推送到您的命名空间。否则，它应该是一个完整的仓库名称，例如 “user_name/model”，这允许您将模型推送到您所属的组织，使用 “organization_name/model”。
strategy (str 或 [~trainer_utils.HubStrategy]，可选，默认为 “every_save”) –
定义推送到 Hub 的内容范围和时间。可能的值包括
- ”end”：推送模型、其配置、处理类（例如 tokenizer，如果已传递给 [Trainer]）以及一个
模型卡草稿，当 [~Trainer.save_model] 方法被调用时。- “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) – 是否将仓库设为私有。如果为 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”：在每个 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)

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

<提示>

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

</提示>

参数：

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

一种将所有与训练相关的基本参数进行分组的方法。

<提示>

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

</提示>

参数：

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

<Tip warning={true}>

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

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