训练细节详解

每种训练方法的 数据 → 模型 → Loss 全流程

8 种训练方法,每种都讲清楚:训练数据长什么样、什么进模型、模型输出什么、Loss 怎么算。 附带真实数字的计算示例。

① 预训练(Pretraining)

基座模型的诞生——用海量文本训练一个"接龙机器"。

📦 训练数据
原始文本,不需要任何标注,只需要"一堆文字"
来源示例占比
Common Crawl网页文本、论坛帖子、博客...~60%
代码GitHub 仓库、Stack Overflow...~15%
书籍电子书、学术论文...~10%
百科/知识Wikipedia、教科书...~10%
合成数据大模型生成的高质量文本~5%
数据 一段原始文本:"量子力学是描述微观粒子行为的物理学理论"
🔢 Tokenization(分词)
输入 "量子力学是描述微观粒子行为的物理学理论"
输出 [12456, 8901, 3200, 15678, 22100, 7432, 9011, 45210, 312, 8877]

分词器把文本切成 token ID 序列。500M 模型通常用 vocab_size=32000 的 SentencePiece。

🧠 模型输入和输出
输入 token 序列:[t₁, t₂, t₃, ..., t₁₀] = [12456, 8901, 3200, ...]
输出 每个位置都输出一个 vocab_size 维的概率分布(32000 个数字,加起来 = 1)
位置 1 预测 t₂、位置 2 预测 t₃ ... 位置 9 预测 t₁₀
1
一条 10 token 的文本 → 通过错位法自动产生 9 个训练样本
↓
2
因果掩码(下三角矩阵)确保位置 i 只能看到 t₁...tᵢ,不能偷看后面的 token
↓
3
一次 forward pass 同时得到 9 个位置的预测 → 效率极高
// 具体例子:文本 "量子力学是描述微观粒子行为的物理学理论"(10 tokens)
位置 1: 看到 [量子] → 预测下一个 = 力学
位置 2: 看到 [量子,力学] → 预测下一个 = 是
位置 3: 看到 [量子,力学,是] → 预测下一个 = 描述
...
位置 9: 看到 [量子...物理学] → 预测下一个 = 理论
// 一条文本 → 9 个训练样本,标注成本 = 0
📉 Loss 计算
Loss 交叉熵(Cross-Entropy):−log(模型给正确答案分配的概率)
// 位置 1:模型预测"力学"的概率
模型输出 32000 维向量 → softmax → 概率分布
P("力学" | "量子") = 0.35 // 模型觉得有 35% 概率
loss₁ = −log(0.35) = 1.05

// 位置 2:模型预测"是"的概率
P("是" | "量子力学") = 0.12
loss₂ = −log(0.12) = 2.12

// 总 Loss = 所有位置的平均
L = (loss₁ + loss₂ + ... + loss₉) / 9 = 1.73
// Loss 越低,模型预测越准。预训练目标:最小化 L
公式
L = −(1/n) Σᵢ log P(tᵢ | t₁, ..., tᵢ₋₁)
对每个位置 i,取模型给"正确答案"tᵢ的概率,取负对数,然后全部平均。
预训练的本质:输入一段文字 → 模型在每个位置预测下一个 token → Loss 衡量预测和实际答案的差距 → 梯度下降更新权重。数据就是原始文本,不需要标注,错位法自动产生训练信号。

② SFT 监督微调

让基座模型从"接龙"变成"回答问题"。

📦 训练数据
人工标注的(指令, 好回答)对。数据量 10K~1M 条。
#指令(instruction)回答(response)
1请解释什么是量子力学量子力学是描述微观粒子行为的物理理论。与经典物理不同...
2用 Python 写一个快排def quicksort(arr): if len(arr) <= 1: return arr...
3翻译成英文:今天天气很好The weather is nice today.

每条数据由人工标注员写一个"高质量回答"。这比预训练数据贵得多(需要人工),但量少得多。

🧠 模型输入和输出
输入 [指令 tokens] + [回答 tokens]
例:[请, 解释, 什么, 是, 量子, 力学] + [量子, 力学, 是, 描述, 微观, ...]
输出 每个位置的 next-token 概率分布(和预训练一样)
Loss 只在回答部分计算 Loss! 指令部分不参与 Loss。
loss_mask = [0,0,0,0,0,0, 1,1,1,1,1,...]
// 关键区别:Loss 只在 response 上算
输入序列: [请, 解释, 什么, 是, 量子, 力学, 量子, 力学, 是, 描述, ...]
loss_mask: [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, ...]

// 位置 1~6(指令部分):模型也做了预测,但 loss_mask=0,不参与梯度更新
// 位置 7+(回答部分):正常计算 loss,更新权重

LSFT = −(1/m) Σᵢ loss_mask[i] · log P(tᵢ | t₁..tᵢ₋₁)
// m = 回答部分的 token 数(非零 mask 的个数)
SFT vs 预训练的唯一区别:Loss 只在"回答"部分计算。模型学到的是"看到这种指令格式,就输出这种回答",而不是"继续接龙"。训练方式和预训练完全一样(自回归 + 交叉熵),只是 loss_mask 不同。

③ RLHF / PPO

用强化学习让模型"说人话"——4 个模型协作的复杂流程。

📦 训练数据
人类偏好数据:同一个问题 + 两个回答 + 人类选更好的
prompt回答 A回答 B人类选择
解释量子力学量子力学描述了微观粒子的波粒二象性...就是薛定谔的猫那个东西吧A ✓
写一首诗春天来了花开了真好看春风拂柳绿如烟,花开满园香漫天...B ✓

标注量 10 万~100 万条偏好对。训练 RM 后,RM 可以无限打分,不再需要人工。

🏗️ 4 个模型的角色
Actor(策略)
就是你要训练的模型
输入 prompt → 生成回答
Critic(价值)
评估"当前状态好不好"
输入 prompt+已生成 tokens → 标量值
Reward Model
给完整回答打分
输入 prompt+完整回答 → 分数
Reference(参考)
SFT 模型的冻结副本
提供 log πref(y) → KL 惩罚
🔄 PPO 训练循环(一步详解)
1
采样阶段:Actor 对一个 prompt 生成回答 y = [y₁, y₂, ..., yₙ]
↓
2
打分:RM 给完整回答打分 → reward r(如 7.5/10)
↓
3
KL 惩罚:计算 log πθ(y) − log πref(y),防止 Actor 偏离 SFT 太远
↓
4
优势估计:Critic 逐 token 估算"这个 token 比平均好还是差"→ Advantage At
↓
5
更新:用 PPO 的 clipped surrogate loss 更新 Actor + Critic

每个模型的具体输入输出:

Actor 输入:prompt tokens [请,解释,量子,力学]
输出:自回归生成 response tokens [量子,力学,是,描述...]
同时输出每个 token 的 log πθ(yₜ | prompt, y₁..yₜ₋₁)
RM 输入:prompt + 完整 response
输出:标量分数 r = 7.5
Ref 输入:prompt + 完整 response(和 Actor 一样的输入)
输出:每个 token 的 log πref(yₜ | ...)(冻结,不更新权重)
Critic 输入:prompt + 已生成的部分 response [y₁..yₜ]
输出:标量 V(sₜ) = "从这个位置往后,预计还能拿多少奖励"

Loss 计算:

// Step 1: 计算每个 token 的即时奖励
Rt = rRM − β · (log πθ(yₜ) − log πref(yₜ))
// rRM 只在最后一个 token 给(完整回答的分数)
// KL 惩罚在每个 token 上都有

// Step 2: 用 GAE 计算 Advantage(Critic 提供基线)
δt = Rt + γ·V(st+1) − V(st) // TD error
At = Σk (γλ)k · δt+k // GAE: 加权累积 TD error

// Step 3: Actor 的 PPO Loss
ratiot = πθ_new(yₜ) / πθ_old(yₜ) // 新旧策略比
Lactor = −E[ min(ratiot·At, clip(ratiot, 0.8, 1.2)·At) ]
// clip 防止策略更新太猛 → 训练稳定

// Step 4: Critic 的 Loss
Lcritic = E[ (V(st) − Ractual)² ] // 让 Critic 的估值逼近真实回报
数字实例
Actor 生成:"量子力学是描述微观粒子的理论"
RM 打分:r = 7.5
某 token "微观":log πθ = -2.1, log πref = -2.5
KL 惩罚 = β·(-2.1 - (-2.5)) = 0.05·0.4 = 0.02
该 token 的即时奖励 Rt = 0 - 0.02 = -0.02(非末尾 token,RM 分还没到)
Critic 估计 V(st) = 3.2,实际后续回报 = 4.0
Advantage At = 4.0 - 3.2 = +0.8 → 这个 token 比预期好 → 鼓励
ratio = 1.05 → clip(1.05, 0.8, 1.2) = 1.05 → loss = -min(1.05×0.8, 1.05×0.8) = -0.84
PPO 的核心:① Actor 生成回答 ② RM 打分 ③ Critic 做基线 ④ 用 clip 限制更新幅度。4 个模型同时跑,显存 = 4× 模型大小。这就是为什么 PPO 很贵,也是后来 DPO/GRPO 要干掉它的原因。

④ DPO 直接偏好优化

用数学把 RL 问题变成监督学习——干掉奖励模型和 PPO 循环。

📦 训练数据
偏好三元组:(prompt, 好回答, 差回答)。和 RLHF 用同样的数据,但直接用,不先训 RM。
promptchosen (yw)rejected (yl)
解释量子力学量子力学描述了微观粒子的波粒二象性...就是薛定谔的猫那个东西吧
写一首诗春风拂柳绿如烟...春天来了花开了真好看
🏗️ 只需要 2 个模型
策略模型 πθ
正在训练的模型
和 SFT 模型同架构
权重可更新
参考模型 πref
SFT 模型的冻结副本
提供 log πref(y)
权重不更新
🧠 模型输入输出

同一条数据,两个模型各跑两遍(chosen 和 rejected):

πθ 输入 ①:[prompt] + [chosen] → 输出:log πθ(yw) = 整条序列的 log 概率之和
输入 ②:[prompt] + [rejected] → 输出:log πθ(yl)
πref 输入 ①:[prompt] + [chosen] → 输出:log πref(yw)(冻结,不更新)
输入 ②:[prompt] + [rejected] → 输出:log πref(yl)
// 具体计算:一条偏好数据
prompt = "解释量子力学"
chosen = "量子力学描述了微观粒子的波粒二象性..." (30 tokens)
rejected = "就是薛定谔的猫那个东西吧" (12 tokens)

// 策略模型 πθ 计算
log πθ(yw) = Σ log P(yw,t | ...) = -18.5
log πθ(yl) = Σ log P(yl,t | ...) = -22.3

// 参考模型 πref 计算(冻结)
log πref(yw) = -20.1
log πref(yl) = -21.0

// 计算 log 比率差
log_ratio_w = log πθ(yw) - log πref(yw) = -18.5 - (-20.1) = +1.6
log_ratio_l = log πθ(yl) - log πref(yl) = -22.3 - (-21.0) = -1.3

// DPO Loss (β = 0.1)
L = -log σ(β · (log_ratio_w - log_ratio_l))
  = -log σ(0.1 × (1.6 - (-1.3)))
  = -log σ(0.1 × 2.9)
  = -log σ(0.29)
  = -log(0.572) = 0.558 // 模型已经在偏好正确方向上,loss 较小
DPO Loss 公式
LDPO = -E[ log σ(β · (log πθ(yw)/πref(yw) - log πθ(yl)/πref(yl))) ]
直觉:好回答的 log 比率要大于差回答的 log 比率。σ 把差值变成概率,-log 让模型最小化"选错"的概率。
DPO 的核心:和 SFT 训练一样简单——每次取一条 (prompt, chosen, rejected) 三元组,两个模型各算 log 概率,套公式算 loss,反向传播更新 πθ。不需要 RM,不需要 PPO 循环,显存只需 2× 模型。

⑤ GRPO 组相对策略优化

DeepSeek R1 的核心算法——用"小组互评"干掉 Critic 网络。

📦 训练数据
可验证任务:数学题(有标准答案)或代码题(有测试用例)。不需要人类偏好。
prompt可验证答案奖励函数
证明 √2 是无理数反证法完整推导答案正确 = 1, 错误 = 0
写 Python 快排通过 10 个测试用例通过率 = reward
123 × 456 = ?56088精确匹配 = 1
🧠 核心机制:采样 G 个回答 → 组内相对比较
1
对一个 prompt,Actor 采样 G 个回答(如 G=8):{y₁, y₂, ..., yG}
↓
2
对每个回答计算可验证奖励 ri(对答案、跑测试)
↓
3
组内归一化:Ai = (ri - mean) / std → 这就是 Advantage,不需要 Critic!
↓
4
用 PPO 风格的 loss 更新 Actor(带 clip + KL 惩罚)
// 具体例子:prompt = "证明 √2 是无理数",G=4 个采样

// Step 1: Actor 采样 4 个回答
y₁ = "假设√2=p/q..." → 完整正确
y₂ = "√2≈1.414..." → 不是证明
y₃ = "用反证法:设√2=a/b..." → 思路对但断了
y₄ = "假设√2=p/q..." → 正确完整

// Step 2: 可验证奖励
r₁ = 0.9, r₂ = 0.3, r₃ = 0.7, r₄ = 0.8

// Step 3: 组内归一化 → Advantage
mean = (0.9+0.3+0.7+0.8)/4 = 0.675
std = √(((0.225)²+(0.375)²+(0.025)²+(0.125)²)/4) = 0.249

A₁ = (0.9-0.675)/0.249 = +0.904 → 鼓励
A₂ = (0.3-0.675)/0.249 = -1.506 → 惩罚
A₃ = (0.7-0.675)/0.249 = +0.100 → 微鼓励
A₄ = (0.8-0.675)/0.249 = +0.502 → 鼓励

// Step 4: GRPO Loss(对每个回答的每个 token)
ratioi,t = πθ(yi,t) / πθ_old(yi,t)
L = -(1/G) Σᵢ (1/|yᵢ|) Σₜ min(ratio·Aᵢ, clip(ratio,1-ε,1+ε)·Aᵢ) + β·KL
// 和 PPO 一样,但 Advantage 来自组内归一化,不需要 Critic
GRPO 的核心:不需要 Critic 网络。对同一个 prompt 采样一组回答,用可验证奖励打分,组内归一化得到 Advantage。显存只需 2× 模型(Actor + Ref),比 PPO 省一半。天然适合数学/代码等有标准答案的任务。

⑥ RLVR 可验证奖励强化学习

奖励不来自人类,而来自可验证的规则——数学对答案、代码跑测试。

📦 训练数据
有标准答案的题目 + 验证器。不需要人类标注偏好。
题目标准答案验证器
123 × 456 = ?56088精确匹配
def fib(n): ...参考实现跑 20 个测试用例
解方程 x²-5x+6=0x=2, x=3代入验证
🧠 奖励计算方式

RLVR 不是一种新算法,而是一种新的奖励来源。通常搭配 GRPO 使用。

传统 RLHF 的奖励
输入 prompt + response → RM 打分

RM 是训练出来的,打分有噪声、有偏差。需要人类偏好数据训练 RM。

RLVR 的奖励
输入 response → 规则验证(确定性)

数学:提取答案 → 精确匹配。代码:跑测试用例 → 通过率。客观、免费、无限扩展。

// 数学题奖励计算
prompt = "123 × 456 = ?"
model_output = "<think>123×400=49200, 123×56=6888, 49200+6888=56088</think> 56088"
提取答案: 56088
标准答案: 56088
reward = 1.0 // 精确匹配

// 代码题奖励计算
prompt = "写一个快排函数"
model_output = "def quicksort(arr): ..."
跑 20 个测试用例: 18 通过, 2 失败
reward = 18/20 = 0.9

// 奖励设计技巧
// 1. 格式奖励:输出格式正确 +0.1,否则 0
// 2. 部分正确:代码编译通过但测试没过 → +0.2
// 3. 长度惩罚:防止模型输出废话 → -0.01 × len
RLVR 的核心:奖励来自规则而非人类。和 GRPO 结合时,模型采样多个回答 → 验证器打分 → 组内归一化 → 更新。DeepSeek R1-Zero 用纯 RLVR 训练,模型自己"涌现"出了思维链推理能力——没人教它要一步步思考,它发现分步算能答对更多题。

⑦ 知识蒸馏

大模型当老师,小模型当学生——用老师的"知识"训练学生。

📦 训练数据
老师模型(大模型)生成的回答。学生模型(小模型)学习老师的输出。
prompt老师回答(72B 模型生成)
解释量子力学量子力学是描述微观粒子行为的物理理论。它基于几个核心原理:波粒二象性、量子化、不确定性原理...
123×456让我们一步步计算:123×400=49200, 123×50=6150, 123×6=738, 总和=56088
🧠 两种蒸馏方式
输出蒸馏(简单)
数据 老师的最终回答文本
Loss 和 SFT 一样:交叉熵
只是数据是老师生成的
概率蒸馏(经典)
数据 老师每个 token 的概率分布
Loss KL 散度:学生分布 vs 老师分布
// 概率蒸馏具体计算
prompt = "123 × 456 ="

// 老师模型 (72B) 在位置 7 的输出分布
teacher_logits = [2.1, -0.5, 0.8, ..., -1.2] // 32000 维
teacher_probs = softmax(teacher_logits / T) // T=温度,T>1 使分布更平滑
Pteacher("5") = 0.45, Pteacher("6") = 0.32, Pteacher("4") = 0.12...

// 学生模型 (500M) 在同一位置的输出
student_logits = [1.5, -0.3, 0.2, ..., -0.8]
student_probs = softmax(student_logits)
Pstudent("5") = 0.38, Pstudent("6") = 0.28, Pstudent("4") = 0.15...

// KL 散度 Loss
LKD = KL(Pteacher ‖ Pstudent) = Σ Pteacher(v) · log(Pteacher(v) / Pstudent(v))
// 对所有 vocab 中的 token v 求和
// 学生不仅学"答案是5",还学"老师觉得6也有可能"
蒸馏的核心:老师模型(大)生成高质量数据或概率分布 → 学生模型(小)学习。输出蒸馏 = 用老师回答当 SFT 数据。概率蒸馏 = 用 KL 散度让学生拟合老师的完整分布(学到"不确定性"信息)。DeepSeek R1 → R1-Distill-Qwen-32B 就是输出蒸馏。

⑧ LoRA 低秩微调

冻结原始权重,只训练一个小矩阵——省显存、省存储。

📦 训练数据
和 SFT / DPO 用一样的数据。LoRA 是一种训练方法,不是数据类型。
🧠 核心思想:权重变化是低秩的
原始 W0 (d×d):预训练权重,冻结不更新
LoRA W = W0 + ΔW = W0 + B·A
B (d×r) + A (r×d),r 远小于 d(如 r=8, d=1024)
// 参数量对比
原始权重 W0: d × d = 1024 × 1024 = 1,048,576 参数
LoRA (r=8): d×r + r×d = 1024×8 + 8×1024 = 16,384 参数

// 节省比例
16,384 / 1,048,576 = 1.56% // 只需训练 1.5% 的参数!

// 前向传播
h = W0·x + B·A·x // W0·x 是冻结的前向,B·A·x 是 LoRA 分支
// 推理时可以合并:W = W0 + B·A,无额外计算开销

// Loss 和 SFT 完全一样(交叉熵),只是梯度只更新 A 和 B
L = -Σ log P(yt | ...) // 和 SFT 一样
∂L/∂W0 = 0 // 不更新
∂L/∂A ≠ 0, ∂L/∂B ≠ 0 // 只更新这两个
// 真实模型的参数账:LLaMA-2-7B(hidden=4096、intermediate=11008、L=32、r=16)
单个 4096×4096 矩阵:A(16×4096) + B(4096×16) = 131,072(原矩阵 16,777,216 的 0.781%)
只挂 Wq, Wv:131,072 × 2 × 32 层 = 8.4M = 7B 的 0.120%
挂注意力 4 投影:131,072 × 4 × 32 = 16.8M = 0.240%
全挂(再加 FFN 三块,每块 16×4096 + 16×11008 = 241,664):40.0M = 0.571%
r=64 全挂:40.0M × 4 = 159.9M = 2.284% // 参数量随 r 线性增长
// 所以「只训练 0.1%~0.6% 参数」不是口号,是可拿计算器复现的账;检查点也从 14 GB 降到几百 KB~百 MB
W0 (冻结)
1024 × 1024
~4 MB (BF16)
不更新
+
B (d×r)
1024 × 8
~16 KB
训练中
A (r×d)
8 × 1024
~16 KB
训练中
LoRA 的核心:冻结大模型的所有权重,只在每个线性层旁加两个小矩阵 B 和 A。训练时只更新 B 和 A(参数量减少 ~98%),推理时合并回原权重(零额外开销)。QLoRA 进一步把 W0 量化到 4-bit,让单卡 8GB 就能微调 7B 模型。

训练细节详解 · 8 种训练方法全覆盖

◂ 返回导航主页