Python训练CNN做形状识别：深度学习毕设完整实战指南

每年这个节点，都会有同学来问我：深度学习方向的毕设到底选什么题才不踩坑？如果是第一次认真接触机器学习，我会优先推荐一条路——用Python训练一个卷积神经网络，完成形状识别。这个题目的妙处在于，它把深度学习里最重要的东西全串起来了：数据、模型、训练、评估、可视化，每一个环节你都能亲手掌控。既不像复现经典分类网络那样高不可攀，也不像调现成库跑个结果那样什么都没留下。

很多人一听到“形状识别”第一反应是“这是不是太简单了”，但真正动手做过的同学会知道，哪怕只是识别圆形、三角形、正方形这三种基础几何图形，背后都藏着数据分布、网络设计、超参调优、过拟合判断这一整套深度学习基本功。而且这个方向往深了走，可以直接延伸到工业零件分拣、图纸矢量化、OCR前置处理这些现实场景，答辩时你完全站得住脚。这篇文章我就把整个项目的完整思路、代码细节、训练过程中大概率会踩的坑，从头到尾梳理一遍，动手做一个属于自己的完整项目，也给自己留一份拿得出手的毕设成果。

1. 为什么我逢人就推荐“形状识别”这个毕设题

1.1 毕设选题的三个硬指标：数据、算力、工作量

一个合格的深度学习毕设题，不管学校要求严格还是宽松，本质上都要同时满足三个条件：数据能拿到、模型能跑动、工作量能讲清。

先说数据。很多经典课题看起来漂亮，比如医疗影像分割、遥感目标检测，但数据获取这一关就先卡死了。医疗数据涉及隐私和标注成本，遥感数据动辄几个G还带着复杂的预处理流程，很多同学光倒腾数据就耗掉了半个学期。形状识别完全不存在这个问题，数据是自己生成的。你写一段Python脚本，用PIL或者OpenCV就能画出成千上万张带有位置、尺寸、颜色、噪声变化的标准图像。这不仅是省事，更意味着你对数据分布有绝对的控制权，这是很多公开数据集给不了你的优势。

再说算力。CNN训练最怕的就是“模型太大、机器带不动”。形状识别是天然的小任务，输入图片64×64或者128×128就够了，网络结构也不需要很深。我带的项目里，大多数同学用个人笔记本的CPU就能把整个训练流程跑完，只是时间长短的问题。如果是GPU环境，几十秒一个epoch，十分钟内收敛到90%以上的准确率很正常。这个特性对学生党来说非常友好。

最后是工作量。毕设答辩最尴尬的场面是什么？老师问“这个项目你自己做了哪些工作”，你支支吾吾答不上来。形状识别的工作量是完整且可见的：你要自己写数据生成脚本、自己设计网络结构、自己调参做对比实验、自己写评估分析。每一步都是一块明确的成果。

1.2 形状识别不是什么玩具，它有真实的工业价值

如果只把形状识别停留在“识别圆形三角形”这个层面，确实显得单薄。但这个任务背后对应的是工业视觉里的一个经典问题：几何形状分类与定位。流水线上检测零件是否合格、分类不同规格的工件、识别图纸中的几何元素，本质上都是类似的思路。

我在实际推进这个项目时，通常会建议同学们把“形状识别”包装成一个更具体的应用场景来展开。比如做一个“传送带上的零件分拣模拟系统”，相机拍摄到的零件图像先做预处理，再通过CNN分清楚它是圆形垫片、方形模块还是三角支架。这样一来，你的毕设题目就有了工程语境，而不是一个孤立的图像分类demo。答辩的时候，老师听到你把这个小任务和实际场景对应上了，第一印象就会好很多。

1.3 和MNIST、CIFAR这些公开数据集相比，自造数据强在哪里

用公开数据集做分类，最大的问题不是难度，而是“大家都在做，你很难做出差异化”。MNIST手写数字识别已经被做到99.7%以上了，你的毕设还能贡献什么新东西？CIFAR-100虽然有100类，但本质上你是在复现一个公开baseline，全程没有自己的数据工程环节。

形状识别则不同。你从零开始设计数据生成方案的时候，就必须认真思考：图片里有哪些干扰因素？尺寸变化要不要考虑？旋转要不要考虑？背景噪声怎么加？这些思考拿到答辩台上是加分项，因为你展现的是一个数据工程师的思维，而不仅仅是一个“调包侠”。更重要的是，很多公开数据集是已经清洗过的，而你自己生成的数据，反而能让你亲身经历一次“数据在什么情况下会让模型学崩掉”的全过程，这个体验很难得。

2. 数据集自造：用Python画出上万张训练图

2.1 手工造数据和网上扒数据的区别

我个人非常坚持“shape识别要用自己生成的数据”，除了前面说的可控性，还有一个原因是：这能从头建立你对数据的敬畏感。我见过太多同学下载一个数据集，不管三七二十一直接开训，遇到问题连数据长什么样都不知道，排查起来完全没有头绪。

自己生成数据，你会明确知道每张图的生成参数。旋转角度是随机的、位置是随机的、颜色是随机的、噪声强度设了某个值，这些信息在你后面分析模型为什么会把三角形错认成正方形时，会发挥巨大的作用。就拿我自己的经验来说，有次模型在验证集上准确率一直上不去，查了很久发现是某些样本的三角形在随机旋转后，顶点被裁切到了图像边缘，轮廓严重变形。如果没有生成参数记录，这个问题几乎不可能定位。

2.2 用PIL批量生成形状样本的实际代码

先确定数据规模。形状识别这个任务，我建议生成2万张左右比较合适，三类形状按数量等分，每类大约6600张。2万张这个量级对CNN来说不算大，但足够训练出一个泛化能力不错的模型，而且生成过程快，CPU环境下几分钟就能跑完。

生成代码我用PIL来做，示例如下：

python复制import os
import random
import numpy as np
from PIL import Image, ImageDraw

SHAPES = ["circle", "square", "triangle"]
COLORS = [
    (200, 30, 30),
    (30, 120, 200),
    (30, 160, 60),
    (220, 150, 30),
    (150, 50, 180),
]

def add_noise(img_array, noise_level=10):
    noise = np.random.randint(-noise_level, noise_level, img_array.shape)
    return np.clip(img_array + noise, 0, 255).astype(np.uint8)

def draw_shape(draw, shape, cx, cy, r, color):
    if shape == "circle":
        draw.ellipse([cx - r, cy - r, cx + r, cy + r], fill=color)
    elif shape == "square":
        half = int(r * 1.2)
        draw.rectangle([cx - half, cy - half, cx + half, cy + half], fill=color)
    elif shape == "triangle":
        points = [
            (cx, cy - r),
            (cx - int(r * 0.9), cy + int(r * 0.7)),
            (cx + int(r * 0.9), cy + int(r * 0.7)),
        ]
        draw.polygon(points, fill=color)

def generate_dataset(root="shape_dataset", total_per_class=6600, img_size=64):
    for split in ["train", "val", "test"]:
        for shape in SHAPES:
            os.makedirs(os.path.join(root, split, shape), exist_ok=True)

    # 先确定每个split的分配比例：train 80%, val 10%, test 10%
    for shape in SHAPES:
        indices = list(range(total_per_class))
        random.shuffle(indices)
        train_n = int(total_per_class * 0.8)
        val_n = int(total_per_class * 0.1)
        splits = {
            "train": indices[:train_n],
            "val": indices[train_n:train_n + val_n],
            "test": indices[train_n + val_n:],
        }
        for split, id_list in splits.items():
            for idx in id_list:
                img = Image.new("RGB", (img_size, img_size), (245, 245, 245))
                draw = ImageDraw.Draw(img)
                r = random.randint(12, img_size // 2 - 6)
                cx = random.randint(r + 4, img_size - r - 4)
                cy = random.randint(r + 4, img_size - r - 4)
                color = random.choice(COLORS)
                draw_shape(draw, shape, cx, cy, r, color)
                # 加随机小线段作为背景杂讯
                for _ in range(3):
                    x1 = random.randint(0, img_size - 1)
                    y1 = random.randint(0, img_size - 1)
                    x2 = random.randint(0, img_size - 1)
                    y2 = random.randint(0, img_size - 1)
                    draw.line([x1, y1, x2, y2], fill=(180, 180, 180), width=1)
                img_array = np.array(img)
                img_array = add_noise(img_array, noise_level=8)
                img = Image.fromarray(img_array)
                img.save(os.path.join(root, split, shape, f"{idx:05d}.png"))

if __name__ == "__main__":
    random.seed(42)
    np.random.seed(42)
    generate_dataset()

这段代码有几个值得注意的细节。一是颜色随机，每类形状都会以不同颜色出现，避免了模型靠“颜色”作弊识别类别，这在数学上叫防止“shortcut learning”。二是在背景里加了几条浅色线段作为干扰，目的是一开始就把任务难度调到“有但又不会太难”的档位，让模型的鲁棒性得到真实锻炼。三是噪声范围控制在了8左右，不会严重破坏轮廓，但也足以模拟真实相机传感器的噪点。

2.3 旋转、缩放、遮挡：对手越强，模型越强

刚才的代码里，形状的位置和大小是随机的，但旋转其实还没做进去。如果你想让模型真正学到“你这个形状转成什么角度都是同一个东西”，就要把形状本身旋转后再绘制。

旋转怎么设计？在PIL里可以直接绘制一张临时图，旋转后再贴到背景上。这个实战操作里有个小技巧：旋转时需要用边界矩形，否则边缘会被裁掉。比如三角形是锐利的顶点，旋转到45度附近时，原始包围盒很容易装不下，所以你要在旋转前就预留出足够大的画布，旋转完再裁剪到目标尺寸。

遮挡这个因素，我建议在进阶版本里再加入。用几个随机位置的不透明矩形覆盖住形状的一部分，模拟真实场景中零件被部分遮挡的情况。加了这一步之后，模型的泛化能力会明显强一截，但也意味着训练难度上升，前期阶段可以先不加，等基础模型跑通之后再做对比实验，这也是毕设里可以写进报告里的“消融实验”的一部分。

2.4 数据划分：别把验证集和测试集混为一谈

代码里我用了8:1:1的比例切分，这和很多公开数据集的做法一致。但要注意一个容易犯的错：验证集和测试集的用途完全不同。验证集是训练过程中反复用来评估模型、调整超参的；测试集只能在你最终确定模型之后用一次，用来汇报最终泛化指标。如果拿测试集反复试来试去，测试集实际上就变成了验证集，最后报出来的指标会有虚高成分，这在学术规范上是不严谨的。

有些同学图省事直接从train里随机抽几张当val，这种做法会导致同分布样本泄漏，因为同一个类别的同一种干扰形态可能同时出现在train和val里，评估结果会比真实应用场景偏乐观。所以生成时就把三个set完全独立地生成，互不重叠，这个习惯要养成。

3. 搭建CNN模型：一个轻量但五脏俱全的网络

3.1 为什么CNN天生适合做形状识别

形状识别本质上是一个图像分类问题，而CNN在处理图像分类时有一个非常朴素的道理：图像是二维结构，像素之间的相对位置关系极其重要。圆形之所以是圆形，不是因为某个单独的像素点是什么颜色，而是因为那一圈像素在空间上排成了“圆弧”这个模式。

如果用全连接网络去处理图像，每个像素都会被当成一个独立特征，完全丢失了邻域结构信息，模型需要海量参数才能勉强记住各类形状的像素排列。而CNN通过“卷积核在图上滑动”这个操作，只关注每一个局部小窗口内的特征组合，不仅大幅减少了参数数量，还能让模型自动学习到类似“这块区域是弧线”“这两条边形成了直角”这样的中间概念。

我常给同学打的一个比方是：全连接网络像一个非要背下整本书的考生，书里每个字的位置都要硬记；而CNN像抓重点的考生，拿一个小放大镜在书页上滑动，把“关键词”一个一个找出来。找完关键词之后再做合并投票，决定这一页到底是讲三角形的还是讲圆的。

3.2 一个三层卷积的实用模型结构

形状识别不需要重型网络，推荐直接设计一个三层卷积的轻量CNN，训练速度快、显存占用小、过拟合风险低。以下是我在项目里用得最多的结构：

python复制import torch
import torch.nn as nn

class ShapeNet(nn.Module):
    def __init__(self, num_classes=3):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, padding=1),
            nn.BatchNorm2d(16),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2),
            nn.Conv2d(16, 32, kernel_size=3, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2),
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * 8 * 8, 128),
            nn.ReLU(inplace=True),
            nn.Dropout(0.3),
            nn.Linear(128, num_classes),
        )

    def forward(self, x):
        return self.classifier(self.features(x))

输入尺寸是64×64×3，经过三次卷积加池化后，特征图变成8×8×64。为什么是8×8？因为每次MaxPool2d会把宽高减半：64 → 32 → 16 → 8。这个推算是设计网络结构的核心，你在改输入大小时一定要重新算一遍展平后的维度。

3.3 每一层在干什么，参数怎么算出来的

把每一层拆开看，其实是三个层次的特征提取过程。

第一层卷积层有16个卷积核，每个卷积核3×3大小，输入通道3，所以这层的权重参数数量是16×3×3×3再加16个偏置，也就是432+16=448个参数。这16个卷积核会在图上找最基础的视觉模式，比如不同方向的边、角点。第一层池化后，图像从64×64变成32×32，信息量减小但核心模式被保留。

第二层卷积层有32个卷积核，输入是16通道，参数数量32×3×3×16+32=4640。这一层会把第一层找到的“局部边角”组合成“圆弧片段”“直线段组合”这类中间语义。第三层64个卷积核，参数为64×3×3×32+64=18496。这三层卷积加起来约2.36万个参数，和后面全连接层相比占比很小。

真正占参数大头的是全连接层。展平之后是64×8×8=4096维，接128个神经元，权重数量4096×128，约52.4万，再加上最后一层128×3约384。整个模型的总参数量在55万左右，仍然比动辄上千万的ResNet小得多，CPU训练毫无压力。

3.4 为什么不用ResNet、MobileNet这些更“高级”的模型

我经常收到同学反问：既然深度学习这么流行，为什么不直接用ResNet？理由很简单：杀鸡不用牛刀。ResNet几十层深度，在这个只有三类简单几何图形的任务上，绝大部分卷积核学到的特征都冗余了。训练这样的网络需要更大数据量、更长训练时间、更多显存，而最终精度的提升可能只有零点几个百分点。这个投入产出比是毕设项目里需要避开的陷阱。

但是MobileNet这类轻量模型也不是完全不能用。我建议的做法是：主线用自己设计的轻量CNN拿结果，如果学有余力，可以再跑一个预训练的MobileNet做对比实验，比比参数量、推理速度、精度三者之间的权衡。这个对比作为毕设论文里的一个章节是完全够格的。

4. 训练与评估：看着损失下降是种享受

4.1 数据加载：Dataset和DataLoader的正确打开方式

数据集生成好了，接下来要写PyTorch的数据加载模块。很多人直接把这步当成“模板代码”复制粘贴，但数据加载其实直接关系到训练效率，值得认真写。

python复制from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image
import os

class ShapeDataset(Dataset):
    def __init__(self, root_dir, transform=None):
        self.root_dir = root_dir
        self.transform = transform
        self.classes = sorted(os.listdir(root_dir))
        self.class_to_idx = {c: i for i, c in enumerate(self.classes)}
        self.samples = []
        for cls in self.classes:
            cls_path = os.path.join(root_dir, cls)
            for fname in os.listdir(cls_path):
                self.samples.append((os.path.join(cls_path, fname), self.class_to_idx[cls]))

    def __len__(self):
        return len(self.samples)

    def __getitem__(self, idx):
        path, label = self.samples[idx]
        img = Image.open(path).convert("RGB")
        if self.transform:
            img = self.transform(img)
        return img, label

transform_train = transforms.Compose([
    transforms.Resize((64, 64)),
    transforms.RandomRotation(10),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
])

transform_eval = transforms.Compose([
    transforms.Resize((64, 64)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
])

train_dataset = ShapeDataset("shape_dataset/train", transform_train)
val_dataset = ShapeDataset("shape_dataset/val", transform_eval)
test_dataset = ShapeDataset("shape_dataset/test", transform_eval)

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=2)
val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False, num_workers=2)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=2)

注意训练集和验证集用了不同的transform。训练集加了RandomRotation(10)做在线数据增强，相当于每次epoch模型看到的都是旋转了最多10度的样本，这在有效扩大数据规模的同时也提高了模型的旋转鲁棒性。验证集和测试集不做随机增强，保证指标是稳定的、可复现的。

4.2 损失函数、优化器、超参选择的逻辑链条

分类任务最常用的是交叉熵损失。PyTorch里面nn.CrossEntropyLoss()已经帮你把softmax和log都封装好了，输入的是网络原始logit输出，不需要你手动加softmax。它的数学含义是把模型对每个类别的打分转成概率分布，然后再衡量预测分布和真实标签分布之间的差异。

优化器一般推荐Adam起步，学习率设在1e-3。我在实际跑这个任务时，发现Adam+SGD的先后组合也很好用：先用Adam快速下到较低的loss区域，后面换成SGD小学习率微调，这样精度往往能再往上爬一点。但前期调参阶段不要搞这么多花活，一个Adam学到底，把baseline拿到，再考虑优化器切换的对比实验。

batch size这里用了64，这个值比较平衡。如果用的是CPU训练，可以适当调小到32，减少单次前向/反向的显存开销。学习率可以这样判断：如果loss曲线剧烈震荡、不下降，说明学习率大了；如果loss下降非常慢，每次epoch只降一点点，说明学习率小了。

4.3 训练主循环：模型保存与早停

训练代码本身不复杂，复杂的是等待的过程。这里直接给一个带模型保存的完整训练循环：

python复制import torch
from sklearn.metrics import accuracy_score

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = ShapeNet(num_classes=3).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

best_val_acc = 0.0
epochs = 50

for epoch in range(epochs):
    model.train()
    train_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()
        train_loss += loss.item() * images.size(0)

    model.eval()
    all_preds = []
    all_labels = []
    with torch.no_grad():
        for images, labels in val_loader:
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            preds = torch.argmax(outputs, dim=1)
            all_preds.extend(preds.cpu().numpy())
            all_labels.extend(labels.cpu().numpy())

    val_acc = accuracy_score(all_labels, all_preds)
    avg_train_loss = train_loss / len(train_dataset)

    print(f"Epoch {epoch+1:03d} | Train Loss: {avg_train_loss:.4f} | Val Acc: {val_acc:.4f}")

    if val_acc > best_val_acc:
        best_val_acc = val_acc
        torch.save(model.state_dict(), "best_model.pth")
        print(f"  -> Best model saved, Val Acc: {best_val_acc:.4f}")

这段代码里有两个习惯值得养成。一是每轮epoch都在验证集上算准确率，然后保存“当前最优”的模型，而不是最后一步的模型。深度学习训练中，最后一轮不一定是最好的，过拟合往往发生在训练后期，所以“early stopping + 最优checkpoint”是行业里的标准操作。二是把train_loss做成了按样本数平均后的值，这样即使batch size不同、总样本数变化，loss数值还是可比的。

4.4 评估不止看准确率：分类报告和混淆矩阵才见真章

准确率到了90%以上，很多同学就觉得完工了。但毕设答辩时，老师一定会追问“哪些类别更易混淆、为什么”。这时候没有混淆矩阵的分析，你只能支支吾吾。

一个靠谱的做法是：加载best_model.pth，在test集上跑一遍，然后打分类报告和混淆矩阵。

python复制import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.metrics import classification_report, confusion_matrix

model.load_state_dict(torch.load("best_model.pth"))
model.eval()

y_true = []
y_pred = []
with torch.no_grad():
    for images, labels in test_loader:
        images = images.to(device)
        outputs = model(images)
        preds = torch.argmax(outputs, dim=1)
        y_true.extend(labels.numpy())
        y_pred.extend(preds.cpu().numpy())

print(classification_report(y_true, y_pred, target_names=["circle", "square", "triangle"]))

cm = confusion_matrix(y_true, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues",
            xticklabels=["circle", "square", "triangle"],
            yticklabels=["circle", "square", "triangle"])
plt.xlabel("Predicted")
plt.ylabel("True")
plt.savefig("confusion_matrix.png")

如果你发现三角形被大量错认成了正方形，这一步就能很快定位问题。然后你可以回到数据生成脚本里，统计一下这些被错认的三角形样本长什么样。经验情况下，大部分是尺寸偏小、边界模糊、或者旋转角度让三角形看起来接近直角形状的样本。这类归因分析是论文里“失败案例分析”的绝佳素材。

5. 踩坑实录：那些训练过程中大概率会翻的车

5.1 损失不降，卡在初始值附近

这是新手最容易遇到的第一道坎。训练跑了好几个epoch，loss纹丝不动，准确率约等于随机猜测。原因通常有三个方向，按排查优先级排序。

第一，数据标签错了。自己写生成脚本时，目录名和标签对的对应关系容易在某个地方写岔了。我调试过一个项目，生成时把triangle和square的文件夹目录对调了，但代码却按原逻辑读取，于是模型学到的映射关系完全是相反的，loss降不下去。排查方法很简单：随机挑一批数据，打印图片和标签，肉眼对照。

第二，学习率太高导致loss震荡。Adam虽然自适应学习率，但初始lr=0.01时还是经常震荡不收敛。把lr降到1e-3甚至3e-4通常就稳了。

第三，数据没有归一化。很多人只用了ToTensor把像素缩到0到1之间，但实际上0到1的数据配合BatchNorm通常也能训练。更隐蔽的问题是Normalize的参数设错了，mean和std设得离谱也可能让训练变慢。

5.2 训练集准确率95%，验证集只有80%：典型的过拟合

当train acc和val acc差距超过10个百分点的时候，基本可以确定过拟合了。形状识别这个任务本身维度不高，模型又很轻量，正常情况训练精度和验证精度不会差太多。出现大gap，常见原因有以下几种。

第一个原因是数据量不够或者数据多样性不够。如果每一类只有一两百张图，模型很容易“背题”。解决办法就是回到数据生成脚本，把样本数量和随机干扰范围都增加。

第二个原因是模型容量偏大。把卷积层通道数从16/32/64改成8/16/32，或者在全连接层加Dropout，都能有效缓解过拟合。

第三个原因是训练轮数过长，模型已经在训练集上“死记硬背”噪声了。查看最优模型保存的epoch，如果是在最后几轮才保存的，一般模型已经在过拟合边缘上走过头了。这时候早停策略就很有价值。

5.3 三角形和正方形总是互相混淆

这个案例特别有意思。我们任务里三类都是几何图形，为什么偏偏三角形和正方形容易混淆？我分析了一个典型批次的数据后发现，有两类样本最容易出问题。

第一类是三角形被随机缩放得很小、且旋转后边缘接近水平或垂直时，卷积核抽到的轮廓特征和正方形有点像。第二类是正方形本身被背景杂讯线段干扰得很严重，部分边缘被“切断”，模型在特征图上看到的形状更接近三角轮廓的中心区域。

定位到这一类问题后，我做的第一个修复动作不是改网络，而是改数据生成策略：强制让三角形的旋转角度覆盖均匀分布，并且保证样本的最小尺寸不低于某个阈值，减少极端缩放的样本。改完之后混渎率明显下降。这个经验说明一个问题：数据层的修正往往比网络结构层调整更直接有效。你会意识到，深度学习调试的第一步永远是怀疑数据而不是怀疑模型。

5.4 复现问题：换台电脑结果就对不上了

毕设答辩上，你用自己的笔记本跑一遍，老师不一定看着；但如果同组同学用同一份代码、同一个数据集，结果跑出了不一样的准确率，这个过程就叫“复现性问题”。

严格来说，PyTorch的训练过程涉及多个随机源：数据加载时的shuffle顺序、Dropout的随机失活、卷积权重的初始化、数据增强里的随机旋转角度。这些随机性会导致即使相同参数，每次训练结果也有小幅度波动。为了保证论文里的指标可复现，建议在训练脚本开头固定随机种子：

python复制def set_seed(seed=42):
    import random
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False

set_seed(42)

这样写之后，在同一个软硬件环境里，训练结果基本能复现。也要提前在论文里写清楚实验环境版本：Python版本、PyTorch版本、CUDA版本，这些细节在复现时都会影响结果。

5.5 loss出现nan：数据里没有“爆表”但梯度爆了

虽然这个任务不像RNN那样容易梯度爆炸，但偶尔也会遇到train loss突然变成nan的情况。常见原因有两个：一是学习率太大、Adam修正不过来，梯度值直接溢出；二是输入数据里有全黑的、全白的异常样本，经过归一化后产生了不合法的数值。

一个快速定位技巧是：把batch size调成1，看看是不是某个特定样本触发的。如果是，那大概率是这张图的像素值有问题，回到数据生成代码查一下有没有越界写入。如果不是特定样本，就是全局超参问题，把lr调低一个数量级重新跑。

最后再聊几句实在话

我做过很多个方向的毕设辅导，每次面对“什么题目更容易做出成果、又不至于流水账”这个问题，我的答案始终是：不要图热闹，不要追大模型，找一个像形状识别这样“小而完整”的任务，把每个环节做扎实。你从造数据开始，到训练模型结束，最后拿到一套能自己解释的实验结果，这种经验带来的成长，比直接跑通一个几十层的大网络要丰富得多。

另外，这个项目后续能扩展的方向其实不少。如果你想把形状识别升级成“检测+分类”，可以用yolo这类目标检测框架，把形状的位置也框出来；如果你想尝试迁移学习，可以用预训练的ResNet做Fine-tune；如果你想把模型部署出去，用ONNX导出然后做一个网页demo，让用户上传图片实时识别，属于锦上添花的亮点。每一条路都能把你这次积累的底子继续放大。

我个人最大的体会是：项目本身不会决定你的毕设上限，你对项目里每一个失败和困惑的深挖程度才会。所以别急着看结果，过程里那些“为什么loss掉不下去”“为什么这个类容易被混淆”的瞬间，才是你真正学到东西的时刻。