Question

1. optimization 模块提供如下功能：

   • 一个具有固定权重衰减的 optimizer，可用于对模型进行微调。
   • 几个 schedule，它们是以继承自 _LRSchedule 的 schedule 对象的形式提供。
   • 一个 gradient accumulation 类，用于累积多个 batch 的梯度。

5.1 Optimizer API

1. class transformers.AdamW：具有固定的 weight decay 的 Adam 。

   
   xxxxxxxxxx
   class transformers.AdamW(
     params: typing.Iterable[torch.nn.parameter.Parameter],
     lr: float = 0.001,
     betas: typing.Tuple[float, float] = (0.9, 0.999),
     eps: float = 1e-06,
     weight_decay: float = 0.0,
     correct_bias: bool = True,
     no_deprecation_warning: bool = False
   )

   参数：

   • params：一个 nn.parameter.Parameter 可迭代对象或字典，指定需要被优化的 parameters 或 parameter groups 。
   • lr：一个浮点数，指定初始学习率。
   • betas：一个 Tuple[float,float] 元组，指定 Adam 的参数$({\beta }_1,{\beta }_2)$$ (\beta_1,\beta_2) $ 。
   • eps：一个浮点数，用于数值稳定。
   • weight_decay：一个浮点数，指定权重衰减。
   • correct_bias：一个布尔值，指定是否在 Adam 中 correct bias 。例如，在 BERT TF repo 中，他们使用 False 。
   • no_deprecation_warning：一个布尔值，指定是否屏蔽 deprecation warning 。

   方法：

   • step( closure: typing.Callable = None)：指定单个 optimization step 。

     参数：closure：一个可调用对象，用于重新评估模型并返回 loss 。

2. class transformers.Adafactor(PyTorch)：Adafactor 优化器。

   
   xxxxxxxxxx
   class transformers.Adafactor(
     paramslr = 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：参考 AdamW 。
   • lr：external 的学习率。
   • eps：一个 Tuple[float, float] 元组，指定正则化系数，分别用于 square gradient 和 parameter scale 。
   • clip_threshold：一个浮点数，指定 final gradient update 的均方根阈值。
   • decay_rate：一个浮点数，指定用于计算 running averages of square 的系数。
   • beta1：一个浮点数，指定用于计算 running averages of gradient 的系数。
   • weight_decay：一个浮点数，指定权重衰减（L2 正则化）。
   • scale_parameter：一个布尔值，如果为 True，则学习率通过 root mean square 来缩放。
   • relative_step：一个布尔值，如果为 True，则计算 time-dependent 学习率而不是 external 学习率。
   • warmup_init：一个布尔值，指定 time-dependent 学习率是否启用 warm-up 初始化。

   方法：参考 AdamW 。

3. class transformers.AdamWeightDecay(TensorFlow)：在梯度上启用了 L2 权重衰减和 clip_by_global_norm 的 Adam 。

   
   xxxxxxxxxx
   class transformers.AdamWeightDecay(
     learning_rate: typing.Union[float, keras.optimizers.schedules.learning_rate_schedule.LearningRateSchedule] = 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: typing.Optional[typing.List[str]] = None,
     exclude_from_weight_decay: typing.Optional[typing.List[str]] = None,
     name: str = 'AdamWeightDecay',
     **kwargs 
   )

   参数：

   • learning_rate：一个浮点数或 tf.keras.optimizers.schedules.LearningRateSchedule，指定学习率或学习率调度。

   • beta_1：一个浮点数，指定 Adam 的${\beta }_1$$ \beta_1 $ 参数。

   • beta_2：一个浮点数，指定 Adam 的${\beta }_2$$ \beta_2 $ 参数。

   • epsilon：一个浮点数，是 Adam 中的$ϵ$$ \epsilon $ 参数，用于数值稳定性。

   • amsgrad：一个布尔值，指定是否应该使用算法的 AMSGrad 变体。

   • weight_decay_rate：一个浮点数，指定权重衰减的系数。

   • include_in_weight_decay：一个关于字符串的列表，指定对哪些 parameters 应用权重衰减。如果未传递该参数，则默认应用于所有的 parameters（除非它们位于 exclude_from_weight_decay 中）。

   • exclude_from_weight_decay：一个关于字符串的列表，指定对哪些 parameters 排除权重衰减。如果一个 parameter name 同时位于 include_in_weight_decay 和 exclude_from_weight_decay，那么以 include_in_weight_decay 优先级最高。

   • name：一个字符串，指定权重衰减操作的名称。

   • kwargs：关键字操作，可以为 clipnorm, clipvalue, lr, decay：

     • clipnorm：基于梯度范数来裁剪梯度。
     • clipvalue：基于梯度的取值来裁剪梯度。
     • decay：用于后向兼容性，从而允许学习率的时间逆向衰减 time inverse decay 。
     • lr：用于后向兼容性，建议使用 learning_rate 。

   方法：

   • from_config(config) ：从配置文件中创建一个 AdamWeightDecay 。

4. transformers.create_optimizer()：创建一个 optimizer 。

   
   xxxxxxxxxx
   transformers.create_optimizer(
     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: typing.Optional[float] = None,
     adam_global_clipnorm: typing.Optional[float] = None,
     weight_decay_rate: float = 0.0,
     power: float = 1.0,
     include_in_weight_decay: typing.Optional[typing.List[str]] = None )

   参数：

   • init_lr：一个浮点数，指定 warmup 阶段结束时的期望学习率。
   • num_train_steps：一个整数，指定总的训练 step 数。
   • num_warmup_steps：一个整数，指定 warmup step 数。
   • min_lr_ratio：一个浮点数，学习率线性衰减结束时的最终学习率为 init_lr * min_lr_ratio 。
   • adam_beta1：一个浮点数，指定 Adam 的${\beta }_1$$ \beta_1 $ 参数。
   • adam_beta2：一个浮点数，指定 Adam 的${\beta }_2$$ \beta_2 $ 参数。
   • adam_epsilon：一个浮点数，指定 Adam 中的$ϵ$$ \epsilon $ 参数，用于数值稳定性。
   • adam_clipnorm：一个浮点数，如果不是None ，指定每个权重梯度范数的裁剪值。
   • adam_global_clipnorm：一个浮点数，如果不是None ，把所有权重梯度拼接起来，然后这个拼接结果的范数的裁剪值。
   • weight_decay_rate：一个浮点数，指定权重衰减系数。
   • power：一个浮点数，指定多项式衰减的幂次。
   • include_in_weight_decay：参考 AdamWeightDecay 。

5.2 Schedule API

1. class transformers.SchedulerType：一个枚举类型。

   
   xxxxxxxxxx
   class transformers.SchedulerType(
     value, names = None, module = None, qualname = None, type = None, start = 1
   )

2. transformers.get_scheduler()：一个统一的 API，根据 scheduler name 来获取 scheduler 。

   
   xxxxxxxxxx
   transformers.get_scheduler(
     name: typing.Union[str, transformers.trainer_utils.SchedulerType],
     optimizer: Optimizer,
     num_warmup_steps: typing.Optional[int] = None,
     num_training_steps: typing.Optional[int] = None 
   )

   参数：

   • name：一个字符串或 SchedulerType，指定 scheduler 的名字。
   • optimizer：一个 torch.optim.Optimizer 对象，指定优化器。
   • num_warmup_steps：一个整数，指定需要的 warmup step 的数量。不是所有的 scheduler 都需要这个参数（因此这个参数是可选的）。如果这个参数没有设置，而 scheduler 需要这个参数，则将引发一个错误。
   • num_training_steps：一个整数，指定需要的 training step 的数量。不是所有的 scheduler 都需要这个参数（因此这个参数是可选的）。如果这个参数没有设置，而 scheduler 需要这个参数，则将引发一个错误。

3. transformers.get_constant_schedule( optimizer: Optimizer, last_epoch: int = -1) ：创建一个常数学习率的调度器。

   参数：

   • optimizer：一个 torch.optim.Optimizer 对象，指定优化器。
   • last_epoch：一个整数，指定 last epoch 的索引，用于恢复训练。

4. transformers.get_constant_schedule_with_warmup(optimizer: Optimizer, num_warmup_steps: int, last_epoch: int = -1)：创建一个带 warmup 的常数学习率的调度器。

   参数：

   • num_warmup_steps：一个整数，指定 warmup 阶段的 step 数。
   • 其它参数参考 get_constant_schedule() 。

5. transformers.get_cosine_schedule_with_warmup(optimizer: Optimizer, num_warmup_steps: int, num_training_steps: int, num_cycles: float = 0.5, last_epoch: int = -1)：创建一个带 warmup 的余弦学习率的调度器。

   参数：

   • num_training_steps：一个整数，指定总的训练 step 数。
   • num_cycles：一个浮点数，指定余弦调度中的波数，默认为 0.5，表示半个余弦（从最大值下降到零）。
   • 其它参数参考 get_constant_schedule_with_warmup() 。

6. transformers.get_cosine_with_hard_restarts_schedule_with_warmup(optimizer: Optimizer, num_warmup_steps: int, num_training_steps: int, num_cycles: float = 0.5, last_epoch: int = -1)：创建一个带 warmup 的、且若干个硬重启的余弦学习率的调度器

   参数：

   • num_cycles：一个整数，指定 hard restart 的数量。
   • 其它参数参考 get_cosine_schedule_with_warmup() 。

7. transformers.get_linear_schedule_with_warmup( optimizer, num_warmup_steps, num_training_steps, last_epoch = -1)：创建一个带 warmup 的线性调度器。

   参数：参考 get_constant_schedule_with_warmup() 。

8. transformers.get_polynomial_decay_schedule_with_warmup(optimizer, num_warmup_steps, num_training_steps, lr_end = 1e-07, power = 1.0, last_epoch = -1)：创建一个带 warmup 的多项式衰减调度器。

   参数：

   • lr_end：一个浮点数，制定结束时的学习率。
   • power：一个浮点数，指定指数因子。
   • 其它参数参考 get_constant_schedule_with_warmup() 。

9. class transformers.WarmUp(TensorFlow)：在一个给定的 learning rate decay schedule 上应用一个 warmup 。

   
   xxxxxxxxxx
   class transformers.WarmUp(
     initial_learning_rate: float,
     decay_schedule_fn: typing.Callable,
     warmup_steps: int,
     power: float = 1.0,
     name: str = None
   )

   参数：

   • initial_learning_rate：一个浮点数，指定 warmup 结束时的学习率。
   • decay_schedule_fn：一个可调用对象，指定在 warmup 之后所采用的 schedule 函数。
   • warmup_steps：一个整数，指定 warmup 阶段的 step 数。
   • power：一个浮点数，指定用于多项式 warmup 的指数因子（默认为线性 warmup ）。
   • name：一个字符串，指定在 schedule 阶段返回的张量的 name prefix 。

5.3 Gradient Strategies API

1. class transformers.GradientAccumulator(TensorFlow)：gradient accumulation 工具函数。

   当用于分布式训练时，应在副本上下文中调用该 accumulator 。梯度将在每个副本上局部地累积，不需要同步。然后用户应该调用 .gradients ，如果需要的话则 scale 梯度，并将结果传递给 apply_gradients。

   方法：

   • reset()：在当前 replica 上 reset 被累计的梯度。