LRScheduler¶

class paddle.optimizer.lr. LRScheduler ( learning_rate=0.1, last_epoch=- 1, verbose=False ) [源代码] ¶

学习率策略的基类。定义了所有学习率调整策略的公共接口。

目前在paddle中基于该基类，已经实现了12种策略，分别为：

• NoamDecay: 诺姆衰减，相关算法请参考 《Attention Is All You Need》 。请参考 NoamDecay。

• ExponentialDecay: 指数衰减，即每次将当前学习率乘以给定的衰减率得到下一个学习率。请参考 ExponentialDecay。

• NaturalExpDecay: 自然指数衰减，即每次将当前学习率乘以给定的衰减率的自然指数得到下一个学习率。请参考 NaturalExpDecay。

• InverseTimeDecay: 逆时间衰减，即得到的学习率与当前衰减次数成反比。请参考 InverseTimeDecay。

• PolynomialDecay: 多项式衰减，即得到的学习率为初始学习率和给定最终学习之间由多项式计算权重定比分点的插值。请参考 cn_api_paddle_optimizer_lr_PolynomialDecay。

• PiecewiseDecay: 分段衰减，即由给定step数分段呈阶梯状衰减，每段内学习率相同。请参考 PiecewiseDecay。

• CosineAnnealingDecay: 余弦式衰减，即学习率随step数变化呈余弦函数周期变化。请参考 CosineAnnealingDecay。

• LinearWarmup: 学习率随step数线性增加到指定学习率。请参考 LinearWarmup。

• StepDecay: 学习率每隔固定间隔的step数进行衰减，需要指定step的间隔数。请参考 StepDecay。

• MultiStepDecay: 学习率在特定的step数时进行衰减，需要指定衰减时的节点位置。请参考 MultiStepDecay。

• LambdaDecay: 学习率根据自定义的lambda函数进行衰减。请参考 LambdaDecay。

• ReduceOnPlateau: 学习率根据当前监控指标（一般为loss）来进行自适应调整，当loss趋于稳定时衰减学习率。请参考 ReduceOnPlateau。

• MultiplicativeDecay: 每次将当前学习率乘以lambda函数得到下一个学习率。请参考 MultiplicativeDecay。

你可以继承该基类实现任意的学习率策略，导出基类的方法为 form paddle.optimizer.lr import LRScheduler ， 必须要重写该基类的 get_lr() 函数，否则会抛出 NotImplementedError 异常。

import paddle
from paddle.optimizer.lr import LRScheduler

class StepDecay(LRScheduler):
    def __init__(self,
                learning_rate,
                step_size,
                gamma=0.1,
                last_epoch=-1,
                verbose=False):
        if not isinstance(step_size, int):
            raise TypeError(
                "The type of 'step_size' must be 'int', but received %s." %
                type(step_size))
        if gamma >= 1.0:
            raise ValueError('gamma should be < 1.0.')

        self.step_size = step_size
        self.gamma = gamma
        super(StepDecay, self).__init__(learning_rate, last_epoch, verbose)

    def get_lr(self):
        i = self.last_epoch // self.step_size
        return self.base_lr * (self.gamma**i)

import paddle
import numpy as np

x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
linear = paddle.nn.Linear(10, 10)
scheduler = paddle.optimizer.lr.StepDecay(learning_rate=0.5, step_size=5, gamma=0.8, verbose=True)
sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameters=linear.parameters())
for epoch in range(20):
    for batch_id in range(2):
        x = paddle.to_tensor(x)
        out = linear(x)
        loss = paddle.mean(out)
        loss.backward()
        sgd.step()
        sgd.clear_gradients()
        scheduler.step()    # If you update learning rate each step
  # scheduler.step()        # If you update learning rate each epoch