1. 问题（Problem statement）​

设想你拿 Qwen3-0.6B 去问一句："按照泰国总理府的规定，什么情况下可以采用特定方式采购？" 模型会非常自信地回答你，而且答错——因为它压根没见过足够多的泰国政府公文。

很多人试图用几千条问答对做 fine-tuning 来补救，然后发现根本没用。 原因在于：SFT 教的是"回答的形式"，不是"知识"本身。 如果知识从来就不在模型权重里， 教它用正确的语气去回答，只不过是让它在胡说八道的时候更加理直气壮而已。

新知识进入模型有三条路，选错路正是大多数 LLM 项目失败的根源：

这篇文章走的是第二条路。

2. 我们要做什么（Solution）​

我们会拿一个 base 模型（尚未经过 instruction tuning）， 用与预训练阶段完全相同的 objective——预测下一个词——在我们关心领域的泰语原始文本上继续训练。 没有标签，没有问答对，只有纯文本。

但这篇文章的核心不是"训完变强了"，而是你为此付出的代价：

模型忘掉原本会做的事情，这个现象叫作灾难性遗忘（catastrophic forgetting）。 我们不会空口谈它，而是要把它量化成数字，再去找一个你能接受的平衡点。

3. 公式（Equation）​

3.1 CPT 的 objective​

• $x_t$ = 第 $t$ 个位置的 token
• $x_{<t}$ = 它前面的全部 token
• $p_\theta$ = 模型预测出的概率

这个式子和预训练时一模一样，唯一变的是数据。 这正是 CPT 不需要标签的原因——文本自己就是答案。

3.2 Perplexity：我们的度量单位​

翻译成人话就是："平均而言，模型正在多少个选项之间犹豫。" PPL = 20 表示大约在 20 个词之间摇摆，PPL = 5 则笃定得多。困惑度越低越好。

3.3 本章最重要的公式——Replay Mixing​

$\lambda$ 就是每个 batch 中领域数据所占的比例。

• $\lambda = 1.0$ → 纯领域数据 → 领域能力涨得最快，同时也忘得最快
• $\lambda = 0.5$ → 一半一半 → 涨得慢一些，但遗忘少得多

不要把这个值写死，去扫一遍它的取值，然后挑一个你能接受的点。

4. 把公式画出来（Visualize）​

困惑度到底在告诉我们什么​

右边这张图是大家最容易忽略的地方：如果有人说"困惑度降了 5 个点"，却不告诉你起点是多少， 这句话基本没有信息量——因为 80 → 75 只是改善了 6%，而 10 → 5 是改善了 50%。

replay ratio 所控制的那笔交易​

5. 准备环境（Environment）​

打开 Colab，选择 Runtime → Change runtime type → T4 GPU（免费额度就够用）。

torch_dtype=torch.float16      # 不是 bfloat16
attn_implementation="sdpa"     # 不是 flash_attention_2
fp16=True                      # 在 TrainingArguments 里（不是 bf16=True）

本系列每个 notebook 的第一个 cell 都会把这行打印出来，让你亲眼看到：

cap = torch.cuda.get_device_capability(0)
print("compute capability:", cap)                    # T4 = (7, 5)
print("native bf16:", cap[0] >= 8)                   # T4 -> False
print("torch says   :", torch.cuda.is_bf16_supported())  # T4 -> True（把 emulation 也算上了！）

显存预算有多少，又都花到哪去了​

注意 optimizer state 占的显存比模型本身还多——Adam 要为每个参数各存一份 $m$ 和 $v$。 换成 adamw_bnb_8bit 能省下 3.3 GB，这意味着你可以把 batch size 或序列长度再往上加不少。

自己动手玩一下显存预算——调调参数，看看什么时候会 OOM：

6. 准备数据（Data）​

我们使用 pythainlp/thaigov-v2-corpus-22032023——这是泰国政府的新闻与公文语料库（公有领域）， 它扮演的角色是"模型见得远远不够的专业领域知识"。这类政府公文用词高度固定、术语密集， 和任何一个组织的内部知识库在性质上是一样的，你完全可以把它换成自己的语料。

另外再用一份通用泰语文本作为 replay data，用来抑制遗忘。

from datasets import load_dataset

domain = load_dataset("pythainlp/thaigov-v2-corpus-22032023", split="train")
domain = domain.shuffle(seed=42).select(range(8000))

Packing：别让 padding 吃掉你的预算​

如果把每篇文档都 pad 到同样长度，你会有海量算力浪费在 <pad> 上。 正确的做法是把所有文档首尾相接，再切成等长的 512 token 块。

def pack(examples, block_size=512):
    ids = []
    for text in examples["context"]:
        ids.extend(tokenizer(text + tokenizer.eos_token).input_ids)
    n = (len(ids) // block_size) * block_size
    return {"input_ids": [ids[i:i+block_size] for i in range(0, n, block_size)]}

7. 核心代码（Main code）​

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B-Base",           # 要 base，不要 instruct —— CPT 必须从 base 开始
    torch_dtype=torch.float16,        # T4 没有 bf16
    attn_implementation="sdpa",       # T4 没有 FlashAttention-2
).cuda()

model = model.float()                 # 训练前必须转成 fp32 —— 见下方提示框

args = TrainingArguments(
    output_dir="cpt-out",
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,    # effective batch = 16
    num_train_epochs=1,
    learning_rate=2e-5,               # 比 SFT 低 10 倍 —— 见下方警告
    lr_scheduler_type="cosine",
    warmup_steps=50,
    optim="adamw_bnb_8bit",           # 省下 3.3 GB
    gradient_checkpointing=True,
    max_grad_norm=1.0,                # 防止 fp16 数值爆炸
    fp16=True,                        # 不是 bf16
    logging_steps=10,
)

ValueError: Attempting to unscale FP16 gradients.

8. 结果（Results）​

notebook 会在训练前后各测三项指标，并写入 results.json：

1. 领域 held-out PPL —— 应当明显下降（这是我们花钱买到的东西）
2. 通用 held-out PPL —— 应当有所上升（这是我们付出的代价）
3. 来自 KobEval-TH 评测集的 TH-KNOW accuracy，附带 Wilson 95% CI

9. 对比（Comparison）​

notebook 在同一份数据上训练了三种配置，好让这笔交易变成看得见的数字：

读懂这张表就是本章的核心：

• λ = 1.0 在领域 PPL 上最好（4.07），但通用 PPL 变差，从 5.88 升到 6.72 —— 这就是被量化出来的灾难性遗忘，而不是空口断言。
• λ = 0.5 在领域上让出一点（4.29），通用 PPL 反而变好 到 4.98。 replay 在这里不只是防止遗忘，还让模型整体的泰语建模能力更强了。

10. 小结（Summary）​

• CPT 用与预训练相同的 objective 把知识写进权重，不需要任何标签
• 它永远是一笔交易：领域上的精准，是拿丢掉的通用能力换来的
• replay ratio $\lambda$ 就是调节汇率的旋钮——去扫，别猜
• 足够低的学习率是"做 CPT"和"毁掉模型"之间的分界线
• 每一个数字都必须带上置信区间

下一章： SFT 与 LoRA——当模型已经有了知识，我们该怎么教它回答， 以及为什么只训练 1.7% 的参数，效果就能逼近全参数训练。

参考文献（References）​

1. Gururangan et al. (2020). Don't Stop Pretraining: Adapt Language Models to Domains and Tasks — 本章所遵循的领域自适应预训练方法的源头
2. Ibrahim et al. (2024). Simple and Scalable Strategies to Continually Pre-train Large Language Models — 让 CPT 不至于毁掉模型的 replay 与学习率策略
3. Gupta et al. (2023). Continual Pre-Training of Large Language Models: How to (re)warm your model? — 继续预训练时学习率 warmup 为何如此关键
4. Luo et al. (2023). An Empirical Study of Catastrophic Forgetting in Large Language Models During Continual Fine-tuning — 对灾难性遗忘的系统性量化
5. Kaplan et al. (2020). Scaling Laws for Neural Language Models — scaling laws——"8,000 篇文档远远不够"的依据
6. Hoffmann et al. (2022). Training Compute-Optimal Large Language Models — Chinchilla：算力最优的数据与参数配比
7. Yuenyong et al. (2025). OpenThaiGPT 1.6 and R1: Thai-Centric Open Source and Reasoning Large Language Models — 真实规模的泰语 CPT，可与本章的小实验对照
8. Lowphansirikul et al. (2021). WangchanBERTa: Pretraining transformer-based Thai Language Models — 泰语预训练模型的先行者及其语料处理

本系列的文章、代码与 notebook 均以 CC BY-NC-SA 4.0 授权 —— 可自由使用与改编，须署名、限非商业用途，并以相同方式共享。文中引用的第三方模型与数据集仍适用各自的许可证。

1. 问题（Problem statement）​

拿上一章那个纯 base 模型 Qwen3-0.6B-Base，输入一句泰语 "帮我推荐几道泰国菜吧"。你得到的往往不是回答， 而是续写——它可能再帮你编三个问题、把话头接成一篇旅游文章， 或者写到一半切换成英语。因为它唯一被训练过的事情是："互联网上这样的文字，后面通常跟着什么"。

回答的能力——接住指令、答在点上、然后停下来——不是 pretraining 自带的。 它来自 SFT：用几千到几百万对（指令，好的回答）继续训练。 你用过的每一个 instruct 模型，无一例外都走过这一步。

但真要自己动手，会撞上叠在一起的两层问题：

第一层——full fine-tuning 的成本。 如果训练全部参数，每个任务你都会得到一整个新模型（0.6B 模型约 1.2 GB）。 一个有十个任务的组织——文档摘要、公文起草、客服回复、投诉分类——就得存十份副本。 而且用偏高的学习率去动每一个权重，正是把第 1 章刚灌进去的知识抹掉的配方（还记得那个学习率警告框吗）。

第二层——泰语。 即便是已经 post-train 过的 Qwen3-0.6B， 也有一个我们全系列反复看到的症状：用泰语提问，回答却在句子中途滑回英语 （这正是本系列 th_ratio 指标的由来），因为它见过的 SFT 数据以英语为主。

这一章同时解决两层问题：用泰语指令数据做 SFT，并用 LoRA 代替 full fine-tuning。

2. 我们要做什么（Solution）​

我们会拿 Qwen3-0.6B，用 4,000 条泰语指令-回答对来训练， loss 和第 1 章一模一样，外加两件新东西：

1. 补全掩码（completion mask）——只在回答一侧的 token 上计 loss，不计提问一侧（3.1 节会解释跳过这一步会怎样以一种滑稽的方式翻车）
2. LoRA（Low-Rank Adaptation）——把原有权重全部冻结，改为在每层之上叠加两个小矩阵来训练

3. 公式（Equation）​

3.1 SFT loss 与补全掩码​

• $(x, y)$ = 一条训练样本——$x$ 是指令部分（含 chat template），$y$ 是模型训练时真正看到的 token 序列
• $y_t$ = 第 $t$ 个位置的 token，$y_{<t}$ = 它前面的全部 token
• $p_\theta$ = 参数为 $\theta$ 的模型预测出的概率
• $m_t \in \{0,1\}$ = 补全掩码——只在回答一侧的 token 上为 1，在 prompt 的 token 上为 0

试着把 $m_t$ 拿掉（即令 $m_t \equiv 1$ 处处成立），这个式子立刻变回第 1 章 CPT 的 objective。 SFT 就是把文本布置成对话场景的 CPT，再加上一个掩码——没有更多了。

但这一个掩码就是成功的一半，因为 $m_t \equiv 1$ 是最容易踩中的默认值 （很多 pipeline，包括 SFTTrainer，如果 collator 没配对，就会悄悄按这种方式训练）。 而在典型的泰语指令数据里，prompt 一侧的 token 占到样本的约 60%—— 也就是说你的大部分梯度正在教模型学写用户的提问，而不是学回答。 它的后遗症会在第 9 节现出原形。

3.2 LoRA：训练修正项，而不是权重​

LoRA 不直接更新权重矩阵 $W_0$，而是把 $W_0$ 钉死，去学习一个由两个小矩阵相乘构成的差量：

• $W_0 \in \mathbb{R}^{d\times k}$ = 该层的原始权重，被冻结，完全不接收梯度
• $B \in \mathbb{R}^{d\times r}$ 和 $A \in \mathbb{R}^{r\times k}$ = 我们真正训练的两个 adapter 矩阵
• $r \ll \min(d, k)$ = 修正项的秩（rank）——LoRA 的主旋钮（本章用 $r = 16$）
• $\alpha$ = 缩放系数——乘积 $BA$ 永远会被乘上 $\alpha/r$（本章 $\alpha = 32$，所以 $\alpha/r = 2$）

这个定义里有两个细节，重要程度远超它们的长相：

$B$ 整个矩阵被初始化为零，所以第一步时 $\Delta W = 0$—— 训练从 base 模型分毫不差地出发，不存在被随机权重扰动的阶段。 （$A$ 则是随机 Gaussian——如果两个都设成零，双方的梯度会永远为零，因为各自都在和零相乘。）

$\alpha/r$ 里的除数 $r$ 让 update 的量级与秩无关—— 把 $r$ 翻倍，$BA$ 的求和多出一倍的项，却刚好被除回去。 所以你可以扫一遍 $r$ 的取值，而不必每次重新调学习率。

训练结束后你有两条路：merge（$W' = W_0 + \frac{\alpha}{r}BA$，得到一个没有额外 latency 的单一模型）， 或分开保存——本系列选的是第二条，因为可插拔的 adapter 正是第 4 章免费变出 reference model 的道具。

3.3 可训练参数占比——一个要亲手验算的数字，不是背下来的数字​

对一个 $d \times k$ 的矩阵，adapter 有 $rd + rk$ 个参数，占比为

• $d, k$ = 原权重矩阵的维度
• $r$ = adapter 的秩

代入 Qwen3-0.6B 的真实数值（hidden 1024、intermediate 3072、28 层， 在 q、k、v、o、gate、up、down 全部 7 个矩阵上挂 adapter），可训练参数是 10,092,544 个， 基座是 596,049,920 个 = 1.69%。

4. 把公式画出来（Visualize）​

一个掩码，扭转整坨梯度的方向​

这张图没有任何比数 token 更深的内容——但被跳过的恰恰就是数 token 这一步： 泰语的 prompt（含 system message 和 chat template）往往比回答更长， 不加掩码地训练，你就把大部分算力花在了教模型一件你根本不想要的事上。 notebook 会把抽样数据集的真实占比打印出来——图中的 60/40 只是一个典型样本的代表值，不是什么神圣常数。

为什么 rank 16 就"够了"——low-rank 假设​

LoRA 的假设（Hu 等人，2021）是：相对于矩阵的全维度，fine-tune 只在为数不多的几个重要方向上挪动权重。 这张图人为构造了一个正好具有这种结构的假 $\Delta W$（rank 16 信号 + 噪声）， 再让 SVD 把它找回来——如果真实的 update 长这样，rank 16 的 adapter 就能留住几乎全部内容。 这张图没有证明的是：真实的 update 总是长这样。 那是研究的经验性发现，也是 LoRA "通常"逼近 full fine-tuning、而非"总是"的原因。

验算数字，不要背数字​

log-log 轴上的直线印证了公式所说的：占比随 $r$ 精确线性增长。 在这个模型上，"低于 1%"只有当 $r \le 9$ 时才成立—— 而那不是任何人在语言任务上真正会用的值。我们用的点（$r=16$）是 1.69%，以 fp32 保存约 40 MB。

5. 准备环境（Environment）​

打开 Colab，选择 Runtime → Change runtime type → T4 GPU（免费额度够用）。

torch_dtype=torch.float16      # 不是 bfloat16
attn_implementation="sdpa"     # 不是 flash_attention_2
fp16=True                      # 在 SFTConfig 里（不是 bf16=True）

cap = torch.cuda.get_device_capability(0)
print("compute capability:", cap)                    # T4 = (7, 5)
print("native bf16:", cap[0] >= 8)                   # T4 -> False
print("torch says   :", torch.cuda.is_bf16_supported())  # T4 -> True（把 emulation 也算上了！）

for p in model.parameters():
    if p.requires_grad:
        p.data = p.data.float()      # 只转 adapter —— 不是整个模型

用了 LoRA 之后彻底改头换面的显存预算​

还记得第 1 章 Adam 的 optimizer state 比模型本身还占地方吗（$m$ 和 $v$ 合计约 4.4 GB）。 现在只训练 adapter，Adam 只需为 1,010 万个参数存 state——大约 0.08 GB， 连 adamw_bnb_8bit 都不再需要了。剩下的大头是 base 权重（fp16，约 1.2 GB）和 activations。

在计算器里切换 full fine-tuning 和不同的 LoRA rank，看看预算在哪里发生变化：

6. 准备数据（Data）​

我们使用 airesearch/wangchanx-seed-free-synthetic-instruct-thai-120k—— WangchanX 团队的 120,000 对合成泰语指令-回答数据集（抽样 4,000 条使用）。

from datasets import load_dataset

ds = load_dataset("airesearch/wangchanx-seed-free-synthetic-instruct-thai-120k", split="train")
ds = ds.shuffle(seed=42).select(range(4000))

def to_text(ex):
    messages = [
        {"role": "user", "content": ex["instruction"]},   # 列名务必对照 dataset card 检查
        {"role": "assistant", "content": ex["output"]},
    ]
    return {"text": tok.apply_chat_template(messages, tokenize=False,
                                            enable_thinking=False)}

train_ds = ds.map(to_text, remove_columns=ds.column_names)

有两行值得放慢速度读：

• apply_chat_template 把消息拼装成 Qwen3 被训练时的格式（<|im_start|>user … <|im_end|> …）。 我们只在这一个地方调用一次——原因见第 9 节的陷阱 2
• enable_thinking=False 关闭 Qwen3 的 thinking 模式，让本章的样本保持简单、掩码逻辑直截了当

然后是一个应该养成习惯的仪式：永远把第一条样本 decode 出来亲眼看一遍。

print(train_ds[0]["text"][:400])
# 必须看到 <|im_start|>user ... <|im_end|> ... <|im_start|>assistant ... 每个 turn 各出现一次

notebook 还会打印抽样数据的 token 长度统计：prompt 一侧与回答一侧的中位数， 以及长度超过 768 token 的样本占比——后面这个数字会在陷阱 3 里回来讨债。

7. 核心代码（Main code）​

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model
from trl import SFTTrainer, SFTConfig, DataCollatorForCompletionOnlyLM

tok = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B",                # post-trained 版 —— 本章修的是行为，不是灌知识
    torch_dtype=torch.float16,        # T4 没有 bf16
    attn_implementation="sdpa",       # T4 没有 FlashAttention-2
).cuda()

lora = LoraConfig(
    r=16,
    lora_alpha=32,                    # α/r = 2 —— 见公式 3.2
    lora_dropout=0.05,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    task_type="CAUSAL_LM",
)
model = get_peft_model(model, lora)
model.print_trainable_parameters()    # 信这一行，别信任何博客里的数字

for p in model.parameters():          # 第 5 节的 fp16 警告框
    if p.requires_grad:
        p.data = p.data.float()

接下来是把公式 3.1 翻译成代码的那一块——充当 $m_t$ 的 collator：

collator = DataCollatorForCompletionOnlyLM(
    response_template="<|im_start|>assistant\n",   # 这之前的一切 = prompt
    tokenizer=tok,
)

这个 collator 把 <|im_start|>assistant 之前所有 token 的 label 设为 -100—— 这是 PyTorch 的 loss function 会跳过的值，也正是第 4 章 seq_logp 函数里 用来掩掉 prompt 一侧的同一个值。同一个掩码，出现在不同的章节。

cfg = SFTConfig(
    output_dir="sft-out",
    dataset_text_field="text",
    max_seq_length=768,               # notebook 会打印被截断的样本数 —— 陷阱 3
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,    # effective batch = 16
    num_train_epochs=1,
    learning_rate=2e-4,               # LoRA 扛得住 —— full FT 用这个值就是灾难（第 1 章）
    lr_scheduler_type="cosine",
    warmup_ratio=0.03,
    packing=False,                    # completion mask 无法直接和 packing 一起用
    fp16=True,                        # T4：不是 bf16
    logging_steps=10,
)

trainer = SFTTrainer(
    model=model,
    args=cfg,
    train_dataset=train_ds,
    data_collator=collator,
    processing_class=tok,
)
trainer.train()                       # 在 T4 上约 15 分钟

训练结束，只保存修正项：

model.save_pretrained("qwen3-0.6b-th-sft-lora")   # ~40 MB —— 不是 1.2 GB

这个 adapter 正是第 4 章以 kobkrit/qwen3-0.6b-th-sft-lora 之名加载的那个， 既当初始 policy，又（在关掉 adapter 时）当 reference model——一份价值 40 MB 的跨章礼物。

8. 结果（Results）​

notebook 会在训练前后各测三项指标，并写入 results.json：

1. TH-INSTR——通过指令遵循 rubric（答在点上、自己收尾、不出戏）的回答占比， 来自 KobEval-TH 评测集，附 Wilson 95% CI
2. th_ratio——回答中泰文字符的占比，本系列的常驻指标。 初始的 Qwen3-0.6B 在泰语 prompt 上以滑回英语著称，用 4,000 条纯泰语数据做 SFT 应当让这个数字明显上移——如果没动，那就是先去排查掩码和 template 的信号，别的以后再说
3. 在 token 预算内以 eos 收尾的回答占比——捕捉陷阱 1 和陷阱 3 造成的"停不下来"症状

9. 对比（Comparison）​

notebook 在同一份数据上训练三种配置，再与初始模型对照：

SFT 在每个维度都有提升：TH-INSTR +10 分（73.3% → 83.3%），th_ratio 上升 （更多回答留在泰语，不再漂移到英语），困惑度从 21.3 降到 17.7 —— 而只训练了 1.69% 的参数，adapter 仅约 40 MB。

关于全参数微调与不加掩码那一行： notebook 确实训练了一个不加掩码的 LoRA，用来展示模型 答完之后自问自答续写用户问题的行为（示例见 §8），但没有为它计算完整指标，也没有做 100% 参数的全参数微调 —— 那超出了免费 Colab 的预算。我们只报告实测到的数字，不为没有跑过的 实验填数。

10. 小结（Summary）​

• SFT 就是对话版的 CPT + 补全掩码——loss 还是第 1 章那个，变的是数据被布置成了对话，以及掩码决定哪些 token 计入
• 掩码是成功的一半——$m_t \equiv 1$ 会让 60% 的梯度去学写提问，训出一个答完还自己编问题的模型
• LoRA 训练的是"修正项"，不是权重：$W' = W_0 + \frac{\alpha}{r}BA$，$B$ 从零出发，训练从 base 精确起步；$\alpha/r$ 让换 rank 不用重调 lr
• 1.69% 不是"低于 1%"——adapter 随 hidden size 线性增长，base 按二次方增长，模型越小 adapter 占比越大。永远用 print_trainable_parameters() 核实
• 每个任务约 40 MB 的 adapter：一个 base + 多个 adapter，这也是第 4 章 reference model 免费的原因
• lr 2e-4 之所以安全，是因为 base 被冻结——同一个值在全参数训练下会毁掉模型
• pad ≠ eos、template 只套一次、别让截断砍在回答中间——三个症状在 inference 现形、根子却在数据里的坑

下一章： RLHF 与 PPO——模型会回答了，但"答得好"写不成 loss function。 我们会让人类比较回答、从这些偏好中训练 reward model，再用 reinforcement learning 把模型推向它—— 而起点，就是本章这个 40 MB 的 adapter。

参考文献（References）​

1. Hu et al. (2021). LoRA: Low-Rank Adaptation of Large Language Models — 第 3 节 W' = W₀ + (α/r)BA 公式的出处
2. Aghajanyan et al. (2020). Intrinsic Dimensionality Explains the Effectiveness of Language Model Fine-Tuning — 微调具有低内在维度的证据——LoRA 为何有效
3. Dettmers et al. (2023). QLoRA: Efficient Finetuning of Quantized LLMs — 用 4-bit 扩展 LoRA，使更大的模型能装进单张 GPU
4. Biderman et al. (2024). LoRA Learns Less and Forgets Less — LoRA 以学得更少换取忘得更少——建议与第 9 节对读
5. Ouyang et al. (2022). Training language models to follow instructions with human feedback — InstructGPT：整条 SFT -> RM -> PPO 流水线的源头
6. Wang et al. (2022). Self-Instruct: Aligning Language Models with Self-Generated Instructions — 用模型自身生成指令数据
7. Zhou et al. (2023). LIMA: Less Is More for Alignment — 几千条高质量样本就够——我们只用 4,000 条的理由

本系列的文章、代码与 notebook 均以 CC BY-NC-SA 4.0 授权 —— 可自由使用与改编，须署名、限非商业用途，并以相同方式共享。文中引用的第三方模型与数据集仍适用各自的许可证。

1. 问题（Problem statement）​

第 2 章的 SFT 藏着一个前提假设：必须有标准答案可以模仿。 但想想我们真正想要的东西，比如"把数学题做对，并用读得通的泰语解释清楚"—— 这句话没有唯一答案，好的回答可以有一百种写法，而"读得通"三个字根本写不成公式。

一旦试图直接 optimize 这些目标，我们总会撞上两堵墙：

第一堵墙——质量写不成 loss。 "更好"无法定义成函数，但人类比较的能力极强： 给两个回答让人指出更喜欢哪个，立刻能答，而且相互间还算一致。 所以现实中能收集到的数据是三样东西：prompt $x$、被选中的回答 $y_w$、被拒绝的回答 $y_l$。

第二堵墙——就算有了分数，也无法 backprop。 假设存在一个魔法函数 $r(x,y)$ 能给每个回答打分，你依然没法做 supervised 训练： 因为回答 $y$ 是一个 token 一个 token 采样出来的，分数在采样结束之后才到， 而导数无法逆着采样往回走——从 $r$ 回到权重 $\theta$ 的路径恰好在那里断掉了。

这就是本章标题的由来：我们要 optimize 的是一个无法求导的奖励。 能做到这件事的工具，名叫 reinforcement learning。

2. 我们要做什么（Solution）​

RLHF 用两步走同时拆掉两堵墙：

• Stage A——Reward Model： 训练一个模型 $r_\phi(x,y)$ 去模仿人类在偏好对上的比较（拆第一堵墙，并顶替打分打不过来的人类）
• Stage B——PPO： 用 policy-gradient RL 把 policy 推向 $r_\phi$ 的高分方向，全程不需要对采样求导（拆第二堵墙），同时系上KL 牵引绳，不让它跑离初始模型

付出的代价是复杂度：训练期间有四个模型同时待在显存里—— policy $\pi_\theta$（被训练的那个）、reference $\pi_{\text{ref}}$（被冻结的初始模型）、 reward model $r_\phi$，以及一个还没登场的 value network（价值网络）$V_\psi$（3.4 节见）。

还有一句话请揣在兜里带完全系列：本章的 objective 是整个系列后半程的母公式。 第 4 章（DPO）把它解成闭式，让 reward model 和 RL 循环相互抵消。 第 5 章（GRPO）换掉 advantage（优势）的估计方式，让价值网络消失。 把这一章弄懂，后面两章就成了一眼能读懂的"零件删减"。

3. 公式（Equation）​

3.1 Reward model：Bradley–Terry​

Stage A 用一个短短的 loss 训练 $r_\phi$：

• $r_\phi(x,y)$ = 每段文本一个标量分数——实践中就是把语言模型的头换成单层 linear（num_labels=1）
• $\sigma$ = sigmoid，把分数差变成人类会选 $y_w$ 的概率（Bradley–Terry 模型）
• 差值 $r_\phi(x,y_w) - r_\phi(x,y_l)$ 拉得越开，loss 越低

一个常被忽视、事后吃亏的点：这个 loss 只看得见分数的差值。 把 $r_\phi$ 换成 $r_\phi + c$（$c$ 是任意常数）——loss 纹丝不动。 也就是说 reward model 的绝对尺度没有意义，也不被训练所确定。 跑两次可能得到平均分 3.7 和 −12.4，排序却完全一致。 这就是进 PPO 之前必须先 standardize reward（减 mean 除 std）的原因——记住这一点，它会在第 7 节和第 9 节回来。

3.2 母公式：RLHF objective​

如果全系列只背一个公式，就背这个：

用人话读一遍："把 reward 分数拿到最多，但每离初始模型远一步，都要交罚款。"

• $\pi_\theta$ = policy，正在训练的模型——注意 $y$ 是从 $\pi_\theta$ 自己采样出来的，这是它与从静态文件学习的 SFT 之间的结构性区别
• $\pi_{\text{ref}}$ = reference，初始模型（第 2 章 SFT 之后的模型），训练全程冻结
• $\beta$ = 每偏离一个 nat 的价格——牵引绳的紧度
• $\mathbb{D}_{\text{KL}}$ = policy 与 reference 之间的分布距离

3.3 PPO 裁剪代理目标：Stage B 的发动机​

原始的 policy gradient（REINFORCE）一批 rollout 只能更新一次就得扔，非常昂贵——因为 generate 才是瓶颈。 PPO 想把同一批 rollout 榨上好几个 epoch，就需要一个校正系数（importance sampling ratio）：

• $s_t$ = 位置 $t$ 的状态，即 prompt 加上已经采样出的全部 token
• $a_t$ = "动作"，即 rollout 时已经采样出的下一个 token
• $\pi_{\theta_{\text{old}}}$ = rollout 那一刻的 policy snapshot——只算一次，然后冻结

再用 clip 把 $\rho_t$ 夹住：

• $\hat A_t$ = 优势（advantage），"这个 token 比预期好多少"（下一小节定义）
• $\epsilon$ = trust region 的宽度（标准值 0.2）

核心在于 min + clip 合起来构成一种刻意的悲观： 如果 $\hat A_t$ 为正（好 token），把 $\rho_t$ 往上推的收益被封顶在 $1+\epsilon$——推过头没有任何额外收益，梯度为零。 但如果 $\hat A_t$ 为负（坏 token），min 永远会选更差的那一支——罚款没有上限。 一句话总结：收益有限，损失无限。policy 因此只会在原地附近迈小步。

3.4 GAE：怎么算 advantage 才不会淹死在噪声里​

advantage 由价值网络 $V_\psi$ 的 TD error 构建：

• $V_\psi(s_t)$ = 价值网络，预测"从这里走到结束，还能收多少 reward"——这就是第四个模型
• $r_t$ = 每个 token 的 reward（在我们的任务里：每个位置的 KL 罚款，外加最后一个 token 上的任务得分）
• $\gamma$ = discount factor（LLM 任务通常取 1.0）
• $\lambda$ = bias–variance 旋钮：$\lambda = 0$ 全盘信任 $V_\psi$（$V_\psi$ 预测跑偏时 bias 大），$\lambda = 1$ 完全不信、等着看真实结局（背上整条链的噪声，variance 大），常用值 0.95

3.5 PPO 的完整 loss：三项，两个模型​

把所有零件拼成 optimizer 真正看到的那一个 loss（按 minimize 的写法）：

• 第一项 = 3.3 节的裁剪代理目标（加负号，因为我们要 maximize）
• 第二项 = value loss，教 $V_\psi$ 贴近真实 return $\hat R_t$，$c_1$ 通常取 0.5
• 第三项 = entropy bonus $\mathcal{H}$，防止分布过早塌缩，$c_2$ 通常取 0.01
• 至于公式 3.2 的 KL 牵引绳，实践中习惯把它塞进逐 token 的 reward：$r_t \leftarrow r_t - \beta\,(\log\pi_\theta - \log\pi_{\text{ref}})$——第 7 节用的正是这个写法

数一数需要调的玩具：4 个模型，加上 $\epsilon, \beta, \gamma, \lambda, c_1, c_2$，再加两套 learning rate。 这就是 PPO "换个 seed 跑两遍，结果完全两回事"名声的来源， 也是第 4 章整章存在的理由。

4. 把公式画出来（Visualize）​

Bradley–Terry：梯度堆在还排错的那些对上​

在下面的工具里选择 Bradley-Terry 模式，然后拖动 margin 看看： reward model 已经自信排对的对（margin 很正）几乎不剩任何梯度—— Stage A 的训练预算会自动流向它还排错的那些对。

如果这张图让你想起第 4 章 DPO 的梯度——不是巧合。 DPO 把这个 Bradley–Terry 模型整个搬了过去，只是换了"由谁来充当 reward"。

看得见的 trust region：min + clip​

请仔细看那份不对称——它就是 PPO 的全部性格： 朝好的方向挪，每次最多赚 20%；但一旦给坏 token 的概率多了，就会被全力拽回来。 图中的"平坦区"正是 trust region，它让 PPO 可以把旧 rollout 反复用上好几个 epoch 而不爆炸。

GAE 的 bias–variance 旋钮​

从底部那条线往上读：$\lambda = 0$（绿）时 advantage 几乎全程贴零—— 结尾的分数传不到前面的 token，因为一切都要经过预测跑偏的 $V_\psi$ 过滤。 $\lambda = 1$（红）时每个 token 都从结尾拿到全额 credit，但也背上了整条链累积的噪声。 $\lambda = 0.95$（蓝）是全行业选中的中间点——信号走得远，噪声被压住。

继续之前，先亲手建立 advantage——"比预期好多少"——的直觉： 下面的工具用组内平均代替 $V_\psi$ 当 baseline（这是对第 5 章的全剧透）。 按下 All correct 那组，看看当所有回答拿到相同 reward 时会发生什么：

全组 advantage 为零 = 没有任何可学的信号——把这个感觉记住，读第 9 节时会用到。

KL 牵引绳：把公式 3.2 画出来​

绿线停下来的那个点不是猜的——它就是公式 3.2 的数学结论： 优化会恰好停在"每多偏离一个 nat 所换来的 reward 正好等于 β"的位置，再往前走就是亏本。 当 $\beta = 0$ 时，这个停止条件根本不存在——只要多偏离一点点还能换到哪怕一丁点 reward，那就算"赚"。 于是模型会一路远离自然语言，只要 reward 的数字还在往上跳。

5. 准备环境（Environment）​

打开 Colab，选择 Runtime → Change runtime type → T4 GPU（免费额度够用）。

torch_dtype=torch.float16      # 不是 bfloat16
attn_implementation="sdpa"     # 不是 flash_attention_2

cap = torch.cuda.get_device_capability(0)
print("compute capability:", cap)                    # T4 = (7, 5)
print("native bf16:", cap[0] >= 8)                   # T4 -> False
print("torch says   :", torch.cuda.is_bf16_supported())  # T4 -> True（把 emulation 也算上了！）

为什么 RLHF 昂贵：一张图说完​

图中的数字只是权重——还没算 activation、generate 时的 KV cache、gradient 和 optimizer state。 在 0.6B 上一切都显得小巧，但那个 ×4 的乘数在放大时哪儿也不去：到 7B 就是 56 GB，什么都还没开始做。

6. 准备数据（Data）​

Stage A——给 reward model 的偏好对​

使用 iapp/dpo_thai_tutorial（100 对，Apache-2.0）—— 我为这个系列亲手制作并开放使用的泰语偏好数据集。 每行有人工挑选的 prompt、chosen、rejected，重点关注礼貌程度和语言的自然度。

按 80/20 切分：80 对训练，20 对留作 held-out，训练期间绝不碰。 Stage A 的及格线是：在留出的 20 对上的 pairwise ranking accuracy，其 Wilson 95% CI 不跨 0.5 ——只要"显著好于抛硬币"就算机制验证成功，因为 20 对实在做不出更窄的 CI。

Stage B——能用规则批改的题目​

PPO 循环用的是 VISAI-AI/gsm8k-thai（GSM8K 的泰语翻译版）里的 64 道数学题， 并用可核查的规则打分，而不是用 Stage A 的 reward model：

import re

def rule_reward(response: str, gold: int) -> float:
    """回答中最后一个整数正确得 +1.0，真的用泰语回答再得 +0.2"""
    nums = re.findall(r"-?\d+", response.replace(",", ""))
    correct = 1.0 if nums and int(nums[-1]) == gold else 0.0
    thai = sum("ก" <= ch <= "๛" for ch in response)
    thai_bonus = 0.2 if thai / max(len(response), 1) >= 0.5 else 0.0
    return correct + thai_bonus

7. 核心代码（Main code）​

7.1 Stage A——训练一个真正的 reward model（约 6 分钟）​

把语言模型改造成打分机：LM 头被换成返回单个标量的单层 linear。

import torch, torch.nn.functional as F
from transformers import AutoModelForSequenceClassification, AutoTokenizer
from peft import LoraConfig, get_peft_model

tok = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")
rm = AutoModelForSequenceClassification.from_pretrained(
    "Qwen/Qwen3-0.6B",
    num_labels=1,                          # 标量头：每段文本一个分数
    torch_dtype=torch.float16,             # T4 没有 bf16
    attn_implementation="sdpa",
).cuda()
rm.config.pad_token_id = tok.pad_token_id

rm = get_peft_model(rm, LoraConfig(
    task_type="SEQ_CLS", r=8, lora_alpha=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    modules_to_save=["score"],             # 打分头是随机初始化的，必须全量训练
))
for p in rm.parameters():
    if p.requires_grad:
        p.data = p.data.float()            # 第 1 章的 fp16 教训：在 fp32 中训练

def rm_loss(chosen, rejected):
    s_w = rm(**chosen).logits.squeeze(-1)     # r_φ(x, y_w)
    s_l = rm(**rejected).logits.squeeze(-1)   # r_φ(x, y_l)
    return -F.logsigmoid(s_w - s_l).mean()    # 就是公式 3.1 本身

在 80 对上训 3 个 epoch，然后在留出的 20 对上测 pairwise accuracy，附 Wilson CI。 如果 CI 不跨 0.5——你刚刚用 80 行数据，成功训出了人生第一个 reward model。

7.2 Stage B——从零手写 PPO，约 120 行（约 10 分钟）​

我们不用 TRL 的 PPOTrainer，而这是一个刻意的决定，不是犟： TRL 已把 PPOTrainer 移入 trl.experimental，并宣布计划在 0.29.0 移除—— 用这个库教的代码，再过几个月就跑不起来了。 而自己写的约 120 行 PPO 循环，只要 PyTorch 还在就能跑。 更重要的是：亲手写过，你才知道每一行在做什么——和第 4 章那 25 行 DPO loss 是同一个道理。

棋盘上的棋子：policy = base + LoRA adapter（来自第 2 章，is_trainable=True）， reference = 同一个 base 关掉 adapter，value head 是插在最后一层 hidden state 上的两层 MLP：

value_head = torch.nn.Sequential(
    torch.nn.Linear(1024, 1024), torch.nn.Tanh(),
    torch.nn.Linear(1024, 1),
).float().cuda()                           # ~1M 参数 —— 和另外三个比起来微不足道

rollout：每次对 8 个 prompt 采样回答（max_new_tokens=200、do_sample=True）， 用 rule_reward 打分，在 batch 内 standardize 分数，并当场把 rollout 时的 log-prob detach 存下来。 然后进入这个 update 循环——全章的心脏，40 行（完整循环在 notebook 里）：

def compute_gae(rewards, values, gamma=1.0, lam=0.95):
    """rewards: 单条 response 的 [T]，values: [T+1]（最后一格 = 结束后为 0）"""
    adv, acc = torch.zeros_like(rewards), 0.0
    for t in reversed(range(rewards.shape[0])):
        delta = rewards[t] + gamma * values[t + 1] - values[t]   # 公式 3.4
        acc = delta + gamma * lam * acc                          # Â_t = δ_t + γλ Â_{t+1}
        adv[t] = acc
    return adv

def ppo_update(rollout, eps=0.2, beta=0.05):
    out = policy(rollout.ids, output_hidden_states=True)         # 一次 forward 拿两样东西
    logp = gather_logprobs(out.logits, rollout.ids)              # [B, T] 带梯度
    with torch.no_grad(), policy.disable_adapter():
        logp_ref = gather_logprobs(policy(rollout.ids).logits, rollout.ids)

    # 逐 token 的 reward = 每个位置的 KL 罚款 + 最后一个 token 上的任务得分（公式 3.2）
    rew = -beta * (logp.detach() - logp_ref)
    rew[:, -1] += rollout.scores_std                 # standardize 过的 rule 得分

    hidden = out.hidden_states[-1].detach().float()  # detach = 切断流向主干的梯度
    values = value_head(hidden).squeeze(-1)
    adv = torch.stack([compute_gae(r, F.pad(v, (0, 1))) for r, v in zip(rew, values)])
    adv = (adv - adv.mean()) / (adv.std() + 1e-8)    # 再 standardize 一层 advantage

    log_ratio = (logp - rollout.logp_old).clamp(-10, 10)   # 防 fp16 overflow！
    ratio = log_ratio.exp()                                # ρ_t（公式 3.3）
    surr = torch.min(ratio * adv.detach(),
                     ratio.clamp(1 - eps, 1 + eps) * adv.detach())

    returns = (adv + values).detach()                # value head 的学习目标
    m = rollout.resp_mask                            # 只统计 response 的 token
    loss = (-(surr * m).sum() + 0.5 * ((values - returns).pow(2) * m).sum()) / m.sum()
    return loss                                      # （entropy 项在 notebook 里）

配置：$\epsilon = 0.2$、$\beta = 0.05$、$\gamma = 1.0$、$\lambda = 0.95$， 同一批 rollout 训 4 个 epoch，共 64 个 prompt，adapter 的 LR 为 1e-5、value head 为 1e-4。 在 T4 上一次运行约 10 分钟（notebook 会跑两次：$\beta = 0.05$ 和 $\beta = 0$）。

8. 结果（Results）​

notebook 每个 update 同时量三条曲线，并写入 results.json：

1. 每个 rollout 的平均 reward——应当爬升（这是我们买到的东西）
2. 相对 $\pi_{\text{ref}}$ 的逐 token KL——应当上升然后在 $\beta$ 划定的天花板下饱和（这是付出的价格）
3. 平均回答长度——病症探测器：长度异常暴涨或跳水，是 policy 开始跑偏的第一信号

当场抓获 reward hacking​

notebook 的第二次运行设定 $\beta = 0$，其他一个字都不动——没有牵引绳。 预期会看到的模式：reward 爬得一样快或更快，但 KL 没有天花板地飞升， 回答开始退化——车轱辘话、异常地短，或者变成句尾塞个数字的固定套路。 因为 rule_reward 只看得见最后的数字和泰文字符占比——它看不见的一切，都是模型可以白扔的东西。

$\beta = 0$ 运行中退化回答的实例，会由 notebook 的最后一个 cell 打印出来：

[这一格只能由 notebook 的真实运行结果来填 —— 我不会自己编造 degenerate 的例子，
 因为整个系列立足的规矩就是：没有任何数字或 output 是 invent 出来的。
 跑完 notebook，"hacking exhibits" 那个 cell 会展示 2-3 条真实回答和它们的 KL]

9. 对比（Comparison）​

notebook 用同一套 held-out 泰语数学题（TH-MATH）测量三个系统：

你应该看到的模式是：$\beta = 0.05$ 那行 accuracy 小幅上移或持平，KL 稳定； $\beta = 0$ 那行拿到训练时最高的 rule reward，但 held-out accuracy 不应更好， 而且语言崩坏——作弊刷来的分数不会迁移到新题上。

如果看到的是别的情况，可以这样解读：

• 三行几乎没有差别 → advantage 几乎全程为零。检查每个 batch 里的 reward 有没有多样性（如果模型每道题都答错，standardize 之后的 advantage 就是纯噪声——和第 4 节工具里 All wrong 那组一模一样的感觉）
• β = 0 但 KL 没飞 → 4 epoch 乘 64 prompt 太短，hack 还没熟透——加大轮数再看，先别下"没有 hacking"的结论
• β = 0.05 但 KL 照样飞 → 几乎可以肯定是忘了 standardize 分数，让 reward 的尺度淹没了 β；要不然就是 LR 太高

需要提防的坑​

1. 不 standardize reward 按公式 3.1，reward 的尺度没有定义——两个排序完全一致的 RM 可以给出相差十倍的尺度。 而那个尺度是直接乘进 advantage 和梯度的：原本稳定的运行，一换 RM 就会当场爆炸。

2. 在 update 循环里重算 logp_old 本章最安静的 bug：没有报错，loss 看起来正常，但 $\rho_t = 1$ 恒久成立， clip 从未生效，trust region 并不存在——你以为自己在跑 PPO，其实在跑 REINFORCE。

3. policy 和 value 共用主干却不做 stop-gradient value loss 的尺度很大，会顺着 backbone 倒灌回去覆写语言能力。 本 notebook 用 hidden state 上的 .detach() 挡住它（见 7.2 节代码）——一行的价格。

4. fp16 ratio overflow log-ratio 大约到 11.1，exp(log_ratio) 就能冲破 fp16 的上限。 必须永远在 .exp() 之前 .clamp(-10, 10)——而且如果经常看到 log-ratio 涨到那个量级， 那本身就是 policy 逃离旧 rollout 太快的信号（降 LR，或减少每批 rollout 的 epoch 数）。

10. 小结（Summary）​

• RLHF = 两步绕路，去 optimize 无法求导的东西：先训练裁判（$r_\phi$），再用 RL 冲着裁判的分数跑
• Bradley–Terry 只看得见差值——reward 的绝对尺度没有定义，所以使用前永远要 standardize
• 母公式 $\max\ \mathbb{E}[r] - \beta\,\mathbb{D}_{\text{KL}}$ 是唯一需要背下来的公式——第 4、5 章就是用别的方法解这个公式
• KL 不是 regularizer——它是整个系统唯一的停止条件。什么时候拆掉它，Goodhart 什么时候上班
• min + clip = 设计出来的悲观：收益有限、损失无限——让旧 rollout 可以反复使用的 trust region
• GAE 是 bias–variance 旋钮，而它依赖的 $V_\psi$ 是第四个模型——第 5 章 GRPO 会把它删掉
• PPO 贵在结构，不是代码写得烂：4 个模型 + 十来个 hyperparameter，就是门票价格

下一章： DPO——DPO 用纯代数，从你刚背下的母公式 3.2 出发，把 reward model 和 RL 循环双双删掉。

参考文献（References）​

1. Schulman et al. (2017). Proximal Policy Optimization Algorithms — PPO 原始论文：第 3 节的裁剪代理目标
2. Schulman et al. (2015). High-Dimensional Continuous Control Using Generalized Advantage Estimation — GAE：PPO 所用的优势估计
3. Christiano et al. (2017). Deep reinforcement learning from human preferences — 开启"从人类偏好做 RL"的工作
4. Stiennon et al. (2020). Learning to summarize from human feedback — 首次在摘要任务上真正跑通的 RLHF
5. Ouyang et al. (2022). Training language models to follow instructions with human feedback — InstructGPT：整条 SFT -> RM -> PPO 流水线的源头
6. Bai et al. (2022). Training a Helpful and Harmless Assistant with Reinforcement Learning from Human Feedback — helpful/harmless 数据集及关于 KL 的经验
7. Zheng et al. (2023). Secrets of RLHF in Large Language Models Part I: PPO — 其他论文略去的 PPO 工程细节
8. Bradley & Terry (1952). Rank Analysis of Incomplete Block Designs: I. The Method of Paired Comparisons — 所有奖励模型赖以成立的 Bradley-Terry 模型

本系列的文章、代码与 notebook 均以 CC BY-NC-SA 4.0 授权 —— 可自由使用与改编，须署名、限非商业用途，并以相同方式共享。文中引用的第三方模型与数据集仍适用各自的许可证。

1. 问题（Problem statement）​

假设你希望自己的 AI 助手"永远用泰语回答"——听起来很简单。 但你试着把它写成一个 loss function 看看，你会发现根本写不出来。

这就是 alignment 的核心难题：回答的质量没法写成公式。 "更礼貌""更自然""不要中途滑回英语"——这些都不存在唯一正确的标准答案， 有的只是比较：让人看两个回答，然后说更喜欢哪一个。 于是得到的数据长成三元组：prompt $x$、被选中的回答 $y_w$（chosen）、被拒绝的回答 $y_l$（rejected）。

PPO 版本的 RLHF 用两步绕路来解决这个问题：

1. 训练一个奖励模型 $r_\phi(x,y)$ 去模仿人类的偏好
2. 用 RL 把策略推向该奖励模型给分高的方向

这条绕路是有代价的：

所以这一章的问题只有一句话：我们能不能把第 1 步和第 2 步直接跳过？

2. 我们要做什么（Solution）​

答案是能，而且理由非常漂亮。

出发点是这样一个观察：带 KL 约束的 RLHF objective 存在闭式解（closed form）。 我们其实早就知道最优策略长什么样，一个 RL step 都不用跑。 既然如此，我们就把公式反过来写——与其问"这个 reward 对应什么策略"， 不如问"这个策略意味着多少 reward"。

这就是 DPO（Direct Preference Optimization），由 Rafailov 等人在 2023 年提出。 名字里的 "Direct" 指的是我们直接在偏好数据上做优化，中间不经过任何代理。

3. 公式（Equation）​

3.1 先摆出题目：RLHF objective​

用人话读一遍："把 reward 拿到最高，但不许离初始模型太远。"

• $\pi$ = 策略，也就是我们正在训练的模型
• $\pi_{\text{ref}}$ = 参考策略，也就是初始模型（本章指第 2 章 SFT 之后的模型）
• $r(x,y)$ = 回答 $y$ 对 prompt $x$ 的 reward
• $\beta$ = 这根牵引绳的紧度，越大就把模型往 $\pi_{\text{ref}}$ 拉得越狠

KL 那一项不是装饰。没有它，模型会跑向 reward 很高但语言已经崩坏的地方。

3.2 第一步——闭式解​

上面这道题可以手推出来（本质是在求一个相对目标分布 KL 最小的分布），结果是

• $Z(x) = \sum_{y}\pi_{\text{ref}}(y|x)\exp\!\big(r(x,y)/\beta\big)$ 就是 partition function，负责把总和归一到 1 的分母
• 注意 $Z(x)$ 只依赖 $x$，不依赖 $y$——把这句话记牢，它待会儿是主角

直觉上的含义是：最优策略就是原模型，按 $\exp(r/\beta)$ 重新加权。 reward 高的回答概率被放大，reward 低的被压低，但一切始终是从 $\pi_{\text{ref}}$ 原本的形状出发的。

实际上我们算不出 $Z(x)$，因为那要把全宇宙所有可能的回答都加起来。 这正是大家不得不用 RL 的原因——也正是 DPO 不需要用 RL 的原因。

3.3 第二步——把公式反解出 reward​

两边取 log 再移项，得到

这一行就是关键：任何 reward 函数都可以改写成"最优策略与初始策略"的形式。 也就是说，只要手上有两个模型，我们立刻就能算出它隐含的 reward，完全不必训练任何奖励模型。

3.4 第三步——代入 Bradley-Terry，$Z(x)$ 抵消​

偏好的标准建模方式是 Bradley-Terry：人类选择 $y_w$ 而非 $y_l$ 的概率为

其中 $\sigma$ 是 sigmoid。注意在这个式子里，reward 只以差值的形式出现。 把 3.3 代进去——$\beta\log Z(x)$ 在两边完全相等，因为 $x$ 是同一个——于是它直接抵消掉了。

3.5 梯度——直觉所在之处​

其中 $\hat r = \beta\log\big(\pi_\theta/\pi_{\text{ref}}\big)$ 被称为隐式奖励（implicit reward）。

一块一块地读：

• 右边的括号 = 方向：同时把 $y_w$ 的 log-prob 推上去、把 $y_l$ 的 log-prob 压下来
• $\sigma(\hat r_l - \hat r_w)$ = 权重，也就是"模型把这一对排错得有多离谱"

这个权重是全章最重要的教学点。如果模型本来就把这一对排对了（$\hat r_w$ 明显大于 $\hat r_l$）， 那么 $\sigma(\hat r_l - \hat r_w)$ 会趋近于零，这一对几乎不贡献任何梯度。 于是 DPO 会自动把注意力集中在自己犯的错上，不需要任何人替它筛数据。

4. 把公式画出来（Visualize）​

Bradley-Terry：从 reward 差值到概率​

差值为零的那一点恰好给出概率 0.5，也就是"模型没有意见"。 又因为整条曲线只看差值，给两边的 reward 同时加上一个常数不会改变任何东西。 这就是 $Z(x)$ 能被抵消掉的几何解释。

Loss 与梯度权重​

令 $\Delta = \log\frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - \log\frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)}$， 则 loss 为 $-\log\sigma(\beta\Delta)$，梯度权重为 $\sigma(-\beta\Delta)$。

右边这一面板要仔细看：当 margin 很正的时候，权重会收敛到零——这一对"已经毕业了"。 而 $\beta$ 越大，曲线越陡，也就是学得越快、"退学"也越早。 在 $\beta = 1.0$ 时，margin 超过 4 的样本对几乎不剩任何梯度。 而在 $\beta = 0.1$ 时曲线平缓得多，模型会持续从每一对里都收一点梯度——更慢，但更稳。

$\beta$ 决定模型能离初始状态多远​

这张图从右往左读：在 $\beta = 0.1$ 时，几乎全部概率质量都塌到了 reward 最高的 $y_5$ 上。 这就是 mode collapse——分数好看了，多样性却荡然无存。 而在 $\beta = 10$ 时，柱子几乎贴着虚线，等于什么都没学到。 $\beta$ 不是那种"调到 loss 最低"的超参数，它是一个在服从偏好与保住自我之间选择交易点的旋钮。

自己拖动一下参数，看看 loss 和梯度的形状会怎么变：

5. 准备环境（Environment）​

打开 Colab，选择 Runtime → Change runtime type → T4 GPU（免费额度够用）。

torch_dtype=torch.float16      # 不是 bfloat16
attn_implementation="sdpa"     # 不是 flash_attention_2
fp16=True                      # 在 DPOConfig 里（不是 bf16=True）

cap = torch.cuda.get_device_capability(0)
print("compute capability:", cap)                    # T4 = (7, 5)
print("native bf16:", cap[0] >= 8)                   # T4 -> False
print("torch says   :", torch.cuda.is_bf16_supported())  # T4 -> True（把 emulation 也算上了！）

一个完全不额外占显存的 reference model​

DPO 需要同时用到 $\pi_\theta$ 和 $\pi_{\text{ref}}$，听上去像是要加载两个模型。 但我们是在第 2 章的 LoRA adapter 基础上继续做的，因此两者共享同一份底座权重。

from peft import PeftModel

base = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B",
    torch_dtype=torch.float16,
    attn_implementation="sdpa",
).cuda()

policy = PeftModel.from_pretrained(base, "kobkrit/qwen3-0.6b-th-sft-lora", is_trainable=True)

policy 就是 base + adapter，而 $\pi_{\text{ref}}$ 就是同一个 base，只不过把 adapter 关掉。 直接用 context manager policy.disable_adapter() 就行，不需要额外加载任何东西。

6. 准备数据（Data）​

DPO 的数据只需要 3 列：prompt、chosen、rejected。

数据集 1 —— iapp/dpo_thai_tutorial（100 对，Apache-2.0） 这是我为这个系列亲手做的数据集，以 Apache-2.0 发布，欢迎拿去继续用。 它是人工挑选的泰语偏好对，重点关注礼貌程度和语言的自然度。

数据集 2 —— 自己造大约 400 对，源自 airesearch/wangchanx-seed-free-synthetic-instruct-thai-120k。 造法非常直白：

• chosen = 数据集自带的泰语参考答案
• rejected = 基座模型自己用 greedy decoding 生成的回答

def build_rejected(prompt):
    with torch.no_grad(), policy.disable_adapter():
        out = policy.generate(**tok(prompt, return_tensors="pt").to("cuda"),
                              max_new_tokens=192, do_sample=False)
    return tok.decode(out[0], skip_special_tokens=True)[len(prompt):]

合起来大约 500 对，留出 15% 作为 held-out 用于评测，训练期间绝不碰。

7. 核心代码（Main code）​

这一节的重点不是怎么调库，而是亲手把 DPO loss 写出来， 然后证明它和真家伙一模一样。如果第 3 节的推导还没让你完全信服，这段代码会让你信。

7.1 手写 25 行​

import torch, torch.nn.functional as F

def seq_logp(model, input_ids, attention_mask, labels):
    """'仅回答部分'的 log-prob 之和（prompt 的 token 已被 mask 成 -100）"""
    logits = model(input_ids=input_ids, attention_mask=attention_mask).logits
    logits = logits[:, :-1, :]                   # 位置 t 预测的是第 t+1 个 token
    target = labels[:, 1:]                       # 所以目标要往后移一位
    mask = target.ne(-100)                       # 只统计回答部分的 token
    target = target.masked_fill(~mask, 0)        # 避免 gather 在 -100 处出错
    logp = torch.log_softmax(logits.float(), dim=-1)
    tokp = logp.gather(-1, target.unsqueeze(-1)).squeeze(-1)
    return (tokp * mask).sum(-1)                 # [B] —— 是求和，不是求平均

def dpo_loss(policy, batch, beta=0.1):
    pi_w = seq_logp(policy, batch["chosen_ids"],   batch["chosen_mask"],   batch["chosen_labels"])
    pi_l = seq_logp(policy, batch["rejected_ids"], batch["rejected_mask"], batch["rejected_labels"])

    with torch.no_grad(), policy.disable_adapter():        # reference: 关掉 adapter + 不要梯度
        ref_w = seq_logp(policy, batch["chosen_ids"],   batch["chosen_mask"],   batch["chosen_labels"])
        ref_l = seq_logp(policy, batch["rejected_ids"], batch["rejected_mask"], batch["rejected_labels"])

    delta = (pi_w - ref_w) - (pi_l - ref_l)                # 第 4 节里的 Δ
    loss = -F.logsigmoid(beta * delta).mean()              # 就是公式 3.4 本身

    r_w = beta * (pi_w - ref_w).detach()                   # chosen 的隐式奖励
    r_l = beta * (pi_l - ref_l).detach()                   # rejected 的隐式奖励
    return loss, r_w, r_l

整个 DPO 就全在这里了，没有任何其他藏起来的东西。 delta 那一行是公式 3.4 一对一翻译成的代码，而 -F.logsigmoid(beta * delta) 就是完整的 loss。

7.2 证明它和 TRL 一致​

from trl import DPOTrainer, DPOConfig

cfg = DPOConfig(
    output_dir="dpo-out",
    beta=0.1,
    loss_type="sigmoid",              # 必须与我们手写的公式一致
    label_smoothing=0.0,              # 一旦不为零，公式就不再是 3.4 了
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,    # effective batch = 16
    num_train_epochs=2,
    learning_rate=5e-6,               # 远低于 SFT —— 见下方警告
    lr_scheduler_type="cosine",
    warmup_ratio=0.1,
    max_length=768,
    max_prompt_length=256,
    fp16=True,                        # T4 没有 bf16
    logging_steps=5,
)

trainer = DPOTrainer(model=policy, args=cfg, train_dataset=train_ds, processing_class=tok)

# 关键：刚创建的 LoRA 中 lora_B = 0，此时 policy 与 reference 完全相同，
# 差值为零，两种实现都会返回 ln 2 —— 即使公式写错了也一样。
# 必须先扰动权重，这个 assert 才是真正的检验。
with torch.no_grad():
    for name, p in policy.named_parameters():
        if "lora_B" in name:
            p.add_(torch.randn_like(p) * 0.01)

loss_manual, _, _ = dpo_loss(policy, batch, beta=0.1)
loss_trl = trainer.compute_loss(policy, trl_batch)

assert torch.allclose(loss_manual, loss_trl, atol=1e-4)
print("一致:", loss_manual.item(), loss_trl.item())