1. 为什么CIFAR-10是检验PyTorch实战能力的试金石
很多人入门深度学习，第一个跑通的往往是MNIST——手写数字识别。28×28的灰度图，10个类别，随便搭个两层卷积就能冲到99%的准确率。但说实话，MNIST已经太"干净"了，干净到几乎无法暴露你在真实项目里会遇到的任何问题。而CIFAR-10就完全不一样了。
CIFAR-10包含60000张32×32的彩色图像，分属10个类别：飞机、汽车、鸟、猫、鹿、狗、青蛙、马、船、卡车。每个类别6000张，其中50000张作为训练集，10000张作为测试集。这个数据集最"折磨人"的地方在于：32×32的分辨率实在太低了，低到很多图像连人眼都要仔细辨认才能分清是猫还是狗。再加上每个类别内部的姿态、光照、背景差异极大，模型很容易在相似的类别之间反复混淆。
我个人的经验是，如果你能在CIFAR-10上把准确率稳定做到90%以上，说明你对PyTorch的数据管道、模型设计、训练策略、正则化手段已经有了比较系统的掌握。如果只能做到70%出头，那大概率是某个环节存在明显的短板——可能是数据增强不够，可能是学习率调度没做好，也可能是模型容量和正则化之间的平衡没找对。
这篇文章我会从零开始，把整个CIFAR-10分类项目的完整流程拆开来讲。不是那种"import完事、fit一下收工"的流水账，而是把每个环节背后的决策逻辑、我踩过的坑、以及实测有效的调参技巧都摊开来说。适合已经了解PyTorch基础语法、想通过一个完整项目把知识串起来的读者，也适合之前跑过CIFAR-10但效果不理想、想找到瓶颈在哪的朋友。
2. 数据管道的搭建：别小看这一步，它决定了上限
2.1 CIFAR-10数据集加载的两种方式与选择逻辑
PyTorch生态里加载CIFAR-10最直接的方式是用torchvision.datasets.CIFAR10。它帮你处理好了下载、解压、缓存、索引的全部流程，一行代码就能拿到数据。但这里有个容易被忽略的细节：torchvision默认下载的数据集存放在./data目录下，如果你在多个项目里反复使用，建议指定一个统一的缓存路径，避免重复下载。
import torch from torchvision import datasets, transforms from torch.utils.data import DataLoader train_transform = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2), transforms.ToTensor(), transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2470, 0.2435, 0.2616]) ]) test_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2470, 0.2435, 0.2616]) ]) train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=train_transform) test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=test_transform) train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=4, pin_memory=True) test_loader = DataLoader(test_dataset, batch_size=256, shuffle=False, num_workers=4, pin_memory=True)另一种方式是自己写Dataset子类，手动读取CIFAR-10的二进制文件。这种方式适合你需要对数据做特殊处理、或者想深入理解数据格式的场景。CIFAR-10的原始数据是每张图1024字节（32×32×3），按行优先排列，标签单独存在另一个文件里。自己解析的话，用numpy.frombuffer配合reshape就能搞定。但对于绝大多数项目来说，torchvision的封装已经足够，没必要重复造轮子。
2.2 归一化参数为什么是这三个数
上面代码里Normalize用的均值[0.4914, 0.4822, 0.4465]和标准差[0.2470, 0.2435, 0.2616]，这不是随便填的，而是CIFAR-10训练集在RGB三个通道上的统计值。用数据集自身的统计量做归一化，能让每个通道的分布都拉到均值0、方差1附近，这对神经网络的收敛速度和稳定性有直接影响。
如果你偷懒直接用mean=[0.5, 0.5, 0.5]、std=[0.5, 0.5, 0.5]，模型也能跑，但收敛会慢一些，最终精度可能差0.5到1个百分点。这个差距在CIFAR-10这种已经卷到90%+的任务上，其实挺关键的。我建议你花两分钟算一下真实统计量，或者直接用上面这组经过验证的值。
2.3 数据增强的尺度拿捏：做少了没用，做多了有害
CIFAR-10的数据增强有几个经典组合。最基础的是RandomCrop(32, padding=4)加RandomHorizontalFlip()。前者先在图像四周填充4个像素，再随机裁剪回32×32，相当于让图像在位置上有±4像素的抖动；后者以50%概率水平翻转，增加左右不变性。
再进一步可以加ColorJitter做颜色扰动，但这里有个坑：ColorJitter的参数不能设太大。我试过brightness=0.5，结果模型在测试集上反而掉了将近2个点。原因是CIFAR-10的图像本身分辨率就低，颜色信息对类别判别很重要，过度扰动会让模型学不到稳定的颜色特征。后来我把brightness、contrast、saturation都控制在0.2以内，效果就比较稳了。
还有一个进阶技巧是RandomErasing或Cutout，随机遮挡图像中的一块区域。这对防止模型过拟合局部纹理很有效，但遮挡面积的比例要控制好，一般设在0.1到0.25之间。太大容易把关键信息遮没，太小又起不到正则化作用。
注意：数据增强只在训练时启用，测试和验证时必须用干净的
test_transform。我见过有人在验证集上也加了随机裁剪，结果验证精度波动特别大，排查了半天才发现是增强用错了地方。
3. 模型设计：从VGG到ResNet，到底选哪个
3.1 一个够用的基线模型长什么样
如果你刚开始做CIFAR-10，我建议先用一个简化版的VGG作为基线。结构不复杂，但足够让你把整个训练流程跑通，并且能到85%左右的准确率。
import torch.nn as nn class SimpleVGG(nn.Module): def __init__(self, num_classes=10): super().__init__() self.features = nn.Sequential( nn.Conv2d(3, 64, 3, padding=1), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.Conv2d(64, 64, 3, padding=1), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.MaxPool2d(2), nn.Conv2d(64, 128, 3, padding=1), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.Conv2d(128, 128, 3, padding=1), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.MaxPool2d(2), nn.Conv2d(128, 256, 3, padding=1), nn.BatchNorm2d(256), nn.ReLU(inplace=True), nn.Conv2d(256, 256, 3, padding=1), nn.BatchNorm2d(256), nn.ReLU(inplace=True), nn.MaxPool2d(2), ) self.classifier = nn.Sequential( nn.Linear(256 * 4 * 4, 512), nn.ReLU(inplace=True), nn.Dropout(0.5), nn.Linear(512, num_classes) ) def forward(self, x): x = self.features(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x这个模型大概有500万参数，在CIFAR-10上训练30到50个epoch，配合适当的学习率调度，能稳定到85%到88%。它的好处是结构清晰，每一层的输入输出维度都很好算，调试起来方便。
3.2 为什么ResNet在CIFAR-10上更值得投入
当你把基线跑到88%左右，想再往上冲，就会遇到瓶颈。这时候ResNet系列是更值得投入的方向。CIFAR-10上常用的ResNet有ResNet-18、ResNet-34，以及专门为小图像设计的ResNet-20、ResNet-32、ResNet-44、ResNet-56。
这里有个关键区别：标准的ResNet-18是为ImageNet的224×224图像设计的，第一层是7×7卷积加stride=2，后面还跟一个maxpool。直接搬到CIFAR-10的32×32图像上，第一次下采样就把特征图缩到16×16，再经过maxpool变成8×8，信息损失太严重。所以针对CIFAR-10的ResNet变体，通常会把第一层改成3×3卷积、stride=1，并且去掉初始的maxpool。
class BasicBlock(nn.Module): def __init__(self, in_planes, planes, stride=1): super().__init__() self.conv1 = nn.Conv2d(in_planes, planes, 3, stride=stride, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(planes) self.conv2 = nn.Conv2d(planes, planes, 3, stride=1, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(planes) self.relu = nn.ReLU(inplace=True) self.shortcut = nn.Sequential() if stride != 1 or in_planes != planes: self.shortcut = nn.Sequential( nn.Conv2d(in_planes, planes, 1, stride=stride, bias=False), nn.BatchNorm2d(planes) ) def forward(self, x): out = self.relu(self.bn1(self.conv1(x))) out = self.bn2(self.conv2(out)) out += self.shortcut(x) out = self.relu(out) return outResNet-20在CIFAR-10上大概27万参数，训练得当能到91%以上。ResNet-56参数多一些，能到93%左右。但参数越多，过拟合的风险也越大，需要配合更强的正则化。
3.3 模型选型的决策依据
到底选哪个模型，我的建议是看你的目标：
| 目标 | 推荐模型 | 预期精度 | 训练时间（单卡） |
|---|---|---|---|
| 跑通流程、理解原理 | SimpleVGG | 85%-88% | 20-30分钟 |
| 追求较高精度 | ResNet-20 | 91%-92% | 40-60分钟 |
| 冲击SOTA | ResNet-56 + 强增强 | 93%-94% | 2-3小时 |
| 学习注意力机制 | ResNet + SE模块 | 93%+ | 2-3小时 |
不要一上来就冲着最复杂的模型去。先把简单模型跑通，理解每个组件的作用，再逐步加复杂度，这样遇到问题时你才知道是哪个环节出了岔子。
4. 训练策略：学习率、优化器与正则化的配合
4.1 学习率调度：Cosine退火为什么比StepLR更稳
学习率是训练过程中最敏感的超参数。设大了loss震荡不收敛，设小了收敛慢还容易陷局部最优。CIFAR-10上最常用的两种调度是StepLR和CosineAnnealingLR。
StepLR的做法是在固定的epoch节点把学习率乘以一个衰减系数，比如每30个epoch乘以0.1。这种方式简单直接，但衰减点前后的loss曲线会有明显的"台阶"，有时候会错过更好的解。
Cosine退火则是让学习率按照余弦曲线从初始值平滑降到接近0。我实测下来，Cosine退火在CIFAR-10上的最终精度通常比StepLR高0.3到0.5个百分点，而且训练过程更稳定，不容易出现loss突然跳变的情况。
from torch.optim.lr_scheduler import CosineAnnealingLR optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4) scheduler = CosineAnnealingLR(optimizer, T_max=200)初始学习率设0.1配合SGD是比较经典的组合。如果你用Adam，初始学习率要降到1e-3左右，否则容易发散。不过CIFAR-10上SGD加动量通常比Adam的最终精度更高，虽然收敛慢一些。
4.2 权重衰减与Dropout的协同
权重衰减（weight decay）和Dropout是两种不同层面的正则化手段。权重衰减在优化器层面惩罚大的权重值，Dropout在模型层面随机丢弃神经元。两者可以同时用，但要注意强度搭配。
我常用的配置是weight_decay=5e-4配合分类头部的Dropout(0.5)。如果模型参数量更大，比如ResNet-56，可以把weight_decay提到1e-3，Dropout保持0.3到0.5。如果发现训练集精度远高于验证集（比如训练95%、验证88%），说明过拟合严重，可以加大weight_decay或者提高Dropout比例。
反过来，如果训练集和验证集精度都很低且接近，那是欠拟合，应该减小正则化强度或者增加模型容量。
4.3 标签平滑：一个被低估的小技巧
标签平滑（Label Smoothing）是我强烈建议在CIFAR-10上尝试的技巧。标准交叉熵用的是one-hot标签，即正确类别为1、其余为0。标签平滑把正确类别的目标值从1降到比如0.9，把其余类别的目标值从0升到0.1/9。
criterion = nn.CrossEntropyLoss(label_smoothing=0.1)这个改动看起来很小，但效果很明显。它防止模型对训练样本过度自信，提升了泛化能力。我在ResNet-20上试过，加了标签平滑后验证精度提升了大约0.5个百分点，而且训练后期的loss曲线更平滑。
4.4 混合精度训练：省显存又提速
如果你的显卡支持混合精度（大多数NVIDIA显卡从Volta架构开始都支持），用torch.cuda.amp可以显著减少显存占用并加速训练。CIFAR-10的模型不算大，但混合精度能让你在同样的显存下开更大的batch size，或者训练更大的模型。
from torch.cuda.amp import autocast, GradScaler scaler = GradScaler() for images, labels in train_loader: images, labels = images.cuda(), labels.cuda() optimizer.zero_grad() with autocast(): outputs = model(images) loss = criterion(outputs, labels) scaler.scale(loss).backward() scaler.step(optimizer) scaler.update()实测在ResNet-56上，混合精度能带来大约30%的速度提升，显存占用减少约40%。精度损失几乎可以忽略，最终准确率差异在0.1个百分点以内。
5. 训练过程中那些让人抓狂的问题与排查思路
5.1 Loss不下降：从数据管道开始查
训练启动后loss纹丝不动，这是最让人焦虑的情况。我的排查顺序是这样的：
第一步，检查数据标签是否对齐。写个小脚本，从train_loader里取一个batch，把图像和标签打印出来，人眼确认一下图像内容和标签是否匹配。我遇到过因为自定义Dataset里索引写错，导致图像和标签完全错位的情况，loss自然降不下去。
第二步，检查归一化是否合理。如果输入数据的数值范围异常（比如没有做ToTensor导致像素值还是0-255），模型第一层就会饱和，梯度传不回去。
第三步，检查学习率是否过大。把学习率降到1e-4试试，如果loss开始下降，说明之前的学习率太大了。
第四步，检查模型输出。用一个随机初始化的模型对固定输入做前向传播，看输出logits的数值范围。如果全是0或者全是很大的值，说明初始化有问题。
5.2 验证精度震荡：BatchNorm和batch size的关系
验证精度在每个epoch之间大幅震荡，比如从85%跳到82%再跳到86%，这种情况通常和BatchNorm有关。BatchNorm在训练时用当前batch的统计量，在验证时用训练集累积的滑动平均统计量。如果batch size太小（比如小于32），每个batch的统计量波动很大，滑动平均就跟不上，导致验证时表现不稳定。
解决办法有两个：一是增大batch size到128或256；二是如果显存不够，可以把BatchNorm的momentum调小一些（默认0.1，可以试0.01），让滑动平均更新得更平滑。
5.3 过拟合的识别与应对
过拟合的典型信号是：训练精度持续上升，验证精度在某个epoch后开始下降或停滞。这时候可以采取以下措施，按优先级排序：
- 增加数据增强强度，比如加入RandomErasing
- 提高weight_decay
- 提高Dropout比例
- 使用标签平滑
- 减少模型参数量
- 早停（Early Stopping）
我一般会先看训练和验证精度的差距。如果差距在3个百分点以内，问题不大；差距在5到8个百分点，需要加正则化；差距超过10个百分点，说明模型容量远超数据量所需，应该换小模型。
5.4 类别混淆分析：找出模型到底在哪儿犯错
CIFAR-10的10个类别里，猫和狗、鹿和马、飞机和船这几对特别容易混。训练完之后，用混淆矩阵看看模型主要在哪些类别之间犯错，比只看总体准确率有价值得多。
from sklearn.metrics import confusion_matrix import seaborn as sns import matplotlib.pyplot as plt model.eval() all_preds, all_labels = [], [] with torch.no_grad(): for images, labels in test_loader: images = images.cuda() outputs = model(images) preds = outputs.argmax(dim=1).cpu().numpy() all_preds.extend(preds) all_labels.extend(labels.numpy()) cm = confusion_matrix(all_labels, all_preds) plt.figure(figsize=(10, 8)) sns.heatmap(cm, annot=True, fmt='d', cmap='Blues') plt.xlabel('Predicted') plt.ylabel('True') plt.show()如果发现猫和狗的混淆特别严重，可以考虑针对这两类做额外的数据增强，或者用更细粒度的特征提取方法。不过说实话，32×32的图里猫和狗本来就难分，人眼准确率也就八成左右，模型能到九成已经不错了。
6. 把精度从90%推到94%的进阶手段
6.1 学习率预热：前几个epoch的稳定器
学习率预热（Warmup）是在训练最开始的一小段时间里，把学习率从很小的值线性增加到初始值。这样做是为了避免训练初期模型参数随机初始化时，大学习率导致的不稳定。
def warmup_lr(epoch, warmup_epochs=5, base_lr=0.1): if epoch < warmup_epochs: return base_lr * (epoch + 1) / warmup_epochs return base_lr配合Cosine退火，前5个epoch做warmup，后面按余弦下降。这个组合在ResNet系列上特别有效，能明显减少训练初期的loss震荡。
6.2 CutMix与MixUp：让模型学会"插值"
CutMix和MixUp是两种更强的数据增强方法。MixUp把两张图按比例线性混合，标签也按同样比例混合；CutMix则是把一张图的一块区域剪切粘贴到另一张图上，标签按面积比例混合。
def mixup_data(x, y, alpha=0.2): lam = np.random.beta(alpha, alpha) batch_size = x.size(0) index = torch.randperm(batch_size).cuda() mixed_x = lam * x + (1 - lam) * x[index] y_a, y_b = y, y[index] return mixed_x, y_a, y_b, lam def mixup_criterion(criterion, pred, y_a, y_b, lam): return lam * criterion(pred, y_a) + (1 - lam) * criterion(pred, y_b)这两种方法能让模型在训练时见到更多"中间态"的样本，提升决策边界的平滑性。我在ResNet-20上加了MixUp之后，验证精度从91.2%提到了92.1%。但要注意，MixUp需要更长的训练轮数才能收敛，通常要200个epoch以上。
6.3 随机深度：给ResNet加一点"随机性"
随机深度（Stochastic Depth）是在训练时以一定概率随机跳过ResNet的某些残差块，测试时使用完整的网络。这相当于一种结构层面的正则化，能防止模型对某些层的过度依赖。
实现方式很简单，在BasicBlock的forward里加一个概率判断：
class StochasticBasicBlock(nn.Module): def __init__(self, in_planes, planes, stride=1, survival_prob=0.8): super().__init__() self.survival_prob = survival_prob self.block = BasicBlock(in_planes, planes, stride) def forward(self, x): if self.training: if torch.rand(1).item() > self.survival_prob: return x return self.block(x)survival_prob一般设在0.7到0.9之间。层数越深的网络，这个技巧的效果越明显。ResNet-56上加随机深度，能提升0.3到0.5个百分点。
6.4 测试时增强：不训练也能涨点
测试时增强（Test Time Augmentation, TTA）是在推理阶段对同一张图做多种变换（比如原图、水平翻转、小幅度裁剪），分别预测后取平均。这不需要重新训练，直接在已有模型上就能用。
def predict_tta(model, images): model.eval() preds = [] with torch.no_grad(): preds.append(model(images)) preds.append(model(torch.flip(images, dims=[3]))) return torch.stack(preds).mean(dim=0)TTA通常能带来0.2到0.5个百分点的提升，代价是推理时间翻倍。对于离线评测或者对延迟不敏感的场景，这个技巧很划算。
7. 完整训练脚本的组织与实验管理
7.1 把配置抽出来：别把超参数散落在代码各处
一个可维护的训练脚本，应该把超参数集中管理。我习惯用一个字典或者简单的配置类来存所有可调参数：
config = { 'model': 'resnet20', 'epochs': 200, 'batch_size': 128, 'lr': 0.1, 'momentum': 0.9, 'weight_decay': 5e-4, 'warmup_epochs': 5, 'label_smoothing': 0.1, 'mixup_alpha': 0.2, 'use_amp': True, 'seed': 42, }这样做的好处是，当你需要对比不同配置时，改一个字典就行，不用在代码里到处找参数。而且方便把配置和训练日志一起保存，方便回溯。
7.2 日志记录：训练曲线比最终数字更重要
我见过很多人只记录最终准确率，训练过程中的loss和精度曲线一概不留。这样一旦结果不理想，根本不知道问题出在哪个阶段。
建议每个epoch结束后记录：训练loss、训练精度、验证loss、验证精度、当前学习率。用tensorboard或者简单的CSV文件都行。训练完之后把曲线画出来，能一眼看出是过拟合、欠拟合还是学习率调度有问题。
import csv with open('train_log.csv', 'w', newline='') as f: writer = csv.writer(f) writer.writerow(['epoch', 'train_loss', 'train_acc', 'val_loss', 'val_acc', 'lr']) for epoch in range(config['epochs']): train_loss, train_acc = train_one_epoch(...) val_loss, val_acc = validate(...) writer.writerow([epoch, train_loss, train_acc, val_loss, val_acc, scheduler.get_last_lr()[0]])7.3 随机种子的设置：让实验可复现
深度学习实验的随机性来源很多：参数初始化、数据打乱、Dropout、数据增强的随机变换。如果不固定种子，同样的代码跑两次结果可能差0.5个百分点以上，这会让调参变得毫无意义。
import random import numpy as np def set_seed(seed=42): 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注意，cudnn.deterministic=True会稍微降低训练速度，但能保证结果可复现。在调参阶段建议开启，最终跑正式结果时可以根据需要关掉。
8. 一些实测有效的经验与容易忽略的细节
8.1 Batch size与学习率的联动关系
很多人不知道batch size和学习率是需要联动调整的。经验法则是：batch size翻倍，学习率也大致翻倍。这是因为更大的batch size意味着梯度估计更准确，可以承受更大的步长。
如果你因为显存限制只能用64的batch size，那学习率应该从0.1降到0.05左右。反过来，如果你用512的大batch，学习率可以提到0.2甚至0.4。当然这不是线性的，具体还要看优化器和模型。
8.2 验证集的使用：别用测试集调参
CIFAR-10的测试集只有10000张，如果你反复用测试集来调超参数，很快就会过拟合测试集。正确的做法是从50000张训练集里划出5000张作为验证集，用验证集来选模型和调参，测试集只在最后评估一次。
from torch.utils.data import random_split train_size = len(train_dataset) - 5000 val_size = 5000 train_subset, val_subset = random_split( train_dataset, [train_size, val_size], generator=torch.Generator().manual_seed(42) )注意，random_split之后，两个子集共享同一个transform。如果你想让验证集用不同的transform，需要分别创建dataset再拆分索引。
8.3 模型保存：保存什么、什么时候保存
不要只保存最后一个epoch的模型。我的习惯是保存三个文件：最后一个epoch的模型、验证精度最高的模型、以及训练日志。验证精度最高的模型往往不是最后一个epoch的，因为后期可能过拟合。
best_acc = 0 for epoch in range(epochs): train(...) val_acc = validate(...) if val_acc > best_acc: best_acc = val_acc torch.save(model.state_dict(), 'best_model.pth') torch.save(model.state_dict(), 'last_model.pth')保存state_dict而不是整个模型，这样加载时更灵活，也不容易因为代码结构变化而出错。
8.4 学习率找边界：一个快速确定初始学习率的方法
如果你不确定初始学习率设多少合适，可以用Leslie Smith提出的LR Range Test。做法是让学习率从一个很小的值（比如1e-6）线性增加到较大的值（比如1），每个batch记录loss，然后画出loss随学习率变化的曲线。loss下降最快的那个学习率，就是比较合适的初始值。
这个方法我在新数据集上经常用，比盲目试0.1、0.01、0.001高效得多。CIFAR-10上通常会在0.05到0.2之间找到最优点。
8.5 关于训练轮数的经验值
CIFAR-10上不同模型的推荐训练轮数：
- SimpleVGG：50到80个epoch
- ResNet-20：200个epoch（配合Cosine退火）
- ResNet-56：200到300个epoch
- 带MixUp/CutMix：300到400个epoch
训练轮数不够，模型还没收敛；轮数太多，过拟合风险增加。配合Cosine退火时，T_max应该设成总epoch数，让学习率在训练结束时刚好降到接近0。
9. 从CIFAR-10出发还能往哪走
把CIFAR-10做到93%以上之后，这个数据集能教给你的东西就差不多了。接下来可以往几个方向延伸：一是换更复杂的数据集，比如CIFAR-100（100个类，每类600张）或者Tiny ImageNet（200个类，64×64图像）；二是尝试更先进的网络结构，比如EfficientNet、ConvNeXt的轻量版本；三是把训练好的模型部署到实际应用中，比如用ONNX导出、用TensorRT加速推理。
但不管往哪走，CIFAR-10上积累的这些基本功——数据管道的搭建、模型结构的理解、训练策略的调优、问题排查的思路——都是通用的。我个人的体会是，与其在十个数据集上各跑一遍demo，不如在一个数据集上把每个环节都吃透。CIFAR-10就是那个最适合"吃透"的数据集，它足够小，让你能在单卡上快速实验；又足够难，让你必须认真对待每一个细节才能拿到好结果。
