PyTorch实战CIFAR-10图像分类：从Kaggle数据到ResNet提交全流程

简介：面向深度学习初学者的实战Kaggle图像分类资源包，围绕CIFAR-10数据集使用PyTorch实现完整竞赛流程。压缩包共1017个文件，大小仅2.34MB：1006张PNG图像是CIFAR-10数据样例，可直接观察各类别特征；4个Python脚本与2个Jupyter Notebook实现数据加载、模型训练与预测提交，3个CSV文件包含标签和提交记录，另有少量pyc缓存，整体流程完整且代码组织清晰。已有180人学习，适合希望在真实竞赛环境中从代码入手理解图像分类的读者。资源内含两版可运行的Notebook，对照checkpoint可查看代码演进与提交差异；训练脚本与submission.csv提交样例能帮助入门者快速对齐数据格式，补全“训练-预测-提交”的完整链路；建议首次使用时按Notebook顺序执行，从而逐步掌握数据加载、模型构建与预测输出的关键写法。整体内容紧凑，可直接结合Kaggle赛题页面边练边学，是实践CIFAR-10图像分类任务的便捷素材。

1. 从零到第一份提交：CIFAR-10 图像分类为什么值得用 PyTorch 打一轮

先把结论放这儿：用 PyTorch 打一轮 Kaggle 的 CIFAR-10 图像分类（就是那个叫 CIFAR-10 - Object Recognition in Images 的经典赛），大概是入门阶段投入产出比最高的实战路线。图只有 32×32，一张普通消费级显卡就训得动，5 万张训练数据也远没到要上分布式、调显存的地步；但一个完整竞赛流程该踩的坑，它几乎全都有——Kaggle 注册、数据集下载、标签映射、数据增强、训练循环、提交格式，一条龙走完，你对「用框架做项目」的理解会和只跑 MNIST 完全不一样。

这适合刚学完 PyTorch 基础框架、想上一个有排行榜反馈的实战项目的人，也适合想在简历里放一个可量化结果的一线开发。我会顺着一条可复现的路径讲：数据怎么进到模型、训练循环怎么写、参数为什么这样设、提交文件怎么对，以及实际踩过的坑。照着做能跑通，想改参数也知道改哪里。

2. 数据闭环：Kaggle 注册、下载与 32×32 图片的 Dataset 封装

2.1 Kaggle 注册与数据下载：验证码、CLI 和两种姿势

先把数据长什么样说清楚。这个比赛里，train 目录下有 5 万张 32×32 的 PNG，按 id 命名；trainLabels.csv 里是 id 到类别名的映射，类别一共 10 个：airplane、automobile、bird、cat、deer、dog、frog、horse、ship、truck。test 目录下有 30 万张无标注图片，提交时按 id 顺序给出预测的类别字符串。这和 torchvision 内置的那份 CIFAR-10 不一样——内置版已经按 5 万/1 万切好且都带标签，而竞赛版要自己处理一整条「无标注推断」链路。想拿到排行榜分数，就得用 Kaggle 竞赛官网的那份数据。

注册这一步，我见过太多人卡在验证码上：页面加载出来了，验证码区域却是空白的，点提交就报「captcha must be filled out」。这多半不是 Kaggle 的问题，而是浏览器广告拦截扩展把验证码所在的 iframe 一起拦掉了。常见做法是：关掉广告拦截扩展、改用普通窗口而不是隐身模式、换一个浏览器再试；还不行就用手机浏览器注册一次，注册通过之后就不再需要页面验证码了。

账号搞定后，推荐用 CLI 下载，而不是在浏览器里等 zip：

# 1. 在当前 Python 环境里装 Kaggle 官方命令行工具 pip install kaggle # 2. 配置 API 密钥：kaggle.com 个人页 -> Settings -> API -> Create New Token mkdir -p ~/.kaggle mv ~/Downloads/kaggle.json ~/.kaggle/ chmod 600 ~/.kaggle/kaggle.json # 3. 先打开比赛页面点 Join Competition 并接受规则，否则下面这步会 403 kaggle competitions download -c cifar-10 unzip -q cifar-10.zip -d cifar-10/

说明一下：-c cifar-10是比赛标识符，去比赛页看 URL 最后一段就是这个值，别自己改。chmod 600是让 CLI 不抱怨存放权限，Windows 用户如果用了 Git Bash 同样需要这一步。如果你习惯在 Kaggle Notebook 里直接干活，那可以改用 kagglehub 接口跑下载，路径逻辑会不太一样，但背后的数据是一样的。我一般推荐本地 CLI，原因是测试集有 30 万张图，解压后占几个 GB，本地存一份，后面反复做验证和推断都方便。

环境上顺便说一下，我用 Anaconda 建独立环境，避免污染 base：

conda create -n cifar python=3.10 -y conda activate cifar pip install torch torchvision pandas pillow

参数说明：Python 3.10 以上和当前版本 PyTorch 的兼容性都很好，不必追最新；torch 和 torchvision 必须配套安装，直接一条pip install torch torchvision默认拉取匹配版本，最不容易出错。GPU 版别靠 pip 默认源猜，去 PyTorch 官网复制对应 CUDA 版本的安装命令，装完再验证。

2.2 目录结构与数据校验：训练前先数清文件

解压完成后先别急着写模型，把目录整理成下面这样，后面所有脚本的路径都不会乱：

data/cifar-10/ ├── train/ # 50000 张 ├── test/ # 300000 张 ├── trainLabels.csv └── sampleSubmission.csv

然后做一次文件计数，这是整个项目里最便宜的一道保险：

import os train_dir = "data/cifar-10/train" test_dir = "data/cifar-10/test" print("train 图片数:", len(os.listdir(train_dir))) # 期望 50000 print("test 图片数:", len(os.listdir(test_dir))) # 期望 300000

如果 test 目录数出来不是 30 万，多半是解压时漏了文件，或者下载的版本不对。这个检查必须在训练前做，因为等训练完才发现测试集少了一万张，提交时平台直接报行数不符，整个训练周期就白费了。

注意：test 目录必须正好 30 万张，多一张少一张都先别进训练环节，先搞清楚数据哪来的。

顺带看sampleSubmission.csv的格式，通常两列：id、label，id 不带.png后缀，label 是类别字符串。后面生成提交文件时严格按这个格式对齐，别自己发明列名。

2.3 写一个 Dataset 类：把 CSV 和图片文件合成模型的输入

现在把「一张一张 PNG + 一张标签表」变成一个 Dataset。我一般这么写：

import pandas as pd from PIL import Image from torch.utils.data import Dataset class KaggleCIFAR10(Dataset): def __init__(self, csv_path, img_dir, transform=None): self.df = pd.read_csv(csv_path) # 两列: id, label self.img_dir = img_dir self.transform = transform self.label_list = sorted(self.df["label"].unique()) # 10 个类别 self.label2idx = {name: i for i, name in enumerate(self.label_list)} def __len__(self): return len(self.df) def __getitem__(self, idx): row = self.df.iloc[idx] img = Image.open(f"{self.img_dir}/{row['id']}.png").convert("RGB") label = self.label2idx[row["label"]] if self.transform: img = self.transform(img) return img, label

逻辑说明：label2idx从整张表取唯一类别名并排序，保证 10 个类稳定映射到 0～9，且每次运行顺序一致。这里有个隐藏收益——训练前打印一次self.label_list，和 torchvision 内置 CIFAR-10 的类别顺序对比一下。理论上两边都按字母序，天然一致，但这个动作花十秒，能省掉后面「标签错位」一整个排查周期。

Image.open读出来是 PIL 对象，convert("RGB")是为防止个别图片是灰度模式导致通道数不一致。transform 放在__getitem__里执行，而不是提前一次性做完，因为增强必须每次采样随机执行，提前做完就失去意义了。

容易忽略的一点：测试集没有 csv，只有图片文件，所以推断时不能用这个 Dataset。我会单独写一个只读图片的 Dataset，或者直接包一层返回img_id和图像，这个到第 4 章推断部分再展开。

3. 模型与训练：PyTorch 实战 CIFAR-10 的 ResNet-18 基线

3.1 模型选型：为什么 ResNet-18 是性价比之王

CIFAR-10 的图只有 32×32，这个尺寸决定了选模型的第一原则：别把 ImageNet 那套 224×224 输入的模型直接硬搬。常见做法是用 ResNet 系，把第一个 7×7 卷积换成 3×3、去掉开头的大池化，让网络在 32×32 上正常工作。torchvision 里的resnet18(num_classes=10)虽然默认按 224 设计，但在 CIFAR-10 上配合增强直接跑，也能到 88%～90%；想再进一步，换 ResNet-34 或宽残差（WideResNet）都行，代价是训练时间变长。

有人会问：现在最新的图像分类模型不是 Swin、ViT 这些 Transformer 系吗？确实能在 CIFAR-10 上跑到 95% 以上，但训练轮数、学习率、增强策略的调参复杂度都明显上升。5 万张 32×32 的小图，CNN 的归纳偏置占尽便宜，Transformer 靠数据量堆出来的优势在这里发挥不出来。我的建议很直接：第一版永远用 ResNet 这类卷积网络做基线，先把流程跑通、把提交分数拿到手，再考虑要不要换更贵的模型。基线的作用是给你一个「正常水平」的参照，之后所有改动都跟它比，这比一上来就追大模型有意义得多。

3.2 最小训练脚本：一屏能看完的训练循环

模型、数据、优化器凑齐之后，训练循环其实很短。下面这版先用 torchvision 内置数据做说明，流程更少；真实比赛里把 2.3 节的 Dataset 换进来，其余完全不用动：

import torch import torch.nn as nn import torchvision from torchvision import datasets, transforms from torch.utils.data import DataLoader transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2470, 0.2435, 0.2616)), ]) transform_val = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2470, 0.2435, 0.2616)), ]) train_ds = datasets.CIFAR10(root="./data", train=True, download=True, transform=transform_train) val_ds = datasets.CIFAR10(root="./data", train=False, download=True, transform=transform_val) train_loader = DataLoader(train_ds, batch_size=128, shuffle=True, num_workers=4) val_loader = DataLoader(val_ds, batch_size=256, shuffle=False, num_workers=4) model = torchvision.models.resnet18(num_classes=10) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=60) model = model.cuda() for epoch in range(60): model.train() running_loss = 0.0 for x, y in train_loader: x, y = x.cuda(), y.cuda() optimizer.zero_grad() loss = criterion(model(x), y) loss.backward() optimizer.step() running_loss += loss.item() scheduler.step() if (epoch + 1) % 10 == 0: print(f"epoch {epoch+1}, loss {running_loss / len(train_loader):.4f}")

参数说明：SGD 配 lr=0.1、momentum=0.9、weight_decay=5e-4 是 CIFAR-10 上被验证过很多次的组合，weight_decay 对每层参数做 L2 正则，能明显压过拟合；CosineAnnealingLR 让学习率在 60 个 epoch 里从 0.1 余弦降到接近 0，前期大步快走、后期小幅精修，比固定学习率稳定多 1～2 个点。batch_size=128 在单卡上足够，4GB 显存就能跑；num_workers 按 CPU 核数一半设，太小会饿着 GPU，太大反而因为进程调度变慢。

参数整理成表会更直观：

另外提一句：如果发现前 5 个 epoch 的 loss 不降，先查两个地方——归一化 stats 是否匹配、输入是否真的过了 ToTensor。这两处错了，换什么模型都救不回来。

3.3 数据增强参数：CIFAR-10 的四个默认增强

CIFAR-10 的增强有非常成熟的配方，我的默认配置长这样：

from torchvision import transforms train_tf = transforms.Compose([ transforms.RandomCrop(32, padding=4), # 四周补 4px，再随机裁回 32×32 transforms.RandomHorizontalFlip(p=0.5), # 一半概率水平翻转 transforms.ToTensor(), # 从 0~255 的 uint8 变成 0~1 的 float32 transforms.Normalize((0.4914, 0.4822, 0.4465), # CIFAR-10 全量 RGB 均值 (0.2470, 0.2435, 0.2616)), # CIFAR-10 全量 RGB 标准差 transforms.RandomErasing(p=0.5, scale=(0.02, 0.33)), # Cutout 变体，随机擦除一块 ])

每个参数都有讲究：padding=4的意思是把 32×32 的图四周各补 4 像素成 40×40，再随机裁 32×32 回来，等价于让模型见到轻微平移的图，这是这个数据集上收益最高的增强之一；翻转概率 0.5 是对称性标准设置，不要随便调大；Normalize 用的是 CIFAR-10 自己的统计量，不是 ImageNet 那组——用 ImageNet 的均值去归一化 0～1 范围的数据，输入分布会整体偏移，轻则收敛慢，重则 loss 卡住。RandomErasing 是后期加的，类似 Cutout，强迫模型不依赖单一特征块，但如果训练轮数少于 40，建议先关掉它，因为它在数据少时会引入额外噪声，反而掉点。

4. 提交与涨点：生成 submission.csv 的三个稳定动作

4.1 推断与提交文件：30 万张图怎么在本地跑完

训练完成后，要把 test 目录 30 万张图全部过一遍模型生成提交文件。这里和训练时有两处关键差异：没有标签、文件量大，所以不能复用训练 Dataset，推断循环也要写成块状，别一张一张读：

import os import pandas as pd import torch from PIL import Image model.eval() test_dir = "data/cifar-10/test" test_files = sorted(os.listdir(test_dir)) # 必须排序，保证 id 顺序稳定 label_names = ["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"] # 与训练 label2idx 对应 pred_ids, pred_labels = [], [] with torch.no_grad(): for i in range(0, len(test_files), 256): batch = [] for f in test_files[i:i + 256]: img = Image.open(os.path.join(test_dir, f)).convert("RGB") batch.append(transform_val(img)) x = torch.stack(batch).cuda() out = model(x) # 水平翻转做一次 TTA，两次前向取平均，稳定涨 0.2~0.4 个点 out = (out + model(torch.flip(x, dims=[3]))) / 2 probs = torch.softmax(out, dim=1) preds = probs.argmax(dim=1).cpu().tolist() for f, p in zip(test_files[i:i + 256], preds): pred_ids.append(f.split(".")[0]) pred_labels.append(label_names[p]) sub = pd.DataFrame({"id": pred_ids, "label": pred_labels}) sub.to_csv("submission.csv", index=False) print(sub.shape) # 期望 (300000, 2)

逻辑说明：sorted保证 test 文件按 id 稳定排列，不然每次生成的提交文件顺序都会变；torch.flip(x, dims=[3])是水平翻转，把原图和翻转图的输出概率取平均，这就是测试时增强（TTA），对 ResNet 这类模型通常能稳定涨一点；argmax拿到的序号，必须用和训练时同一个label2idx的反向映射转成类别字符串，这里是最容易出错的一环。

注意一个问题：30 万张图在本地逐张推断可能要几十分钟到几小时。如果觉得慢，常见做法是把模型转 ONNX，再用推理引擎跑 FP16，或者把 batch 调大到 512 减少 Python 循环开销。但我的建议是——第一个提交先用最简单的版本拿分数，确认流程没问题，再考虑优化速度。一个能打的慢提交，比一个跑飞快的废提交有用得多。

4.2 三个稳定涨点动作：标签平滑、余弦退火与模型平均

基线跑到 90% 上下之后，下面三个动作是我每次必做的，都不动网络结构，风险低、收益稳。

第一个是标签平滑。CrossEntropyLoss 默认把正确类当 1、其他当 0，模型容易过于自信。标签平滑把「1」改成「1-ε」，并把 ε 均匀分给其他类，能明显改善泛化：

class LabelSmoothingCE(nn.Module): def __init__(self, smoothing=0.1): super().__init__() self.smoothing = smoothing def forward(self, logits, target): log_probs = torch.log_softmax(logits, dim=-1) n = logits.size(-1) true_dist = torch.full_like(log_probs, self.smoothing / (n - 1)) true_dist.scatter_(1, target.unsqueeze(1), 1.0 - self.smoothing) return (-true_dist * log_probs).sum(dim=-1).mean()

smoothing=0.1 是 CIFAR-10 上常见的取值，太大（0.3 以上）会让训练 loss 下不去，太小（0.01）等于没加。

第二个是余弦退火，脚本里已经有了，但这里要强调：T_max必须等于 epoch 数，而不是随手填。如果 T_max=60 而只训 30 个 epoch，学习率只走完半条余弦曲线，相当于没退火完；反过来 T_max 大于 epoch 数，学习率降不到最低点。想多涨一点，训完一整轮后把学习率重置再训一轮，这就是 warm restart 思路，对 CIFAR-10 效果很稳。

第三个是模型平均，最稳的涨点方式。不用真的训多个模型，把同一份训练里不同 epoch 的 checkpoint 拿出来，对输出概率取平均即可：

models = [model_epoch_40, model_epoch_50, model_epoch_60] final_prob = sum(torch.softmax(m(x), dim=1) for m in models) / len(models)

参数说明：参与平均的 checkpoint 之间差异要够大才有收益，一般每隔 10 个 epoch 存一个，挑验证集准确率最高的 3～5 个；全用同一训练阶段的会没变化。这三个动作叠一起，从 90% 推到 93%～94% 是可以预期的。

5. 避坑手册：Kaggle 图像分类最容易翻车的 5 个环节

到提交为止完整链路都走通了，但真实比赛里，大部分人不是输给模型，而是输给边界环节。按我的经历排序，注册、下载、环境、推理、训练，每个环节都有一个高频翻车点，先看总表：

下面每条按「现象 → 原因 → 解决」拆开讲。

5.1 账号与下载：验证码消失和 403

坑 1：Kaggle 注册时验证码不显示，点提交就报「captcha must be filled out」。

• 现象：页面上验证码区域一片空白或一直转圈；手机浏览器能显示但网页端不行。
• 原因：验证码是第三方 iframe 嵌入的，浏览器的广告拦截扩展或隐私模式把它当广告拦掉了；少数情况是浏览器自动填充干扰了勾选框。
• 解决：逐个关掉浏览器扩展（优先广告拦截类），用普通窗口而非隐身模式；还不行就换手机浏览器完成注册。注册只需要一次，之后用 API token 操作，不再需要页面验证码。

坑 2：命令行下载kaggle competitions download -c cifar-10报 403 Forbidden。

• 现象：API key 配好了，kaggle competitions list能列比赛，但 download cifar-10 就 403。
• 原因：这个比赛需要先接受规则。CLI 按你账号的权限下载，你从没在浏览器里点过 Join Competition / 接受规则，服务端就认为无权访问数据。
• 解决：浏览器打开比赛页，点 Join Competition，勾选并接受规则，必要时重新生成一次 API token。之后重跑下载命令即可。

5.2 环境与装包：GPU 识别和版本错位

坑 3：torch.cuda.is_available()返回 False，训练悄悄跑在 CPU 上。

• 现象：装完 PyTorch 后一切正常，train 也跑得动，但一个 epoch 要好几分钟，GPU 占用始终为 0；另一类是 AMD 卡（比如 7900XTX）在 WSL2 里装官方预编译包，torch 直接回退 CPU 或报 kernel 不匹配。
• 原因：绝大多数是装了 CPU 版 wheel，pip 在某些源上默认把 torch 解析成不带 CUDA 的版本；AMD 卡在 WSL2 下需要 ROCm 后端，官方 CUDA wheel 识别不了。
• 解决：装完先跑一段诊断：python -c "import torch; print(torch.__version__, torch.cuda.is_available())"。版本号里能看到+cu118、+cu121这类后缀才说明是 GPU 版；AMD/WSL2 环境按官方 ROCm 安装指引装配套 wheel，ROCm 和 WSL 内核版本有对应关系，装完要重启 WSL 才生效。我的做法是：本地环境不确定时，先把训练脚本在 Kaggle Notebook 的免费 GPU 上跑通拿分数，本地再慢慢折腾 GPU，这样不耽误比赛进度。

5.3 数据与推理：标签错位和归一化用错

坑 4：本地验证集 92%，提交到排行榜只剩百分之四十几。

• 现象：训练过程一切正常，验证准确率不低，推断脚本也跑完生成了 submission.csv，提交后分数低得离谱，甚至接近随机猜。
• 原因：标签映射错位。训练时类别字符串变成数字，推断时数字再变回字符串，两处用了两个不一样的顺序列表——比如训练用sorted(label_list)，推断时手写了另一种顺序。模型没学错，是输出对错了标签。
• 解决：把训练label2idx的列表序列化保存，推断时原样复用，不要手敲；提交前用 sampleSubmission 的前 50 行跑一次预测，肉眼核对类别字符串和图片内容对不对得上。这个 30 秒的核对能救回一整次提交窗口。

坑 5：训练 loss 停在 2.3 附近不动，或者第一轮就变 nan。

• 现象：训练开始后 loss 非常平稳地不下降，或者某个 epoch 直接变 nan，之后再也回不来。
• 原因：归一化参数用错。最常见是把 ImageNet 的 (0.485, 0.456, 0.406) 当 mean 用到 CIFAR-10 上，输入分布整体偏移，模型学不到东西；另一类是 transform 里忘写 ToTensor，把 0～255 的 uint8 图直接送到卷积层，数值范围过大把梯度炸掉。
• 解决：用 CIFAR-10 自己的统计量 (0.4914, 0.4822, 0.4465) 和 (0.2470, 0.2435, 0.2616)，并保证 ToTensor 在 Normalize 前面。排查时从 train_loader 拿一个 batch 打印 x.min() 和 x.max()，有效输入范围应该是 -3 到 3 之间；如果打印出来是 0～255，ToTensor 一定漏了。

6. 提交通关的最后一道校验：本地验证集与 10 分钟核对

6.1 先切一个本地验证集

最后一个实用技巧不是调模型，而是「别拿测试集当验证集用」。比赛版数据没有官方验证集，很多人直接在 train 上训完就对着 test 推断，然后赌一次提交。我的做法是先切出一份本地验证集：

import pandas as pd from sklearn.model_selection import train_test_split df = pd.read_csv("data/cifar-10/trainLabels.csv") train_df, val_df = train_test_split( df, test_size=5000, stratify=df["label"], random_state=42 ) train_df.to_csv("train_split.csv", index=False) val_df.to_csv("val_split.csv", index=False)

用stratify按类别等比例切，保证 10 个类在验证集里各 500 张。这 5000 张就是你的「本地排行榜」，每个模型改动都拿它打分，比盲提交快得多。注意切完训练集变成 4.5 万张，训练脚本里的 csv 路径要指向train_split.csv，别再用原始的 trainLabels.csv，否则验证集就漏进训练里了。

6.2 提交前的三个核对

提交文件生成之后，我固定会做三件事，顺序不能乱：第一，sub.shape必须等于 (300000, 2)，多一行少一行都是废文件；第二，id 列和sampleSubmission.csv的 id 前 10 个比对，确认没有.png后缀差异；第三，label 列做一次value_counts()，10 个类都要出现且数量别出现极端值——比如某一个类超过一半，那基本是标签错位了。这三步加一起不到 10 分钟，但能挡掉我犯过的几乎所有低级错误。

打了这几年比赛，我养成的习惯是：宁可错过一个提交窗口，也不交一份格式存疑的文件；每轮改动先跑本地验证，再用同一份代码生成提交。这套流程笨，但稳。CIFAR-10 这场打完之后你会发现，这些坑在别的图像分类比赛里几乎原样重演，到时候照着这份排查单走一遍就行。希望帮到你。

本文还有配套的精品资源，点击获取