企业官网建设流程全解析

调一个两层的小网络，损失曲线趴在0.69附近一动不动，这是我刚上手神经网络时最常遇到的画面。那时候我把学习率从0.1改到0.01，又从0.01改成0.5，权重初始化换了好几种，问题照旧。后来老老实实拿张A4纸把公式推了一遍，才发现是自己输出层误差项定义错了，激活函数导数那一项直接漏掉。BP神经网络的算法原理本身并不玄乎，真正的门槛在于：它的每一行代码都对应着一个具体的偏导数，公式推导里哪个符号对应哪个矩阵，一旦对不上，代码就跑不通。这篇东西我打算把BP神经网络从整体思路、前向传播、公式手推、手写实现一直到排查技巧整套讲一遍，面向的是刚学完机器学习基础想动手复现、或者准备面试需要手推BP的朋友，也适合那些框架用得很熟但一直没搞明白梯度到底怎么流回来的工程师。

1. 先把BP神经网络这件事说明白：它到底在学什么

1.1 从"中间层没有标准答案"这个核心矛盾说起

BP神经网络属于监督学习里最经典的一类模型，全称是误差反向传播神经网络。它的结构就是若干层神经元首尾相连，输入层接收特征，中间一个或多个隐藏层做非线性变换，输出层给出预测值。结构听起来平平无奇，但真正让它成为一个可训练系统的，是一个很尖锐的矛盾：输出层有标签可以对答案，隐藏层没有。你手里有输入和输入对应的目标值，可中间那些层的权重到底该调成多少，没有人告诉你标准答案。

解决这个矛盾的办法，就是把输出层的误差按照权重比例，一层一层往回去分摊。谁的权重贡献大，谁就多背一点锅。这个"分摊"的数学工具就是链式法则。损失函数对某一层权重的偏导，可以拆成"损失对该层输出的偏导"乘"该层输出对该层输入的偏导"乘"该层输入对该层权重的偏导"，拆到最后每一段都是能算的。反向传播这个名字里的"反向"，说的就是这个从输出层往输入层逐层回推的方向。

这里要提醒一个常见的理解偏差：很多人以为BP是一种网络结构，其实它不是，它是一种计算梯度的算法。你可以把BP套在任何由可微运算堆叠起来的结构上，卷积网络、循环网络用的都是同一套反向传播逻辑。理解了这一点，后面学更复杂的模型时就不会觉得是新东西。

1.2 一次完整训练到底转了几个圈

整个训练流程可以拆成一个不断循环的四步闭环。第一步前向传播，输入数据经过逐层的加权求和和激活函数，得到预测输出。第二步算损失，拿预测值和真实标签比较，得到一个标量，衡量这次预测错得有多离谱。第三步反向传播，把这个标量损失对每一个权重、每一个偏置的偏导都算出来，得到一个和参数矩阵同形状的梯度矩阵。第四步参数更新，沿着梯度的反方向按学习率走一小步。

这四步走完叫一个迭代，跑完整个数据集叫一个epoch，通常要跑几百上千个epoch。梯度下降的更新式子写成矩阵形式很简单：

W ← W − η · ∂L/∂W

关键的地方在于，每一次迭代里，前向传播算出来的中间结果——每一层的输入 z 和激活输出 a——都必须缓存下来，因为反向传播要用。这一点在手写代码的时候特别容易踩坑，很多新手写完前向就把它当临时变量丢掉，反向的时候再去重算，代码结构会很乱，也更容易出错。

另外还有一个绕不开的前提：整条计算链条必须处处可微。激活函数得可导，损失函数得可导，加权求和本身是线性的天然可导。这也是为什么早期用阶跃函数做激活的网络没法训练，因为导数在绝大多数位置都是0，梯度传回去全是0，权重根本更新不了。这个细节在理解激活函数选型的时候很关键，后面会展开讲。

2. 前向传播的每一步：从输入向量到预测值

2.1 单个神经元：加权求和加一次非线性挤压

一个神经元干的事分两半。前半段是线性部分，把所有输入乘上对应权重再求和，加上偏置：

z = w₁x₁ + w₂x₂ + … + wₙxₙ + b = wᵀx + b

后半段是把 z 塞进一个非线性函数里，得到这个神经元的输出 a = f(z)。为什么非要加这个非线性函数，不能只用线性加权？因为线性层叠线性层，结果还是线性变换，三层和一层在表达能力上没有本质区别。加了非线性激活之后，网络才能拟合曲线、曲面这类非线性关系。这就是所谓的万能逼近能力的基础。

激活函数的选型直接影响训练效果，我把几个常用的放在一起对比一下。Sigmoid 的表达式是 σ(z) = 1/(1+e^(−z))，输出范围在 0 到 1 之间，它最大的好处是导数可以写成 σ(z)(1−σ(z))，直接用输出值就能算，不用重新代入 z。缺点是输出不是零中心的，而且当 z 的绝对值变大时，函数进入饱和区，导数趋近于0，梯度传到这里就快没了。Tanh 表达式是 (e^z−e^(−z))/(e^z+e^(−z))，输出范围 −1 到 1，是零中心的，导数写成 1−tanh²(z)，比 Sigmoid 收敛通常快一些。ReLU 就是 max(0, z)，正半轴导数恒为1，能有效缓解深层网络的梯度消失，但负半轴导数恒为0，学习率太大时神经元可能永久失活，这就是常说的"死亡ReLU"。

注意：如果你的网络只有两三层、数据量也不大，用 Sigmoid 或 Tanh 完全没问题，不必无脑上 ReLU。ReLU 的优势要在较深的网络里才明显体现出来。

2.2 多个神经元串成层：矩阵形式和维度对齐

单个神经元翻来覆去就这点东西，真正让代码变简洁的是把整层神经元写成矩阵运算。假设第 l 层有 n^(l) 个神经元，上一层的输出是 a^(l−1)，维度是 n^(l−1)，那么这一层的加权求和可以一次性算完：

z^(l) = W^(l) · a^(l−1) + b^(l)

其中 W^(l) 的形状是 (n^(l), n^(l−1))，b^(l) 的形状是 (n^(l), 1)，激活之后 a^(l) = f(z^(l))，形状是 (n^(l), 1)。

维度这事看着琐碎，但它是最有效的调试手段。我自己的习惯是，每写一层就在注释里标一遍维度，一旦报形状不匹配的错，先别急着改代码，拿纸把每一层的 (行, 列) 写下来对一遍，八成问题就露出来了。举个例子，一个 2-3-1 的网络：输入层2个节点，第一层权重形状 (3, 2)，偏置 (3, 1)，输出 (3, 1)；第二层权重形状 (1, 3)，偏置 (1, 1)，输出 (1, 1)。这条链上如果哪一步写反了，要么矩阵乘法直接报错，要么更隐蔽地算出个形状碰巧对得上的错误结果，后者才是真正要命的。

还有一个实际工程里的细节：批量训练的时候，输入通常按 (batch_size, n_features) 的行向量形式组织，此时公式要改成Z = A_prev · Wᵀ + b，b 通过广播自动扩展。这两种写法在数学上等价，只是矩阵摆的方向不同。我建议你从一开始就固定一种习惯，别一会儿行向量一会儿列向量，来回切换是形状错误的主要来源。

2.3 损失函数选谁：MSE 和交叉熵的分工

损失函数是反向传播的起点，它决定了第一项偏导怎么算。回归任务常用均方误差：

L = (1/2m) Σ (a^(L) − y)²

前面的 1/2 纯粹是为了求导方便，平方求导会掉下来一个 2，正好和 1/2 约掉，公式干净很多。分类任务更常用交叉熵，二分类形式是：

L = −(1/m) Σ [ y·ln(a) + (1−y)·ln(1−a) ]

很多人第一次看到交叉熵会发怵，但把它和 Sigmoid 搭配起来用，会有一个非常漂亮的结果：输出层的误差项直接化简成δ = a − y，那个 Sigmoid 的导数项消失了。这不是巧合，而是交叉熵的设计和 Sigmoid 的导数结构刚好对上了。所以如果你用 Sigmoid 做输出层又选了 MSE，梯度里会多带一个 a(1−a) 的因子，当预测值接近 0 或 1 时这个因子的值很小，梯度被压得很扁，收敛会明显变慢。这是选型时必须知道的取舍。

表格第三列这个统一的结果很有启发性：不管具体是哪种组合，只要你把激活和损失配对用对了，输出层误差项的形式总是"预测减真实"。这也是为什么框架里能那么统一地处理各种损失函数。

3. 反向传播公式手推：链式法则一层层剥开

3.1 输出层的误差项 δ 究竟从哪里冒出来

先定义符号。设第 l 层的加权输入是 z^(l)，激活输出是 a^(l)，损失记作 L。为了书写方便，定义这一层的误差项：

δ^(l) ≡ ∂L/∂z^(l)

意思是损失对第 l 层加权输入的偏导。为什么要按 z 而不是按 a 定义误差项？因为链式法则往下传的时候，z 是连接上一层权重和这一层激活的枢纽节点，用 δ 做中间变量能让公式高度统一，这也是初学者看教材时最容易迷惑的一步。

从输出层开始推。损失对输出层激活的偏导是 ∂L/∂a^(L)，而激活输出对加权输入的偏导是 f′(z^(L))，根据链式法则：

δ^(L) = ∂L/∂z^(L) = (∂L/∂a^(L)) ⊙ f′(z^(L))

这里的 ⊙ 是逐元素相乘。以 MSE 加线性输出为例，L = (1/2)(a − y)²，那么 ∂L/∂a = a − y，配合线性激活的导数 1，得到 δ = a − y。如果换成交叉熵加 Sigmoid，∂L/∂a 是 −(y/a) + (1−y)/(1−a)，乘上 Sigmoid 导数 a(1−a) 之后一顿约分，最后还是 δ = a − y。这两条路径我都自己动手写过，建议你也至少完整推一遍交叉熵那条，约分的过程很能说明问题。

提示：这里的 ⊙ 表示逐元素相乘而不是矩阵乘。在代码里对应 numpy 的*，写成@就是另一个意思了，这个符号错误极难通过报错发现，只会让梯度数值悄悄错掉。

3.2 隐藏层误差反传：为什么要乘以权重矩阵的转置

输出层的 δ 拿到之后，往前一层传。对第 l 层（隐藏层），它和后面一层的关系是 z^(l+1) = W^(l+1) a^(l) + b^(l+1)，而 a^(l) = f(z^(l))。用链式法则把 L 对 z^(l) 的偏导拆开，经过整理可以得到：

δ^(l) = ( (W^(l+1))ᵀ · δ^(l+1) ) ⊙ f′(z^(l))

这个式子有三个地方值得停下来想清楚。第一，为什么是转置。前向传播时权重矩阵 W^(l+1) 的形状是 (n^(l+1), n^(l))，把本层的 n^(l) 维信号映射到下一层的 n^(l+1) 维空间。反向传播的方向正好相反，要把 n^(l+1) 维的误差信号映射回 n^(l) 维，自然就得用转置矩阵，形状是 (n^(l), n^(l+1))，乘上 (n^(l+1), 1) 的 δ，得到 (n^(l), 1)，维度对得上。转置在这里不是数学上的顺手为之，而是维度决定的必然要求。

第二，这个式子揭示了误差分配的逻辑。权重越大，说明这个连接对下一层的贡献越大，那么下一层的误差就该多分一点回来。转置乘法正是在做这件事：把下一层每个神经元的误差，按连接权重加权求和，分摊给本层的每个神经元。

第三，为什么要乘本层的激活导数 f′(z^(l))。反向传回来的是"误差对本层加权输入的敏感度"，但真正能调的是权重，权重影响的是 z，z 影响的是 a，a 才影响最终损失。这条链上 f′(z) 是必经的一环，不能漏。初学者最常犯的错就在这：公式照抄了但忘了乘激活导数，结果梯度方向大致对但数值偏差很大，训练能走但慢得离谱，还很难定位。

3.3 梯度公式汇总和一个 2-2-1 网络的完整数值演算

误差项都拿到之后，权重梯度其实很好写。因为 z^(l) = W^(l) a^(l−1) + b^(l)，所以 ∂z^(l)/∂W^(l) 就是 a^(l−1)，∂z^(l)/∂b^(l) 就是 1，于是：

∂L/∂W^(l) = δ^(l) · (a^(l−1))ᵀ

∂L/∂b^(l) = δ^(l)

批量训练时再对所有样本求平均，W 的梯度形状是 (n^(l), n^(l−1))，正好和 W 自己同形，逐元素减法更新即可。

光看公式容易飘，我用一个 2-2-1 的网络完整算一遍。网络结构：输入 2 个节点，隐藏层 2 个节点用 Sigmoid，输出层 1 个节点用 Sigmoid，损失用 MSE。初始权重设定为 W^(1) = [[0.2, 0.4], [−0.5, 0.3]]，b^(1) = [0.1, −0.1]ᵀ，W^(2) = [[0.6, −0.8]]，b^(2) = [0.2]。样本输入 x = [0.5, 0.1]ᵀ，目标 y = 1，学习率 η = 0.5。

前向传播的中间结果我列成表：

反向传播从输出层开始。δ^(2) = (a − y)·a(1−a) = (−0.4504)×0.5496×0.4504 = −0.1115。接着算隐藏层误差，δ₁^(1) = W^(2)₁ × δ^(2) × a₁(1−a₁) = 0.6×(−0.1115)×0.5597×0.4403 = −0.0165，同理 δ₂^(1) = (−0.8)×(−0.1115)×0.4207×0.5793 = 0.0217。

权重梯度就是对号入座。W^(2) 的梯度等于 δ^(2) 分别乘上两个隐藏层输出：−0.1115×0.5597 = −0.0624 和 −0.1115×0.4207 = −0.0469。W^(1) 的梯度要用 δ^(1) 乘输入：−0.0165×0.5 = −0.0082、−0.0165×0.1 = −0.0016、0.0217×0.5 = 0.0109、0.0217×0.1 = 0.0022。偏置梯度直接就是 δ 本身。最后更新，比如 W^(2)₁ 从 0.6 变成 0.6 − 0.5×(−0.0624) = 0.6312。

这个例子我建议你真的拿纸复现一遍，不用算到小数点后四位，算到两位能对上趋势就够了。手算过一次之后，代码里哪一层乘错了、哪个转置漏了，看一眼就能感觉出来。

4. 不依赖框架手写一个BP神经网络

4.1 参数初始化：为什么不能全部填 0

初始化听起来是小事，实际上是整个训练能不能启动的第一道关。最直觉的做法是把所有权重都设成 0，这个做法会直接导致训练失败。原因是对称性问题：如果同一层的所有神经元初始权重完全一样，那么它们在前向传播中接收的输入相同、输出相同，反向传播中拿到的梯度也完全相同，更新之后权重依然一模一样。整层神经元等于退化成一个，网络的表达能力被砍掉了大半。偏置可以初始化为 0，因为它不参与对称性破坏这个问题。

合理的初始化要让权重随机，同时控制幅度。太小的初始权重会让信号在层层传递中不断衰减，最后到达输出层时数值很小，梯度也小；太大则相反，前向输出容易进入饱和区，梯度直接趋近 0。Xavier 初始化给出了一个被广泛使用的方案，对第 l 层：

W^(l) ~ U( −√(6/(n_in+n_out)), +√(6/(n_in+n_out)) )

这个区间的上下界来自对前向和反向信号方差的分析，目标是让每一层的输出方差和输入方差尽量保持一致。对于前面那个 2-2-1 的网络，第一层的区间是 ±√(6/4) ≈ ±1.2247，第二层是 ±√(6/3) ≈ ±1.4142。配合 Sigmoid 或 Tanh 使用时效果通常不错；如果换成 ReLU，业界更常用 He 初始化，区间改成以 0 为均值、方差为 2/n_in 的正态分布。这些数字不用死记，记住背后的目标就行：让信号和梯度在层间流动时方差保持稳定。

注意：初始化的随机种子一定要固定下来。同一个网络跑两次结果差很多的时候，先别怀疑算法，检查是不是种子没设。实验对比的时候，种子不固定会让你的结论完全站不住脚。

4.2 完整代码实现与逐行说明

下面这份实现我用行向量形式组织数据，维度是 (batch_size, n_features)，和主流框架的习惯一致。前向传播过程中把每一层的 z 和 a 都缓存进字典，反向直接用，避免重算。

import numpy as np def sigmoid(z): return 1.0 / (1.0 + np.exp(-z)) def sigmoid_grad_from_a(a): # 利用 a 直接求导，省掉重新代入 z 的一步 return a * (1.0 - a) def tanh_grad_from_a(a): return 1.0 - a * a class BPNetwork: def __init__(self, sizes, activation="sigmoid", seed=42): self.sizes = sizes self.activation = activation rng = np.random.default_rng(seed) self.W, self.b = [], [] for n_in, n_out in zip(sizes[:-1], sizes[1:]): # Xavier 初始化区间 limit = np.sqrt(6.0 / (n_in + n_out)) self.W.append(rng.uniform(-limit, limit, size=(n_out, n_in))) self.b.append(np.zeros(n_out)) self.cache = {} def _act(self, z): if self.activation == "tanh": return np.tanh(z) return sigmoid(z) def _act_grad(self, a): if self.activation == "tanh": return tanh_grad_from_a(a) return sigmoid_grad_from_a(a) def forward(self, X): # X 形状 (batch, n_in) A = X self.cache = {"A0": X} for i, (W, b) in enumerate(zip(self.W, self.b)): Z = A @ W.T + b # 加权求和，形状 (batch, n_out) A = self._act(Z) # 激活 self.cache[f"Z{i+1}"] = Z self.cache[f"A{i+1}"] = A return A def backward(self, Y): m = Y.shape[0] L = len(self.W) grads_W = [None] * L grads_b = [None] * L # 输出层误差项，MSE + Sigmoid 的情形 A_last = self.cache[f"A{L}"] delta = (A_last - Y) * self._act_grad(A_last) for i in range(L - 1, -1, -1): A_prev = self.cache[f"A{i}"] grads_W[i] = delta.T @ A_prev / m grads_b[i] = delta.mean(axis=0) if i > 0: # 误差反传：乘转置权重，再乘本层激活导数 delta = (delta @ self.W[i]) * self._act_grad(self.cache[f"A{i}"]) return grads_W, grads_b def step(self, grads_W, grads_b, lr): for i in range(len(self.W)): self.W[i] -= lr * grads_W[i] self.b[i] -= lr * grads_b[i] def fit(self, X, Y, epochs=5000, lr=0.5, verbose=500): for ep in range(1, epochs + 1): pred = self.forward(X) loss = np.mean((pred - Y) ** 2) gw, gb = self.backward(Y) self.step(gw, gb, lr) if ep % verbose == 0: print(f"epoch {ep:5d} loss {loss:.6f}") return self

几处值得划重点的地方。delta = (A_last - Y) * self._act_grad(A_last)这一行就是 3.1 节推出来的公式，(A_last - Y)来自 MSE 对激活的偏导，后面那个因子来自激活函数本身。反传那一行delta @ self.W[i]用的就是转置乘法，因为 W[i] 形状是 (n_out, n_in)，delta 形状是 (batch, n_out)，左乘之后自然得到 (batch, n_in)，转置在矩阵乘法里已经隐含完成了。第一次写的时候我在这里纠结了很久，以为必须显式写W.T，其实要看你把 W 定义成什么朝向，定义方式不同，公式的写法就要跟着改，两者必须自洽。

4.3 两个验证实验：XOR 分类与正弦曲线拟合

跑通代码之后要用小规模、可预期的问题来验证，别一上来就上大数据集。第一个实验是经典的 XOR 问题，四个样本 (0,0)→0、(0,1)→1、(1,0)→1、(1,1)→0。这个问题线性不可分，单层感知机永远学不会，正好用来验证网络确实具备非线性能力。用 2-4-1 结构，Sigmoid 激活，学习率 0.5，跑五千轮，损失能掉到 0.002 以下，四个样本的预测值分别接近 0.05、0.95、0.95、0.05。

X = np.array([[0,0],[0,1],[1,0],[1,1]], dtype=float) Y = np.array([[0],[1],[1],[0]], dtype=float) net = BPNetwork([2, 4, 1], activation="sigmoid", seed=7) net.fit(X, Y, epochs=5000, lr=0.5, verbose=1000) print(net.forward(X).round(3))

第二个实验是拟合正弦曲线，这也是很多人说的 BP 神经网络拟合曲线的典型场景。在 −2π 到 2π 之间取 200 个点，y = sin(x)，用 1-8-1 的网络去拟合。这里有个细节：输出层如果用 Sigmoid，输出范围被限制在 0 到 1 之间，而 sin 的取值范围包含负值，永远拟合不了。所以做回归任务时输出层要用线性激活，隐藏层用 Tanh 更合适，因为它输出零中心，对拟合这种有正有负的曲线收敛更快。

x = np.linspace(-2*np.pi, 2*np.pi, 200).reshape(-1, 1) y = np.sin(x) net = BPNetwork([1, 8, 1], activation="tanh", seed=1) net.fit(x, y, epochs=8000, lr=0.05, verbose=2000) pred = net.forward(x) print("拟合均方误差:", np.mean((pred - y) ** 2))

实测下来，隐藏层 8 个 Tanh 神经元、八千轮训练，均方误差能压到 0.001 这个量级，画出来的曲线和原正弦基本重合，只在下采样点稀疏的区域略有偏差。如果误差停在 0.05 左右下不去，八成是两个原因：隐藏层神经元太少，或者学习率给大了导致在最优点附近来回跳。

5. 实操踩坑与排查速查表

5.1 梯度消失、梯度爆炸和学习率的三方博弈

梯度消失是 Sigmoid 和 Tanh 的天然短板。反向传播每往前一层，就要乘一次本层的激活导数和一次权重。Sigmoid 导数的最大值只有 0.25，层数一多，0.25 连乘几次就接近 0 了，前面的隐藏层几乎收不到有效梯度，权重基本不动。表现就是训练日志里损失一开始降一点，然后就卡住不动。应对办法有几种：把激活换成 ReLU 系列、用 Xavier 或 He 初始化控制信号幅度、减少网络层数、或者引入残差连接给梯度开一条直通路径。

梯度爆炸则是另一个极端。权重初始化太大，或者学习率设得过高，反向传播中梯度连乘后急剧放大，参数一步更新就跑到很离谱的地方，损失直接变成 nan。判断方法很简单，训练日志里损失不是下降而是突然变成 inf 或者 nan，基本就是爆炸了。粗暴但有效的处理是梯度裁剪，把每次更新的梯度范数限制在一个阈值内，比如超过 5 就等比例缩回去。

学习率是这两个问题之外的第三个变量，也是实际调参时最先动手的一个。它太大，损失曲线会剧烈震荡甚至发散；太小，收敛慢得让人怀疑人生。我一般先用 0.1 试一下看曲线形状，如果震荡就除以 10，如果下降太慢就乘 3，逐步逼近。数据显示，配上动量之后，学习率可以适当放大而不会那么敏感。

5.2 训练不收敛的排查清单

出问题的时候最忌讳乱改代码，我整理了一份按顺序排查的清单，从最容易验证的开始，基本上一到两轮就能锁定方向。

提示：训练前先用一批极小数据（比如 4 到 8 个样本）做一次过拟合测试。如果网络连这几条数据都拟合不了，说明代码哪里有 bug，此时去调超参数是浪费时间。

这个"先过拟合小数据集"的习惯是我踩了无数坑之后养成的，强烈推荐。它把"代码是不是写错了"和"超参数是不是不合适"这两个问题彻底分开了，排查效率能提高一大截。

5.3 MATLAB 版本对照：从 nntool 到 fitnet

有不少课程和教材还在用 MATLAB 讲 BP 神经网络拟合曲线，这里也顺手对一下。MATLAB 的神经网络工具箱把训练流程封装得很彻底，浅层网络最常用的写法是 feedforwardnet 加上 train：

x = -2*pi:0.05:2*pi; y = sin(x); net = feedforwardnet(8); % 8 个隐藏层神经元 net.trainParam.epochs = 8000; net.trainParam.lr = 0.05; net = train(net, x, y); % 自动完成初始化、前向、反向、更新 pred = net(x); plot(x, y, 'b', x, pred, 'r');

老版本里还有个图形界面的 nntool，可以直接导入数据、设结构、点按钮训练，适合教学演示。用它的好处是省去了手写反向传播，坏处也在这里：整个过程是个黑盒，梯度怎么算、初始化怎么做的，全被包起来了。我的建议是两边都走一遍，先用 MATLAB 快速看到拟合曲线长什么样，建立直观感受，再用手写的 numpy 版本把每一步对一遍，这样既有效率又不至于浮在表面。

顺便提一句，MATLAB 默认的数据组织方向和 numpy 相反，输入是按列放的，特征在行的维度上，跨语言移植代码时这个转置关系一定要确认清楚，不然会出现"代码没错但结果就是不对"的诡异情况。

6. BP 之外：这套思想的延伸与边界

6.1 从 SGD 到 Adam：优化器到底在改什么

前面一直用最朴素的批量梯度下降，所有样本算平均梯度再更新。它的缺点是每步都要扫全量数据，大数据集上慢得没法用。随机梯度下降每次只用一条样本，更新快但抖动大。小批量梯度下降折中，每次用 32 到 256 条样本，这也是现在实际训练中最常用的方式。

再往后是动量法，思路是给参数更新加一个"惯性"：如果前几步梯度方向一致，就加速往前冲；如果方向来回变，就相互抵消，减小震荡。数学上就是在更新量里引入一个衰减的历史梯度累积项。带动量的 SGD 收敛曲线明显更平滑，对学习率也没那么敏感。

Adam 在动量之外又引入了自适应学习率，为每个参数单独维护梯度的一阶矩和二阶矩估计，学习率按参数的历史梯度平方自动缩放。梯度一直很大的参数步子自动变小，梯度一直很小的参数步子适当放大。这个机制让 Adam 在大多数任务上几乎不用怎么调学习率就能跑出不错的结果，代价是占用的显存多一些，泛化性能在某些任务上比精调过的 SGD 略差一点。

有意思的是，Adam 的更新策略有个细节很像 BP 本身：它也在做一种"按贡献分配"的调整，谁的历史梯度大谁就被压一压，谁一直没动静谁就被推一推。这种自适应的思想，和当初把误差按权重比例分摊回去的逻辑，内核上是相通的。

6.2 什么时候该放弃 BP 思路

BP 不是万能钥匙，它有自己的适用边界。第一，问题是线性可分的，比如简单的二分类，用逻辑回归就能解决，上多层网络纯属杀鸡用牛刀，还引入了初始化、学习率一堆要调的参数。第二，数据量极小，比如只有几十条样本，这时候参数多的网络会直接过拟合，用决策树、支持向量机这类模型往往更稳。第三，需要模型完全可解释，比如某些需要给出明确判别规则的场景，神经网络的权重矩阵基本没法解释成人类能读懂的规则，这时应该换线性模型或者基于规则的算法。

还有一个容易被忽略的点：BP 依赖梯度，意味着损失函数必须可微。一旦你的任务涉及离散的、不可导的决策步骤，比如排序、路径选择，直接套 BP 就行不通，需要引入梯度估计或者强化学习那一套方法。数据集里存在大量噪声、标签本身就不准的时候，BP 会把噪声也一起拟合进去，效果可能还不如简单的朴素贝叶斯。

说到底，理解 BP 的价值不只在于会用它，更在于知道它什么时候不适用。这套反向传播的思想已经渗透到几乎所有现代深度学习模型里，卷积层、注意力机制、批归一化，反向传播的逻辑都是同一套：沿计算图往回收，用链式法则把误差分摊下去，每个可微算子贡献自己那一段偏导。

我自己在做项目时的一个体会是，把 BP 手推一遍这件事，投入产出比高得超出预期。后面再遇到梯度为 nan、损失卡住不动、模型不学习这类问题，脑子里会自动过一遍公式链条：是激活导数那项错了，还是转置漏了，还是损失函数配错了激活。定位问题的速度和只会调框架的人完全不在一个量级。如果你也正卡在某个训练不收敛的坑里，不妨把纸笔拿出来，按第 3 节那个 2-2-1 的例子从头推一次，很多疑惑会在推导的过程中自己解开。