先说个真实的感受：很多人在入门神经网络时，第一道坎不是“什么是神经元”，而是那一堆数学公式。BP神经网络我前前后后复习过好几轮，每次隔一段时间不看，再捡起来时总要重新推导一遍。后来我发现，只要把正向传播、反向传播和梯度下降这三件事用一张纸串起来，后面再看任何深度学习框架都轻松很多。这篇文章就是我最常用的一份“复习笔记”，专门讲BP神经网络的数学原理推导，从最基础的三层网络开始，最后再聊聊Momentum、自适应学习率这些简单的变体应用。适合两类人看：一类是刚学机器学习、想弄明白反向传播到底在做什么的同学；另一类是像我一样学完就忘、需要快速复习的从业者。
1. 先别急着看公式：BP网络到底在模仿什么
1.1 一个猜价格的游戏
你想买一套二手房，中介给了两个信息：面积80平、楼层5层。你心里大概会估一个价：“这个位置不错，80平大概能卖200万”。这个估价过程，其实就是一个最简单的神经网络在做预测。
神经网络内部发生的事情，本质上就是一堆“旋钮”和“加法器”的组合。输入是面积、楼层这些信息，网络把它们乘以不同的系数，再加到一起，通过一个非线性变换，最后输出一个预测值。这里的“系数”就是权重，“加的那个数”就是偏置。训练一个BP神经网络，说白了就是不断转动这堆旋钮，让预测值越来越接近真实答案。
1.2 “正向”和“反向”到底指什么
BP全称是Back Propagation，中文叫反向传播。我当年学的时候一直困惑一个问题：既然叫“反向”，那是不是网络在倒着跑？后来才明白，这里的“反向”专指误差信号的方向。
一次完整的训练过程分两步：
- 正向传播：输入数据从输入层进入，经过隐藏层计算，逐步传到输出层，得到一个预测结果。这个方向是数据流动的方向，从输入到输出。
- 反向传播：拿预测结果和真实标签算出一个误差，然后把这个误差从输出层往输入层逐层传回去，每经过一层就计算一下“这一层的旋钮该往哪个方向转、转多少”。这个方向跟数据流动方向相反，所以叫反向。
可以这样理解：正向传播是“做题”，反向传播是“批改作业”。批改完之后，老师把自己的意见一层层传回去，让每一层的参数都知道自己错在哪里。
1.3 需要的数学基础其实只有三样
很多人被BP的数学推导吓住，是因为公式里又是偏导又是链式法则，看起来像天书。但如果你把基础剥开，真正必须掌握的只有三样东西：
- 偏导数：一个多元函数对某一个变量求导，只看这个变量的变化对结果的影响，其他变量暂时当成常数。
- 链式法则：复合函数求导时，逐层相乘。比如y = f(g(x))，那么dy/dx = f'(g(x))·g'(x)。
- 矩阵乘法：多个样本、多个神经元一起算的时候，用矩阵写起来非常简洁，本质上就是一堆乘法和加法。
这三样东西，高中数学都学过。所以这篇笔记的核心思路，就是把一个看起来很吓人的网络，拆成一张可以手算的算术题。
为了后面推导不混乱，我先约定记号。本文用一个最简单的三层网络做例子：输入层有2个神经元（x1、x2），隐藏层有1个神经元，输出层有1个神经元（输出预测值）。这个结构小到可以手算，但又足够展示BP的全部流程。
这里先规定符号：
- 输入向量x = [x1, x2]
- 从输入到隐藏层的权重记作w11、w12，偏置记作b1
- 从隐藏层到输出层的权重记作v，偏置记作b2
- 激活函数用Sigmoid，记作σ(z)，公式是σ(z) = 1 / (1 + e^(-z))
- 损失函数用均方误差（MSE），记作L = 1/2 (y_pred - y_true)² 前半部分的1/2是为了后续求导方便
这个结构麻雀虽小但五脏俱全。接下来我们就用一组真实数字把它完整算一遍。
2. 正向传播：数据在网络里走了一趟，顺便算出一个“离谱”的预测
2.1 单个神经元到底计算了什么
很多人看神经网络图解时会误解，以为那个圆圈就是“一个神经元”。实际上一个神经元内部做了两件事：先对输入做线性加权求和，再过一个非线性激活函数。
先看线性部分。对于一个接收多个输入x1、x2的神经元，它先计算：
z = w11·x1 + w12·x2 + b1
这看起来就是一个多元一次函数。w是权重，b是偏置。偏置的作用在于：即使所有输入全是0，神经元也能产生一个非零输出，相当于给这个神经元一个“基础灵敏度”。
然后是非线性部分，也就是激活函数。如果没有激活函数，神经网络无论堆多少层，最后还是一个线性模型，能力很有限。Sigmoid函数把任意实数压缩到0到1之间，形状是一条S曲线。为什么要用非线性函数？因为现实世界的问题绝大多数不是线性可分的，比如判断一张图上是不是有猫，这种决策边界非常复杂，只有引入非线性，网络才具备拟合复杂函数的能力。
2.2 用一个具体例子把前向传播算一遍
为了不让自己在后续推导中迷路，我直接把数值放进去。假设现在有一个训练样本，输入是x1 = 0.5，x2 = 0.1，真实标签y_true = 0.8。网络权重初始化如下：
- 输入到隐藏层：w11 = 0.3，w12 = 0.6，b1 = 0.2
- 隐藏层到输出层：v = 0.8，b2 = 0.1
这组初始权重完全是随机选的，不用管它为什么是这些数，后面会看到它们被训练成什么样子。
先算隐藏层的线性加和：
z1 = w11·x1 + w12·x2 + b1 = 0.3 × 0.5 + 0.6 × 0.1 + 0.2 = 0.15 + 0.06 + 0.2 = 0.41
然后激活：
a1 = σ(z1) = 1 / (1 + e^(-0.41))
我一般不会去死记e的值，直接用计算器算一下：e^(-0.41) ≈ 0.6637，所以：
a1 = 1 / (1 + 0.6637) ≈ 0.6011
隐藏层输出就是0.6011，注意这个值被压缩在0到1之间，符合Sigmoid特性。
接下来算输出层。因为只有一个输出神经元，它接收隐藏层的输出a1，做同样的操作：
z2 = v · a1 + b2 = 0.8 × 0.6011 + 0.1 = 0.4809 + 0.1 = 0.5809
再激活：
a2 = σ(z2) = 1 / (1 + e^(-0.5809))
e^(-0.5809) ≈ 0.5595，所以：
a2 = 1 / (1 + 0.5595) ≈ 0.6412
所以网络对这个样本的预测值是0.6412，而真实值是0.8。差了大约0.16，确实很“离谱”。
然后算损失：
L = 1/2 × (y_true - a2)² = 0.5 × (0.8 - 0.6412)² = 0.5 × 0.1588² ≈ 0.5 × 0.02521 ≈ 0.0126
这就是当前网络在这一个样本上的误差。
2.3 为什么实际代码里都写矩阵形式
上面这个例子只算了一个样本，而且只有一个隐藏神经元，所以式子看起来还比较亲民。但真实场景里，一个网络可能有好几千个输入特征、几十个隐藏层、每层几百个神经元，一次训练还要同时喂几百个样本进去。如果还用这种逐项写变量的方式，公式会长到没边。
所以工程实现里，大家都会把权重写成矩阵，把输入写成向量或矩阵，一次完成一整批计算。写成矩阵形式之后，前向传播就变成：
- 隐藏层：Z1 = W1 · X + b1，A1 = σ(Z1)
- 输出层：Z2 = W2 · A1 + b2，A2 = σ(Z2)
这里的W1是矩阵，维度是“本层神经元数 × 上层神经元数”。A1是上一层输出，Z2是当前层线性结果。矩阵乘法看起来复杂，但你在循环里只写一行代码就搞定了。真正理解矩阵形式的含义，其实还是从单个神经元的计算逻辑扩展开来的，所以手推小例子非常重要。
3. 反向传播：误差是怎么一层层“甩锅”的（本文的重头戏）
3.1 损失函数：为什么用平方差来度量“错得有多离谱”
刚刚我们算了损失L = 0.0126，这个数反映的是预测值与真实值的差距。但我们得停下来问一个问题：为什么用平方，而不是直接用绝对值？
有两个特别实际的原因。
第一个原因是数学性质好。绝对值函数在零点不可导，而平方函数处处可导。BP算法依赖导数来计算梯度，如果损失函数不可导，梯度计算就无从谈起。
第二个原因是“错得越大，惩罚越狠”。预测值与真实值差0.1的时候，平方损失是0.005；差0.5的时候，平方损失是0.125。差了5倍误差，损失却差了25倍。这看起来有点“残忍”，但恰恰是这种非线性放大，让网络在预测严重离谱时能快速修正。相比之下，绝对误差会让网络对“差一点”和“差很多”的修正力度差不多，训练起来会慢很多。
3.2 链式法则：误差从输出层逆流而上的“交通路线”
现在进入最核心的部分：怎么把误差L对某个权重的偏导数求出来。
我们先看输出层的权重v。L是通过a2依赖v的，而a2又是通过z2依赖v的，也就是说存在一条完整的依赖链：
L → a2 → z2 → v
注意这里的箭头方向不是数据流向，而是“谁影响谁”：v影响z2，z2影响a2，a2影响L。求∂L/∂v时，就要沿着这条链逐段求导再相乘，用链式法则：
∂L/∂v = (∂L/∂a2) × (∂a2/∂z2) × (∂z2/∂v)
这三个部分分别求出来，问题就解决了。
先看第一段∂L/∂a2。L = 1/2 (y_true - a2)²，求导：
∂L/∂a2 = -(y_true - a2) = a2 - y_true
这里要注意符号，很多新手在这里会算反。把数值代进去：0.6412 - 0.8 = -0.1588。
第二段是∂a2/∂z2。Sigmoid函数有一个非常漂亮的求导公式：
σ'(z) = σ(z) × (1 - σ(z))
也就是∂a2/∂z2 = a2 × (1 - a2) = 0.6412 × (1 - 0.6412) ≈ 0.2300。
第三段是∂z2/∂v。因为z2 = v · a1 + b2，所以对v求导，结果是a1 = 0.6011，偏置b2对v的导数为0。
三项相乘：
∂L/∂v = (a2 - y_true) × a2 × (1 - a2) × a1 = (-0.1588) × 0.2300 × 0.6011 ≈ -0.02195
这个负的梯度告诉我们：要减小损失，v应该往正方向增加，因为在当前状态下v越大，预测值越接近真实值0.8。
3.3 引入误差项δ：少算好几次重复运算
如果你需要单独对每个权重都做一遍链式法则，计算量会爆炸。仔细看一眼∂L/∂v的表达式，会发现有几段东西经常重复出现。
定义输出层的误差项δ₂为：
δ₂ = (a2 - y_true) × a2 × (1 - a2)
那么刚才的梯度就可以写成：
∂L/∂v = δ₂ × a1
同样，偏置b2的梯度也很简单：
∂L/∂b2 = δ₂
为什么偏置的梯度就是δ₂？因为z2 = v·a1 + b2，对b2求导正好是1，链式法则只剩前两段乘积。
这个“误差项”就是BP算法的精髓。有了它，每一层的权重梯度都可以写成“这一层的误差项 × 上一层的激活输出”，非常有规律。
3.4 把误差继续传回隐藏层：“甩锅”给前面的权重
输出层的梯度算完之后，还得继续往回传，算输入层到隐藏层的权重w11和w12。
这一次依赖链更长：
L → a2 → z2 → a1 → z1 → w11
但还是可以一步一步来。关键一步是求∂L/∂a1。注意，a1同时影响z2，而z2又影响a2。我们可以用已经算好的δ₂来简化：
∂L/∂a1 = δ₂ × ∂z2/∂a1 = δ₂ × v
代进数值：-0.1588 × 0.2300 × 0.8 ≈ -0.02922。
然后继续往回传，经过隐藏层的激活函数：
∂a1/∂z1 = a1 × (1 - a1) = 0.6011 × 0.3989 ≈ 0.2398
定义隐藏层的误差项δ₁：
δ₁ = δ₂ × v × a1 × (1 - a1) = (-0.1588) × 0.2300 × 0.8 × 0.2398 ≈ -0.00701
最后对w11求导：
∂L/∂w11 = δ₁ × x1 = (-0.00701) × 0.5 ≈ -0.003505
对w12求导：
∂L/∂w12 = δ₁ × x2 = (-0.00701) × 0.1 ≈ -0.000701
对b1求导：
∂L/∂b1 = δ₁ ≈ -0.00701
到这里，整张网络每个参数的梯度都算出来了。我把它们整理成一张表，方便你对照检查有没有算错：
| 参数 | 梯度 | 含义 |
|---|---|---|
| v | -0.02195 | 输出层权重应该增大 |
| b2 | -0.1588 | 输出层偏置应该增大 |
| w11 | -0.003505 | 输入x1对应的权重略微增大 |
| w12 | -0.000701 | 输入x2对应的权重略微增大 |
| b1 | -0.00701 | 隐藏层偏置增大 |
注意这些梯度全是负的，说明当前状态下所有参数都应该往正方向调，才能减小损失。这只是一个样本的结果，实际训练中会计算一个batch的平均梯度，但原理完全一致。
4. 梯度下降与学习率：为什么是“向山下走”，而不是“往山上爬”
4.1 梯度方向告诉我们的第一件事
现在我们已经知道了每个参数的偏导数。这些偏导数组合在一起，就是损失函数在当前点的“梯度”。梯度的数学含义是：函数值上升最快的方向。
我们目标是让损失函数变小，所以要往反方向走，也就是负梯度方向。这就像站在山坡上，想看风景最差的山谷在哪里，那就沿着最陡的下坡路走。每一步都往下，总会走到一个低点。
不要小看这个直觉。很多人学完BP推导之后，不知道“算梯度”和“更新参数”到底有什么关系。其实反向传播算出来的每个∂L/∂w，只回答了一个问题：这个参数要往哪个方向调，才能让损失变大。我们把方向反过来，就是让损失变小。
4.2 参数更新公式：一次迭代的完整后半程
有了梯度之后，更新参数的公式非常简单：
w_new = w_old - η × ∂L/∂w
其中η是学习率（learning rate），控制每一步走的幅度。
为什么用减号？因为梯度是损失上升的方向，减去它等于走向损失下降的方向。为什么还要乘一个η？因为梯度给的是“方向”，但没告诉我们应该走多远。如果每次迈一大步，可能直接跨过山谷跳到对面山坡上；如果每次只挪一小步，训练又要等很久。η就是这步大小的调节旋钮。
我们把刚才的数值代进去，设η = 0.1，看几个参数的更新结果：
v_new = 0.8 - 0.1 × (-0.02195) = 0.8 + 0.002195 ≈ 0.802195
w11_new = 0.3 - 0.1 × (-0.003505) = 0.3 + 0.0003505 ≈ 0.300351
b2_new = 0.1 - 0.1 × (-0.1588) = 0.1 + 0.01588 ≈ 0.11588
可以看到，每个参数确实都往增大方向调整了，跟之前梯度的判断一致。这次更新之后，如果重新做一遍前向传播，新的预测值应该会更接近0.8一些。一次“前向传播 → 反向传播 → 参数更新”的完整流程，就是一个训练迭代（iteration）。
4.3 学习率到底应该设多大：三个典型后果
学习率是BP网络里最重要也最容易让人头大的超参数。
- 如果η太大，比如设成1.0，参数会像喝醉了一样在损失函数表面疯狂跳动，训练曲线剧烈震荡，损失不但不下降反而可能涨成NaN。
- 如果η太小，比如设成0.0001，训练会非常慢，损失曲线像蜗牛一样缓慢下滑，跑几百轮也没明显变化。
- 如果η适中，比如0.01到0.1这个范围，损失会平滑下降，虽然偶尔有小波动，但整体趋势稳定向好。
我自己的经验是：刚开始训练时，先用0.01这个保守值跑50轮，看损失曲线斜率。如果下降很平稳但速度偏慢，再逐步加大到0.05；如果发生震荡，马上除以10降回去。与其一开始纠结最优学习率，不如用这个试错法快速定位。
4.4 伪代码：让完整训练流程在脑子里跑一遍
公式推导完成之后，我推荐大家用伪代码把整个训练循环默写一遍：
初始化权重 w11, w12, v 和偏置 b1, b2 设置学习率 eta for 每一轮训练（epoch）: for 每个训练样本: # 前向传播 z1 = w11 * x1 + w12 * x2 + b1 a1 = sigmoid(z1) z2 = v * a1 + b2 a2 = sigmoid(z2) # 计算损失 loss = 0.5 * (y_true - a2) ^ 2 # 反向传播（关键步骤） delta2 = (a2 - y_true) * a2 * (1 - a2) delta1 = delta2 * v * a1 * (1 - a1) # 更新参数 v = v - eta * delta2 * a1 b2 = b2 - eta * delta2 w11 = w11 - eta * delta1 * x1 w12 = w12 - eta * delta1 * x2 b1 = b1 - eta * delta1这个伪代码虽然只有十几行，但已经把BP神经网络的所有核心步骤都覆盖了。如果你能不看笔记，独立写出这个结构，说明你是真的理解了，而不是只会调框架。
5. 从标准BP到常用变体：Momentum、自适应学习率和ReLU的魔改思路
5.1 标准BP的两个实际毛病
先说结论：标准BP在小型例题上表现很好，但放到真实场景里有两个明显毛病。
第一个毛病是收敛慢。前面算出来的梯度只是一个样本的梯度，如果数据集有几万条，每个样本给的梯度方向可能还不完全一致，参数就会像无头苍蝇一样左右摇摆，整体前进速度被拖慢。
第二个毛病是容易陷入局部极小值。损失函数在高维空间里往往有无数个坑坑洼洼，标准BP一旦掉进一个不深不浅的坑，梯度接近零，参数就几乎不更新了，训练卡在那里。
这两个问题催生了很多变体。作为入门，你不需要把所有优化器都搞懂，但下面两个方向非常值得了解。
5.2 加上动量：让参数跑得像一只有惯性的球
Momentum（动量）的思路特别生活化。想象一个小球从山坡上滚下来，如果山坡上有个小坑，小球不会停在坑里，因为它有惯性，会借力冲出去继续往低处走。神经网络训练也希望参数具备这种“惯性”。
实现方式很朴素：维护一个速度变量v，每次更新时，先让v保留一部分之前的速度，再叠加上当前的梯度：
v_new = α × v_old - η × gradient
w_new = w_old + v_new
这里的α通常设为0.9左右，叫动量系数。它的含义是：上一次往东走的趋势，这一次依然保留90%。如果连续好几轮梯度方向差不多，速度会越来越快；如果方向突然相反，速度会缓和下来，减少震荡。
我带过的很多朋友在例子中看到效果之后会发出同一种疑问：这跟直接调大学习率有什么区别？区别在于，Momentum是让参数在“方向一致”时加速，在“方向不一致”时刹车，而单纯调大学习率会让所有更新都变大，震荡反而更严重。
5.3 自适应学习率：每个参数拥有自己的步长
标准BP里所有参数共用同一个学习率η。这其实不太合理，因为不同参数所处的“地形”陡峭程度可能完全不同。
自适应学习率的思想是：给每个参数单独记录它最近的梯度大小，梯度大的方向说明地形陡峭，学习率就调小一点；梯度小的地方说明地形平缓，学习率就调大一点。这样既不会震荡，又能保持较快收敛。
RMSProp、Adam这些优化器都基于这个思想。Adam你可以理解为“Momentum + 自适应学习率”的结合：先用动量稳定方向，再按梯度历史调整步长。它的默认参数在大多数问题上都表现不错，所以现在工程里基本默认用Adam。
从训练曲线看，标准BP就像一步一步小心翼翼走路，Momentum像跑步，Adam像一种会自己调节步伐节奏的智能跑者。
5.4 激活函数变体：为什么现在很少看到Sigmoid了
还有一个重要的简单变体，是换激活函数。Sigmoid在本文推导里很好看，因为它求导公式很优美，但在深层网络中有一个致命问题：梯度消失。
Sigmoid函数的导数最大只有0.25。在反向传播中，误差项每经过一层就要乘以这个小于1的数。假设网络有10层，这个因子反复乘法之下，梯度会变成原来的0.25的10次方，小到几乎为零。结果就是靠近输入层的参数几乎学不动。
现在更常用的是ReLU，就是max(0, z)。它的导数要么是0要么是1，乘法因子是1的梯度不会衰减，所以深层网络也能训练起来。代价是，如果某个神经元的输入一直为负，它的梯度就是0，这个神经元就永远学不动了，这叫Dead ReLU。解决思路包括用Leaky ReLU，给负数部分一个很小的斜率，比如0.01。
5.5 一个实际使用变体的场景：手写数字识别
举一个简单应用场景：给一个28×28像素的手写数字图片，输出它属于0~9哪个数字。图片有784个输入特征，输出层需要10个神经元，每个神经元对应一个数字类别的得分。
如果用标准BP，Sigmoid激活函数加固定学习率0.01，训练几百轮可能勉强能到90%的准确率，但训练曲线抖得厉害。换成ReLU激活函数加Adam优化器，同样的网络结构，训练过程稳定很多，几十轮之后就能超过95%。
这就是变体的价值：它不是改变网络的骨架，而是在训练层面让网络性能大幅提升。骨架还是那一套，向前算一遍、往回传一遍、更新一下参数，变体主要改的是“怎么更新”和“用什么激活函数”。
6. 新手最容易踩的5个坑，以及我个人推荐的调参顺序
6.1 坑1：根本不归一化数据
很多新手在实现BP网络时，直接把原始数据塞进去训练。如果输入特征是“房屋面积200平”“房屋年龄30年”这种量纲差异巨大的数据，数值大的特征会在加权求和里占据绝对主导地位，小数值特征几乎没起到作用。
更麻烦的是，在反向传播时，梯度大小和输入特征的值成正比。比如x1=200，x2=0.01，那么∂L/∂w11会比∂L/∂w12大几万倍，训练起来极不稳定。
正规做法是把特征缩放到[0,1]或[-1,1]区间，比如用最值归一化（Min-Max）或标准化（Standardization）。很多新手遇到loss不降，第一反应是调学习率，结果调了半天没用，其实归一化一加，问题立刻消失。
6.2 坑2：权重全部初始化为零或同一常数
如果你把所有权重初始化为0，会产生一个非常隐蔽的问题：所有神经元在同一层的输出完全相同，反向传播算出来的梯度也完全相同，更新之后它们依然相等。这种“对称性”会让网络的每个隐藏神经元退化成一个神经元，无论设多少都白搭。
正确做法是用小的随机数初始化。常见策略有：
- 均匀分布随机初始化，比如在[-0.5, 0.5]之间取值
- Xavier初始化，根据神经元数量自动调整随机范围
- He初始化，专为ReLU设计，稍后会一步到位
但注意随机数也不能太大。如果权重初始值过大，Sigmoid的输入就跑到饱和区，导数接近0，梯度消失，训练也推不动。一个比较稳妥的做法是控制在0.1以下的小随机数。
6.3 坑3：用单个样本更新还是用批量更新，搞不清楚
标准BP的伪代码里，我是拿单个样本做演示的。但对于一个完整数据集，如果你每看完一条数据就更新一次参数（这叫在线学习或随机梯度下降SGD），噪声会非常大，收敛过程曲折。如果你把所有数据都看完再更新一次（这叫批量梯度下降），每次计算量太大，而且容易陷入局部极小。
工程上最常用的是介于两者之间的小批量（Mini-batch）方式：每次随机抽取几十个样本，算完这几十个的平均梯度后更新一次。小批量有两个好处：一是梯度更稳定；二是计算效率高，因为现代硬件对矩阵乘法做了大量优化，一次算64个样本比循环算64次单个样本要快得多。
批大小一般选32、64、128这些数值。太大的批会让梯度很平缓，训练速度反而不一定最优；太小的批则噪声大。
6.4 坑4：loss变成NaN，第一反应别急着调学习率
刚跑网络的人看到loss变成NaN，通常第一反应是“学习率大了，调小一点”。这没错，但只答对了一半。
loss变成NaN还有另外两个高频原因：
- 数据里有缺失值或异常值，比如某个特征是0或者无穷大，前向传播算出来的值爆炸，反向传播梯度也爆炸，后面更新就开始出现无穷大。
- 梯度爆炸本身，也就是梯度值过于巨大，更新后权重变得非常大，下一次前向传播直接溢出。这种情况的解法除了调小学习率，还有梯度裁剪（把梯度限制在某个范围），或者使用自适应学习率优化器来天然缓解。
我的建议是动手排查的顺序先看数据，再初始化，最后再调学习率。很多人一上来就调学习率，是因为这是最容易操作的旋钮，但问题根源可能在别处。
6.5 我个人推荐的调参顺序
调参这件事，如果东一榔头西一棒子，很难定位真正的问题。我带过的朋友里，那些比较快的往往都遵循一套固定顺序：
- 先检查数据质量：有没有缺失、有没有归一化、标签是否正确。
- 再确认网络结构：层数不宜过深，激活函数是否有梯度消失风险。
- 然后设一个偏保守的学习率，比如0.01，跑50轮看loss曲线。
- 如果曲线平稳下降但偏慢，再考虑加Momentum或换Adam。
- 如果曲线震荡，优先降学习率，而不是改网络结构。
- 最后才调整网络宽度或者层数，这是结构层面的改动，影响最大，也要花最多时间验证。
顺序的核心逻辑是：先排除“数据问题”，再看“训练算法问题”，最后才考虑“网络容量问题”。反过来调，很容易陷入一种困境：你以为是网络不够宽，拼命加神经元，结果发现只是学习率太大。
在本文这个迷你例子里，我还会额外加一个小提示：训练时把损失函数打印出来看，而不是只看最终准确率。损失曲线能告诉你很多信息，比如收敛速度、是否震荡、是否过拟合。一份漂亮的损失曲线，往往比最终数字更能说明问题。
最后再分享一个小技巧。很多同学看完BP推导之后，觉得已经明白了，但一周之后又忘了。我的做法是：不要急着去看框架源码，先拿一张纸，把这个3×1×1的微型网络，从正向算一次、反向算一次、更新一次，全部手写出来。写到你不需要翻笔记的时候，这些公式才是你的了。等你把这个小网络吃透，再看主流深度学习框架里那些封装好的layer、loss、optimizer，会发现它们的每一行代码，本质上都逃不开这张纸上的那几步简单数学。
