知识蒸馏实战指南：原理、PyTorch实现与关键参数调优

Meta 时隔 16 个月重新回到开源模型发布节奏，扎克伯格又公开为蒸馏技术站台，这个消息让很多人重新开始讨论一个老话题：大模型到底能不能越训越小，同时还能保留足够能力。模型蒸馏并不是新鲜概念，它在图像分类、语音识别和推荐系统里已经存在多年。它之所以被再次推到前台，是因为当前大模型的训练和推理成本太高，而蒸馏正好提供了一条用较小模型逼近较大模型能力的路径。

这篇文章会从知识蒸馏的原理入手，带你理解 Teacher 模型和 Student 模型之间到底在传递什么信息；然后用一个基于 PyTorch 的最小实验把整个流程跑通；再展开温度、软标签权重、数据分布这些关键参数对蒸馏效果的影响；最后补上常见坑、排查路径和生产落地建议。学完之后，你至少能独立完成一次“用大模型教小模型”的实验，并且知道遇到蒸馏效果不理想时该从哪里查。

1. 先理解知识蒸馏：大模型压缩里的“师生传承”

1.1 一句话解释蒸馏在做什么

知识蒸馏（Knowledge Distillation）的核心想法非常朴素：用一个已经训练好的复杂模型当老师，去指导另一个结构更简单、参数量更少的学生模型学习。目标是让学生模型在推理阶段用更低的计算成本，逼近教师模型的预测能力。

在很多教程里，这个关系被写成Teacher -> Student。教师模型通常称为 Teacher，学生模型通常称为 Student。训练时，Student 不仅学习真实数据标签，还学习 Teacher 在数据上输出的概率分布。关键点是，这种“概率分布”比原始标签携带了更多信息。

以图像分类为例，一张猫的图片。真实标签只告诉模型“这是猫”。但 Teacher 模型的输出可能是：猫 0.90，狗 0.07，老虎 0.02，狐狸 0.01。这组概率里实际上包含了“猫和狗比较像，猫和狐狸关系更远”这样的语义信息。如果只学习原始硬标签，这些类间相似关系就被完全丢掉了。

1.2 软标签和温度参数：蒸馏和普通训练的本质差异

知识蒸馏区别于普通监督学习的关键，在于它使用了软标签（soft label）。

普通训练使用硬标签（hard label），也就是 one-hot 向量，正确答案是 1，其余是 0。蒸馏训练则使用 Teacher 模型输出的概率分布作为辅助监督信号，这个分布不是非 0 即 1，而是带着各类别之间的相似度信息。

为了让概率分布更“软化”，蒸馏通常会引入温度参数 T。原始 logits 直接通过 softmax 得到的分布可能过于尖锐，比如某个类概率 0.99，其他类接近 0，这样仍然丢失了类间关系。蒸馏的做法是先除以 T 再进入 softmax：

p_i = exp(z_i / T) / sum_j exp(z_j / T)

T 越大，分布越平滑，小概率类别的差异也会被放大；T = 1 时就是普通 softmax。Hinton 在 2015 年的论文中把这个过程概括为：提取 Teacher 的“暗知识”，再迁移给 Student。

1.3 为什么开源模型厂商会主动支持蒸馏

蒸馏和开源的关系很容易理解。开源社区把大模型权重公开出来，其他团队就可以把它当作 Teacher，通过蒸馏得到适合自己业务场景的小模型。这样一个几百亿参数的大模型，可以被压缩成几十亿甚至几亿参数的小模型，部署成本大幅下降。

Meta 时隔较长时间重新开源，管理层又公开表达对蒸馏路线的支持，背后的逻辑并不难猜：开源模型矩阵里，既需要大参数模型作为能力上限，也需要可蒸馏的小模型去覆盖低成本推理场景。对开发者而言，这等于拥有了一条“用开源大模型训练自己私有小模型”的路径。

注意：蒸馏不是简单地“大模型生成答案，小模型背答案”。它更关注概率分布层面的对齐。如果你只是想记录大模型的回答，那是数据采集；如果你让小模型学习大模型答案背后的分布偏好，那才是真正意义上的蒸馏。

2. 蒸馏的三种常见模式，落地前先选对形态

蒸馏不是一个固定流程，它可以根据 Teacher 是否在训练过程中更新、是否能够访问模型参数，分成几种不同模式。

2.1 离线蒸馏：先训好老师，再训练学生

离线蒸馏是最常见、最容易上手的模式。先把 Teacher 模型完整训练好，冻结参数，然后对训练数据统一推理一遍，把每个样本的 logits 或概率分布保存下来。Student 训练时直接读取这些预存的软标签。

这种模式的优势是训练成本低，Student 训练阶段不需要在显存里同时加载 Teacher，适合大多数普通项目。不足是 Teacher 是静态的，如果后期 Teacher 升级，需要重新生成一次软标签。另一个隐藏问题是存储：如果数据量很大，缓存全部 logits 会占用不少空间。

实际项目中，更常见的做法是边训练边让 Teacher 前向传播，把 logits 实时传给 Student。从算法效果上看这仍然属于离线蒸馏，因为 Teacher 权重一直保持冻结。

2.2 在线蒸馏：老师和学生一起训练

在线蒸馏中，Teacher 和 Student 在训练过程中同步更新，Teacher 不再是一个静态模型。常见形式是，先用一个较强的初始化模型作为 Teacher，在训练早期指导 Student，在训练过程中 Teacher 也被任务标签继续优化。

在线蒸馏适合 Teacher 模型本身尚未固定、或者希望 Teacher 能伴随业务数据持续演进的场景。它的好处是 Student 能从动态变化的 Teacher 中学到更贴近当前任务的信息，训练出的 Student 往往更适应特定数据。代价是训练显存占用高，系统复杂度也更高，需要同时维护两套模型的状态。

2.3 自蒸馏和黑盒蒸馏：另一种路线

自蒸馏指的是模型自己教自己，通常是深度网络把高层特征向下层迁移，或者把不同深度的分支互相监督。自蒸馏不需要额外的复杂 Teacher，也不用准备第二套模型结构，常用于提升一个小模型的已有上限。

黑盒蒸馏在大模型时代越来越常见。它假设你拿不到 Teacher 的权重或中间层输出，只能调用推理接口，获得文本输出甚至概率。这种场景下，蒸馏目标是让 Student 模仿 Teacher 的回答风格、偏好和结构化输出模式。典型的做法是构造一批指令数据，调用 Teacher 生成参考答案，再用这些数据微调 Student。严格来说，这种基于生成结果的蒸馏，信息量比 logits 蒸馏少，但胜在适用范围广。

三种模式可以用一张表快速区分：

选择时先回答两个问题：你拿得到 Teacher 权重吗？训练时能否接受更大的显存开销？拿不到权重就选黑盒，拿得到且显存充足可以试在线蒸馏，普通项目优先从离线蒸馏开始。

3. 用 PyTorch 做一次最小蒸馏实验

聊完概念，下面用一个最小可运行的实验把蒸馏流程落地。环境使用 Python 3.10 和 PyTorch，数据集用 MNIST。MNIST 本身太简单，蒸馏收益并不明显，但它能让你快速看到整个训练链路，排除硬件和复杂度干扰。

3.1 实验目标与网络设计

实验目标：训练一个稍大的 TeacherNet，再让参数量更少的 StudentNet 学习 Teacher 的软标签，最后对比三条路线的准确率：

• TeacherNet 本身的效果。
• StudentNet 直接用硬标签训练的效果。
• StudentNet 使用蒸馏 loss 训练的效果。

TeacherNet 使用两层卷积加 BatchNorm，StudentNet 使用更小卷积核数量。

import torch import torch.nn as nn import torch.nn.functional as F from torch.utils.data import DataLoader from torchvision import datasets, transforms class TeacherNet(nn.Module): def __init__(self): super().__init__() self.features = nn.Sequential( nn.Conv2d(1, 32, 3, padding=1), nn.BatchNorm2d(32), nn.ReLU(inplace=True), nn.MaxPool2d(2), nn.Conv2d(32, 64, 3, padding=1), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.MaxPool2d(2), ) self.classifier = nn.Linear(64 * 7 * 7, 10) def forward(self, x): h = self.features(x) h = h.view(h.size(0), -1) return self.classifier(h) class StudentNet(nn.Module): def __init__(self): super().__init__() self.features = nn.Sequential( nn.Conv2d(1, 16, 3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(2), nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(2), ) self.classifier = nn.Linear(32 * 7 * 7, 10) def forward(self, x): h = self.features(x) h = h.view(h.size(0), -1) return self.classifier(h)

这里 TeacherNet 的参数量远大于 StudentNet。代码的意图是让 Student 用更少参数去拟合 Teacher 的能力边界，而不是简单地把 Teacher 结构复制一份。

3.2 准备数据，先训练 Teacher

加载 MNIST 并做标准化。MNIST 是灰度图，通道数为 1，图像尺寸 28x28。

transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) train_set = datasets.MNIST("./data", train=True, download=True, transform=transform) test_set = datasets.MNIST("./data", train=False, download=True, transform=transform) train_loader = DataLoader(train_set, batch_size=128, shuffle=True) test_loader = DataLoader(test_set, batch_size=256, shuffle=False)

训练 Teacher 时，直接使用交叉熵损失。这里只训练 3 个 epoch，目的是快速演示。实际项目里 Teacher 必须训练到收敛，否则后面会教偏 Student。

def train_model(model, loader, epochs=3, lr=1e-3): optimizer = torch.optim.Adam(model.parameters(), lr=lr) model.train() for epoch in range(epochs): total_loss = 0.0 for x, y in loader: optimizer.zero_grad() logits = model(x) loss = F.cross_entropy(logits, y) loss.backward() optimizer.step() total_loss += loss.item() avg_loss = total_loss / len(loader) print(f"epoch {epoch + 1}, loss {avg_loss:.4f}") return model

训练完成后，Teacher 进入评估模式。这一步非常关键：如果忘记调用teacher.eval()，BatchNorm 和 Dropout 在推理时会使用训练状态，logits 会不稳定，Student 学到的软标签质量会明显下降。

3.3 自定义蒸馏损失函数

蒸馏损失由两部分组成：

• KL 散度：衡量 Student 的软化概率和 Teacher 的软化概率之间的距离。
• 交叉熵：让 Student 仍然学习真实硬标签，防止 Teacher 犯错时带偏 Student。

def distillation_loss(student_logits, teacher_logits, labels, temperature=4.0, alpha=0.7): soft_target = F.softmax(teacher_logits / temperature, dim=1) log_prob_student = F.log_softmax(student_logits / temperature, dim=1) kl_div = F.kl_div(log_prob_student, soft_target, reduction="batchmean") distill_part = kl_div * (temperature * temperature) hard_part = F.cross_entropy(student_logits, labels) return alpha * distill_part + (1 - alpha) * hard_part

注意distill_part = kl_div * (temperature * temperature)。因为在 logits 除以 T 之后，梯度会缩小到原来的 1/T 量级，乘回 T 的平方可以让蒸馏损失的梯度尺度重新回到合理范围。这是很多初学者最容易漏掉的一个细节。

alpha控制蒸馏损失和硬标签损失的占比。alpha = 0时退化为普通交叉熵训练，alpha = 1时完全不看真实标签，只学 Teacher。

3.4 训练 Student

训练流程是：每一批数据输入 Teacher，用torch.no_grad()获得 Teacher 输出，再输入 Student，计算蒸馏损失，更新 Student 参数。

teacher = TeacherNet() teacher = train_model(teacher, train_loader, epochs=3) teacher.eval() student = StudentNet() optimizer = torch.optim.Adam(student.parameters(), lr=1e-3) student.train() for epoch in range(5): total_loss = 0.0 for x, y in train_loader: with torch.no_grad(): teacher_logits = teacher(x) student_logits = student(x) loss = distillation_loss( student_logits, teacher_logits, y, temperature=4.0, alpha=0.7 ) optimizer.zero_grad() loss.backward() optimizer.step() total_loss += loss.item() avg_loss = total_loss / len(train_loader) print(f"student epoch {epoch + 1}, loss {avg_loss:.4f}")

训练阶段需要 Teacher 对同一批数据做前向推理。如果数据量巨大，可以先把 Teacher logits 保存成.npy或.pt文件，训练 Student 时只读文件，避免 Teacher 反复前向传播。

3.5 验证结果

写一个简单评估函数，计算测试集准确率。

def evaluate(model, loader): model.eval() correct = 0 total = 0 with torch.no_grad(): for x, y in loader: pred = model(x).argmax(dim=1) correct += (pred == y).sum().item() total += y.size(0) return correct / total teacher_acc = evaluate(teacher, test_loader) student_acc = evaluate(student, test_loader) print(f"teacher acc: {teacher_acc:.4f}") print(f"student acc: {student_acc:.4f}")

记录结果时，建议按下面这张表组织：

MNIST 任务上，独立训练的小模型本来就能达到很高准确率，所以蒸馏提升可能只有零点几个百分点，这是正常的。换到 CIFAR-10、CIFAR-100 或真实业务分类数据，差距会明显得多。真正判断蒸馏是否有效，要建立在“相同 Student 结构、相同优化器、相同训练步数”的对比上。

注意：验证蒸馏效果时，不要只记录最终准确率。至少要记录 Teacher 是否收敛、Student 是否使用相同的硬标签数据、温度参数是多少、随机种子是什么。缺少这些信息，实验结果很难复现。

4. 温度、alpha 和数据分布：决定蒸馏效果的四个关键变量

同样的蒸馏代码，不同参数产生的结果可能差异巨大。下面四个变量是最值得反复调整的。

4.1 温度 T：软化程度不是越高越好

温度的作用是调节概率分布的平滑程度。T 越大，分布越平滑，模型会更多关注 Teacher 在次级类别之间的偏好；T 越小，越接近 one-hot 分布，蒸馏退化成普通交叉熵。

但 T 并不是越大越好。过高的温度会让所有类别的概率都趋向均匀，软标签失去判别性。实际项目中，分类任务常用 T 在 2 到 8 之间，生成式大模型蒸馏常用 T 在 0.6 到 1.5 之间，因为不同任务的输出分布尺度完全不同。

T 调高到极端值后，典型现象是训练 loss 下降很快，但测试准确率逐渐下降。这是因为 Student 学到了太多平滑噪声，反而丢失了关键判别信息。

4.2 alpha：软标签和硬标签的权重平衡

alpha 控制 KL 散度损失在总损失中的比例。alpha 越大，Student 越依赖 Teacher 的软标签；alpha 越小，Student 越依赖真实硬标签。

常见设置在 0.5 到 0.9 之间。如果 Teacher 能力明显强于 Student，可以调大 alpha；如果 Teacher 在部分样本上经常犯错，alpha 调大反而会把错误传染给 Student。一个稳妥策略是先固定 alpha = 0.7，观察验证集变化，再按 0.1 的步长微调。

4.3 Teacher 的质量和训练数据一致性

如果 Teacher 本身没有收敛，它的 logits 包含大量噪声，Student 学到的东西自然不可靠。更隐蔽的问题是 Teacher 和 Student 的训练数据分布不一致。比如 Teacher 是在全量数据上训练的，Student 却只用了一部分清洗后的数据；或者 Teacher 来自公开权重，Student 使用的是业务数据，两者在边缘样本上的分布差异会直接反映到软标签上。

遇到这种情况，先在业务数据子集上对 Teacher 做一轮评估。如果 Teacher 在业务数据上已经明显不擅长，就不要把它当作权威老师，可以结合硬标签权重提高真实标签的作用。

4.4 Student 的结构容量要匹配任务复杂度

Student 不是越轻越好。如果任务本身很复杂，Student 容量严重不足，无论 Teacher 多强，它都“记不住”知识。一个简单检查方法是：先让 Student 直接训练硬标签，如果硬标签训练都达不到合理基线，说明 Student 结构需要加大。

关键参数速查表：

5. 蒸馏效果怎么验证：不能只看准确率

很多团队评估蒸馏时只对比一个准确率，这在实验阶段可以理解，但在生产项目里远远不够。

5.1 三个核心维度：准确率、压缩比、推理时延

准确率看的是模型质量，压缩比看的是模型体积，推理时延看的是服务性能。三者需要一起看。

比如一个 7B 模型蒸馏成 2B 模型，准确率只下降 1%，但单次推理时延下降 60%，显存占用下降 70%，这个蒸馏就是值得做的。相反，如果准确率下降 5%，模型体积只缩小 20%，这个蒸馏收益就很有限。

生产环境建议记录：

• 模型文件大小。
• 单条样本推理时延（P50/P95）。
• 峰值显存或内存占用。
• 每秒请求吞吐量。
• 重启加载模型所需时间。

5.2 检查分布漂移：单独看难样本表现

平均准确率会掩盖很多问题。比如 Student 在整体测试集上只比 Teacher 低 1%，但在某个业务关键子类上低了 8%。这才是需要重点排查的部分。

一种做法是把测试集按类别或业务维度分组，分别计算 Teacher 和 Student 的准确率。两列并排放在一起，能很快发现哪些子类出现退化。另一种做法是把 Teacher 分类错误、Student 分类正确和 Teacher 正确、Student 错误的样本分别打印出来，人工观察差异模式。

如果 Student 在 Teacher 原本擅长的类别上反而退化了，通常说明蒸馏时这个类别对应的软标签被其他类别稀释了，或者训练数据里这个类别的样本不足。

5.3 实验复现清单

为了保证实验可复现，至少记录以下内容：

• 随机种子。
• Teacher 结构、参数数量、是否冻结。
• Teacher 训练轮数和最终准确率。
• Student 结构和参数数量。
• 温度 T、alpha、batch size、学习率。
• 标签处理方式：是否用真实硬标签、软标签是否离线缓存。
• 测试集划分方式和评估脚本版本。

条目不要多，但每条都要具体。记录完整后，即使换一个人来跑，也能得到几乎一致的结果。

6. 常见坑与排查路径：蒸馏失败的六种现象

蒸馏实验遇到效果不佳，大多数情况下不是算法原理错了，而是某个环节出现了细节问题。下面按“现象 -> 原因 -> 检查方式 -> 处理建议”整理。

排查顺序建议按输入数据、Teacher 状态、蒸馏参数、Student 结构依次检查。

先确认 Teacher 在训练集和测试集上的准确率。Teacher 自己都不行，后面的蒸馏都谈不上。然后确认 Teacher 是否处于eval()状态，BatchNorm 和 Dropout 是否被正确冻结。接着检查软标签的数值范围，如果所有 logits 都在 0 附近，说明 Teacher 输出有问题。最后再调温度 T 和 alpha，不要一开始就同时调两个参数。

一套更稳定的降级方案是：先用alpha = 0训练 Student 得到基线，再逐步调大 alpha。如果 alpha = 0 时 Student 效果已经接近 Teacher，说明任务本身足够简单，蒸馏收益小，重点应该转向推理性能优化；如果 alpha = 0 时效果明显差，说明 Student 容量不足，优先调结构而不是调温度。

7. 蒸馏在开源大模型生态里的落地场景

回到 Meta 重新开源模型这件事上。对普通开发者来说，蒸馏不再只是论文里的概念，而是一条可以实际操作的技术路径。

7.1 白盒蒸馏和黑盒蒸馏的选择

如果使用的是开源权重，你能拿到模型参数，这就是白盒场景。白盒蒸馏可以让 Student 对齐 Teacher 的 logits、隐藏状态，甚至注意力分布。信息量更大，效果通常也更好。

如果只能通过 API 调用开源模型，只能拿到生成文本，这就是黑盒场景。常见做法是构造一批高质量指令，调用 Teacher 生成答案，再用这些数据去微调 Student。这种方法的限制是，Teacher 的推理过程中间状态不可见，Student 只能学到输出层面的模式。

对大多数团队，建议按“先黑盒后白盒”的顺序验证：先用 Teacher 生成一组业务数据，微调一个小的开源模型作为基线。如果能跑通，再去研究如何读取 Teacher 的 logits 或隐藏状态，做真正的白盒蒸馏。

7.2 “蒸馏一本书”“蒸馏成 Skill”的说法怎么理解

社区里经常看到“蒸馏一本书”“把知识蒸馏成 Skill”这类说法。它们和经典知识蒸馏机制并不完全一样，更多是指把大量文档、方法论或大模型的回答模式，整理成可复用的知识库、Prompt 模板或智能体工作流。

这种泛化用法反映的是同一个诉求：把昂贵、笨重、难以复制的能力，压缩成轻量、可控、可复用的资产。做技术选型时要注意区分：如果你只是在整理 Prompt 或知识库，那属于工程优化；如果训练了一个小模型去模拟大模型的输出分布，那才是真正意义上的知识蒸馏。

7.3 面对动辄百亿参数模型，从小任务开始

开源大模型很多，但不需要一上来就找最大的模型蒸馏。一个更稳妥的做法是，先用一个小型开源模型，在业务数据上完成一次完整的蒸馏实验，把温度、alpha、数据分布、评估流程都跑顺。之后再迁移到更大的 Teacher 模型上。

这一步的价值在于：小模型训练速度快，失败成本低，更容易暴露问题。当你连小模型的蒸馏都做不稳定时，换成大模型只会更难排查。

8. 从实验到工程：蒸馏模型发布前需要做什么

实验跑通只是第一步。把一个蒸馏后的模型放进生产环境，还要补齐很多环节。

8.1 学习环境与生产环境的差距

学习环境里，一个 Jupyter Notebook 跑完即可，可能只关注准确率。生产环境至少还要关注：

• 配置外置化：温度、alpha、模型路径不能写死在代码里。
• 日志和监控：训练阶段记录 loss，服务阶段记录推理时延和请求量。
• 权限和安全：模型文件要有访问控制，避免未授权下载。
• 异常处理：推理服务需要处理输入格式错误、显存不足、模型加载失败等情况。
• 回滚方案：线上模型出现问题时要能快速切换到上一个版本。
• 数据备份：Teacher 软标签是重要中间产物，应纳入版本管理。

8.2 四份可复用清单

训练前检查清单：

1. 确认 Teacher 模型已收敛。
2. 确认 Teacher 与 Student 使用同一套数据预处理。
3. 固定随机种子。
4. 先设定 T=4、alpha=0.7 的默认值。
5. 确认 Teacher 在训练阶段处于eval()状态。

实验记录清单：

1. 记录 Teacher 准确率和 student 基线准确率。
2. 记录温度 T、alpha、batch size、学习率。
3. 保存蒸馏 loss 曲线。
4. 单独统计关键子类准确率。
5. 保存 Teacher logits 缓存文件。

发布前检查清单：

1. 用生产数据做一次分布验证。
2. 对比 Teacher 和 Student 的推理时延。
3. 检查模型文件大小和资源占用。
4. 确认异常分支有日志。
5. 准备回滚版本。

排查顺序清单：

1. 输入数据是否一致。
2. Teacher 是否收敛并冻结。
3. 软标签数值是否合理。
4. 温度是否过高或过低。
5. Student 容量是否足够。
6. 训练随机种子是否固定。

8.3 扩展方向：蒸馏、量化和剪枝的配合

蒸馏不一定要单独使用。它和量化、剪枝可以组合成一条完整的模型压缩链路：先蒸馏出一个小模型，再对这个小模型做 INT8 量化，必要时再做结构化剪枝。

需要注意顺序。一般建议先做蒸馏，再量化和剪枝。如果先量化再蒸馏，量化噪声会影响软标签的质量，蒸馏效果会打折扣。

对一个刚开始做蒸馏的开发者来说，最有价值的练习不是立刻拿一个百亿参数模型去精调，而是把本文的 MNIST 实验换成你业务里最容易出现分布差异的数据，记录下温度和 alpha 的变化，体会“什么样的老师才能带出好学生”。当你能解释清楚 Teacher 为什么教得好、Student 为什么学得差，你才算真正理解了蒸馏。