IRG知识蒸馏实战：用特征关系图将ResNet50压缩进ResNet18

简介：知识蒸馏IRG算法实战配套源码包，面向具备一定深度学习基础、希望掌握特征蒸馏与模型压缩技巧的研究者与工程师。资源围绕ResNet50作为教师网络、ResNet18作为学生网络的IRG蒸馏流程，提供完整的Python实现与中间结果，可辅助理解知识蒸馏中的特征图对齐与关系建模机制，同时可作为论文复现、毕业设计或模型轻量化实践的参考资料。压缩包内文件超过2000个，整体约930.95MB，以2400余张训练及蒸馏过程的可视化png图片为主，另有7个py脚本、4个json结果文件、3个pyc与1个txt说明，便于对照代码与输出逐步复盘。包内包含result_kd.json、result_student.json等关键输出，可直接查看教师、学生与蒸馏模型的精度差异。目前已有720人学习下载，适合用于课程设计、算法对比或作为IRG蒸馏的参考实现。

1. 压缩延迟而不是压缩参数：知识蒸馏的第一性原理

大多数人找知识蒸馏，是想把 ResNet50 的精度装进 ResNet18 里。真正动手调过一轮的人会发现：瓶颈不在最后的分类权重，而在特征图之间的结构关系没有完成迁移。IRG 算法和传统 KD 的差别就在这里——它不要求学生模仿教师输出的类概率，而是要求学生在同一张图像内部重建空间位置之间的相似关系，同时重建同一 batch 内不同图像之间的相互关系。这份实战资源以 ResNet50 为教师、ResNet18 为学生，完整跑了一遍 IRG 蒸馏流程，训练结束后沉淀出 result.json、result_student.json、result_kd.json 三个结果文件和六张训练曲线图。把结果文件与 IRG 损失实现对照着拆一遍，能直接复用到后续轻量模型替换线上服务的目标上，适合已经掌握基础分类训练、想在部署端压缩模型体积的工程师。

2. IRG 拆解与实验环境准备

2.1 logits 蒸馏在学生网络上的短板

传统知识蒸馏的做法很简单：训练完教师网络后，用温度参数 T 软化 logits，再让学生网络同时拟合真实标签和软化后的教师输出。损失可以写成：

L_KD = alpha * L_CE(y, p_s) + (1 - alpha) * T^2 * KL(softmax(z_t / T), softmax(z_s / T))

这个方案在输出空间比较规整的任务里效果好，但问题也很直观：logits 是分类头输出的一维向量，输入图像的空间结构到这一步已经被全局池化抹平。学生拿到的只是“类别与类别之间的软边界”，丢失的是“特征图上每个位置和周围位置如何组织”的信息。ResNet18 的层数比 ResNet50 浅，特征提取能力弱，单独训练时很容易陷入局部解，靠 KL 项只能修正输出分布，无法修正中间表示。

IRG 算法选择从特征图层面做迁移，它把教师特征图拆成两类关系：

• intra-instance 关系：把特征图每个空间位置当作一个实例，也就是一个 C 维向量，求所有位置两两之间的内积相似度，得到 N×N 的关系矩阵，N=H×W。
• inter-instance 关系：把每张图都当成一个实例，先取全局平均得到一个 C 维向量，再计算 batch 内图像两两之间的相似度，得到 B×B 的关系矩阵。

前一个保存的是空间组织方式，后一个保存的是样本间的上下文，再加上一个可学习的变换层用来消除学生特征通道数与教师不一致的问题，这三块合起来才是 IRG 的完整损失。用一句话概括：教师教学生“图像内在结构的相似方式”，而不是“最终答案的软性边界”。这也是为什么 IRG 在深层特征蒸馏上的表现常常好过 logits 蒸馏。

2.2 工程环境与文件目录

动手复现之前要先确认环境。这份资源整体定位在 PyTorch 生态，依赖主要是 torch、torchvision、matplotlib 、tqdm 和 json。

conda create -n irg python=3.9 -y conda activate irg pip install torch torchvision matplotlib tqdm python -c "import torch; print(torch.__version__)"

我一般建议 Python 3.9 以上，PyTorch 2.x 版本默认带自动混合精度接口，训练时能有效降低显存占用。教师网络用 ResNet50，前向和梯度计算都比较吃显存，8GB 显存起步才比较舒服。显存不足时，可以把 batch size 从 64 降到 32，或者把输入分辨率从 224×224 降到 160×160，在数据增强阶段用 Resize 处理，不需要改模型结构。

注意：如果只用 CPU 跑，IRG 蒸馏会非常慢。ResNet50 教师一次前向在 CPU 上大约需要几百毫秒，一个 epoch 几百张图就要跑几十分钟，建议至少准备一块消费级 GPU。

解压资源包后，目录结构大致如下：

├── result.json ├── result_student.json ├── result_kd.json ├── class.json ├── 77291b3ad.png ├── 5a8b75712.png ├── 5e4d1ee0d.png ├── 5d358beb9.png ├── 8029e3396.png └── 14719a83e.png

三个 JSON 文件的角色不一样，先把用途对齐：

六张 PNG 是训练过程中的准确率和损失曲线，文件名末尾 8 位是本次运行的随机哈希 ID。后面章节我会按这三个 JSON 的字段结构去复现训练，并把日志写回同样的格式。

3. 用 torchvision 加载 ResNet50 与 ResNet18：骨干特征提取器实现

3.1 去掉分类头，保留 layer4 输出

先看 ResNet50 和 ResNet18 在网络结构上的差异。ResNet50 使用的是 bottleneck 残差块，层数更深，每个 block 包含 1×1、3×3、1×1 三个卷积，整体通道数在 layer4 输出时是 2048；ResNet18 使用的是 basic block，每层只有两个 3×3 卷积，layer4 输出通道数是 512。两者最后的分类头结构相同，但特征提取部分的宽度和深度完全不是一个量级。

用 torchvision 加载模型时，要注意把最后的 avgpool 和 fc 拿掉，只保留卷积骨干部分：

import torch import torch.nn as nn from torchvision import models def build_backbone(name: str, pretrained: bool = True) -> nn.Module: """返回去掉分类头的卷积骨干，输出的是 layer4 特征图。""" net = getattr(models, name)(pretrained=pretrained) children = list(net.children()) # ResNet 的 children 顺序： # conv1, bn1, relu, maxpool, layer1, layer2, layer3, layer4, avgpool, fc return nn.Sequential(*children[:-2]) # 丢弃 avgpool 与 fc teacher_backbone = build_backbone("resnet50").cuda().eval() student_backbone = build_backbone("resnet18").cuda().train()

在 224×224 输入下，ResNet50 得到的是 B×2048×7×7 特征图，ResNet18 得到的是 B×512×7×7。通道数不同，但空间尺寸一致，正好适合用关系矩阵做对齐。

教师网络加载后要锁住参数。很多新手只调用model.eval()就以为不会更新了，这是不对的，eval 只改变 BatchNorm 和 Dropout 的行为，参数的requires_grad仍然是 True。稳妥做法是显式冻结：

for p in teacher_backbone.parameters(): p.requires_grad = False

student 侧虽然也可以加载 torchvision 的预训练权重，但后续要整体参与反向传播，requires_grad保持默认的 True 即可。

3.2 用相似度矩阵定义 IRG 关系图

IRG 的核心是两个相似度函数。第一个算样本内部的空间关系，第二个算样本间的关系：

def intra_similarity(feat: torch.Tensor) -> torch.Tensor: """把每个空间位置当成一个实例，计算位置间的相似度矩阵。""" b, c, h, w = feat.shape vec = feat.flatten(2).transpose(1, 2) # B, N, C vec = vec / (vec.norm(dim=-1, keepdim=True) + 1e-8) sim = torch.bmm(vec, vec.transpose(1, 2)) # B, N, N return sim / (c ** 0.5) def inter_similarity(feat: torch.Tensor) -> torch.Tensor: """把整张图当成一个实例，计算 batch 内图像的相似度矩阵。""" g = feat.mean(dim=[2, 3]) # B, C g = g / (g.norm(dim=-1, keepdim=True) + 1e-8) return torch.mm(g, g.t()) # B, B

feat.flatten(2)把 H×W 拉平成一个 N=H×W 的序列，转置后变成 B×N×C，也就是每个空间位置一个 C 维向量。归一化后做矩阵乘法，得到 B×N×N 的相似度矩阵。除以c ** 0.5是为了把数值规模控制在合理范围，避免通道数增大时内积结果爆炸。

inter_similarity里先做全局平均池化，得到每张图的全局描述符，归一化后再做矩阵乘法，得到 B×B 的批内相似度。这两个矩阵的维度都和通道数 C 无关，所以 ResNet50 的 2048 维与 ResNet18 的 512 维不会挡路，这是选择关系矩阵做蒸馏的核心原因。

关系矩阵的具体形状对比如下：

3.3 蒸馏损失与分类损失的组合

两个关系矩阵都算出来后，用 MSE 做匹配：

import torch.nn.functional as F def irg_loss(feat_t: torch.Tensor, feat_s: torch.Tensor) -> torch.Tensor: """计算教师与学生特征图之间的 IRG 距离。""" intra_t, intra_s = intra_similarity(feat_t), intra_similarity(feat_s) inter_t, inter_s = inter_similarity(feat_t), inter_similarity(feat_s) return F.mse_loss(intra_t, intra_s) + F.mse_loss(inter_t, inter_s)

分类还是走学生自己的分类头，注意feat_s是卷积特征图，要先做池化再进入全连接：

student_head = nn.Linear(512, num_classes).cuda() feat_t = teacher_backbone(images) feat_s = student_backbone(images) logits_s = student_head(F.adaptive_avg_pool2d(feat_s, 1).flatten(1))

最后组合成总损失：

loss_cls = F.cross_entropy(logits_s, labels) loss_kd = irg_loss(feat_t.detach(), feat_s) loss = loss_cls + 0.3 * loss_kd

feat_t.detach()是关键，教师特征不进入自动求导，IRG 损失反向传播时只会更新学生与后续层的参数。lambda 取 0.3 是因为 IRG 损失经过归一化后量级通常在 0.1~1.0 之间，这个初始值不会压过 CE 损失。等训练中期 val acc 停滞时，再把 lambda 调到 0.5 甚至 1.0，这样能避免一开始就把学生特征逼得太死。

4. 蒸馏训练循环：从 loss 加权到 result_*.json 落盘

4.1 数据加载与类别索引写入

这份资源的训练流程分三段：先用 ResNet50 独立训练并记录 result.json，然后在不改教师权重的情况下跑 IRG 蒸馏，得到 result_kd.json，最后再单独训练一个 ResNet18 作为 baseline，得到 result_student.json。三段共用同一套训练函数，只是 loss 配置不同。

数据加载使用 ImageFolder 组织最直接，类别名从子目录自动解析，这个映射就是 class.json 的来源：

from torchvision.datasets import ImageFolder from torchvision import transforms train_transform = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) train_set = ImageFolder("data/train", train_transform) train_loader = torch.utils.data.DataLoader( train_set, batch_size=64, shuffle=True, num_workers=4, pin_memory=True)

启动训练前，把类别索引 dump 成 class.json：

import json with open("class.json", "w", encoding="utf-8") as fp: json.dump(train_set.class_to_idx, fp, ensure_ascii=False, indent=2)

class_to_idx是 ImageFolder 按文件夹名称自动生成的字典，顺序和模型输出的 logits 索引严格对应。如果自己写数据集类，也要保证 label 的编码顺序与这里的 class.json 一致，否则后面解读 result_kd.json 时会把类别对应错。

4.2 完整蒸馏训练循环

以蒸馏段为例，需要把教师网络固定住，学生网络和投影层一起训练。把学生网络封装成一个类，一次前向同时返回特征图和 logits，避免重复计算特征：

class StudentNet(nn.Module): def __init__(self, num_classes: int): super().__init__() self.backbone = build_backbone("resnet18", pretrained=True) self.head = nn.Sequential( nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.Linear(512, num_classes), ) def forward(self, x): feat = self.backbone(x) logits = self.head(feat) return feat, logits

训练循环主体：

from tqdm import tqdm optimizer = torch.optim.SGD( student.parameters(), lr=0.01, momentum=0.9, weight_decay=5e-4) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( optimizer, T_max=max_epoch) for epoch in range(max_epoch): student.train() teacher_backbone.eval() total_loss, correct, total = 0.0, 0, 0 for images, labels in tqdm(train_loader): images, labels = images.cuda(), labels.cuda() with torch.no_grad(): feat_t = teacher_backbone(images) feat_s, logits_s = student(images) loss_cls = F.cross_entropy(logits_s, labels) loss_kd = irg_loss(feat_t.detach(), feat_s) loss = loss_cls + 0.3 * loss_kd optimizer.zero_grad() loss.backward() optimizer.step() total_loss += loss.item() * images.size(0) correct += (logits_s.argmax(dim=1) == labels).sum().item() total += images.size(0) train_acc = 100.0 * correct / total print(f"epoch {epoch} train_loss {total_loss / total:.4f} train_acc {train_acc:.2f}")

每次迭代都单独算loss_cls和loss_kd，建议打印出来观察数值。IRG 关系损失在训练初期通常从 0.5 左右开始下降，如果发现它不降反升，说明学生特征和教师特征的空间组织方式差距在拉大，优先检查 teacher 是否被意外训练。

注意：教师网络用了eval()后，BatchNorm 里的 running_mean 和 running_var 不会更新，这能保证同一个 batch 的输入在每次迭代中得到稳定的特征输出。如果教师是用完全随机初始化训练的，这里 resolve 会明显变差，建议先让教师在自己的训练任务上收敛到 90% 以上再开始蒸馏。

4.3 逐 epoch 写 JSON，中断不丢进度

训练日志有两种常见写法：整个 list 最后一次写，或者每个 epoch 追加写。如果训练中途断掉，最后一次写会丢失全部历史记录，所以推荐每次 epoch 结束都把记录追加进同一个数组再覆盖写入：

import os import json def write_history(path: str, record: dict): prev = [] if os.path.exists(path): with open(path, "r", encoding="utf-8") as fp: prev = json.load(fp) prev.append(record) with open(path, "w", encoding="utf-8") as fp: json.dump(prev, fp, ensure_ascii=False, indent=2)

每个 epoch 验证后写入一条记录，字段保持统一：

record = { "epoch": epoch, "train_loss": round(train_loss, 4), "train_acc": round(train_acc, 2), "val_acc": round(val_acc, 2), "lr": round(optimizer.param_groups[0]["lr"], 6), } write_history("result_kd.json", record)

这样既保留完整训练历史，也方便训练完成后一次性读回整个 JSON 列表。训练 result.json 时，把 irg_loss 去掉、只留 cross_entropy 就可以复用同一套函数；训练 result_student.json 时则完全不加载教师网络，模型结构和 result_kd 一致，只差 loss 配置不同。三段训练产出三个 JSON，就形成了后面要用的完整对照组。

5. 训练日志与预测文件的读取方式：把 kd 的效果量化出来

5.1 JSON 字段语义与结构防御

资源包里的 result_kd.json、result_student.json、result.json 基本是同一个结构，可能包含两种形态：一种是 list，里面每个元素是一个 epoch 的记录；另一种是单个 dict，只在训练结束时写入了最优结果。读取前先做类型判断，避免直接 index 报错：

import json def load_metric(path: str): with open(path, "r", encoding="utf-8") as fp: data = json.load(fp) if isinstance(data, dict): return [data] # 统一转成 list return data res_teacher = load_metric("result.json") res_student = load_metric("result_student.json") res_kd = load_metric("result_kd.json")

一条典型记录长这样：

[ {"epoch": 80, "train_loss": 1.083, "train_acc": 89.71, "val_acc": 88.04, "lr": 0.0012}, {"epoch": 81, "train_loss": 0.981, "train_acc": 90.29, "val_acc": 88.95, "lr": 0.0009} ]

如果训练脚本在验证集上返回的是准确率百分比，val_acc 字段直接用百分数数值；如果返回 0~1 之间的小数，读取后要乘 100。两种写法在资源包里都可能出现，习惯上我在写日志时统一转成百分比，避免画图时还要做单位换算。

5.2 三模型对比脚本

拿到三个 list 后，取各自最好的 val_acc 作为最终指标：

best_teacher = max(res_teacher, key=lambda r: r["val_acc"]) best_student = max(res_student, key=lambda r: r["val_acc"]) best_kd = max(res_kd, key=lambda r: r["val_acc"]) print(f"Teacher ResNet50 {best_teacher['val_acc']:.2f}") print(f"Student ResNet18 base {best_student['val_acc']:.2f}") print(f"Student ResNet18 IRG {best_kd['val_acc']:.2f}")

判断蒸馏是否生效，核心不是看 kd 有没有超过 teacher，而是看两点：kd 是否同时高于 student 的 baseline，以及 kd 是否比 baseline 更接近 teacher。如果出现 kd 反而比 baseline 低的情况，先检查训练阶段是否真的加载了教师特征做约束，再看 IRG loss 是否在持续下降。

5.3 用 matplotlib 重新绘制训练曲线

资源包自带了六张 PNG，但那些图是训练完成时生成的。如果你想调整对比维度，比如把 teacher、student、kd 三条曲线画进同一张图，可以用下面的脚本重新出图：

import matplotlib.pyplot as plt epochs = [e["epoch"] for e in res_kd] plt.plot(epochs, [e["train_acc"] for e in res_kd], label="train (kd)") plt.plot(epochs, [e["val_acc"] for e in res_kd], label="val (kd)") plt.plot(epochs, [e["val_acc"] for e in res_teacher], label="teacher val") plt.plot(epochs, [e["val_acc"] for e in res_student], label="student val") plt.legend() plt.xlabel("epoch") plt.ylabel("acc(%)") plt.savefig("kd_compare.png", dpi=150, bbox_inches="tight")

注意：如果 result.json 里是单个 dict 而不是 list，那它没有逐 epoch 记录，画不了完整曲线。解决的笨办法是写日志时就从开始阶段逐个 epoch 写入，不要只保留最后结果。

曲线图最容易暴露的问题是过拟合：train acc 一路上扬而 val acc 在某 epoch 掉头，说明学生网络已经开始记住训练集噪声，此时应该降低学习率或增大 weight decay，不要急着调蒸馏权重。

6. 从 ResNet 迁移到移动端网络：三个动作实战

如果只想在公开数据集上复现一个数字，前面的内容已经够了。真正到工程里，大多数人要换的不会是 ResNet18，而是体积更小、延迟更低的移动端网络。这时候原来代码里隐藏的两个前提都会被打破：学生特征图的空间尺寸可能和教师不一致，学生通道数也会跟教师差出好几倍。迁移时我一般做三个动作。

6.1 特征层空间尺寸不一致时先对齐

假如学生网络改成 MobileNetV3，经过 head 部分的卷积组合，输出特征图在 224×224 输入下可能得到 14×14 而不是 ResNet50 的 7×7。IRG 的 intra 关系矩阵是 N×N，N 不一致时维度对不上，必须先把两边的特征拉平到同一尺度再算关系：

import torch.nn.functional as F if feat_s.shape[2] != feat_t.shape[2]: feat_s = F.interpolate( feat_s, size=feat_t.shape[2:], mode="bilinear", align_corners=False, )

bilinear 插值会改变特征图内部的空间结构，因此对学生和教师要做同样的变换，避免关系损失在数值上被插值噪声主导。另一个更省事的做法是把关系矩阵改成固定尺寸输出，比如对空间位置做下采样后再建图，但这会增加实现复杂度。

6.2 通道不匹配时用 1×1 卷积过渡

通道数不一致不会直接让 IRG 失效，因为 intra 和 inter 相似度先做了 L2 归一化，C 的差异会被消掉一部分，但实验里效果通常会差一点。更稳的做法是给学生特征接一个通道投影：

self.projector = nn.Conv2d(student_channels, teacher_channels, 1)

这样学生 backbone 的一层特征经过投影后再和教师特征算相似度矩阵，收敛速度通常比直接归一化快 10%~20%。投影层消耗的参数量不大，student 特征从 256 上到 2048 时，参数大约 52 万个，在总模型里基本可以忽略。投影层要和 student backbone 一起训练，不要冻结。

6.3 验证新方案是否真正生效

每回迁移都值得先回到一个原则：蒸馏的收益上限是 teacher 和 student 之间的能力差。如果教师和学生单独训练的 val acc 只差 0.5 个点，IRG 再调也补不出显著提升。我在实验流程里会先训练前记录两个网络的 baseline，再跑 KD 训练，最后用一段脚本把三个 JSON 文件拉到同一张图上对比：

print(f"teacher: {best_teacher['val_acc']:.2f} student: {best_student['val_acc']:.2f} kd: {best_kd['val_acc']:.2f}")

如果 kd 的精度没有同时高于 student 且逼近 teacher，就要回去检查 relation loss 是否真的在下降，而不是只看总 loss。IRG 的单个关系 loss 在稳定收敛后通常低于 0.3，高于这个值基本说明学生还没学到空间关系，可行做法是增大 projector 的学习率或加一层 BN，而不是继续调 lambda。

本文还有配套的精品资源，点击获取