CIFAR10彩色图片识别实战：用PyTorch搭建CNN并提升准确率到88%+

每次带新同学入门深度学习，我都会安排一个固定动作：先跑通MNIST，再立刻上CIFAR10彩色图片识别。很多人在MNIST上刷到99%准确率后信心爆棚，转头在CIFAR10上却被锤得怀疑人生——训练集准确率飙到99%，验证集死活卡在50%上下。这不是你笨，而是CIFAR10这个数据集恰好卡在一个尴尬的位置：图片分辨率低到人眼都费劲，类别又多又杂，彩色通道还引入了三倍的信息量，它才是真正检验“你有没有理解训练闭环”的第一道门槛。

这篇内容我会把从零开始做CIFAR10彩色图片识别的完整过程掰开揉碎，包括数据集解析、CNN结构设计、PyTorch训练代码、数据增强策略、过拟合排查以及一套能稳定刷到88%以上的调优路线。无论你是课程作业做到P2周，还是想找个小项目练手，这篇文章都能直接照着抄。

1. 数据规模、通道与32x32尺寸带来的三重挑战

1.1 CIFAR-10的基本盘

先把这个数据集的家底摸清楚。CIFAR-10由60000张32x32的彩色图片组成，共10个类别：飞机（airplane）、汽车（automobile）、鸟（bird）、猫（cat）、鹿（deer）、狗（dog）、青蛙（frog）、马（horse）、船（ship）、卡车（truck）。其中50000张作为训练集，10000张作为测试集，每个类别的图片数量严格均衡，各6000张。

每张图片是32x32像素、RGB三通道，也就是说输入维度是32x32x3=3072。作为对比，MNIST是28x28灰度图，只有784维。别小看这不到4倍的数据量差距，从784维跳到3072维，再加上从黑白到彩色的语义复杂度跃升，整个问题的难度不是一个量级。

官方把数据分成了5个训练批次加1个测试批次，也就是cifar-10-batches-py目录下的data_batch_1到data_batch_5和test_batch。每个batch用pickle存储，包含10000张图。在实际开发中我强烈建议直接用torchvision.datasets.CIFAR10加载，官方接口帮你处理好了文件读取、标签映射和格式转换，没必要自己写pickle解析逻辑，除非你想做底层练习。

1.2 32x32小尺寸带来的视觉信息挑战

这是整个项目最核心的难点。32x32分辨率有多低呢？相当于一张图放大后在屏幕上只有指甲盖大小。人眼去区分其中一些类别都费劲——尤其是猫和狗、鹿和马，轮廓模糊、背景杂乱、光线不均，很多细节已经被压缩得不成样子。

MNIST之所以简单，是因为手写数字的笔画结构清晰，前景和背景对比强烈，而且类别之间的结构差异非常明显。CIFAR-10则是典型的自然图像，有大量纹理、颜色渐变、边缘干扰和背景噪声，模型必须学会从极度有限的分辨率中提取真正有区分度的特征。

这个特性直接决定了一个问题：简单模型很容易在训练集上表现完美，但完全无法泛化到验证集。因为图片分辨率低、信息冗余少，模型只要记住了训练集中少数几个判别性特征（比如某个像素块的颜色组合），就能在训练集上拿到很高准确率，这些特征在验证集上毫无用处。

我见过很多第一次做CIFAR-10的人，训练集准确率冲到99%后兴奋地说“我超过SOTA了”，结果验证集准确率只有50%。这不是模型不够好，而是它把训练集的噪声全背下来了。

1.3 彩色通道意味着什么

RGB三通道不仅仅是输入维度的变化，它带来了新的特征维度。颜色分布对大类别区分有很强的指示作用：青蛙偏绿、船和卡车常在蓝色背景中出现、汽车和卡车颜色偏向金属色。这也是为什么在CIFAR-10上，一个结构合适的CNN能比在MNIST上更早地从颜色通道中学到有效特征。

三通道输入对代码最直接的影响是：定义第一个卷积层时输入通道数必须是3，而不是1。如果你从MNIST代码迁移过来，最容易出bug的地方就是nn.Conv2d(1, 32, 3)忘改成nn.Conv2d(3, 32, 3)，报错还算好排查，但更隐蔽的问题是输入三通道后没有做归一化，导致模型收敛极慢。

另外一个容易被忽略的点是归一化。灰度图归一化可能只是“锦上添花”，但彩色图像如果不做归一化，RGB三个通道的取值范围不一致（受光线、物体颜色影响），会让梯度的尺度在不同通道间失衡，导致训练不稳定。CIFAR-10官方推荐的归一化参数是mean=(0.4914, 0.4822, 0.4465)，std=(0.2023, 0.1994, 0.2010)，后面我会专门说为什么这组数值不能随便换。

2. 用PyTorch搭建一个能跑通的彩色图像分类网络

2.1 为什么是CNN而不是全连接网络

有些人上来就问：32x32也不大，能不能直接用全连接网络硬吃？如果你把3072维拉平，用三层全连接，第一层到第二层哪怕只映射到1024个神经元，参数量就是3072x1024≈314万。这还只是一层，整个网络参数量冲到千万级，在没有大量数据增强和正则化的情况下，训练集直接过拟合到爆。

CNN解决这个问题的核心思路是局部连接和参数共享。一个3x3的卷积核只关注局部邻域内的像素关系，而且同一个核在所有位置重复使用。这相当于用“扫描”的方式提取图像各处的局部特征，既大幅减少参数量，又天然具备平移不变性。用人话说就是：一张猫脸在图片左上角还是右下角，卷积核都能识别出来，而全连接网络做不到这一点。

在CIFAR-10这种既有空间结构又有局部纹理区分度的数据集上，CNN是性价比最高的选择。实践数据也很直观：一个参数量在80万左右的CNN可以刷到85%以上的验证准确率，而一个全连接网络在同样参数量下往往只能到45%-55%。

2.2 一个基础但完整的CNN结构

我下面给的模型结构是经过多次实验验证的“稳妥方案”，不是最花哨的，但跑起来很稳，训练时间也适中，非常适合作为P2周的结构模板。

python复制import torch
import torch.nn as nn

class CIFAR10CNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.features = nn.Sequential(
            # Block 1: 3 -> 32
            nn.Conv2d(3, 32, kernel_size=3, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
            nn.Conv2d(32, 32, kernel_size=3, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2),

            # Block 2: 32 -> 64
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2),

            # Block 3: 64 -> 128
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2),
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(128 * 4 * 4, 256),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(256, num_classes),
        )

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

每经过一个Block，空间尺寸减半：32x32 -> 16x16 -> 8x8 -> 4x4；通道数翻倍：3 -> 32 -> 64 -> 128。这种设计遵循了CNN的经典范式：越往深层，空间分辨率越低，但通道数越多，提取的特征越抽象。最后的全连接层输入是128x4x4=2048维，映射到256维再接10维输出。

padding=1的作用是让3x3卷积不改变特征图尺寸，这样下采样完全由MaxPool控制。我一般不用stride=2的卷积做下采样，因为对CIFAR-10这种小图来说，MaxPool的无参数方式更稳，能保留更强的平移不变性。BatchNorm2d是我强烈建议加上的，在32x32这种小分辨率下，BatchNorm能显著加速收敛，还能起到一定的正则化作用，减少对学习率初始值的敏感度。

2.3 损失函数与优化器选择

多分类任务的首选是nn.CrossEntropyLoss。很多人第一次写的时候会试图自己先做softmax再算损失，这其实没必要——PyTorch的CrossEntropyLoss内部已经包含了log_softmax和NLLLoss的计算，直接输入模型的原始logits就行，再手动加softmax反而会造成数值不稳定。

优化器方面，对于这个小模型，我的建议是SGD加momentum，而不是一上来就用Adam。Google Colab上T4 GPU跑50个epoch也就十分钟出头，用SGD多一点耐心，能得到更平滑、更泛化的收敛结果。相比Adam，SGD+momentum虽然在前期收敛慢，但后期验证准确率上限通常更高，这在小数据集上体现得很明显。

python复制import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)

weight_decay=5e-4是CIFAR-10上的经典默认值，相当于对参数做L2正则化，抑制过拟合。学习率初始0.1配合余弦退火，会在训练后期自动降到接近0，帮助模型收敛到更平坦的极小值点。这套配置没有太多花里胡哨的东西，但它是CIFAR-10上验证过无数次的黄金组合。

2.4 完整的训练循环代码

光有网络定义还不够，我直接把完整训练代码也放出来。这段代码已经去掉了所有无关逻辑，是可以直接跑通的最小闭环。

python复制import torch
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader, SubsetRandomSampler
import numpy as np

# 数据预处理：仅仅归一化，增强在后面章节单独展开
transform_train = transforms.Compose([
    transforms.RandomCrop(32, padding=4),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])

transform_test = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])

# 加载数据集
train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)
test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)

# 从训练集中切出5000张作为验证集
num_train = len(train_dataset)
indices = list(range(num_train))
np.random.shuffle(indices)
val_size = 5000
val_indices = indices[:val_size]
train_indices = indices[val_size:]

train_loader = DataLoader(train_dataset, batch_size=128, sampler=SubsetRandomSampler(train_indices), num_workers=2)
val_loader = DataLoader(train_dataset, batch_size=128, sampler=SubsetRandomSampler(val_indices), num_workers=2)
test_loader = DataLoader(test_dataset, batch_size=128, shuffle=False, num_workers=2)

# 训练
def train_one_epoch(model, loader, criterion, optimizer, device):
    model.train()
    total_loss, correct, total = 0, 0, 0
    for inputs, labels in loader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        total_loss += loss.item() * inputs.size(0)
        _, predicted = outputs.max(1)
        total += labels.size(0)
        correct += predicted.eq(labels).sum().item()
    return total_loss / total, 100.0 * correct / total

def evaluate(model, loader, criterion, device):
    model.eval()
    total_loss, correct, total = 0, 0, 0
    with torch.no_grad():
        for inputs, labels in loader:
            inputs, labels = inputs.to(device), labels.to(device)
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            total_loss += loss.item() * inputs.size(0)
            _, predicted = outputs.max(1)
            total += labels.size(0)
            correct += predicted.eq(labels).sum().item()
    return total_loss / total, 100.0 * correct / total

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = CIFAR10CNN().to(device)
best_acc = 0.0

for epoch in range(50):
    train_loss, train_acc = train_one_epoch(model, train_loader, criterion, optimizer, device)
    val_loss, val_acc = evaluate(model, val_loader, criterion, device)
    scheduler.step()
    if val_acc > best_acc:
        best_acc = val_acc
        torch.save(model.state_dict(), 'best_model.pth')
    print(f'Epoch {epoch+1:02d} | Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.2f}% | Val Acc: {val_acc:.2f}%')

这段代码有几点值得注意。一是验证集从训练集里切了5000张出来，而不是直接拿官方测试集当验证集用。为什么这么做？因为测试集是最终评估用的，如果你反复用测试集来调参，模型会对测试集产生隐式的过拟合，最终报告出来的准确率会有水分。正确的姿势是训练过程中只跟验证集打交道，全部调参完成后才用测试集做最终评估。

二是SubsetRandomSampler的用法。这里对每个epoch都会重新打乱train_indices，确保每个epoch看到的训练子集顺序不同，有助于收敛。验证集的sampler不需要shuffle，保持固定评估集合即可。

三是model.train()和model.eval()的切换。很多新手忘记这步，导致训练完成后模型还处于train模式，Dropout和BatchNorm的行为与推理阶段不一致，验证准确率会莫名其妙地偏低。我在所有评估函数里都会显式调用model.eval()，这是一个好习惯。

四是torch.no_grad()。验证阶段不需要计算梯度，加上这个能节省显存并加速推理，在CIFAR-10这种小数据集上虽然差别不明显，但养成了习惯以后做大项目能省不少事。

3. 训练闭环中的关键配置与调试细节

3.1 数据增强：让有限的5万张图片发挥更大价值

如果你直接在原始数据集上训练上面的模型，不做任何增强，大概能到78%-80%的验证准确率。这已经是“能跑通”的级别，但离CIFAR-10的真正水平还差不少。数据增强把它拉到85%以上几乎是必须的。

我在代码里用的增强手段有两招：一是RandomCrop(32, padding=4)，二是RandomHorizontalFlip()。第一招的效果是：先把图片四周各填充4个像素（默认填0），再随机裁剪回32x32，相当于人为制造了随机平移效果。同一张图每次喂给模型的位置都略有不同，模型就不会再死记某个像素点的绝对位置。第二招是水平翻转，进一步扩充训练样本的多样性。

有人可能会问：填充的0像素不会引入噪声吗？实测下来影响很小，因为填充区域最终会被裁剪掉绝大部分，而且随机裁剪本身就是为了让模型看到更多平移变体，少量填充像素反而能提供更丰富的边缘信息。当然，你也可以试一下transforms.AutoAugment('CIFAR10')，这是PyTorch内置的自动增强策略，效果更好，但对训练时间的消耗也更大。

核心原则：增强只作用于训练集，验证集和测试集只做ToTensor和Normalize。如果你把增强用到验证集上，验证准确率会变得毫无意义，因为它衡量的不是模型对真实数据的泛化能力，而是模型对增强后的合成图像的适配程度。

3.2 归一化的均值和方差不是随便填的

我在很多网上代码里看到有人用transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))，理由是“这样能把数据映射到[-1,1]”。这话本身没错，只归一化到[-1,1]也能训练，但这不是CIFAR-10的最优解。

CIFAR-10数据集的标准统计值是：mean=(0.4914, 0.4822, 0.4465)，std=(0.2023, 0.1994, 0.2010)。这组数值是计算了整个数据集的每个通道像素均值与标准差得到的。使用它们做归一化，相当于把每个通道的分布拉回到均值为0、方差为1的标准正态分布附近。用0.5那组数据，相当于假设每个通道的分布都是对称均匀的，但实际上CIFAR-10的蓝色通道偏暗、绿色通道偏亮，并不对称，这会拖慢收敛速度。

在一个35个epoch的实验里，我用标准统计值做归一化，验证准确率在83%左右，而用0.5归一化，同样配置只有79%-80%，而且前5个epoch明显收敛更慢。这个差距不小，也不需要额外成本，直接套用标准统计值就好。

3.3 验证集怎么切最合理

很多教程直接用官方测试集做验证集，在训练循环里打log时报告测试集准确率。这种做法的问题在于：一旦你根据测试集结果调整了超参数，测试集就不再是“没见过”的数据了。你在CIFAR-10上反复调参，最终测试集准确率的可信度会打折扣。

更严格的做法是从50000张训练集中切出一部分做验证集。具体切多少？5000张比较合适，剩余45000张训练。12分之一的比例既能保证验证集统计波动不大，也不会让训练数据损失太多。如果你只切1000张，验证准确率会上下跳得很厉害，看起来像模型不稳定，其实是验证集本身太小，采样噪声太大。

官方测试集留在最后用。等所有超参数定下来、模型训练完，再把在验证集上表现最好的权重加载到测试集上跑一次，拿到最终的泛化能力评估。这个数字才是你有底气写在报告里的成绩。

4. 过拟合、学习率震荡与验证集评估的实战经验

4.1 训练loss下降但验证acc上不去的典型症状

这是我见过最多的故障现象。训练loss稳步下降到0.1以下，训练准确率冲到99%甚至100%，但验证准确率在50%-60%区间反复横跳，怎么都上不去。这就是过拟合的教科书式症状。

为什么CIFAR-10上过拟合这么容易出现？核心原因是32x32的分辨率太小，有效信息量有限，模型很容易找到训练集中某些独特的像素组合来记忆每个样本。尤其当模型参数量偏大、训练轮数偏多、数据增强不足时，记忆训练集的“捷径”远比学习泛化特征容易得多。

直觉化的解释是：模型像一个记忆力超强的学生，他靠着背答案可以在平时的练习题上拿满分，但一到模拟考就露馅，因为题目稍微变了个样他就认不出来了。应对过拟合的思路就是“让他多做一些变形题，不给他背答案的机会”——这就是数据增强的作用；同时再降低模型的“背诵能力”——Dropout和weight_decay都是干这个的。

如果你发现验证准确率卡在60%附近上不去，第一步不是改模型结构，而是先看看数据增强有没有生效。我踩过的一个坑是，代码里定义了transform_train，也在DataLoader里传了这个transform，但忘了传给torchvision.datasets.CIFAR10，导致增强完全没生效，训练集却依然能过拟合到99%，白白浪费了好几个epoch。

4.2 学习率震荡的表现与修正

另一种常见症状是loss在下降，但验证准确率的曲线像心电图一样大起大落，每个epoch之间波动超过3个百分点。这通常不是模型结构问题，而是优化过程不稳定的信号。

最可能的原因是学习率太大。SGD初始学习率0.1对于这个模型来说其实偏大了，但配合余弦退火它在后期会降下来，所以总体波动是可以接受的。如果你发现val acc在30个epoch时还在±5%之间震荡，就需要考虑把初始学习率降到0.05甚至0.01。

batch size也会影响震荡。batch size越小，每个batch的梯度噪声越大，更新方向越不稳定。很多人为了省显存把batch size设成32，这在CIFAR-10上也可以，但如果再配合较大的学习率，震荡就会变明显。我推荐batch size至少用128，如果显存充裕，256也可以。当然，batch size过大也会带来另一个问题：收敛变慢，因为每个epoch的梯度更新次数变少了。

怎么判断是学习率还是batch size的问题？看训练集准确率的变化：如果训练集准确率也跟着震荡，说明是优化器更新方向不稳定，多半是学习率的问题；如果训练集准确率稳定上升但验证集剧烈震荡，说明模型在验证集上的泛化能力不稳定，更可能是数据增强不够或验证集划分不合理。

4.3 训练中应该盯哪些指标

新手最容易犯的错是全程只盯着训练loss看，一看loss降了就觉得万事大吉。loss下降只是模型在拟合训练数据的表现，它不能反映泛化能力。我最关注的两个指标是验证集准确率和训练集与验证集准确率的差距。

合理的训练曲线长这样：前5个epoch验证准确率从10%快速爬升到40%-50%，这是模型刚开始学会识别颜色和简单的纹理特征；中间10-20个epoch逐步爬到70%-75%，增速变缓；最后20-50个epoch曲线趋于平缓，从75%一步步磨到85%以上。健康的曲线是单调上升且有边际递减效应，如果曲线中间出现断崖式下跌，通常是学习率出问题了。

CIFAR-10随机猜测的准确率是10%（10个类别均等）。如果你的模型在前几个epoch验证准确率还在10%-20%徘徊，这是正常的，模型的预测能力还不强，但至少证明代码逻辑没有大问题。如果第一个epoch验证准确率就冲到99%，反而要警惕，大概率是数据泄漏了——比如把训练集和验证集混在一起、或者标签在预处理阶段被意外写入特征。

早停（early stopping）的标准怎么定？我一般看连续10个epoch验证准确率没有刷新历史最佳值，就手动停止，然后加载best_model.pth。这个阈值不是固定的，遇到波动大的情况可以放宽到15个epoch。

5. 调优路线图与最终结果

5.1 从基线到增强的里程碑

我按顺序记录了几个关键节点的验证准确率，可以当作参照，但不同机器、不同随机种子跑出来会有波动，重点看相对提升幅度。

从这个表可以看出来，提升最大的两件事是数据增强和BatchNorm，它们都是几乎零成本就能获得5个百分点以上的提升。结构加深也是有限度的，对于CIFAR-10，32-64-128三层卷积块已经够用，继续加深模型（比如上到256通道）收益会变得非常小，但训练时间会明显增加。

5.2 进阶方向：Label Smoothing、MixUp、迁移学习

如果你有余力，下面几个方向值得试试。

Label Smoothing（标签平滑）是一种正则化技巧，它把独热编码的硬标签改成软标签，比如把正确类别的目标概率从1.0改成0.9，剩下0.1平均分给其他9个类别。这样做的目的是让模型不要对训练样本的预测过于自信，间接缓解过拟合。在PyTorch里可以直接设置nn.CrossEntropyLoss(label_smoothing=0.1)，一行代码，实测通常能带来0.5-1个百分点的提升。

MixUp是一种数据增强方法，思路是把两张图按比例混合成一张新图，标签也按相同比例混合。比如按0.5的比例混合一张猫和一张狗，标签就是(猫0.5, 狗0.5)。这个方法在CIFAR-10上效果不错，但实现起来需要自己写collate逻辑，对新手不太友好。有兴趣的可以等基础版本跑通后再尝试。

迁移学习是另一个方向：直接用预训练的ResNet18（backbone），在CIFAR-10上微调，验证准确率能到93%-94%。但需要把输入分辨率调整到224x224或者修改第一层卷积的stride，处理起来稍微麻烦一些。对于P2周这个阶段，我更建议先把基础CNN做到80%以上，再去碰迁移学习，这样能更扎实地理解CNN的工作原理。

5.3 训练时间与硬件参考

训练时长取决于你的硬件。以我上面给的结构和训练配置为例：在Google Colab免费版的T4 GPU上，batch size=128，50个epoch大约需要10-15分钟；在本地M系列Mac上，用MPS后端跑同样的配置，需要30-40分钟；如果只有CPU，跑50个epoch可能要3-4小时，这种情况下建议把epoch数降到20个先验证代码没问题。

如果显存不够，优先做两件事：减小batch size到64（对应修改DataLoader的batch_size参数），或者把网络的通道数从32-64-128改为24-48-96。不要一上来就缩小输入分辨率，32x32已经是最低要求了，再缩下去模型能获取的信息量会严重不足。

训练过程中建议随时保存最佳权重的checkpoint，我前面代码里已经写了torch.save(model.state_dict(), 'best_model.pth')。后续测试或者做可视化时，直接加载这个权重，而不是加载最后一个epoch的权重。最后一个epoch时模型可能已经过了最佳点，验证准确率不升反降，这在余弦退火的后期也时有发生。

测试集准确率和验证集准确率之间通常会有一个小的差距，一般是在0.5-2个百分点之间。如果测试集准确率显著低于验证集，比如低了5个百分点以上，说明验证集的划分有偏差，或者模型对验证集产生了轻度过拟合，这在实际项目中值得警惕。

在实际操作中，我把CIFAR-10当成了检验环境与基本功的试金石

每次在新机器、新环境部署深度学习框架，我都会先跑一遍CIFAR-10的完整流程。这个项目不大不小，既能验证CUDA/PyTorch是否配置正确，也能直观感受到当前硬件的训练速度。做这个项目最大的体会是：不要被“数据集小”迷惑，它的难点全在细节里——归一化参数选没选对、增强有没有生效、验证集有没有切错、best checkpoint记没记住，任何一个环节出问题，最终准确率都会说话。

如果你卡在哪个阶段上不去，每次改动只动一个变量，改完跑3-5个epoch看趋势，不要同时改学习率和模型结构，否则出了问题时你根本定位不到原因。另一个小建议是加一段可视化代码，展示模型对验证集图片的预测结果和置信度，这能帮你直观看出模型在哪些类别上犯糊涂，比单纯的准确率数字信息量大得多。

祝你的模型一次跑通，验证准确率早日突破90%。