训练参数

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: dict[str, dict[str, str]] | dict[str, str] | str | None = None, batch_sampler: ~sentence_transformers.training_args.BatchSamplers | str | ~sentence_transformers.sampler.DefaultBatchSampler | ~typing.Callable[[...], ~sentence_transformers.sampler.DefaultBatchSampler] = BatchSamplers.BATCH_SAMPLER, multi_dataset_batch_sampler: ~sentence_transformers.training_args.MultiDatasetBatchSamplers | str | ~sentence_transformers.sampler.MultiDatasetDefaultBatchSampler | ~typing.Callable[[...], ~sentence_transformers.sampler.MultiDatasetDefaultBatchSampler] = MultiDatasetBatchSamplers.PROPORTIONAL, router_mapping: str | None | dict[str, str] | dict[str, dict[str, str]] = <factory>, learning_rate_mapping: str | None | dict[str, float] = <factory>)[源代码]

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 (Dict[str, str] | Dict[str, Dict[str, str]], 可选) –

    数据集列名到路由器路由的映射，例如“query”或“document”。这用于指定每个数据集要使用的路由器子模块。接受两种格式：

    1. Dict[str, str]：列名到路由的映射。

    2. Dict[str, Dict[str, str]]：数据集名称到列名到路由的映射，用于多数据集训练/评估。

  • learning_rate_mapping (Dict[str, float] | None, 可选) – 参数名称正则表达式到学习率的映射。这允许您为模型的不同部分设置不同的学习率，例如，对于 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 表示每个节点上排名为 0 的进程；如果为 False，则 first 表示节点排名为 0 的节点上排名为 0 的进程。在具有共享文件系统的多节点环境中，您很可能希望使用 local=False，这样只有第一个节点的主进程会执行处理。然而，如果文件系统不共享，则每个节点的主进程都需要进行处理，这是默认行为。

  • desc (str, 可选, 默认为 “work”) – 用于调试日志的工作描述

property n_gpu

此进程使用的 GPU 数量。

注意

只有当您有多个可用的 GPU 但未使用分布式训练时，这个值才会大于一。对于分布式训练，它将始终为 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，数据加载器在数据集消耗一次后不会关闭工作进程。这允许保持工作进程的数据集实例存活。可能加快训练速度，但会增加内存使用。默认为 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”：在每个 epoch 结束时进行评估。

    将 strategy 设置为 “no” 以外的值会将 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，在可以执行第一次评估之前等待的 epoch 或步数。

  • 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 的小数部分百分比）。

  • 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 or [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

private_repo (bool，可选，默认为 False) – 是否将仓库设为私有。如果为 None (默认值)，则仓库将为公开，除非组织的默认设置为私有。如果仓库已存在，则此值将被忽略。

： 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”：当调用 [~Trainer.save_model] 方法时，推送模型、其配置、处理类（例如 tokenizer，如果传递给 [Trainer]）和模型卡的草稿。 - “every_save”：每次保存模型时，推送模型、其配置、处理类（例如 tokenizer，如果传递给 [Trainer]）

    和

    模型卡的草稿。推送是异步的，以不阻塞训练，并且在保存非常频繁的情况下，只有在前一次推送完成后才会尝试新的推送。训练结束时，会用最终模型进行最后一次推送。 - “checkpoint”：与 “every_save” 类似，但最新的检查点也会被推送到名为 last-checkpoint 的子文件夹中，允许您使用 trainer.train(resume_from_checkpoint=”last-checkpoint”) 轻松恢复训练。 - “all_checkpoints”：与 “checkpoint” 类似，但所有检查点都会像它们在

    每次模型保存时，都会生成一份模型卡的草稿。推送是异步的，以避免阻塞训练。如果保存非常频繁，只有在前一次推送完成后，才会尝试新的推送。训练结束时，会用最终模型进行最后一次推送。- “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 的小数部分百分比）。

  • max_steps (int, 可选, 默认为 -1) – 如果设置为正数，则表示要执行的总训练步数。会覆盖 num_train_epochs。对于有限的数据集，训练将通过数据集反复进行（如果所有数据都已用尽），直到达到 max_steps。

  • gradient_accumulation_steps (int, 可选, 默认为 1) –

    在执行反向/更新传播之前，累积梯度的更新步数。

    <提示 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()[源代码]

序列化此实例，同时用它们的值替换 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

并行使用的进程数。