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

1次阅读

没有评论

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

在开始讨论误差反向传播（Backpropagation，简称 BP）算法之前，我们需要先理解神经网络的基本工作原理。神经网络由多层神经元组成，通常包括输入层、隐藏层和输出层。每一层的神经元通过权重和偏置与下一层的神经元相连。

前向传播 ：这是神经网络进行预测的过程。输入数据从输入层开始，经过每一层的权重和激活函数的变换，最终到达输出层。前向传播可以用以下公式表示：

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

其中，$a^{(l)}$ 是第 $l$ 层的激活值，$f$ 是激活函数，$W^{(l)}$ 是权重矩阵，$b^{(l)}$ 是偏置向量。

反向传播 ：这是神经网络学习的过程。通过计算预测值与真实值之间的误差，然后将这个误差从输出层反向传播到输入层，调整每一层的权重和偏置，以最小化误差。

误差反向传播的核心是链式法则（Chain Rule），用于计算损失函数对每一层权重和偏置的梯度。以下是详细的推导过程：

定义损失函数 ：常用的损失函数包括均方误差（MSE）和交叉熵损失。以 MSE 为例：

$$ L = \frac{1}{2} \sum_{i=1}^{n} (y_i – \hat{y}_i)^2 $$

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

$$ \frac{\partial L}{\partial a^{(L)}} = \hat{y} – y $$

然后通过链式法则计算损失函数对输出层权重和偏置的梯度：

$$ \frac{\partial L}{\partial W^{(L)}} = \frac{\partial L}{\partial a^{(L)}} \cdot \frac{\partial a^{(L)}}{\partial z^{(L)}} \cdot \frac{\partial z^{(L)}}{\partial W^{(L)}} $$

$$ \frac{\partial L}{\partial b^{(L)}} = \frac{\partial L}{\partial a^{(L)}} \cdot \frac{\partial a^{(L)}}{\partial z^{(L)}} \cdot \frac{\partial z^{(L)}}{\partial b^{(L)}} $$

隐藏层的梯度计算 ：对于第 $l$ 层，梯度计算需要用到第 $l+1$ 层的梯度：

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

其中，$\delta^{(l)}$ 是第 $l$ 层的误差项，$\odot$ 表示逐元素乘法。

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

import numpy as np

class NeuralNetwork:
    def __init__(self, layers):
        """
        初始化神经网络
        :param layers: 每层的神经元数量，例如 [2, 3, 1] 表示输入层 2 个神经元，隐藏层 3 个，输出层 1 个
        """
        self.layers = layers
        self.weights = [np.random.randn(layers[i], layers[i-1]) for i in range(1, len(layers))]
        self.biases = [np.random.randn(layers[i], 1) for i in range(1, len(layers))]

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

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

    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 train(self, X, y, epochs, learning_rate):
        """训练网络"""
        for epoch in range(epochs):
            for x, target in zip(X, y):
                # 前向传播
                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] - target) * 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.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 算法的时间复杂度主要取决于前向传播和反向传播的计算量。对于一个具有 $L$ 层、每层 $n$ 个神经元的网络，前向传播的时间复杂度为 $O(L \cdot n^2)$，反向传播的时间复杂度也是 $O(L \cdot n^2)$。因此，总的时间复杂度为 $O(L \cdot n^2)$。