深入解析BP反向传播梯度：从数学原理到代码实现

1次阅读

共计 2587 个字符，预计需要花费 7 分钟才能阅读完成。

在神经网络的训练过程中，我们通常使用梯度下降法来最小化损失函数。而梯度计算的核心就是反向传播算法（Backpropagation，简称 BP）。BP 算法通过链式法则高效地计算网络中每个参数的梯度，使得神经网络能够通过调整权重来逐步优化性能。

没有准确的梯度计算，优化过程就如同盲人摸象。梯度告诉我们应该如何调整参数才能使损失函数下降，这是神经网络能够学习的关键所在。

BP 算法的核心是链式法则。让我们以一个简单的全连接网络为例，推导梯度计算的数学过程。

假设我们有一个三层网络（输入层、隐藏层、输出层），其前向传播过程可以表示为：

隐藏层输出：$h = \sigma(W_1x + b_1)$
输出层输出：$y = W_2h + b_2$
损失函数：$L = \frac{1}{2}(y – t)^2$（其中 t 是目标值）

反向传播时，我们需要计算损失对各参数的梯度：

首先计算损失对输出的梯度：$\frac{\partial L}{\partial y} = y – t$
然后计算输出层权重的梯度：
$\frac{\partial L}{\partial W_2} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial W_2} = (y-t)h^T$
计算隐藏层输出的梯度：
$\frac{\partial L}{\partial h} = W_2^T(y-t)$
最后计算隐藏层权重的梯度：
$\frac{\partial L}{\partial W_1} = \frac{\partial L}{\partial h} \odot \sigma'(W_1x+b_1) \cdot x^T$

这个推导过程展示了 BP 算法如何通过层层反向传播误差信号来计算梯度。

下面是一个简单的 NumPy 实现，展示了完整的前向传播和反向传播过程：

import numpy as np

class TwoLayerNet:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重
        self.W1 = np.random.randn(input_size, hidden_size) * 0.01
        self.b1 = np.zeros(hidden_size)
        self.W2 = np.random.randn(hidden_size, output_size) * 0.01
        self.b2 = np.zeros(output_size)

    def forward(self, x):
        # 前向传播
        self.z1 = np.dot(x, self.W1) + self.b1
        self.h = self.sigmoid(self.z1)
        self.y = np.dot(self.h, self.W2) + self.b2
        return self.y

    def backward(self, x, y, t, learning_rate=0.01):
        # 反向传播
        m = x.shape[0]  # 样本数量

        # 输出层梯度
        dy = (y - t) / m
        dW2 = np.dot(self.h.T, dy)
        db2 = np.sum(dy, axis=0)

        # 隐藏层梯度
        dh = np.dot(dy, self.W2.T)
        dz1 = dh * self.sigmoid_derivative(self.z1)
        dW1 = np.dot(x.T, dz1)
        db1 = np.sum(dz1, axis=0)

        # 更新参数
        self.W2 -= learning_rate * dW2
        self.b2 -= learning_rate * db2
        self.W1 -= learning_rate * dW1
        self.b1 -= learning_rate * db1

    def sigmoid(self, z):
        return 1 / (1 + np.exp(-z))

    def sigmoid_derivative(self, z):
        s = self.sigmoid(z)
        return s * (1 - s)

# 使用示例
net = TwoLayerNet(2, 4, 1)
x = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])  # 输入
t = np.array([[0], [1], [1], [0]])              # 目标输出

# 训练循环
for epoch in range(10000):
    y = net.forward(x)
    net.backward(x, y, t)
    if epoch % 1000 == 0:
        loss = np.mean((y - t)**2)
        print(f'Epoch {epoch}, Loss: {loss:.4f}')

当网络较深时，梯度在反向传播过程中可能会变得极小（消失）或极大（爆炸）。这主要是由于激活函数的导数连乘导致的。

解决方案：