简介：这是一份面向高校课程设计或深度学习入门者的花卉识别工程，围绕花卉图像自动分类这一任务，涵盖数据读取与划分、模型构建、训练测试和结果可视化等环节。压缩包共49个文件、约3.36MB，主体为15个jpg与13个png花卉样本、12个Python源码，并包含Git忽略文件、Markdown说明、训练与测试日志等辅助内容，可作为从数据预处理到CNN/MobileNet迁移学习实践的可运行参考。工程在传统卷积神经网络之外，还提供MobileNet模型测试与热图可视化代码，便于对比不同结构的识别效果，并通过训练日志和结果图定位过拟合等问题，帮助复现实验与分析模型关注区域。资源目前已有363人学习，对正在完成图像识别类课程设计或希望快速上手深度学习流程的读者，是一份结构清晰、即下即用的实战资料。
1. 花卉识别课程设计值不值得选：为什么这套 Python 深度学习源码比管理系统更有答辩优势
对 Python 深度学习入门者来说，花卉识别几乎是课程设计里「下限最低、上限却很高」的题目。数据是公开的、任务是一个标准图像分类问题、结果能可视化，答辩时评委看得懂，你也讲得清，不像隔壁那种 Java 课程设计案例源码的管理系统，除了增删改查很难聊出深度。但别高兴太早，每年都有学生拿着完整源码跑不出效果：loss 不降、val acc 卡在 30%、换一张真实照片就识别错。问题基本出在两个地方——数据划分不干净，以及迁移学习的学习率配置不对。这篇就把从数据准备到训练、评估、答辩可视化的完整路径讲透。
2. 先定方案再碰代码：迁移学习 + CNN 的选型逻辑与最小模型替换
2.1 花卉识别本质是细粒度图像分类，普通分类思路会吃亏
先想清楚这个题目在技术上属于哪一类。花卉识别不是一个常见的「猫 vs 狗」粗粒度分类，102 类花卉里大量存在外观高度相似的品种，比如玫瑰、月季、蔷薇放在一起，普通人分辨都要犹豫，模型要能抓到花瓣纹理、花蕊结构、叶片边缘这些局部差异。这类问题在深度学习里叫细粒度图像分类，难点在于类间差异小、类内差异反而大：同一朵花不同角度、不同光照下差别可能比不同品种还明显。
也就是说，你不能指望一个随机初始化的浅层网络能直接学会这种分辨能力。这也是为什么同样用 CNN，有人三小时训出 90% 准确率，有人训到虚脱还在 40% 徘徊——差距不在「你有没有用深度学习」，而在你有没有用对别人已经训练好的视觉先验。
2.2 从零训练、冻结微调、全面微调：三种方案的代价与上限
课程设计阶段，主流做法有三种，我把它们在 102 类花卉数据集上的表现预期、训练时长和踩坑程度列出来：
| 方案 | 数据需求 | 训练时长（单卡） | 预期 top-1 准确率 | 主要风险 |
|---|---|---|---|---|
| 从零训练小型 CNN | 至少 5 万张，需自采或大量增强 | 3–6 小时 | 40%–60% | 过拟合、训练不收敛 |
| 冻结骨干 + 只训练分类头 | 每类 20 张即可起步 | 20–40 分钟 | 60%–75% | 上限低，特征不够细分 |
| 预训练模型全面微调 | 每类 30–80 张 | 1–2 小时 | 85%–95% | 学习率设错会灾难性遗忘 |
我一般会直接推荐第三种。理由很朴素：课程设计要的是在一个有限数据集上把结果做出来，而不是重新发明视觉特征提取器。ImageNet 上训出来的 ResNet 已经学会了边缘、纹理、形状这些通用特征，花卉识别要做的只是在这个基础上「微调」——让它更关注花瓣和花蕊的差异，这比从零开始学要省太多时间，也更稳。
2.3 骨干网络选 ResNet18 还是 MobileNet：课程设计场景下的取舍
骨干网络的选择会影响你后面所有代码和答辩内容。对课程设计场景，我的默认答案是 ResNet18。残差结构在答辩时非常好讲——跳连接解决了深层网络退化问题，这一句话就能让评委看出你确实理解了网络设计；另外 ResNet18 参数量约 1100 万，在 CPU 上做单张推理也就一两秒，现场演示不会卡到尴尬。MobileNet 的优势是轻量、适合部署到手机或树莓派，但如果你的选题没有部署要求，它反而不如 ResNet 好讲。
选型的同时，我习惯先写一段「模型替换分类头」的最小代码，验证网络能跑通再继续。这里用 PyTorch 2.x + torchvision 的新 API：
import torch.nn as nn import torchvision.models as models from torchvision.models import ResNet18_Weights num_classes = 102 # Oxford 102 花卉数据集 model = models.resnet18(weights=ResNet18_Weights.IMAGENET1K_V1) num_ftrs = model.fc.in_features # ResNet18 这里应该是 512 model.fc = nn.Linear(num_ftrs, num_classes) print(model)这段代码先把 ImageNet 上预训练好的权重加载进来，再把最后一层全连接替换成自己的分类头。model.fc.in_features这个写法请一定保留，不要硬编码 512——万一你换成 ResNet50，它的 fc 输入是 2048，写死就要改代码。num_classes=102对应数据集类别数，如果你用的是 17 类花卉或自采数据，改成实际类别数即可。跑完打印模型结构，确认 fc 输出的尺寸变了，选型就基本落地了。
3. 把数据集盘清楚：Oxford 102 的目录组织、8:1:1 划分与数据增强参数
3.1 数据从哪来：公开数据集与自采数据集的现实差距
花卉识别用得最多的是 Oxford 102 Flowers，102 个类别、每类几十到两百多张，总量约八千多张，图像是花卉在自然环境下的照片，不是实验室白底图，于是天然带上了光照、遮挡、背景干扰，刚好能暴露模型真实水平。官方原始划分是每类前 10 张做训练、后 10 张做验证、其余做测试，如果你按这个划分，得到的指标可以直接跟论文对比。另一个选择是 17 类花卉数据集，类别少、每类 80 张，适合做快速 demo，但答辩深度不够。
自采数据集是最容易翻车的路线。手机拍 50 张一张张裁剪标注，听起来可行，实际做下来你会被「同一朵花的不同角度到底算不算一个样本」这种问题折磨。我见过一个人用爬虫批量抓花图，结果类别标签错了一半，训练时模型把「菊花」里混入的背景全学进去了。如果不是老师明确要求自采，建议用公开数据集，把精力留给网络和参数。
3.2 目录结构与 ImageFolder：让 torchvision 直接读数据的规范
PyTorch 的torchvision.datasets.ImageFolder要求目录严格按照「根目录 / 类别名 / 图片」组织。很多课程设计源码拿到手跑不通，就是因为数据路径没对上。我常用的结构是这样：
dataset/ ├── train/ │ ├── rose/ │ │ ├── rose_001.jpg │ │ └── rose_002.jpg │ ├── tulip/ │ └── sunflower/ ├── val/ └── test/train、val、test 三个目录互不交叉，每个子目录名是类别名。这样直接用datasets.ImageFolder('dataset/train')就能加载，类别名会自动按字母序映射成数字标签。图片格式建议统一成 JPG，尺寸不必提前裁剪，ImageFolder会在加载时做 Resize；但要注意把所有图片统一成 RGB 三通道，灰度图混进来会在后面归一化时报错。
3.3 划分脚本：按类别比例拆分，阻断同源图片泄漏
如果下载的原始数据是一整个目录，我一般先写一个划分脚本，按 8:1:1 把每类图片随机分到 train/val/test。注意这里有个容易忽略的泄漏点：train 和 val 里如果出现几乎一样的图，模型在验证集上的成绩就是假的。自拍数据尤其要小心——同一朵花的连拍图，先按「拍摄批次」分桶，再整桶划分，不能一张张随机打散。
import os import random import shutil random.seed(42) # 固定随机种子，保证每次划分结果一致 src = 'dataset/raw_images' # 原始数据：类目录下放了全部图片 dst = 'dataset' ratio_train, ratio_val = 0.8, 0.1 for class_name in os.listdir(src): class_dir = os.path.join(src, class_name) if not os.path.isdir(class_dir): continue images = os.listdir(class_dir) random.shuffle(images) n_total = len(images) n_train = int(n_total * ratio_train) n_val = int(n_total * ratio_val) splits = { 'train': images[:n_train], 'val': images[n_train:n_train + n_val], 'test': images[n_train + n_val:], } for split_name, imgs in splits.items(): out_dir = os.path.join(dst, split_name, class_name) os.makedirs(out_dir, exist_ok=True) for img in imgs: shutil.copy2(os.path.join(class_dir, img), os.path.join(out_dir, img)) print('划分完成') for split_name in ['train', 'val', 'test']: cnt = sum(len(os.listdir(os.path.join(dst, split_name, c))) for c in os.listdir(os.path.join(dst, split_name))) print(split_name, cnt)random.seed(42)保的是可复现：你改一次增强策略后再跑，不会因为划分变了分不清是数据问题还是网络问题。shutil.copy2保留原图元数据，后续做格式转换时不至于丢信息。还有一个细节，test目录在整个训练过程中任何人都不能碰，包括你自己——所有调参、看曲线、看混淆矩阵，都只参考 val 的结果，test 留给最后一次性评估。
3.4 数据增强参数：翻转、旋转、裁剪、归一化的实操数值
花卉识别里的增强和猫狗分类同一个套路，但参数要克制。花瓣这类纹理一旦旋转超过 30 度或裁剪太狠，看起来就不像花，模型学到的全是增强噪声。我用得比较顺手的一套：
from torchvision import transforms train_transforms = transforms.Compose([ transforms.RandomResizedCrop(224, scale=(0.6, 1.0)), transforms.RandomHorizontalFlip(p=0.5), transforms.RandomRotation(15), transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) val_transforms = 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.6, 1.0)意思是裁剪区域占原图的 60% 到 100%，比例低于 0.5 会让花朵主体被切掉大半。水平翻转对花卉完全合理，但垂直翻转不要开——花倒过来在自然界几乎不存在，模型没必要学这种不真实的变化。旋转控制在 15 度内，ColorJitter 三个分量都取 0.2，避免颜色失真太夸张。验证集和测试集只做Resize(256) + CenterCrop(224)，不做任何随机增强，这样才能拿到稳定、公平的指标。归一化的 mean 和 std 用的是 ImageNet 标准值，和预训练权重当时的预处理保持一致，这个不能改，改了你前面的迁移学习基本白做。
4. 跑通训练主流程：损失函数、分层学习率与最佳权重的保存
4.1 预训练权重自带预处理：weights.transforms() 帮你对齐输入
我们手动写了 Normalize，但 torchvision 新版本其实给了更省事的写法：.transforms()方法能直接取到和该预训练权重配套的预处理流程，输入尺寸、Resize 方式、归一化均值方差全部对齐，比自己拼手写的更不容易出错。比如：
weights = ResNet18_Weights.IMAGENET1K_V1 preprocess = weights.transforms() # 包含 Resize、ToTensor、Normalize model = models.resnet18(weights=weights) model.fc = nn.Linear(model.fc.in_features, num_classes)这有个隐含坑要注意：如果你用了weights.transforms()，那么 val 集预处理里那个Resize(256) + CenterCrop(224)就不再适用，因为 transforms 对象内部可能用的是Resize(232)之类的自己的配置。数据加载时用同一个preprocess处理 train/val 的图片，但训练集在它之前还要叠增强，顺序是「先增强，再走 preprocess」。
由此说句实在话，版本差异是课程设计源码最容易翻车的点之一。网上能找到不少「免费 python 源码大全」里的老代码，用models.resnet18(pretrained=True)，这种写法在旧版 torchvision 里能用，但新版会直接报参数不匹配的警告甚至错误。拿到源码第一件事不是跑，而是看它 import 的模型 API 是否匹配你环境里的 torchvision 版本。
4.2 损失函数为什么选 CrossEntropyLoss：软标签与类别不均衡
训练分类任务，损失函数默认就是交叉熵。CrossEntropyLoss 内部已经帮你把全连接输出的 logits 做 softmax 再算对数损失，你不需要在模型里额外接 softmax 层。它对分类错误施加的惩罚是非线性的：模型越「自信」地分错，loss 越大，梯度越猛，这对细粒度分类其实有利——能逼着网络把最容易混淆的花卉类别分开。
如果类别不均衡，比如某类只有 20 张，另一类 180 张，要传weight参数：
criterion = nn.CrossEntropyLoss(weight=class_weights)class_weights可以按1 / 类别样本数归一化得到。但我的课程设计经验是：只要每类样本数差距不超过 5 倍，不设权重也行，省得引入新的调参变量；差距很大时再设。
4.3 分层学习率：预训练层与新分类头不能用一个学习率
这是整个训练流程里最容易踩、也最值得讲的一个参数设置。预训练层已经收敛得很好，你拿着一张大学习率去把整个 ResNet 连同新 fc 层一起更新，几个 epoch 下来预训练特征就被冲掉了，表现就是 val acc 卡住不动。标准做法是给新分类头设大一点的学习率，给预训练层设小学习率：
import torch.nn as nn param_groups = [ {'params': model.fc.parameters(), 'lr': 1e-3}, # 新分类头 {'params': [p for n, p in model.named_parameters() if 'fc' not in n], 'lr': 1e-4}, # 预训练层 ] optimizer = torch.optim.SGD(param_groups, momentum=0.9, weight_decay=1e-4) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=4, gamma=0.5)| 参数 | 推荐值 | 说明 |
|---|---|---|
| 分类头学习率 | 1e-3 | 新层从零学，给大步长快速收敛 |
| 预训练层学习率 | 1e-4 | 微调旧特征，步长太大会灾难性遗忘 |
| 优化器 | SGD, momentum=0.9 | Adam 也行，但 SGD 迁移学习表现通常更稳 |
| weight_decay | 1e-4 | 轻微的正则，缓解过拟合 |
| scheduler | StepLR, 每 4 轮减半 | 后期学习率下降让 loss 落得更平 |
named_parameters()会把每个参数的名字和值遍历出来，名字里含fc的只有新分类头，剩下的都是预训练层，这个过滤逻辑简洁且不会漏。SGD 配合动量收敛慢但稳，Adam 收敛快但会在迁移学习后期出现震荡。课程设计如果用 Adam，答辩被问「为什么不用 SGD」确实不好答；用 SGD 就没有这个问题。
4.4 训练循环细节：按 val acc 保存最佳权重，别等最后一个 epoch
最后一个 epoch 的模型不一定最好，尤其是有 scheduler 在动态降学习率时，往往是中间某个 epoch 的 val acc 最高。我坚持用「每轮验证一次，val acc 创新高就覆盖保存 best_model.pth」的方式：
best_acc = 0.0 epochs = 20 for epoch in range(epochs): model.train() running_loss = 0.0 for images, labels in train_loader: images, labels = images.to(device), labels.to(device) optimizer.zero_grad() outputs = model(images) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() model.eval() correct, total = 0, 0 with torch.no_grad(): for images, labels in val_loader: images, labels = images.to(device), labels.to(device) outputs = model(images) _, predicted = torch.max(outputs, 1) total += labels.size(0) correct += (predicted == labels).sum().item() val_acc = 100.0 * correct / total print(f'epoch {epoch+1}: loss={running_loss/len(train_loader):.4f}, val_acc={val_acc:.2f}%') if val_acc > best_acc: best_acc = val_acc torch.save(model.state_dict(), 'best_model.pth') print(f'保存最佳模型，val_acc={val_acc:.2f}%')device在脚本开头统一写torch.device('cuda' if torch.cuda.is_available() else 'cpu')，没有独显也能在 CPU 上跑，只是慢。Train 和 eval 两个模式切换别忘——model.eval()会关掉 BN 和 dropout 的随机行为，只保留其中一批是推理脚本常用的坑。如果本机没有 NVIDIA 显卡，可以到云平台租一块 T4 跑训练，本地只做推理演示，这是课程设计阶段性价比很高的做法。训练结束后，加载权重时注意格式：model.load_state_dict(torch.load('best_model.pth', map_location='cpu'))，一般按官方推荐用weights_only=True更安全。
5. 避坑：花卉识别源码最常见的 5 个翻车现场
5.1 训练中途报解码错误，数据读到一半崩了
现象：train 循环跑了一半，突然报OSError: broken image file，程序直接退出。原因：数据集里混入了损坏的图片、格式伪装成 jpg 但不是真 jpg 的文件，或者下载时截断的图片。解决：不要在 load 时靠运气，提前遍历清洗。写个小脚本把所有图片用PIL.Image.open()打开并调用img.verify()，失败的直接移除，再把扩展名统一转成 jpg。这个 5 分钟的活能省掉后面所有训练中断的烦恼。另外 DataLoader 设num_workers=4时异常信息会乱，建议调试期先num_workers=0，跑通了再调高。
5.2 val acc 卡在 30% 上不去：学习率把预训练权重冲掉了
现象：train loss 正常下降，但 val acc 在第 5 个 epoch 后一直徘徊在 30% 左右，怎么调都不动。原因：预训练层使用了和分类头一样的较大学习率，前面的卷积特征被破坏，等价于从随机初始化的特征开始训练，而这套数据量根本撑不起从零训练。解决：回到 4.3 的分层学习率方案。我见过有的免费源码大全里的旧代码干脆不做分层，统一lr=1e-3，改完分层后常见结果是 val acc 从 30% 跳到 85% 以上。这是最典型的「源码没坏，参数不对」的情况。
5.3 增强参数开太大：训练集准确率 99%，验证集反而下降
现象：train acc 很快到 99%，val acc 却比预期的低 5-8%。原因：数据增强强度过高，模型在「被旋转 90 度的花」和「被裁掉一半的花」上反复拟合，而这些样本跟真实分布差距太大，学出来的特征反而干扰了正常图片的分类。解决：把RandomRotation(15)改小到 10、关闭ColorJitter的 hue 分量，或者减少 RandomResizedCrop 的 scale 下限到 0.7，优先保真实分布。判别依据是误差 e 两个曲线：train loss 持续低于 val loss 且随 epoch 拉大，先怀疑增强过头而不是先怀疑网络能力。
5.4 验证集准确率很高，拿手机拍一张真实照片却识别错
现象：val acc 95%，把模型部署到本地，手机随手拍一张菊花，预测结果错得离谱。原因：一是数据泄漏，train 和 val 里出现了同源图片，val acc 虚高；二是模型学的是背景而不是花，尤其是公开数据集里花的位置居中、背景固定，模型很容易把「绿色背景 + 中心色块」当成判别特征。解决：划分时按 3.3 的方式阻断同源图；评估时额外准备一些网上搜来的真实照片，放到一个单独的test_real/目录里，专门验证泛化能力。如果你发现模型对真实照片错得有规律，基本可以判定它把背景当成了特征，后面第六章的 Grad-CAM 可视化就能直接证明这一点。另外注意千万别用 opencv 的imread读图直接塞给模型——它读出来是 BGR 通道顺序，颜色一错，模型在当前任务上的表现立刻崩。
5.5 显存不够、训练极慢：batch size、num_workers 与 CPU 版 PyTorch
现象：设置batch_size=64直接 OOM，或者训练一个 epoch 要 40 分钟。原因：显存不够时处理方式不是硬扛，而是往下调。ResNet18 + 224 输入，16G 显存的卡跑 batch 64 没问题，8G 卡建议降到 32，4G 卡降到 8，不行就用梯度累积。但首先要排查你是不是装成了 CPU 版 PyTorch——很多人在 VSCode 里配 Python 环境时，直接pip install torch装的就是 CPU 版，训练速度差十几倍，跟参数没有半点关系。解决：检查torch.version.cuda是否存在，确认 GPU 可用后再谈调参。另外 DataLoader 的num_workers在 Windows 上设 0 或 2 比较稳，设 8 反而可能因为进程开销把速度拖慢，还容易触发内存错误。
6. 答辩加分动作：混淆矩阵与 Grad-CAM 特征可视化
6.1 混淆矩阵：定位模型最容易混淆的那几对花
训练完先别急着收工，跑一遍 test 集，把混淆矩阵画出来。这对细粒度分类几乎是必做项，因为评委一定会问「你这个模型最可能在什么情况下犯错」。用 sklearn 一句话算出矩阵，再按行归一化方便对比：
from sklearn.metrics import confusion_matrix import numpy as np cm = confusion_matrix(y_true, y_pred) cm_norm = cm.astype('float') / (cm.sum(axis=1, keepdims=True) + 1e-8) np.fill_diagonal(cm_norm, 0) # 把对角线清零，只看错误分布 idx = np.unravel_index(np.argsort(cm_norm, axis=None)[-5:], cm_norm.shape)np.fill_diagonal把正确的预测清零后，剩下最大的几个元素就是模型混淆最严重的位置。我通常会把前 5 对混淆类名打印出来，再单独找出这些类各自的 test 图片来看，十次里有八次会发现是「背景相似」或「同色系花」在互相干扰，这正好是下一步可视化要验证的结论。
6.2 Grad-CAM 热力图：证明模型在「看花」而不是「看背景」
答辩现场最能镇场的就是 Grad-CAM。它通过目标类别对最后一层卷积特征的梯度加权，把模型「重点看哪里」画成热力图叠加在原图上。如果热力图集中在花瓣和花蕊上，说明模型学到的确实是花；如果热力图一片绿全是背景，那 val acc 高也只是假象。核心实现不复杂，靠 hook 取特征与梯度：
feature_map, grad_map = {}, {} def forward_hook(module, input, output): feature_map['value'] = output def backward_hook(module, grad_input, grad_output): grad_map['value'] = grad_output[0] h_f = model.layer4.register_forward_hook(forward_hook) h_b = model.layer4.register_full_backward_hook(backward_hook) out = model(img_tensor.unsqueeze(0)) # img_tensor 是预处理后的单张图 model.zero_grad() out[0, pred_class].backward() feat = feature_map['value'][0] # [C, H, W] grad = grad_map['value'][0] # [C, H, W] weights = grad.mean(dim=(1, 2), keepdim=True) cam = torch.relu((weights * feat).sum(dim=0)) cam = (cam - cam.min()) / (cam.max() - cam.min() + 1e-8)要点在最后两步：grad.mean(dim=(1,2))把每个通道的梯度平均成一个权重，再与特征图逐通道加权求和，得到的就是「对目标类别最关键的二维空间位置」，最后取 relu 只保留正向贡献，归一化到 0-1 后可以直接用 matplotlib 的imshow叠加到原图上。答辩时多准备三张图：正常花的热力图、混淆对里看错的那张图的热力图、以及一张背景干扰严重但识别对的图。我自己的习惯是，所有结果必须我自己先用纯背景图暗测一遍——比如拿一张「花很小、背景很大」的照片跑 Grad-CAM，如果热力图不在花上，我不会把这张图放进答辩 PPT。视觉证据比任何准确率数字都更能回答「你的模型到底学到了什么」。希望这些参数和习惯能帮你少走几趟弯路。
本文还有配套的精品资源，点击获取
