深入解析bp反向传播算法过程：从数学原理到代码实现

1次阅读

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

神经网络的核心是通过调整权重来最小化损失函数。想象一个盲人登山者：他需要根据脚下坡度（梯度）判断下一步方向。反向传播就是计算这个 ” 坡度 ” 的系统方法，它解决了传统机器学习中手工设计特征的局限性。

前向传播的局限性：单次前向传播只能得到当前预测结果，无法知道每个权重对误差的贡献度
链式法则的威力：通过反向逐层传递误差，可以高效计算所有参数的梯度
计算效率优势：相比数值微分法（通过微小扰动计算梯度），反向传播的复杂度与网络前向计算相当

设神经网络有 L 层，定义：
– $W^{(l)}$：第 l 层的权重矩阵
– $z^{(l)} = W^{(l)}a^{(l-1)} + b^{(l)}$：线性变换结果
– $a^{(l)} = \sigma(z^{(l)})$：激活后的输出
– $C$：损失函数（如 MSE 或交叉熵）

输出层误差计算：
$\delta^{(L)} = \nabla_a C \odot \sigma'(z^{(L)})$
反向传播误差：
$\delta^{(l)} = ((W^{(l+1)})^T \delta^{(l+1)}) \odot \sigma'(z^{(l)})$
参数梯度计算：
$\frac{\partial C}{\partial W^{(l)}} = \delta^{(l)} (a^{(l-1)})^T$
$\frac{\partial C}{\partial b^{(l)}} = \delta^{(l)}$

import numpy as np
from sklearn.datasets import load_digits

class NeuralNetwork:
    def __init__(self, layers):
        # 初始化权重和偏置
        self.weights = [np.random.randn(y, x)*0.1 
                        for x, y in zip(layers[:-1], layers[1:])]
        self.biases = [np.zeros((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):
        """前向传播"""
        for w, b in zip(self.weights, self.biases):
            x = self.sigmoid(np.dot(w, x) + b)
        return x

    def backward(self, x, y):
        """反向传播核心"""
        # 初始化梯度容器
        nabla_w = [np.zeros_like(w) for w in self.weights]
        nabla_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])
        nabla_b[-1] = delta
        nabla_w[-1] = np.dot(delta, activations[-2].T)

        for l in range(2, len(self.weights)+1):
            z = zs[-l]
            sp = self.sigmoid_prime(z)
            delta = np.dot(self.weights[-l+1].T, delta) * sp
            nabla_b[-l] = delta
            nabla_w[-l] = np.dot(delta, activations[-l-1].T)

        return nabla_w, nabla_b