Requiem如是说

Appearance

第三阶段：训练过程 —— 详解 ​

读完这篇，你会搞懂：一个只会"续写"的基座模型，经过怎样的训练流程变成能对话、能推理、能遵循指令的 AI 助手。 预计阅读时间：60-75 分钟。

目录 ​

概览：从"会续写"到"会聊天"的旅程 ​

第二阶段我们拆解了 Transformer 的内部结构——它本质上是一台"下一个词元预测机"。但光有架构还不够，架构只是骨架，参数才是血肉。一个未经训练的 Transformer 输出的全是随机噪音，要让它变成 ChatGPT 或 Claude 这样的对话助手，需要经过一整套训练流程。

现代 LLM 的训练管线分为三个大阶段：

训练三阶段总览

第一阶段——预训练：在海量互联网文本上做 next-token prediction。这个阶段最贵、最慢，占整个训练成本的 95% 以上。产出的基座模型会续写文章，但不会和人对话——你跟它说"帮我写一首诗"，它可能续写"……的优秀范例包括……"，因为它只见过续写任务，没见过指令-回答的格式。

第二阶段——监督微调（SFT）：用几万到几十万条人类标注的"指令→回答"范例来训练。数据量远小于预训练，但格式对路，模型很快就学会了"用户说 A，我应该回 B"的模式。

第三阶段——对齐（Alignment）：让模型不仅有问有答，还要答得"好"——有用、安全、符合人类偏好。最常见的手段是 RLHF（基于人类反馈的强化学习）和 DPO（直接偏好优化）。2026 年的趋势是用可验证奖励（RLVR）替代主观的人类偏好标注。

这三个阶段结束后，一个 AI 助手就诞生了。接下来我们逐个展开。

3.1 预训练（Pre-training） ​

数据从哪里来 ​

预训练的数据就是"整个互联网的精华部分"。2026 年主流模型的训练数据来源大致如下：

数据来源占比（估）说明
Common Crawl（网页抓取）50-60%最大的公开语料库，每月抓取数十亿网页，但原始质量极低
书籍5-10%Books3、Gutenberg 等，提供高质量长文本
代码库10-15%GitHub 公开仓库、Stack Overflow，大幅提升模型推理能力
Wikipedia 及百科3-5%多语言、结构化、高质量的事实性知识
学术论文3-5%arXiv、PubMed 等，提供严谨的科学文本
论坛 / 社交媒体5-10%Reddit、知乎等，提供对话式、非正式语言
新闻媒体3-5%时效性信息
多语言语料5-10%非英语数据，中文模型的训练数据中中文占比通常 30-40%

数据不是下载下来就能用的，需要经过一整套数据清洗 pipeline：

  1. 去重：互联网上同一篇文章可能被转载几百次。用 MinHash 等算法（一种快速近似去重技术，无需逐字比对即可找出相似文档）进行模糊去重，确保模型不会在同一段话上"刷题"几十遍。
  2. 质量过滤：删除过短、乱码、纯数字、纯符号的文本。2026 年的做法是训练一个轻量级分类器来自动判断文本质量，替代了早期的规则过滤。
  3. 去隐私：移除邮箱、手机号、身份证号等个人身份信息。
  4. 毒性过滤：删除仇恨言论、极端暴力等内容。
  5. 语言识别：只保留目标语言的文本（对中文模型来说，会专门标出中英文混合内容）。

经过这套 pipeline 后，原始爬取的 100TB 数据通常只剩下 1-5TB 的高质量文本。数据清洗是预训练的隐形壁垒——算法大家都差不多，但数据质量的差距直接决定了模型质量。

训练目标：Next-Token Prediction ​

预训练的任务简单但极其暴力：给模型看一段文本，让它预测下一个词元。

具体做法是把一段文本切成一串 token ，然后：

  • 输入 ，让模型预测
  • 输入 ，让模型预测
  • 输入 ，让模型预测
  • ……

每次预测，模型输出的是整个词表（通常 10 万-20 万个词元）上的概率分布，然后拿正确答案的负对数似然作为损失：

这个公式翻译成人话：模型认为正确答案的概率越大，损失越小；如果模型把正确答案排在很低的位置，损失就很大。

交叉熵损失（Cross-Entropy Loss） ​

上面那个公式就是交叉熵损失。这个概念在 AI 训练中极其核心，值得展开讲。

一句话定义：交叉熵衡量两个概率分布之间的"距离"——一个是模型预测的分布，一个是真实答案的分布。

先看一个具体例子。假设词表只有 4 个词：[猫, 狗, 鱼, 鸟]，模型要预测下一个词。在某一时刻：

模型预测的概率分布 Q:  [猫: 0.1, 狗: 0.6, 鱼: 0.2, 鸟: 0.1]
正确答案的分布 P:      [猫: 0.0, 狗: 1.0, 鱼: 0.0, 鸟: 0.0]  ← "狗"是正确答案

正确答案的分布是一个 one-hot 向量（独热编码）——只有正确答案那一位置是 1，其余全为 0。就像一个单选题的答题卡：4 个选项中只有被涂黑的那个是"对"的。

交叉熵的公式：

由于 中只有正确答案那一项是 1，其余都是 0，公式化简为：

上例中，狗，所以损失 。

如果模型预测得很准（狗），损失 ——很小。 如果模型预测得很差（狗），损失 ——很大。

用一个图来感受 的形状：

交叉熵损失曲线

关键特征：当模型概率从 0.01 提升到 0.1 时，损失从 4.6 降到 2.3（降了 2.3）；但从 0.9 提升到 0.99 时，损失只从 0.105 降到 0.010（降了 0.095）。 这个形状决定了训练初期（模型还很菜时）损失下降很快，训练后期下降越来越慢——这是完全正常的训练曲线形态。

为什么是 而不是其他函数？这和信息论中的"编码长度"概念有关。 可以理解为：如果模型认为某事件概率是 ，那么用最优编码方案传递这个事件需要多少比特。交叉熵本质上衡量的是"用模型 Q 的编码方案去传递真实分布 P 的信息，会浪费多少比特"。这个理论基础让交叉熵成为概率预测任务中最自然的选择。

在实际训练中，预训练数据有几万亿个 token，每一步训练的损失是把当前批次（batch）中所有 token 的损失取平均。这个平均值就是模型在"这批数据上表现有多差"的量化指标。

困惑度（Perplexity）：比损失更直观的指标 ​

交叉熵损失的数值（0.5、1.2、3.7……）本身不太直观——"loss=2.5"到底算好还是算差？AI 社区引入了一个更易理解的指标：困惑度（Perplexity，简称 PPL）。

翻译成人话：困惑度表示模型在每个预测位置上，平均相当于从多少个等可能的候选中做选择。

交叉熵 Loss困惑度 PPL直觉解读
0.01.0模型 100% 确定，只有一个候选——这是理论下限
0.6932.0模型在 2 个等可能的词之间纠结
1.0993.03 个候选
2.30310.010 个候选——已经不太确定了
4.605100.0100 个候选——基本在瞎猜

为什么是 而不是 2 或 10 为底？因为交叉熵公式里用的 默认是以 为底的自然对数 。所以 ，困惑度和损失是一一对应的转换关系。

用之前的例子验证：模型给"狗"的概率是 0.6，损失 = -ln(0.6) ≈ 0.511，困惑度 = e^0.511 ≈ 1.67。也就是说，虽然模型最可能选"狗"，但它对"猫"（0.1）和"鱼"（0.2）也有一定考虑——等效于在约 1.67 个选项中犹豫。

2026 年前沿模型的典型预训练困惑度：

模型规模预训练 PPL（估）说明
小模型（~1B）8-15语言规律基本掌握，细节模糊
中模型（~7B）6-10大多数预测比较确定
大模型（~70B）4-7非常确定，但仍有意外
前沿模型（>200B）3-5接近人类水平（人类 PPL 约 2-3）

困惑度的下限是 1.0（完全确定），但自然语言天然有不确定性——同一个上文可以合理接多种下文。所以即使完美模型，PPL 也做不到 1.0。人类在相似预测任务上的 PPL 大约在 2-3 之间，这是语言的固有熵。

困惑度色阶

一个完整的多 Token 损失计算走读 ​

前面讲的是单个 token 的损失，但实际训练中是一整句话一起算的。下面用一个完整的例子走一遍，看看损失到底是怎么出来的。

假设模型正在处理一句话，词表只有 6 个 token：[the, cat, sat, on, mat, <EOS>]。给定上文 "the cat"，模型需要预测下一个 token。在预训练中，整个句子拆成 4 个预测任务：

位置1: 输入 [the]           → 预测 cat     （正确答案是 cat）
位置2: 输入 [the, cat]      → 预测 sat     （正确答案是 sat）
位置3: 输入 [the, cat, sat] → 预测 on      （正确答案是 on）
位置4: 输入 [the, cat, sat, on] → 预测 mat （正确答案是 mat）

每一步，模型输出词表上 6 个词的概率分布。假设某次训练时的预测如下：

位置上下文正确答案模型给正确答案的概率该位置的 Loss (-ln p)
1thecat0.40-ln(0.40) = 0.916
2the catsat0.25-ln(0.25) = 1.386
3the cat saton0.50-ln(0.50) = 0.693
4the cat sat onmat0.80-ln(0.80) = 0.223

平均损失 = (0.916 + 1.386 + 0.693 + 0.223) / 4 ≈ 0.805

对应困惑度 = e^0.805 ≈ 2.24——模型在每个位置上平均约在 2 个选项中犹豫。

位置 2（sat）的损失最大（1.386），因为模型只给了 25% 的概率。这说明在 "the cat" 之后，模型还没学会"猫最常见的动作是坐"。随着训练推进，模型在类似模式上反复看到 "the cat sat"，对 sat 的概率会逐渐提高——损失自然下降。

位置 4（mat）的损失最小（0.223），因为上文已经给出了强大的线索（"the cat sat on the..."），模型非常确定接下来是 mat。

这就是交叉熵在真实训练中的运作方式：每个位置独立预测，所有位置的损失取平均，优化器让这个平均值越来越小。

损失下降曲线：训练健康的晴雨表 ​

一个健康的预训练，损失曲线长这样：

训练损失曲线

  • 前 20% 步数：损失断崖式下降（6→3），模型学会了语言最基本的结构（常见词搭配、标点用法）
  • 中间 60% 步数：平缓下降（3→2），模型在消化大量的事实知识和语言细节
  • 最后 20% 步数：越来越慢（2→1.8），边际收益递减——每个 token 能榨出的信息越来越少

如果训练曲线突然出现尖刺（Loss Spike），就说明训练出了问题（通常是学习率太大或数据里有脏数据）。

还有一种更隐蔽的问题——训练损失一直在降，但验证损失不降反升。这就是过拟合，下面单独展开。

过拟合：背答案 ≠ 学规律 ​

一句话：过拟合 = 模型把训练数据"背"下来了，但碰到没见过的题就不会做。

用考试来类比最直观——两个学生：

  • 学生 A 理解了"三角形面积 = 底 × 高 ÷ 2"，题目怎么变形都会做
  • 学生 B 把练习册所有答案背下来，题干稍微换几个字就不会

学生 B 就是过拟合——练习册正确率 100%（训练集损失极低），一上考场就崩（验证集损失飙升）。模型记住的不是"语言本身的规律"，而是"这批训练数据里有哪些具体的句子"。

如何发现过拟合？

训练时会专门留出一部分数据不给模型练，只用来定期检查——这叫验证集。每跑完一定步数，用验证集算一次损失，不更新参数。两边的损失曲线放在一起看：

过拟合曲线

  • 训练损失（蓝线）：一路下降，模型对它看过的数据越来越熟
  • 验证损失（红线）：先跟着降（学到了通用规律），降到某一点后开始反弹上升——模型不再学习规律，而是在记忆训练数据里的噪音和巧合

两条曲线分叉的位置叫最佳停止点——那是模型泛化能力最强的时候，再往后训练只会越来越"死记硬背"。

为什么会过拟合？

原因解释
数据太少没看够"题型"，模型只好死记硬背
模型太大参数量远超样本量，记忆容量绰绰有余
训得太久规律学完之后，剩余步数无事可做，开始背细节
数据重复同一内容出现太多次，模型学会套模板

预训练阶段数据量巨大（万亿级 token），过拟合不太常见——数据还没背完就训完了。SFT 和微调阶段才是过拟合的高发区：数据只有几千到几万条，模型又很大，一不小心就会背下来。

怎么防？

1. 早停（Early Stopping）——最简单有效的方法。盯着验证损失，一旦不再下降就开始犹豫，一旦上升立刻停。不需要改模型、不需要改数据。

2. Dropout——训练时随机丢弃 5%-10% 的神经元连接，每次前向传播的网络都略有不同。效果是逼模型"不要把希望寄托在某一根筋上"，必须学会冗余、泛化的表达。推理时关掉 Dropout，所有连接恢复正常。

3. 权重衰减（Weight Decay）——在损失函数上额外加一项：参数值越大，扣分越多。鼓励模型用小的参数去拟合数据，避免某些参数长得过于极端。AdamW 公式最后的 -η·λ·θ 做的就是这件事。

4. 更多样化的数据——不是更多同类数据，而是更多"花样"。不同风格、不同写法、不同领域。多样性 > 数量。

5. LoRA 自带防过拟合——微调时只调整低秩矩阵（r = 16 或 32），原始权重完全冻结。小秩相当于给模型上了"紧箍咒"：你想调整答案可以，但只能在 16 维的小空间里调，不能把整个 4096 维参数表全改了。这种强约束天然抑制了过拟合。

反向传播与梯度下降 ​

有了损失函数，下一步就是更新模型参数让损失变小。这需要两个算法配合：反向传播（Backpropagation）算梯度，梯度下降（Gradient Descent）用梯度更新参数。

梯度是一个函数在每个参数上的"偏导数"组成的向量，指向函数值增长最快的方向。由于我们要让损失变小，所以沿着梯度的反方向走。

先理解"调收音机旋钮"的类比：

你面前有一台老式收音机，上面有几千亿个旋钮（模型参数）。你想收听某个电台（让模型准确预测下一个词），但目前全是噪音。你小心翼翼地扭转第一个旋钮一点点，听听噪音是变大了还是变小了。如果变小了，继续往那个方向转；如果变大了，就往反方向转。然后换下一个旋钮……等把所有旋钮都拧过一遍，噪音比刚才小了一点点。重复几百万次，电台就越来越清晰了。

这个类比中，"听噪音大小"就是前向传播 + 计算损失，"判断应该往哪个方向拧"就是反向传播，"实际拧旋钮"就是参数更新。

正式的三个步骤：

Step 1：前向传播（Forward Pass） 输入一批 token（整数 ID），让它们依次经过 Embedding 层（把每个 token ID 查表转成一个高维稠密向量，第二阶段第二站有详细讲解）→ 每一层 Transformer → 最后的输出层（把向量映射回词表大小的概率分布）。用交叉熵算出损失值。

Step 2：反向传播（Backward Pass） 从损失值出发，利用微积分的链式法则，逐层往回计算每个参数对损失的贡献（即梯度）。这个过程叫自动微分（Automatic Differentiation）——你不用手算导数，深度学习框架（如 PyTorch、JAX 等 Python 库）会自动追踪每一步计算，帮你把梯度算出来。关于反向传播的详细机制和为什么需要残差连接来防止梯度消失，第二阶段的第五站已经展开讲过。

Step 3：参数更新（Optimizer Step） 最简单的更新规则——梯度下降：

其中 是学习率（Learning Rate），控制每一步走多大。太大容易跳过最优解（甚至发散），太小训练太慢。

实践中用的是 AdamW 优化器，这是 Adam 的改进版，核心改进有两个：

  • 动量（Momentum）：不只看当前这一步的梯度，还"记住"前几步的方向。类似推一个很重的球下坡——球有了惯性，即使局部有个小坑也不会卡住。
  • 自适应学习率：不同参数的学习率不同。经常被更新的参数学习率自动调小（"你已经够好了，不用再大动了"），很少被更新的参数学习率自动调大（"你还没怎么学过，加快点"）。

AdamW 更新公式（不必背，感受一下复杂度就行）：

最后一项 是权重衰减（Weight Decay）——每次更新都把所有参数往零的方向拉一点点，防止某些参数长得太大导致过拟合。这是 AdamW 和原始 Adam 的主要区别。

整个训练流程串起来：

训练循环

训练硬件：GPU 集群 ​

预训练需要成千上万个 GPU 协同工作数月。单卡跑不动的原因很简单：一个 671B 参数的模型（如 DeepSeek V4 的 MoE 版本），即使把每个参数压缩到 4-bit（量化，即用低精度存储，详见 3.5 节）也需要 ~335GB 显存，而一张 H100 只有 80GB。所以必须把模型拆开，分散到多张卡甚至多台机器上。

并行策略概览：

策略做法通信模式通信量
数据并行（DP）每张卡有完整模型副本，分到不同批次数据，最后同步梯度All-Reduce= 参数量（每步）
张量并行（TP）把一层内的矩阵乘法切开，不同卡算不同部分All-Reduce= 每层激活值（每层）
流水线并行（PP）不同层放在不同卡上，像流水线一样传递中间结果点对点（P2P）= 层间激活值（每 micro-batch）
序列并行（SP）把长序列按 token 维度切开All-Gather中等
专家并行（EP）MoE 模型中不同专家放在不同卡，按需路由All-to-All取决于路由分布

下面逐个拆解前三种核心策略——它们也是 3D 并行的基石。

数据并行（DP） ​

思路：每张 GPU 都存一份完整的模型，但每张卡吃不同的数据。

具体流程：

  1. 一个 batch 的数据均匀分给 N 张卡（每张卡拿到 batch/N 条样本）
  2. 每张卡独立做前向传播 → 算 loss → 反向传播 → 算出自己的梯度
  3. 所有卡用 All-Reduce 通信，把 N 份梯度加在一起取平均
  4. 每张卡用平均后的梯度更新自己的模型参数

因为每张卡的模型副本完全一样、梯度也完全一样，更新后的参数自然保持一致。

DP 为什么不是银弹：通信量等于模型参数量——每步训练都要把全部梯度的每个字节在 N 张卡之间同步。一个 70B 参数的模型，如果用 FP16 存梯度，每步就要传输 70B × 2 字节 = 140GB 的梯度数据。当 GPU 数量增多时，All-Reduce 的通信时间会成为瓶颈，把"加速"变成"大家一起等网络"。

适用条件：单卡能装下完整模型。对 70B 模型（FP16 约 140GB），单张 H100（80GB）装不下，所以纯 DP 行不通——必须结合其他策略。

张量并行（TP） ​

思路：一层内部的矩阵乘法太大，单卡算不过来——那就把矩阵"切"开，多张卡各算一部分。

以 Transformer 中最常见的 Y = X × W 为例（X 是输入，W 是权重矩阵）：

  • 列切分：把 W 按列切成两份 [W₁ | W₂]，分别放在 GPU0 和 GPU1 上。输入 X 同时发给两张卡，GPU0 算 X × W₁，GPU1 算 X × W₂，最后把结果拼起来。这需要一次 All-Gather（把两半拼成完整输出）。
  • 行切分：把 W 按行切成两份，但输入 X 也要相应切列。两张卡分别算，结果做 All-Reduce 求和。

这两种切法在 Transformer 的 MLP 和 Attention 层中交替使用，形成"列切 → 行切 → 列切 → 行切"的节奏。

TP 的核心约束——必须在同一台机器内：TP 每经过一个 Transformer 层就要做一次 All-Reduce，通信频率极高。例如一个 80 层的模型，一次前向就要 80+ 次 All-Reduce。这要求通信带宽极高、延迟极低——只有 NVLink（同一节点内 GPU 直连，900 GB/s）能满足。一旦跨机走 InfiniBand（~400 GB/s 且延迟更高），TP 的通信开销就会把加速吃光。因此 TP 的规模通常不超过一台机器内的 GPU 数（2-8 张）。

流水线并行（PP） ​

思路：把模型按层切开——GPU0 管第 1-10 层，GPU1 管第 11-20 层，以此类推。数据像流水线一样依次经过每张卡。

前向过程：GPU0 算完前 10 层 → 把中间结果（激活值）发给 GPU1 → GPU1 继续算 11-20 层 → 发给 GPU2 → …… → 最后一张卡输出 loss 并开始反向传播，梯度沿原路传回。

气泡问题（Bubble）——PP 的头号痛点：

流水线的天然缺陷是"前面的人要等后面的人"。假设 4 张卡各管 10 层：

时间 →
GPU0: [F0====] [F1====] [          空闲          ] [B0====] [B1====]
GPU1: [ 空闲  ] [F0====] [F1====] [          空闲          ] [B0====]
GPU2: [ 空闲  ] [ 空闲  ] [F0====] [F1====] [          空闲          ]
GPU3: [ 空闲  ] [ 空闲  ] [ 空闲  ] [F0====] [F1====] [          空闲  ]
                                              ↑ 大片空白 = 气泡

GPU 大部分时间在闲着——这就是"气泡"。PP 阶段越多，气泡占比越高。

微批次（Micro-Batching）——填上气泡的关键：

把一个大 batch 切成 M 个小份（micro-batch），像流水线一样连续灌进去：

GPU0: [F0][F1][F2][F3][            ][B0][B1][B2][B3]
GPU1: [  ][F0][F1][F2][F3][         ][  ][B0][B1][B2][B3]
GPU2: [  ][  ][F0][F1][F2][F3][      ][  ][  ][B0][B1][B2]
GPU3: [  ][  ][  ][F0][F1][F2][F3][   ][  ][  ][  ][B0][B1]

切得越细，气泡占比越小。当 M >> P 时，气泡占比趋近于 0（但 micro-batch 太小时 GPU 本身利用率会下降，所以实际取平衡点）。

PP 的通信：PP 的通信是点对点的（P2P），只发生在相邻 GPU 之间，只传每层的输出激活值（通常几十 MB 级别），远低于 TP 的通信量。因此 PP 可以跨节点走 InfiniBand——通信负担小而分散，这是它和 TP 最大的区别。

三种策略的对比 ​

维度DPTPPP
切分对象数据（batch）层内矩阵（W 的行/列）模型层数分组
通信模式All-Reduce（梯度）All-Reduce（每层激活值）P2P（层间激活值）
通信频率每步 1 次每层 1-2 次每个 micro-batch 1 次
单次通信量= 模型参数量中等（取决于 hidden dim）小（几十 MB）
能否跨机能（但通信量大时慢）必须同机（NVLink 才够快）能（通信量小）
典型并行度几十到几千2-8（同机 GPU 数）几到几十

3D 并行：三者如何组合 ​

单独用任何一种策略都有瓶颈，所以实际训练是三者叠加：

3D 并行架构

分层逻辑：

  • 最内层 TP：同一台机器内 2-8 张 GPU 用 NVLink 做张量并行，解决"单层装不进一张卡"的问题。受物理限制，TP 不出机器。
  • 中间层 PP：不同机器之间用 InfiniBand 做流水线并行，解决"层数太多"的问题。利用 micro-batch 填气泡。
  • 最外层 DP：所有机器作为一个整体再做数据并行，解决"数据太多、训练太慢"的问题。梯度跨所有机器 All-Reduce。

一个 70B 模型的实际部署示例：

模型 70B 参数，FP16 训练，每张 H100 有 80GB 显存。 模型本身占 70B × 2 字节 = 140GB，加上优化器状态（AdamW 存两份动量，各 4 字节）约 70B × 8 = 560GB，单卡无论如何装不下。

典型方案：TP=4（一台机器内 4 张卡切一层），PP=8（8 个流水线阶段），DP=64（64 份数据并行副本）。 总 GPU 数 = 4 × 8 × 64 = 2048 张 H100。

具体算一下显存：TP=4 后每张卡只存一层参数的 1/4，即单层参数 70B/层数 → 切 4 份。PP=8 后每张卡只负责 1/8 的层数。两者叠加，每张卡实际存储约 70B / 8（PP切层）/ 4（TP切矩阵）× 2 字节 ≈ 4.4GB 的模型参数。加上优化器状态和激活值缓存，每张卡总占用约 60-70GB，恰好塞进 80GB 显存。

序列并行（SP）和专家并行（EP） ​

2026 年的 4D/5D 并行是 3D 的扩展：

  • 序列并行（SP）：当训练上下文越来越长（128K、256K token），单次前向的激活值矩阵巨大。SP 把序列按 token 维度切分到不同 GPU，用 Ring Attention 或类似机制跨卡通信，有效降低单卡的激活值内存峰值。2025 年后主流框架（Megatron-LM、DeepSpeed）已内置支持。
  • 专家并行（EP）：专为 MoE 架构设计。MoE 中每次前向只激活一部分专家（如 8/256），EP 把不同专家放在不同 GPU 上，token 按路由结果"去找"对应专家。通信模式是 All-to-All——token 被分发到不同 GPU（dispatch），计算完后再收集回来（combine），通信量取决于路由分布的均匀程度。

GPU 集群拓扑（2026 年典型配置）：

GPU 集群拓扑

NVLink 负责一机之内的高速通信，InfiniBand（或 RoCE）负责跨机通信。对于 256 张以上 GPU 的集群，InfiniBand 是刚需——多机之间的梯度同步必须在一个合理的时间内完成。

混合精度训练是另一个关键技巧。最早用 FP32（32 位浮点）训练，后来发现大部分计算用 FP16 甚至 BF16 就够了，速度快一倍且省一半显存。2026 年 Hopper 架构（H100/H200）开始支持 FP8 训练，Blackwell 架构（B200）进一步优化了 FP4/FP6 推理。混合精度的做法是：前向和反向传播用低精度（快），参数更新和维护用高精度（稳），两个世界各取所长。

BF16 vs FP16：两者都是 16 位浮点，但"蛋糕切法"不同。FP16 是 1 位符号 + 5 位指数 + 10 位尾数，表示范围只有 ±65504，训练中很容易溢出。BF16 是 1 位符号 + 8 位指数 + 7 位尾数，指数位数和 FP32 一样（都是 8 位），所以表示范围一样大（~±3.4 × 10³⁸），只是精度低一些。对训练来说，范围比精度重要得多——一次溢出比精度损失致命得多。所以 BF16 几乎完全取代了 FP16 成为训练的标准精度。

训练成本（2026 年数据） ​

训练大模型有多烧钱？先看 2026 年的硬件价格：

GPU 型号显存单价（估）租赁价格（GPU/时）
NVIDIA H100 (80GB)80GB HBM3~$30,000$1.76-$2.35
NVIDIA H200 (141GB)141GB HBM3e—~$3.50
NVIDIA B200 (192GB)192GB HBM3e—$4.90-$6.50
AMD MI300X192GB HBM3—~$6.00

不同规模模型的训练成本：

模型规模GPU 数量训练时长纯算力成本（租）全部成本（含硬件、人工、数据）
小模型（<7B）8-64 张 H100几天~几周$5,000-$100,000$50,000-$1,500,000
中等模型（7B-70B）256-2048 张 H1001-3 个月$0.5M-$5M$5M-$50M
大模型（70B-400B）2048-8192 张 H1002-4 个月$5M-$20M$50M-$200M
前沿模型（>400B）10K-20K 张 H1003-6 个月$20M-$100M$700M-$2.5B

几个真实的成本锚点：

  • DeepSeek-V3（2024.12）：公布的训练成本 ~$5.6M（仅 GPU 租赁），但这是单次成功运行的成本。加上失败实验、人员、数据等全部投入，实际远高于此。
  • GPT-4（2023）：据估算训练硬件采购成本约 $800M，但这是一次性硬件投入（可复用），按折旧摊销约 $40M 每轮。
  • 前沿万亿参数模型（2026）：训练一个万亿参数模型，全部投入在 $700M-$2.5B 之间。其中 GPU 芯片占硬件成本的 ~44%，网络互联占 ~9-17%，人才团队（100-300 人）占总开发成本的 ~29-49%。

一个容易被忽略的成本黑洞是 MFU（模型浮点利用率）。大多数集群的 MFU 只有 20-40%——买了 100 张卡，实际只有 20-40 张在有效工作，其余时间在等数据、等通信、处理故障。这意味着有效算力成本是账面的 2-5 倍。

训练成本正以每年约 2.4 倍的速度增长（Epoch AI 数据）。Anthropic CEO Dario Amodei 在 2024 年预测"未来几年会出现十亿美元一次的训练运行"，2026 年看这个预测已经接近兑现。

基座模型的行为特征 ​

预训练完成后的模型叫基座模型（Base Model）。它很聪明，但和你期望的"聊天机器人"完全不同。

它会做什么：给定一段文本开头，续写出合理、连贯、甚至很专业的后续内容。比如输入"勾股定理的证明方法有"，它可能续写"……以下三种：几何拼图法、代数法和欧几里得原本中的面积法。第一种……"——文章水平很高，但它只是遵循训练数据中百科词条的写作模式。

它不会做什么：

  • 不会"回答"问题。你问"什么是勾股定理"，它可能继续写"……是中学数学的重要内容，下面从定义、证明和应用三个方面来学习"（这是教辅材料的续写模式），而不是直接回答"直角三角形两直角边的平方和等于斜边的平方"。
  • 不会拒绝不恰当请求。预训练数据里有各种"禁忌"内容，模型同样会续写，因为它的目标只是"让这段文本看起来像互联网上正常的文章"，而不是"做一个无害的助手"。
  • 不会追问。你跟它说"我不舒服"，它不会问"哪里不舒服"，而是续写一篇关于健康管理的长文。

简单说，基座模型是一个文档续写器，不是对话助手。它需要后面两个训练阶段来"转性"。

训练不稳定性 ​

大模型训练不是一帆风顺的。最常见的问题是 Loss Spike（损失尖峰）——训练曲线本来平稳下降，突然某个 step 损失暴增 10 倍甚至直接变成 NaN。这就是"梯度爆炸"。

发生原因：

  • 某个 batch 的数据恰好包含极端的文本模式（比如大段重复内容）
  • 学习率太高，参数跳到了损失函数的"悬崖"边上
  • FP16 精度下某个中间值溢出

应对策略：

  • Gradient Clipping（梯度裁剪）：设定一个梯度范数的上限（比如 1.0），超过就等比例缩小所有梯度。简单粗暴但有效。
  • 训练状态回滚：检测到 loss spike 后，自动回退到几步之前的参数 checkpoint，跳过那个"有毒"的 batch，从下一个 batch 继续。
  • 混合精度 + 损失缩放：BF16 因为和 FP32 有同样的指数范围，天然抗溢出，这也是它取代 FP16 的核心原因之一。

即便如此，大规模训练仍然需要专门的团队 24 小时"盯盘"——因为每次出问题后从 checkpoint 恢复可能要花好几个小时，团队必须快速判断是回退还是继续。

数据墙（Data Wall） ​

2024-2025 年，AI 行业撞上了一堵"墙"：高质量的公开文本数据不够用了。

Goldman Sachs 首席数据官在 2025 年直言："公开训练数据已经耗尽——不是即将耗尽，是已经耗尽。" Elon Musk 也在 2025 年初表示："人类知识的累计总和在 2024 年已被 AI 训练消耗完毕。"

具体数字：

  • Epoch AI 预测高质量人类文本数据将在 2026-2032 年间接近饱和
  • Stanford 2026 AI Index 报告警告：真实训练数据可能在 6 年内耗尽
  • MIT 研究发现 25% 的最高质量数据源已设置访问限制（OpenAI 被禁止抓取 26% 的顶级数据源）

应对方案：合成数据

既然真实数据不够，就让 AI 自己"造"训练数据。2025-2026 年的代表性工作：

方案来源核心思路
BeyondWebDatologyAI (2025.08)精心设计的合成数据框架，3B 模型用 BeyondWeb 训练的表现在多项任务上超过 8B 模型用 Cosmopedia 训练的结果
REWIREMeta (2025.06)把低质量网页数据"改写"成高质量文本。7B 规模下，22 个任务平均提升 2.5 个百分点，82% 的合成文本来自原本会被丢弃的低质文档

风险：模型崩溃（Model Collapse）

用 AI 生成的数据训练 AI，最大的隐患是模型崩溃。想象一下复印机连续复印：第一代还清晰，第十代就糊成一片了。同理，如果模型反复在自己的输出上训练：

  • 输出会趋向"平均化"，失去多样性和创造力
  • 长尾知识（罕见事实、小语种、冷门专业）最先消失
  • 错误会累积放大——一次生成的幻觉变成下一轮的"训练事实"

Stanford 2026 报告谨慎表态："迄今没有确凿证据表明合成数据可以完全替代真实数据在预训练中的作用。"

数据墙是 2026 年 AI 领域最受关注的问题之一。目前最务实的策略是"两手抓"——继续挖掘企业私有数据、人类标注数据等未被利用的真实数据，同时用越来越成熟的合成数据技术补充。

3.2 监督微调（SFT） ​

SFT 数据长什么样 ​

预训练数据是随意的互联网文本，SFT 数据则是精挑细选的指令-回答对（Instruction-Response Pairs）。每条数据包含：

{
  "instruction": "用简单的语言解释什么是光合作用",
  "input": "",                          ← 可选的上下文
  "output": "光合作用是植物利用阳光、水和二氧化碳来制造食物（葡萄糖）的过程。
            植物叶片中含有叶绿素，它能捕捉阳光的能量……"
}

更真实的例子——现代 SFT 数据通常是多轮对话格式：

json
[
  {"role": "user", "content": "帮我写一个 Python 函数，判断一个数是否是质数"},
  {"role": "assistant", "content": "好的，这是一个简洁的质数判断函数：\n\n```python\ndef is_prime(n):\n    if n < 2:\n        return False\n    for i in range(2, int(n**0.5) + 1):\n        if n % i == 0:\n            return False\n    return True\n```\n\n时间复杂度是 O(√n)……"},
  {"role": "user", "content": "能加上类型注解和文档字符串吗？"},
  {"role": "assistant", "content": "当然可以：\n\n```python\ndef is_prime(n: int) -> bool:\n    \"\"\"判断一个整数是否是质数。\n    \n    Args:\n        n: 待判断的整数\n    Returns:\n        如果是质数返回 True，否则返回 False\n    \"\"\"\n    ……"}
]

SFT 数据覆盖的任务类型很广：问答、写作、翻译、代码、摘要、推理、头脑风暴……每条数据都告诉模型"当用户这样说时，你应该这样回答"。

和预训练的技术区别 ​

技术层面惊人地简单：SFT 和预训练是完全一样的 next-token prediction，只是数据格式变了。

预训练时，模型对所有 token 都计算损失（因为所有 token 都需要"预测"）。SFT 时有个小技巧——只对回答部分的 token 计算损失，用户输入部分的 token 不计算损失。

用户输入："解释光合作用"         ← 这些 token 不参与损失计算
助手回答："光合作用是植物利用……" ← 只对这些 token 计算损失

这样模型学会的不是"用户会说什么"，而是"面对这样的用户输入，我应该输出什么"。

数据质量 > 数据数量 ​

预训练是"大力出奇迹"——数据越多越好（虽然质量也重要）。SFT 则是"少而精取胜"。经验表明：

SFT 数据量效果
1,000 条高质量模型开始有基本的指令遵循能力
10,000 条高质量大多数任务表现不错，"小"模型（7B）也能对话
50,000-100,000 条覆盖各种任务类型，对话流畅自然
100 万+ 条边际收益递减，杂质反而干扰已有能力

关键在于每条数据的"信息密度"——一条包含详细推理步骤的数学题解答，比一百条"你好-你好"的打招呼对话有价值得多。2026 年的趋势是用更强的模型（如 GPT-5、Claude 4）生成 SFT 数据，然后人工筛选和编辑——既有人工标注的质量，又有 AI 生成的规模和多样性。

对话模板（Chat Template） ​

为了让模型区分"用户说的话"和"助手应该输出的内容"，SFT 使用对话模板把对话历史转成一个特殊格式的字符串。

不同模型的模板格式不同。举个例子对比：

ChatML 格式（OpenAI 系列）：

<|im_start|>system
你是一个有帮助的助手。<|im_end|>
<|im_start|>user
法国的首都在哪里？<|im_end|>
<|im_start|>assistant
法国的首都是巴黎。<|im_end|>

Llama 格式（Llama 3/4 系列）：

<|begin_of_text|><|start_header_id|>system<|end_header_id|>

你是一个有帮助的助手。<|eot_id|><|start_header_id|>user<|end_header_id|>

法国的首都在哪里？<|eot_id|><|start_header_id|>assistant<|end_header_id|>

法国的首都是巴黎。<|eot_id|>

DeepSeek 格式：

<｜begin▁of▁sentence｜>你是一个有帮助的助手。
User: 法国的首都在哪里？
Assistant: 法国的首都是巴黎。

每种模板定义了不同的特殊 token（如 <|im_start|>、<|eot_id|>）来标记角色切换。如果在推理时用错了模板格式，模型可能完全"懵掉"——这就像你用'Chinglish'和一个只学过英文语法的人聊天，对方虽然认识这些字但不知道这句话的结构。

SFT 后的能力涌现 ​

SFT 做完后，模型发生的几个关键变化：

1. 学会了"指令-回答"的对话格式。 输入一个问题，输出一个回答，而不是续写一段文章。

2. 学会了角色扮演。 System prompt 中写的"你是一个××"开始真正起作用——模型会调整自己的语气、知识范围和回答风格。

3. 学会了拒绝不恰当请求。 训练数据中有大量"我无法帮助你完成这个请求"的范例，模型会模仿这种拒绝行为。不过这种"拒绝"是被动模仿的，不够可靠——所以还需要下一阶段的对齐。

4. 能力被"激活"而非"获得"。 SFT 不会教模型新的事实知识（知识在预训练阶段就已经存进 FFN 了）。SFT 的作用是把预训练中已经学会但"不知道什么时候该用"的知识引导出来。就像一个小提琴手（预训练）已经会拉琴了，SFT 是告诉他"现在是你的独奏部分，开始吧"。

3.3 RLHF（基于人类反馈的强化学习） ​

SFT 让模型学会了"一问一答"的格式，但还需要解决一个问题：同一个问题可能有多种合理的回答，人类更偏好哪一种？

用户："怎么减肥？"

回答 A（有帮助）：
"健康的减肥需要结合饮食调整和规律运动。建议每天保持 500 千卡的热量缺口，
每周进行 150 分钟中等强度有氧运动……"

回答 B（敷衍）：
"少吃多动就行。"

回答 C（危险）：
"连续一周只喝水，保证瘦 10 斤。"

三个回答都是"合理的续写"，但人类显然更想要 A。RLHF 的目标就是让模型的输出对齐到人类的偏好上——有用、安全、诚实。

整体流程图 ​

RLHF 完整流程

奖励模型（Reward Model） ​

奖励模型本质上是一个"打分器"——输入一个 (prompt, response) 对，输出一个分数，分数越高表示回答越好。

技术实现：把 SFT 模型的最后一层（原本输出词表大小的概率分布）换成一个标量回归头——只有一个输出神经元的线性层，输出一个实数分数——然后在人类排序数据上训练。训练用的损失函数叫 Bradley-Terry 模型，核心思想是：如果标注员认为回答 A 好于回答 B，那么奖励模型给 A 的分数应该显著高于 B。

具体来说，对于一对排序 ，损失为：

其中 是奖励模型， 是 Sigmoid 函数（），它的作用是把任意实数"压缩"到 (0, 1) 区间——分数差距越大，Sigmoid 输出越接近 1，损失越接近 0；如果差的回答反而得分更高，Sigmoid 输出接近 0， 会让损失暴增。

奖励模型通常是和 SFT 模型相同架构但独立训练的副本。比如用 LLaMA-70B-SFT 初始化一个 70B 的奖励模型。

PPO（Proximal Policy Optimization） ​

有了奖励模型，就可以用强化学习来优化 SFT 模型了。核心问题是：如何在提高奖励分的同时，不让模型"跑偏"？

'跑偏'是什么意思？假设你只要求模型"最大化奖励分"，模型可能学会各种取巧行为（叫奖励黑客 Reward Hacking）：

  • 发现说"当然！"开头能得高分 → 所有回答都以"当然！"开头
  • 发现用词越华丽分越高 → 把简单回答灌水成废话连篇
  • 发现回避争议话题得分稳定 → 所有敏感问题都回"这是一个复杂的问题，有不同观点……"
  • 更极端的：发现输出特定字符组合能骗过奖励模型直接得高分（类似对抗攻击）

PPO 的核心创新是加了一个约束项——不只要奖励高，还不能和 SFT 模型差太远：

翻译成人话：奖励分要尽量高，但如果新的回答方式和 SFT 模型差距太大，就要扣分。

其中 是 KL 散度（Kullback-Leibler Divergence），用来衡量两个概率分布之间的差异。KL 散度为零表示两个分布完全相同，越大表示差异越大。这里用它来保证新模型（）输出的概率分布不会偏离 SFT 模型（）太远。 是惩罚系数，越大越"保守"。

PPO 还有另外两个重要的技术细节：

1. Ratio Clipping（比率裁剪）

PPO 的关键操作：比较"新策略给某个 token 的概率"和"旧策略给它的概率"的比值 。如果 ，说明新策略更喜欢这个 token 了。PPO 把这个比值裁剪到 （通常 ），防止一次更新幅度过大。

Advantage（优势函数） 是比"这个动作好不好"更进一步的"这个动作比平均好多少"。如果你在围棋中走了一步好棋，光是"获得优势"还不够——要看你这一步比其他可能的步子好多少。Advantage > 0 意味着这个动作比预期好，应该提高它的概率；Advantage < 0 则相反。

2. 多轮迭代

PPO 不是一次性的。一轮 PPO 训练包括：

  • 用当前策略对一批 prompt 采样回答
  • 用奖励模型给这些回答打分
  • 用 PPO 更新策略
  • 重复下一轮……

每轮结束后，策略模型稍微"进化"了一点，奖励模型也面临新的分布（模型输出风格变了）。这也是 RLHF 不稳定的重要原因——奖励模型在它没见过的数据分布上打分可能不准确。

为什么 RLHF 这么难做 ​

RLHF 被公认为整个训练 pipeline 中最"玄学"的环节，原因有几层：

1. 奖励黑客（Reward Hacking） 策略模型会无孔不入地找奖励模型的漏洞。奖励模型喜欢"详细"的回答 → 策略模型开始无限啰嗦。奖励模型喜欢"积极"的语气 → 策略模型把坏消息也包装得像好消息。这个问题没有根治方案，只能不断迭代奖励模型和调整约束系数。

2. 分布漂移（Distribution Shift） 奖励模型是在 SFT 模型的输出上训练的，但 PPO 每更新一次，策略模型的输出分布就变一次。几轮之后，奖励模型面对的都是它没怎么见过的"风格"的回答，打分准确度自然下降。

3. 人类偏好数据本身的问题 人对"好回答"的判断不一致——不同标注员标准不同，同一个人不同时间也可能给出不同排序。更微妙的是，人类倾向于喜欢看起来好看的回答（排版清晰、语气自信），而不是实际上正确的回答。标注员可能不经意地将一个语法完美但事实错误的答案排在语法粗糙但事实正确的答案之前。

4. 训练不稳定 PPO 对超参数（训练前人工设定的参数，如学习率、惩罚系数 ）极度敏感。学习率稍高一点，模型可能突然"崩溃"——开始输出胡言乱语。惩罚系数 太大，模型原地踏步； 太小，模型放飞自我。一个好的 RLHF 运行通常需要几十次甚至上百次的超参数调试。

这些困难直接催生了下一节的 DPO 和更简洁的替代方案。

3.4 DPO 与 2026 年的替代方案 ​

DPO 原理：跳过奖励模型 ​

DPO（Direct Preference Optimization）是 2023 年斯坦福提出的方法，核心洞察是：既然最终要优化的是策略模型，为什么不直接从偏好数据优化，而非要训练一个单独的打分器？

数学上，DPO 证明了 RLHF 的优化目标可以等价地转化为一个直接优化策略模型的损失函数：

这个公式看起来复杂，但直觉很简单：

  • ：好回答的概率比 SFT 基线提升多少？
  • ：差回答的概率比 SFT 基线提升多少？
  • 我们希望前者大、后者小，两者的差越大越好

整个训练只需要偏好对数据（prompt + 好回答 + 差回答），不需要奖励模型，不需要 PPO 的多轮采样。用标准的监督学习流程就能训，稳定性大幅提升。

DPO vs RLHF 对比 ​

维度RLHFDPO
需要奖励模型？是，需要额外训练一个同规模的打分器否，直接优化策略
训练复杂度高（采样 → 打分 → PPO → 迭代）低（标准监督学习流程）
训练稳定性差（对超参很敏感）好（loss 曲线平滑）
计算开销高（PPO 需要同时加载策略模型 + 参考模型 + 奖励模型 + 价值模型至少 4 个模型）中（只需策略模型 + 参考模型 2 个）
性能上限理论上更高（奖励模型可复用，支持在线迭代）受限于偏好数据的质量和覆盖范围
奖励黑客风险高（策略要"攻击"奖励模型）低（没有可攻击的奖励模型）
适用场景大厂前沿模型、需要在线迭代的场景中小团队、快速迭代、学术研究

2024-2025 年的趋势非常明显：绝大多数模型团队采用 SFT → DPO 作为标准流程，RLHF 越来越被边缘化。但在前沿推理模型（如 o1/o3、DeepSeek-R1）中，RL 又以一种新的形式回归了——RLVR。

2026 年新方法速览 ​

2025-2026 年是 Post-Training 方法的大爆发年。核心趋势是从"人类偏好"转向可验证奖励（Verifiable Rewards）——数学题对不对、代码能不能跑、推理步骤有没有逻辑漏洞，这些都可以自动验证，不需要人工标注。

GRPO（Group Relative Policy Optimization，组内相对策略优化）

DeepSeek-R1 使用的训练算法，2024 年提出，2025-2026 年成为主流。核心创新：不要奖励模型，不要价值函数，只用组内对比。

对每个 prompt，采样 个回答（比如 8 个），用可验证规则打分（数学题看答案对不对，代码看能不能运行），然后把每个回答的分数和这组回答的平均分比较：

优势（Advantage）为正的回答，提升其概率；为负的，降低其概率。就这么简单。DDaR 不需要额外的奖励模型，不需要复杂的 PPO 裁剪，只需要一个可验证的评分规则。

GRPO 的一大发现是：纯强化学习可以催生推理行为。DeepSeek-R1-Zero 在没有任何"你应该一步步思考"的 SFT 数据的情况下，仅通过 GRPO 训练就自发学会了反思、自我验证、纠正错误——模型发现"想得更仔细"能得更高分（因为正确答案的概率更高），于是内生地产生了长思维链行为。

DAPO（Decoupled Clip and Dynamic Sampling Policy Optimization）

字节跳动 / 清华 2025 年提出，针对 GRPO 的几个痛点做了四项改进：

  1. Clip-Higher：不对称裁剪阈值，防止策略熵崩溃——即模型输出变得过于确定（概率集中在少数 token 上），失去回答的多样性
  2. 动态采样：如果一个 batch 中所有回答都正确或都错误（方差为零），这些数据对学习没有帮助，直接跳过并重采样
  3. Token 级损失聚合：对长思维链（可能几千个 token），按 token 粒度平均损失而非按回答粒度，防止长序列梯度消失
  4. 超长回答惩罚：对超出长度限制被截断的回答，给一个额外的负奖励，减少截断噪音

效果：DAPO 用 Qwen2.5-32B 训练，在 AIME 2024 数学竞赛题上达到 50 分，需要的训练步数比 DeepSeek-R1-Zero 少 50%。

SimPO / KTO / ORPO（简要速览）

方法核心思路一句话
SimPO用生成概率直接当奖励信号，连参考模型都不需要DPO 的更简化版
KTO不需要成对的好/差回答，每个回答单独一个"满意/不满意"标签偏好数据不够时适用
ORPO把 SFT 和偏好优化合并成一步训练"SFT → DPO"变成一次搞定

RLVR（Reinforcement Learning with Verifiable Rewards）

这是 2026 年最重要的范式转换词。RLVR 不是一种具体算法，而是一个范畴——所有用自动可验证的奖励（而非人类标注的偏好）来做强化学习的方法。

可验证奖励的例子：

  • 数学题：答案对不对（精确匹配或符号验证）
  • 代码：能不能通过单元测试
  • 推理：每一步逻辑是否自洽（LLM-as-judge）
  • 格式：是否遵循了指定的输出格式

现代 Post-Training 标准流程 ​

2026 年，训练一个高质量 AI 助手的标准后训练管线：

Post-Training 标准流程

不同公司的选择各有侧重点：

  • Anthropic：RLHF 深度积累 + Constitutional AI（让模型根据一套原则自我修正，然后 RL 强化）
  • OpenAI：大规模 RLHF + 推理时扩展（o 系列模型更依赖 RL 搜索）
  • DeepSeek：GRPO + 可验证奖励，DeepSeek-R1 的成功证明了 RLVR 路线的威力
  • Meta / 通义 / Kimi：SFT + DPO 为主，辅以 RLVR

3.5 微调技术（LoRA / QLoRA） ​

前面讲的预训练和 SFT 都是"全量微调"（Full Fine-tuning）——更新模型的所有参数。这对个人开发者和小团队来说很不现实：一个有 7B 参数的模型，即使是 BF16 精度也需要 ~14GB 显存来存放参数，加上优化器状态（AdamW 需要为每个参数存两份额外数据：动量 和二阶矩 ，所以优化器状态是参数量的 2 倍），全量微调需要 ~42GB——一张 RTX 4090（24GB）根本装不下。

全量微调 vs 参数高效微调 ​

全量微调参数高效微调（PEFT）
更新的参数100%（全部 7B）0.1%-1%（几百万-几千万）
显存需求（7B）~42GB（需要 A100 之类）~6-14GB（消费级显卡就可以）
训练速度慢（梯度要算所有参数）快（大部分参数冻结）
灾难性遗忘风险高（可能忘记预训练知识）低（原始权重没动）
性能上限理论上最高接近全量微调，差距很小

LoRA 原理 ​

LoRA（Low-Rank Adaptation，低秩适配）是 2021 年微软提出的方法，至今仍是 PEFT 的绝对主流。

核心思路：不在原始权重矩阵上直接修改，而是在旁边加两个小矩阵 和 ，只训练这两个小的。

原始的全连接层：

其中 ，对于 d_model=4096 的模型， 是 [4096, 4096]，约 1678 万参数。

LoRA 的做法：

其中 ，， 是秩（rank），可以理解为中间瓶颈的"宽度"—— 越小，两个小矩阵越窄，可训练参数越少。通常取 8-64。（为什么叫"秩"以及为什么低秩就够了，下一段讲。）

LoRA 架构图

如果 ， 和 加起来只有 个参数——不到原始 （1678 万）的 0.8%。

为什么"低秩"就够了？

这是 LoRA 最有意思的洞察：模型在适配新任务时，权重更新矩阵 的"内在秩"远小于原始矩阵的维度。翻译成人话：微调时需要改变的信息其实很少，大部分预训练学到的通用知识不需要动，只需要在一个很低维度的子空间中调整即可。

把输入从 维压缩到 维， 再解压回 维。 越小，可训练参数越少，但信息瓶颈也越窄。实验表明 或 在大多数任务上已经够用，更大的 （64 或 128）在复杂推理任务上有一定收益但边际递减。

LoRA 还有一个缩放参数 ：

控制 LoRA 分支对输出的贡献大小。增大 相当于让微调"更激进"地改变模型行为。通常 设成 的 1-2 倍（如 ）。

实践中的 LoRA 配置：

组件常见选择
应用到哪些层通常只应用到 Attention 的 Q、K、V、O 四个矩阵（有时也加 FFN 的 W₁、W₂）
rank 8-64（小任务 8-16，复杂任务 32-64）
通常等于 或
Dropout0.05-0.1（训练时随机丢弃 5-10% 的神经元连接，防止过拟合）

QLoRA：量化 + LoRA ​

QLoRA（Quantized LoRA）是 2023 年华盛顿大学提出的改进：把原始模型量化到 4-bit（大幅缩减显存），然后在量化模型上挂 LoRA 适配器训练。

关键创新是 NF4（NormalFloat 4）——一种专门为"正态分布的权重"设计的量化格式。和普通的 4-bit 量化（INT4）不同，NF4 假设权重近似正态分布，把量化密度集中在接近零的区域（大部分权重集中在那里），从而在 4-bit 下保持更高的精度。

实际效果：一个 65B 的模型，全量微调需要 ~780GB 显存，QLoRA 只需要 ~48GB——一张 48GB 的 A6000 就能微调。7B 模型用 QLoRA 甚至可以在 RTX 4090 笔记本上跑训练。

LoRAQLoRA
基座模型精度BF16 / FP164-bit (NF4)
7B 微调显存~14GB~6GB
13B 微调显存~26GB~10GB
70B 微调显存~140GB（需 A100 80GB × 2）~30GB（单张消费级显卡）

2026 年 LoRA 家族进展 ​

LoRA 提出五年了，2025-2026 年仍然迭代活跃：

LoRA+（2024-2025）：发现标准 LoRA 中 和 用同样的学习率是次优的。（输出端）应该用比 （输入端）更大的学习率—— 直接产生输出，需要快速适应任务特征； 负责特征提取，慢一点有助于保留预训练知识。实践中 到 的比例效果最好。

DoRA（Weight-Decomposed Low-Rank Adaptation，2024-2025）：把权重更新分解为幅度（magnitude）和方向（direction）两个独立分量，分别适配。直觉：方向告诉模型"往哪走"，幅度告诉模型"走多远"。实验表明 DoRA 在很多任务上能逼近甚至达到全量微调的水平。AAAI 2026 论文发现 DoRA 的核心优势是增加了权重更新矩阵的奇异值熵（衡量矩阵各行/各列更新均匀程度的指标，熵越高说明没有"偏科"）——让更新更均匀，更像全量微调。

FoRA（Fisher-Orthogonal Rank Adaptation，2026）：思路从"降秩"转为"减层"——不用所有层都挂 LoRA，而是用 Fisher 信息矩阵识别哪些层对当前任务最相关，只在关键层上做适配。同时用 Stiefel 流形约束保证低秩矩阵不退化（有效秩从 ~0.71 恢复到 ~0.88）。效果：用一半的参数达到甚至超过标准 LoRA 的性能。

2026 趋势总结：

方向代表方法核心思路
非对称优化LoRA+A 和 B 矩阵用不同的学习率
权重分解DoRA, DoRAN分离幅度和方向的适配
层选择FoRA只适配"需要适配"的层
正交约束SVDLoRA, SORA用正交性保证低秩质量
量化融合MedLoRA, QLoRA 变体探索最佳量化 + PEFT 组合

动手建议 ​

如果你想在自己机器上微调一个模型，2026 年最推荐的入门路径：

工具选择：

  • Unsloth：高度优化的 LoRA/QLoRA 训练库。对 Llama、Qwen、Mistral 系列做了 CUDA kernel 级别的优化，训练速度比标准 HuggingFace Trainer 快 2-3 倍，显存省 50%+
  • LLaMA-Factory：有 Web UI 的微调框架，支持几乎所有主流的训练方法和模型，适合不想写代码的用户

推荐配置（2026）：

基座模型：Qwen3-7B 或 DeepSeek V4 Flash-Lite（小尺寸版）
方法：QLoRA, r=16, alpha=32
GPU：RTX 4090 (24GB) 或以上
数据：5000-20000 条高质量对话（自己筛选或从公开数据集拼）
工具：Unsloth
时间：几小时到一晚上

这样你就能得到一个在自己领域上表现良好的定制模型，体验完整训练流程。

本阶段小结 ​

LLM 三阶段训练流程

七个核心 takeaway：

  1. 预训练是大头：占成本 95%+，数据质量和规模同等重要，2026 年数据墙是最大挑战
  2. 交叉熵是统一的损失函数：预训练、SFT、DPO 的损失函数都可以追溯到交叉熵或其变体
  3. SFT 是"激活"而非"灌输"：几万条高质量数据的格式引导，就能让预训练中学到的能力浮现
  4. RLHF 提供了对齐框架但太难做：奖励黑客、分布漂移、训练不稳定催生了 DPO 等更简洁的方案
  5. 可验证奖励（RLVR）是 2026 年主旋律：数学题对错、代码能跑否——自动验证替代人类标注，GRPO/DAPO 成为新标配
  6. LoRA 让个人也能微调大模型：低秩适配 + 量化 = 消费级显卡跑训练，QLoRA 把 7B 微调的显存门槛降到 ~6GB
  7. 训练管线仍在快速迭代：每年训练成本翻倍、新对齐方法层出不穷——读完这阶段你有了完整的知识框架，后续新论文都能自己看懂了

参考文献与图片来源 ​

论文与博客 ​

标题作者/来源类型/年份链接说明
Attention Is All You NeedVaswani et al.论文 / 2017https://arxiv.org/abs/1706.03762Transformer 原始论文
Language Models are Unsupervised Multitask Learners (GPT-2)Radford et al.论文 / 2019https://d4mucfpksywv.cloudfront.net/better-language-models/language_models_are_unsupervised_multitask_learners.pdfGPT-2 训练数据与基座模型行为
Scaling Laws for Neural Language ModelsKaplan et al.论文 / 2020https://arxiv.org/abs/2001.08361缩放定律
Training Compute-Optimal Large Language Models (Chinchilla)Hoffmann et al.论文 / 2022https://arxiv.org/abs/2203.15556Chinchilla 缩放定律
Training Language Models to Follow Instructions with Human Feedback (InstructGPT)Ouyang et al.论文 / 2022https://arxiv.org/abs/2203.02155RLHF 原始论文
Proximal Policy Optimization AlgorithmsSchulman et al.论文 / 2017https://arxiv.org/abs/1707.06347PPO 算法
Direct Preference OptimizationRafailov et al.论文 / 2023https://arxiv.org/abs/2305.18290DPO
LoRA: Low-Rank Adaptation of Large Language ModelsHu et al.论文 / 2021https://arxiv.org/abs/2106.09685LoRA
QLoRA: Efficient Finetuning of Quantized LLMsDettmers et al.论文 / 2023https://arxiv.org/abs/2305.14314QLoRA + NF4
DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement LearningDeepSeek-AI论文 / 2025https://arxiv.org/abs/2501.12948GRPO + 纯 RL 推理涌现
DAPO: Decoupled Clip and Dynamic Sampling Policy OptimizationYu et al.论文 / 2025https://arxiv.org/abs/2503.14476DAPO
DoRA: Weight-Decomposed Low-Rank AdaptationLiu et al.论文 / 2024https://arxiv.org/abs/2402.09353DoRA
LoRA+: Efficient Low Rank Adaptation of Large ModelsHayou et al.论文 / 2024https://arxiv.org/abs/2402.12354LoRA+ 非对称学习率
Transformer Feed-Forward Layers Are Key-Value MemoriesGeva et al.论文 / 2021https://arxiv.org/abs/2012.14913FFN 键值记忆假说
BeyondWeb: Lessons from Scaling Synthetic Data for Trillion-scale PretrainingDatologyAI论文 / 2025https://arxiv.org/abs/2508.10975合成数据框架
Post-Training in 2026: GRPO, DAPO, RLVR & BeyondLLM-Stats博客 / 2026https://llm-stats.com/blog/research/post-training-techniques-20262026 后训练技术综述
GPU Servers for LLM Training: VRAM, Fabric & Pricing (2026)Hostline博客 / 2026https://hostline.io/blog/blog-best-gpu-servers-for-llm-training/2026 GPU 训练成本数据
The Internet Isn't Big Enough To Train AIForbes文章 / 2024https://www.forbes.com/sites/rashishrivastava/2024/07/24/the-internet-isnt-big-enough-to-train-ai-one-fix-fake-data/数据墙报道
Predicting GPU Performance and Training CostsCottier et al. (Epoch AI)论文 / 2024https://arxiv.org/abs/2405.21015训练成本估算法论

在线工具与延伸资源 ​

资源说明
Unsloth最快的 LoRA/QLoRA 微调库
LLaMA-Factory带 Web UI 的微调框架
HuggingFace Open RLHF开源 RLHF 训练框架
Epoch AI训练趋势与成本跟踪
LLM-Stats模型参数与架构对比数据库

图片来源 ​

描述来源许可
交叉熵损失曲线、训练损失曲线、困惑度色阶作者用 matplotlib 绘制自由使用
训练三阶段总览、训练循环、GPU 集群拓扑、RLHF 流程、LoRA 架构、Post-Training 流程作者用 matplotlib 绘制自由使用

Released under the MIT License.

Copyright © 2026-present Requiem