深入解析BP算法：正向传播与反向传播的实现原理与优化实践

1次阅读

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

BP（Backpropagation）算法是训练神经网络的核心方法，它通过不断调整网络参数（权重和偏置）来最小化预测误差。这个过程分为两个主要阶段：正向传播（Forward Propagation）和反向传播（Backward Propagation）。

正向传播 ：输入数据从输入层经过隐藏层传递到输出层，计算每一层的输出值。
反向传播 ：从输出层开始，反向计算误差对每个参数的梯度，并使用梯度下降法更新参数。

BP 算法的关键在于链式求导法则，它使得误差能够从输出层逐层反向传播到输入层，从而高效地计算所有参数的梯度。

正向传播是神经网络对输入数据进行处理并生成输出的过程。具体步骤如下：

输入层到第一隐藏层 ：输入数据 $X$ 与第一层的权重 $W^1$ 和偏置 $b^1$ 相乘，然后通过激活函数 $f$ 得到第一隐藏层的输出 $A^1$。
$$
Z^1 = W^1 X + b^1 \
A^1 = f(Z^1)
$$
隐藏层到隐藏层 ：前一层的输出 $A^{l-1}$ 与当前层的权重 $W^l$ 和偏置 $b^l$ 相乘，再通过激活函数得到当前层的输出 $A^l$。
$$
Z^l = W^l A^{l-1} + b^l \
A^l = f(Z^l)
$$
隐藏层到输出层 ：最后一层的输出 $A^{L-1}$ 与输出层的权重 $W^L$ 和偏置 $b^L$ 相乘，通过输出层的激活函数（如 Softmax）得到最终的预测值 $\hat{Y}$。
$$
Z^L = W^L A^{L-1} + b^L \
\hat{Y} = g(Z^L)
$$

激活函数的选择 ：常用的激活函数包括 Sigmoid、ReLU 和 Tanh。ReLU 因其简单和高效（避免梯度消失）成为隐藏层的首选，而输出层通常根据任务类型选择（如二分类用 Sigmoid，多分类用 Softmax）。

反向传播的核心是通过链式法则计算损失函数对每个参数的梯度。以均方误差（MSE）为例，损失函数为：
$$
L = \frac{1}{2} (Y – \hat{Y})^2
$$

输出层梯度 ：首先计算损失对输出层输入的梯度 $\frac{\partial L}{\partial Z^L}$。
$$
\frac{\partial L}{\partial Z^L} = (\hat{Y} – Y) \cdot g'(Z^L)
$$
然后计算权重和偏置的梯度：
$$
\frac{\partial L}{\partial W^L} = \frac{\partial L}{\partial Z^L} A^{L-1} \
\frac{\partial L}{\partial b^L} = \frac{\partial L}{\partial Z^L}
$$
隐藏层梯度 ：对于第 $l$ 层，梯度计算如下：
$$
\frac{\partial L}{\partial Z^l} = (W^{l+1})^T \frac{\partial L}{\partial Z^{l+1}} \cdot f'(Z^l) \
\frac{\partial L}{\partial W^l} = \frac{\partial L}{\partial Z^l} A^{l-1} \
\frac{\partial L}{\partial b^l} = \frac{\partial L}{\partial Z^l}
$$
参数更新 ：使用梯度下降法更新参数，学习率为 $\eta$：
$$
W^l = W^l – \eta \frac{\partial L}{\partial W^l} \
b^l = b^l – \eta \frac{\partial L}{\partial b^l}
$$

以下是一个简单的 BP 神经网络实现，用于二分类任务：

import numpy as np

class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        self.W1 = np.random.randn(input_size, hidden_size) * 0.01
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) * 0.01
        self.b2 = np.zeros((1, output_size))

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

    def sigmoid_derivative(self, x):
        return x * (1 - x)

    def forward(self, X):
        self.Z1 = np.dot(X, self.W1) + self.b1
        self.A1 = self.sigmoid(self.Z1)
        self.Z2 = np.dot(self.A1, self.W2) + self.b2
        self.A2 = self.sigmoid(self.Z2)
        return self.A2

    def backward(self, X, y, learning_rate):
        m = X.shape[0]

        # 输出层梯度
        dZ2 = self.A2 - y
        dW2 = np.dot(self.A1.T, dZ2) / m
        db2 = np.sum(dZ2, axis=0, keepdims=True) / m

        # 隐藏层梯度
        dZ1 = np.dot(dZ2, self.W2.T) * self.sigmoid_derivative(self.A1)
        dW1 = np.dot(X.T, dZ1) / m
        db1 = np.sum(dZ1, axis=0, keepdims=True) / m

        # 参数更新
        self.W2 -= learning_rate * dW2
        self.b2 -= learning_rate * db2
        self.W1 -= learning_rate * dW1
        self.b1 -= learning_rate * db1

    def train(self, X, y, epochs, learning_rate):
        for epoch in range(epochs):
            output = self.forward(X)
            self.backward(X, y, learning_rate)
            if epoch % 100 == 0:
                loss = np.mean((output - y) ** 2)
                print(f'Epoch {epoch}, Loss: {loss:.4f}')