第 6 章 微调:文本分类
第 6 章 微调:文本分类
本章来源:本文整理自 LLMs-from-scratch 仓库的 ch06/01_main-chapter-code/ch06.ipynb,原书为 Sebastian Raschka《Build a Large Language Model (From Scratch)》。
这章要解决什么问题
前面五章,我们一直在造一个"文字接龙机"——它读海量文本,学会预测下一个词,能写出还算连贯的句子。
可它有个让人头疼的毛病:不听话。
你问它"这段话算不算垃圾短信?请回答 yes 或 no",它很可能不回答 yes/no,而是顺着你的话继续编故事。这不是 bug,是它的本能——它只学会了"接龙",没学过"按指令办事"。
这一章,我们就要把这样一个"只会接龙的家伙",改造成一个能干脆利落做判断的分类器:给它一条短信,它回你一个标签,"垃圾短信"或"不是垃圾短信"。
具体要亲手做的事:搞一个垃圾短信数据集、把它处理成模型能吃的形状、给预训练好的 GPT 换上一颗"分类脑袋"、算出模型现在有多准、动手微调让它变准,最后拿几条真实短信测一测。
一句话目标:让 GPT 从"写作文"改成"做选择题"。
用大白话讲原理
先分清两种微调:当"通才"还是当"专才"
"微调(finetuning)"这个词你可能常听到,但它在实际项目中主要分两条路:
- 指令微调(instruction finetuning):把模型调成"听得懂指令的通才"。你让它翻译、总结、写代码,它都能干——ChatGPT 走的就是这条路。下一章专门讲。
- 分类微调(classification finetuning):把模型调成"只会一件事的专才"。本章就走这条。它只认识固定几个标签,比如"垃圾短信"和"非垃圾短信",别的啥也不会。
打个比方:指令微调是培养一个"什么都会一点的全科医生";分类微调是培养一个"只会看某种片子、但看得极准的专科医生"。 显然,培养专科医生简单得多——任务越窄,模型越好调。这也是为什么你如果有机器学习背景,会觉得分类微调眼熟:它和训练一个卷积网络识别手写数字,本质上是一回事。
本章做的是二分类(binary classification):只有 2 个类。
我们要造的到底是个啥:给 GPT 换一颗"脑袋"
一个预训练好的 GPT,结构上可以粗略拆成两截:
- 前段(身体):一堆 transformer 块,负责把文字"读懂",转成一个个富含语义的向量。
- 尾段(脑袋):一个输出层,把向量摊成 50,257 维——因为它的任务是从 5 万多个词里挑下一个。
我们要做的是:把那个 5 万维的"接龙脑袋"拆掉,换上一颗只有 2 个输出的"分类脑袋"。 一颗输出代表"垃圾短信"的分数,另一颗代表"不是"的分数。哪边分数高,就判它是哪边。
那"身体"呢?基本不动。因为它早在预训练阶段就把英语的语法、常识学进去了,这些本事对判垃圾短信一样有用——我们只是借用它已经练好的语言功底,省下重新训练的成本。 这就是"微调"里"微"字的含义:只动一点点,不做大手术。
类比:你不是从头培训一个新人,而是把一位资深老编辑叫来,简单交代几句,让他转岗去当垃圾信息审核员。他底子好,转岗很快。
凭什么用"最后一个 token"来做判断?
这里有个关键细节,第一次看会很反直觉:我们往里扔一整条短信,却只盯着最后一个 token 的输出向量来做分类。
为什么?回想第 3 章的因果注意力(causal attention):GPT 里每个 token 只能"回头看"自己和它前面的 token,看不到后面的。这意味着——
- 第 1 个 token:只知道第 1 个词。
- 第 2 个 token:知道前 2 个词。
- ...
- 最后一个 token:知道整句话的所有词。
所以,最后一个 token 的输出向量是唯一"读过全文"的那个。拿它来判断整条短信的性质,最合理。
一句话:在一群只能往前看的人里,站在队尾的那个人见识最广。 我们问的就是他。
顺手复习:交叉熵为什么能当"准确率"的替身
训练时我们会反复算一个数:交叉熵损失(cross-entropy loss)。
为什么不用"准确率"直接优化?因为准确率是个"跳变"的指标——预测对了是 1,错了是 0,中间没有过渡,没法求导。而训练靠的是求导(梯度下降),必须找一个光滑、可导的替代品。交叉熵就是这个人选:预测得越离谱、损失越大;预测得越自信且正确、损失越小。它的形式是:
其中 是模型给第 个样本的"真实类别 "分配的概率。我们最小化交叉熵,等价于在间接地最大化准确率。 这个思路第 5 章已经用过,这里换了个任务再用一遍。
好,原理讲清,下面开始动手。为了让你能亲手跑通,我们选一个小数据集,连笔记本都能几分钟训完。
6.1 先把数据请进来:垃圾短信数据集
机器学习的游戏规则很简单:喂什么料,长什么本事。 所以要教模型认垃圾短信,就得先给它一堆标好答案的短信。我们用 UCI 的经典 SMS Spam Collection 数据集——一堆短信,每条都被人手工标了 "spam"(垃圾)或 "ham"(非垃圾,来自火腿谐音,指正常短信)。
先下载并解压(代码里还贴心地准备了一个备用下载地址,万一主站抽风也能继续)。解压出来的数据是一个制表符分隔的文本文件,用 pandas 一行读进来,顺手看一眼正负样本各有多少。
你会发现问题:"ham" 比 "spam" 多得多。 这在真实世界里太常见了——正常短信永远比垃圾短信多。
这有个隐患:如果 97% 的短信都是 ham,那我干脆闭着眼全猜 ham,也有 97% 的准确率——但这模型毫无用处。这种"一类压倒另一类"的情况叫数据不平衡(class imbalance),会带偏训练。处理办法有好几种(比如给少数类加权、过采样等,可参考 imbalanced-learn 用户指南),但为了教学简单,我们采用最直接的一招:下采样(downsampling)——把多的那类随机砍到和少的那类一样多,每类留 747 条。
接着,模型不认识 "ham"/"spam" 这种文字标签,只认数字,所以把它们统一换成 0 和 1。再按 70% / 10% / 20% 的比例切成三份——训练集用来学、验证集用来中途调参、测试集留到最后做终考,分别存成 train.csv、validation.csv、test.csv。
为什么非要留出测试集? 因为模型会"记住"它训练时见过的数据。如果你用训练数据考它,它会考得很好,但这不能说明它真学会了——就像让学生做背过的原题。只有没见过的题,才试得出真本事。
6.2 把长短不一的短信对齐:SpamDataset 与填充
现在有个麻烦:短信有长有短。 有的十几个字,有的一百多。
而 GPU 干活的习惯是"整批整批"地算——一个 batch 里的样本必须形状一致,像一摞同样大小的卡片。长短不一的短信没法直接叠成一摞。所以必须先"对齐"。有两种对齐方式:
- 把长短信截断到最短那条的长度;
- 把短短信**填充(pad)**到最长那条的长度。
我们选第 2 种——把大家都补到最长。补什么呢?用一个特殊的"填充 token"。如第 2 章所讲,GPT-2 的词表里有一个 <|endoftext|>(id = 50256),它的原始含义是"文本结束",正好拿来做占位符。
下面的 SpamDataset 类就是干这件事的:它先找出训练集里最长的序列,然后把其余序列都用填充 token 补到同样长。它继承自 PyTorch 的 Dataset,实现了 __getitem__(取第 index 条)和 __len__(一共多少条),这样才能交给后面的 DataLoader 来做批量打包。
import torch
from torch.utils.data import Dataset
class SpamDataset(Dataset):
def __init__(self, csv_file, tokenizer, max_length=None, pad_token_id=50256):
self.data = pd.read_csv(csv_file)
# Pre-tokenize texts —— 先把所有短信一次性编码成 token id,省得每次取都重算
self.encoded_texts = [
tokenizer.encode(text) for text in self.data["Text"]
]
if max_length is None:
self.max_length = self._longest_encoded_length()
else:
self.max_length = max_length
# Truncate sequences if they are longer than max_length
# 超过上限的序列,直接砍掉尾巴
self.encoded_texts = [
encoded_text[:self.max_length]
for encoded_text in self.encoded_texts
]
# Pad sequences to the longest sequence
# 不够长的序列,在末尾补填充 token,直到凑齐 max_length
self.encoded_texts = [
encoded_text + [pad_token_id] * (self.max_length - len(encoded_text))
for encoded_text in self.encoded_texts
]
def __getitem__(self, index):
encoded = self.encoded_texts[index]
label = self.data.iloc[index]["Label"]
return (
torch.tensor(encoded, dtype=torch.long),
torch.tensor(label, dtype=torch.long)
)
def __len__(self):
return len(self.data)
def _longest_encoded_length(self):
max_length = 0
for encoded_text in self.encoded_texts:
encoded_length = len(encoded_text)
if encoded_length > max_length:
max_length = encoded_length
return max_length
# Note: A more pythonic version to implement this method
# is the following, which is also used in the next chapter:
# return max(len(encoded_text) for encoded_text in self.encoded_texts)注意一个细节:填充是"在末尾补",而分类又只看"最后一个 token"。这就意味着,在很长的一摞里,被补出来的那些位置其实是填充符而不是真正的内容。这里我们遵循原书的做法,不去额外屏蔽这些填充位——因果掩码本身保证每个位置只看自己及之前的内容,而模型在微调中会自己学会忽略这些无意义的尾巴。核心思路不变:先对齐长度,才能批量计算。
先建训练集,看看这批数据的"标准长度"是多少——也就是最长的那条训练序列有多长。验证集和测试集也补到同一个长度(也就是最长训练序列的长度)。注意这一步会顺手把"比最长训练样本还长"的验证/测试样本截断——这个行为纯粹是可选的,你也可以不对它们设长度上限,照样能跑。
接着把它们包装成 DataLoader,这里 batch_size=8 就是"每 8 条打成一摞"。训练集要打乱顺序,避免模型记住"顺序"这种无关信息;并丢掉最后凑不满 8 条的那一批,保证每批形状一致。做完再做个"验收",就能确认每批确实是 8 条、每条确实是那么长的 token,三个集合各有多少批也就一清二楚了。
6.3 别从零开始:加载预训练权重
数据齐了,现在轮到模型。关键一步:我们不用随机初始化的空壳,而是加载上一章下载好的 GPT-2 预训练权重。 前面说了,我们要借它已经练好的语言功底。
先写下模型配置。这里可以从小、中、大、特大 4 个尺寸里挑,教学时用最小的 124M 就够;配置里还会顺手检查一件事——数据的最长序列不能超过模型的上下文长度上限。
配置就绪后,下载 GPT-2 权重、套到模型上(download_and_load_gpt2 和 load_weights_into_gpt 都沿用前几章的实现),再做个体检——让它续写一句,看它是否还是那个"文字通顺"的模型。
然后我们试着"用嘴使唤"它——直接在提示词里让它判断这条短信是不是垃圾短信。结果你可能猜到了:它不好好回答 yes/no,而是顺着继续编。 这完全在意料之中——它只被预训练过(只会接龙),从没被"指令微调"过(不会听话)。这也正好告诉我们:光靠提示词逼不出来,得动真格地改造它。下面就开始改造。
6.4 换脑袋:给模型添加分类头
先看一眼模型的全貌,找找我们要动的那一层。你会看到,它就是第 4 章搭出来的那套结构:一叠 trf_blocks(transformer 块),加一个 final_norm(收尾的归一化),最后是 out_head——那个负责把向量映射到 50,257 维词表的输出层。
我们的目标就是把 out_head 换掉。但在换之前,先做一件事:冻结(freeze)整个模型,也就是把所有参数的"可训练开关" requires_grad 一律设成 False。
冻结是什么、为什么要冻结? 模型里每个参数都有一个开关
requires_grad。设成False,训练时梯度就不会更新它——相当于"锁死,别动我"。我们先把全身锁死,是为了接下来手动挑选哪些部位允许学习,避免一不小心把整个 1.24 亿参数全改一遍(既慢,又容易把预训练学到的东西练坏,俗称"灾难性遗忘")。
现在换成二分类脑袋。原来是 50,257 个输出,现在只要 2 个("spam" 和 "not spam")。做法是把 model.out_head 整个替换成一个新的 torch.nn.Linear:输入维度取 BASE_CONFIG["emb_dim"](124M 模型里等于 768),输出维度就是类别数 2——这样换模型也不用改代码。新建的这层默认就是可训练的,无需额外解冻。
严格来说,只调这一层输出就够了。但作者在 Finetuning Large Language Models 里的实验发现:多放开几层,效果会明显更好。 所以除了输出层,我们再把"最后一个 transformer 块"和"紧挨输出层的 final_norm"的参数重新设为可训练(requires_grad = True):
为什么是"最后几层",不是全部? 可以这样理解:越靠前的层学到的是越通用的东西(词义、语法),这部分各任务通用,没必要动;越靠后的层越贴近"当前任务"的专属特征,让它参与微调,模型才有针对分类任务做调整的空间。往外再放开更多层(甚至全量微调)往往还能更好,但代价是更慢、更吃显存。"只调输出层 vs 多调几个尾部层 vs 全量微调",就是在效果和成本之间找平衡。 想看更省参数的玩法,可以翻附录 E 里的 LoRA。
改完之后,模型照样能像以前那样接收文本。随便喂一句试试,会发现输出维度从 50,257 变成了 2:我们喂了 4 个 token,模型就吐出 4 个 2 维向量——每个输入 token 对应一个输出向量。
还记得开头讲的吗?因为因果掩码,只有最后一个 token 见过全句。所以我们只关心最后一个位置的输出,也就是 outputs[:, -1, :]。
6.5 怎么衡量好与坏:准确率与损失
在讲损失之前,先看输出怎么变成"结论"。
模型吐出来的是两个原始分数(logits),比如"spam 得分 2.1、not spam 得分 -0.7"。要变成人话结论,先过 softmax 压成概率,再用 argmax 挑概率最大的那个位置。其实如第 5 章所说,这里 softmax 是可有可无的——因为分数最大的,概率一定也是最大的,直接对 logits 取 argmax 的结果完全一样。
把这套"取最后一个 token → 取最大 → 对比答案"的逻辑套用到整个数据集,就能算出分类准确率(classification accuracy),也就是"猜对的比例"。下面这个 calc_accuracy_loader 负责这件事:
def calc_accuracy_loader(data_loader, model, device, num_batches=None):
model.eval()
correct_predictions, num_examples = 0, 0
if num_batches is None:
num_batches = len(data_loader)
else:
num_batches = min(num_batches, len(data_loader))
for i, (input_batch, target_batch) in enumerate(data_loader):
if i < num_batches:
input_batch, target_batch = input_batch.to(device), target_batch.to(device)
with torch.no_grad():
logits = model(input_batch)[:, -1, :] # Logits of last output token
predicted_labels = torch.argmax(logits, dim=-1)
num_examples += predicted_labels.shape[0]
correct_predictions += (predicted_labels == target_batch).sum().item()
else:
break
return correct_predictions / num_examples先挑好设备(有 GPU 用 GPU,Mac 就用 mps,都没有就退回 CPU),然后在训练、验证、测试三个集合上各抽查几批,算一下准确率。你会看到微调之前的准确率很难看——因为新换的"分类脑袋"还是随机初始化的,压根没学过。别急,微调马上就来。
在动手训练前,得先确定要优化的目标。前面讲过:准确率不能求导,所以我们改用交叉熵损失作为它的替身。单批次的损失计算很简洁:把一批样本送进模型,只取最后一个 token 的输出(model(input_batch)[:, -1, :])去算交叉熵,而不是对所有 token 求平均;再配一个和第 5 章完全一样的 calc_loss_loader,把一批批的损失平均起来,就能估出整个数据集上的损失。
先记下训练前的训练、验证、测试损失,作为后面看进步幅度的基准。下一节,我们就让模型动起来,把这些损失压下去。
6.6 开练:在有监督数据上微调
训练函数 train_classifier_simple 和第 5 章预训练用的 train_model_simple 几乎是同一个模子刻出来的,只有两处不同:
- 它记录已见样本数(
examples_seen),而不是已见 token 数; - 每个 epoch 结束后算准确率,而不是打印一段生成的文本。
# Overall the same as `train_model_simple` in chapter 5
def train_classifier_simple(model, train_loader, val_loader, optimizer, device, num_epochs,
eval_freq, eval_iter):
# Initialize lists to track losses and examples seen
train_losses, val_losses, train_accs, val_accs = [], [], [], []
examples_seen, global_step = 0, -1
# Main training loop
for epoch in range(num_epochs):
model.train() # Set model to training mode
for input_batch, target_batch in train_loader:
optimizer.zero_grad() # Reset loss gradients from previous batch iteration
loss = calc_loss_batch(input_batch, target_batch, model, device)
loss.backward() # Calculate loss gradients
optimizer.step() # Update model weights using loss gradients
examples_seen += input_batch.shape[0] # New: track examples instead of tokens
global_step += 1
# Optional evaluation step
if global_step % eval_freq == 0:
train_loss, val_loss = evaluate_model(
model, train_loader, val_loader, device, eval_iter)
train_losses.append(train_loss)
val_losses.append(val_loss)
print(f"Ep {epoch+1} (Step {global_step:06d}): "
f"Train loss {train_loss:.3f}, Val loss {val_loss:.3f}")
# Calculate accuracy after each epoch
train_accuracy = calc_accuracy_loader(train_loader, model, device, num_batches=eval_iter)
val_accuracy = calc_accuracy_loader(val_loader, model, device, num_batches=eval_iter)
print(f"Training accuracy: {train_accuracy*100:.2f}% | ", end="")
print(f"Validation accuracy: {val_accuracy*100:.2f}%")
train_accs.append(train_accuracy)
val_accs.append(val_accuracy)
return train_losses, val_losses, train_accs, val_accs, examples_seen它内部还会调用 evaluate_model(和第 5 章一模一样,作用是"临时切到评测模式算一下损失,再切回训练模式")以及刚写好的 calc_accuracy_loader。
开跑!用 AdamW 优化器,学习率 5e-5,跑 5 个 epoch。作者实测:在 M3 MacBook Air 上大约 5 分钟,在 V100/A100 这种 GPU 上不到半分钟——小数据集的福利。
训练结束后,用第 5 章的老朋友 plot_values 把训练损失和验证损失画成曲线,就能读出关键信息:曲线一路向下,说明模型确实在学;更让人放心的是,训练损失和验证损失贴得很近——这意味着它没有过拟合(overfitting),没有光顾着背训练集。同样地,把准确率也画出来,会看到模型在第 4、5 个 epoch 后达到了相当不错的水平。
不过要留个心眼:训练时我们设了 eval_iter=5,意味着上面的准确率只是在少数几批上估的,不是全集。想在完整数据上看到真实成绩,得把 num_batches 留空、在全集上重算一遍准确率。结果:训练集和验证集的表现几乎一样,但测试集略低一点——说明模型对训练数据有一点点过拟合,还对用来调超参(比如学习率)的验证集也有一点点过拟合。这是正常现象,不必惊慌。如果想把这点差距再压小,可以试着调大 dropout 率(drop_rate)或加大优化器的 weight_decay。
6.7 上岗:把模型当分类器用
最后,让这个微调好的模型真正干活。
下面这个 classify_review 函数,做的事其实和 SpamDataset 差不多——编码、按上下文长度截断、填充对齐——只不过这次是处理单条文本。它返回模型预测的类别:
def classify_review(text, model, tokenizer, device, max_length=None, pad_token_id=50256):
model.eval()
# Prepare inputs to the model
input_ids = tokenizer.encode(text)
supported_context_length = model.pos_emb.weight.shape[0]
# Note: In the book, this was originally written as pos_emb.weight.shape[1] by mistake
# It didn't break the code but would have caused unnecessary truncation (to 768 instead of 1024)
# Truncate sequences if they too long
input_ids = input_ids[:min(max_length, supported_context_length)]
assert max_length is not None, (
"max_length must be specified. If you want to use the full model context, "
"pass max_length=model.pos_emb.weight.shape[0]."
)
assert max_length <= supported_context_length, (
f"max_length ({max_length}) exceeds model's supported context length ({supported_context_length})."
)
# Alternatively, a more robust version is the following one, which handles the max_length=None case better
# max_len = min(max_length,supported_context_length) if max_length else supported_context_length
# input_ids = input_ids[:max_len]
# Pad sequences to the longest sequence
input_ids += [pad_token_id] * (max_length - len(input_ids))
input_tensor = torch.tensor(input_ids, device=device).unsqueeze(0) # add batch dimension
# Model inference
with torch.no_grad():
logits = model(input_tensor)[:, -1, :] # Logits of the last output token
predicted_label = torch.argmax(logits, dim=-1).item()
# Return the classified result
return "spam" if predicted_label == 1 else "not spam"纸上谈兵不如动手一试。喂一条一眼假的垃圾短信、再喂一条再正常不过的,两条都判对了——这一章的活儿,成了。
最后,训练不易,把成果存下来(用 torch.save 保存 model.state_dict()),免得下次还得重训;以后在新会话里,用 torch.load 把权重读回来、model.load_state_dict() 装回去,就能接着用。
关键概念
- 分类微调(classification finetuning):把预训练模型改造成"只输出固定几个类标签"的专才,和指令微调(多任务通才)相对。
- 数据不平衡(class imbalance):某一类样本远多于另一类,会让模型偷懒;本章用下采样把它拉平。
- 填充(padding):把长短不一的序列补到同一长度,才能打成 batch;这里用
<|endoftext|>(id 50256)当填充符。 - 冻结(freezing):把参数开关
requires_grad设为False,训练时不再更新——先冻结全身,再有选择地解冻。 - 分类头(classification head):把输出层
out_head换成num_classes维(这里是 2 维),新层默认可训练。 - 只微调部分层 vs 全量微调:只调输出层够用,但把最后一个 transformer 块 +
final_norm一起放开效果更好;全量微调更强但更贵。 - 最后一个 token:由于因果注意力,只有它能"看到"全句信息,所以分类时只看它的输出。
- 分类准确率(accuracy):预测正确的比例;因为它不可导,训练时改用可导的交叉熵损失作为替身。
- 过拟合(overfitting):模型"背题"而非"学会",表现为训练/验证好、测试略差;可用调大 dropout、加大 weight decay 缓解。
动手练习
练习解答见仓库的 ch06/01_main-chapter-code/exercise-solutions.ipynb。
想更进一步,也可以看看原仓库的配套材料:
- gpt_class_finetune.py:把本章的分类微调做成一个自包含脚本。
- 附录 E:用**低秩适配(LoRA)**做参数高效微调的入门,比"全量微调"省得多。
如果只想先自测一下理解,试着回答这两个问题:
- "为什么分类时只看最后一个 token,而不看第一个或取平均?"
- "为什么不能直接拿准确率做损失来训练,非要绕道交叉熵?"
能把这两句讲明白,分类微调这块就算真的吃透了。