企业官网建设流程全解析

打破你脑海中“优化代码”的惯性——所谓“蒸馏我自己”，在今天的开发语境下，首先是一场针对模型体积、推理成本和工程落地效率的“自我革命”。无论是大语言模型、视觉分类网络，还是你手里那个跑在边缘设备上的小模型，知识蒸馏都是让“大而强”变成“小而准”的关键技术路线。它解决的根本问题，是用训练阶段的繁重成本，换取部署阶段的轻盈体验。

这篇文章会用一条完整的实操链路来回答这个问号：先讲清楚知识蒸馏的本质逻辑，再从一个分类任务的 Teacher-Student 训练入手，写出可运行的 PyTorch 代码，最后给出调参、排错和工程落地建议。读完你会得到一个清晰的判断：什么时候适合“蒸馏”模型，什么时候其实直接剪枝或量化更划算，以及如何在实践中少踩几个坑。

1. 这篇文章真正要解决的问题

在 AI 应用从“demo 能跑”走向“线上可用”的过程里，几乎每个团队都会撞上这堵墙：训练好的模型效果很好，但部署上去要么内存爆了，要么 GPU 卡贵到用不起，要么推理延迟高到用户直接流失。

常见的急救方案有三个：

• 剪枝：把权重矩阵中不重要的连接直接删掉。这种做法简单，但对效果损伤往往大于预期，尤其对 Transformer 这类参数耦合紧密的结构。
• 量化：把 FP32 换成 INT8 甚至 INT4。收益很直观，但极端量化会引入不可忽视的精度下降，且对硬件支持有要求。
• 知识蒸馏：用一个高性能的大模型（Teacher）去指导一个小模型（Student）学习。Student 自己没有能力从复杂数据分布中学到的知识，通过 Teacher 的“软标签”和中间特征被迁移过来。

蒸馏之所以值得单开一篇文章，是因为它和剪枝、量化不在同一个维度。剪枝和量化是在“已有模型”上做手术，蒸馏则是在“训练过程”中动脑筋。换句话说，蒸馏不是在压缩一个已经训练好的模型，而是直接训练一个“天生就小，但见过大模型世面”的模型。

这篇文章不仅讲理论，还要回答四个非常具体的工程问题：

1. 蒸馏后的 Student 模型为什么往往比直接小模型精度更高？
2. 温度系数和软标签到底是怎么起作用的？
3. 一套最简单可运行的蒸馏训练代码长什么样？
4. 什么场景下蒸馏不划算，什么场景下必须依赖蒸馏？

如果你正准备把一个模型推到移动端、浏览器、嵌入式设备，或者只是想了解大模型时代“小模型如何后发先至”，这篇文章应该能帮你少走一段弯路。

2. 知识蒸馏的核心概念与适用场景

2.1 什么是知识蒸馏

知识蒸馏（Knowledge Distillation）最早被广泛熟知，来自 Hinton 等人在 2015 年发表的论文Distilling the Knowledge in a Neural Network。核心思路并不复杂：既然大模型已经收敛到一个相当好的状态，那它对不同类别的输出概率中，就藏着很多“暗知识”。

举个例子，一个图像分类模型面对一张狗的照片，输出概率可能是：

如果只看最终结果，我们只知道“它分对了，是狗”。但对一个训练好的模型来说，这个 0.09 的“狼”概率其实是宝贵的信息——它说明在模型学到的特征空间里，狗和狼有很强的相似性。这种“不确信”的信息，就是软标签（soft label）的一部分。

直接用小模型去学习硬标签，小模型只能学到“狗就是狗”的结论；但让小模型去学习软标签，它就能知道“狗和狼在某种程度上相似，但在猫那里有明显边界”。这种额外监督，就是小模型能获得超越自身参数容量的原因。

2.2 Teacher-Student 结构

蒸馏的典型结构是“教师-学生”（Teacher-Student）：

• Teacher 模型：参数量大、精度高、推理慢。负责在训练阶段产出监督信号。
• Student 模型：参数量小、精度尚可、推理快。负责在部署阶段替代 Teacher，承担实际业务。

这里有一个很容易被误解的点。很多人以为蒸馏是“拿 Teacher 的预测结果当标签去训练 Student”，这只是最表层的一层。更本质的做法，是让 Student 去拟合 Teacher 在 logits 层面的概率分布。这里引入了一个关键操作——温度系数。

2.3 温度系数与软标签

在分类任务中，模型最后一层输出的是 logits，通过 Softmax 变成概率。温度系数 T 被加到 Softmax 的指数项中：

softmax(logits / T)

• 当T = 1时，就是普通 Softmax。
• 当T > 1时，概率分布变得更平缓，各类别之间的差距缩小，Softmax 的输出携带更多“像谁不像谁”的信息。
• 当T < 1时，分布变得更加尖锐，接近 One-hot 硬标签。

蒸馏训练通常使用一个相对较高的温度（比如T = 4或T = 6）来让 Teacher 输出更充分的暗知识。但 Student 推理时不需要看 Teacher，因此推理时仍然使用T = 1。

如果只看表面，很容易误以为“温度系数就是让模型更确信或者更不确信”，但实际上它的作用是调节“知识粒度”。温度太低，软标签退化成硬标签，蒸馏的优势消失；温度太高，概率分布接近均匀分布，学习的信号变成噪声。

2.4 适合蒸馏的场景与不适合蒸馏的场景

适合蒸馏的场景：

不适合蒸馏的场景：

• 没有任何性能预算压力：如果直接部署大模型成本可接受，蒸馏属于多余动作。
• Teacher 本身效果很差：从一个没有学好的模型里蒸馏，只会把错误信息放大。
• 数据量极少：Student 仍然需要数据来拟合 Teacher 的分布。如果连蒸馏所需的数据都没有，训练过程很容易崩溃。
• 已经用了极端的量化方案：在量化之后再做蒸馏，收益会被硬件精度损失抵消，不如直接量化微调。

这个判断标准很重要。因为实际项目中经常出现“为了蒸馏而蒸馏”的情况——团队并不是因为模型太大跑不动，而是听说蒸馏这个名词很热，就想试一试。这种心态最后往往浪费时间。

2.5 离线蒸馏、在线蒸馏与自蒸馏

按照训练方式，蒸馏还可以细分为三类：

• 离线蒸馏：Teacher 提前训练好，训练 Student 时 Teacher 权重固定。这是最常见、最简单、也最稳妥的方式。
• 在线蒸馏：Teacher 和 Student 同时训练，通常由同一个模型的结构扩展而来。适合没有现成强教师模型的场景，但训练稳定性更难控制。
• 自蒸馏：模型把自己的某个较深层的输出作为监督信号，指导较浅层学习。这种方式更接近“自我反思”，在无额外大模型的情况下也能用。

顺便回答标题里那句“什么时候，蒸馏我自己”：当你手上没有资源训练一个更大的 Teacher，只能在一个模型内部做自我压缩时，你实际上已经进入了自蒸馏的范畴。

3. 环境准备与前置条件

为了让你能照着本文跑通整个流程，我们需要准备一个最小可运行的环境。版本信息请以实际项目为准，这里只演示通用思路。

3.1 硬件与系统要求

• 操作系统：Linux / macOS / Windows 均可，推荐 Linux 云服务器。
• GPU：显存 6GB 以上即可（CIFAR-10 这种小数据集，纯 CPU 也能完成演示，只是慢一点）。
• 内存：16GB 以上。

3.2 依赖库

• Python 3.9 或更高版本。
• PyTorch 1.13 或更高版本（2.x 均可）。
• torchvision，用于加载数据集和预训练模型。
• tqdm，用于显示训练进度。

安装命令：

pip install torch torchvision tqdm

如果你有 CUDA 版本的 PyTorch 需求，建议按照 PyTorch 官网给出的命令安装，这里不展开。需要提醒的是：如果是 CPU 环境，后续代码中to(device)会自动切到 CPU，运行时间会明显变长，但逻辑不受影响。

4. 核心流程拆解

整体流程可以拆成五个阶段：

4.1 准备数据集

本文使用 CIFAR-10 数据集，一共 10 个类别，32×32 的彩色图片。这个数据集足够小，适合在单卡甚至 CPU 上演示蒸馏流程。

4.2 定义一个足够强的 Teacher

直接使用一个在 CIFAR-10 上预训练过的 ResNet-50，或者现场快速训练一个。注意：Teacher 的精度必须明显高于 Student 的期望水平，否则蒸馏没有意义。

4.3 定义一个参数规模更小的 Student

这里选择 ResNet-18。它的参数量大约是 ResNet-50 的四分之一左右，推理速度明显更快，但单独训练时在 CIFAR-10 上的精度通常不如 ResNet-50。

4.4 构造蒸馏损失函数

这是整个流程最核心的部分。训练时 Student 同时看两类信号：

• 看硬标签（真实类别）：用交叉熵损失计算。
• 看 Teacher 的软标签：用 KL 散度计算 Student 输出和 Teacher 输出在温度缩放后的分布差异。

总损失 = α × KD损失 + (1 - α) × CE损失

其中 α 是软标签损失的权重，温度 T 是控制知识粒度的超参数。

4.5 训练并与“直接训练小模型”做对比

为了验证蒸馏的有效性，最标准的做法是设置对照组：

• 直接训练 ResNet-18，不引入任何 Teacher。
• 用 ResNet-50 蒸馏 ResNet-18。

如果蒸馏生效，蒸馏后的 Student 在测试集上的精度应该高于直接训练的学生。

5. 完整示例与代码实现

5.1 项目结构

下面是完整的项目文件结构：

distill_demo/ ├── train_teacher.py # 训练教师模型 ├── train_student.py # 蒸馏训练学生模型 ├── train_baseline.py # 无蒸馏直接训练学生模型（对照组） └── models.py # 模型定义

5.2 模型定义与工具函数

文件路径：models.py

import torch import torch.nn as nn import torch.nn.functional as F def get_resnet(num_classes=10, model_name="resnet18"): """返回 torchvision 中的 ResNet 模型""" import torchvision.models as models if model_name == "resnet18": model = models.resnet18(weights=None, num_classes=num_classes) elif model_name == "resnet50": model = models.resnet50(weights=None, num_classes=num_classes) else: raise ValueError(f"Unsupported model: {model_name}") return model def soft_target_loss(student_logits, teacher_logits, temperature): """ 计算 KL 散度形式的蒸馏损失。 这里默认 teacher_logits 和 student_logits 已经除过 temperature。 """ teacher_probs = F.softmax(teacher_logits / temperature, dim=1) student_log_probs = F.log_softmax(student_logits / temperature, dim=1) loss = F.kl_div(student_log_probs, teacher_probs, reduction="batchmean") return loss

从models.py可以看出，ResNet 模型来自 torchvision，num_classes在 CIFAR-10 上取 10。soft_target_loss是蒸馏的关键函数：先对 Teacher 的 logits 做温度缩放并 Softmax，再对 Student 的 logits 做温度缩放并 LogSoftmax，最后计算 KL 散度。

5.3 训练教师模型

文件路径：train_teacher.py

import torch import torch.nn as nn import torch.optim as optim import torchvision import torchvision.transforms as transforms from tqdm import tqdm from models import get_resnet def load_cifar10(batch_size=128): transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2470, 0.2435, 0.2616)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2470, 0.2435, 0.2616)), ]) trainset = torchvision.datasets.CIFAR10( root="./data", train=True, download=True, transform=transform_train) trainloader = torch.utils.data.DataLoader( trainset, batch_size=batch_size, shuffle=True, num_workers=2) testset = torchvision.datasets.CIFAR10( root="./data", train=False, download=True, transform=transform_test) testloader = torch.utils.data.DataLoader( testset, batch_size=batch_size, shuffle=False, num_workers=2) return trainloader, testloader def train_teacher(epochs=30): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") trainloader, testloader = load_cifar10() teacher = get_resnet(num_classes=10, model_name="resnet50").to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(teacher.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4) scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs) for epoch in range(epochs): teacher.train() running_loss = 0.0 for images, labels in tqdm(trainloader, desc=f"Epoch {epoch + 1}"): images, labels = images.to(device), labels.to(device) optimizer.zero_grad() outputs = teacher(images) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() teacher.eval() correct = 0 total = 0 with torch.no_grad(): for images, labels in testloader: images, labels = images.to(device), labels.to(device) outputs = teacher(images) _, predicted = torch.max(outputs, 1) total += labels.size(0) correct += (predicted == labels).sum().item() accuracy = 100.0 * correct / total print(f"Epoch {epoch + 1} | Loss: {running_loss / len(trainloader):.4f} " f"| Acc: {accuracy:.2f}%") scheduler.step() torch.save(teacher.state_dict(), "./teacher_resnet50_cifar10.pth") print("Teacher saved to ./teacher_resnet50_cifar10.pth") if __name__ == "__main__": train_teacher()

这段代码可以拆成两部分理解：

1. load_cifar10负责加载数据并做标准化，同时对训练集做了随机裁剪和水平翻转，这是小数据集上常用的数据增强策略。
2. train_teacher使用标准的 SGD 优化器和 CosineAnnealing 学习率调度，训练结束后保存权重。

运行教师模型训练：

python train_teacher.py

当训练完成后，你会在根目录看到teacher_resnet50_cifar10.pth文件。

5.4 蒸馏训练学生模型

文件路径：train_student.py

import torch import torch.nn as nn import torch.optim as optim import torchvision import torchvision.transforms as transforms from tqdm import tqdm from models import get_resnet, soft_target_loss def load_cifar10(batch_size=128): transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2470, 0.2435, 0.2616)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2470, 0.2435, 0.2616)), ]) trainset = torchvision.datasets.CIFAR10( root="./data", train=True, download=True, transform=transform_train) trainloader = torch.utils.data.DataLoader( trainset, batch_size=batch_size, shuffle=True, num_workers=2) testset = torchvision.datasets.CIFAR10( root="./data", train=False, download=True, transform=transform_test) testloader = torch.utils.data.DataLoader( testset, batch_size=batch_size, shuffle=False, num_workers=2) return trainloader, testloader def train_student_by_distill(epochs=30, temperature=4.0, alpha=0.7): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") trainloader, testloader = load_cifar10() # Teacher 加载提前训练好的权重 teacher = get_resnet(num_classes=10, model_name="resnet50").to(device) teacher.load_state_dict( torch.load("./teacher_resnet50_cifar10.pth", map_location=device)) teacher.eval() # Student 使用轻量模型 student = get_resnet(num_classes=10, model_name="resnet18").to(device) criterion_ce = nn.CrossEntropyLoss() optimizer = optim.SGD(student.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4) scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs) for epoch in range(epochs): student.train() running_loss = 0.0 for images, labels in tqdm(trainloader, desc=f"Distill Epoch {epoch + 1}"): images, labels = images.to(device), labels.to(device) optimizer.zero_grad() student_logits = student(images) with torch.no_grad(): teacher_logits = teacher(images) loss_hard = criterion_ce(student_logits, labels) loss_soft = soft_target_loss(student_logits, teacher_logits, temperature) loss = alpha * loss_soft + (1.0 - alpha) * loss_hard loss.backward() optimizer.step() running_loss += loss.item() student.eval() correct = 0 total = 0 with torch.no_grad(): for images, labels in testloader: images, labels = images.to(device), labels.to(device) outputs = student(images) _, predicted = torch.max(outputs, 1) total += labels.size(0) correct += (predicted == labels).sum().item() accuracy = 100.0 * correct / total print(f"Epoch {epoch + 1} | Loss: {running_loss / len(trainloader):.4f} " f"| Acc: {accuracy:.2f}%") scheduler.step() torch.save(student.state_dict(), "./student_resnet18_distilled.pth") print("Student saved to ./student_resnet18_distilled.pth") if __name__ == "__main__": train_student_by_distill()

关键逻辑在训练循环内：

1. teacher_logits用torch.no_grad()包裹，因为训练 Student 时不需要回传 Teacher 的梯度。
2. loss_hard让 Student 能够继承真实标签的监督力。
3. loss_soft让 Student 去拟合 Teacher 的概率分布。
4. 如果alpha = 0.7，则最终损失中 70% 来自蒸馏信号，30% 来自真实标签。

5.5 训练对照组（不蒸馏）

文件路径：train_baseline.py

import torch import torch.nn as nn import torch.optim as optim import torchvision import torchvision.transforms as transforms from tqdm import tqdm from models import get_resnet from train_teacher import load_cifar10 def train_baseline(epochs=30): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") trainloader, testloader = load_cifar10() student = get_resnet(num_classes=10, model_name="resnet18").to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(student.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4) scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs) for epoch in range(epochs): student.train() running_loss = 0.0 for images, labels in tqdm(trainloader, desc=f"Baseline Epoch {epoch + 1}"): images, labels = images.to(device), labels.to(device) optimizer.zero_grad() outputs = student(images) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() student.eval() correct = 0 total = 0 with torch.no_grad(): for images, labels in testloader: images, labels = images.to(device), labels.to(device) outputs = student(images) _, predicted = torch.max(outputs, 1) total += labels.size(0) correct += (predicted == labels).sum().item() accuracy = 100.0 * correct / total print(f"Epoch {epoch + 1} | Loss: {running_loss / len(trainloader):.4f} " f"| Acc: {accuracy:.2f}%") scheduler.step() torch.save(student.state_dict(), "./student_resnet18_baseline.pth") print("Baseline student saved to ./student_resnet18_baseline.pth") if __name__ == "__main__": train_baseline()

对照组的价值在于回答一个核心问题：Student 精度提升，到底是蒸馏的功劳，还是仅仅因为充分训练？有对照组，你才能用同样的 epoch、同样的数据增强、同样的优化器，做出公平比较。

6. 运行结果与效果验证

6.1 训练顺序

建议按下面的顺序执行：

# 第一步：训练教师模型 python train_teacher.py # 第二步：蒸馏训练学生模型 python train_student.py # 第三步：训练不蒸馏的学生模型 python train_baseline.py

6.2 应该观察什么指标

每次 epoch 结束后，脚本会打印当前 epoch 的平均训练 Loss 和测试集准确率。你应该重点观察两组数据：

1. 蒸馏训练中的 Loss 曲线：loss_soft是否在下降？loss_hard是否在下降？如果loss_soft快速下降但loss_hard异常升高，说明 Student 过于迎合 Teacher 的分布，而忽略了真实标签，此时应降低alpha。
2. 测试集准确率：最终蒸馏模型的准确率应该高于不蒸馏的对照组。如果两者几乎一样，甚至蒸馏更差，需要检查温度参数、教师质量或alpha权重。

6.3 判断蒸馏是否成功的标准

从材料看，一个比较稳妥的判断标准是：

• 蒸馏后的 Student 精度高于不蒸馏 Student 精度 1 到 2 个百分点以上，说明 Teacher 的软标签确实提供了额外信息。
• 蒸馏后的 Student 精度虽然略低于 Teacher，但其推理速度或模型体积远优于 Teacher，说明蒸馏在工程上取得了收益。

更严谨一点，可以同时记录模型的参数量和推理耗时：

# 粗略统计参数量 python -c " import torch from models import get_resnet for name in ['resnet18', 'resnet50']: model = get_resnet(num_classes=10, model_name=name) total = sum(p.numel() for p in model.parameters()) print(f'{name} parameters: {total / 1e6:.2f}M') "

预期输出类似：

resnet18 parameters: 11.18M resnet50 parameters: 23.52M

这个数字会因 torchvision 版本略有变化，不影响整体判断。

6.4 如果失败，第一步应该看哪里

如果蒸馏后的效果反而更差，不要急着调代码，按以下顺序排查：

1. 确认 Teacher 在测试集上的准确率是否足够高。如果 Teacher 本身只有 50% 的准确率，蒸馏就是在传播错误。
2. 确认训练过程中 Teacher 是否处于eval()模式。如果在训练模式下，BatchNorm 统计量会因为前向传播更新而被迫改变，导致输出不稳定。
3. 确认 Softmax 缩放逻辑没有写反。Student 和 Teacher 的 logits 都必须除以同一个温度系数。
4. 确认loss_soft的量级和loss_hard的量级是否一致。如果不一致，alpha的取值会失去语义理解，损失主导权可能失衡。常见做法是先用一个较小的 batch 打印两个损失值，观察它们的数量级差距。

7. 常见问题与排查思路

这些坑在实际项目中几乎都会遇到，尤其是 Teacher 的 eval 问题和损失量级失衡问题，属于“代码逻辑看起来没错，但训练结果就是不对”的经典原因。

8. 最佳实践与工程建议

8.1 选对 Teacher

Teacher 不是越大越好。是否选择大模型，取决于两个约束：

• Teacher 与 Student 的能力差距不能过大。如果一个 Teacher 有 1B 参数，Student 只有 1M 参数，Student 很难真正学会 Teacher 输出的复杂分布，反而容易发生“知识过载”。
• Teacher 在目标域上表现要好。如果你做的是中文文本分类，拿一个英文模型当 Teacher，不仅没有收益，还可能引入语言偏置。

8.2 温度系数按任务调

温度系数没有“万能默认值”，但有一个可复用的经验路线：

• 先固定T = 4跑一组实验。
• 如果 Student 输出太平滑，测试精度偏低，把T往 2 或 3 调。
• 如果 Student 过于自信，欠拟合 Teacher 的分布，把T往 6 或 8 调。
• 在 Kaggle 或学术比赛中，常见做法是对温度做小范围网格搜索，比如[2, 4, 6, 8]。

8.3 alpha 权重跟着阶段走

alpha代表蒸馏损失在总损失中的比例。它不是恒定不变的：

• 训练初期，可以让alpha偏大，让 Student 先学习 Teacher 的分布结构。
• 训练后期，可以逐渐降低alpha，强化真实标签的约束，避免蒸馏把 Student 带偏。

当然，单阶段固定alpha也能跑通，但如果你追求更高的精度上限，可以考虑使用带衰减的动态权重。

8.4 记录实验元数据

蒸馏涉及的变量很多：Teacher 结构、Student 结构、温度、alpha、优化器、epoch、数据增强策略、seed。如果你不做实验记录，几乎不可能复盘出“这次效果为什么好”。

建议在项目里加一个config.json：

{ "teacher": "resnet50", "student": "resnet18", "temperature": 4.0, "alpha": 0.7, "epochs": 30, "batch_size": 128, "optimizer": "SGD", "lr": 0.1, "seed": 42 }

每次实验保存一份配置文件和一份权重文件，文件名包含时间戳或实验 ID。别小看这一步，它能帮你节省大量“重新试错”的时间。

8.5 关注中间层蒸馏

前文演示的是最经典的 logits 蒸馏。实际工程中，只约束最后的输出分布，往往不足以让 Student 学到足够鲁棒的表示。更进阶的方案是让 Student 的中间特征去匹配 Teacher 的中间特征，常见做法是使用 1×1 卷积或线性层将 Student 特征的通道数对齐到 Teacher 特征通道数，再计算 L2 损失或余弦相似度。

8.6 安全与合规提醒

如果你是蒸馏一个已经训练好的大模型，要注意两点：

• 确认模型的授权许可允许你做蒸馏并商用。
• 蒸馏不会自动让模型“获得新的权利”。如果 Teacher 来自他人训练的开源模型，务必检查其许可证对分发、二次修改和商用的约束。

9. 总结与后续学习方向

回到标题那个问题：“什么时候，蒸馏我自己？”

当你面对一个推理代价过高的模型、一个需要部署到边缘设备的项目、一个希望从大模型身上继承经验的小模型时，知识蒸馏就是最值得考虑的技术路径之一。它不是剪枝或量化的替代品，而是与它们互补的训练策略：先通过蒸馏得到一个“小而准”的 Student，再对 Student 做量化或剪枝，往往比直接压缩大模型有更好的效果。

本文把知识蒸馏的最小可运行方案拆成了三个脚本：训练 Teacher、蒸馏 Student、训练 baseline 对照组。你可以直接复制代码跑一次 CIFAR-10 实验，亲手感受温度系数、alpha 权重和 Teacher 质量对结果的影响。跑完这个实验之后，建议沿着下面三条线继续深入：

1. 理解特征层蒸馏：研究 FitNets、Attention Transfer 等方法，了解如何将 Teacher 的空间注意力或中间特征迁移给 Student。
2. 尝试在线蒸馏与自蒸馏：在没有现成大模型的场景下，利用 batch 内样本的交互或模型自身的深层特征完成自我压缩。
3. 组合部署技巧：把蒸馏后的 Student 再做 INT8 量化，记录精度损失和推理加速数据，这会让你对“模型压缩全流程”有更完整的感知。

最后提醒一句：不要在没有性能压力的情况下强行蒸馏。技术选型永远是为业务目标服务的。如果现有模型部署成本已经可接受，那么把时间花在数据迭代和系统稳定性上，可能比追求“更小更准”更划算。希望这篇教程能帮你少走一些弯路，也欢迎收藏备用于你下一次模型瘦身。