模型训练原理（一）：别急着学 Transformer：所谓“训练大模型”，其实就是把一堆数字一点点改对

这一课先不钻 Transformer 细节，只把训练最底层的主线讲清楚：参数、Loss、Gradient、Optimizer，以及一次 Parameter Update 到底发生了什么。

第一次接触大模型的人，很容易走一条弯路。

上来先学 Transformer。

然后是 Self-Attention、QKV、Multi-Head Attention、RoPE、RMSNorm、MoE……

学了一大圈，名词越来越多，却总有一种很奇怪的感觉：

这些东西我好像都知道，但模型到底是怎么“学会”的，我还是说不清。

这是因为我们一开始就跳得太远了。

Transformer 解决的是“模型长什么样”。

Attention 解决的是“信息怎么在 Token 之间流动”。

MoE 解决的是“模型容量怎么做大而计算量不一起爆炸”。

但它们都没有回答最底层的那个问题：

一个原本什么都不会的模型，到底发生了什么，才会一点点变得有能力？

如果这个问题没有想明白，后面的 Loss、Backpropagation、AdamW、SFT、DPO、GRPO，很容易全变成需要背的术语。

所以第一课，我们什么高级架构都不碰。

只做一件事。

把“训练”两个字彻底拆开。

先说结论：训练模型，本质上不是“往里面塞知识”

假设现在有两个一模一样的 Transformer。

层数一样。

Hidden Size 一样。

Attention 一样。

代码甚至可以一行不差。

第一个是刚刚初始化的模型。

你问它：

“法国的首都是哪里？”

它可能输出一堆毫无意义的 Token。

第二个已经训练了很久。

你问同样的问题，它回答：

“巴黎。”

问题来了。

这两个模型到底哪里不一样？

不是 Transformer 结构突然变了。

不是第二个模型偷偷多了一个“知识模块”。

也不是代码里增加了几万个if else。

真正发生变化的，是模型内部数量极其庞大的一堆数字。

这些数字，就是：

Parameters

参数。

数学上通常统一记成：

θ

所以如果把大模型训练剥到最底层，你会看到一个可能让人有点意外的事实：

所谓训练，就是不断修改模型参数。

训练前是一组参数：

θ0

训练一段时间以后：

θ1

继续训练：

θ2

最后得到：

θT

模型能力发生了巨大变化，但从计算机视角看，最直接的变化就是：

里面那些数字不一样了。

这句话先记住。

接下来真正的问题才出现：

这些数字凭什么知道该怎么改？

一、先把“大模型”三个字拿掉

我们先不用神经网络。

更不用几百亿参数。

假设世界上只有一个简单到不能再简单的模型：

ŷ=wx

这里：

x 是输入。

w 是模型参数。

ŷ 是模型预测出来的结果。

假设现在：

w=3

给模型一个输入：

x=2

那么模型会得到：

ŷ=3×2=6

现在训练数据告诉我们：

当：

x=2

我们希望得到：

y=10

于是现在发生了一件非常普通的事：

模型预测了 6。

正确结果是 10。

人看一眼就知道：

错了。

但问题恰恰出在这里。

“错了”这两个字，对计算机没什么用。

因为模型下一步必须修改参数。

它需要知道的不是：

“我错了。”

而是：

我到底错了多少？

这就是整个机器学习世界里第一个真正重要的角色：

Loss。

二、Loss 并不是“报错值”，它是在定义什么叫“好”

我们可以定义一个非常简单的 Loss：

L=½(ŷ-y)2

不用急着纠结这个公式为什么这样写。

先把数字代进去。

预测结果：

ŷ=6

正确结果：

y=10

所以：

L=½(6-10)2

得到：

L=8

现在模型第一次拥有了一个可以用于训练的信息：

Loss=8

注意这里发生了一个非常重要的转换。

原来我们说：

“这个答案不好。”

这是一种人类语言。

现在变成：

8

这是一个机器可以计算、比较和优化的数字。

所以我更愿意这样理解 Loss：

Loss 的作用，是把“好不好”翻译成数学。

这比“Loss 就是模型预测错误的大小”更重要。

因为只要你继续学习大模型，很快就会发现：

不同训练方法真正有意思的地方，往往就在于它们如何定义“好”。

Pretraining 有自己的目标。

SFT 有自己的目标。

Preference Learning 有自己的目标。

DPO、PPO、GRPO 又有自己的目标。

所以从今天开始，不要再把 Loss 看成控制台里那个不断下降的小数。

它实际上决定了一件非常根本的事：

模型到底被要求朝哪个方向变好。

但现在我们又遇到了一个新问题。

知道：

Loss=8

又能怎么样？

三、知道考了 40 分，不代表你知道该改哪里

想象一个学生考试考了 40 分。

老师只告诉他：

“你考了 40 分。”

这个信息有没有用？

有。

至少他知道成绩不好。

但对于下一次考试而言，这个信息远远不够。

因为真正需要知道的是：

数学哪里错了？

英语哪里错了？

哪道题需要重新学？

哪些地方已经做得不错，不应该乱改？

模型也是一样。

我们现在只知道：

Loss=8

但真正想知道的是：

当前：

w=3

到底应该怎么改？

变成 2.9？

3.1？

4？

还是 10？

Loss 只告诉我们：

现在不好。

它没有直接告诉我们：

参数往哪边改会变好。

所以机器学习需要第二个非常关键的东西：

Gradient

梯度。

四、第一次学 Gradient，千万别先把它理解成“求导”

很多人第一次在这里掉队。

教材开始写：

Derivative。

Partial Derivative。

Chain Rule。

Jacobian。

Computational Graph。

符号越来越多，于是一个本来很直观的概念，被硬生生讲成了高数考试。

其实理解 Gradient，可以先把所有数学放一边。

想象一下：

你现在站在一座大山上。

四周都是浓雾。

你看不见整座山。

也不知道最低的山谷到底在哪里。

但你有一个能力：

你能够感觉脚下的坡度。

于是你可以知道：

往左走，地势升高。

往右走，地势下降。

往前走，下降得更快。

如果你的目标是下山，那么这个信息已经非常有用了。

Gradient 干的事情就很像这样。

参数 w，是你现在所处的位置。

Loss，是你当前位置的高度。

Gradient 告诉你：

如果稍微改变参数，Loss 会朝哪个方向变化，以及变化有多快。

现在回到我们的模型：

ŷ=wx

Loss：

L=½(wx-y)2

我们关心：

如果稍微改变 w，Loss 会怎样变化？

数学上写作：

∂L/∂w

计算以后：

∂L/∂w = (wx-y)x

现在代入：

w=3, x=2, y=10

于是：

∂L/∂w = (3×2-10)×2

得到：

∂L/∂w=-8

如果你第一次看到这里，我不希望你记：

“导数等于负八。”

我希望你脑子里翻译成一句人话：

现在把 w 往大的方向调一点，Loss 会下降。

为什么？

因为 Gradient 指向 Loss 上升最快的方向。

现在 Gradient 是负的。

所以我们反着走，就是增加 w。

这才是 Gradient 对训练真正有用的地方。

它不是数学装饰。

它是模型修改参数时的：

方向信息。

五、接下来这一刻，就是“学习”真正发生的瞬间

现在我们知道：

当前参数：

w=3

Gradient：

-8

于是可以开始更新参数。

最简单的更新规则是：

wnew=w-η∂L/∂w

这里出现了一个新符号：

η

它就是 Learning Rate，学习率。

先别把它想复杂。

学习率干的事情就是：

知道往哪边走以后，一步到底走多远。

假设：

η=0.1

那么：

wnew=3-0.1×(-8)

所以：

wnew=3.8

注意。

就在这一瞬间：

3→3.8

模型完成了一次真正意义上的学习。

没有魔法。

没有“知识突然进入模型”。

也没有某个隐藏模块突然觉醒。

真正发生的事情就是：

参数从 3 变成了 3.8。

但关键是，这并不是随便改的。

它是根据 Loss 产生的 Gradient 改的。

我们现在重新让模型预测。

原来：

w=3

所以：

ŷ=6

现在：

w=3.8

于是：

ŷ=3.8×2=7.6

重新计算 Loss：

L=½(7.6-10)2

得到：

L=2.88

刚才：

Loss=8

现在：

Loss=2.88

模型确实变好了。

这就是一次完整的 Training Step。

六、把训练再跑几次，你就会看见“学习”的样子

第一次：

w=3

然后更新成：

3.8

继续计算。

参数还会继续移动，大致形成这样的过程：

3 → 3.8 → 4.28 → 4.568 → ⋯

慢慢接近：

5

为什么是 5？

因为：

5×2=10

刚好符合训练数据。

现在再回头看“机器学习”这个词。

是不是突然没那么玄学了？

所谓 Learning，并不是机器像人一样突然想明白了什么。

至少从训练机制来看，它干的是：

当前参数产生预测。

预测产生 Loss。

Loss 告诉我们当前有多差。

Gradient 告诉我们该往哪个方向修改参数。

然后真的修改参数。

接着重新来一次。

所以整个训练过程，可以压缩成一条非常重要的链：

这条链，我建议你真正记在脑子里。

不是背。

而是做到以后看到任何训练算法，都可以把它放回这条链里。

七、Learning Rate 为什么不是越大越好？

这里顺手解决一个特别容易理解错的问题。

刚才我们的 Gradient 是：

-8

如果：

η=0.1

那么：

w:3→3.8

结果很好。

于是有人可能会想：

既然方向已经知道了，那干脆走快一点。

把：

η

直接设成 1。

结果会怎样？

wnew=3-1×(-8)

得到：

wnew=11

模型现在预测：

ŷ=11×2=22

正确答案还是：

10

新的 Loss：

L=½(22-10)2=72

刚才还是：

8

现在直接变成：

72

方向明明没错，为什么反而更糟？

因为你一步跨过头了。

这件事特别重要。

它告诉我们：

Gradient 不是“正确参数在哪里”的导航坐标，它只描述当前附近的局部地形。

你走一步以后，情况已经发生变化。

需要重新计算。

这也解释了为什么真实大模型训练绝不是：

“算出 Gradient，然后一直减就行了。”

怎么控制步长？

怎么利用过去的 Gradient？

某些方向变化很大怎么办？

某些参数几乎没有 Gradient 怎么办？

怎么减少震荡？

怎么让训练更稳定？

这些问题最终会把我们带到：

SGD。

Momentum。

Adam。

AdamW。

Muon。

所以 Optimizer 从来不是凭空出现的一堆算法。

它解决的是一个特别朴素的问题：

我已经知道大概该往哪边走了，但到底应该怎么走？

八、现在把一个参数换成 70 亿个参数

到这里，我们终于可以把“大模型”三个字放回来。

刚才模型只有一个参数：

w

真正的神经网络当然不是这样。

它可能有：

w1,w2,w3,…

甚至数十亿、数百亿个参数。

所以我们通常不再一个个写，而是统一表示成：

θ

模型也从：

ŷ=wx

变成：

ŷ=fθ(x)

这个表达非常重要。

它实际上是在说：

模型是一个由参数 θ 决定的函数。

输入：

x

经过当前这组参数计算以后，得到：

fθ(x)

然后和训练目标比较，产生 Loss：

L(fθ(x),y)

再计算所有参数对应的 Gradient：

∇θ L

最后更新：

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

看到这里，有一个非常值得停几秒钟想一下的地方。

前面那个只有一个参数的小模型，和拥有几十亿参数的大模型，在数学骨架上竟然没有发生本质变化。

小模型：

w → Loss → Gradient → Update

大模型：

θ → Loss → Gradient → Update

复杂度暴涨了。

但“学习”这件事的底层逻辑没有变。

这就是为什么第一课一定不能一上来就钻 Transformer。

Transformer 只是告诉我们：

fθ

到底长什么样。

而训练真正解决的是：

θ

到底怎样一点一点变好。

九、真正夸张的问题其实不是“70 亿参数很多”

70 亿这个数字听上去很吓人。

但更值得震撼的问题不是：

“怎么存下 70 亿参数？”

而是：

模型只产生一个 Loss，怎么知道几十亿个参数分别应该往哪里改？

假设模型完成一次预测以后：

Loss=2.31

这只是一个数字。

但模型里面可能有：

θ1,θ2,θ3,…,θ7,000,000,000

我们真正想得到的是：

\frac\partial L\partialθ1

\frac\partial L\partialθ2

\frac\partial L\partialθ3

一直到所有参数。

换句话说：

模型最后只答错了一次。

但我们希望知道：

第一个参数负多少责任？

第 100 个参数呢？

第 100 万个呢？

第 30 亿个参数又应该动多少？

这件事情，才是 Backpropagation 真正解决的问题。

所以以后学反向传播的时候，别只把它理解成：

“链式求导。”

那只是数学实现。

它真正干的事情可以说得非常人话：

把最终错误的责任，一层一层往回分。

Loss 在最末端。

Backpropagation 沿着整个计算过程反向走。

最后把“该改多少”传递到模型内部大量参数上。

这样下一次参数更新才有可能发生。

理解到这一层，反向传播就不再是考试题了。

它是整个神经网络能够学习的核心机制之一。

十、训练大模型，其实是在一个极高维空间里“找位置”

现在换一个角度理解。

假设模型只有两个参数：

w1,w2

那么每一组参数都可以理解成平面上的一个位置。

比如：

(1,2)

是一种模型。

(1.5,4)

又是另一种模型。

每个位置都有自己的 Loss。

于是训练就像在一张地形图上找比较低的位置。

如果有三个参数，就是三维空间。

那 70 亿个参数呢？

就是一个大约 70 亿维的参数空间。

我们已经完全没有办法直观想象它长什么样了。

但数学仍然可以处理。

模型刚初始化时，在这个超高维空间的某个位置：

θ0

算一次 Gradient。

走一步：

θ1

再算。

再走：

θ2

不断继续：

θ0 → θ1 → θ2 → θ3 → ⋯

所以如果一定要给“训练大模型”找一个非常准确的直觉，我更喜欢这样说：

训练是在一个高得无法想象的参数空间里，根据数据不断获得方向信号，然后一步一步寻找更好的参数区域。

这比“把知识灌进去”准确得多。

十一、一个很容易误解的问题：参数是不是一个“知识数据库”？

很多人会自然想象：

“法国首都是巴黎”是不是被存在某几个参数里？

“Python 的 for 循环”存在另外几个参数里？

“牛顿第二定律”又存在另外几个？

如果真是这样，大模型就很像一个超大数据库。

但神经网络没这么简单。

训练过程实际上是：

一次样本产生 Loss。

Loss 产生大量 Gradient。

大量参数发生微小变化。

下一批数据又继续修改它们。

同一个参数可能同时参与很多不同模式。

同一个能力也可能依赖大量参数之间的组合。

这就是为什么后面我们会学到一个非常重要的词：

Distributed Representation

分布式表示。

也就是说：

知识和能力通常不是简单地“一条知识对应一个格子”。

所以大模型训练不是：

找到一块空内存。

写入：

“巴黎 = 法国首都”。

而是不断改变整个模型内部的表示和计算关系，使模型在类似上下文下越来越倾向于产生正确的预测。

这两个直觉差别非常大。

十二、终于可以正式回答：模型到底在优化什么？

我们可以把整个训练目标写成：

θ* = arg minθ 1/N Σi=1N L(fθ(xi),yi)

第一次看到别急着往下滑。

这其实就是把刚才所有东西压缩成了一行。

拆开看。

θ

模型参数。

fθ(xi)

模型对第 (i) 个样本的预测。

yi

第 (i) 个训练目标。

L

模型当前预测得有多不好。

Σi=1N

说明我们不能只在一个样本上表现好，而要考虑大量训练数据。

最前面的：

arg minθ

翻译成人话就是：

找到一组参数，让整体 Loss 尽可能小。

所以如果别人问：

“机器学习里的 Optimization 到底是什么？”

你完全可以回答：

寻找更好的参数。

再具体一点：

在训练数据和目标函数确定以后，通过 Gradient 和 Optimizer 不断修改参数，让模型的 Objective 越来越好。

这就是训练。

十三、这里必须补上一刀：Loss 下降，不代表模型一定“更聪明”

这是第一课非常容易被忽略，但极其重要的一点。

既然训练是在降低 Loss，那是不是：

Loss↓

就一定意味着：

Intelligence↑

不是。

因为机器真正优化的是：

Objective

而我们真正想要的是：

正确。

有用。

会推理。

会写代码。

懂人类指令。

少胡说。

能够调用工具。

能够完成长任务。

这两件事不一定完全重合。

举个极端例子。

一个学生把训练题答案全背下来了。

训练集上的错误率可以非常低。

但换一道稍微不同的问题，他完全不会。

那么他的：

Training Performance 很好。

Generalization 却很差。

模型也是一样。

所以以后看到：

Training Loss 一直下降。

千万不要直接翻译成：

“模型能力一直稳定提升。”

训练指标和真实能力不是完全等价的。

这个认知后面会越来越重要。

因为大模型训练后半程真正困难的东西，很多时候已经不是：

怎么让模型优化。

而是：

我们到底该优化什么，才能得到真正想要的能力？

这就是为什么后来会出现 SFT、Preference Learning、RLHF、DPO、GRPO、RLVR。

它们看似离今天很远。

其实都没有逃出第一课的问题。

十四、以后看到任何训练技术，都先问这四件事

学到这里，我建议你建立一个习惯。

以后再看到一个新算法，不要第一反应去背它的缩写。

先把它拉回最底层。

问：

它吃什么 Data？

模型的 Architecture 是什么？

它到底定义了什么 Objective？

最后 Parameter 是怎样被 Update 的？

这四件事一问，很多复杂技术马上会变得清楚。

为什么？

因为大量所谓“新技术”，其实只是改变了训练链条中的某一环。

AdamW 主要研究的是：

已经有 Gradient 以后，Parameter 怎么更新。

MoE 主要改变的是：

Model Architecture 怎么组织参数和计算。

SFT 改变了：

训练数据和训练目标。

DPO 研究的是：

如何把 Preference 直接变成 Policy 的优化信号。

PPO、GRPO 则进一步引入：

Reward。

名字完全不同。

论文长得完全不同。

但把它们全部剥到底层，仍然逃不开：

这就是第一课真正应该建立起来的“母结构”。

十五、现在还有最后一个问题，而且它会直接把我们带进 LLM

前面一直用了：

(x,y)

也就是说：

给模型一个输入 x。

然后有一个训练目标 y。

对于刚才的小模型很好理解。

输入：

2

目标：

10

图像分类也很好理解。

输入一张猫的照片。

目标：

“猫”。

问题来了。

语言模型的 y 是什么？

假设有一句话：

“今天工作结束以后，我准备去……”

后面可以是：

吃饭。

跑步。

看电影。

回家。

买东西。

语言并不像普通分类一样，每一个输入都有唯一正确答案。

那我们到底怎么把互联网上海量文本变成机器可以训练的：

(x,y)

？

这里出现了一个极其简单，却影响了整个大模型时代的想法：

把下一个 Token 当成答案。

假设有一句：

“我喜欢机器学习”

那么训练时可以不断构造问题。

看到：

“我”

预测后面的 Token。

看到：

“我喜欢”

继续预测下一个。

看到：

“我喜欢机器”

再预测下一个。

于是原本只是普通文本的数据，突然之间可以自动产生大量训练目标。

而真正离谱的地方还不是这个。

真正值得追问的是：

一个模型明明只是在不断练习“下一个 Token 是什么”，为什么最后却可能学会事实知识、语言规律、写代码，甚至表现出复杂推理能力？

如果你现在开始觉得这个问题有点不可思议，那么很好。

因为我们终于走到了大语言模型真正的起点。

第一课结束前，我希望你脑子里留下的不是公式

今天出现了很多词。

Parameter。

Loss。

Gradient。

Optimizer。

Learning Rate。

Backpropagation。

但如果看完以后，你只是多记住了六个英文单词，那这篇就白写了。

我真正希望你建立的是下面这个过程。

模型拿到 Data。

当前 Parameters 决定它怎样计算。

它产生 Prediction。

Prediction 和训练目标之间形成 Loss。

Gradient 从 Loss 中告诉我们：

参数在当前位置应该往什么方向移动。

Optimizer 决定具体怎么走。

参数被更新。

于是：

Old Model

变成：

New Model

然后继续下一轮。

不断重复。

这就是训练。

到这里，你应该能够用自己的话解释一句以前很容易听过去的话：

大模型不是被“编程”出能力的，而是通过优化得到了一组能够表现出这些能力的参数。

这一句真正想明白之后，Transformer 就不再是一座突然出现的大山。

它只是我们接下来要研究的：

那个被训练的函数，到底是怎么设计出来的。

而在进入 Transformer 之前，我们还必须解决一个更关键的问题：

为什么大语言模型偏偏选择“预测下一个 Token”作为训练起点？

更准确地说：

为什么这么简单的目标，最后居然能逼着模型学到这么多东西？

下一课，我们就从这里开始。