企业官网建设流程全解析

上一课讲完 Cross Entropy（交叉熵）以后，我们终于让模型拥有了一个评价自己预测好坏的数字。

假设某一个位置，真实 Token 的概率只有：

P(y)=0.01

那么：

L=-log 0.01≈4.605

很好。

模型现在知道：

这次预测很差。

但如果你真的停下来想两秒，会发现这里有一个非常大的漏洞。

4.605，然后呢？

4.605 只是一个数字。

而一个大语言模型里面可能有几十亿、几百亿，甚至更多参数。

Loss 又没有附带一张说明书告诉模型：

第 18,391,024 个参数，加一点。

第 72,381,552 个参数，减一点。

这个 Attention 权重改多一点。

那个 MLP 权重少改一点。

更前面的 Embedding 也有责任。

所以真正神奇的问题根本不是：

模型怎么知道自己错了？

第四课已经解决了。

真正神奇的是：

模型知道自己错了以后，究竟怎么知道“应该改哪里”？

这才是 Backpropagation（反向传播）真正要解决的问题。

而一旦这件事想明白，你会突然发现：

所谓“训练神经网络”，其实没有想象中那么玄学。

整件事情可以浓缩成一句话：

Loss 负责告诉模型“现在有多差”，Gradient 负责告诉模型“附近往哪里改，Loss 会下降”。

Backpropagation 做的，就是把前者变成后者。

先把几十亿参数忘掉，我们只训练一个数字

先别碰 Transformer。

也先别碰矩阵。

假设我们造了一个世界上最简单的模型：

ŷ=wx

其中：

x 是输入。

w 是模型参数。

ŷ 是模型预测。

现在给模型一个输入：

x=2

当前模型参数：

w=3

所以预测：

ŷ=3×2=6

但是训练数据告诉我们：

真实答案其实是：

y=10

模型预测 6，正确答案 10。

显然预测得不好。

为了让问题简单一点，这里暂时不用 Cross Entropy，而是使用一个很常见的平方误差：

L=½(ŷ-y)2

代进去：

L=½(6-10)2=8

于是现在：

Loss=8

到这里，和上一课的处境完全一样。

模型知道自己不好。

但是：

怎么改？

最关键的问题不是“Loss 是多少”，而是“动一下参数会发生什么”

我们偷偷试一下。

现在：

w=3

如果把它稍微增大一点：

w=3.01

新的预测：

ŷ=3.01×2=6.02

新的 Loss：

L=½(6.02-10)2

大约是：

7.9202

原来的 Loss 是：

8

现在变成：

7.9202

Loss 降了。

这说明什么？

说明在当前这个位置：

把 w 往大的方向推一点，模型会变好。

这其实已经非常接近 Gradient（梯度）的本质了。

我们真正想知道的不是：

L=8

而是：

(∂ L)/(∂ w)

这个东西在问：

如果我现在让参数 w 发生一个非常小的变化，Loss 会往哪个方向变化？变化有多快？

这就是 Derivative（导数）在机器学习里真正有价值的地方。

它不是为了考试求导。

也不是为了证明你学过高等数学。

它本质上是在测量：

Loss 对某一个变量有多敏感。

为什么 Gradient 是负数，反而意味着参数应该变大？

我们直接把刚才的例子算完。

现在：

L=½(ŷ-y)2

所以：

(∂ L)/(∂ŷ) = ŷ-y

当前：

ŷ=6

y=10

于是：

(∂ L)/(∂ŷ) = 6-10=-4

第一次看到：

-4

很多人会懵。

负数到底是什么意思？

其实非常简单。

它告诉你：

当前如果把 ŷ 稍微增大一点，Loss 会下降。

为什么？

因为正确答案是 10。

你现在才预测 6。

当然应该往 10 靠。

所以这里的负号不是在说：

“预测应该变成负数。”

而是在告诉我们：

Loss 下降的方向在另一边。

但问题来了。

我们不能直接修改：

ŷ

ŷ 只是模型计算出来的结果。

真正可以训练的是：

w

所以我们必须继续往前找。

Chain Rule：神经网络真正赖以生存的一条数学规则

现在整个计算过程其实是：

w→ŷ→L

参数 w 先影响预测 ŷ。

预测 ŷ 再影响 Loss。

所以如果我们想知道：

(∂ L)/(∂ w)

可以拆成两段。

第一段：

w→ŷ

因为：

ŷ=wx

所以：

(∂ŷ)/(∂ w)=x

而现在：

x=2

所以：

(∂ŷ)/(∂ w)=2

第二段：

ŷ→L

我们刚才已经算过：

(∂ L)/(∂ŷ)=-4

现在把两段连接起来：

(∂ L)/(∂ w) = (∂ L)/(∂ŷ) × (∂ŷ)/(∂ w)

所以：

(∂ L)/(∂ w) = (-4)×2 = -8

于是：

(∂ L)/(∂ w)=-8

这就是参数 w 当前的 Gradient。

而我们刚才用 (w=3.01) 做的小实验，其实也已经偷偷验证了这个结果。

参数增加：

0.01

Loss 大约减少：

0.0798

两者相除：

−0.0798 / 0.01≈-7.98

已经非常接近真正的导数：

-8

这就是导数。

你完全可以把它理解成：

把参数轻轻碰一下，看看 Loss 会怎么动。

只不过数学让我们不需要真的一次一次试。

Chain Rule 真正厉害的地方，不是公式，而是“影响可以接力”

刚才：

w→ŷ→L

只有两步。

如果是：

a→b→c→d→L

怎么办？

完全一样。

(∂ L)/(∂ a) = (∂ L)/(∂ d) × (∂ d)/(∂ c) × (∂ c)/(∂ b) × (∂ b)/(∂ a)

第一次看这个公式可能很烦。

但其实它只表达一件事：

一个东西不需要直接影响 Loss。只要它能影响下一个变量，下一个变量再继续影响后面的变量，那么这种影响就可以一路传递下去。

我更喜欢把 Chain Rule（链式法则）理解成一种：

影响力换算。

比如：

参数 a 改 1 点，

会让 b 改多少？

b 改 1 点，

会让 c 改多少？

c 又会影响多少 Loss？

把这些“换算率”一路乘起来，

你就知道：

参数 a 最终对 Loss 有多大影响。

到这里，Backpropagation 已经出现了一半。

神经网络为什么刚好特别适合 Chain Rule？

因为神经网络本质上就是一条非常长的函数链。

例如一个极度简化的网络：

x→Layer1→Layer2→Layer3→Logits→Loss

更真实一点：

Token→Embedding→Attention→MLP→Attention→MLP→…→LM Head→Logits→Softmax→Loss

Forward Pass（前向传播）时，信息从左往右走。

输入进来。

一层层计算。

最后得到 Loss。

但当我们想知道：

最前面的某个参数到底该怎么改时，

我们可以反过来：

从 Loss 出发，

沿着原来的计算关系一路往回求导。

这就是：

Backpropagation

反向传播。

但“反向传播”这个名字其实很容易让人误会

很多人第一次学的时候，脑子里会出现一个画面：

Loss 从网络最后面出发，

像一股液体一样，

一层一层倒着流回网络前面。

这个比喻只能算对了一半。

真正往回传播的并不是：

Loss

不是说：

最后 Loss 是 4.605，

那最后一层分 1.8，

倒数第二层分 1.2，

Attention 分 0.6，

Embedding 再承担一点。

神经网络没有这种“责任分账”。

真正往回传播的是：

(∂ L)/(∂ h)

(∂ L)/(∂ z)

(∂ L)/(∂ W)

这些 Gradient Signal（梯度信号）。

也就是：

最终 Loss 对当前这个中间变量有多敏感。

所以所谓“把责任往前传”，更准确的理解应该是：

把 Loss 对后面变量的敏感度，一步一步换算成 Loss 对前面变量的敏感度。

这就是 Backpropagation 的本质。

Computational Graph：几十亿参数为什么没有把问题复杂几十亿倍？

现在再看刚才那个简单模型：

ŷ=wx

L=½(ŷ-y)2

其实可以拆成几个非常小的计算。

先：

w× x

得到：

ŷ

再：

ŷ-y

得到误差：

e

最后：

½e2

得到：

L

这就是一个非常小的 Computational Graph（计算图）。

关键来了。

计算图里的每一个节点，其实根本不需要理解整个神经网络。

乘法节点只需要知道：

乘法怎么求导。

平方节点只需要知道：

平方怎么求导。

Softmax 节点只需要知道：

Softmax 怎么求导。

Matrix Multiplication（矩阵乘法）只需要知道：

矩阵乘法自己的局部导数是什么。

也就是说：

一个巨大神经网络，可以被拆成大量非常简单的局部计算。

Forward 时，每个节点完成自己的计算。

Backward 时，每个节点收到后面传回来的 Gradient，再结合自己的 Local Derivative（局部导数），算出应该继续传给前面的 Gradient。

每个人只负责自己这一小段。

但一段一段连起来以后，

最终就能算出：

Loss 对整个网络所有参数的 Gradient。

这件事非常漂亮。

为什么 Backpropagation 一定要“从后往前”？

这里有个很容易被忽略的问题。

我们不是已经有 Chain Rule 了吗？

那对每一个参数单独算不就好了？

理论上可以。

工程上会浪费得非常夸张。

假设计算图里有：

a→b→c→L

同时：

d→b→c→L

现在你想分别算：

(∂ L)/(∂ a)

和：

(∂ L)/(∂ d)

两者后面的路径：

b→c→L

其实完全一样。

如果每个参数都从头单独求一遍，

同样的东西会被重复算无数次。

Backpropagation 的做法恰恰相反。

先计算：

(∂ L)/(∂ c)

再得到：

(∂ L)/(∂ b)

然后前面的：

a

和：

d

都可以复用已经得到的结果。

所以 Backpropagation 不只是：

“使用 Chain Rule”。

更完整一点应该说：

Backpropagation 是在 Computational Graph 上，从 Loss 开始反向复用中间 Gradient，高效计算所有参数偏导数的方法。

这也是为什么它特别适合神经网络。

神经网络的特点正是：

一个最终 Loss，

前面连着海量参数。

有了 Gradient，参数到底怎么动？

回到最开始那个例子。

我们已经算出：

(∂ L)/(∂ w)=-8

如果我们要最小化 Loss，

就朝 Gradient 的反方向走：

wnew = wold - η (∂ L)/(∂ w)

其中：

η

叫 Learning Rate（学习率）。

假设：

η=0.1

那么：

wnew = 3-0.1×(-8)

得到：

wnew=3.8

新的预测：

ŷ=3.8×2=7.6

原来预测：

6

现在变成：

7.6

离正确答案：

10

更近了。

原来的 Loss：

8

新的 Loss：

½(7.6-10)2=2.88

真的下降了。

所以：

(∂ L)/(∂ w)=-8

不是一个抽象数学结果。

它真的告诉了我们：

这个参数附近往哪个方向走，会让模型变好。

只有一个参数叫导数，几十亿参数以后就叫 Gradient

如果只有：

L=f(w)

我们关心：

(dL)/(dw)

这是 Derivative（导数）。

但真实模型显然有很多参数。

比如：

L=f(w1,w2,w3,…,wn)

那么每一个参数都有自己的偏导数：

(∂ L)/(∂ w1)

(∂ L)/(∂ w2)

…

(∂ L)/(∂ wn)

把它们放在一起：

∇θ L =

(∂ L)/(∂θ1)

(∂ L)/(∂θ2)

⋮

(∂ L)/(∂θn)

这整个东西就是：

Gradient（梯度）。

所以你可以把 Gradient 理解成：

当前模型所有参数各自收到的一份“局部修改方向报告”。

几十亿参数，

就有几十亿个局部偏导。

到这里还只是普通神经网络，现在回到大语言模型

真正精彩的地方来了。

第四课最后留下过一个非常漂亮的结果：

(∂ L)/(∂ zi) = qi-yi

当时我们没有真正展开它。

现在终于可以看懂这条公式到底有多重要。

假设模型最后得到 Vocabulary 上的 Logits：

z1,z2,…,zV

经过 Softmax：

qi= (ezi)/(Σj ezj)

得到模型预测的 Probability Distribution（概率分布）。

真实答案则可以写成 One-hot Target（独热目标）：

y1,y2,…,yV

Cross Entropy：

L=-Σi yilog qi

如果正确 Token 是第 k 个，

那么只有：

yk=1

其余：

yi=0

于是：

L=-log qk

把 Softmax 展开：

L = -log (ezk)/(Σj ezj)

可以写成：

L= -zk+logΣj ezj

然后对任意一个 Logit zi 求导。

最终得到：

(∂ L)/(∂ zi)=qi-yi

这一条公式值得停下来认真看。

因为：

左边是：

Gradient。

右边是：

模型预测分布减去真实目标分布。

换句话说：

模型在 Probability Distribution 上犯的错误，直接变成了 Logit 层的 Gradient。

这就是第四课和第五课真正接上的地方。

用一个数字例子，你会马上看懂 q-y 在干什么

假设 Vocabulary 只有五个 Token。

模型预测：

q= [0.70, 0.15, 0.08, 0.05, 0.02]

而真实答案是第一个 Token。

所以：

y= [1, 0, 0, 0, 0]

那么：

q-y = [-0.30, 0.15, 0.08, 0.05, 0.02]

先看正确 Token。

它当前只有：

70%

但 Target 是：

100%

所以：

0.70-1=-0.30

Gradient 是负的。

Gradient Descent（梯度下降）更新时会减去这个负数，

所以正确 Token 对应的 Logit 会被：

往上推。

再看错误 Token A：

0.15-0=0.15

Gradient 是正的。

更新时会把它的 Logit：

往下压。

错误 Token B：

0.08

也往下压。

但力度比 0.15 小。

错误 Token D 只有：

0.02

所以只需要很小的修正。

这里出现了一个非常漂亮的结果：

错误 Token 当前抢走的概率越多，它收到的纠正信号就越强。

这不是人为写了几十条规则。

它自动从：

Softmax + Cross Entropy

里面长出来了。

再看一个极端例子，你会更容易产生“原来如此”的感觉

假设模型预测：

q= [0.97, 0.01, 0.01, 0.01]

但正确答案其实是第二个 Token。

所以：

y= [0, 1, 0, 0]

那么：

q-y = [0.97, -0.99, 0.01, 0.01]

第一项：

0.97

意思非常直接：

模型极度自信地把概率压在了错误 Token 上。

所以它收到：

极强的向下修正。

第二项：

-0.99

它才是真实答案，

模型却只给了 1%。

所以它收到：

极强的向上修正。

第三、第四项只有：

0.01

它们本来就没抢多少概率，

所以只需要轻微压低。

这时候你应该能真正看懂第四课那句话：

Cross Entropy 不是只负责给模型“打一个分”。

它真正重要的地方在于：

它把 Probability Distribution 上的错误，变成了可以继续向网络内部传播的 Gradient Signal。

但 Logits 也不是参数，训练信号怎么继续往前？

现在我们已经得到：

(∂ L)/(∂ z) = q-y

但：

z

只是 Logits。

还不是模型真正需要训练的参数。

假设最后的 LM Head（语言模型输出层）可以简化写成：

z=Wh+b

这里：

h 是 Transformer 最后产生的 Hidden State（隐藏状态）。

W 是 LM Head 的权重矩阵。

b 是 Bias（偏置）。

z 是最终 Logits。

现在我们已经知道：

(∂ L)/(∂ z) = q-y

于是 Chain Rule 再次登场。

对于 W：

(∂ L)/(∂ W) = (q-y)hT

对于 Bias：

(∂ L)/(∂ b) = q-y

而真正关键的是：

(∂ L)/(∂ h) = WT(q-y)

为什么第三条最重要？

因为它告诉我们：

Gradient 没有停在 LM Head。

LM Head 在计算自己参数 Gradient 的同时，

还会继续产生：

(∂ L)/(∂ h)

告诉前面的 Transformer：

你刚才产生的 Hidden State，也需要调整。

于是训练信号继续往前。

从这里开始，几十亿参数真的都能收到训练信号了

假设整个 Transformer 简化成：

h0→Block1→h1

h1→Block2→h2

一路到：

hL-1→BlockL→hL

最后：

hL→LM Head→Logits→Loss

Forward Pass 时：

从：

h0

一路算到：

Loss

Backward Pass 时：

先得到：

(∂ L)/(∂ z)

再得到：

(∂ L)/(∂ hL)

然后进入最后一个 Transformer Block。

最后一个 Block 内部可能包含：

Attention、

MLP、

Normalization、

Residual Connection。

每个部分都根据自己的局部导数继续应用 Chain Rule。

于是得到：

这一层 Attention 参数的 Gradient。

这一层 MLP 参数的 Gradient。

同时继续得到：

(∂ L)/(∂ hL-1)

然后再进入前一层。

再前一层。

继续。

一直回到网络最前面。

所以 Backpropagation 真正做的事情可以理解成：

Loss

先变成：

(∂ L)/(∂ Logits)

再变成：

(∂ L)/(∂ Hidden State)

然后不断变成：

(∂ L)/(∂ Weight)

以及更前面状态的：

(∂ L)/(∂ Hidden State)

最终得到：

∇θ L

一个地方如果有两条路，Gradient 怎么办？

这里还有一个非常重要的规则。

假设变量 x 同时走了两条计算路径：

x→A→L

和：

x→B→L

那么：

x 对 Loss 的最终影响，

不是只看其中一条。

而是：

两条路径产生的 Gradient 加起来。

也就是说：

(∂ L)/(∂ x) = 路径 A 的贡献 + 路径 B 的贡献

为什么这一点重要？

因为 Transformer 里到处都是分支。

最典型的就是 Residual Connection（残差连接）：

y=x+F(x)

Forward 时：

x 有一条路直接进入 y。

另一条路经过：

F(x)

再进入 y。

Backward 时也是如此。

Gradient 一条可以沿 Residual 的直接路径回来。

另一条经过：

F

回来。

最后两边相加。

以后我们正式讲 Residual 为什么能帮助深层网络训练时，这一点会重新变得非常重要。

一条 Sequence 里几千个 Token，Gradient 又是怎么处理的？

真实语言模型当然不是一次只训练一个 Token。

假设一条 Sequence 有：

T

个参与训练的位置。

每个位置都有自己的 Token Loss：

Lt = -log Pθ(xt|x<t)

如果最终 Loss 是它们的平均：

L = 1/T Σt=1TLt

那么根据导数的线性性质：

∇θ L = 1/T Σt=1T ∇θ Lt

换句话说：

每一个 Token Position 都会产生自己的训练信号。

而同一组模型参数会被整个 Sequence 反复使用。

所以某一个参数最后拿到的 Gradient，

实际上可能同时汇集了：

第 1 个 Token 的贡献，

第 2 个 Token 的贡献，

第 3 个 Token 的贡献，

……

第 4000 个 Token 的贡献。

再加上 Batch 里其他 Sequence 的贡献。

所以一次真实的大模型训练，可以粗略理解成：

大量 Token Position

不断产生 Error Signal

↓

沿 Computational Graph 反向传播

↓

在共享参数处不断汇总

↓

最后形成这一批数据对应的：

∇θ L

这才是真正的“大规模训练信号”。

为什么训练时要保存那么多中间结果？

现在顺便可以解释一个实际问题。

Forward 的时候：

x→h1→h2→h3→L

为什么训练程序不能算完 h1 就立刻把它彻底扔掉？

因为 Backward 时可能还需要它。

例如：

y=wx

要计算：

(∂ y)/(∂ w)

需要知道：

x

很多 Activation Function（激活函数）在求导时，也需要 Forward 阶段产生的中间 Activation（激活值）。

所以训练时除了 Parameters（参数）以外，

还需要保存大量中间状态。

这也是为什么训练大模型时，显存里不只有模型参数。

还会有：

Activations（激活值）、

Gradients（梯度），

以及后面第六课会出现的 Optimizer States（优化器状态）。

这也是 Training（训练）和 Inference（推理）在资源结构上一个非常大的区别。

Backpropagation 不是 Parameter Update，这两个千万别混

这是第五课最容易留下的错误之一。

Backpropagation 做的是：

L→∇θ L

也就是：

把 Gradient 算出来。

它本身并没有决定参数最后怎么更新。

真正的参数更新，是 Optimizer（优化器）的工作。

最简单的情况可能是：

θt+1 = θt-η∇θ L

但现实中的 Optimizer 会进一步考虑很多问题。

比如：

过去几步的 Gradient 要不要参考？

不同参数是不是应该用不同的有效步长？

Learning Rate 多大？

Gradient 一直震荡怎么办？

Weight Decay（权重衰减）怎么处理？

所以：

Backpropagation 回答的是：

往哪里走？

Optimizer 回答的是：

到底怎么走？

这是两件事。

Gradient 也不是“这个参数的重要程度”

还有一个非常常见的误解。

假设某个参数：

(∂ L)/(∂ w) = 0.000001

能不能说：

“这个参数不重要”？

不能。

Gradient 表达的是：

在当前模型、当前数据、当前 Objective（目标函数）、当前参数位置附近，这个参数稍微变化时，对当前 Loss 的一阶影响。

换一条训练样本，

Gradient 可以变。

模型更新一步，

Gradient 也可以变。

甚至换一个 Objective，

Gradient 还会变。

所以 Gradient 是：

局部的。

动态的。

和当前训练目标有关的。

它绝不是一个永久的“参数价值排行榜”。

为什么深度学习里总强调 Differentiable？

现在你应该已经能够自己回答这个问题。

Backpropagation 想从：

L

一路走到：

∇θ L

中间就必须不断使用 Chain Rule。

所以网络里的计算最好都能够提供自己的 Local Derivative。

Matrix Multiplication 可以。

Softmax 可以。

Attention 可以。

MLP 可以。

Normalization 可以。

于是 Gradient 可以一路往回传播。

但以后你会碰到一些很麻烦的东西：

Sampling（采样）、

Argmax、

工具调用、

代码执行、

外部环境反馈。

这些操作不一定还能直接放进一条漂亮的端到端可微计算图。

这时候：

普通 Backpropagation 就开始不够用了。

为什么后面还会出现：

Reinforcement Learning（强化学习）、

Policy Gradient（策略梯度）、

Reward（奖励）？

其实伏笔已经埋在这里了。

到这里，再重新看一次大模型训练，你看到的应该已经完全不一样

第一课我们只知道一条抽象流程：

Data→Model→Prediction→Loss→Gradient→Parameter Update

第二课把 Prediction 打开：

Pθ(xt|x<t)

第三课把 Probability Distribution 打开：

Context→Transformer→Logits→Softmax→Probability Distribution

第四课继续：

Probability + Ground Truth→Cross Entropy→Loss

这一课终于把：

Loss→Gradient

打开了。

现在整条链已经变成：

Text

↓

Token

↓

Context

↓

Transformer

↓

Logits

↓

Softmax

↓

Probability Distribution

↓

Cross Entropy

↓

Loss

↓

Backpropagation

↓

∇θ L

到这里，模型终于不只是知道：

“我错了。”

它开始知道：

“如果想让下一次更好，当前每一个参数附近应该往哪个方向调整。”

真正理解 Backpropagation，只需要抓住四件事

如果这一课公式很多，看完以后有一点乱，可以只留下四件事。

第一件：

Loss 不是修改方案。

L=4.605

只能告诉你模型现在表现不好。

真正能指导参数变化的是：

∇θ L

第二件：

Derivative 本质上是在测量局部敏感度。

(∂ L)/(∂ w)

问的只是：

参数 w 稍微变化一点，

Loss 会怎么变？

第三件：

Chain Rule 让远处的参数也能知道自己对 Loss 的影响。

参数不需要直接连接 Loss。

只要它参与了一条最终影响 Loss 的计算路径，

Gradient 就可以一路算回来。

第四件：

Backpropagation 是在 Computational Graph 上高效执行 Chain Rule。

真正向后传播的不是 Loss 数字，

而是：

Gradient Signal。

最值得记住的，其实是 q-y

如果让我从第五课只挑一条和语言模型最相关的公式，我不会先让你背：

θt+1 = θt-η∇θ L

而是这一条：

(∂ L)/(∂ z)=q-y

为什么？

因为它刚好站在两个世界的交界线上。

左边：

(∂ L)/(∂ z)

属于 Gradient 的世界。

右边：

q-y

属于 Probability Distribution 的世界。

模型预测了什么，

真实答案是什么，

两者之间的差异，

就在这里第一次变成了：

可以真正进入神经网络内部的训练信号。

然后这个信号经过 LM Head。

经过最后一个 Transformer Block。

经过前一层。

再经过前一层。

不断通过 Chain Rule 往前传播。

最终形成：

∇θ L

几十亿参数，

各自得到自己的 Gradient。

所以一个只有：

4.605

这样的 Loss 数字，

最终真的可以改变一个几十亿参数的大语言模型。

这就是 Backpropagation。

但训练到这里其实还没有结束

现在我们终于拥有：

∇θ L

看起来似乎马上就可以：

θ ← θ-η∇θ L

然后结束。

可现实马上会冒出一堆新问题。

Learning Rate 到底多大？

为什么参数更新会来回震荡？

为什么要记住过去的 Gradient？

为什么不同参数需要不同的更新尺度？

Momentum（动量）到底在解决什么？

Adam 为什么会成为深度学习里如此常见的 Optimizer？

AdamW 又为什么要专门处理 Weight Decay？

所以第五课真正完成的是：

Loss→Gradient

而第六课才真正进入：

Gradient→Parameter Update

Backpropagation 已经告诉模型：

附近哪里是下坡。

下一课真正的问题是：

知道下坡方向以后，到底应该怎么走，才能又快、又稳、还不把训练走崩？

这就是 Optimizer（优化器）。