Tensorflow2.0学习率衰减详细汇总

这里先列出5种常见学习率衰减策略的总结，之后详细介绍如何利用tensorflow库自带的类实现学习率衰减。

最后以上面5个例子演示如何自己自定义一个学习率衰减策略。这样大家以后就可以按照自己的需要定制一个学习率调度器了。

学习率调度器的实现参考：

• https://nndl.github.io/ 《神经网络与深度学习》第7章，作者：邱锡鹏
• tensorflow官方API

1. 总结

${\alpha }_0$——初始学习率

${\alpha }_t$——第$t$个step时的学习率

$\beta$ ——学习率衰减系数

$t$ ——当前是第几个step

$T$ ——经历个多少个step后完成一次学习率衰减

这里的公式与《神经网络与深度学习》第7章略微有一点区别，就是引入了$T$，主要是为了与tensorflow的API相契合。不影响理解。

方法	公式	说明
分段常数衰减 Piecewise Constant Decay		每经过$T_1,T_2,...,T_m$倍，学习率就下降为原来的${\beta }_1,{\beta }_2,...,{\beta }_m$倍
逆时衰减 Inverse Time Decay	$${\alpha }_t={\alpha }_0\frac{1}{1+\beta \times \frac{t}{T}}$$	经过$T$个step后，学习率下降为原来的$\frac{1}{1+\beta }$倍
指数衰减 Exponential Decay	$${\alpha }_t={\alpha }_0{\beta }^{\frac{t}{T}}$$	迭代$T$个step后，学习率降为原来的 $\beta$倍
自然指数衰减 Natural Exponential Decay	${\alpha }_t={\alpha }_0\exp (-\beta \times \frac{t}{T})$	迭代$T$个step后，学习率降为原来的 $\exp (-\beta )$倍
余弦衰减 Cosine Decay	${\alpha }_t=\frac{1}{2}{\alpha }_0\left(1+\cos \left(\frac{t\pi }{T}\right)\right)$	迭代$T$个step后学习率降至0

下图是不同学习率衰减的效果。

2. 利用TensorFlow2的API使用学习率衰减

下面通过tensorflow2的API演示如何创建一个学习率衰减调度器，以下例子中的初始学习率均为${\alpha }_0=1$。

2.1 分段常数衰减(Piecewise Constant Decay)

# 分段常数衰减(Piecewise Constant Decay)
import tensorflow as tf
boundaries=[20, 40, 60, 80]  # 以 0-20 20-40 40-60 60-80 80-inf 为分段
values=[1, 0.5, 0.25, 0.125, 0.0625]  # 各个分段学习率的值
piece_wise_constant_decay = tf.keras.optimizers.schedules.PiecewiseConstantDecay(
                            boundaries=boundaries, values=values, name=None)

2.2 逆时衰减(Inverse Time Decay)

$${\alpha }_t={\alpha }_0\frac{1}{1+\beta \times \frac{t}{T}}$$

initial_learning_rate=1.相当于${\alpha }_0=1$

decay_steps=1相当于$T=1$

decay_rate=0.1相当于$\beta =0.1$

即:
$${\alpha }_t=1\cdot \frac{1}{1+0.1t}$$

import tensorflow as tf
inverse_time_decay = tf.keras.optimizers.schedules.InverseTimeDecay(
                     initial_learning_rate=1., decay_steps=1, decay_rate=0.1)

2.3 指数衰减(Exponential Decay)

$${\alpha }_t={\alpha }_0{\beta }^{\frac{t}{T}}$$

initial_learning_rate=1.相当于${\alpha }_0=1$

decay_steps=1相当于$T=1$

decay_rate=0.96相当于$\beta =0.96$

即：
$${\alpha }_t=1\cdot 0.96^t$$

import tensorflow as tf
exponential_decay = tf.keras.optimizers.schedules.ExponentialDecay(
                        initial_learning_rate=1., decay_steps=1, decay_rate=0.96)

2.4 自然指数衰减(Natural Exponential Decay)

$${\alpha }_t={\alpha }_0\exp (-\beta \times \frac{t}{T})$$

initial_learning_rate=1.相当于${\alpha }_0=1$

decay_steps=1相当于$T=1$

decay_rate=0.96相当于$\beta =0.05$

即：
$${\alpha }_t=1\cdot \exp (-0.05t)$$
这个实现方案我没在tensorflow找到，于是自己实现了一个，这部分如果不太理解，可以暂时跳过这部分。自定义学习率调度器的方法在后面有提到。

import tensorflow as tf
class NaturalExpDecay(tf.keras.optimizers.schedules.LearningRateSchedule):
    def __init__(self, initial_learning_rate, decay_steps, decay_rate):
        super().__init__()
        self.initial_learning_rate = tf.cast(initial_learning_rate, dtype=tf.float32)
        self.decay_steps = tf.cast(decay_steps, dtype=tf.float32)
        self.decay_rate = tf.cast(decay_rate, dtype=tf.float32)
        
    def __call__(self, step):
        return self.initial_learning_rate * tf.math.exp(-self.decay_rate * (step / self.decay_steps))
    
natural_exp_decay = NaturalExpDecay(initial_learning_rate=1, 
                                    decay_steps=1, 
                                    decay_rate=0.05)

2.5 余弦衰减(Cosine Decay)

$${\alpha }_t=\frac{1}{2}{\alpha }_0\left(1+\cos \left(\frac{t\pi }{T}\right)\right)$$

initial_learning_rate=1.相当于${\alpha }_0=1$

decay_steps=100相当于$T=100$

即：
$${\alpha }_t=\frac{1}{2}\cdot 1\cdot \left(1+\cos \left(\frac{t\pi }{100}\right)\right)$$
注意这里$T=100$而不是1，当$t=100$时，${\alpha }_t=0.5\cdot (1+cos(\pi ))=0.5\cdot (1-1)=0$

import tensorflow as tf
cosine_decay = tf.keras.experimental.CosineDecay(
                initial_learning_rate=1., decay_steps=100)

2.6 使用方法

学习率衰减调度器的使用方法非常简单，以指数衰减为例。

• 先创建一个学习率衰减调度器
• 把它传入你选择的优化器（这里选择Adam优化器）

import tensorflow as tf
# 1. 先创建指数衰减学习率
exponential_decay = tf.keras.optimizers.schedules.ExponentialDecay(
                    initial_learning_rate=0.01, decay_steps=1000, decay_rate=0.96)
# 2. 送入优化器
optimizer = tf.keras.optimizers.Adam(exponential_decay)
# 普通的优化器
# optimizer = tf.keras.optimizers.Adam(0.01)

3. 自定义实现学习率衰减

这部分参考了tensorflow教程里有关自定义学习率的部分。

通过参考下面的例子，大家以后就可以自由的定义自己需要的学习率调度器。实现学习率衰减，warmup等功能。

首先需要创建一个自定义学习率调度器的类，继承tf.keras.optimizers.schedules.LearningRateSchedule

创建好后，使用方法与2.6完全一致。

代码如下

分段常数衰减(Piecewise Constant Decay)

import tensorflow as tf
class PiecewiseConstantDecay(tf.keras.optimizers.schedules.LearningRateSchedule):
    def __init__(self, boundaries, values):
        super().__init__()
        self.boundaries = tf.cast(boundaries, dtype=tf.float32)
        self.values = tf.cast(values, dtype=tf.float32)
    
    def __call__(self, step):
        for i in range(len(self.boundaries)):
            if self.boundaries[i] >= step:
                return self.values[i]
        else:
            return self.values[-1]

逆时衰减(Inverse Time Decay)

import tensorflow as tf
class InverseTimeDecay(tf.keras.optimizers.schedules.LearningRateSchedule):
    def __init__(self, initial_learning_rate, decay_steps, decay_rate):
        super().__init__()
        self.initial_learning_rate = tf.convert_to_tensor(initial_learning_rate)
        self.decay_steps = tf.cast(decay_steps, dtype=tf.float32)
        self.decay_rate = tf.convert_to_tensor(decay_rate)
    
    def __call__(self, step):
        step = tf.convert_to_tensor(step)
        return self.initial_learning_rate / (1 + self.decay_rate * step / self.decay_steps)

指数衰减(Exponential Decay)

import tensorflow as tf
class ExponentialDecay(tf.keras.optimizers.schedules.LearningRateSchedule):
    def __init__(self, initial_learning_rate, decay_steps, decay_rate):
        super().__init__()
        self.initial_learning_rate = tf.cast(initial_learning_rate, dtype=tf.float32)
        self.decay_steps = tf.cast(decay_steps, dtype=tf.float32)
        self.decay_rate = tf.cast(decay_rate, dtype=tf.float32)
        
    def __call__(self, step):
        return self.initial_learning_rate * self.decay_rate ** (step / self.decay_steps)

余弦衰减(Cosine Decay)

import tensorflow as tf
from math import pi

class CosineDecay(tf.keras.optimizers.schedules.LearningRateSchedule):
    def __init__(self, initial_learning_rate, decay_steps):
        super().__init__()
        self.initial_learning_rate = tf.cast(initial_learning_rate, dtype=tf.float32)
        self.decay_steps = tf.cast(decay_steps, dtype=tf.float32)
    
    def __call__(self, step):
        return self.initial_learning_rate * (1 + tf.math.cos(step * pi / self.decay_steps)) / 2