1. 从一次训练损失不降的排查说起
很多人第一次接触大模型，注意力都被参数量、上下文长度、微调数据量这些"看得见"的东西吸引，反而把反向传播和梯度下降当成两个背下来的名词。我带过几个刚入行的同学，他们能说清楚Transformer的注意力怎么算，但一问"损失为什么不降"，就开始猜学习率、猜数据质量，唯独不去看梯度本身长什么样。这篇文章就围绕反向传播和梯度下降这两个大模型训练的地基展开，把链式法则怎么落地、梯度怎么流动、学习率怎么影响收敛讲透，适合刚入门大模型、想搞懂训练底层逻辑的读者，也适合已经会调API但没深挖过原理的开发者。
先说一个我实际遇到的场景。有个同学拿一份小规模语料做微调，跑了几百步，loss从2.3降到2.1就卡住了，怎么调batch size都没用。他以为是数据太少，准备换更大的数据集。我让他先把梯度打印出来，结果发现大部分层的梯度范数已经接近1e-7，几乎等于零。问题根本不在数据，而在于他用的学习率配合当时的初始化方式，让网络早早进入了饱和区，梯度传不回去。这个例子说明一件事：不看梯度谈训练，等于闭着眼睛开车。而要看懂梯度，就必须先理解反向传播是怎么把误差一层层分回去的，梯度下降又是怎么拿这些梯度去更新参数的。
这两个概念经常被混在一起讲，其实分工很明确。反向传播负责"算"——算出每个参数对最终损失的贡献有多大，也就是梯度；梯度下降负责"用"——拿着这些梯度决定参数往哪个方向、走多大一步。一个管求导，一个管优化。把这两件事分开理解，很多训练中的怪现象就都有了解释的入口。下面我会从链式法则这个数学根子讲起，一路讲到实际训练里学习率、梯度累积、梯度裁剪这些工程细节，尽量把每个"为什么"都交代清楚。
2. 反向传播的本质就是把链式法则拆开算
2.1 为什么不能直接对每个参数求导
一个稍微像样点的神经网络，参数动辄几百万到几千亿。如果要对每个参数单独求一次导，用数值微分的方式，也就是把参数加一个极小值、算一次损失、再减回去，那么每个参数至少要两次前向传播。假设模型有10亿参数，一次前向要几毫秒，光求一遍梯度就要跑20亿次前向，这个成本任何团队都扛不住。所以数值微分只能用来做梯度校验，不能用来训练。
反向传播解决的正是这个效率问题。它的核心洞察是：很多中间计算结果可以复用。前向传播时，每一层的输出都被下一层用到；反向传播时，每一层的梯度也都能被前一层复用。这样一来，求全部参数梯度的计算量，和前向传播是同一个数量级，只差一个常数倍数。这就是为什么反向传播能让大模型训练变得可行——它把"对每个参数单独求导"这种指数级浪费，压成了线性成本。
我常跟人说，反向传播不是什么玄学，它就是动态规划思想在求导上的应用。你把计算图看成一张有向无环图，每个节点存好自己的输出，反向走一遍，每个节点只需要用到它下游传来的梯度和自己前向时存下的局部信息，就能算出自己该往上游传什么。理解了这一点，后面所有的实现细节都是自然推论。
2.2 链式法则在计算图上的具体走法
链式法则本身很简单：复合函数的导数等于各层导数相乘。放到计算图上，就是"上游梯度乘以本地梯度"。举个最小例子，假设有一个标量函数 y = f(g(h(x)))，那么 dy/dx = (dy/df) * (df/dg) * (dg/dh) * (dh/dx)。反向传播就是从 dy/df 开始，一路往左乘。
关键在于，神经网络里每个节点往往有多个下游分支。比如一个中间变量既参与了损失计算，又参与了另一条路径，那么它的梯度就是所有下游分支传回来的梯度之和。这就是为什么反向传播里到处是加法——分支处梯度相加，串联处梯度相乘。这个规则记牢，手推任何网络的反向传播都不会乱。
我用一个具体的两层全连接网络走一遍。设输入 x，第一层权重 W1、偏置 b1，激活函数 ReLU，得到 h = ReLU(W1 x + b1)；第二层权重 W2、偏置 b2，输出 o = W2 h + b2；损失用均方误差 L = 0.5 (o - y)^2。反向传播时，先算 dL/do = o - y。然后 dL/dW2 = dL/do * h^T，dL/db2 = dL/do。接着把梯度传回 h：dL/dh = W2^T * dL/do。再经过ReLU，ReLU的导数是输入大于0时为1、否则为0，所以 dL/d(预激活) = dL/dh 逐元素乘以这个0/1掩码。最后 dL/dW1 = dL/d(预激活) * x^T，dL/db1 = dL/d(预激活)。整个过程没有任何一步需要重新前向，全部靠前向时存下的中间值。
2.3 前向存值换反向省算力这笔账
上面例子里反复出现"前向时存下的中间值"，这不是偶然。反向传播要用到每一层的输入和激活前的值，所以训练时显存占用会比推理大不少。这就是典型的用空间换时间：如果不想存，反向时就得重新算一遍前向，计算量翻倍；存下来，显存压力大但速度快。
大模型训练里显存是稀缺资源，所以出现了梯度检查点这类技术。它的思路是：只存少数几个关键层的激活值，反向传播到某一段时，从最近的检查点重新前向算出这一段需要的中间值，用完就丢。这样显存能降一个数量级，代价是计算量增加大约30%到50%。我在实际项目里，当显存不够、又不想砍batch size时，梯度检查点往往是第一个考虑的开关。它和反向传播的原理直接相关——正是因为反向传播依赖前向中间值，才有"存还是重算"这个权衡。
提示：梯度检查点不是免费的午餐，它换来的显存节省是以额外前向计算为代价的。如果你的任务本身计算密集、显存充裕，就没必要开。
3. 梯度下降：拿到梯度之后到底怎么走
3.1 从批量梯度下降到随机梯度下降的取舍
反向传播算出了梯度，接下来就是梯度下降的活。最朴素的批量梯度下降，是用全部训练样本算一次平均梯度，然后更新一次参数。它的好处是方向准、下降稳，坏处是每走一步都要遍历整个数据集，大模型上根本跑不动。
随机梯度下降每次只用一个样本，更新频繁、速度快，但梯度噪声极大，损失曲线抖得厉害。实际用的是小批量梯度下降，也就是mini-batch，每次用几十到几千个样本。这个折中不是随便定的：batch太小，梯度方差大，训练不稳；batch太大，单步计算慢，而且泛化性能有时反而下降。我自己的经验是，在显存允许的前提下，先从小batch试起，观察损失曲线，如果抖动太大再往上加。很多教程一上来就让你用大batch，其实对小数据集未必合适。
这里有个容易被忽略的点：batch size变了，学习率往往也要跟着调。经验法则是学习率和batch size的平方根成正比，或者线性缩放后再做warmup。原因在于，batch越大，梯度的估计越准、噪声越小，理论上可以走更大的步子。但这个关系不是铁律，具体还得看任务和优化器。
3.2 学习率：步子迈大了会扯着
学习率是梯度下降里最要命的超参数。它决定了每次参数更新的幅度。学习率太大，损失会震荡甚至发散，参数一下子跳到很差的区域；学习率太小，收敛慢得让人绝望，还可能卡在鞍点附近出不来。
我见过太多人把学习率当成一个"调一调就行"的数字，其实它和模型结构、初始化、batch size、优化器都耦合在一起。举个例子，同样是1e-3的学习率，配上Adam可能收敛得很好，换成纯SGD就可能发散，因为Adam对每个参数做了自适应缩放，等效步长完全不同。所以脱离优化器谈学习率是没有意义的。
实际训练里，学习率通常不是固定的，而是配合调度策略。最常见的是warmup加衰减：前几百到几千步把学习率从接近0线性升到峰值，避免训练初期梯度噪声大导致的不稳定；之后再按余弦或线性慢慢降下来，让模型在后期精细收敛。warmup步数一般取总步数的1%到5%，具体看数据规模和batch大小。我在小数据集微调时，warmup会设得短一些，因为总步数本来就少，warmup太长等于浪费了宝贵的训练步数。
3.3 动量与自适应优化器解决了什么问题
纯SGD有个毛病：在峡谷形的地形里，梯度方向来回摆动，前进很慢。动量法的思路是给更新方向加一个"惯性"，把历史梯度累积起来，让方向更平滑。你可以把它想象成一个小球滚下山，遇到小坑能靠惯性冲过去，不会一碰到局部起伏就停住。
Adam这类自适应优化器更进一步，它不只累积梯度，还累积梯度的平方，用来自动调整每个参数的学习率。梯度一直很大的参数，学习率被压小；梯度一直很小的参数，学习率被放大。这对稀疏梯度特别友好，比如Embedding层里很多词向量更新频率差异极大，Adam能让低频词也得到足够的更新。
但Adam也不是万能的。它在某些任务上泛化不如带动量的SGD，而且显存占用更高，因为它要为每个参数存一阶和二阶动量。大模型训练里，为了省显存，出现了AdamW、8-bit Adam、Adafactor这些变体。AdamW主要是把权重衰减从梯度更新里解耦出来，改得更合理；8-bit Adam把动量量化成8位整数，显存直接砍到四分之一左右。我在显存吃紧的项目里用过8-bit Adam，收敛曲线和全精度版本几乎看不出差别，是很划算的取舍。
| 优化器 | 核心机制 | 显存开销 | 适用场景 |
|---|---|---|---|
| SGD | 纯梯度更新 | 最低 | 数据量大、追求泛化 |
| SGD+Momentum | 累积一阶动量 | 低 | 计算机视觉常见 |
| Adam | 一阶+二阶动量 | 高 | 稀疏梯度、快速收敛 |
| AdamW | Adam+解耦权重衰减 | 高 | 大模型微调主流 |
| 8-bit Adam | 动量量化存储 | 中 | 显存受限场景 |
4. 大模型训练里那些和梯度有关的工程细节
4.1 梯度累积：小显存跑大batch的障眼法
大模型训练时，显存往往装不下理想的batch size。梯度累积的思路很直接：把一个大batch拆成几个小batch，分别前向和反向，但先不更新参数，而是把梯度累加起来，等攒够相当于一个大batch的量再更新一次。这样等效batch size上去了，显存占用还是小batch的水平。
这里有个细节必须注意：损失要除以累积步数。因为默认的损失是batch内平均，如果你累积了4步再更新，相当于把4个平均损失加在一起，梯度就放大了4倍，等效学习率也变了。正确做法是每步损失除以累积步数，或者最后统一除以累积步数。我见过有人忘了这一步，结果训练一开始就发散，排查半天才发现是梯度被放大了。
梯度累积和反向传播的关系在于，它把多次反向传播的结果暂存起来。实现上，你只需要在反向传播后不调用优化器的step，而是等累积够了再step，然后清零梯度。PyTorch里就是控制optimizer.zero_grad()和optimizer.step()的调用时机。
accumulation_steps = 4 for i, batch in enumerate(dataloader): outputs = model(batch) loss = criterion(outputs, batch.labels) / accumulation_steps loss.backward() if (i + 1) % accumulation_steps == 0: optimizer.step() optimizer.zero_grad()4.2 梯度裁剪：防止个别样本把训练带偏
训练中偶尔会遇到梯度爆炸，某个batch的梯度范数突然变得极大，一步更新就把参数推到很远的地方，损失直接变成NaN。梯度裁剪就是给梯度范数设一个上限，超过就按比例缩回去。常见做法是全局范数裁剪，把所有参数的梯度拼起来算一个总范数，超过阈值就整体缩放。
阈值怎么定？没有统一答案，常见的是1.0。我一般会先跑几百步，把梯度范数打印出来看看正常范围，再定阈值。如果正常范数在0.5左右，阈值设1.0就合适；如果正常就在5上下，那阈值设1.0反而会把大部分更新都裁掉，训练变慢。梯度裁剪是保险丝，不是常规操作，如果发现需要频繁裁剪，说明学习率或数据本身有问题，得从根上查。
4.3 梯度消失与梯度爆炸的现场判断
梯度消失和爆炸是反向传播的经典问题。梯度消失是指梯度在往回传的过程中越来越小，浅层几乎收不到有效信号，参数几乎不更新。梯度爆炸则相反，梯度越传越大，更新失控。两者根源都在于链式法则里的连乘：如果每层的局部梯度都小于1，连乘后指数衰减；都大于1，就指数增长。
判断方法很直接：打印每一层梯度的范数。如果发现靠近输入的层梯度范数比输出层小好几个数量级，基本就是梯度消失；如果某层突然大得离谱，就是爆炸。残差连接、层归一化、合理的初始化都是缓解梯度消失的手段，梯度裁剪则是对付爆炸的。这些技术之所以有效，本质上都是在调节反向传播路径上梯度的尺度。
5. 把原理落到代码：一次最小可跑的验证
5.1 手写一个两层网络的反向传播
光看公式容易飘，我建议每个学大模型的人都手写一次反向传播。下面是一个不依赖自动求导的两层网络，用numpy实现，能直观看到梯度是怎么一层层算出来的。
import numpy as np def relu(x): return np.maximum(0, x) def relu_grad(x): return (x > 0).astype(float) # 前向 x = np.random.randn(4, 3) W1 = np.random.randn(3, 5) * 0.1 b1 = np.zeros(5) W2 = np.random.randn(5, 2) * 0.1 b2 = np.zeros(2) y = np.random.randn(4, 2) z1 = x @ W1 + b1 h = relu(z1) o = h @ W2 + b2 loss = 0.5 * np.mean((o - y) ** 2) # 反向 dL_do = (o - y) / o.size dW2 = h.T @ dL_do db2 = dL_do.sum(axis=0) dL_dh = dL_do @ W2.T dL_dz1 = dL_dh * relu_grad(z1) dW1 = x.T @ dL_dz1 db1 = dL_dz1.sum(axis=0)跑一遍你会发现，dW1、dW2的形状和W1、W2完全一致，这就是反向传播的输出——每个参数的梯度。拿这些梯度去更新，就是梯度下降。手写一遍之后，再看PyTorch的loss.backward()，你就知道它背后在干什么了。
5.2 用梯度校验确认自己没算错
手写反向传播最容易出错的地方是维度对不上或者漏了某个分支。梯度校验是标准做法：用数值微分算一个近似梯度，和反向传播算的解析梯度对比，相对误差在1e-6量级就说明实现正确。
def numerical_grad(param, func, eps=1e-5): grad = np.zeros_like(param) it = np.nditer(param, flags=['multi_index']) while not it.finished: idx = it.multi_index old = param[idx] param[idx] = old + eps f_plus = func() param[idx] = old - eps f_minus = func() param[idx] = old grad[idx] = (f_plus - f_minus) / (2 * eps) it.iternext() return grad这个技巧在实现自定义算子、自定义损失函数时特别有用。我每次写新的反向逻辑，都会先跑一遍梯度校验，确认无误再上大规模训练。省下的调试时间远超写校验代码的时间。
5.3 观察损失曲线判断梯度是否健康
训练时盯着损失曲线，其实能读出很多梯度的信息。健康的曲线是前期快速下降、后期平缓收敛，偶尔有小波动但整体趋势明确。如果曲线剧烈震荡，多半是学习率太大或batch太小；如果几乎不降，可能是学习率太小、梯度消失，或者数据标签有问题；如果突然变成NaN，先查梯度爆炸，再查数值溢出。
我习惯在训练脚本里加一段定期打印梯度范数的逻辑，每几百步记录一次。这样一旦出问题，回看日志就能定位是哪一层、哪个阶段出的状况，比盲目调参高效得多。这个习惯是从一次线上事故里养成的：当时模型训练到一半loss突然飙升，因为没有梯度日志，排查了两天才发现是某个batch里混入了异常样本，导致梯度爆炸。
6. 几个反复被问到的实操问题
6.1 池化层的反向传播要不要算梯度
这个问题问的人特别多。最大池化的反向传播，梯度只回传给前向时取到最大值的那个位置，其他位置梯度为零。所以严格说，池化层本身没有可训练参数，不需要更新权重，但梯度必须正确地路由回去，否则前面层的参数就收不到信号。平均池化则是把梯度平均分给窗口内所有位置。实现上，最大池化要记录前向时的最大值索引，反向时按索引散射梯度。这也是为什么池化层在前向时要存一点额外信息。
6.2 学习率该从多大开始试
没有万能答案，但有个实用的起步策略：用一个小规模子集，从1e-4开始，分别试1e-5、1e-4、1e-3，看哪个损失下降最快又不发散。这叫学习率范围测试，本质是观察不同学习率下的损失变化。对于微调预训练模型，1e-5到5e-5是常见区间；从头训练小模型，1e-3到1e-2也常见。关键是别照搬别人的数字，因为你的模型、数据、优化器都和别人的不一样。
6.3 梯度累积和学习率要不要联动
要。梯度累积等效于放大了batch size，按照前面说的缩放关系，学习率通常也该相应调整。如果你从batch size 8累积到等效32，学习率可以适当调大，但不必严格按4倍来，因为梯度累积的噪声特性和真正的大batch并不完全一样。我的做法是先保持学习率不变跑一段，看收敛情况再微调，而不是一上来就按公式硬套。
6.4 为什么微调时经常冻结底层
微调大模型时，底层通常学的是通用特征，顶层才和具体任务相关。冻结底层一方面省显存和计算，另一方面避免小数据集把底层已经学好的通用表示带偏。从梯度角度看，冻结就是把这些参数的梯度置零、不参与更新。这也解释了为什么冻结底层后训练更稳——反向传播到冻结层就停了，浅层不会因为小数据的噪声而被破坏。
7. 我在实际项目里踩过的几个坑
第一个坑是忘了清零梯度。PyTorch的梯度默认是累加的，如果你不在每步更新前调用zero_grad，梯度会一直叠加，等效学习率越来越大，训练很快失控。这个错误新手常犯，而且症状和"学习率太大"很像，容易误判。我的建议是把zero_grad和step绑在一起写，形成肌肉记忆。
第二个坑是混合精度训练下的梯度溢出。用fp16训练时，梯度值太小会下溢成0，太大会上溢成inf。解决办法是用loss scaling，把损失放大再反向，更新前再缩回去。现在很多框架用动态loss scaling自动处理，但如果你手动实现，一定要检查梯度里有没有inf或nan。
第三个坑是warmup没配好导致早期发散。有一次我微调一个模型，前几十步loss直接飙到很大，查下来是warmup步数设成了0，训练一开始就用峰值学习率，而模型初始化后的梯度噪声又大，直接跑飞了。加上几百步warmup后问题消失。这件事让我记住：训练初期是最脆弱的阶段，warmup不是可选项。
第四个坑和梯度累积有关。我一度以为梯度累积只是省显存，不影响结果，后来发现如果BatchNorm这类依赖batch统计的层存在，梯度累积的小batch统计和真正大batch统计并不一致，会导致性能差异。所以用梯度累积时，要注意模型里有没有对batch size敏感的层，必要时换成LayerNorm或GroupNorm。
反向传播和梯度下降这两个东西，看公式半小时就能"懂"，但真正理解它们，是在一次次调参、看梯度、排查发散的过程中慢慢建立的。我到现在养成的习惯还是：任何训练异常，先看梯度，再看学习率，最后才怀疑数据和模型结构。这个顺序帮我省下了大量瞎调参的时间。如果你刚开始学大模型，别急着上大参数量，先把一个小网络的反向传播手推一遍、手写一遍、用梯度校验验一遍，后面遇到再复杂的情况，心里都有底。
