知识蒸馏原理与PyTorch实战：避开过度蒸馏的陷阱

最近两三年，“蒸馏”这个词被反复提到，甚至有几分被妖魔化的味道。模型体积大了要蒸馏，边缘设备部署要蒸馏，训练数据不够要蒸馏；更夸张的是，在一些社区里还能看到“把一本书蒸馏成知识库”“把某个 skill 蒸馏进智能体”的说法。蒸馏看起来像是一个万能压缩器，好像只要把大模型的知识倒进小模型里，就能既保住效果又降低资源开销。但事实没有那么简单。

过度蒸馏同样要付出代价：能力退化、知识失真、多样性坍缩、不可调试，甚至会出现“越蒸越笨”的情况。本文不打算把知识蒸馏吹成银弹，也不打算全盘否定它，而是从原理、PyTorch 代码、常见误区和工程实践几个维度，把知识蒸馏讲清楚。无论你是刚接触这个概念的学生，还是正在做模型压缩落地的工程师，都可以按这篇文章的内容做一次对照实验，亲自感受蒸馏的收益与边界。

1. 背景与核心概念

1.1 蒸馏模型是什么意思

知识蒸馏（Knowledge Distillation）最早是 Hinton 等人在 2015 年前后系统提出的一种模型训练方法，核心思想非常直观：让一个小模型去模仿一个大模型的行为。这里的大模型被称为教师模型，小模型被称为学生模型。

教师模型往往参数量大、结构复杂，在特定任务上已经训练得比较充分。学生模型结构更小，更适合部署在资源有限的环境中。传统训练方式下，小模型只能从原始标签中学习，比如一张图片的标签是“猫”，那模型就把所有信息压缩成“这张图是猫”这样一个 one-hot 向量。但教师模型不一样，它除了能告诉学生“这是猫”，还会输出“它和狗有点像”“和老虎稍像一点”“和汽车完全不像”这样的软信息。

蒸馏模型的核心，就是让学生模型学习教师模型输出的概率分布，而不仅仅是硬标签。这样学生模型能够继承教师模型对数据之间相似性的理解，训练效率通常会比直接从标签学习更高。

“蒸馏模型是什么意思，以及原理是什么”这个高频问题，答案也在这里：蒸馏是知识传递方式，属于模型压缩和知识迁移的一种实现路径。它不是“把一个模型融化后再倒进另一个模型”，而是通过模仿输出的概率分布，达到迁移知识的目的。

1.2 知识蒸馏解决什么问题

知识蒸馏能流行起来，是因为它在实际工程中解决了三类问题。

第一类问题是模型压缩与推理加速。云端训练一个大模型效果很好，但要把模型部署到手机、嵌入式设备、边缘网关，内存和算力都有限。直接运行大模型不现实，于是训练一个参数少得多的小模型来模仿大模型，是常见方案。

第二类问题是数据受限场景下的知识迁移。有些场景拿不到完整的原始标注数据，或者原始数据涉及隐私不能直接迁移。这时候可以把大模型在已有数据上产生的 logits 或预测结果保存下来，作为小模型的训练目标。这就是所谓的“用教师输出替代标签”。

第三类问题是多任务或多模型融合。多个教师模型可能擅长不同领域，通过蒸馏可以把多个教师的知识融合进一个学生模型，减少部署多个模型的成本。

但要注意，知识蒸馏不是无损压缩。它更像“复述”——学生能学到教师讲的大部分内容，但一定会丢失一些细节。正是这个“丢失细节”的问题，决定了过度蒸馏是有代价的。

1.3 为什么“蒸馏”最近被推得很高

最近一两年，随着大模型参数规模越来越大、推理成本越来越高，“蒸馏”这个词的讨论频率明显上升。模型厂商希望用更小的模型实现接近大模型的效果，业务团队希望降低线上推理的响应时间和费用，算法工程师则希望用蒸馏快速获得一个可部署的模型。

再加上生成式 AI 和智能体的兴起，“把一本书蒸馏进知识库”“把某个 skill 蒸馏进小模型”等说法不断出现。这些说法有的成立，有的只是比喻，甚至有的是营销话术。知识蒸馏确实是一种有效技术，但它有自己的适用条件和理论边界。把它当成万能压缩工具，就会走进误区。

接下来，我们先拆解知识蒸馏的原理，再用 PyTorch 实现一个最小可运行的项目，最后重点分析“过度蒸馏”到底会付出什么代价。

2. 知识蒸馏的核心原理拆解

2.1 教师模型与学生模型

知识蒸馏的基本框架由教师模型和学生模型组成。

教师模型通常是已经训练好的、精度较高的大模型。在蒸馏过程中，教师模型参数是冻结的，它只负责对输入样本产生预测结果。学生模型是待训练的小模型，它的结构比较小，参数量远低于教师模型。

训练时，同一个 batch 的输入会分别进入教师模型和学生模型。教师模型输出 logits，学生模型也输出 logits。蒸馏的目标是让两个 logits 经过软化后的概率分布尽可能接近。

这里有一个容易混淆的点：学生模型并不仅仅是“模仿教师的最终答案”，而是“模仿教师的判断过程”。判断过程体现在类别之间的相对概率上。比如一张模糊的图片，教师判断它是“7”的概率是 0.6，是“1”的概率是 0.3，是“9”的概率是 0.1。如果只看硬标签，学生只知道答案是“7”，完全丢失了“它和 1、9 都有点像”这个信息。而蒸馏能把这部分信息保留下来。

2.2 软标签为什么比硬标签更好

硬标签是 one-hot 编码，比如猫是[0, 1, 0]，狗是[1, 0, 0]。这样的标签没有类别之间的相似度信息，模型在训练时只关注把正确的类概率拉高，不关心错误类之间的相对关系。

软标签则是模型输出的概率分布，比如[0.1, 0.8, 0.1]。这种分布包含的信息更丰富：0.1 表明该样本与第一个类别有一定关联，0.8 表明它最可能属于第二个类别。当教师模型训练得足够好时，这些软标签可以帮助学生模型理解类别间的边界和联系。

在图像分类、文本分类等任务中，使用软标签训练小模型，往往比直接使用硬标签训练同一个模型收敛更快、泛化更好。但软标签不是越“软”越好，这引出了下一个关键概念——温度系数。

2.3 温度系数 T 的作用

为了让教师模型输出的概率分布更“软”，蒸馏时会对 logits 除以一个温度系数 T，再做 softmax：

softmax(z_i / T)

其中z_i是模型输出的 logits，T是温度系数。

当T = 1时，运算就是普通 softmax，输出的概率分布和模型原始预测一致。当T > 1时，logits 被缩小，softmax 之后分布更平滑，类别之间的细微信号会被放大。当T非常大时，分布趋于均匀，几乎所有类别概率都差不多，反而失去了信息。当T < 1时，分布会更尖锐，接近硬标签。

所以温度系数是一个需要调参的关键项。它控制着“教师传递多少细节给学生”。温度太低，蒸馏退化为硬标签学习；温度太高，教师传递了太多噪声。常见的做法是在 3 到 5 之间做网格搜索，并观察学生模型在验证集上的表现。

2.4 蒸馏损失函数：KL 散度与任务损失结合

知识蒸馏的损失函数通常由两部分组成：

L = alpha * L_hard + (1 - alpha) * L_distill

其中L_hard是学生模型与真实硬标签之间的交叉熵损失，让模型仍然能学到正确类别；L_distill是学生模型软输出与教师模型软输出之间的 KL 散度，让学生模型模仿教师的概率分布。

L_distill的典型计算方式是：

L_distill = KL(softmax(student_logits / T), softmax(teacher_logits / T)) * T^2

为什么要乘以T^2？因为 KL 散度在计算时会对软化后的 logits 求梯度，除以 T 之后，梯度的尺度会发生改变。乘回T^2，可以在不同温度下保持梯度量级稳定，避免温度改变导致训练不稳定。

alpha控制两部分损失的比例。当训练数据较少时，可以提高蒸馏损失的权重；当数据量充足时，硬标签损失更重要。比较常用的初始值是alpha = 0.7，也就是让模型 70% 关注硬标签，30% 关注教师的软知识。实际使用时应根据任务调整。

3. 环境准备与实验设计

3.1 运行环境与依赖

本文的完整代码基于 Python 和 PyTorch。PyTorch 的版本建议使用 2.x 及以上，但 1.13 等版本也能运行。核心 API 变化不大，关键是torch.nn.functional.kl_div、torch.nn.CrossEntropyLoss这些基础接口。

需要的依赖如下：

• Python 3.8 及以上
• PyTorch 2.x
• torchvision
• CUDA 可选，CPU 也能完成演示，只是训练速度慢一些

安装依赖的命令：

pip install torch torchvision

如果网络环境特殊，也可以使用国内镜像源安装：

pip install torch torchvision -i https://pypi.tuna.tsinghua.edu.cn/simple

安装完成后，可以用下面这段代码验证环境是否正常：

python -c "import torch; print(torch.__version__)"

运行后输出 PyTorch 版本号即说明环境正常。

3.2 实验设计思路

为了让大家直观感受知识蒸馏的作用，以及“过度蒸馏有代价”这个问题，我们设计一个对照实验。

数据集使用 MNIST 手写数字识别。任务本身相对简单，训练速度快，适合在 CPU 上演示。教师模型使用一个两层卷积网络（TeacherCNN），参数较多，表达能力更强。学生模型使用一个单隐层 MLP（StudentMLP），参数量小，更适合体现压缩和蒸馏的效果。

实验分为三组：

通过对比对照组学生和蒸馏学生的精度与收敛速度，可以验证知识蒸馏是否有效。同时我们会讨论，如果进一步压缩学生模型、提高温度、或者对同一个教师做多代蒸馏，会出现什么样的副作用。

4. 完整实战：PyTorch 实现一个最小知识蒸馏项目

4.1 完整训练脚本

下面给出一个可直接复制运行的 PyTorch 脚本。代码中的注释已经说明每个部分的作用。

# 文件路径：distill_mnist.py import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torch.utils.data import DataLoader from torchvision import datasets, transforms # 设备选择，有 GPU 用 GPU，没有 GPU 用 CPU device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # MNIST 数据预处理 transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) train_dataset = datasets.MNIST( root="./data", train=True, transform=transform, download=True ) test_dataset = datasets.MNIST( root="./data", train=False, transform=transform, download=True ) train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=256, shuffle=False) # 教师模型：相对复杂的 CNN class TeacherCNN(nn.Module): def __init__(self): super().__init__() self.conv1 = nn.Conv2d(1, 32, 3, padding=1) self.conv2 = nn.Conv2d(32, 64, 3, padding=1) self.pool = nn.MaxPool2d(2) self.fc = nn.Linear(64 * 7 * 7, 10) def forward(self, x): x = F.relu(self.conv1(x)) x = self.pool(F.relu(self.conv2(x))) x = x.view(x.size(0), -1) return self.fc(x) # 学生模型：简单的单隐层 MLP class StudentMLP(nn.Module): def __init__(self, hidden=128): super().__init__() self.fc1 = nn.Linear(28 * 28, hidden) self.fc2 = nn.Linear(hidden, 10) def forward(self, x): x = x.view(x.size(0), -1) x = F.relu(self.fc1(x)) return self.fc2(x) # 通用训练函数：使用硬标签交叉熵 def train_with_hard_label(model, epochs=3): optimizer = optim.Adam(model.parameters(), lr=1e-3) criterion = nn.CrossEntropyLoss() model.train() for epoch in range(1, epochs + 1): total_loss = 0.0 correct = 0 total = 0 for images, labels in train_loader: images, labels = images.to(device), labels.to(device) optimizer.zero_grad() logits = model(images) loss = criterion(logits, labels) loss.backward() optimizer.step() total_loss += loss.item() preds = logits.argmax(dim=1) correct += (preds == labels).sum().item() total += labels.size(0) print( f"Epoch {epoch}: loss={total_loss / len(train_loader):.4f}, " f"acc={correct / total:.4f}" ) # 蒸馏训练函数 def train_with_distill(student, teacher, epochs=5, T=4.0, alpha=0.7): optimizer = optim.Adam(student.parameters(), lr=1e-3) hard_criterion = nn.CrossEntropyLoss() teacher.eval() # 教师模型冻结 for epoch in range(1, epochs + 1): student.train() total_loss = 0.0 correct = 0 total = 0 for images, labels in train_loader: images, labels = images.to(device), labels.to(device) # 教师模型只输出软标签，不计算梯度 with torch.no_grad(): teacher_logits = teacher(images) student_logits = student(images) # 软化后的学生 logits 和教师 logits soft_student = F.log_softmax(student_logits / T, dim=1) soft_teacher = F.softmax(teacher_logits / T, dim=1) # 蒸馏损失：KL 散度，乘以 T^2 保持梯度尺度 distill_loss = F.kl_div( soft_student, soft_teacher, reduction="batchmean" ) * (T * T) # 硬标签交叉熵损失 hard_loss = hard_criterion(student_logits, labels) # 综合损失 loss = alpha * hard_loss + (1 - alpha) * distill_loss optimizer.zero_grad() loss.backward() optimizer.step() total_loss += loss.item() preds = student_logits.argmax(dim=1) correct += (preds == labels).sum().item() total += labels.size(0) print( f"Distill Epoch {epoch}: loss={total_loss / len(train_loader):.4f}, " f"acc={correct / total:.4f}" ) # 模型评估函数 def evaluate(model): model.eval() correct = 0 total = 0 with torch.no_grad(): for images, labels in test_loader: images, labels = images.to(device), labels.to(device) logits = model(images) preds = logits.argmax(dim=1) correct += (preds == labels).sum().item() total += labels.size(0) return correct / total if __name__ == "__main__": print("====== 训练教师模型 ======") teacher = TeacherCNN().to(device) train_with_hard_label(teacher, epochs=3) teacher_acc = evaluate(teacher) print(f"Teacher test acc: {teacher_acc:.4f}") print("\n====== 训练对照组学生模型（硬标签） ======") student_plain = StudentMLP().to(device) train_with_hard_label(student_plain, epochs=3) plain_acc = evaluate(student_plain) print(f"Plain student test acc: {plain_acc:.4f}") print("\n====== 训练蒸馏学生模型 ======") student_distilled = StudentMLP().to(device) train_with_distill(student_distilled, teacher, epochs=5, T=4.0, alpha=0.7) distill_acc = evaluate(student_distilled) print(f"Distilled student test acc: {distill_acc:.4f}") print("\n====== 结果对比 ======") print(f"Teacher acc: {teacher_acc:.4f}") print(f"Plain student acc: {plain_acc:.4f}") print(f"Distilled student acc: {distill_acc:.4f}")

4.2 运行方式

将上面的代码保存为distill_mnist.py，然后在终端运行：

python distill_mnist.py

程序会自动下载 MNIST 数据集，并依次训练教师模型、对照学生模型和蒸馏学生模型。在普通 CPU 上，整个训练过程大约需要几分钟到十几分钟，具体时间取决于机器配置。

如果希望结果更稳定，可以调整随机种子：

import random import numpy as np def set_seed(seed=42): random.seed(seed) np.random.seed(seed) torch.manual_seed(seed)

4.3 预期结果与解读

MNIST 是相对简单的任务，三个模型的最终精度可能都比较高，教师模型一般能达到 99% 左右，学生模型也能达到 98% 以上。因此在 MNIST 上，蒸馏学生和普通学生之间的差距不一定非常明显。但这不表示蒸馏没有用，更多时候，蒸馏的价值体现在下面几个方面：

• 在相同 epoch 数下，蒸馏学生的收敛速度往往更快。
• 如果减少训练数据量，蒸馏学生比普通学生更稳定。
• 如果继续压缩学生模型，比如把隐藏层从 128 降到 32，蒸馏的优势会逐渐显现。
• 在复杂任务（如 CIFAR-10、文本分类、目标检测）上，蒸馏效果通常比 MNIST 更明显。

所以，建议大家运行完脚本后，自己尝试修改hidden参数、调整T和alpha，对比不同设置下的结果。这种对照实验，比直接背结论更能帮助理解蒸馏的边界。

4.4 如何扩展到自己的任务

实际项目中，很少有人直接用 MNIST。要扩大到自己任务，核心步骤是一样的：

1. 准备一个已经训练好的教师模型，并冻结参数。
2. 构建一个目标学生模型，结构按部署资源设计。
3. 准备蒸馏数据集，可以是原始训练集，也可以是无标签数据。
4. 在训练循环中，同时计算硬标签损失和与教师模型的 KL 散度损失。
5. 根据验证集效果调整温度T、损失权重alpha和训练轮数。

需要注意的是，教师模型的数据分布与学生模型训练数据分布必须一致。如果教师模型在一个领域的训练集上训练，却拿另一个领域的无标签数据进行蒸馏，学生模型可能学到错误的知识。

5. 过度蒸馏的代价：为什么不能无限压缩

5.1 学生模型的性能天花板

很多人在蒸馏时有一个默认假设：教师模型越强，学生模型也越强。但实际上，学生模型的能力上限受到自身结构和参数量的限制。教师模型能学到复杂决策边界，学生模型不一定有这个表达能力。

更关键的问题是，学生模型是在模仿教师，而不是在直接学习原始数据。教师模型的错误也会被继承。如果教师模型本身对某些类别存在偏见或过拟合，学生模型会把这些偏见一起学过去。这种情况下，蒸馏不是“净化知识”，而是“放大错误”。

当学生模型容量远小于教师模型时，强行让两者输出分布接近，学生只能“牺牲一部分知识去拟合另一部分知识”。这种压缩必然导致精度下降。一旦出现“学生已经尽力但始终追不上教师”的情况，通常不是调参能解决的，而是模型容量差距过大或任务本身不适合蒸馏。

5.2 多样性坍缩与同质化

在分类任务中，过度蒸馏可能只表现为精度下降。但在生成任务，比如文本生成、对话系统、图像生成中，过度蒸馏的代价会更明显：模型输出的多样性会坍缩。

原因在于神经网络在训练时倾向于学习概率分布的主峰。教师模型的输出分布中，原本有一些次峰代表多样化的表达方式。温度过高时，这些次峰被过度平滑；温度过低时，学生模型又直接逼近硬标签，把次峰忽略。多代蒸馏后，次峰信息可能完全消失，模型输出越来越模板化，越来越保守。

这种情况在对话机器人、文本续写和创意生成场景中尤其致命。一个被多轮蒸馏的模型，可能语法正确、内容安全，但缺乏创造力和多样性。这就是“过度蒸馏的代价”中容易被低估的一点。

5.3 知识失真与幻觉：从模型蒸馏到知识库蒸馏

最近常看到“把一本书蒸馏成知识库”“把某个 skill 蒸馏进智能体”等说法。我们需要冷静看待这些提法。

一本书包含的信息量非常大，包括概念定义、逻辑推导、案例、上下文、作者观点等。如果只用一个简单的知识库或一个小模型去“蒸馏”整本书，本质上是在做高压缩率的有损压缩。模型或知识库能保留多少关键信息，取决于存储结构、索引方式、训练数据覆盖度和压缩策略。如果压缩率过高，很容易出现知识失真。

在生成式应用中，这种失真往往表现为“幻觉”。模型把不确定的、残缺的知识用一种自信的语气输出，用户无法判断这是忠实于原文还是模型自己“脑补”出来的。所以，如果要做一本书或长文档的知识库，不能只依赖蒸馏，还需要保留原文引用、分段检索、答案溯源和人工审核机制。

5.4 可解释性下降与调试困难

学生模型结构更小，理论上更容易解释。但经过蒸馏后，学生模型的行为更多来自教师模型的“隐式知识”，而不是清晰的规则。这会导致一个尴尬的局面：小模型本身很容易看结构，但它的行为却很难被理解，因为你不知道它从教师那里学到了什么。

如果蒸馏过程中出现某些样本表现异常，排查困难会明显增加。你需要同时检查学生模型、教师模型、蒸馏数据、温度参数、损失权重，问题可能出在任意一环。相比之下，普通训练的小模型虽然精度可能略低，但行为路径更清晰，便于调试。

这也说明，知识蒸馏不是“免费的午餐”。它用可解释性和可控性，换取了精度和规模之间的平衡。工程上必须明确取舍。

6. 常见误区与排查思路

6.1 蒸馏被“妖魔化”的几种表现

知识蒸馏被妖魔化，主要不是因为技术本身有问题，而是因为一些不准确的认知被反复传播。

误区一：蒸馏是万能压缩工具。实际上，蒸馏适合处理“大模型效果好但资源受限”的场景。如果数据充足且可以直接训练小模型，盲目引入教师模型反而增加复杂度，未必有收益。

误区二：温度越高越好。温度高会让分布更平滑，但过高的温度会让所有类别概率接近均匀，学生模型学不到有效的类别区分信息。温度相当于一个调节信息粒度的旋钮，不是越大越好。

误区三：蒸馏一次成功，就可以无限蒸馏。多代蒸馏（用蒸馏后的学生模型再去蒸馏下一个更小的模型）确实可行，但每一代都会有信息损失。第二代学生还能保持大部分效果，到第三代、第四代，累积误差可能会让模型性能明显下降。

误区四：教师模型越强，学生模型一定越强。教师模型与学生模型之间存在“能力鸿沟”。教师是 90 分，学生可能因为容量限制只能到 80 分；但如果教师是 95 分且输出分布过于自信，学生反而可能只能到 75 分。选择教师，不是越强越好，而是越“适合教”越好。

6.2 常见问题排查表

6.3 如何判断蒸馏是否过度

判断蒸馏是否过度，不能只看测试集精度，还要观察模型在真实场景下的表现。以下几个信号可以帮助你判断：

• 精度指标还在合理范围内，但模型在边界样本、对抗样本上表现明显下降。
• 生成类任务中，输出文本或图片的多样性显著降低，翻来覆去是几种固定模式。
• 模型对训练数据分布之外的样本非常敏感，泛化能力变差。
• 人类评估时发现模型的“常识感”下降，会一本正经地输出错误信息。
• 对代码或配置稍作修改，模型行为就剧烈变化，稳定性变差。

如果出现这些问题，建议先停止压缩，回到原始数据训练一个同等规模的小模型作为 baseline。只有蒸馏模型稳定优于 baseline，才说明蒸馏的收益是真实的。

7. 知识蒸馏的工程最佳实践

7.1 选对适用场景

知识蒸馏不是银弹，它在以下场景中更值得尝试：

• 模型需要部署到端侧或边缘设备，算力与内存受限。
• 云端大模型训练成本可以接受，但线上推理成本不能接受。
• 有大量无标签数据，希望借助大模型生成软标签来训练小模型。
• 需要把多个模型的能力融合到一个模型里，减少服务数量。

反过来说，如果数据充足、标注成本低、可以直接训练小模型，或者模型需要强可解释性，那么优先考虑普通训练和规则方案，而不是一上来就做蒸馏。

7.2 调参建议

蒸馏调参的核心是温度T和损失权重alpha。下面的建议来自常见工程经验，实际任务仍需自己验证。

值得注意的是，温度T与alpha之间存在耦合关系。增大T会让软标签更平滑，这时可能需要适当增大蒸馏损失权重；减小T时，蒸馏损失本身的信息量下降，可以适当降低alpha。分开调参容易得到局部最优解，建议做一个小网格搜索。

7.3 数据选择与评估指标

蒸馏数据的选择直接影响学生模型效果。很多情况下，使用原始训练集加无标签数据的组合效果最好。教师模型在无标签数据上产生软标签，相当于对学生进行“半监督增强”。

评估蒸馏模型不能只看测试集准确率。建议增加以下指标：

• 错误分析：按类别查看学生模型与教师模型的一致率和差异。
• 鲁棒性测试：对输入加入噪声、遮挡、扰动，观察精度变化。
• 校准度：模型预测的概率是否反映真实置信度。
• 生成质量：如果是文本或图像生成任务，使用人工评估或多样性指标。

如果学生模型只在测试集上表现好，而在真实数据上波动很大，说明蒸馏过程过拟合了教师模型，需要增加数据或正则化。

7.4 更稳妥的轻量化替代方案

蒸馏是模型轻量化的一种手段，但不是唯一手段。工程上可以根据实际情况组合使用。

实际项目中，常见做法是先训练一个精度达标的教师模型，再用蒸馏训练一个较小的学生模型，最后对 学生模型做量化或剪枝。每一步都需要在验证集上确认掉点程度，避免“叠加损耗”。

7.5 上线前检查清单

如果要在生产环境中使用蒸馏模型，建议按以下清单排查：

• 教师模型是否达到业务要求的精度与鲁棒性。
• 学生模型是否与直接训练的小模型做过公平对比。
• 蒸馏数据是否覆盖真实业务场景，不能只在公开数据集上有效。
• 温度、alpha、训练轮数等超参是否记录并复现。
• 是否在独立测试集上做过误差分析。
• 模型监控指标是否包含置信度、多样性和异常输入比例。
• 是否保留教师模型接口，方便后续迭代蒸馏。
• 如果涉及知识库或文档蒸馏，是否保留原始来源和引用链路。

8. 总结与下一步学习路线

知识蒸馏是一个让人又爱又恨的工具。它能在很多场景下有效压缩模型、迁移知识，但它不是无损压缩，更不是万能钥匙。被妖魔化的蒸馏，本质上是被当成了“无需数据、无需调参、无需权衡”的捷径。而真正做过蒸馏实验的人都知道，温度、权重、教师选择、数据分布，每一个环节都会影响最终效果。

如果你刚开始接触蒸馏，建议先不要追那些“蒸馏一本书”“蒸馏一个 skill”的热点概念，而是按本文的 PyTorch 示例跑通一个最小实验。亲眼看一看教师的软标签长什么样，感受温度变化对学生训练的影响，再尝试把模型容量缩小、把蒸馏轮数增加，记录精度和多样性的变化。一组简单的对照实验，会比任何宣传话术都更接近真相。

接下来的学习路线也比较清晰：可以先深入理解 KL 散度和交叉熵的关系，接着看 Hinton 关于知识蒸馏的原始论文，再学习特征蒸馏、对比蒸馏、自蒸馏等进阶方向。与此同时，把量化、剪枝和模型结构搜索补齐，才能在实际项目中灵活选择压缩方案。如果你也在项目里遇到过“蒸馏后模型变笨”的情况，欢迎按本文思路做一组对照实验，结果往往比争论更有说服力。