BP神经网络误差反向传播推导：从数学原理到代码实现

1次阅读

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

BP 神经网络（Backpropagation Neural Network）是一种多层前馈神经网络，通过误差反向传播算法进行训练。反向传播算法是深度学习中最核心的训练方法之一，它通过计算损失函数对网络参数的梯度，并利用梯度下降法更新权重和偏置，从而最小化预测误差。

反向传播算法的优势在于能够高效地计算梯度，尤其适用于多层网络的训练。理解反向传播的数学原理，对于调试神经网络、设计新的网络结构以及优化训练过程都至关重要。

考虑一个具有 $L$ 层的神经网络，第 $l$ 层的权重矩阵为 $W^l$，偏置向量为 $b^l$，激活函数为 $f^l$。前向传播过程可以表示为：

$$
z^l = W^l a^{l-1} + b^l
$$
$$
a^l = f^l(z^l)
$$

其中，$a^0$ 是输入数据，$a^L$ 是网络的输出。

常用的损失函数包括均方误差（MSE）和交叉熵损失。以 MSE 为例，对于单个样本 $(x, y)$，损失函数为：

$$
J = \frac{1}{2} |y – a^L|^2
$$

反向传播的核心是计算损失函数对每一层参数的梯度。根据链式法则，我们可以从输出层开始，逐层计算梯度。

首先计算损失函数对输出层输入的梯度：

$$
\delta^L = \frac{\partial J}{\partial z^L} = \frac{\partial J}{\partial a^L} \cdot \frac{\partial a^L}{\partial z^L} = (a^L – y) \odot f’^L(z^L)
$$

其中，$\odot$ 表示逐元素相乘。

对于第 $l$ 层（$l < L$），梯度可以递归计算：

$$
\delta^l = \frac{\partial J}{\partial z^l} = \left((W^{l+1})^T \delta^{l+1} \right) \odot f’^l(z^l)
$$

有了 $\delta^l$ 后，可以计算损失函数对权重和偏置的梯度：

$$
\frac{\partial J}{\partial W^l} = \delta^l (a^{l-1})^T
$$
$$
\frac{\partial J}{\partial b^l} = \delta^l
$$

下面是一个简单的 BP 神经网络的 Python 实现，包含完整的反向传播代码：

import numpy as np

class NeuralNetwork:
    def __init__(self, layer_sizes):
        self.layer_sizes = layer_sizes
        self.weights = [np.random.randn(y, x) * 0.1 for x, y in zip(layer_sizes[:-1], layer_sizes[1:])]
        self.biases = [np.random.randn(y, 1) * 0.1 for y in layer_sizes[1:]]

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

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

    def forward(self, x):
        a = x
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, a) + b
            a = self.sigmoid(z)
        return a

    def backward(self, x, y):
        # 前向传播
        activations = [x]
        zs = []
        a = x
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, a) + b
            zs.append(z)
            a = self.sigmoid(z)
            activations.append(a)

        # 反向传播
        delta = (activations[-1] - y) * self.sigmoid_prime(zs[-1])
        nabla_w = [np.zeros(w.shape) for w in self.weights]
        nabla_b = [np.zeros(b.shape) for b in self.biases]
        nabla_w[-1] = np.dot(delta, activations[-2].T)
        nabla_b[-1] = delta

        for l in range(2, len(self.layer_sizes)):
            z = zs[-l]
            sp = self.sigmoid_prime(z)
            delta = np.dot(self.weights[-l+1].T, delta) * sp
            nabla_w[-l] = np.dot(delta, activations[-l-1].T)
            nabla_b[-l] = delta

        return nabla_w, nabla_b

    def update(self, nabla_w, nabla_b, learning_rate):
        self.weights = [w - learning_rate * nw for w, nw in zip(self.weights, nabla_w)]
        self.biases = [b - learning_rate * nb for b, nb in zip(self.biases, nabla_b)]

梯度消失和梯度爆炸是深度神经网络训练中的常见问题。梯度消失发生在深层网络中，当梯度通过多个层反向传播时，如果激活函数的导数小于 1，梯度会指数级减小，导致浅层网络参数更新缓慢。梯度爆炸则相反，当梯度通过多个层反向传播时，如果权重矩阵的值较大，梯度会指数级增大，导致参数更新过大，网络无法收敛。

解决方案包括：