BP神经网络计算：从数学原理到Python实现

1次阅读

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

BP 神经网络就像学习骑自行车时的纠错机制。当你刚开始骑车时，身体会根据车把的偏转角度不断调整重心（反向传播误差），最终找到平衡点（收敛）。这种通过误差反馈来调整内部参数的方式，正是现代深度学习的基础范式。

前向传播本质是矩阵的连续变换，用 LaTeX 表示第 $l$ 层输出：
$$\mathbf{a}^{[l]} = \sigma(\mathbf{W}^{[l]}\mathbf{a}^{[l-1]} + \mathbf{b}^{[l]})$$
其中 $\sigma$ 是激活函数，常见的 Sigmoid 函数为：
$$\sigma(z) = \frac{1}{1+e^{-z}}$$

以平方误差损失 $L = \frac{1}{2}(y-\hat{y})^2$ 为例，输出层梯度：
$$\frac{\partial L}{\partial \mathbf{W}^{[L]}} = (\hat{y}-y) \odot \sigma'(z^{[L]}) \cdot \mathbf{a}^{[L-1]T}$$
这个公式就像多米诺骨牌，误差从输出层逐层向前传递。

学习率 $\eta$ 相当于下山的步长：
– 步长太大（左图）会震荡不收敛
– 步长太小（右图）收敛缓慢

  ↑ loss                     ↑ loss
  | *  *                     |   *
  |*    *                    |  * 
  |______> epoch             |______> epoch

import numpy as np

class ThreeLayerNet:
    def __init__(self, input_size, hidden_size, output_size):
        # He 初始化更适合 ReLU 激活
        self.W1 = np.random.randn(input_size, hidden_size) * np.sqrt(2./input_size)
        self.b1 = np.zeros(hidden_size)
        self.W2 = np.random.randn(hidden_size, output_size) * np.sqrt(2./hidden_size)
        self.b2 = np.zeros(output_size)

数值梯度与解析梯度对比是调试的金标准：

def grad_check(inputs, targets, net, epsilon=1e-7):
    # 计算解析梯度
    analytic_grad = net.backward(inputs, targets)

    # 计算数值梯度
    params = net.get_params()
    num_grad = np.zeros_like(params)
    for i in range(len(params)):
        params[i] += epsilon
        loss_plus = net.forward(inputs, targets)
        params[i] -= 2*epsilon
        loss_minus = net.forward(inputs, targets)
        num_grad[i] = (loss_plus - loss_minus) / (2*epsilon)
        params[i] += epsilon  # 恢复原值

    # 比较相对误差
    diff = np.linalg.norm(analytic_grad - num_grad) / np.linalg.norm(analytic_grad + num_grad)
    return diff < 1e-5  # 误差应小于 1e-5

方法	适用场景	初始化公式
Xavier	Sigmoid/tanh	$W \sim N(0, \sqrt{1/n_{in}})$
He	ReLU 家族	$W \sim N(0, \sqrt{2/n_{in}})$

class LearningRateScheduler:
    def __init__(self, initial_lr, decay_rate, decay_steps):
        self.lr = initial_lr
        self.decay_rate = decay_rate
        self.decay_steps = decay_steps
        self.steps = 0

    def step(self):
        self.steps += 1
        if self.steps % self.decay_steps == 0:
            self.lr *= self.decay_rate
        return self.lr

应在全连接层之后、激活函数之前插入 BN 层：

FC → BN → ReLU → Dropout

计算图优化 ：PyTorch/TensorFlow 通过构建计算图，可以自动分析运算依赖关系，实现并行计算和内存复用
自动微分对比 ：手动实现需要显式编写梯度公式，而自动微分只需定义前向计算，框架会自动构建反向图
内存效率问题 ：三层网络的内存复杂度为 $O(n^2)$，当隐藏层达到数千节点时需要考虑梯度检查点技术

在手动实现 BP 网络的过程中，最深的体会是：反向传播的数学推导看似复杂，但本质上就是系统地应用链式法则。通过这次从零实现，我真正理解了为什么 ReLU 比 Sigmoid 更不容易出现梯度消失——当输入 >0 时，ReLU 的导数为常数 1，梯度可以无损传递。建议每个深度学习实践者都尝试手动实现一次 BP 算法，这对理解框架底层原理大有裨益。

正文完