深入解析BP神经网络中的梯度下降与链式法则：从数学原理到代码实现

1次阅读

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

在传统的机器学习中，BP（Back Propagation）神经网络通过反向传播算法来优化权重参数。然而，初学者常常会遇到两个主要问题：

计算效率低下 ：使用数值微分法（如中心差分）计算梯度时，需要对每个参数进行两次前向传播，计算复杂度为 O(n^2)，对于大规模网络几乎不可行。
梯度不稳定 ：手动实现反向传播时，容易出现梯度消失（Gradient Vanishing）或梯度爆炸（Gradient Explosion）现象，尤其是在深层网络中，这使得训练过程难以收敛。

BP 神经网络的核心在于链式法则（Chain Rule），它允许我们将复杂的梯度计算分解为多个简单的偏导数的乘积。假设我们有一个简单的多层感知机（MLP），其损失函数为 L，第 l 层的输出为 a^l，权重为 W^l，偏置为 b^l，激活函数为 σ。那么，反向传播的梯度可以表示为：

$$
\frac{\partial L}{\partial W^l} = \frac{\partial L}{\partial a^{l+1}} \cdot \frac{\partial a^{l+1}}{\partial z^{l+1}} \cdot \frac{\partial z^{l+1}}{\partial W^l}
$$

其中，z^{l+1} = W^l \cdot a^l + b^l。通过链式法则，我们可以逐层计算梯度，从而高效地更新权重。

下面是一个基于 Python 的 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(layers[i], layers[i+1]) * 0.01 for i in range(len(layers)-1)]
        self.biases = [np.zeros((1, layers[i+1])) for i in range(len(layers)-1)]

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

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

    def forward(self, X):
        self.activations = [X]
        self.z_values = []
        for w, b in zip(self.weights, self.biases):
            z = np.dot(self.activations[-1], w) + b
            self.z_values.append(z)
            a = self.sigmoid(z)
            self.activations.append(a)
        return self.activations[-1]

    def backward(self, X, y, output):
        m = X.shape[0]
        delta = (output - y) * self.sigmoid_derivative(output)
        for i in reversed(range(len(self.weights))):
            dw = np.dot(self.activations[i].T, delta) / m
            db = np.sum(delta, axis=0, keepdims=True) / m
            if i > 0:
                delta = np.dot(delta, self.weights[i].T) * self.sigmoid_derivative(self.activations[i])
            self.weights[i] -= self.learning_rate * dw
            self.biases[i] -= self.learning_rate * db

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