Transformers 文档

优化

Transformers

加入 Hugging Face 社区

并获得增强的文档体验

协作开发模型、数据集和空间

通过加速推理获得更快的示例

在文档主题之间切换

开始使用

优化

.optimization 模块提供

一个具有固定权重衰减的优化器，可用于微调模型，以及
以调度对象的形式提供的多个调度，这些调度对象继承自 _LRSchedule
一个梯度累积类，用于累积多个批次的梯度

AdamW (PyTorch)

类 transformers.AdamW

< 源代码 >

( params: Iterable lr: float = 0.001 betas: Tuple = (0.9, 0.999) eps: float = 1e-06 weight_decay: float = 0.0 correct_bias: bool = True no_deprecation_warning: bool = False )

参数

params (Iterable[nn.parameter.Parameter]) — 要优化的参数的迭代器或定义参数组的字典。
lr (float, *可选*, 默认值: 0.001) — 要使用的学习率。
betas (Tuple[float,float], *可选*, 默认值: (0.9, 0.999)) — Adam 的 betas 参数 (b1, b2)。
eps (float, *可选*, 默认值: 1e-06) — Adam 的 epsilon，用于数值稳定性。
**weight_decay** (``float``, *可选*, 默认值为 0.0) — 要应用的解耦权重衰减。
**correct_bias** (``bool``, *可选*, 默认值为 ``True``) — 是否在 Adam 中校正偏差（例如，在 Bert TF 存储库中，他们使用 ``False``）。
**no_deprecation_warning** (``bool``, *可选*, 默认值为 ``False``) — 用于禁用弃用警告的标志（设置为 ``True`` 以禁用警告）。

实现 Adam 算法，并根据解耦权重衰减正则化中的介绍修复权重衰减。

步骤

< source >

( 闭包: Callable = None )

参数

**闭包** (``Callable``, *可选*) — 重新评估模型并返回损失的闭包。

执行单个优化步骤。

AdaFactor (PyTorch)

类 transformers.Adafactor

< source >

( params lr = None eps = (1e-30, 0.001) clip_threshold = 1.0 decay_rate = -0.8 beta1 = None weight_decay = 0.0 scale_parameter = True relative_step = True warmup_init = False )

参数

params (Iterable[nn.parameter.Parameter]) — 要优化的参数的迭代器或定义参数组的字典。
lr (float, 可选) — 外部学习率。
eps (Tuple[float, float], 可选, 默认值 (1e-30, 0.001)) — 分别用于平方梯度和参数尺度的正则化常数
clip_threshold (float, 可选, 默认值 1.0) — 最终梯度更新的均方根阈值
decay_rate (float, 可选, 默认值 -0.8) — 用于计算平方运行平均值的系数
beta1 (float, 可选) — 用于计算梯度运行平均值的系数
weight_decay (float，可选，默认为 0.0) - 权重衰减 (L2 惩罚)
scale_parameter (bool，可选，默认为 True) - 如果为 True，则学习率按均方根缩放
relative_step (bool，可选，默认为 True) - 如果为 True，则计算与时间相关的学习率，而不是外部学习率
warmup_init (bool，可选，默认为 False) - 与时间相关的学习率计算取决于是否正在使用预热初始化

AdaFactor pytorch 实现可以作为 Adam 原始 fairseq 代码的替代品： https://github.com/pytorch/fairseq/blob/master/fairseq/optim/adafactor.py

论文：Adafactor: Adaptive Learning Rates with Sublinear Memory Cost https://arxiv.org/abs/1804.04235 请注意，此优化器会根据 scale_parameter、relative_step 和 warmup_init 选项内部调整学习率。要使用手动（外部）学习率调度，您应该设置 scale_parameter=False 和 relative_step=False。

此实现处理低精度（FP16，bfloat）值，但我们尚未彻底测试。

推荐的 T5 微调设置 (https://discuss.huggingface.co/t/t5-finetuning-tips/684/3)

不建议在没有 LR 预热或 clip_threshold 的情况下进行训练。
- 使用预定的 LR 预热到固定 LR
- 使用 clip_threshold=1.0 (https://arxiv.org/abs/1804.04235)
禁用相对更新
使用 scale_parameter=False
不应将其他优化器操作（如梯度裁剪）与 Adafactor 一起使用

示例

Adafactor(model.parameters(), scale_parameter=False, relative_step=False, warmup_init=False, lr=1e-3)

其他人报告说以下组合效果很好

Adafactor(model.parameters(), scale_parameter=True, relative_step=True, warmup_init=True, lr=None)

当在 Trainer 中使用 lr=None 时，您很可能需要使用 AdafactorSchedule

调度器如下

from transformers.optimization import Adafactor, AdafactorSchedule

optimizer = Adafactor(model.parameters(), scale_parameter=True, relative_step=True, warmup_init=True, lr=None)
lr_scheduler = AdafactorSchedule(optimizer)
trainer = Trainer(..., optimizers=(optimizer, lr_scheduler))

用法

# replace AdamW with Adafactor
optimizer = Adafactor(
    model.parameters(),
    lr=1e-3,
    eps=(1e-30, 1e-3),
    clip_threshold=1.0,
    decay_rate=-0.8,
    beta1=None,
    weight_decay=0.0,
    relative_step=False,
    scale_parameter=False,
    warmup_init=False,
)

步骤

< 来源 >

( closure = None )

参数

closure (可调用对象，可选) - 一个重新评估模型并返回损失的可调用对象。

执行单个优化步骤

AdamWeightDecay (TensorFlow)

类 transformers.AdamWeightDecay

< source >

( learning_rate: Union = 0.001 beta_1: float = 0.9 beta_2: float = 0.999 epsilon: float = 1e-07 amsgrad: bool = False weight_decay_rate: float = 0.0 include_in_weight_decay: Optional = None exclude_from_weight_decay: Optional = None name: str = 'AdamWeightDecay' **kwargs )

参数

learning_rate (Union[float, LearningRateSchedule]，*可选*，默认为 0.001) — 要使用的学习率或计划。
beta_1 (float，*可选*，默认为 0.9) — Adam 中的 beta1 参数，它是第一个动量估计的指数衰减率。
beta_2 (float，*可选*，默认为 0.999) — Adam 中的 beta2 参数，它是第二个动量估计的指数衰减率。
epsilon (float，*可选*，默认为 1e-07) — Adam 中的 epsilon 参数，它是数值稳定性的小常数。
amsgrad (bool，*可选*，默认为 False) — 是否应用此算法的 AMSGrad 变体，请参阅 Adam 和超越的收敛性。
weight_decay_rate (float，可选，默认为 0.0) — 要应用的权重衰减。
include_in_weight_decay (List[str]，可选) — 要应用权重衰减的参数名称（或正则表达式模式）列表。如果未传递任何内容，则默认情况下会将权重衰减应用于所有参数（除非它们在 exclude_from_weight_decay 中）。
exclude_from_weight_decay (List[str]，可选) — 要排除应用权重衰减的参数名称（或正则表达式模式）列表。如果传递了 include_in_weight_decay，则其中的名称将取代此列表。
name (str，可选，默认为 "AdamWeightDecay") — 在应用梯度时创建的操作的可选名称。
kwargs (Dict[str, Any]，可选) — 关键字参数。允许使用 {clipnorm、clipvalue、lr、decay}。 clipnorm 表示按范数裁剪梯度；clipvalue 表示按值裁剪梯度，包含 decay 是为了向后兼容，以便允许学习率随时间反向衰减。包含 lr 是为了向后兼容，建议改用 learning_rate。

Adam 允许对梯度进行 L2 权重衰减和全局范数裁剪。仅仅将权重的平方添加到损失函数中*不是*使用 L2 正则化/权重衰减与 Adam 的正确方法，因为这将以奇怪的方式与 m 和 v 参数交互，如解耦权重衰减正则化中所示。

相反，我们希望以不与 m/v 参数交互的方式来衰减权重。这相当于使用普通（非动量）SGD 将权重的平方添加到损失中。

from_config

< source >

( config )

使用 WarmUp 自定义对象从其配置创建优化器。

transformers.create_optimizer

< source >

( init_lr: float num_train_steps: int num_warmup_steps: int min_lr_ratio: float = 0.0 adam_beta1: float = 0.9 adam_beta2: float = 0.999 adam_epsilon: float = 1e-08 adam_clipnorm: Optional = None adam_global_clipnorm: Optional = None weight_decay_rate: float = 0.0 power: float = 1.0 include_in_weight_decay: Optional = None )

参数

init_lr (float) — 预热阶段结束时期望的学习率。
num_train_steps (int) — 训练步骤总数。
num_warmup_steps (int) — 预热步骤数。
min_lr_ratio (float, 可选, 默认值: 0) — 线性衰减结束时的最终学习率将为 init_lr * min_lr_ratio。
adam_beta1 (float, 可选, 默认值: 0.9) — Adam 中使用的 beta1。
adam_beta2 (float，可选，默认为 0.999) — Adam 中使用的 beta2。
adam_epsilon (float，可选，默认为 1e-8) — Adam 中使用的 epsilon。
adam_clipnorm (float，可选，默认为 None) — 如果不是 None，则将每个权重张量的梯度范数裁剪到此值。
adam_global_clipnorm (float，可选，默认为 None) — 如果不是 None，则将梯度范数裁剪到此值。使用此参数时，将在所有权重张量上计算范数，就好像它们被连接成一个向量一样。
weight_decay_rate (float，可选，默认为 0) — 要使用的权重衰减。
power (float，可选，默认为 1.0) — 用于 PolynomialDecay 的幂。
include_in_weight_decay (List[str]，可选) — 要对其应用权重衰减的参数名称（或正则表达式模式）列表。如果没有传递，则权重衰减将应用于除偏差和层归一化参数之外的所有参数。

创建一个使用学习率调度程序的优化器，该调度程序使用预热阶段，然后是线性衰减。

时间表

学习率调度器 (PyTorch)

类 transformers.SchedulerType

< 源代码 >

( value names = None module = None qualname = None type = None start = 1 )

TrainingArguments 中参数 lr_scheduler_type 的调度器名称。默认情况下，它使用 “linear”。在内部，这将从 Trainer 中检索 get_linear_schedule_with_warmup 调度器。调度器类型

“linear” = get_linear_schedule_with_warmup
“cosine” = get_cosine_schedule_with_warmup
“cosine_with_restarts” = get_cosine_with_hard_restarts_schedule_with_warmup
“polynomial” = get_polynomial_decay_schedule_with_warmup
“constant” = get_constant_schedule
“constant_with_warmup” = get_constant_schedule_with_warmup
“inverse_sqrt” = get_inverse_sqrt_schedule
“reduce_lr_on_plateau” = get_reduce_on_plateau_schedule
“cosine_with_min_lr” = get_cosine_with_min_lr_schedule_with_warmup
“warmup_stable_decay” = get_wsd_schedule

transformers.get_scheduler

< 源代码 >

( name: Union optimizer: Optimizer num_warmup_steps: Optional = None num_training_steps: Optional = None scheduler_specific_kwargs: Optional = None )

参数

name (str 或 SchedulerType) — 要使用的调度器名称。
optimizer (torch.optim.Optimizer) — 将在训练期间使用的优化器。
num_warmup_steps (int，可选) — 预热的步数。并非所有调度器都需要此参数（因此该参数是可选的），如果未设置且调度器类型需要它，则该函数将引发错误。
num_training_steps (int，可选) — 训练的步数。并非所有调度器都需要此参数（因此该参数是可选的），如果未设置且调度器类型需要它，则该函数将引发错误。
scheduler_specific_kwargs (dict，可选) — 调度器的额外参数，例如带重启的余弦调度器。调度器类型和调度器参数不匹配将导致调度器函数引发 TypeError。

用于从其名称获取任何调度器的统一 API。

transformers.get_constant_schedule

< source >

( optimizer: Optimizer last_epoch: int = -1 )

参数

optimizer (~torch.optim.Optimizer) — 要为其安排学习率的优化器。
last_epoch (int，可选，默认为 -1) — 恢复训练时最后一个 epoch 的索引。

使用优化器中设置的学习率创建一个具有恒定学习率的调度表。

transformers.get_constant_schedule_with_warmup

< source >

( optimizer: Optimizer num_warmup_steps: int last_epoch: int = -1 )

参数

optimizer (~torch.optim.Optimizer) — 要为其安排学习率的优化器。
num_warmup_steps (int) — 预热阶段的步数。
last_epoch (int, 可选, 默认值 -1) — 恢复训练时最后一个 epoch 的索引。

创建一个学习率恒定的计划，在预热阶段之前，学习率在 0 和优化器中设置的初始 lr 之间线性增加。

transformers.get_cosine_schedule_with_warmup

< source >

( optimizer: Optimizer num_warmup_steps: int num_training_steps: int num_cycles: float = 0.5 last_epoch: int = -1 )

参数

optimizer (~torch.optim.Optimizer) — 要为其安排学习率的优化器。
num_warmup_steps (int) — 预热阶段的步数。
num_training_steps (int) — 训练步数的总数。
num_cycles (float， *可选*，默认为 0.5) — 余弦调度中的波浪数（默认值是从最大值按半余弦函数降至 0）。
last_epoch (int， *可选*，默认为 -1) — 恢复训练时最后一个周期的索引。

创建一个学习率调度器，使其在预热阶段后，按照余弦函数的值从优化器中设置的初始学习率降低到 0，在预热阶段，学习率在 0 和优化器中设置的初始学习率之间线性增加。

transformers.get_cosine_with_hard_restarts_schedule_with_warmup

< source >

( optimizer: Optimizer num_warmup_steps: int num_training_steps: int num_cycles: int = 1 last_epoch: int = -1 )

参数

optimizer (~torch.optim.Optimizer) — 要为其调度学习率的优化器。
num_warmup_steps (int) — 预热阶段的步数。
num_training_steps (int) — 训练步数总数。
num_cycles (int， *可选*，默认为 1) — 要使用的硬重启次数。
last_epoch (int, 可选, 默认为 -1) — 恢复训练时最后一个 epoch 的索引。

创建一个学习率调度器，使其在优化器中设置的初始学习率到 0 之间，按照余弦函数的值递减，并在经历几个热启动重启后，在热身期间，学习率在 0 和优化器中设置的初始学习率之间线性增加。

transformers.get_linear_schedule_with_warmup

< source >

( optimizer num_warmup_steps num_training_steps last_epoch = -1 )

参数

optimizer (~torch.optim.Optimizer) — 要为其安排学习率的优化器。
num_warmup_steps (int) — 热身阶段的步数。
num_training_steps (int) — 训练步数的总数。
last_epoch (int, 可选, 默认为 -1) — 恢复训练时最后一个 epoch 的索引。

创建一个学习率调度器，使其在热身期间，学习率在 0 和优化器中设置的初始学习率之间线性增加，并在热身结束后，学习率从优化器中设置的初始学习率线性递减到 0。

transformers.get_polynomial_decay_schedule_with_warmup

< source >

( 优化器热身步数训练步数最终学习率 = 1e-07 幂 = 1.0 上次迭代周期 = -1 )

参数

优化器 (~torch.optim.Optimizer) — 要为其安排学习率的优化器。
热身步数 (int) — 热身阶段的步数。
训练步数 (int) — 训练步数的总数。
最终学习率 (float, 可选, 默认值: 1e-7) — 最终学习率。
幂 (float, 可选, 默认值: 1.0) — 幂因子。
上次迭代周期 (int, 可选, 默认值: -1) — 恢复训练时最后一个迭代周期的索引。

创建一个学习率调度，在预热阶段，学习率从 0 线性增加到优化器中设置的初始学习率。之后，学习率从优化器中设置的初始学习率多项式衰减到由 最终学习率 定义的最终学习率。

注意：根据 fairseq 实现，*幂* 默认为 1.0，而 fairseq 实现又是基于 https://github.com/google-research/bert/blob/f39e881b169b9d53bea03d2d341b31707a6c052b/optimization.py#L37 处的原始 BERT 实现。

transformers.get_inverse_sqrt_schedule

< 来源 >

( optimizer: Optimizer num_warmup_steps: int timescale: int = None last_epoch: int = -1 )

参数

optimizer (~torch.optim.Optimizer) — 要为其安排学习率的优化器。
num_warmup_steps (int) — 预热阶段的步数。
timescale (int, 可选, 默认值 num_warmup_steps) — 时间尺度。
last_epoch (int, 可选, 默认值 -1) — 恢复训练时最后一个时期的索引。

创建一个具有平方根反比学习率的调度，在预热期（预热期将学习率从 0 线性增加到优化器中设置的初始学习率）之后，从优化器中设置的初始学习率开始。

transformers.get_wsd_schedule

< source >

( optimizer: Optimizer num_warmup_steps: int num_stable_steps: int num_decay_steps: int min_lr_ratio: float = 0 num_cycles: float = 0.5 last_epoch: int = -1 )