深入解析BP神经网络误差反向传播：从数学原理到实现细节

1次阅读

没有评论

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

神经网络的前向传播过程可以简单描述为：输入数据通过层层网络结构，经过权重矩阵的线性变换和激活函数的非线性变换，最终得到输出结果。前向传播的数学表达式为：

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

其中，$a^{(l)}$ 表示第 $l$ 层的激活值，$z^{(l)}$ 表示第 $l$ 层的加权输入，$W^{(l)}$ 和 $b^{(l)}$ 分别表示第 $l$ 层的权重和偏置，$f$ 为激活函数。

前向传播完成后，我们需要衡量网络输出与真实标签之间的差异，这就是损失函数的作用。常见的损失函数包括均方误差（MSE）和交叉熵损失（Cross Entropy）。

误差反向传播（Backpropagation, BP）算法的核心是通过链式法则计算损失函数对各个参数的梯度。具体推导过程如下：

首先计算输出层的误差项 $\delta^{(L)}$：

$$
\delta^{(L)} = \frac{\partial J}{\partial z^{(L)}} = \frac{\partial J}{\partial a^{(L)}} \odot f'(z^{(L)})
$$

然后反向传播误差到隐藏层：

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

最后计算各参数的梯度：

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

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

import numpy as np

class NeuralNetwork:
    def __init__(self, layer_sizes):
        self.layer_sizes = 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):
        return 1.0 / (1.0 + np.exp(-z))

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

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

    def train(self, x, y, learning_rate=0.1):
        # Forward pass
        activation = x
        activations = [x]
        zs = []

        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, activation) + b
            zs.append(z)
            activation = self.sigmoid(z)
            activations.append(activation)

        # Backward pass
        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

        # Update weights
        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 算法的时间复杂度主要取决于两个方面：