当前位置：首页 > news >正文

手撕反向传播：从计算图到代码，彻底搞懂神经网络凭什么“知错能改”

news 2026/6/9 7:38:56

别再只会调包了！一文带你彻底搞懂BP算法的前世今生，附可运行代码

你有没有想过：当你告诉一个神经网络“你猜错了”，它是怎么知道应该怪罪哪个神经元、哪条连接的呢？
一个几百层的网络，几百万个参数，误差信号到底该如何逆流而上，精准地给每个参数指明“改进方向”？

这个问题的答案，就是今天的主角——反向传播（Backpropagation）。

本文不堆砌晦涩公式，而是从一张购物小票的计算图开始，一路手写代码，实现一个完整的二层神经网络。跟着我走完这一程，你会发现：反向传播，原来如此简单。

一、计算图：把数学算式变成“水管线路”

先看一个生活场景：你买了100件衣服（每件2元）和150条裤子（每条3元），总价多少？

100 × 2 + 150 × 3 = 650

我们可以把这段计算画成一张图，每个圆圈代表一个运算，箭头代表数据流动：

这就是计算图——把复杂计算拆成一个个简单的小节点，每个节点只干一件事：拿到输入，算出输出，传给下家。

1.1 前向传播：顺着箭头算出结果

从左边输入开始，一步步向右推进，直到得到最终结果。这个过程就叫前向传播。

如果你再给总价加个10%的涨价系数，图就变长了：

前向传播很简单，就是按顺序计算。但它的真正威力在于：我们可以沿着同样的图，反着走一遍，就能知道每个变量对最终结果的影响有多大。

这就是反向传播。

二、链式法则：反向传播的“导航地图”

如果我们想知道“衣服单价上涨1元，最终付款会变多少”，其实就是求导数。

在计算图上，我们从最右边开始，向左反向传播，每经过一个节点就乘上该节点的局部导数。这个规则就是微积分里的链式法则。

举个经典例子：z = (x + y)²

先令u = x + y，则z = u²。
导数关系：∂z/∂x = (∂z/∂u) × (∂u/∂x) = 2u × 1 = 2(x+y)。

画成计算图：

反向传播时，从z出发，先经过平方节点（导数为2u），再经过加法节点（导数为1），最终得到∂z/∂x和∂z/∂y。

一句话总结：反向传播就是把上游传来的梯度，乘上当前节点的局部导数，再传给下游。

三、基础运算节点的反向传播规则

3.1 加法节点：我是“分流器”

对于z = x + y，有∂z/∂x = 1，∂z/∂y = 1。

加法节点的反向传播：上游梯度原样复制给两个分支。

def add_backward(dout): dx = dout * 1.0 dy = dout * 1.0 return dx, dy

3.2 乘法节点：我是“交换乘”

对于z = x × y，有∂z/∂x = y，∂z/∂y = x。

乘法节点的反向传播：上游梯度乘以另一个输入的值，然后传给对方。

def mul_backward(x, y, dout): dx = dout * y dy = dout * x return dx, dy

小提示：在神经网络里，全连接层的反向传播就是乘法节点在矩阵版本下的推广。

四、激活函数的反向传播（带代码实现）

激活函数是神经网络引入非线性的关键。我们来实现最常用的两个：ReLU和Sigmoid。

4.1 ReLU：简单粗暴，负值“杀死”

ReLU函数：f(x) = max(0, x)
导数：x ≤ 0 时导数为 0，x > 0 时导数为 1。

反向传播时，只需把上游梯度中对应于前向输入 ≤0 的位置置零。

class Relu: def __init__(self): self.mask = None # 记录哪些位置 <=0 def forward(self, x): self.mask = (x <= 0) # True 表示该位置需要阻断 out = x.copy() out[self.mask] = 0 return out def backward(self, dout): dout[self.mask] = 0 # 梯度清零 dx = dout return dx

4.2 Sigmoid：优雅的“S”曲线

Sigmoid函数：f(x) = 1 / (1 + e^{-x})
它的导数有一个漂亮的形式：f'(x) = f(x) × (1 - f(x))。

这意味着反向传播时，我们可以直接复用前向传播的输出值，不用重新计算指数。

class Sigmoid: def __init__(self): self.out = None def forward(self, x): self.out = 1 / (1 + np.exp(-x)) return self.out def backward(self, dout): dx = dout * (1.0 - self.out) * self.out return dx

为什么Sigmoid曾经很流行？因为它输出范围在(0,1)，适合作为概率。但缺点是容易导致梯度消失，现在很多场合被ReLU取代。

五、Affine层（全连接层）的反向传播：矩阵版乘法

全连接层的数学形式：Y = X·W + b
其中X是输入矩阵（N×m），W是权重矩阵（m×n），b是偏置（1×n，会广播到每一行）。

反向传播的公式（设E = ∂L/∂Y）：

∂L/∂X = E·Wᵀ
∂L/∂W = Xᵀ·E
∂L/∂b = 对 E 的行求和
（因为前向时 b 被广播了）

class Affine: def __init__(self, W, b): self.W = W self.b = b self.x = None self.dW = None self.db = None def forward(self, x): self.x = x.reshape(x.shape[0], -1) # 展平 out = np.dot(self.x, self.W) + self.b return out def backward(self, dout): dx = np.dot(dout, self.W.T) self.dW = np.dot(self.x.T, dout) self.db = np.sum(dout, axis=0) dx = dx.reshape(*self.original_x_shape) # 恢复原形状 return dx

形状检查（举例）：

X: (64, 784)，W: (784, 10) → Y: (64, 10)
dout: (64, 10) → dW = Xᵀ·dout = (784,64)×(64,10) = (784,10) ✅
db = sum(dout, axis=0) = (10,) ✅

六、输出层：Softmax + 交叉熵损失的“终极简化”

在分类任务中，输出层通常用Softmax将得分转为概率，再用交叉熵损失计算误差。

Softmax公式：
y_k = e^{x_k} / Σ_j e^{x_j}

交叉熵损失：
L = - Σ t_k log(y_k)，其中t是 one-hot 真实标签。

当我们将 Softmax 和交叉熵合并成一个层时，反向传播的梯度会出奇地简单：

∂L/∂x = y - t

也就是说，上游梯度直接等于预测概率减去真实标签，再除以 batch_size 取平均。

而对于输出层，一般会直接将结果代入损失函数的计算。对于我们之前介绍的分类问题，这里选择交叉熵误差（Cross Entropy Error）作为损失函数，就可以得到一个Softmax-with-Loss层，它包含了Softmax和Cross Entropy Loss两部分。

导数的计算会比较复杂，可以用计算图表示如下：

简化得：

在代码中可以实现为一个类 SoftmaxWithLoss：

class SoftmaxWithLoss: def __init__(self): self.loss = None self.y = None # softmax 输出 self.t = None # 真实标签（one-hot） def forward(self, x, t): self.t = t self.y = softmax(x) # 假设 softmax 已实现 self.loss = cross_entropy_error(self.y, self.t) return self.loss def backward(self, dout=1): batch_size = self.t.shape[0] dx = (self.y - self.t) / batch_size return dx

这个简洁的结果是反向传播中最美的公式之一——它直接把“误差”定义为“预测减去真相”。

七、组装一个完整的二层神经网络

现在我们把所有层串起来，搭建一个用于MNIST手写数字识别的两层网络：

隐藏层：Affine → ReLU
输出层：Affine → SoftmaxWithLoss

import numpy as np from collections import OrderedDict class TwoLayerNet: def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01): # 初始化参数 self.params = {} self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size) self.params['b1'] = np.zeros(hidden_size) self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size) self.params['b2'] = np.zeros(output_size) # 构建层（有序字典保证前向/反向顺序） self.layers = OrderedDict() self.layers['Affine1'] = Affine(self.params['W1'], self.params['b1']) self.layers['Relu1'] = Relu() self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2']) self.last_layer = SoftmaxWithLoss() def predict(self, x): for layer in self.layers.values(): x = layer.forward(x) return x def loss(self, x, t): y = self.predict(x) return self.last_layer.forward(y, t) def gradient(self, x, t): # 前向传播 self.loss(x, t) # 反向传播 dout = 1 dout = self.last_layer.backward(dout) layers_rev = list(self.layers.values()) layers_rev.reverse() for layer in layers_rev: dout = layer.backward(dout) # 收集梯度 grads = {} grads['W1'] = self.layers['Affine1'].dW grads['b1'] = self.layers['Affine1'].db grads['W2'] = self.layers['Affine2'].dW grads['b2'] = self.layers['Affine2'].db return grads

使用方式：

net = TwoLayerNet(784, 50, 10) x_batch, t_batch = get_mini_batch() # 获取一批数据 grads = net.gradient(x_batch, t_batch) # 一次反向传播算出所有梯度 # 然后用 SGD 等优化器更新 net.params

注意：上面代码中的 softmax、cross_entropy_error 以及数值梯度函数需要你自己补充，这里为了聚焦主题，不再展开。