oneflow.optim

Optimizers

Copyright 2020 The OneFlow Authors. All rights reserved.

Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

class oneflow.optim.Adagrad(params: Union[Iterator[oneflow.nn.Parameter], List[Dict]], lr: float = 0.001, lr_decay: float = 0.0, weight_decay: float = 0, initial_accumulator_value: float = 0.0, eps: float = 1e-10)

实现 Adagrad 优化算法。

公式是:

\[ \begin{align}\begin{aligned}& S_{t} = S_{t-1} + grad \odot grad\\& decay\_lr = \frac{learning\_rate}{(1 + (train\_step - 1) * lr\_decay)}\\& X_{t} = X_{t-1} - \frac{decay\_lr}{\sqrt{S_{t} + \epsilon}} \odot grad\end{aligned}\end{align} \]
参数:
  • params (Union[Iterator[Parameter], List[Dict]])- 待优化参数构成的 iterable 或定义了参数的 dict。

  • lr (float, optional)- 学习率,默认为 0.001。

  • lr_decay (float, optional)- 学习率的衰减因子,默认为 0.0。

  • weight_decay (float, optional)- 权重衰减, 默认为 0。

  • initial_accumulator_value (float, optional)- S 的初始值,默认为 0.0。

  • eps (float, optional)- 一个为提高数值稳定性而添加到分母的小常数项,默认为 1e-10。

例如:

例1:

# 假设 net 是一个自定义模型。
adagrad = flow.optim.Adagrad(net.parameters(), lr=1e-3)

for epoch in range(epochs):
    # Read data, Compute the loss and so on.
    # ...
    loss.backward()
    adagrad.step()
    adagrad.zero_grad()

例2:

# 假设 net 是一个自定义模型。
adagrad = flow.optim.Adagrad(
    [
        {
            "params": net.parameters(),
            "lr": learning_rate,
            "clip_grad_max_norm": 0.5,
            "clip_grad_norm_type": 2.0,
        }
    ],
)

for epoch in range(epochs):
    # 读取数据,计算损失等等。
    # ...
    loss.backward()
    adagrad.clip_grad()
    adagrad.step()
    adagrad.zero_grad()

如果你想要使用 clip_grad 函数,你可以参考这个例子。

关于 clip_grad_max_normclip_grad_norm_type 的更多细节, 你可以参考 oneflow.nn.utils.clip_grad_norm_()

step(closure: Optional[Callable] = None)

执行单个优化步骤。

参数:
  • closure (callable, optional)- 重新测试模型并返回损失的闭包。

class oneflow.optim.Adam(params: Union[Iterator[oneflow.nn.Parameter], List[Dict]], lr: float = 0.001, betas: Tuple[float, float] = (0.9, 0.999), eps: float = 1e-08, weight_decay: float = 0, amsgrad: bool = False, do_bias_correction: bool = True)

实现 Adam 优化算法。

它在 Adam: A Method for Stochastic Optimization 中被提出。 L2 penalty 的实现遵循了 Decoupled Weight Decay Regularization 中提出的变化。

该算法可以根据梯度的一阶矩估计和二阶矩估计动态地调整每个参数的学习率。

参数更新的方程是:

\[ \begin{align}\begin{aligned}& V_t = \beta_1*V_{t-1} + (1-\beta_1)*grad\\& S_t = \beta_2*S_{t-1} + (1-\beta_2)*{grad} \odot {grad}\\& \hat{g} = learning\_rate*\frac{{V_t}}{\sqrt{{S_t}}+\epsilon}\\& param_{new} = param_{old} - \hat{g}\end{aligned}\end{align} \]
参数:
  • params (iterable) - 待优化参数构成的 iterable 或定义了参数组的 dict。

  • lr (float, optional) - 学习率(默认值:1e-3)。

  • betas (Tuple[float, float], optional) - 用于计算梯度及其平方的移动平均的系数(默认值:(0.9, 0.999))

  • eps (float, optional) - 添加到分母中以提高数值稳定性的项(默认值:1e-8)。

  • weight_decay (float, optional) - 权重衰减 (L2 penalty) (默认值: 0)

  • amsgrad (bool, optional) - 是否使用该算法的 AMSGrad 变体(默认值: False) 。

  • do_bias_correction (bool, optional) - 是否做偏差校正(默认值:True)。

示例:

例1:

# 假设 net 是一个自定义模型。
adam = flow.optim.Adam(net.parameters(), lr=1e-3)

for epoch in range(epochs):
    # 读取数据,计算损失,等等。
    # ...
    loss.backward()
    adam.step()
    adam.zero_grad()

例2:

# 假设 net 是一个自定义模型。
adam = flow.optim.Adam(
    [
        {
            "params": net.parameters(),
            "lr": learning_rate,
            "clip_grad_max_norm": 0.5,
            "clip_grad_norm_type": 2.0,
        }
    ],
)

for epoch in range(epochs):
    # 读取数据,计算损失,等等。
    # ...
    loss.backward()
    adam.clip_grad()
    adam.step()
    adam.zero_grad()

若要使用 clip_grad 函数,请参考这个示例。

关于 clip_grad_max_normclip_grad_norm_type 函数的更多细节,请参考 oneflow.nn.utils.clip_grad_norm()

step(closure: Optional[Callable] = None)

执行一个优化步骤。

参数:
  • closure (callable, optional) - 重新测试模型并返回损失的闭包。

property support_sparse

Whether the Optimizer support sparse update.

class oneflow.optim.AdamW(params: Union[Iterator[oneflow.nn.Parameter], List[Dict]], lr: float = 0.001, betas: Tuple[float, float] = (0.9, 0.999), eps: float = 1e-08, weight_decay: float = 0, amsgrad: bool = False, do_bias_correction: bool = True)

实现 AdamW 优化算法。

原始的的 Adam 算法是在 Adam: A Method for Stochastic Optimization 中被提出。 其变式 AdamW 在 Decoupled Weight Decay Regularization 中被提出。

所以我们使用 Adam-weight-decay 算法来解决以下问题。

参数更新的方程是:

\[ \begin{align}\begin{aligned}& V_t = \beta_1*V_{t-1} + (1-\beta_1)*grad\\& S_t = \beta_2*S_{t-1} + (1-\beta_2)*{grad} \odot {grad}\\& \hat{g} = learning\_rate*(\frac{{V_t}}{\sqrt{{S_t}}+\epsilon}+\lambda*param_{old})\\& param_{new} = param_{old} - \hat{g}\end{aligned}\end{align} \]
参数:
  • params (iterable) - 待优化参数构成的 iterable 或定义了参数组的 dict。

  • lr (float, optional) - 学习率(默认值:1e-3)。

  • betas (Tuple[float, float], optional) - 用于计算梯度及其平方的移动平均的系数(默认值:(0.9, 0.999))

  • eps (float, optional) - 添加到分母中以提高数值稳定性的项(默认值:1e-8)。

  • weight_decay (float, optional) - 权重衰减 (L2 penalty) (在等式中为 λ, 默认值: 0)

  • amsgrad (bool, optional) - 是否使用该算法的 AMSGrad 变体 (默认值: False) 。

  • do_bias_correction (bool, optional) - 是否做偏差校正(默认值:True)。

示例:

例1:

# 假设 net 是一个自定义模型。
adamw = flow.optim.AdamW(net.parameters(), lr=1e-3)

for epoch in range(epochs):
    # 读取数据,计算损失,等等。
    # ...
    loss.backward()
    adamw.step()
    adamw.zero_grad()

例 2:

# 假设 net 是一个自定义模型。
adamw = flow.optim.AdamW(
    [
        {
            "params": net.parameters(),
            "lr": learning_rate,
            "clip_grad_max_norm": 0.5,
            "clip_grad_norm_type": 2.0,
        }
    ],
)

for epoch in range(epochs):
    # 读取数据,计算损失,等等。
    # ...
    loss.backward()
    adamw.clip_grad()
    adamw.step()
    adamw.zero_grad()

若要使用 clip_grad 函数,请参考这个示例。

关于 clip_grad_max_normclip_grad_norm_type 函数的更多细节,请参考 oneflow.nn.utils.clip_grad_norm()

step(closure: Optional[Callable] = None)

执行一个优化步骤。

参数:
  • closure (callable, optional) - 重新测试模型并返回损失的闭包。

property support_sparse

Whether AdamW Optimizer support sparse update.

class oneflow.optim.LAMB(params: Union[Iterator[oneflow.nn.Parameter], List[Dict]], lr: float = 0.001, betas: Tuple[float, float] = (0.9, 0.999), eps: float = 1e-08, weight_decay: float = 0, adam_w_mode: bool = True, do_bias_correction: bool = True, amsgrad: bool = False)

实现 LAMB 优化算法。

LAMB 在 Large Batch Optimization for Deep Learning: Training BERT in 76 minutes 中被提出。

参数更新的方程是:

\[ \begin{align}\begin{aligned}& V_t = \beta_1*V_{t-1} + (1-\beta_1)*grad\\& S_t = \beta_2*S_{t-1} + (1-\beta_2)*{grad} \odot {grad}\\& \hat{u} = \frac{{V_t}}{\sqrt{{S_t}}+\epsilon}\\& \hat{r} = learning\_rate * \frac{||param_{old}||_2}{||\hat{u}||_2}\\& param_{new} = param_{old} - \hat{r} * \hat{u}\end{aligned}\end{align} \]
参数:
  • params (iterable) - 待优化参数构成的 iterable 或定义了参数组的 dict。

  • lr (float, optional) - 学习率(默认值:1e-3)。

  • betas (Tuple[float, float], optional) - 用于计算梯度及其平方的移动平均的系数(默认值:(0.9, 0.999))

  • eps (float, optional) - 添加到分母中以提高数值稳定性的项(默认值:1e-8)。

  • weight_decay (float, optional) - 权重衰减 (L2 penalty) (默认值: 0)

  • adam_w_mode (bool, optional) - 应用 L2 正则化或去耦权重衰减 True (也被称为 AdamW 优化算法) (默认值: True)

  • do_bias_correction (bool, optional) - 是否做偏差校正(默认值:True)。

  • amsgrad (bool, optional) - 是否使用该算法的 AMSGrad 变体,现在不支持! (默认值: False)

示例:

例1:

# 假设 net 是一个自定义模型。
lamb = flow.optim.LAMB(net.parameters(), lr=1e-3)

for epoch in range(epochs):
    # 读取数据,计算损失,等等。
    # ...
    loss.backward()
    lamb.step()
    lamb.zero_grad()

例 2:

# 假设 net 是一个自定义模型。
lamb = flow.optim.LAMB(
    [
        {
            "params": net.parameters(),
            "lr": learning_rate,
            "clip_grad_max_norm": 0.5,
            "clip_grad_norm_type": 2.0,
        }
    ],
)

for epoch in range(epochs):
    # 读取数据,计算损失,等等。
    # ...
    loss.backward()
    lamb.clip_grad()
    lamb.step()
    lamb.zero_grad()

若要使用 clip_grad 函数,请参考这个示例。

关于 clip_grad_max_normclip_grad_norm_type 函数的更多细节,请参考 oneflow.nn.utils.clip_grad_norm()

step(closure: Optional[Callable] = None)

执行一个优化步骤。

参数:
  • closure (callable, optional) - 重新测试模型并返回损失的闭包。

class oneflow.optim.Optimizer(parameters, options)
add_param_group(param_group)None
clip_grad()

剪切一个参数 iterable 的梯度范数。 范数是在所有梯度上一起计算的,就像它们被串联成一个向量一样。 可以设置 max_norm 和 norm_type。

更多的细节请参考文档中的优化器(如 Adam、SGD 等)。

也可以参考代码中的 oneflow.nn.utils.clip_grad_norm_() 函数。

load_state_dict(state_dict)None

加载由 state_dict 函数创建的优化器的状态。

参考自: https://pytorch.org/docs/stable/_modules/torch/optim/optimizer.html#Optimizer.load_state_dict

state_dict()

dict 作为类型返回优化器的状态。

它包含两个条目:

  • state - 一个保存当前优化状态的 dict,它的内容在不同的优化器类之间是不同的。

  • param_group - 一个包含所有参数组的 dict。

参考自: https://pytorch.org/docs/stable/_modules/torch/optim/optimizer.html#Optimizer.state_dict

step(closure: Optional[Callable] = None)Optional[oneflow.Tensor]

执行一个优化步骤。

参数:
  • closure (callable, optional) - 重新测试模型并返回损失的闭包。

property support_sparse

Whether the Optimizer support sparse update.

zero_grad(set_to_none: bool = False)

将所有已优化的张量的梯度设置为零。

参数:
  • set_to_none (bool) - 设置 grads 为 None 而不是 0。一般来说,这将有较低的内存占用,并能适度地提高性能。然而,这会导致一些不同的行为。

例如:
  1. 当用户试图访问一个 gradient 并对其进行手动操作时,一个 None 属性或一个全是 0 的 Tensor 将表现得不同。

  2. 如果用户请求 zero_grad (set_to_none=True),然后再反向传播,对于没有收到梯度的参数,保证其梯度为 None。

  3. 如果梯度为 0 或 None,优化器有不同的行为(在一些情况下,它以 0 梯度执行该步骤;而在另一些情况下,它完全跳过该步骤)

class oneflow.optim.RMSprop(params: Union[Iterator[oneflow.nn.Parameter], List[Dict]], lr: float = 0.001, alpha: float = 0.99, eps: float = 1e-08, weight_decay: float = 0, momentum: float = 0.0, centered: bool = False)

实现 RMSprop 优化算法。

Root Mean Squared Propagation (RMSProp) 是一种未发表的、自适应的学习率方法。最先提出了 RMSProp 的构想出现在 http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf 的第29页。

原始方程如下:

\[ \begin{align}\begin{aligned}r(w, t) = \alpha r(w, t-1) + (1 - \alpha)(\nabla Q_{i}(w))^2\\\begin{split}W = w - \frac{\eta} {\\sqrt{r(w,t) + \epsilon}} \nabla Q_{i}(w)\end{split}\end{aligned}\end{align} \]

第一个方程计算了每个权重的梯度平方的移动平均值。然后将梯度除以 \(sqrt{v(w,t)}\). 在一些情况下,加入一个动量项 \(\beta\) 是很有效的。OneFlow 的实现中采用了 Nesterov 加速方法:

\[ \begin{align}\begin{aligned}r(w, t) = \alpha r(w, t-1) + (1 - \alpha)(\nabla Q_{i}(w))^2\\\begin{split}v(w, t) = \beta v(w, t-1) + \frac{\eta} {\\sqrt{r(w,t) + \epsilon}} \nabla Q_{i}(w)\end{split}\\w = w - v(w, t)\end{aligned}\end{align} \]

如果 centered 为 True:

\[ \begin{align}\begin{aligned}r(w, t) = \alpha r(w, t-1) + (1 - \alpha)(\nabla Q_{i}(w))^2\\g(w, t) = \alpha g(w, t-1) + (1 - \alpha)\nabla Q_{i}(w)\\\begin{split}v(w, t) = \beta v(w, t-1) + \frac{\eta} {\\sqrt{r(w,t) - (g(w, t))^2 + \epsilon}} \nabla Q_{i}(w)\end{split}\\w = w - v(w, t)\end{aligned}\end{align} \]

其中 \(\alpha\) 是一个超参数,其典型值为 0.99, 0.95 等等。 \(\beta\) 是一个 momentum 项。 \(\epsilon\) 是一个 smoothing 项,用来避免被零整除,通常设置在 1e-4 到 1e-8 的范围内。

参数:
  • params (iterable) - 待优化参数构成的 iterable 或定义了参数组的 dict。

  • lr (float, optional) - 学习率(默认值:1e-2)。

  • momentum (float, optional) - momentum 因子(默认值: 0, oneflow 现在不支持 momenmtum > 0)。

  • alpha (float, optional) - smoothing 常量(默认值: 0.99)。

  • eps (float, optional) - 添加到分母中以提高数值稳定性的项(默认值:1e-8)。

  • centered (bool, optional) - 如果为 True , 计算 centered RMSProp,梯度通过对其方差的估计进行标准化处理。

  • weight_decay (float, optional) - 权重衰减(L2 penalty)(默认值: 0)。

示例:

例 1:

# 假设 net 是一个自定义模型。
rmsprop = flow.optim.RMSprop(net.parameters(), lr=1e-3)

for epoch in range(epochs):
    # 读取数据,计算损失,等等。
    # ...
    loss.backward()
    rmsprop.step()
    rmsprop.zero_grad()

例 2:

# 假设 net 是一个自定义模型。
rmsprop = flow.optim.RMSprop(
    [
        {
            "params": net.parameters(),
            "lr": learning_rate,
            "clip_grad_max_norm": 0.5,
            "clip_grad_norm_type": 2.0,
        }
    ],
)

for epoch in range(epochs):
    # 读取数据,计算损失,等等。
    # ...
    loss.backward()
    rmsprop.clip_grad()
    rmsprop.step()
    rmsprop.zero_grad()

若要使用 clip_grad 函数,请参考这个示例。

关于 clip_grad_max_norm_clip_grad_norm_type 函数的更多细节,请参考 oneflow.nn.utils.clip_grad_norm()

step(closure: Optional[Callable] = None)

执行一个优化步骤。

参数:
  • closure (callable, optional) - 重新测试模型并返回损失的闭包。

class oneflow.optim.SGD(params: Union[Iterator[oneflow.nn.Parameter], List[Dict]], lr: float = 0.001, momentum: float = 0.0, weight_decay: float = 0.0)

实现 SGD 优化算法。

该算法将随机样本的梯度作为小批量梯度下降中整体梯度的近似估计。

当 momentum = 0,参数的更新方程为:

\[param_{new} = param_{old} - learning\_rate * grad\]

当有了 momentum,参数的更新方程为:

\[ \begin{align}\begin{aligned}& V_t = \beta * V_{t-1} - learning\_rate * (g_t + param_{old} * weight\_decay)\\& param_{new} = param_{old} + V_t\end{aligned}\end{align} \]
参数:
  • params (iterable) - 待优化参数构成的 iterable 或定义了参数组的 dict。

  • lr (float, optional) - 学习率(默认值:1e-3)。

  • momentum (float, optional) - momentum 因子(默认值: 0.0)。

  • weight_decay (float, optional) - 权重衰减(L2 penalty)(默认值: 0.0)。

示例:

例1::

# 假设 net 是一个自定义模型。
sgd = flow.optim.SGD(net.parameters(), lr=1e-3)

for epoch in range(epochs):
    # 读取数据,计算损失,等等。
    # ...
    loss.backward()
    sgd.step()
    sgd.zero_grad()

例2:

# 假设 net 是一个自定义模型。
sgd = flow.optim.SGD(
    [
        {
            "params": net.parameters(),
            "lr": learning_rate,
            "clip_grad_max_norm": 0.5,
            "clip_grad_norm_type": 2.0,
        }
    ],
)

for epoch in range(epochs):
    # 读取数据,计算损失,等等。
    # ...
    loss.backward()
    sgd.clip_grad()
    sgd.step()
    sgd.zero_grad()

若要使用 clip_grad 函数,请参考这个示例。

关于 clip_grad_max_normclip_grad_norm_type 函数的更多细节,请参考 oneflow.nn.utils.clip_grad_norm()

step(closure: Optional[Callable] = None)

执行一个优化步骤。

参数:
  • closure (callable, optional) - 重新测试模型并返回损失的闭包。

property support_sparse

Whether SGD Optimizer support sparse update.

Copyright 2020 The OneFlow Authors. All rights reserved.

Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

class oneflow.optim.lr_scheduler.CosineAnnealingLR(optimizer: oneflow.nn.optimizer.optimizer.Optimizer, T_max: int, eta_min: float = 0.0, last_step: int = - 1, verbose: bool = False)

文档参考自: https://pytorch.org/docs/stable/generated/torch.optim.lr_scheduler.CosineAnnealingLR.html?highlight=cosine#torch.optim.lr_scheduler.CosineAnnealingLR

使用 cosine annealing schedule 设置每个参数组的学习率,其中 \(\eta_{max}\) 被设置为初始学学习率, \(T_{cur}\) 是自 SGDR 中最后一次重启以来的 epoch 数。

\[\begin{split}\begin{aligned} \eta_t & = \eta_{min} + \frac{1}{2}(\eta_{max} - \eta_{min})\left(1 + \cos\left(\frac{T_{cur}}{T_{max}}\pi\right)\right), & T_{cur} \neq (2k+1)T_{max}; \\ \eta_{t+1} & = \eta_{t} + \frac{1}{2}(\eta_{max} - \eta_{min}) \left(1 - \cos\left(\frac{1}{T_{max}}\pi\right)\right), & T_{cur} = (2k+1)T_{max}. \end{aligned}\end{split}\]

当 last_step=-1, 设置初始学习率为 lr。因为调整是递归定义的, 除学习率调整器之外,它也可以同时被其他算子修改。 如果学习率完全由这个调整器设定,每一步的学习率就变成了:

\[\eta_t = \eta_{min} + \frac{1}{2}(\eta_{max} - \eta_{min})\left(1 + \cos\left(\frac{T_{cur}}{T_{max}}\pi\right)\right)\]

这在 SGDR: Stochastic Gradient Descent with Warm Restarts 中被提出。 请注意,这只实现了 SGDR 的 cosine annealing 部分,并不包括重新启动。

参数:
  • optimizer (Optimizer) - 被包装的优化器。

  • T_max (int) - 迭代的最大数量。

  • eta_min (float) - 学习率的最小值,默认值:0。

  • last_step (int) - 最后一个 epoch 的索引,默认值:-1。

  • verbose (bool) - 如果为 True ,则会为每次更新打印一条信息到标准输出,默认值: False

get_lr(base_lr, step)

Compute learning rate using chainable form of the scheduler

class oneflow.optim.lr_scheduler.CosineDecayLR(optimizer: oneflow.nn.optimizer.optimizer.Optimizer, decay_steps: int, alpha: float = 0.0, last_step: int = - 1, verbose: bool = False)

此算子构建了一个 Cosine decayed 学习率调整器。

在用户指定的 decay_steps 之前,学习率被更新为:

\[ \begin{align}\begin{aligned}& cos\_decay = 0.5*(1+cos(\pi*\frac{current\_step}{decay\_steps}))\\& decay\_factor = (1-\alpha)*cos\_decay+\alpha\\& learning\_rate = base\_learning\_rate*decay\_factor\end{aligned}\end{align} \]

在用户指定的 decay_steps 之后,学习率被更新为:

\[learning\_rate = {base\_learning\_rate}*{\alpha}\]

这在 SGDR: Stochastic Gradient Descent with Warm Restarts 中被提出。 请注意,这里只实现了 SGDR 的 cosine annealing 部分,并不包括重新启动。

参数:
  • optimizer (Optimizer) - 被包装的优化器。

  • decay_steps (int) - 学习率调整器中 decay steps。

  • alpha (float, optional) - 学习率比例因子( \(\alpha\) ),默认值为 0.0。

  • last_step (int) - 最后一个 epoch 的索引,默认值:-1。

  • verbose (bool) - 如果为 True ,则会在每次更新时打印一条信息到标准输出。默认为 False

示例:

import oneflow as flow

...
cosine_decay_lr = flow.optim.lr_scheduler.CosineDecayLR(optimizer, decay_steps=100, alpha=0.0)
for epoch in range(num_epoch):
    train(...)
    cosine_decay_lr.step()
get_lr(base_lr, step)

Compute learning rate using chainable form of the scheduler

class oneflow.optim.lr_scheduler.ExponentialLR(optimizer: oneflow.nn.optimizer.optimizer.Optimizer, gamma: float, last_step: int = - 1, verbose: bool = False)

在每个 epoch 中对每个参数组的学习率进行伽玛衰减操作。 当 last_step = -1 时,设置初始学习率为 lr。

参数:
  • optimizer (Optimizer) - 被包装的优化器。

  • gamma (float) - 学习率衰减的乘法系数。

  • last_step (int) - 最后一个 epoch 的索引,默认值:-1。

  • verbose (bool) - 如果为 True ,则会在每次更新时打印一条信息到标准输出。默认为 False

get_lr(base_lr, step)

Compute learning rate using chainable form of the scheduler

class oneflow.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_step=- 1, verbose=False)

将每个参数组的学习率设置为给定函数的初始 lr 倍。 当 last_step = -1 时,设置初始学习率为 lr。

\[learning\_rate = base\_learning\_rate*lambda(last\_step)\]
参数:
  • optimizer (Optimizer) - 被包装的优化器。

  • lr_lambda (function or list) - 一个根据给定参数 epoch 计算乘法因子的函数,或为一组函数,其中每个函数用于 optimizer.param_groups 中的每一个组。

  • last_step (int) - 最后一个 epoch 的索引(默认值:-1)。

  • verbose (bool) - 如果为 True ,则会在每次更新时打印一条信息到标准输出。默认为 False

示例:

import oneflow as flow

...
lambda1 = lambda step: step // 30
lambda2 = lambda step: 0.95 * step
lambda_lr = flow.optim.lr_scheduler.LambdaLR(optimizer, [lambda1, lambda2])
for epoch in range(num_epoch):
    train(...)
    lambda_lr.step()
load_state_dict(state_dict)

加载调整器的状态。

参数:
  • state_dict (dict) - 调整器的状态,应为调用 state_dict() 函数所返回的对象。

state_dict()

dict 类型返回调整器的状态。

它包含了 self.__dict__ 中每个变量不是优化器的条目。 学习率 lambda 函数只有在它们是可调用的对象时才会被保存,如果是函数或 lambdas 则不会被保存。

step()

执行一个优化步骤。

class oneflow.optim.lr_scheduler.MultiStepLR(optimizer: oneflow.nn.optimizer.optimizer.Optimizer, milestones: list, gamma: float = 0.1, last_step: int = - 1, verbose: bool = False)

一旦步数达到一个临界值,对每个参数组的学习率进行伽玛衰减操作。注意,这种衰减可以与其他因素导致的学习率变化同时发生。 当 last_step = -1 时,设置初始学习率为 lr。

参数:
  • optimizer (Optimizer) - 被包装的优化器。

  • milestones (list) - step indices 的 list,必须是递增的。

  • gamma (float, optional) - 学习率衰减的乘法系数(默认值:0.1)。

  • last_step (int) - 最后一个 epoch 的索引(默认值:-1)。

  • verbose (bool) - 如果为 True ,则会在每次更新时打印一条信息到标准输出。默认为 False

示例:

import oneflow as flow

...
multistep_lr = flow.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[30,80], gamma=0.1)
for epoch in range(num_epoch):
    train(...)
    multistep_lr.step()
get_lr(base_lr, step)

Compute learning rate using chainable form of the scheduler

class oneflow.optim.lr_scheduler.PolynomialLR(optimizer, steps: int, end_learning_rate: float = 0.0001, power: float = 1.0, cycle: bool = False, last_step: int = - 1, verbose: bool = False)

此算子创建了一个多项式形式的学习率衰减调整器。学习率按如下方式更新:

如果 cycle 为 True ,则等式为:

\[\begin{split}\begin{aligned} & decay\_batch = decay\_batch*ceil(\frac{current\_batch}{decay\_batch}) \\ & learning\_rate = (base\_lr-end\_lr)*(1-\frac{current\_batch}{decay\_batch})^{power}+end\_lr \end{aligned}\end{split}\]

如果 cycle 为 False ,则等式为:

\[\begin{split}\begin{aligned} & decay\_batch = min(decay\_batch, current\_batch) \\ & learning\_rate = (base\_lr-end\_lr)*(1-\frac{current\_batch}{decay\_batch})^{power}+end\_lr \end{aligned}\end{split}\]
参数:
  • optimizer (Optimizer) - 被包装的优化器。

  • steps (int) - 衰减的步数。

  • end_learning_rate (float, optional) - 最终学习率,默认值为 0.0001。

  • power (float, optional) - 多项式的幂,默认为 1.0。

  • cycle (bool, optional) - 如果 cycle 为 True,调整器将在每一步中衰减学习率,默认值为 False。

示例:

import oneflow as flow

...
polynomial_scheduler = flow.optim.lr_scheduler.PolynomialLR(
    optimizer, steps=5, end_learning_rate=0.00001, power=2
    )
for epoch in range(num_epoch):
    train(...)
    polynomial_scheduler.step()
get_lr(base_lr, step)

Compute learning rate using chainable form of the scheduler

class oneflow.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10, threshold=0.0001, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08, verbose=False)

当一个 metric 停止更新时,降低学习率。 一旦学习停滞不前,降低 2-10 倍的学习率往往能有效改善。 这个调整器每读取一个指标量,如果没有在第 ‘patience’ 轮学习中看到改进, 就会降低学习率。

参数:
  • optimizer (Optimizer) - 被包装的优化器。

  • mode (str) - min 或者 max 。在 min 模式中,当被监测的数量不再减少时学习率将会减小;在 max 模式中,当被监测的数量不再增加时学习率将会减小。默认为 min

  • factor (float) - 学习率降低的系数, new_lr = lr * factor , 默认值:0.1。

  • patience (int) - 若在这个 epoch 中模型还没有改善,学习率将降低。例如,如果 patience = 2 ,那么我们会忽略前两个没有改善的 epoch ,如果此后 loss 仍然没有减小,学习率也将会在第三个 epoch 后减小。默认值:10。

  • threshold (float) - 测量新的最佳状态的阈值,只关注一些重要变化。默认:1e-4。

  • threshold_mode (str) - relabs 。 在 rel 模式中,(max)dynamic_threshold = best * ( 1 + threshold ),(min)dynamic_threshold = best * ( 1 - threshold ); 在 abs 模式中,(max)dynamic_threshold = best + threshold,(min)dynamic_threshold = best - threshold inmode。默认: rel

  • cooldown (int) - 学习率减少后,在恢复正常操作前要等待的 epoch 数,默认值:0。

  • min_lr (float or list) - 一个标量或一个标量列表,分别是所有参数组和每组的学习率下限,默认:0。

  • eps (float) - 应用于学习率的最小衰减,如果新旧学习率之间的差异小于 eps,更新将被忽略。默认值:1e-8。

  • verbose (bool) - 如果为 True ,则会在每次更新时打印一条信息到标准输出。默认为 False

示例:

optimizer = flow.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
scheduler = flow.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min')
for epoch in range(10):
    train(...)
    val_loss = validate(...)
    # 注意,该步骤应在validate()之后调用。
    scheduler.step(val_loss)
property in_cooldown

Whether the learning rate scheduler in cooldown phase.

is_better(a, best)

Whether the metric has improvement.

load_state_dict(state_dict)

加载调整器的状态。

参数:
  • state_dict (dict) - 调整器的状态,应为调用 state_dict() 函数所返回的对象。

state_dict()

dict 形式返回调整器的状态。

它包含了 self.__dict__ 中每个变量的条目,而这些变量并不是优化器。

step(metrics)

执行单个优化步骤。

参数:
  • metrics (float)- 一个衡量模型训练效果的指标量。

class oneflow.optim.lr_scheduler.StepLR(optimizer: oneflow.nn.optimizer.optimizer.Optimizer, step_size: int, gamma: float = 0.1, last_step: int = - 1, verbose: bool = False)

在每一个周期为 step_size 的步骤中,对每个参数组的学习率进行伽玛衰减操作。 注意,这种衰减可以与其他因素导致的学习率变化同时发生。 当 last_step = -1 时,设置初始学习率为 lr。

参数:
  • optimizer (Optimizer) - 被包装的优化器。

  • step_size (int) - 学习率衰减的周期。

  • gamma (float, optional) - 学习率衰减的乘法系数(默认:0.1)。

  • last_step (int) - 最后一个 epoch 的索引(默认值:-1)。

  • verbose (bool) - 如果为 True ,则会在每次更新时打印一条信息到标准输出。默认为 False

示例:

import oneflow as flow

...
step_lr = flow.optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)
for epoch in range(num_epoch):
    train(...)
    step_lr.step()
get_lr(base_lr, step)

Compute learning rate using chainable form of the scheduler