深入解析BP神经网络的前向传播与反向传播计算过程

1次阅读

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

BP 神经网络（Backpropagation Neural Network）是一种多层前馈神经网络，通过反向传播算法来调整网络权重，广泛应用于分类、回归等任务。它的核心思想是通过前向传播计算输出，然后通过反向传播调整权重，逐步降低预测误差。

前向传播是指输入数据从输入层经过隐藏层传递到输出层的过程。假设网络有 L 层，第 l 层的输出为：

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

其中，$f$ 为激活函数，$W^{(l)}$ 和 $b^{(l)}$ 分别为第 l 层的权重和偏置。

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

$$
J(W, b) = \frac{1}{2m} \sum_{i=1}^{m} (y_i – a^{(L)}_i)^2
$$

其中，$m$ 为样本数量，$y_i$ 为真实标签，$a^{(L)}_i$ 为网络输出。

反向传播的核心是通过链式法则计算损失函数对每一层参数的梯度。具体步骤如下：

计算输出层的误差：

$$
\delta^{(L)} = (a^{(L)} – y) \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}, \quad \frac{\partial J}{\partial b^{(l)}} = \delta^{(l)}
$$

以下是使用 NumPy 实现 BP 算法的完整代码：

import numpy as np

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

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

    def sigmoid_prime(self, z):
        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):
        # Forward pass
        a = x
        activations = [x]
        zs = []
        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)

        # 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.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

        # Update weights and biases
        self.weights = [w - self.learning_rate * nw for w, nw in zip(self.weights, nabla_w)]
        self.biases = [b - self.learning_rate * nb for b, nb in zip(self.biases, nabla_b)]

学习率过大可能导致震荡，过小则收敛缓慢。建议使用动态学习率或自适应优化算法（如 Adam）。