AI反向传播算法入门指南：从数学原理到Python实现

1次阅读

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

反向传播算法是深度学习模型训练的引擎，它通过高效计算梯度让神经网络学会从错误中调整权重。没有反向传播，深度学习不会成为今天改变世界的技术。理解它的原理，是掌握神经网络核心运作机制的关键。

想象神经网络的计算过程像河流分支，数据从输入层流向输出层时，每个神经元都是汇合点。反向传播则是逆流而上的溯源过程：

计算图将网络拆解为基本运算节点（加法、乘法、激活函数）
链式法则告诉我们：下游梯度 = 上游梯度 × 局部梯度

以简单表达式 z = (x + y)^2 为例：

   x   y
    \ / 
     +   (加法节点)
     |
     ^2  (平方运算)
     |
     z

当已知 ∂L/∂z 时：
– ∂L/∂(x+y) = 2(x+y) × ∂L/∂z
– ∂L/∂x = ∂L/∂(x+y) × 1

以 Sigmoid 激活函数 σ(x)=1/(1+e^-x) 为例：

先计算函数本身的导数：
```
\frac{dσ}{dx} = σ(x)(1-σ(x))
```
当反向传播时，若上层传来梯度值 ∂L/∂σ：
```
\frac{∂L}{∂x} = \frac{∂L}{∂σ} × σ(x)(1-σ(x))
```

import numpy as np

class TwoLayerNet:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重（注意：对称初始化会导致学习失效）self.W1 = np.random.randn(input_size, hidden_size) * 0.01
        self.b1 = np.zeros(hidden_size)
        self.W2 = np.random.randn(hidden_size, output_size) * 0.01
        self.b2 = np.zeros(output_size)

    def forward(self, X):
        # 第一层计算
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = 1 / (1 + np.exp(-self.z1))  # Sigmoid 激活

        # 第二层计算
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        exp_scores = np.exp(self.z2 - np.max(self.z2, axis=1, keepdims=True))
        self.probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)  # Softmax
        return self.probs

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

        # 输出层梯度
        delta3 = self.probs
        delta3[range(num_examples), y] -= 1
        delta3 /= num_examples

        # 隐藏层梯度（注意 Sigmoid 导数）dW2 = np.dot(self.a1.T, delta3)
        db2 = np.sum(delta3, axis=0)
        delta2 = np.dot(delta3, self.W2.T) * (self.a1 * (1 - self.a1))

        # 输入层梯度
        dW1 = np.dot(X.T, delta2)
        db1 = np.sum(delta2, axis=0)

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

当出现以下现象时，可能遭遇梯度消失：
– 底层权重更新量接近 0
– 训练初期 loss 下降后很快停滞

解决方案：
– 改用 ReLU 等非饱和激活函数
– 使用残差连接（ResNet 思路）
– 合理的权重初始化（如 He 初始化）