1. 项目整体拆解与方案选型
1.1 为什么是MobileNet：毕业设计选型的第一课
每年到毕业季，计算机相关专业的学生都在纠结同一个问题：做什么题目既能顺利通过答辩，又不至于把自己折腾到脱发？花朵识别系统这个名字出现的频率相当高，原因很直接——数据集公开、任务定义清晰、用户感知度强，导师看了觉得有应用价值，答辩时也好演示。但真正决定这个项目是"优秀"还是"勉强过关"的，其实是模型选型这一步。
我见过不少同学一上来就上ResNet152、EfficientNet-B7，觉得网络越大精度越高。结果呢？用CPU跑了三天一个epoch都没跑完，最后只能去蹭实验室的GPU，还经常因为显存不够被迫把batch size调到4。这里的问题不是模型不好，而是跟场景不匹配。毕业设计的花卉识别系统，绝大多数运行环境是普通笔记本电脑，甚至可能是答辩现场那台不知道用了多少年的台式机。你总不能跟评委说"等我回家用GPU跑一下再给您看结果"吧？
MobileNet系列就是为这种场景设计的。它的核心思想是用深度可分离卷积替代标准卷积，把计算量和参数量降了一个量级。以MobileNetV2为例，在ImageNet上Top-1精度71.8%的模型，参数量只有3.4M，而ResNet50的参数量是25.6M，差了七倍多。更关键的是它的推理速度——在CPU上跑一张224x224的图片，MobileNetV2只要几十毫秒，ResNet50可能要几百毫秒。对于花朵识别这种类间差异相对明显、但类内又有姿态、光照、遮挡变化的分类任务，MobileNet的能力完全够用。
如果你用的是MobileNetV3-Large，精度还能再往上走一点，因为V3引入了SENet的注意力机制和h-swish激活函数，在同等计算量下比V2更强。不过V3在PyTorch的torchvision库里已经提供了预训练权重，加载起来非常方便，不会增加太多实现成本。我的建议是：如果你的数据集规模在1000张以上，用MobileNetV3-Large；如果数据量在500张以下，用MobileNetV2反而更稳，因为V3的参数量虽然不大，但数据太少时还是容易过拟合。
1.2 系统整体架构与模块划分
一个完整的毕业设计项目，不能只有模型训练那一块，那样工作量撑不满论文。我拆解这个项目时，通常把它分成四个模块：
数据处理模块：负责数据集的加载、划分、增强、归一化。这是整个项目的基础，也是论文里"实验准备"章节要写的核心内容。
模型训练模块：包括迁移学习加载预训练权重、修改分类头、配置优化器和学习率调度器、执行训练循环、验证和保存最优模型。这是核心中的核心，也是答辩时评委最关注的部分。
模型评估模块：除了算准确率，还要输出混淆矩阵、每个类别的precision/recall/F1，绘制训练过程中的loss和accuracy曲线。这部分是论文里"实验结果分析"章节的素材来源。
Web应用模块：用Flask或FastAPI封装一个简单的网页，用户可以上传花朵图片，系统返回识别结果和置信度。这个模块让项目从"算法演示"升级成"应用系统"，在系统展示环节非常加分。
模块之间用清晰的接口衔接：数据处理模块输出标准的Dataset类，模型训练模块接收Dataset并输出权重文件，评估模块加载权重文件生成指标和图，Web应用模块加载权重文件做推理。这样的架构设计本身就是一个亮点，论文里的"系统设计"章节直接按这个逻辑写就行。
2. 数据集准备与预处理细节
2.1 数据集选型：Oxford 102的坑与替代方案
花朵识别领域最常用的公开数据集是Oxford 102 Flowers，102个类别，每个类别40到258张图片不等，总共约8000多张。在Ubuntu 21.10、Face-Recognition 1.3.0环境搭建方面有很多细节需要注意。我见过很多同学用Ubuntu 22.04或24.04虚拟机踩坑，建议不要直接使用最新版本的系统，优先选择Ubuntu 20.04或21.10这种比较稳定的发行版，依赖库版本冲突会少很多。
提示：官方下载地址在国内访问很慢，建议找镜像源或者用网盘分享的资源。下载后检查一下文件完整性，我遇到过解压到一半报错的情况。
还有一个数据集是Flower 17，17个类别，类别数少，适合做快速验证。如果时间充裕，可以先用Flower 17跑通整个流程，再上Oxford 102做正式实验。
这里要说一个很多教程不会提的问题：数据集的类别分布不是均匀的。Oxford 102里有的类别只有40张，有的有258张，这种不平衡会直接影响训练效果。处理办法有两个：一是在sampler里设置类别权重，让少的类别有更高的采样概率；二是数据增强时对少数类做更强的变换。我通常先用第二种，因为实现简单，改动少，效果也够用。
另一个容易被忽略的是数据泄露问题。有的公开数据集里同一朵花的多张图片是连续拍摄的，背景、角度差异很小，如果不做乱序和合理的划分，验证集准确率会虚高。正确做法是：先用random seed固定随机数，再按类别分层抽样划分train/val/test，保证每个类别在三个集合里都有分布。
2.2 数据增强与加载器的工程化写法
数据增强是花朵识别项目里性价比最高的操作。花朵图片的主要变化来自拍摄角度、光照条件、花瓣形态，而深度学习模型天然对这些变化不完全鲁棒。PyTorch的torchvision.transforms提供了全套工具，下面是我在项目里实测效果最好的组合：
train_transforms = transforms.Compose([ transforms.RandomResizedCrop(224, scale=(0.6, 1.0)), transforms.RandomHorizontalFlip(p=0.5), transforms.RandomRotation(degrees=15), transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1), 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.08到1.0更保守，因为花朵识别不需要那么极端的缩放。RandomRotation控制在15度以内，转动太多会导致花的朝向失真。ColorJitter里的hue=0.1很关键，花朵的颜色是分类的重要特征，色相偏移太大会改变花朵的真实颜色，导致模型学到错误的特征。
验证集的transform要干净得多，只做Resize到256、CenterCrop到224、ToTensor和Normalize。原因很简单：验证集的作用是模拟真实场景，加太多随机变换会让指标失真。
Dataset和DataLoader的写法也有讲究。如果你直接用ImageFolder加载数据，目录结构必须严格符合root/class_name/image.jpg的格式。如果用继承torch.utils.data.Dataset的方式自定义，要重写__init__、__len__、__getitem__三个方法。我建议用ImageFolder，因为它自动生成类别到索引的映射，后续做混淆矩阵时可以直接复用。
DataLoader里有个参数经常被人忽略：num_workers。Windows系统下设置大于0会报错，建议直接设为0；Linux/Mac下可以设为CPU核数的一半或直接设为2。pin_memory=True可以加速GPU训练时的数据传递，但如果你的数据加载逻辑里有自定义的CPU操作，开了反而可能更慢，需要实测。
3. MobileNet模型搭建与训练全流程
3.1 迁移学习的正确打开方式
花朵识别项目最适合用迁移学习，不需要从头训练。原因是：ImageNet上的预训练模型已经学会了丰富的底层特征，比如边缘、纹理、颜色分布，而花朵图片的低层特征和这些是高度相似的。我们只需要让模型在花朵数据集上微调高层特征和分类器就行。
以PyTorch为例，加载MobileNetV2预训练权重的代码非常简洁：
import torchvision.models as models model = models.mobilenet_v2(weights=models.MobileNet_V2_Weights.IMAGENET1K_V1) num_features = model.classifier[1].in_features model.classifier[1] = nn.Linear(num_features, num_classes)MobileNetV2的classifier结构是两个层：第一层是Dropout，第二层是Linear。上面的代码只替换了最后一层Linear，把输出维度改成自己的类别数。MobileNetV3的结构稍微有点不同，它的classifier是Sequential包含多个层，操作逻辑一样：先读出最后一个Linear的in_features，然后替换掉。
关于微调策略，我建议分两种方式讨论：
方式一：全量微调（也称解冻训练）。加载预训练权重后，所有层都参与训练，学习率设小一些，比如0.001。这种方式效果好，因为花朵在ImageNet里有对应的类别（比如雏菊、向日葵、兰花等很多花卉类别），低层特征可以直接复用，但同时需要的数据量也更大，如果只有几百张图片，很容易过拟合。
方式二：冻结特征层，只训练分类层。把features层的requires_grad设为False，只让classifier层可训练，学习率可以设大一些，比如0.01。这种方式训练速度非常快（几分钟就能跑完），但效果上限低，适合先用它跑通流程。
我实际用的是一种折中方案：先冻结特征层训练几个epoch，等分类层收敛后再解冻特征层，用更小的学习率全量微调。具体操作是训练5个epoch后，遍历模型的参数把requires_grad全部设为True，并把优化器学习率降到原来的1/10。这种"先冷后热"的策略既避免了前期训练不稳定，又能最终达到比较好的精度。
3.2 训练参数配置与调优记录
训练参数这块，我直接给出我在102类花朵数据集上验证过的一整套配置，你可以直接抄：
batch_size = 64 learning_rate = 1e-3 weight_decay = 1e-4 epochs = 30 optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs, eta_min=1e-5) criterion = nn.CrossEntropyLoss()优化器选择Adam而不是SGD，原因很实际：Adam自适应学习率，对初始学习率不敏感，调试成本低，收敛速度也比SGD快。SGD要配合好动量和学习率调度策略才能发挥威力，新手用不好反而会跑来跑去找不到最低点。
weight_decay设置1e-4就很合适，太大了会让模型欠拟合，太小了起不到正则化效果。学习率调度选了CosineAnnealingLR，是因为它在训练后期能让loss平稳下降，比StepLR那种阶梯式下降的震荡小得多。eta_min设为1e-5防止学习率降到0导致训练停滞。
关于batch_size的坑：如果你的GPU显存只有4GB，batch_size设64很可能OOM。秋招笔试平台常见情况是Adam优化器和余弦退火策略，建议先设32试水，显存足够再往上加。另一个关键点是梯度累积，如果batch_size设32仍然OOM，可以把batch_size设为16，并用accumulation_steps=4模拟batch_size 64的效果，也就是每batch梯度累计，每4个batch更新一次权重，代码实现如下：
accumulation_steps = 4 optimizer.zero_grad() for i, (inputs, labels) in enumerate(train_loader): outputs = model(inputs) loss = criterion(outputs, labels) loss = loss / accumulation_steps loss.backward() if (i + 1) % accumulation_steps == 0: optimizer.step() optimizer.zero_grad()这里有个细节：loss要除以accumulation_steps，因为梯度是累计的，除以步数后等效于用batch_size=64的梯度来更新，这样学习率不用调整。
3.3 训练过程监控与模型保存策略
训练时不要光盯着终端里那几行输出，建议用TensorBoard记录每个epoch的train_loss、val_loss、val_accuracy。如果你想出一个更直观的效果，可以用 wandb 做可视化，不过毕业设计没必要引入额外依赖了。在本地保存日志到runs/目录，训练完还可以截图放到论文的实验分析章节。
训练循环的代码框架如下，我保留关键实现：
best_val_acc = 0.0 best_model_path = "best_mobilenet.pth" for epoch in range(epochs): model.train() train_loss = 0.0 correct = 0 total = 0 for inputs, labels in train_loader: inputs, labels = inputs.to(device), labels.to(device) outputs = model(inputs) loss = criterion(outputs, labels) optimizer.zero_grad() loss.backward() optimizer.step() train_loss += loss.item() * inputs.size(0) _, predicted = torch.max(outputs, 1) total += labels.size(0) correct += (predicted == labels).sum().item() train_acc = 100.0 * correct / total avg_train_loss = train_loss / total # 验证阶段 model.eval() val_loss = 0.0 val_correct = 0 val_total = 0 with torch.no_grad(): for inputs, labels in val_loader: inputs, labels = inputs.to(device), labels.to(device) outputs = model(inputs) loss = criterion(outputs, labels) val_loss += loss.item() * inputs.size(0) _, predicted = torch.max(outputs, 1) val_total += labels.size(0) val_correct += (predicted == labels).sum().item() val_acc = 100.0 * val_correct / val_total avg_val_loss = val_loss / val_total print(f"Epoch {epoch+1}/{epochs}, Train Loss: {avg_train_loss:.4f}, Train Acc: {train_acc:.2f}%, Val Acc: {val_acc:.2f}%") if val_acc > best_val_acc: best_val_acc = val_acc torch.save(model.state_dict(), best_model_path) print(f"Saved best model with val_acc {best_val_acc:.2f}%") scheduler.step() print(f"Training complete. Best val acc: {best_val_acc:.2f}%")注意三个关键点：第一，验证阶段必须加with torch.no_grad()，否则会构建计算图，白白占用显存，模型越大越明显。第二，model.train()和model.eval()不能漏，因为BatchNorm和Dropout在训练和推理时的行为是不同的。第三，保存模型权重时要保存验证集准确率最高的那次，不是最后一次epoch的结果，因为最后一次不一定最优。
模型保存我只保存state_dict()而不是整个model对象。torch.save(model, ...)保存了完整模型结构和权重，加载时对PyTorch版本和模型类定义位置的要求更高，填报时容易出问题。只保存state_dict()是官方推荐做法。当然，我会把类别名称列表存成JSON文件，因为推理时要用来做映射。
4. 分类系统实现与场景落地
4.1 基于Flask的Web识别服务搭建
模型训练好了，怎么让它变成一个能演示的系统？最常见的方案是用Flask写一个轻量级Web服务，用户上传图片，后端调用模型推理，返回识别结果和置信度。
Flask相对Django来说更轻，代码量少，是毕业设计系统展示的主流选择。核心代码如下：
import io import torch import torch.nn.functional as F from PIL import Image from flask import Flask, request, jsonify, render_template from torchvision import transforms app = Flask(__name__) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model_path = "best_mobilenet.pth" num_classes = 102 # 先构建MobileNetV2结构，再加载权重 import torchvision.models as models model = models.mobilenet_v2(weights=None) num_features = model.classifier[1].in_features model.classifier[1] = torch.nn.Linear(num_features, num_classes) model.load_state_dict(torch.load(model_path, map_location=device)) model.to(device) model.eval() # 类别名称映射文件事先存好 import json with open("class_names.json", "r") as f: class_names = json.load(f) 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]) ]) @app.route("/", methods=["GET"]) def index(): return render_template("index.html") @app.route("/predict", methods=["POST"]) def predict(): if "image" not in request.files: return jsonify({"error": "未找到图片文件"}), 400 file = request.files["image"] img_bytes = file.read() img = Image.open(io.BytesIO(img_bytes)).convert("RGB") img_tensor = transform(img).unsqueeze(0).to(device) with torch.no_grad(): outputs = model(img_tensor) probs = F.softmax(outputs, dim=1)[0] top_prob, top_idx = torch.topk(probs, 3) results = [] for prob, idx in zip(top_prob, top_idx): results.append({ "class_name": class_names[idx.item()], "confidence": round(prob.item(), 4) }) return jsonify({"results": results}) if __name__ == "__main__": app.run(debug=False, host="0.0.0.0", port=5000)几个实现细节要强调：
Image.open(io.BytesIO(img_bytes)).convert("RGB")这行很关键。convert("RGB")是为了防止用户上传的图片是RGBA四通道或者灰度单通道，导致后续transforms报错。PIL打开图片后默认保留原始模式，不转一下模型就会因通道数不匹配而报错。model.eval()必须在Web服务启动前调用一次，而不是每次推理都调用。原因和训练时一样：BatchNorm和Dropout的行为依赖这个模式标志位。返回top3而不是top1，是交互层面的小优化。因为花朵识别里往往有多个相近品种，用户看到top3时更容易理解为什么系统"认错了"，在答辩演示时也能显示出你考虑了系统可用性。
Flask的
host="0.0.0.0"表示监听所有网络接口，这样同一局域网内的其他设备也能访问。答辩时你可以用手机连同一个WiFi，打开浏览器上传图片，演示效果会非常惊艳。
前端页面这部分，不需要设计得多花哨，简洁就好。一个文件上传按钮、一个预览区域、一个显示结果的区域就足够了。用原生HTML+JavaScript就行，不用引入框架。以下是一个最小可用的前端模板：
<!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>MobileNet 花朵识别系统</title> </head> <body> <h1>MobileNet 花朵识别系统</h1> <input type="file" id="imageInput" accept="image/*"> <br><br> <img id="preview" alt="预览" style="max-width: 400px; display: none;"> <br><br> <button id="predictBtn" onclick="predict()" disabled>开始识别</button> <div id="result"></div> <script> const imageInput = document.getElementById('imageInput'); const preview = document.getElementById('preview'); const predictBtn = document.getElementById('predictBtn'); imageInput.addEventListener('change', function() { const file = this.files[0]; if (file) { const reader = new FileReader(); reader.onload = function(e) { preview.src = e.target.result; preview.style.display = 'block'; predictBtn.disabled = false; }; reader.readAsDataURL(file); } }); async function predict() { const file = imageInput.files[0]; const formData = new FormData(); formData.append('image', file); const response = await fetch('/predict', { method: 'POST', body: formData }); const data = await response.json(); if (data.error) { document.getElementById('result').innerText = '错误: ' + data.error; } else { let html = '<h3>识别结果：</h3>'; data.results.forEach(item => { html += `<p>${item.class_name} —— 置信度：${(item.confidence * 100).toFixed(2)}%</p>`; }); document.getElementById('result').innerHTML = html; } } </script> </body> </html>把这段HTML保存为templates/index.html，Flask会自动找到它。
4.2 模型导出与推理优化
如果你还想更进一步，把模型从PyTorch导出为ONNX格式，这样就能在手机端或者其他部署环境中运行。这个操作对论文的"系统实现"章节是个加分项，说明你考虑了模型的跨平台部署能力。
dummy_input = torch.randn(1, 3, 224, 224).to(device) torch.onnx.export( model, dummy_input, "mobilenet_flower.onnx", opset_version=11, input_names=["input"], output_names=["output"], dynamic_axes={"input": {0: "batch_size"}, "output": {0: "batch_size"}} )导出时dynamic_axes设置得让batch_size维度是动态的，这样部署时可以一次推理多张图片。ONNX模型可以直接用ONNX Runtime做推理，CPU上速度比PyTorch还略快一点，因为做了额外优化。
推理速度优化方面，还有一个容易被忽略的技巧：量化。PyTorch的torch.quantization接口可以把模型从FP32量化到INT8，模型体积能压缩到原来的1/4左右，推理速度在部分硬件上能提升2到4倍。如果最终演示用的是一台老旧的笔记本，量化是救命的。当然，量化后精度会有一定的下降，通常损失1%到3%，对于花朵分类来说在可接受范围内。
但我要说句实话：如果你只是做毕业设计，ONNX和量化都算是"加分项"，不是"必选项"。先把基础功能完整跑通，有时间再研究这些优化。很多同学一上来就想把模型压缩到极小，结果压缩完精度掉了不少，答辩时当场识别错误，那就尴尬了。
5. 常见问题与排查技巧实录
5.1 训练阶段经典问题
问题一：loss不下降
这是最让人崩溃的情况。排查思路按可能性从高到低排序：第一，检查数据标签是否和图片对应。把训练集的图片分批可视化，同时打印对应的标签，肉眼扫一遍。第二，检查学习率是否过大，试着降到原来的1/10。第三，检查数据归一化是否做对了，如果mean和std没配对，输入分布会被错误地缩放。第四，检查模型是否处于train模式，如果忘写model.train()而模型里有Dropout，训练时Dropout是关闭的，但BN仍然生效，这个bug比较隐蔽，需要把模型的状态打出来看。
问题二：训练集准确率很高，验证集准确率很低
典型的过拟合。处理办法依次尝试：增加数据增强的强度（比如再加transforms.RandomAffine）、增加weight_decay到1e-3、添加Dropout层。如果数据量实在太小（几百张），考虑做数据重组，通过mixup或cutmix生成更多样化的样本。我自己在102类花朵数据上实测，mixup能把过拟合的空间压缩不少，实现也不复杂：
def mixup_data(x, y, alpha=0.2): lam = np.random.beta(alpha, alpha) batch_size = x.size(0) index = torch.randperm(batch_size) mixed_x = lam * x + (1 - lam) * x[index] y_a, y_b = y, y[index] return mixed_x, y_a, y_b, lam问题三：GPU显存不足
前面已经提到过梯度累积的方案。还有一个方案是混合精度训练，PyTorch从1.6开始原生支持：
scaler = torch.cuda.amp.GradScaler() for inputs, labels in train_loader: with torch.cuda.amp.autocast(): outputs = model(inputs) loss = criterion(outputs, labels) scaler.scale(loss).backward() scaler.step(optimizer) scaler.update() optimizer.zero_grad()混合精度把FP32降到FP16，显存占用直接减半，速度也会有提升。但注意，如果你的显卡不支持FP16加速，效果可能不明显。
5.2 部署阶段常见坑点
问题四：Flask启动时报错Address already in use
端口被占用了。先查是谁占用了5000端口，或者在Linux/Mac下用lsof -i:5000、Windows下用netstat -ano | findstr :5000，然后换一个端口（比如5001）就行。这个问题在答辩现场特别容易遇到——上一组同学的项目还开着没关。建议写一个环境变量或者配置文件来定义端口号，换端口时只改一处。
问题五：前端报错Uncaught TypeError: Cannot read properties of null
这个错误通常是getElementById的id拼错了。检查HTML元素的id和JavaScript代码里的字符串是否完全一致，包括大小写。还有一种情况是script标签放在了元素前面，导致DOM还没加载完就执行了查询。解决方案是把script放到body的最后，或者使用DOMContentLoaded事件，或者直接加上defer属性。
问题六：上传图片后收到空文件
可能是前端的FormData构造不正确，也可能是后端的request.files["image"]这个key跟前端append的key不一致。我遇到过一次非常无语的情况：前端用formData.append('img', file)，后端用request.files['image']，两个key不一致，后端拿到空对象，返回400错误。这类问题只要你前后端对照着看，30秒就能发现。
问题七：模型加载后精度下降
最常见原因是训练时用了GPU，测试时map_location设置不对，检查一下权重加载时map_location=torch.device('cpu')有没有写。第二个常见原因是数据预处理不一致。训练时的transform是RandomResizedCrop，如果部署时忘记改成Resize+CenterCrop，会导致输入分布不一致，精度必然掉。第三个原因是漏了model.eval()，这在前面强调过。
5.3 经验速查表
把我踩过的坑和常用的解法整理成一张表，方便你在开发时快速对照：
| 遇到的现象 | 可能原因 | 先尝试的解法 |
|---|---|---|
| loss不降 | 数据标签错乱 | 可视化一批图片和标签检查 |
| 训练集准、验证集不准 | 过拟合 | 增强数据增强、加大weight_decay |
| GPU显存不足 | batch_size过大 | 降低batch_size或梯度累积 |
| 推理时结果不对 | 模型模式错误或预处理不一致 | 检查model.eval()和transform是否一致 |
| Web上传报错400 | 前后端key不一致 | 检查FormData的key和request.files的key |
| 端口被占用 | 服务未关闭 | 换端口或kill进程 |
| 保存的权重加载报错 | 模型结构不匹配 | 检查num_classes是否一致 |
6. 从毕设到实战：扩展方向与我的体会
这个项目做完之后，如果你想继续深挖或者参加比赛、发论文，有几个方向可以延展：一是细粒度图像识别，花朵分类本身就是细粒度识别的一个重要场景，可以尝试加入注意力机制、部件定位等更复杂的算法；二是移动端部署，把模型转换到TensorFlow Lite或CoreML，在手机上做实时识别；三是目标检测，从单花分类升级为图中多朵花同时检测和识别，这会用到YOLO或Faster R-CNN；四是迁移学习在不同领域的应用，MobileNet的轻量特性让它非常适配工业质检、农业病虫害识别等场景。
我在实际使用中发现，做这个项目最重要的是先把数据准备好，然后跑通一个最简流程，再逐步加特性。不要一开始就想把所有功能都做上，那样只会陷入无尽的bug调试。先用MobileNetV2加默认预训练权重跑一个结果，确认整个链路通顺之后，再回头替换成MobileNetV3、加数据增强、做模型导出，每一步都有明确的对照结果，排查问题也就更有方向感。
最后再分享一个小技巧：训练过程中，把每个epoch的验证集准确率记录下来，然后用matplotlib画一条学习曲线。毕业论文里放两张图，一张是训练/验证loss曲线，一张是验证准确率曲线，评委看了会觉得你的实验做得很扎实。就这个细节，很多同学都会漏掉，但恰恰是这些细节，拉开了"认真做"和"应付做"的差距。
