【剑指offer】梯度消失和梯度爆炸

【剑指offer】系列文章目录

BN层详解
交叉熵损失函数

---

原文地址：梯度消失和梯度爆炸

---

梯度消失和梯度爆炸

梯度消失和梯度爆炸是深度神经网络中常见的问题，这些问题可能导致模型无法训练或者训练过程非常缓慢。
【文末配有代码，可以参考代码案例进行理解以下概念】

• 梯度消失指的是在反向传播过程中，模型的某些层的梯度非常小，甚至接近于0，导致这些层的参数几乎无法更新。这种情况产生的原因有：一是在深层网络中，当网络层数较多时，梯度会在反向传播过程中多次相乘，使得梯度值逐渐变小，最终消失。当梯度消失时，网络的学习效果会变得非常差，甚至无法训练。二是采用了不合适的损失函数，比如sigmoid。当梯度消失发生时，接近于输出层的隐藏层由于其梯度相对正常，所以权值更新时也就相对正常，但是当越靠近输入层时，由于梯度消失现象，会导致靠近输入层的隐藏层权值更新缓慢或者更新停滞。这就导致在训练时，只等价于后面几层的浅层网络的学习。

• 梯度爆炸指的是在反向传播过程中，模型的某些层的梯度非常大，甚至超过了计算机可以表示的范围，导致这些层的参数发生了非常大的变化。这种情况通常发生在深度神经网络中，当网络层数较多时，梯度会在反向传播过程中多次相乘，使得梯度值逐渐变大，最终爆炸。当梯度爆炸时，网络的学习效果也会变得非常差，甚至无法训练。梯度爆炸会伴随一些细微的信号，如：①模型不稳定，导致更新过程中的损失出现显著变化；②训练过程中，在极端情况下，权重的值变得非常大，以至于溢出，导致模型损失变成 NaN等等。

---

为什么会产生梯度消失和梯度爆炸

梯度消失：
根据链式法则，如果每一层神经元对上一层的输出的偏导乘上权重结果都小于1的话，那么即使这个结果是0.99，在经过足够多层传播之后，误差对输入层的偏导会趋于0
关于梯度消失，以sigmoid函数为例子，sigmoid函数使得输出在[0,1]之间。

事实上x到了一定大小，经过sigmoid函数的输出范围就很小了，参考下图

如果输入很大，其对应的斜率就很小，我们知道，其斜率（梯度）在反向传播中是权值学习速率。所以就会出现如下的问题：
在深度网络中，如果网络的激活输出很大，其梯度就很小，学习速率就很慢。假设每层学习梯度都小于最大值0.25，网络有n层，因为链式求导的原因，第一层的梯度小于0.25的n次方，所以学习速率就慢，对于最后一层只需对自身求导1次，梯度就大，学习速率就快。
这会造成的影响是在一个很大的深度网络中，浅层基本不学习，权值变化小，后面几层一直在学习，结果就是，后面几层基本可以表示整个网络，失去了深度的意义。

代码示例

代码如下（示例）：

import torch
import torch.nn as nn
import numpy as np

# 定义一个五层的全连接神经网络
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(1, 10)
        self.fc2 = nn.Linear(10, 10)
        self.fc3 = nn.Linear(10, 10)
        self.fc4 = nn.Linear(10, 10)
        self.fc5 = nn.Linear(10, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = torch.relu(self.fc3(x))
        x = torch.relu(self.fc4(x))
        x = self.fc5(x)
        return x

# 定义一个计算权重梯度的函数
def compute_gradient(net, x):
    y = net(x)
    loss = torch.sum(y)
    loss.backward()
    gradients = [p.grad for p in net.parameters()]
    return gradients

# 定义一个计算梯度变化的函数
def compute_gradient_change(gradients1, gradients2):
    gradient_change = []
    for g1, g2 in zip(gradients1, gradients2):
        if g1 is None or g2 is None:
            gradient_change.append(None)
        else:
            gradient_change.append(torch.norm(g1 - g2) / torch.norm(g1))
    return gradient_change

# 定义一个计算梯度的函数
def compute_gradient_norm(gradients):
    gradient_norm = [torch.norm(g) for g in gradients if g is not None]
    return gradient_norm

# 定义一个训练函数
def train(net, optimizer, x, num_epochs=1000):
    for epoch in range(num_epochs):
        optimizer.zero_grad()
        y = net(x)
        loss = torch.sum(y)
        loss.backward()
        optimizer.step()

# 构造输入数据
x = torch.linspace(-1, 1, 100).reshape(-1, 1)

# 计算梯度变化
net1 = Net()
net2 = Net()
gradients1 = compute_gradient(net1, x)
optimizer1 = torch.optim.SGD(net1.parameters(), lr=0.1)
train(net1, optimizer1, x, num_epochs=100)
gradients2 = compute_gradient(net1, x)
# 计算梯度变化
gradient_change1 = compute_gradient_change(gradients1, gradients2)

# 计算梯度范数
gradient_norm1 = compute_gradient_norm(gradients2)

# 修改激活函数为sigmoid
class NetSigmoid(nn.Module):
    def __init__(self):
        super(NetSigmoid, self).__init__()
        self.fc1 = nn.Linear(1, 10)
        self.fc2 = nn.Linear(10, 10)
        self.fc3 = nn.Linear(10, 10)
        self.fc4 = nn.Linear(10, 10)
        self.fc5 = nn.Linear(10, 1)

    def forward(self, x):
        x = torch.sigmoid(self.fc1(x))
        x = torch.sigmoid(self.fc2(x))
        x = torch.sigmoid(self.fc3(x))
        x = torch.sigmoid(self.fc4(x))
        x = self.fc5(x)
        return x

# 计算梯度变化
net3 = NetSigmoid()
gradients1 = compute_gradient(net3, x)
optimizer3 = torch.optim.SGD(net3.parameters(), lr=0.1)
train(net3, optimizer3, x, num_epochs=100)
gradients2 = compute_gradient(net3, x)
gradient_change2 = compute_gradient_change(gradients1, gradients2)

# 计算梯度范数
gradient_norm2 = compute_gradient_norm(gradients2)

print('Gradient change (ReLU):', gradient_change1)
print('Gradient norm (ReLU):', gradient_norm1)
print('Gradient change (sigmoid):', gradient_change2)
print('Gradient norm (sigmoid):', gradient_norm2)

输出结果：

Gradient change (ReLU): [tensor(nan), tensor(nan), tensor(nan), tensor(nan), tensor(nan), tensor(nan), tensor(nan), tensor(nan), tensor(nan), tensor(0.)]
Gradient norm (ReLU): [tensor(nan), tensor(nan), tensor(nan), tensor(nan), tensor(nan), tensor(nan), tensor(nan), tensor(nan), tensor(nan), tensor(200.)]
Gradient change (sigmoid): [tensor(0.), tensor(0.), tensor(0.), tensor(0.), tensor(0.), tensor(0.), tensor(0.), tensor(0.), tensor(0.), tensor(0.)]
Gradient norm (sigmoid): [tensor(6.4147e-05), tensor(0.0017), tensor(0.0174), tensor(0.0106), tensor(0.0838), tensor(0.0480), tensor(0.1575), tensor(0.0573), tensor(632.4555), tensor(200.)]

前两行输出是梯度爆炸的效果，后两行是梯度消失的效果，具体含义可结合代码了解
使用sigmoid。当梯度消失发生时，接近于输出层的隐藏层由于其梯度相对正常，所以权值更新时也就相对正常，但是当越靠近输入层时，由于梯度消失现象，会导致靠近输入层的隐藏层权值更新缓慢或者更新停滞。这就导致在训练时，只等价于后面几层的浅层网络的学习。

---