神经网络反向传播手算详解：从三节点示例彻底搞懂梯度下降

1. 网络传播流程拆解：从一次“猜数字”说起

很多朋友学神经网络，上来就背公式：正向传播就是加权求和再过激活函数，反向传播就是链式法则求偏导。道理都懂，但一遇到多层网络、具体数字，就彻底懵了——梯度为什么这么算？权重到底怎么更新？更新完为什么网络就能变准？

我当年也是卡在这地方。后来一位前辈跟我说了句话，让我一下子通了：别把网络当黑盒，把它当一条流水线。正向传播是零件从前往后走，反向传播是“追责”信号从后往前传——每一道工序都得知道自己该为最终误差背多少锅。

这篇文章我就用一个最简单的三节点网络（2个输入、2个隐藏节点、1个输出），带着具体数字，完整走一遍正向传播和反向传播的全过程。所有计算我都展开写，你拿张纸和计算器跟着算一遍，比看十遍公式都管用。

先明确我们要解决的问题：假设我们要根据两个特征预测一个分值，训练样本只有一个，输入是 x1=0.5、x2=0.2，真实标签是 0.7（你可以理解为期望的输出结果）。这个例子足够简单，简单到每一步脑子都能跟上，但麻雀虽小五脏俱全，正向、反向、梯度下降、参数更新全都有。

那这个例子到底解决什么问题？它解决的是“神经网络的学习过程究竟在做什么”这个根本困惑。适合刚学完感知机、看了一堆理论但还没动手算过的手推小白，也适合面试前想快速把传播过程彻底理清楚的求职者。

2. 为什么非要“正向”加“反向”两趟流程？

理解这两趟流程，你不能把它们割裂开看。它们是一套连续更新的闭环：正向传播负责“评估现状”，反向传播负责“寻找改进方向”，最后更新参数让“现状变好”。这个过程反复迭代，网络就一步步收敛了。

2.1 正向传播：数据从输入流向输出

我先给网络里的每个连接分配初始权重和偏置，为了便于跟算，数值都取得很规整：

• 输入层到隐藏层的权重矩阵 W1:
  • w11 = 0.4（x1→h1）
  • w12 = 0.2（x2→h1）
  • w21 = 0.3（x1→h2）
  • w22 = 0.5（x2→h2）
• 隐藏层偏置 b1 = 0.1（h1），b2 = 0.2（h2）
• 隐藏层到输出层的权重 W2:
  • v1 = 0.6（h1→output）
  • v2 = 0.7（h2→output）
• 输出层偏置 b_out = 0.3

激活函数我们用最经典的 sigmoid，原因有二：一是它的输出范围在0到1之间，适合这个单节点标量输出的场景；二是它的导数性质极好——f’(x) = f(x)·(1-f(x))，反向传播计算时直接复用正向传播的结果，省去大量重复计算。这个便利在后面的手算里你会直观感受得到。

正向传播的规则就一句话：上一层每个节点乘上对应权重，累加，再加上偏置，最后过激活函数，得到下一层节点的值。

先算隐藏层节点 h1 的加权输入：

net_h1 = x1*w11 + x2*w12 + b1 = 0.5*0.4 + 0.2*0.2 + 0.1 = 0.2 + 0.04 + 0.1 = 0.34

过 sigmoid 激活：

h1 = sigmoid(0.34) = 1 / (1 + exp(-0.34)) ≈ 0.5842

同理，h2：

net_h2 = x1*w21 + x2*w22 + b2 = 0.5*0.3 + 0.2*0.5 + 0.2 = 0.15 + 0.1 + 0.2 = 0.45 h2 = sigmoid(0.45) ≈ 0.6106

往前传到输出层：

net_out = h1*v1 + h2*v2 + b_out = 0.5842*0.6 + 0.6106*0.7 + 0.3 = 0.3505 + 0.4274 + 0.3 = 1.0779 out = sigmoid(1.0779) ≈ 0.7460

当前网络对样本的预测值是 0.7460，真实值是 0.7，差了多少？用均方误差（MSE）来量化：

L = 0.5 * (out - y)² = 0.5 * (0.7460 - 0.7)² = 0.5 * 0.002116 ≈ 0.001058

注意我这里用了 0.5 系数，纯粹是为了求导时把平方项的 2 抵消掉，简化梯度表达式。这是很多教材里默认的写法，为了后续手算方便，不是因为 MSE 必须带这个系数。严谨地讲，不带 0.5 的 MSE 也完全合法，只是梯度多了个 2 倍。这里有个细节值得多说一句：你用 0.5 还是 1，都不影响网络的效果，因为梯度下降本身就含学习率这个可以任意调整的系数，缩放误差函数只是改变梯度的绝对大小，优化器会自动适应。但如果你手算推导，带 0.5 会让中间过程清爽很多。

2.2 反向传播：误差信号从输出往输入倒流

说完正向，重头戏来了。

你可能会有个直觉困惑：误差是 0.001，很小啊，这网络看起来已经不错了？但请记住，这只是随便初始化的一组权重，这个巧合般的低误差完全是因为我刻意把初始值设得比较规整。实际应用中，随机初始化的权重通常会让误差大得多，训练就是要不断降低这个值。而且哪怕误差小，我们也必须知道每个参数对这个误差的贡献方向，才能继续优化。

反向传播的核心思想就四个字：链式法则。误差 L 对每个权重求偏导，然后把梯度拆解成路径上的“局部导数”的连乘。

从输出层开始。我们需要求三个量：

第一个，误差对 out 的导数：

dL/dout = out - y = 0.7460 - 0.7 = 0.0460

如果用了0.5系数，这个导数就是 (out - y)；如果没用，就是 2*(out - y)。数值不同，但方向一致。

第二个，sigmoid 函数对 net_out 的导数。这里展示sigmoid的优雅之处：

dout/dnet_out = out * (1 - out) = 0.7460 * (1 - 0.7460) = 0.7460 * 0.2540 ≈ 0.1895

第三个，对于权重 v1，我们需要 net_out 对 v1 的导数，就是 h1：

dnet_out/dv1 = h1 = 0.5842

三连乘：

dL/dv1 = dL/dout * dout/dnet_out * dnet_out/dv1 = 0.0460 * 0.1895 * 0.5842 ≈ 0.00509

这个 0.00509 就是权重 v1 应该调整的方向和幅度。同理：

dL/dv2 = 0.0460 * 0.1895 * h2 = 0.0460 * 0.1895 * 0.6106 ≈ 0.00532 dL/db_out = 0.0460 * 0.1895 * 1 ≈ 0.00872

对偏置的导数是链式法则中最后一项为1的特殊情况，因为偏置直接加到累加和上。

输出层搞定后，要向隐藏层继续“追责”。隐藏层节点 h1 的最终误差信号，来自输出层节点通过 v1 传回来的误差。为了便于手算，我们先算一个中间量——输出层节点的“总误差信号”，通常记作 δ_out：

δ_out = (out - y) * out * (1 - out) = 0.0460 * 0.1895 ≈ 0.00872

这个 δ 的含义就是“输出节点对最终误差的敏感程度”，反向传播每往前走一层，都要计算对应节点的 δ，再乘以合适的路径权重向更前层传递。

h1 的误差信号就是 δ_out 乘以 v1：

δ_h1 = δ_out * v1 * h1 * (1 - h1) = 0.00872 * 0.6 * 0.5842 * (1 - 0.5842) = 0.00872 * 0.6 * 0.5842 * 0.4158 ≈ 0.00127

看到链式法则的层层剥离了吗？每个隐藏节点都在“接下”上一层传来的误差信号，再乘上自己的激活函数导数，形成自己的 δ。于是：

dL/dw11 = δ_h1 * x1 = 0.00127 * 0.5 ≈ 0.00064 dL/dw12 = δ_h1 * x2 = 0.00127 * 0.2 ≈ 0.00025 dL/db1 = δ_h1 = 0.00127

同理 h2：

δ_h2 = δ_out * v2 * h2 * (1 - h2) = 0.00872 * 0.7 * 0.6106 * 0.3894 ≈ 0.00145 dL/dw21 = δ_h2 * x1 = 0.00145 * 0.5 ≈ 0.00073 dL/dw22 = δ_h2 * x2 = 0.00145 * 0.2 ≈ 0.00029 dL/db2 = δ_h2 = 0.00145

到这里，所有参数的梯度就都算出来了。这一步的本质不是魔法，就是把输出误差按权重比例分摊给每个前层节点，再乘上各自激活函数的变换率，得到“误差对每个参数的敏感度”。

3. 梯度下降更新：完成一次真正的“学习”

有了梯度，怎么更新权重？很多初学者在这一步容易犯迷糊：梯度算出来了，为什么是“减”而不是“加”？这个直觉问题我觉得值得多费点笔墨说清楚。

简单讲，梯度指向的是误差增大的最快方向，我们要往反方向（即负梯度方向）走，误差才会减小。你可以把它想象成下山：梯度告诉你哪个方向最陡、坡度最大，但那是往上爬的方向；要下山就得反着走。学习率就是你的步长。

设定学习率 η = 0.5，对每个参数执行更新公式：

新值 = 旧值 - η * 梯度

逐项来算：

v1: 0.6 - 0.5 * 0.00509 ≈ 0.6 - 0.00255 = 0.5975 v2: 0.7 - 0.5 * 0.00532 ≈ 0.7 - 0.00266 = 0.6973 b_out: 0.3 - 0.5 * 0.00872 ≈ 0.3 - 0.00436 = 0.2956 w11: 0.4 - 0.5 * 0.00064 ≈ 0.4 - 0.00032 = 0.3997 w12: 0.2 - 0.5 * 0.00025 ≈ 0.2 - 0.00013 = 0.1999 w21: 0.3 - 0.5 * 0.00073 ≈ 0.3 - 0.00037 = 0.2996 w22: 0.5 - 0.5 * 0.00029 ≈ 0.5 - 0.00015 = 0.4999 b1: 0.1 - 0.5 * 0.00127 ≈ 0.1 - 0.00064 = 0.0994 b2: 0.2 - 0.5 * 0.00145 ≈ 0.2 - 0.00073 = 0.1993

然后用这组新参数重新做一次正向传播，你会看到误差降得更低了。这一步“用更新的参数重新前向计算”非常重要：反向传播本身不是学习，梯度下降更新才是学习的动作，而前向计算是检验学习效果的手段。三个环节缺一不可，循环往复就是训练过程。

我们快速验证一次新权重下的 out：

net_h1 = 0.5*0.3997 + 0.2*0.1999 + 0.0994 = 0.1999 + 0.0400 + 0.0994 ≈ 0.3392 h1 = sigmoid(0.3392) ≈ 0.5840 net_h2 = 0.5*0.2996 + 0.2*0.4999 + 0.1993 = 0.1498 + 0.1000 + 0.1993 ≈ 0.4491 h2 = sigmoid(0.4491) ≈ 0.6105 net_out = 0.5840*0.5975 + 0.6105*0.6973 + 0.2956 ≈ 0.3489 + 0.4257 + 0.2956 ≈ 1.0702 out = sigmoid(1.0702) ≈ 0.7447 L_new = 0.5 * (0.7447 - 0.7)² = 0.5 * 0.002 = 0.001

误差从 0.001058 降到了 0.001，确实降了，虽然步子不大，但方向正确。如果数据集更大、迭代更多次，网络的预测能力会逐步逼近真实规律。

这里顺带讲一个很多人忽略的细节：为什么权重更新幅度看起来很小？因为学习率 0.5 在小网络中是一个合理甚至保守的选择。学习率设太大会导致梯度更新步伐过大，越过最优点导致发散；设太小则收敛极慢。工业实践中会用自适应学习率算法（如 Adam）自动调整，但手推阶段用固定学习率最直观，能清楚看到每一步在干什么。

我想再分享一个帮你验证梯度算得对不对的土办法，我管它叫“数值梯度检验”。方法是：对某个权重 w，先把 w 加上一个极小的扰动 ε（比如 1e-5），做一次正向传播，记录误差变化；再把 w 减去 ε，再做一次正向传播。然后用中心差分公式：

( L(w+ε) - L(w-ε) ) / (2ε)

这个值应该和反向传播算出的梯度非常接近。我第一次手推完所有梯度后，用这个方法验证，发现输出层权重基本一致，但隐藏层某个权重差了10%左右，检查发现是链式法则里漏乘了一项。如果你也在手推，强烈建议写完代码或者抱着计算器做一次数值梯度检验，它能帮你抓住推导中的致命细节错误，比单纯对公式可靠得多。

4. 常见问题与调试经验：手推传播流程最容易踩的坑

在这个领域待久了，我发现初学者推反向传播基本会踩同样几个坑。我把它们整理成一张速查表，每个都附上规避方法：

我再重点展开两个最隐蔽的坑。

第一个是梯度消失的直观感受。你看上面例子里，δ 从输出层的 0.00872 传到隐藏层变成 0.00127，数值缩小了约 6.9 倍。这是单层隐藏层的情况；如果网络有十几层，每层都乘 sigmoid 导数（最大值只有 0.25），误差信号传到最前层就几乎为 0 了，前层权重几乎学不动。这就是为什么现代深层网络普遍用 ReLU 等导数为常数的激活函数，从源头规避梯度消失。手推时你只要记住：误差信号在每一层都会“缩水”，缩水系数就是激活函数的导数乘以路径权重大小。

第二个坑是把“损失减小”等同于“网络学会了”。在极端情况下，网络可能靠记住训练样本的噪声实现低训练误差，但在新数据上表现一塌糊涂，这叫过拟合。反向传播只负责把训练误差压下来，压到什么程度合适、怎么防止压过头，是正则化和验证集策略的问题。初学者容易误解“反向传播的目标就是让损失变成0”，这句话只说对了一半——让损失变小是目标，但在新样本上表现好才是最终目的。这两个目标的差距，是深度学习中最多隐性成本的地方。

5. 从手推走向实战：你的下一步路线图

学会了这个三节点的小例子，你对神经网络的理解就已经超过了很多只会调库的同学。但接下来要怎么走，我个人建议按这个顺序来：

先用代码验证你的手算过程。别急着上深度学习框架，可以先写一段最朴素的 Python 代码，完全按矩阵乘法和链式法则手动实现一遍正向传播和反向传播，用上面的数值梯度检验去验证手算结果。这个过程能彻底巩固你对“张量形状如何在层间流动”的理解。框架帮你省掉的正是这些底层繁琐操作，但省掉不等于你可以不懂。

然后，把小网络扩展到真实场景。比如手写数字识别，输入是28×28像素的图像，输出是10类概率。这时正向传播的矩阵运算形状变成 [784]×[784×128]×[128×10]，反向传播的链式法则本质和这个三节点例子完全一致，只是每个节点的 δ 从标量变成了矩阵。你会发现，理解了标量版本，矩阵版本只不过是把所有计算“批量进行”而已。重点建议使用小批量训练时，多留意不同样本的梯度是如何平均的——这会直接关系到批量大小的选择逻辑。

最后，抽空把反向传播和计算图结合起来看。现代深度学习框架（任何一个主流框架都可以）把网络表示为计算图，反向传播就是沿着计算图逆向走一遍，自动帮你应用链式法则。当你理解了手推过程，再看框架的backward()接口，你会心一笑——它干的事，就是你刚才拿着计算器干的事。

就我个人经验来说，每带一个新人，我都会让他先手推这个例子，算完再用他熟悉的深度学习框架（PyTorch 或 TensorFlow）搭一个等同结构的小网络，把初始权重设成同样的值，观察训练 loss 曲线是不是和你手推降低的幅度一致。这一步如果对得上，说明你对神经网络的传播机制已经有了非常扎实的直觉。这个练习做完之后，后面理解卷积、循环神经网络里的各种变体，就会顺畅得多——因为所有结构的“学习机制”都还是这套两趟流程的变体。

如果你在手推过程中遇到梯度数值和框架计算不一致的情况，第一反应不应该是怀疑框架，而应该回去检查你的链式法则有没有漏项。这个习惯，能帮你省下未来大量的调试时间。