深入解析BP神经网络中的误差反向传播算法：从数学原理到代码实现

1次阅读

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

神经网络模拟人脑神经元的工作方式，通过大量简单的计算单元相互连接进行信息处理。一个典型的神经网络包含输入层、隐藏层和输出层，层与层之间通过权重连接。数据从输入层流向输出层的过程称为前向传播（Forward Propagation），而误差反向传播（Backpropagation）则是调整权重的关键算法。

前向传播的计算过程可以表示为：

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

$$
a^{(l)} = \sigma(z^{(l)})
$$

其中，$z^{(l)}$ 表示第 $l$ 层的加权输入，$W^{(l)}$ 是权重矩阵，$b^{(l)}$ 是偏置向量，$a^{(l)}$ 是激活值，$\sigma$ 是激活函数。

反向传播算法的核心是链式法则，通过计算损失函数对每个权重的梯度来更新网络参数。算法分为三个主要步骤：

前向传播计算输出
计算输出层误差
反向传播误差并更新权重

以均方误差损失函数为例：

$$
L = \frac{1}{2} \sum (y – a^{(L)})^2
$$

输出层的误差为：

$$
\delta^{(L)} = \frac{\partial L}{\partial a^{(L)}} \cdot \sigma'(z^{(L)}) = (a^{(L)} – y) \cdot \sigma'(z^{(L)})
$$

隐藏层的误差通过链式法则反向传播：

$$
\delta^{(l)} = ((W^{(l+1)})^T \delta^{(l+1)}) \cdot \sigma'(z^{(l)})
$$

权重和偏置的梯度则为：

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

$$
\frac{\partial L}{\partial b^{(l)}} = \delta^{(l)}
$$

以下是 BP 神经网络的 Python 实现，包含 Sigmoid 激活函数和均方误差损失函数：

import numpy as np
from typing import List, Tuple

class NeuralNetwork:
    def __init__(self, layer_sizes: List[int]):
        """
        初始化神经网络
        :param layer_sizes: 每层的神经元数量，如 [2,3,1] 表示输入层 2 个，隐藏层 3 个，输出层 1 个
        """
        self.layer_sizes = layer_sizes
        self.num_layers = len(layer_sizes)

        # 初始化权重和偏置
        self.weights = [np.random.randn(y, x) for x, y in zip(layer_sizes[:-1], layer_sizes[1:])]
        self.biases = [np.random.randn(y, 1) for y in layer_sizes[1:]]

    def sigmoid(self, z: np.ndarray) -> np.ndarray:
        """Sigmoid 激活函数"""
        return 1 / (1 + np.exp(-z))

    def sigmoid_prime(self, z: np.ndarray) -> np.ndarray:
        """Sigmoid 函数的导数"""
        s = self.sigmoid(z)
        return s * (1 - s)

    def forward(self, x: np.ndarray) -> np.ndarray:
        """前向传播"""
        a = x
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, a) + b
            a = self.sigmoid(z)
        return a

    def train(self, X: np.ndarray, y: np.ndarray, epochs: int, learning_rate: float):
        """训练神经网络"""
        for epoch in range(epochs):
            # 前向传播
            activations = [X]
            zs = []
            for w, b in zip(self.weights, self.biases):
                z = np.dot(w, activations[-1]) + b
                zs.append(z)
                activations.append(self.sigmoid(z))

            # 反向传播
            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, self.num_layers):
                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

            # 更新权重和偏置
            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)]

BP 算法的时间复杂度主要取决于：