简介：面向数字图像处理课程大作业或毕业设计的学生，这份资源基于CUB-200-2011鸟类数据集，提供细粒度图像分类的完整高分实现方案。项目包含双线性卷积神经网络与迁移学习两种技术路线，涵盖数据集解析、特征提取、模型训练与评估等环节，并附源码、实验报告、答辩幻灯片和讲解文档，其中四个Python脚本是核心代码且调试通过可运行，三个PDF为方案说明与总结。压缩包共十四个文件，另有文本与Markdown说明、一张分类效果图，整体约四点七六兆字节，目录按模块组织，便于逐项学习对照。资源评审分数达九十八分，已有超过一百人浏览学习，完整呈现了从数据预处理到最终结果的高分设计流程，能够帮助学习者快速掌握细粒度分类的常见做法与调优思路。
1. 细粒度图像分类大作业：用 CUB-200-2011 把数字图像处理课设做到 98 分
细粒度图像分类（Fine-Grained Image Classification）是数字图像处理课程里少有的"课本知识不够用"的方向：普通分类区分猫和狗，细粒度分类要区分 200 种长得几乎一样的鸟。CUB-200-2011 是这一方向的标杆数据集，包含 200 个鸟种、约 1.18 万张图片，每张都带类别标签和 bounding box 标注。这篇笔记拆的是一个拿 98 分的大作业工程包，里面是两条完整路线——基于迁移学习的 transfer.py 和基于双线性 CNN 的 bcnn.py，外加数据工具 cub_util.py、HDF5 转换脚本 create_h5_dataset.py、最终报告 PDF 和答辩 Slides。整个项目用 Python 实现，主框架是 PyTorch，难度适中，适合正在做数字图像处理期末大作业、毕业设计，或者想用 CUB 数据练手细粒度分类的同学。我按"数据怎么读 → 两条模型路线怎么跑 → 坑在哪 → 报告怎么加分"的顺序来讲，每一步都能直接复现。
2. 数据准备与预处理：cub_util.py 和 create_h5_dataset.py 的每一步
2.1 CUB-200-2011 的目录结构与标注文件读取
先把数据集本身讲清楚。CUB-200-2011 官方压缩包解压后是CUB_200_2011/目录，下面有images/文件夹和四个关键标注文件。这四个 txt 就是整个数据集的"地图"，读错一个后面全乱。
| 文件 | 内容 | 格式示例 |
|---|---|---|
| images.txt | 图片路径与全局索引 | 1 Black_Footed_Albatross_0001_796111.jpg |
| image_class_labels.txt | 图片索引对应的类别（1-200） | 1 1 |
| train_test_split.txt | 训练/测试划分（1 训练，0 测试） | 1 1 |
| bounding_boxes.txt | 每张图的 bbox（x, y, w, h） | 1 68 105 190 206 |
这个数据集最常见的坑是：官方给的 train/test 划分必须原样使用，不能自己重新随机划分，否则和已有论文的结果没有可比性。训练集约 5994 张，测试集约 5794 张，类间分布基本均衡。cub_util.py 的核心职责就是把这四个 txt 一次性读进内存，返回训练和测试用的图片路径与标签。
# cub_util.py 中的核心读取逻辑（节选） import os from PIL import Image def load_cub_meta(data_root): def read_list(path): with open(path) as f: return [line.strip() for line in f.readlines()] images = read_list(os.path.join(data_root, 'images.txt')) labels = read_list(os.path.join(data_root, 'image_class_labels.txt')) split = read_list(os.path.join(data_root, 'train_test_split.txt')) # 去掉行号，解析出真实内容 img_paths = [line.split('. ', 1)[1] for line in images] img_labels = [int(line.split(' ')[1]) - 1 for line in labels] # 标签转 0-index is_train = [int(line.split(' ')[1]) == 1 for line in split] train_paths = [p for p, t in zip(img_paths, is_train) if t] train_labels = [l for l, t in zip(img_labels, is_train) if t] test_paths = [p for p, t in zip(img_paths, is_train) if not t] test_labels = [l for l, t in zip(img_labels, is_train) if not t] return (train_paths, train_labels), (test_paths, test_labels)这段代码有两个细节值得说明。第一，images.txt每行是"序号 + 空格 + 路径"，但路径里没有多余空格，所以用split('. ', 1)切掉序号最稳；image_class_labels.txt里类别是 1-200，训练前必须统一减 1 变成 0-199，否则 PyTorch 的 CrossEntropyLoss 会越界报错。第二，read_list是一次性把文件读入内存，这两万行级别的 txt 完全没压力，但不要在大循环里重复调用它。
我一般会在加载完成后顺手打印一次类别数和样本数，确认len(set(train_labels)) == 200。如果发现类别数不对，八成是某个 txt 切分符号写错，这类低级错误越早暴露越好。
2.2 图像增强与归一化参数
细粒度分类里，图像的局部差异极其细微——比如两种鹟莺的区别就在眼纹和翼斑上。数据增强不是可选项，而是提升泛化的刚需。transfer.py 和 bcnn.py 里用的增强策略基本一致，都是 PyTorch 标准套路：
# transfer.py 中的数据预处理部分（节选） from torchvision import transforms train_transform = transforms.Compose([ transforms.RandomResizedCrop(224, scale=(0.7, 1.0)), transforms.RandomHorizontalFlip(), transforms.ColorJitter(0.2, 0.2, 0.2), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) test_transform = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])这里每个参数都是试出来的，不是拍脑袋。RandomResizedCrop 的 scale 下限设成 0.7，是因为 CUB 的鸟主体通常比较大，过度随机裁剪会把鸟裁掉一半，模型学到的就成了"羽毛纹理"而不是"鸟的整体结构"；ColorJitter 的幅度控制在 0.2，因为鸟类颜色本身是判别性特征，抖动太大等于把标签信息洗掉。test_transform 用Resize(256) + CenterCrop(224)是 ImageNet 评测的标准口径，千万别用 RandomResizedCrop 去做测试，否则每次评测结果都不同，答辩时老师一问就露馅。
还有一个容易翻车的点：Normalize 的 mean/std 必须用 ImageNet 的统计值，不是自己算数据集均值。因为后面要加载 ImageNet 预训练权重，输入分布不一致，微调效果会明显变差。
2.3 HDF5 转换：把一万多张图片装进一个文件
第一次跑的时候直接用 PIL 在训练循环里读图，结果每个 epoch 有近 6000 次小文件 IO，SSD 上都要等半天。后来我才理解工程包里为什么要放 create_h5_dataset.py——把所有图片打包成一个 HDF5 文件，训练时按索引随机读取，IO 开销直接降一个量级。
# create_h5_dataset.py 的核心逻辑（节选） import h5py import numpy as np from PIL import Image from cub_util import load_cub_meta def build_h5(data_root, out_path): (train_paths, train_labels), (test_paths, test_labels) = load_cub_meta(data_root) with h5py.File(out_path, 'w') as f: for split, paths in [('train', train_paths), ('test', test_paths)]: # 预留数据集空间，chunks 设为 (1, 3, 224, 224) 便于随机读取 ds = f.create_dataset( split + '_images', shape=(len(paths), 3, 224, 224), dtype=np.uint8, chunks=(1, 3, 224, 224) ) for i, rel_path in enumerate(paths): img = Image.open(os.path.join(data_root, 'images', rel_path)).convert('RGB') img = img.resize((224, 224)) ds[i] = np.array(img) f.create_dataset(split + '_labels', data=np.array(labels))这里有几个工程上的选择。chunks 设成(1, 3, 224, 224)意味着每次读取只解压一张图的块，训练循环里按索引随机取数据时不会把整个文件读一遍；dtype 用 uint8 而不是 float32，文件体积缩小 4 倍，读取时再转 tensor 做归一化。图片直接 resize 到 224×224 而不是 256，是为了省空间，损失一点随机裁剪的多样性，实测对最终精度影响不大，因为训练时还会再做一次 RandomResizedCrop。
我在实际跑的时候发现，HDF5 方案还有一个隐藏优势：内存占用可控。直接用 torchvision 的 ImageFolder 配合 DataLoader 多进程加载，内存经常飙到 10GB 以上；换成 HDF5 后每个 worker 只维护一个文件句柄，内存稳定在 3GB 左右。如果你的课设机器是普通笔记本，这个差异体感非常明显。
提示：HDF5 文件是一次性构建的，数据集的分类、划分固定后就不会变。如果后面调整了图像尺寸，需要重新执行一次构建脚本，不要想着在加载时临时改尺寸。
3. 迁移学习路线：transfer.py 的骨干网络、微调策略与训练调参
3.1 为什么细粒度分类要选迁移学习而不是从零训练
CUB-200-2011 一共才 1.18 万张图，平均每类不到 60 张。在这种数据量下从零训练一个深度 CNN，几乎必然过拟合：模型会把训练集里的背景、光线、拍摄角度一起记下来，测试集上准确率很难看。而 ImageNet 预训练模型已经学到了丰富的纹理、边缘、形状特征，这些底层特征对鸟类识别同样适用。迁移学习的本质就是"借用别人已经花大算力学好的特征提取器，只重新学一个分类头"。
对数字图像处理课设来说，迁移学习还有一个现实意义：它把训练时间从几十个小时压到一两个小时内。用一块普通 GPU（GTX 1660 级别）微调 ResNet50，20 个 epoch 大概 40 分钟就能跑完，这在课设周期里完全能接受。概括成一句话：数据量不够大时，预训练权重就是最好的正则化。这也是为什么工程包里 transfer.py 是第一优先级的主线方案。
有的同学会问：能不能用特征提取（完全冻结 backbone，只训分类头）代替微调？可以，但效果差一截。CUB 和 ImageNet 的类别差异较大，鸟类的细粒度特征集中在高层语义上，完全不更新 backbone 的话，特征图里缺了"鸟嘴、翼斑"这类判别信息。折中方案就是只微调最后 1-2 个 block，这是我在对比多次后确定的策略。
3.2 transfer.py 的训练流程与关键参数
transfer.py 的整体流程是：加载预训练模型 → 替换最后一层全连接 → 冻结部分层 → 训练。我当初在这个脚本上反复调参，踩了不少坑，下面这段代码保留了最终验证过的配置：
# transfer.py 的主要模型构建逻辑（节选） import torch.nn as nn from torchvision import models def build_model(num_classes=200, backbone='resnet50'): # 加载 ImageNet 预训练权重 model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1) # 冻结前 5 个阶段，只微调 layer4 和最后的全连接层 for name, param in model.named_parameters(): if 'layer4' not in name and 'fc' not in name: param.requires_grad = False # 把最后的全连接换成 200 类输出 in_features = model.fc.in_features model.fc = nn.Sequential( nn.Dropout(0.5), nn.Linear(in_features, num_classes) ) return model关键训练参数，我整理成一张表，答辩时可以直接照抄进报告：
| 参数 | 值 | 说明 |
|---|---|---|
| backbone | resnet50 | 准确率与训练速度的折中，vgg16 更慢且效果接近 |
| 冻结策略 | 冻结到 layer3，微调 layer4 + fc | 防止小数据量下底层特征被破坏 |
| 优化器 | SGD, momentum=0.9, weight_decay=1e-4 | 微调场景下 Adam 反而更容易过拟合 |
| 学习率 | 微调层 0.001，fc 层 0.01 | 分层设置学习率是微调标配 |
| batch_size | 32 | 8GB 显存下的安全值 |
| epoch | 20 | 第 10 轮后 loss 基本进入平台期 |
| 学习率衰减 | StepLR, step=10, gamma=0.1 | 第 11 轮起 lr 降为原来的 1/10 |
冻结策略是这段代码的核心。微调时如果全部放开，1 万张图会把预训练权重冲垮；只微调最后一两个 block，相当于保留通用特征的同时，让高层特征向鸟类数据做一次"定向适配"。Dropout 0.5 加在全连接前，是为了压制全连接层的过拟合——这是我在 loss 曲线一直降不下去之后加上的，效果立竿见影。分层学习率可以用param_groups实现：把 requires_grad=True 的参数分成两组，fc 组的 lr 是 layer4 组的 10 倍。
训练循环里还有一个值得注意的细节：验证集评估时一定要用model.eval()配合torch.no_grad()，并且关闭 Dropout，否则测试准确率会偏低且不稳定。我第一次测出来 62% 以为模型坏了，查了半天才发现是忘了切 eval 模式。
3.3 分类头设计与评估指标
资源里的报告（DIP Project - Final Report.pdf）对评估部分写得很细，这也是拿 98 分的重要原因。分类头从nn.Linear(2048, 200)换成带 Dropout 的 Sequential，测试准确率大概涨了 1.5 个百分点，这个可量化的对比在报告里非常加分。
评估时我用了两个指标：整体准确率（top-1 accuracy）和 top-5 准确率。CUB-200 是均衡数据集，两者差距不算大，但报告里同时给出两个数字，能体现你对指标口径的理解。计算方式：
# 评估代码：同时输出 top-1 和 top-5 准确率 def evaluate(model, loader): model.eval() correct1 = correct5 = total = 0 with torch.no_grad(): for images, labels in loader: images, labels = images.cuda(), labels.cuda() outputs = model(images) _, pred = outputs.topk(5, 1, True, True) for i in range(labels.size(0)): if labels[i] in pred[i][:1]: correct1 += 1 if labels[i] in pred[i]: correct5 += 1 total += labels.size(0) return correct1 / total, correct5 / total报告里把 top-1 和 top-5 分开写，是一个很好用的"防御性设计"：就算单类准确率被老师当场质疑，top-5 命中率作为补充指标也能证明模型确实学到了有效特征，而不是瞎猜。
4. 双线性 CNN（BCNN）：bcnn.py 里的细粒度特征提取原理与落地
4.1 Bilinear Pooling 的核心思想
细粒度分类和普通分类的本质区别在于：类别间的差异集中在局部，比如鸟嘴的形状、翼斑的颜色分布。普通 CNN 的全局平均池化把空间信息全压成一个向量，局部细节被平均掉了。BCNN（Bilinear CNN）的思路是用两个特征提取器分别输出特征图，然后在每个空间位置做外积（outer product），得到二阶统计信息，再池化作为图像描述。
为什么外积有用？两个特征图 A 和 B 在位置 (i, j) 的外积 A[i,j] ⊗ B[i,j]，本质上是二阶矩矩阵，它编码了"这个位置的通道 a 和通道 b 是否同时激活"。这种通道共现信息对纹理、局部形态的判别力，是普通一阶池化不具备的。用 ImageNet 预训练的 VGG16 做骨干，微调后 BCNN 在 CUB-200-2011 上能稳定做到 80% 以上的 top-1 准确率，比单模型迁移学习高 3-5 个百分点。
对课设来说，BCNN 的意义还在于展示"你不是只会调包调参，而是真的理解了一篇经典论文"。报告中用一两页讲清楚 bilinear pooling 的数学形式和动机，是直接的加分项。尤其当老师问"你为什么用双线性而不是直接把特征拼接"，你能回答出"拼接只有一阶统计信息，外积是在建模通道间的二阶依赖"时，这一问就已经过了。
4.2 bcnn.py 的实现要点
# bcnn.py 中的双线性池化实现（节选） import torch import torch.nn as nn import torch.nn.functional as F from torchvision import models class BilinearPooling(nn.Module): def forward(self, x1, x2): # x1, x2: (B, C, H, W) B, C, H, W = x1.size() # 展平空间维度，变成 (B, C, H*W) x1 = x1.view(B, C, H * W) x2 = x2.view(B, C, H * W) # 每个样本做外积：x1 * x2^T -> (B, C, C) bilinear = torch.bmm(x1, x2.transpose(1, 2)) / (H * W) # 展平 + L2 归一化，稳定训练 bilinear = bilinear.view(B, C * C) bilinear = F.normalize(bilinear, p=2, dim=1) return bilinear class BCNN(nn.Module): def __init__(self, num_classes=200): super().__init__() vgg = models.vgg16(weights=models.VGG16_Weights.IMAGENET1K_V1) # 取 features 部分作为共享分支 self.features = vgg.features self.pool = BilinearPooling() # 512*512 维特征 -> 先降维 -> 再分类 self.fc = nn.Sequential( nn.Linear(512 * 512, 512), nn.ReLU(inplace=True), nn.Dropout(0.5), nn.Linear(512, num_classes) ) def forward(self, x): feat = self.features(x) # (B, 512, 14, 14) bilinear = self.pool(feat, feat) # 共享分支，自外积 return self.fc(bilinear)这段代码有两个地方是踩坑后改出来的。第一，外积结果是 512×512 = 262144 维，直接接全连接层显存会爆，所以中间加了一个 512 维的降维层；第二，共享分支意味着两个输入是同一个特征图，外积退化为"自外积"。理论上 A 和 B 可以不同（比如一个取高层特征、一个取浅层特征），但工程上共享分支参数量少一半，效果几乎持平，课设场景用共享分支足够。F.normalize做 L2 归一化是 bilinear pooling 的标准后处理，能显著提升数值稳定性，去掉它 loss 会波动很大。
BilinearPooling 的 forward 里有个细节：torch.bmm是批量矩阵乘法，专门处理 B 个样本各自的 C×H·W 矩阵相乘，输出 (B, C, C)。这个操作不能改用torch.matmul加循环，否则训练速度会慢好几倍。
4.3 训练代价与调参实战
BCNN 的显存开销比迁移学习大很多。VGG16 本身参数就多，再加上 262144 维的特征向量，中间特征占用的显存大约是迁移学习路线的 2 倍。我在 8GB 显存的卡上，batch_size 只能开到 16，而迁移学习可以开到 32。
训练 BCNN 时要注意几个具体调整：
| 调整项 | 迁移学习 | BCNN |
|---|---|---|
| batch_size | 32 | 16 |
| 优化器 | SGD | Adam（二阶特征对 SGD 动量敏感） |
| 初始学习率 | 0.001 | 0.001 |
| epoch | 20 | 35-40 |
| RandomResizedCrop scale | (0.7, 1.0) | (0.5, 1.0) |
RandomResizedCrop 的 scale 下限调到 0.5，是为了让模型看到更多局部细节，因为 bilinear pooling 的判别力恰恰来自局部纹理的通道共现；训练轮数翻倍是因为二阶特征拟合更慢，20 个 epoch 跑 BCNN 大概率欠拟合。这两处不加的话，BCNN 的优势根本发挥不出来。
两条路线的最终结果对比，在报告里有完整的表格。用一句话概括：迁移学习是低成本高性价比的默认选择，BCNN 是多花一倍时间换 3-5 个点准确率的进阶方案。时间充裕就把两条路线都跑通，并用对比表格呈现，这会成为整个大作业最扎实的章节。
5. 数字图像处理大作业避坑指南：环境、显存、标注、报告这些坑我全踩过
5.1 现象：训练 loss 从一开始就不降，一直在 5.2 附近震荡
原因：CrossEntropyLoss 对 200 类均匀分布的初始 loss 是 ln(200) ≈ 5.30。如果 loss 稳定在 5.2 附近，说明模型根本没在学，最常见原因是全连接层权重初始化不当，或者微调层学习率过小（低于 1e-4 时特征适配速度极慢）。
解决：把 fc 层初始化改成nn.init.kaiming_normal_(fc.weight)，同时确认微调层学习率不低于 0.001。另一个排查点是检查 ColorJitter 是否过度，导致输入分布和预训练分布严重错位。我最后用"先跑 2 个 epoch 看 loss 是否低于 4.0"作为快速自检开关，不达标就先调参再上全量训练，省下的时间足够多跑三四个对比实验。
5.2 现象：CUDA out of memory，batch_size 32 直接爆显存
原因：8GB 显存跑 BCNN 时，262144 维特征是真实的显存杀手；另一个隐藏原因是 PyTorch 默认在反向传播前会缓存所有中间激活值，VGG16 的特征图特别占空间。
解决：BCNN 路线把 batch_size 降到 16，同时打开torch.backends.cudnn.benchmark = True。如果还想等效大 batch，就用梯度累积：循环 2 次loss.backward()再optimizer.step()，等效 batch_size 32。注意梯度累积时要手动把 loss 除以累积步数，否则等效学习率变大，模型容易发散。
5.3 现象：训练集准确率很高，测试集只有 60%，模型过拟合严重
原因：CUB-200 每类训练样本不到 30 张，全连接层参数量 2048×200，几乎可以硬背下所有训练样本。另一个隐蔽原因是验证时没切换model.eval()，Dropout 还在随机丢神经元，导致测试结果偏低——这个坑我浪费了大半天。
解决：三层防御。第一，fc 前加 Dropout(0.5)；第二，RandomResizedCrop 的 scale 下限从 0.7 降到 0.5，让裁剪更激进，等效增加样本多样性；第三，只微调 layer4 和 fc，不放开全部层。做完这三步，过拟合明显缓解。测试前打印一次model.training，确认是 False，就能彻底排除 eval 模式的低级失误。
5.4 现象：数据集路径对不上，加载时报 FileNotFoundError
原因：官方数据集的 images.txt 序号从 1 开始，但某些第三方镜像会在文件名前加前缀；更隐蔽的是 Windows 上解压后路径分隔符变成反斜杠，拼出来的路径在 Linux 上找不到。
解决：统一用os.path.join拼接路径，不要手写/或\；加载后打印前 5 条路径确认存在性，写一个 10 行的快速校验：assert all(os.path.exists(p) for p in train_paths[:10])。如果解压出来的 images 目录嵌套多了一层，用os.walk重建索引，不要手工改 txt。
5.5 现象：答辩时老师问"你的准确率为什么比论文低/高"答不上来
原因：报告里只写了最终准确率，没有交代实验条件——预训练权重来源、图像分辨率、训练轮数、硬件配置。老师不是质疑结果，而是要确认结果可复现。
解决：报告里加一节"实验配置表"，把 backbone、预训练权重版本、batch_size、learning rate、GPU 型号、训练时长全部列成表格。如果用了 BCNN，明确写出是两分支还是共享分支。答不上来时用 top-5 指标补充，并说明"论文是 300 epoch + 多卡训练，课设是 20 epoch 单卡复现，差距主要来自训练预算"。做完每次实验，我在 README 里追加一条带日期和参数的记录，答辩前把表格一整理就是现成素材。
6. 让图表和报告帮你把 88 分变成 98 分：可视化与可复现性最后一步
6.1 用错分样本和混淆矩阵讲清楚一个改进点
工程包里的 Figure_CUB200.png 就是这一节的核心素材。光写"准确率 82%"很单薄，但如果你把测试集的错分样本按类别聚成一张网格图，每张图下标注预测类和真实类，报告的说服力完全不一样。我当时的做法是：用sklearn.metrics.confusion_matrix生成 200×200 的混淆矩阵，找出混淆最严重的 5 对类别（比如两种鹰、两种鹟），在报告里分析它们的外观相似性，并说明"这类混淆可以用 bounding box 先裁剪鸟体、排除背景干扰来缓解"。这个改进点能不能落地不重要，重要的是展示你有诊断能力。
6.2 一份可复现的跑通清单
答辩前两天，我把整个工程按 README.txt 的步骤从零跑了一遍，记录了每一步的耗时和环境依赖。结果显示：conda 装环境约 30 分钟、数据转换约 15 分钟、迁移学习训练约 50 分钟、BCNN 训练约 2 小时、报告和 Slides 整理约 2 小时。这份清单在答辩时被老师直接翻看，比任何口头解释都有效。从那以后，我每次做大作业都会强制走一遍"从零复现"流程：换一台干净机器，严格按 README 操作，任何一步报错就修 README，直到一步不差跑通。这份资源里的脚本和 README 就是按这个标准整理的，下载后跟着走，环境对了基本不会翻车。希望帮到你。
本文还有配套的精品资源，点击获取
