BP神经网络反向传播过程详解：从数学推导到Python实现

1次阅读

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

反向传播的核心在于链式法则的应用。设网络有 $L$ 层，第 $l$ 层权重为 $W^l$，偏置为 $b^l$，激活函数为 $\sigma(\cdot)$。定义损失函数 $J$ 对第 $l$ 层参数的梯度为：

输出层梯度计算

对于输出层 $L$，首先计算损失函数对输出的偏导：
$$\frac{\partial J}{\partial a^L} = \nabla J(a^L)$$
其中 $a^L$ 为输出层激活值。

隐藏层梯度传播

通过链式法则逐层回传误差：
$$\delta^l = ((W^{l+1})^T \delta^{l+1}) \odot \sigma'(z^l)$$
这里 $z^l$ 为第 $l$ 层的加权输入，$\odot$ 表示 Hadamard 积。

参数更新公式

最终得到权重和偏置的更新量：
$$\frac{\partial J}{\partial W^l} = \delta^l (a^{l-1})^T$$
$$\frac{\partial J}{\partial b^l} = \delta^l$$

SGD：直接使用当前 batch 的梯度更新参数
$$\theta_{t+1} = \theta_t – \eta \nabla J(\theta_t)$$
Momentum：引入动量项积累历史梯度
$$v_{t+1} = \gamma v_t + \eta \nabla J(\theta_t)$$
$$\theta_{t+1} = \theta_t – v_{t+1}$$

import numpy as np

class NeuralNetwork:
    def __init__(self, layers):
        # 初始化权重和偏置
        self.weights = [np.random.randn(y, x)*0.01 
                        for x, y in zip(layers[:-1], layers[1:])]
        self.biases = [np.zeros((y, 1)) for y in layers[1:]]

    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 backward(self, x, y):
        """反向传播"""
        # 初始化梯度容器
        grad_w = [np.zeros_like(w) for w in self.weights]
        grad_b = [np.zeros_like(b) for b in self.biases]

        # 前向计算并保存中间结果
        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)

        # 输出层误差
        delta = (activations[-1] - y) * self.sigmoid_prime(zs[-1])
        grad_b[-1] = delta
        grad_w[-1] = np.dot(delta, activations[-2].T)

        # 反向传播误差
        for l in range(2, len(self.weights)+1):
            z = zs[-l]
            delta = np.dot(self.weights[-l+1].T, delta) * self.sigmoid_prime(z)
            grad_b[-l] = delta
            grad_w[-l] = np.dot(delta, activations[-l-1].T)

        return grad_w, grad_b

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

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