RNN 梯度消失&梯度爆炸

参考：https://zhuanlan.zhihu.com/p/33006526?from_voters_page=true

梯度消失和梯度爆炸本质是同一种情况。梯度消失经常出现的原因：一是使用深层网络；二是采用不合适的损失函数，如Sigmoid。梯度爆炸一般出现的场景：一是深层网络；二是权值初始化太大。

1. 深层网络角度解释梯度消失和梯度爆炸

深层网络由许多非线性层堆叠而来，每一层网络激活后的输出为$f_i(x)$，其中$i$为第$i$层，$x$是第$i$层的输入，即第$i-1$层的输出，$f$是激活函数，整个深层网络可视为一个复合的非线性多元函数：
$$\begin{gathered} f_{i+1}=f(f_i\ast w_i+b) \\ F(x)=f_n(...f_3(f_2(f_1(x)\ast w_1+b)\ast w_2+b)...) \end{gathered}$$
目的是多元函数$F(x)$完成输入到输出的映射，假设不同的输入，输出的最优解是g(x)，则优化深层网络就是为了找到合适的权值，满足$Loss=L(g(x),F(x))$取得极小值。

BP 算法基于梯度下降策略，以负梯度方向对参数进行调整，参数更新：
$$\begin{gathered} w\leftarrow w+\Delta w \\ \Delta w=-\alpha \frac{\partial Loss}{\partial w} \\ \Delta w_1=\frac{\partial Loss}{\partial w_2}=\frac{\partial Loss}{\partial f_n}\frac{\partial f_n}{\partial f_{n-1}}\frac{\partial f_{n-1}}{\partial f_{n-2}}...\frac{\partial f_3}{\partial f_2}\frac{\partial f_2}{\partial w_2} \\ \frac{\partial f_2}{\partial w_2}=f_1 \end{gathered}$$
$\frac{\partial f_n}{\partial f_{n-1}}$即对激活函数求导，如果此部分大于1，随着层数增加，梯度更新将以指数形式增加，即发生梯度爆炸；如果此部分小于1，随着层数增加，梯度更新将以指数形式衰减，即发生梯度消失。

梯度消失、爆炸，其根本原因在于反向传播训练法则，链式求导次数太多。

2. 激活函数角度解释梯度消失和梯度爆炸

计算权值更新信息，需要计算前层偏导信息，因此激活函数选择不合适，比如Sigmoid，梯度消失会更明显。
$$\begin{gathered} Sigmoid(x)=\frac{1}{1+e^{-x}} \\ Sigmoi{d}^{\prime }(x)=\frac{e^{-x}}{(1+e^{-x}{)}^2}=Sigmoid(x)(1-Sigmoid(x)) \end{gathered}$$
如果使用sigmoid作为损失函数，其梯度是不可能超过0.25的，这样经过链式求导之后，很容易发生梯度消失。

tanh作为损失函数，它的导数图如下，可以看出，tanh比sigmoid要好一些，但是它的导数仍然是小于1的。
$$\begin{gathered} tanh(x)=\frac{sinh(x)}{cosh(x)}=\frac{e^x-e^{-x}}{e^x+e^{-x}} \\ tan{h}^{\prime }(x)=1-\frac{(e^x-e^{-x}{)}^2}{(e^x+e^{-x}{)}^2}=1-tan{h}^2(x) \end{gathered}$$

由于sigmoid和tanh存在上述的缺点，因此relu激活函数成为了大多数神经网络的默认选择。relu函数的导数在正数部分是恒等于1，因此在深层网络中就不存在梯度消失/爆炸的问题，每层网络都可以得到相同的更新速度。另外计算方便，计算速度快，加速网络的训练。

但是relu也存在缺点：即在$x$小于0时，导数为0，导致一些神经元无法激活。输出不是以0为中心的。因此引申出下面的leaky relu函数，但是实际上leaky relu使用的并不多。
$$\begin{gathered} RELU(x)=max(0,x) \\ LeakyRELU(x)=max(0.01x,x) \end{gathered}$$

3. RNN中的梯度消失和CNN的梯度消失有区别

RNN中的梯度消失/爆炸和MLP/CNN中的梯度消失/爆炸含义不同：MLP/CNN中不同的层有不同的参数，各是各的梯度；而 RNN 中同样的权重在各个时间步共享，最终的梯度 g 等于各个时间步的梯度 $g_t$ 的和。

• RNN中的总的梯度不会消失。即便梯度越传越弱，那也只是远距离的梯度消失，由于近距离的梯度不会消失，所有梯度之和并不会消失。RNN 所谓梯度消失的真正含义是，梯度被近距离梯度主导，导致模型难以学到远距离的依赖关系。

  

  RNN前向传导过程：
  $$\begin{array}{rl}t& =1\\ s_1& =g(U{x}_1+W{s}_0)\\ o_1& =f(Vg(U{x}_1+W{s}_0))\\ t& =2\\ s_2& =g(U{x}_2+W{s}_1)\\ o_2& =f(Vg(U{x}_2+W{s}_1))=f(Vg(U{x}_2+Wg(U{x}_1+W{s}_0)))\\ t& =3\\ s_3& =g(U{x}_3+W{s}_2)\\ o_3& =f(Vg(U{x}_3+W{s}_2))=f(Vg(U{x}_3+Wg(U{x}_2+W(U{x}_1+W{s}_0))))\\ ...& \\ t& =m\\ ...& \\ Loss& =L(o_m,y)\\ \frac{\partial L}{\partial U}& =\frac{\partial L}{\partial o_m}\frac{\partial o_m}{\partial s_m}\frac{\partial s_m}{\partial U}+\frac{\partial L}{\partial o_m}\frac{\partial o_m}{\partial s_m}\frac{\partial s_m}{\partial s_{m-1}}\frac{\partial s_{m-1}}{\partial U}+...+\frac{\partial L}{\partial o_m}\frac{\partial o_m}{\partial s_m}\frac{\partial s_m}{\partial s_{m-1}}...\frac{\partial s_2}{\partial s_1}\frac{\partial s_1}{\partial U}\\ & =\sum _{t=1}^m\frac{\partial L}{\partial o_m}\frac{\partial o_m}{\partial s_m}\left(\prod _{j=t+1}^m\frac{\partial s_j}{\partial s_{j-1}}\right)\frac{\partial s_t}{\partial U}\end{array}$$

  当激活函数为tanh，$s_t=tanh(U{x}_t+W{s}_{t-1})$，

  权值梯度：
  $$\begin{array}{rl}Loss& =\sum _{t=1}^m\frac{\partial L}{\partial o_m}\frac{\partial o_m}{\partial s_m}\left(\prod _{j=t+1}^m\frac{\partial s_j}{\partial s_{j-1}}\right)\frac{\partial s_t}{\partial U}\\ & =\sum _{t=1}^m\frac{\partial L}{\partial o_m}\frac{\partial o_m}{\partial s_m}\left(\prod _{j=t+1}^{m}tan{h}^{\prime }W\right)\frac{\partial s_t}{\partial U}\end{array}$$

• MLP/CNN 的梯度消失：主要是随着网络加深，浅层网络的梯度越来越小，导致参数无法更新迭代。

4. 梯度消失、爆炸的解决方案

在深度神经网络中，往往是梯度消失出现的更多一些。

4.1 梯度爆炸的解决方案

1. 梯度裁剪：主要思想是设置一个梯度剪切阈值，然后更新梯度的时候，如果梯度超过这个阈值，那么就将其强制限制在这个范围之内。这可以防止梯度爆炸。

2. 权值正则化（weithts regularization）：正则化是通过对网络权重做正则限制过拟合，如下正则项在损失函数中的形式：
   $$Loss=(y-W^{T}x{)}^2+\alpha ||W|{|}^2$$
   常见的是L1正则和L2正则，在各个深度框架中都有相应的API可以使用正则化。

   其中， $\alpha$是指正则项系数，因此，如果发生梯度爆炸，权值的范数就会变的非常大，通过正则化项，可以部分限制梯度爆炸的发生。

4.2 梯度消失的解决方案

4.2.1 选择relu、leakrelu、elu等激活函数

• relu函数的导数在正数部分是恒等于1的，因此在深层网络中不会导致梯度消失和爆炸的问题。relu优点：解决了梯度消失、爆炸的问题，计算速度快，加速网络训练。relu缺点：导数的负数部分恒为0，会导致一些神经元无法激活（可通过设置小学习率部分解决），输出不是以0为中心的。

• leakrelu就是为了解决relu的0区间带来的影响。数学表达：$leakrelu=max(x\ast k,x)$

  其中k是leak系数，一般选择0.1或者0.2，或者通过学习而来。leakrelu解决了0区间带来的影响，而且包含了relu的所有优点。

• elu也是为了解决relu的0区间带来的影响，其数学表达为：

  $$elu(x)=\{\begin{array}{ll}x,& \text{if }x>0\\ \alpha (e^x-1),& \text{otherwise}\end{array}$$
  但是elu相对于leakrelu来说，计算要更耗时间一些。

4.2.2 使用Batchnorm（batch normalization，简称BN）：

目前已经被广泛的应用到了各大网络中，具有加速网络收敛速度，提升训练稳定性的效果，Batchnorm本质上是解决反向传播过程中的梯度问题。通过规范化操作将输出信号x规范化到均值为0，方差为1保证网络的稳定性。 具体来说就是反向传播中，经过每一层的梯度会乘以该层的权重，举个简单例子： 正向传播中$f_3=f_2(w^{T}x+b)$ ，那么反向传播中，$\frac{\partial f_2}{\partial x}=\frac{\partial f_2}{\partial f_1}w$， 反向传播式子中有$w$ 的存在，所以 $w$ 的大小影响了梯度的消失和爆炸，batchnorm就是通过对每一层的输出做scale和shift的方法，通过一定的规范化手段，把每层神经网络任意神经元这个输入值的分布强行拉回到接近均值为0方差为1的标准正太分布，即严重偏离的分布强制拉回比较标准的分布，这样使得激活输入值落在非线性函数对输入比较敏感的区域，这样输入的小变化就会导致损失函数较大的变化，使得让梯度变大，避免梯度消失问题产生，而且梯度变大意味着学习收敛速度快，能大大加快训练速度。

4.2.3 残差结构：

残差单元里的shortcut（捷径）部分可以保证在反向传播中梯度不会消失。

$$\frac{\partial Loss}{\partial x_l}=\frac{\partial Loss}{\partial x_L}\frac{\partial x_L}{\partial x_l}=\frac{\partial Loss}{\partial x_L}\left(1+\frac{\partial }{\partial x_L}\sum _{i=l}^{L-1}F(x_i,W_i)\right)$$
式子的第一个因子$\frac{\partial Loss}{\partial x_L}$表示的损失函数到达 L 层的梯度，小括号中的1表明短路机制可以无损地传播梯度，而另外一项残差梯度则需要经过带有weights的层，梯度不是直接传递过来的。残差梯度不会那么巧全为-1，而且就算其比较小，有1的存在也不会导致梯度消失。所以残差学习会更容易。

4.2.4 LSTM：

使用LSTM（long-short term memory networks，长短期记忆网络），就不那么容易发生梯度消失，主要原因在于LSTM内部复杂的“门”(gates)，如下图，LSTM通过它内部的“门”可以在更新的时候“记住”前几次训练的“残留记忆”，因此，经常用于生成文本中。

5. 参考

RNN

• https://zybuluo.com/hanbingtao/note/541458
• https://colab.research.google.com/drive/1Zfvt9Vfs3PrJwSDF8jMvomz7CzU36RXk

LSTM

• http://colah.github.io/posts/2015-08-Understanding-LSTMs/
• https://www.youtube.com/watch?v=9zhrxE5PQgY&feature=youtu.be
• https://towardsdatascience.com/illustrated-guide-to-lstms-and-gru-s-a-stepby-step-explanation-44e9eb85bf21
• https://medium.com/datadriveninvestor/how-do-lstm-networks-solve-theproblem-of-vanishing-gradients-a6784971a577

欢迎各位关注我的个人公众号：HsuDan，我将分享更多自己的学习心得、避坑总结、面试经验、AI最新技术资讯。

梯度消失 & 梯度爆炸

输出结果:

vanish: 0.025517964452291125
explode: 37.78343433288728

梯度消失

梯度消失问题 (Vanishing gradient problem). 如果导数小于 1, 随着网络层数的增加梯度跟新会朝着指数衰减的方向前进, 这就是梯度消失.

当导数小于 1 的时候, 层数越多, 梯度就越小, 即梯度消失.

梯度爆炸

梯度爆炸问题 (Exploding gradient problem). 如果导数大于 1, 随着网络层数的增加梯度跟新会朝着指数增加的方向前进, 这就是梯度爆炸.

当导数大于 1 的时候, 层数越多, 梯度就越大, 即梯度爆炸.

张量限幅

通过张量限幅, 我们可以有效解决梯度爆炸问题.

tf.clip_by_value

我们可以通过tf.clip_by_value函数来实现张量限幅.

格式:

tf.clip_by_value(
    t, clip_value_min, clip_value_max, name=None
)

参数:

• t: 传入的张量
• clip_value_min: 下限
• clip_value_max: 上限
• name: 数据名称

例子:

# clip_by_value
a = tf.range(10)
print(a)

b = tf.maximum(a, 2)
print(b)

c = tf.minimum(a, 8)
print(c)

d = tf.clip_by_value(a, 2, 8)
print(d)

输出结果:

tf.Tensor([0 1 2 3 4 5 6 7 8 9], shape=(10,), dtype=int32)
tf.Tensor([2 2 2 3 4 5 6 7 8 9], shape=(10,), dtype=int32)
tf.Tensor([0 1 2 3 4 5 6 7 8 8], shape=(10,), dtype=int32)
tf.Tensor([2 2 2 3 4 5 6 7 8 8], shape=(10,), dtype=int32)

tf.clip_by_norm

tf.clip_by_norm可以对梯度进行裁剪, 防止梯度爆炸.

格式:

tf.clip_by_norm(
    t, clip_norm, axes=None, name=None
)

参数:

• t: 传入的张量
• clip_norm: 定义最大限幅
• axes: 计算尺寸
• name: 数据名称

例子:

# clip_by_normal
a = tf.random.normal([2, 2], mean=10)
print(a)
print(tf.norm(a))  # 范数

b = tf.clip_by_norm(a, 15)
print(b)
print(tf.norm(b))  # 范数

输出结果:

tf.Tensor(
[[ 9.33037  10.703022]
 [ 9.788097  9.713704]], shape=(2, 2), dtype=float32)
tf.Tensor(19.793266, shape=(), dtype=float32)
tf.Tensor(
[[7.070867  8.111109 ]
 [7.417748  7.3613706]], shape=(2, 2), dtype=float32)
tf.Tensor(15.0, shape=(), dtype=float32)

mnist 展示梯度爆炸

为了实现梯度爆炸, 我们把学习率设为 0.1.

完整代码

# 读取训练集的特征值和目标值
(x, y), _ = tf.keras.datasets.mnist.load_data()

# 转换为0~1的形式
x = tf.convert_to_tensor(x, dtype=tf.float32) / 255

# 转换成one_hot编码
y = tf.one_hot(y, depth=10)

# 批次分割
train_db = tf.data.Dataset.from_tensor_slices((x, y)).batch(256).repeat(30)


def main():
    # 生成w1形状为[784, 512]的截断正态分布, 中心为0, 标差为0.1
    w1 = tf.Variable(tf.random.truncated_normal([784, 512], stddev=0.1))

    # 生成b1形状为[512]初始化为0
    b1 = tf.Variable(tf.zeros([512]))

    # 生成w2形状为[512, 256]的截断正态分布, 中心为0, 标差为0.1
    w2 = tf.Variable(tf.random.truncated_normal([512, 256], stddev=0.1))

    # 生成b2形状为[256]初始化为0
    b2 = tf.Variable(tf.zeros([256]))

    # 生成w3形状为[256, 10]的截断正态分布, 中心为0, 标差为0.1
    w3 = tf.Variable(tf.random.truncated_normal([256, 10], stddev=0.1))

    # 生成b3形状为[10]初始化为0
    b3 = tf.Variable(tf.zeros([10]))

    # 优化器
    optimizer = tf.keras.optimizers.SGD(learning_rate=0.1)  # 梯度下降

    for step, (x, y) in enumerate(train_db):

        # 把x平铺 [256, 28, 28] => [256, 784]
        x = tf.reshape(x, [-1, 784])

        with tf.GradientTape() as tape:

            # 第一个隐层
            h1 = x @ w1 + b1
            h1 = tf.nn.relu(h1)  # 激活

            # 第二个隐层
            h2 = h1 @ w2 + b2
            h2 = tf.nn.relu(h2)  # 激活

            # 输出层
            out = h2 @ w3 + b3

            # 计算损失函数
            loss = tf.square(y - out)
            loss = tf.reduce_mean(loss)

            # 计算梯度
            grads = tape.gradient(loss, [w1, b1, w2, b2, w3, b3])

            # 调试输出剪切前的范数
            print("================before===============")
            for g in grads:
                print(tf.norm(g))

            grads, _ = tf.clip_by_global_norm(grads, 15)

            # 调试输出剪切后的范数
            print("================after===============")
            for g in grads:
                print(tf.norm(g))

            optimizer.apply_gradients(zip(grads, [w1, b1, w2, b2, w3, b3]))  # 跟新权重


if __name__ == '__main__':
    main()

输出结果

================before===============
tf.Tensor(5.5961547, shape=(), dtype=float32)
tf.Tensor(0.87258744, shape=(), dtype=float32)
tf.Tensor(7.397964, shape=(), dtype=float32)
tf.Tensor(0.69156337, shape=(), dtype=float32)
tf.Tensor(9.840232, shape=(), dtype=float32)
tf.Tensor(0.8157242, shape=(), dtype=float32)
================after===============
tf.Tensor(5.5961547, shape=(), dtype=float32)
tf.Tensor(0.87258744, shape=(), dtype=float32)
tf.Tensor(7.397964, shape=(), dtype=float32)
tf.Tensor(0.69156337, shape=(), dtype=float32)
tf.Tensor(9.840232, shape=(), dtype=float32)
tf.Tensor(0.8157242, shape=(), dtype=float32)
================before===============
tf.Tensor(18.01539, shape=(), dtype=float32)
tf.Tensor(2.9375393, shape=(), dtype=float32)
tf.Tensor(21.330334, shape=(), dtype=float32)
tf.Tensor(2.1504176, shape=(), dtype=float32)
tf.Tensor(21.820374, shape=(), dtype=float32)
tf.Tensor(2.0918982, shape=(), dtype=float32)
================after===============
tf.Tensor(7.5730414, shape=(), dtype=float32)
tf.Tensor(1.2348388, shape=(), dtype=float32)
tf.Tensor(8.966527, shape=(), dtype=float32)
tf.Tensor(0.90396047, shape=(), dtype=float32)
tf.Tensor(9.172523, shape=(), dtype=float32)
tf.Tensor(0.8793609, shape=(), dtype=float32)
================before===============
tf.Tensor(0.5821787, shape=(), dtype=float32)
tf.Tensor(0.0859229, shape=(), dtype=float32)
tf.Tensor(0.7110027, shape=(), dtype=float32)
tf.Tensor(0.082481824, shape=(), dtype=float32)
tf.Tensor(0.51846975, shape=(), dtype=float32)
tf.Tensor(0.1655324, shape=(), dtype=float32)
================after===============
tf.Tensor(0.5821787, shape=(), dtype=float32)
tf.Tensor(0.0859229, shape=(), dtype=float32)
tf.Tensor(0.7110027, shape=(), dtype=float32)
tf.Tensor(0.082481824, shape=(), dtype=float32)
tf.Tensor(0.51846975, shape=(), dtype=float32)
tf.Tensor(0.1655324, shape=(), dtype=float32)

... ...