第 7 章 微调:指令微调
第 7 章 微调:指令微调
本章来源:本文整理自 LLMs-from-scratch 仓库的 ch07/01_main-chapter-code/ch07.ipynb,原书为 Sebastian Raschka《Build a Large Language Model (From Scratch)》。
这章要解决什么问题
一句话:让模型学会"听话"。
前面几章,我们造出了一个会写文章的 GPT——但它只会接龙。你问它"把这句话改成被动语态",它不会去改,而是顺着你的话往下续写,像复读机一样把你的指令抄一遍。这就像你雇了个文笔极好、但完全不懂"指令"是什么的写手:你说"写首诗",他回你"写首诗"。
这一章要做的,就是给这个模型上一次上岗培训:让它看到"指令 → 正确回应"的范例,学会"看到指令就照做"。这一步做完,它才从"文本生成器"变成"助手",也就是我们熟悉的 ChatGPT 那种形态。
具体我们会走完一条完整流水线:
- 认识指令微调,尤其是有监督指令微调(SFT);
- 准备一份"指令-回应"数据集,并把它格式化成 Alpaca 风格;
- 写一个
InstructionDataset类,把数据预分词; - 写自定义的
collate_fn,把批次对齐、并用掩码忽略填充; - 加载预训练(355M 参数)的 GPT;
- 用之前章节的
train_model_simple微调它; - 提取、保存模型对测试集的回应;
- 请另一个更大的模型(Llama 3)来给我们的回答打分。
用大白话讲原理
微调分两种,这一章讲的是"教它听话"那种
回顾第 1 章那张地图,模型的一生分两步:先预训练(读完整个图书馆),再微调(上岗前专项培训)。微调又有两种常见走法:
- 分类微调(第 6 章):把它改造成一个"判定是不是垃圾短信"的分类器——本质上是换了个任务。
- 指令微调(本章):不改任务,还是让它生成文本,但训练它"看到指令就给出该给的答案"——本质上是换了种对话方式。
一句话区分:分类微调是把模型改行;指令微调是教模型学会"察言观色、按吩咐办事"。
为什么"接龙高手"不等于"好助手"?
这里有个关键洞察。预训练的目标是下一个词预测:给一段文字,猜下一个词。模型为了猜得准,学会了语法、常识、逻辑——但它学到的只是"文字接下来通常是什么",而不是"面对这个请求,我该做什么"。
举个例子:
预训练模型看到的输入:把这句话改成被动语态。The chef cooks the meal. 预训练模型的输出:把这句话改成被动语态。The chef cooks the meal. ...(继续接龙)
它把指令当成"待续写的文本"照抄了。要纠正这一点,我们得用大量"指令 → 正确回应"的范例"喂"给它,让它在这些例子里发现规律:"哦,看到 ### Instruction: 后面那一段,我得给出对应的答案,而不是抄一遍。"
这就是指令微调(instruction finetuning),也因为每个范例都明确给了输入和输出,又叫有监督指令微调(supervised instruction finetuning,SFT)——"有监督"是因为答案是人给好的,模型照着学。
引导式反问:为什么普通预训练数据(网上的文章)不够,非得要"输入-输出对"?因为普通文本里没有"这是指令、那是正确回应"的标注;模型无从知道哪段是"问题"、哪段是"该给的答案"。指令数据集干的,就是把这种配对关系显式地告诉模型。
三个名词先认个脸
- 指令格式(prompt template):把"指令 + 输入 + 回应"拼成一段固定模板的文本,让模型有迹可循。本章用 Alpaca 风格。
- collate 函数(collate function):数据加载器把一批样本"打包"成一个张量时的加工函数。这里我们自己写一个,好控制填充和掩码。
- 掩码损失(masked loss):计算损失时,把"填充用的占位符"和"不该算分的部分"屏蔽掉,让模型只从真正有意义的内容里学习。
下面我们就一个一个把它们落到代码上。
7.1 先看家底:本章要用到的包
老规矩,先把用到的库装上(numpy、matplotlib、tiktoken、torch、tqdm、tensorflow),并检查一下版本方便复现。这些包前面章节都用过,不用额外认识新面孔。
7.2 准备指令数据集:先看看"教材"长什么样
微调得有教材。本章直接用作者为这一章准备好的一份指令数据集(约 1100 条),每条都是一个"指令-输入-输出"的小字典。
先把数据下载并读进来(约 1100 条,每条都是一个包含 instruction、input、output 的字典)。读进来后,data 就是一个列表,每一项都是这种结构的字典,随便抽两条感受一下它的长相。
注意:
'input'字段可以为空——有些任务是"纯指令"(比如"把这句话改成被动语态"外其实不需要额外输入),这时候只有instruction和output就够了。
那怎么把这些条目拼成模型的输入呢?办法不止一种。原书对比了两种格式:训练 Alpaca 用的格式,和训练 Phi-3 用的格式。本章采用 Alpaca 风格——它是指令微调最早的提示词模板,用 ### Instruction:、### Input:、### Response: 三段来分隔。
具体到代码,就是写一个小助手函数 format_input:它先用一句 "Below is an instruction that describes a task..." 开场,接着拼上 ### Instruction: 段;只有 input 非空时才追加 ### Input: 段(纯指令任务就跳过),最后返回拼好的文本。抓一条带 input 的样本(比如 data[50]),拼出来就是"开场语 + ### Instruction: + ### Input:",末尾再补上 ### Response: 和标准答案,构成一条完整的训练样本;不带 input 的样本(比如 data[999])则少掉 ### Input: 那一段。
最后,按惯例切分数据集:85% 训练、10% 测试、剩下 5% 做验证,分别存进 train_data、test_data、val_data。
引导式反问:为什么要留一份"验证集"和"测试集"?训练集是"练习题",验证集是"随堂测"(用来判断有没有学过头、即过拟合),测试集是"期末考试"(从头到尾不参与训练,用来给最终表现打分)。数据只有一份、既练又考,分数就不可信了。
7.3 把数据组织成训练批次:本章最"绕"但最值钱的一段
训练时我们希望一次喂给模型一批样本(batch),这样更快。但一批样本长短不一,得先对齐(填充到相同长度)。这里我们分几步做,比第 6 章更精细。
第一步:把数据集包装成 PyTorch 能吃的 Dataset。
它和第 6 章的 SpamDataset 思路一样,区别在于:这里在构造时就把所有样本预先分词好,存进 encoded_texts。
import torch
from torch.utils.data import Dataset
class InstructionDataset(Dataset):
def __init__(self, data, tokenizer):
self.data = data
# 预先对所有文本分词,避免训练时反复编码
self.encoded_texts = []
for entry in data:
instruction_plus_input = format_input(entry)
response_text = f"\n\n### Response:\n{entry['output']}"
full_text = instruction_plus_input + response_text
self.encoded_texts.append(
tokenizer.encode(full_text)
)
def __getitem__(self, index):
return self.encoded_texts[index]
def __len__(self):
return len(self.data)注意这里的 full_text 是"指令部分 + 回应部分"拼起来的完整文本。模型训练时看到的就是这一整段,学会"顺着前面的指令,把后面的回应说出来"。
第二步:确定填充用的 token。
和第 6 章一样,我们用一个"文本结束"token <|endoftext|> 来填充。用 tiktoken 编码一下就能查到它在 GPT-2 词表里的 ID——正是 50256。
第三步:写自定义的 collate 函数。
第 6 章是把所有样本填到同一个长度;本章更精巧——每个批次只填到这个批次里最长样本的长度,不同的批次长度可以不同。这样能少填一堆没用的填充 token。
先写个只处理输入的草稿版 custom_collate_draft_1:找出本批最长长度(多留一个填充位),把每条样本追加一个填充 token 后补齐到该长度,再返回对齐后的输入张量。拿几条长短不一的样例试一下,就能看到短的都被填长了。
第四步:把"目标值"也加上。
光有输入不够,训练还得有答案。和第 5 章预训练一样,目标是输入向右移一位——这样模型学的是"看着当前 token,预测下一个 token"。于是在草稿版基础上再写一版 custom_collate_draft_2:输入取 padded[:-1](去掉最后一个 token)、目标取 padded[1:](去掉第一个 token),两者错开一位对齐。
引导式反问:输入
padded[:-1]、目标padded[1:],为什么一个去掉尾巴、一个去掉脑袋?把两者错开一位对齐,第 个输入对应的目标就正好是第 个 token——"预测下一个词"就这么被编码进了数据的排布里。
第五步:用掩码忽略填充。
这是本章最核心的一个技巧。填充用的那些 <|endoftext|> token 本身没有语义,不该让模型为它们算损失。怎么做?把它们替换成一个特殊值 ignore_index=-100,交叉熵损失函数看到 -100 就自动跳过。
def custom_collate_fn(
batch,
pad_token_id=50256,
ignore_index=-100,
allowed_max_length=None,
device="cpu"
):
# 找本批最长长度
batch_max_length = max(len(item)+1 for item in batch)
# 填充并准备输入与目标
inputs_lst, targets_lst = [], []
for item in batch:
new_item = item.copy()
# 追加一个 <|endoftext|> token
new_item += [pad_token_id]
# 填充到 batch_max_length
padded = (
new_item + [pad_token_id] *
(batch_max_length - len(new_item))
)
inputs = torch.tensor(padded[:-1]) # 输入:去掉最后一个 token
targets = torch.tensor(padded[1:]) # 目标:右移一位
# 新增:把目标里第一个之后的填充 token 都换成 ignore_index
mask = targets == pad_token_id
indices = torch.nonzero(mask).squeeze()
if indices.numel() > 1:
targets[indices[1:]] = ignore_index
# 新增:可选地截断到最大序列长度
if allowed_max_length is not None:
inputs = inputs[:allowed_max_length]
targets = targets[:allowed_max_length]
inputs_lst.append(inputs)
targets_lst.append(targets)
# 列表转张量并搬到目标设备
inputs_tensor = torch.stack(inputs_lst).to(device)
targets_tensor = torch.stack(targets_lst).to(device)
return inputs_tensor, targets_tensor小心这里的一个细节:代码保留的是第一个填充 token(
indices[1:]只掩掉第一个之后的),而不是全掩掉。为什么?因为第一个<|endoftext|>紧跟在回应末尾,它其实在告诉模型"回应到这儿就结束了"——这是个有意义的信号,得留着。只有后面那些纯粹为了凑长度的填充才该被忽略。
验证一下 -100 到底管不管用。 拿一个有两个类别(0 和 1)的小分类任务就能说清。先算两个样本的交叉熵损失,记作 loss_1;再加进第三个样本,损失自然变成一个不同的值 loss_2。现在把第三个样本的标签换成 -100 再算一次,得到 loss_3——结果 loss_1 == loss_3 为真,也就是说,标签为 -100 的那个样本被损失函数彻底忽略了,算出来的损失和没有它时一模一样。这正是 PyTorch cross_entropy(..., ignore_index=-100) 的默认行为。
用大白话总结这段:交叉熵损失本质上是对每个样本的"错误程度"求平均;遇到 -100 就当作"这个样本不存在",从平均里剔除。于是填充 token 就不会污染训练信号。
用公式说:普通交叉熵损失是
而加入掩码后,只有"有效"位置才进平均:
其中 是标签不为 -100 的位置数量。
一个值得做的进阶练习:实践中,人们通常还会把指令部分对应的目标也一起掩掉,只对"回应部分"算损失(因为我们要学的是"如何回答",不是"如何复述指令")。原书把这留作读者练习。
7.4 为指令数据集创建数据加载器
有了 InstructionDataset 和 custom_collate_fn,就可以组装数据加载器了。先确定设备:优先 CUDA,其次 Apple 芯片的 MPS(需要 PyTorch 2.9 或更新版本),两者都没有就退回 CPU。
这里有个效率上的小讲究:我们在 custom_collate_fn 里就直接把数据搬到目标设备(比如 GPU),而不是等进了训练主循环再搬。因为 collate 是数据加载器在后台进程里跑的,让它顺手把搬运做了,训练循环就轻快了。为此用 functools.partial 预先固定 device 和最大长度参数(allowed_max_length=1024),生成一个定制版 collate 函数。
然后照常实例化训练、验证、测试三个数据加载器:batch_size 用 8,num_workers 用 0,collate_fn 换成上面定制好的那个,训练集打乱(shuffle=True、drop_last=True)、验证/测试集不打乱。
跑起来能看到:每个批次的批量大小都是 8,但序列长度各不相同——这正是"按本批最长对齐"的效果;输入里确实有 50256(<|endoftext|>)填充,目标里也有 -100 占位符。
7.5 加载预训练模型:为什么这次要换个"大号"的
加载 GPT 的代码和第 5 章 5.5 节、第 6 章 6.4 节一样。但这次有个重要变化:不加载 1.24 亿参数的小模型,而是加载 3.55 亿参数的 medium 版本。
为什么? 因为 124M 的模型太小了,指令微调后效果还是差得明显、谈不上"像样"。参数不够,学不进"听指令"这种复杂行为。这是个很实用的经验:任务越"聪明",越吃模型容量。
具体做法照旧:复用 GPTModel 和 load_weights_into_gpt,用 download_and_load_gpt2 把权重拉下来;只要把 CHOOSE_MODEL 设成 "gpt2-medium (355M)",并在 BASE_CONFIG 里填上 medium 的 emb_dim=1024、n_layers=24、n_heads=16 即可。
微调之前,先看看这个"没上过课"的模型在验证集任务上表现如何。把 val_data[0] 用 format_input 拼成 Alpaca 输入,交给 generate 生成一段(最多 35 个新 token,遇到 <|endoftext|> 即停,途中用 text_to_token_ids / token_ids_to_text 做文本与 token 的互转)。generate 返回的是"输入 + 生成"拼在一起的完整文本,把开头的指令部分切掉、再去掉 ### Response: 标记,剩下的就是模型单独的回应。
结果印证了开头说的:模型还不会听话。它倒是知道要开一个 "Response" 段落,但内容只是把原始输入和指令又抄了一遍——典型的"接龙式回答"。
7.6 在指令数据上微调
现在正式开训。损失计算和训练函数可以直接复用前面章节的——calc_loss_loader 负责算损失、train_model_simple 负责跑训练循环,一行都不用改,这正是把通用组件抽出来的好处。开训前先用 calc_loss_loader 算一次微调开始前的训练/验证损失做基准(损失越小越好),待会儿好拿来对比微调带来的下降。
提醒:因为这次用的是 355M 的大模型,训练会比前面贵。下面是不同设备跑 2 个 epoch 的耗时参考(在支持的 GPU 上跑,代码不用改):
| 模型 | 设备 | 2 个 epoch 的运行时间 |
|---|---|---|
| gpt2-medium (355M) | CPU (M3 MacBook Air) | 15.78 分钟 |
| gpt2-medium (355M) | GPU (M3 MacBook Air) | 10.77 分钟 |
| gpt2-medium (355M) | GPU (L4) | 1.83 分钟 |
| gpt2-medium (355M) | GPU (A100) | 0.86 分钟 |
| gpt2-small (124M) | CPU (M3 MacBook Air) | 5.74 分钟 |
| gpt2-small (124M) | GPU (M3 MacBook Air) | 3.73 分钟 |
| gpt2-small (124M) | GPU (L4) | 0.69 分钟 |
| gpt2-small (124M) | GPU (A100) | 0.39 分钟 |
作者用的就是 "gpt2-medium (355M)" 跑通了全流程。
开跑:
import time
start_time = time.time()
torch.manual_seed(123)
optimizer = torch.optim.AdamW(model.parameters(), lr=0.00005, weight_decay=0.1)
num_epochs = 2
train_losses, val_losses, tokens_seen = train_model_simple(
model, train_loader, val_loader, optimizer, device,
num_epochs=num_epochs, eval_freq=5, eval_iter=5,
start_context=format_input(val_data[0]), tokenizer=tokenizer
)
end_time = time.time()
execution_time_minutes = (end_time - start_time) / 60
print(f"Training completed in {execution_time_minutes:.2f} minutes.")训练效果不错——训练损失和验证损失都在往下走。而且看每个 epoch 后打印的样例回答,模型已经能把 'The chef cooks the meal every day.' 正确改成被动语态 'The meal is cooked every day by the chef.' 了。用前面章节的 plot_losses 把 train_losses / val_losses 画出来,曲线会更直观。
曲线显示:损失在第一个 epoch 一开始就陡降,说明模型学得很快;到大约 1 个 epoch 时开始出现轻微过拟合(验证损失不再跟着一起降)。
引导式反问:训练损失还在降、验证损失却抬头,这意味着什么?说明模型开始"背题"(记住训练集的具体答案),而不是"学会解题"。这时通常要早停、加正则,或者减少训练轮数——而不是一味加大训练。
7.7 提取并保存回应
训练完了,得把模型对测试集的回答收集下来,供下一节评分。做法很简单:遍历 test_data 里每条样本,按同样的方式生成回应(max_new_tokens=256)、切掉指令部分,把结果写进 entry["model_response"]。先抽前三条看看,眼见为实——第一条和第三条明显答对了;第二条很接近,模型答 "cumulus cloud"(积云),标准答案是 "cumulonimbus"(积雨云)。注意积云确实能发展成能下雷雨的积雨云,所以这算是"接近但不精确"。
评估方式的转变是本章一个重点。第 6 章的评估很简单:算算垃圾/非垃圾分类正确的百分比就行。但指令微调后的模型(比如聊天机器人)没有唯一正确答案,评估要复杂得多,实践中常用这几类办法:
- 简答 / 多选基准:如 MMLU("Measuring Massive Multitask Language Understanding"),考模型的知识储备。
- 人类偏好对比:如 LMSYS chatbot arena,让人在两两对战中投票。
- 自动对话基准:用另一个 LLM 当裁判来打分,如 AlpacaEval。
下一节我们采用类似 AlpacaEval 的思路——用另一个 LLM 给我们的回答打分,但用自己的测试集,而非公开基准。
把全部测试集样本的回答都用上面这套流程写回 test_data 后(用 tqdm 能看到进度),存成 instruction-data-with-response.json(json.dump 时加 indent=4 让文件更易读),抽查一条确认回答已写进字典。最后把模型权重保存成 <模型名>-sft.pth(模型名里的空格和括号去掉),之后用 model.load_state_dict(torch.load(...)) 就能重新加载复用。
7.8 用 Llama 3 自动评估
自己评自己不可靠,我们请个"更聪明的裁判":Meta 的 Llama 3 8B instruct 模型,可以通过 Ollama 在本地跑。(如果你更想用 GPT-4 走 OpenAI API,可参见仓库里的 llm-instruction-eval-openai.ipynb。)
Ollama 是什么? 它是个高效运行 LLM 的应用,本质是 llama.cpp 的包装器——后者用纯 C/C++ 实现推理以榨取效率。注意:Ollama 是用模型生成文本(推理)的工具,不是训练/微调工具。先到 https://ollama.com 装好它(点 Download,装对应系统的 App)。
装完后,一般要么启动 Ollama 应用,要么在单独终端里跑 ollama serve,然后才能从命令行使用。
常见的坑:如果
ollama serve报Error: listen tcp 127.0.0.1:11434: bind: address already in use,说明端口被占了。试试OLLAMA_HOST=127.0.0.1:11435 ollama serve(若还被占,就把数字往上加,直到找到空闲端口)。
在另一个终端里拉起服务后,跑 ollama run llama3 试试 8B 的 Llama 3(约 4.7 GB,首次运行会自动下载)。它会先拉取模型清单和几层权重、校验 sha256 摘要、写入 manifest,最后打印 success。这里的 llama3 指的就是指令微调过的 Llama 3 8B。
内存不够怎么办?
llama3(8B)需要约 16 GB 内存。跑不动就换更小的:把model = "phi-3"(3.8B,约 8 GB 内存)。机器够强的话,也可以换成 700 亿的llama3:70b。
下载完成后会出现一个聊天式提示符。随便问一句比如 "What do llamas eat?",它会像对话助手一样条理清楚地作答(例如解释羊驼是反刍动物、有一个四腔胃,主要吃草、小麦、燕麦、大麦等高纤维植物)。用 /bye 退出这个会话。
正式用它评估前,先确认 Ollama 在跑:写一个小工具 check_if_running("ollama") 遍历系统进程,看有没有名为 ollama 的进程;没在跑就直接抛错提醒你先启动它。
如果你中途重启了 notebook,也不必重跑前面所有代码——只要重新读入 7.7 存好的 instruction-data-with-response.json,再补上 format_input 这个拼接函数,就能接着往下评。
除了命令行 ollama run,我们还能在 Python 里通过它的 REST API 交互。核心是写一个 query_model(prompt, model="llama3") 函数:它向 http://localhost:11434/api/chat 发一个 POST 请求,请求体带上模型名和消息,并把 temperature、seed、num_ctx 固定下来让回答尽量确定,然后流式读取返回的每一行、拼出完整回答。务必确认 Ollama 仍在运行(前面应打印 Ollama running: True)。
若遇到
HTTPError: 404 Client Error: Not Found for url: http://localhost:11434/api/chat,通常是因为你还没下载llama3模型(用 UI 或终端里ollama run llama3下载即可)。
现在就能用 query_model 来评估了。对每条测试集样本,把"输入、标准答案、模型回答"塞进一段提示词,让裁判按 0(最差)到 100(最好)打分,打印出来看看。先用前 3 条试水。
注意:一个更好的评估提示词
一位读者(Ayoosh Kathuria)建议了一个更长、改进版的提示词:它在 1-5 分(而非 0-100)上评估,并给出评分细则——从"1 分:完全没照做,信息不相关、错误或啰嗦"到"5 分:完全照做,清晰、准确、简洁且高效",要求裁判先写评语(
Evaluation:)、再给总分(Total rating:),并把待评的指令、参考答案和模型回答分别填进模板。评分细则约束让评估更准确、噪音更少。更多上下文见这个 GitHub 讨论。
可以看到,Llama 3 给出了合理的评价:即便回答不完全正确,也会给部分分(比如前面 "cumulus cloud" 那条)。
不过上面那个提示词返回的评价很啰嗦。我们可以改造它,让它只回一个 0 到 100 的整数,这样就能算平均分了。110 条测试集在 M3 MacBook Air 上大约 1 分钟能评完:
def generate_model_scores(json_data, json_key, model="llama3"):
scores = []
for entry in tqdm(json_data, desc="Scoring entries"):
prompt = (
f"Given the input `{format_input(entry)}` "
f"and correct output `{entry['output']}`, "
f"score the model response `{entry[json_key]}`"
f" on a scale from 0 to 100, where 100 is the best score. "
f"Respond with the integer number only."
)
score = query_model(prompt, model)
try:
scores.append(int(score))
except ValueError:
print(f"Could not convert score: {score}")
continue
return scores
scores = generate_model_scores(test_data, "model_response")
print(f"Number of scores: {len(scores)} of {len(test_data)}")
print(f"Average score: {sum(scores)/len(scores):.2f}\n")我们的模型拿到了高于 50 的平均分,这个数字可以当成一个参照点:拿去和其他模型比,或者用来衡量你调整训练设置后有没有变好。
注意:写这篇文章时,Ollama 在不同操作系统上还不是完全确定性的,所以你得到的分数可能和这里略有出入。
作为参照:
- Llama 3 8B base 模型(未指令微调):58.51 分。
- Llama 3 8B instruct 模型(指令微调过):82.65 分。
对比一下就能体会:一个 3.55 亿参数的 GPT-2,指令微调后能拿到 50 分出头,已经相当能打了——而真正的对话助手(8B instruct)还在 80 分段。
7.9 结语
这里基本是全书主线代码的终点。我们走完了 LLM 开发周期的主要步骤:实现架构 → 预训练 → 微调。
指令微调之后,还有个可选步骤叫偏好微调(preference finetuning)——它能把模型进一步对齐到特定用户偏好。感兴趣可以看仓库的 04_preference-tuning-with-dpo 文件夹(用 DPO 实现)。
作者也提到,他写这本书最终是想说明一件事:从零实现 LLM,是理解 LLM 怎么工作的最好方式。 如果你要在真实场景里用更强的模型,可以考虑像 axolotl 或 LitGPT 这样的现成工具。
关键概念
- 指令微调(instruction finetuning):训练模型学会遵循指令。因为每条样本的输入-输出对都是显式给出的,也叫有监督指令微调(SFT, supervised instruction finetuning)。
- Alpaca 风格提示词(Alpaca-style prompt):用
### Instruction:/### Input:/### Response:三段组织样本的模板,指令微调最早使用的格式。 InstructionDataset:构造时对全数据集预分词、把"指令 + 回应"拼成完整文本的Dataset子类。- 自定义 collate 函数(
custom_collate_fn):把一批样本填充到本批最长长度(不同批次可不同长),并生成错开一位的输入与目标;数据直接搬到目标设备。 ignore_index = -100:让交叉熵损失忽略带此标签的位置。用来屏蔽填充 token 造成的损失。- 掩码损失(masked loss):用
-100掩掉填充(以及可选地掩掉指令部分),只让模型从"回应"里学习。注意保留第一个<|endoftext|>,它提示模型"回应到此结束"。 - 模型评估:指令微调没有唯一标准答案,改用 LLM 裁判(Llama 3 via Ollama)按提示词给回答打 0-100 分,再取平均。
- 偏好微调(preference finetuning):指令微调之后的可选步骤,用 DPO 等方法把模型对齐到用户偏好。
动手练习
练习解答见仓库的 ch07/01_main-chapter-code/exercise-solutions.ipynb。本章四个练习:
- 7.1 更换提示词风格:把 Alpaca 格式换成别的模板,看看效果有没有差别。
- 7.2 指令与输入掩码:把指令部分的目标 token 也掩掉(用
-100),只对"回应部分"算损失——需要小幅改动InstructionDataset和custom_collate_fn。这正是 7.3 节末尾提示的那个进阶练习。 - 7.3 在原始 Alpaca 数据集上微调:换用完整的 Alpaca 数据集来跑。
- 7.4 用 LoRA 做参数高效微调:只训练一小部分额外参数,而不是全量微调。
全书回顾
到这里,七章全部完成。你走完了一个完整的 LLM 开发周期:
- 理解 LLM:LLM 是什么、Transformer 架构基础。
- 处理文本:分词、BPE、嵌入、位置编码、数据加载。
- 注意力机制:自注意力、因果注意力、多头注意力。
- 实现 GPT:LayerNorm、GELU、前馈、Transformer 块、完整 GPT 模型、文本生成。
- 预训练:交叉熵损失、困惑度、训练循环、温度与 top-k 解码、加载 OpenAI 权重。
- 分类微调:把 GPT 变成垃圾短信分类器。
- 指令微调:让 GPT 遵循指令,并用更大的 LLM 评估。
正如作者所说:从零实现 LLM,是理解 LLM 怎么工作的最好方式。 现在你不仅读懂了,而且亲手写过了。