CNN Image Classifier / CNN 图像分类器

Project Background / 项目背景

CNN image classification is one of the cleanest entry points into modern deep learning engineering. It sits at the intersection of data pipelines, model architecture, optimization, evaluation, and export, so it is the perfect place to learn how all the moving parts of training actually fit together.
CNN 图像分类是进入现代深度学习工程最干净的入口之一。它正好处在数据管线、模型结构、优化、评估和导出这些核心问题的交叉点上，因此非常适合用来理解完整训练系统是怎样协同工作的。

Problem it solves / 它要解决什么问题

The direct task is image classification on CIFAR-10, but the deeper problem is learning how a model turns pixels into layered visual features and how an engineering pipeline turns that model into a reliable training workflow. This page is really about making vision training legible, not just chasing one accuracy number.
直接任务当然是在 CIFAR-10 上做图像分类，但更深的问题是理解模型如何把像素逐层变成视觉特征，以及工程管线如何把这个模型变成稳定可用的训练工作流。这个页面真正要解决的，是让视觉训练过程变得可解释，而不是只追一个 accuracy 数字。

What you learn / 你会学到什么

• ▸ Residual connections and why they help deep CNN optimization / 残差连接为何能帮助深层 CNN 优化
• ▸ Data augmentation and its effect on generalization / 数据增强如何影响泛化能力
• ▸ Mixed precision and practical PyTorch training patterns / 混合精度与实用 PyTorch 训练模式
• ▸ Confusion-matrix based error analysis / 基于 confusion matrix 的错误分析
• ▸ Model export and deployment readiness / 模型导出与部署准备

Code walkthrough / 代码要点解释

pip install torch torchvision

python cnn_cifar10_train.py

cnn-classifier/
├── cnn_cifar10_train.py
├── data/
│   └── cifar-10-batches-py/
└── checkpoints/
    └── best_model.pt

import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms


device = 'cuda' if torch.cuda.is_available() else 'cpu'
BATCH_SIZE = 128
EPOCHS = 10
LR = 3e-4

train_tfms = 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)),
])

test_tfms = 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=train_tfms)
test_ds = datasets.CIFAR10(root='data', train=False, download=True, transform=test_tfms)
train_loader = DataLoader(train_ds, batch_size=BATCH_SIZE, shuffle=True, num_workers=2)
test_loader = DataLoader(test_ds, batch_size=BATCH_SIZE, shuffle=False, num_workers=2)


class ResBlock(nn.Module):
    def __init__(self, in_ch, out_ch, stride=1):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, 3, stride=stride, padding=1, bias=False),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_ch, out_ch, 3, padding=1, bias=False),
            nn.BatchNorm2d(out_ch),
        )
        self.shortcut = nn.Identity() if stride == 1 and in_ch == out_ch else nn.Sequential(
            nn.Conv2d(in_ch, out_ch, 1, stride=stride, bias=False),
            nn.BatchNorm2d(out_ch),
        )
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        return self.relu(self.conv(x) + self.shortcut(x))


class SmallResNet(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.stem = nn.Sequential(
            nn.Conv2d(3, 64, 3, padding=1, bias=False),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
        )
        self.layer1 = nn.Sequential(ResBlock(64, 64), ResBlock(64, 64))
        self.layer2 = nn.Sequential(ResBlock(64, 128, stride=2), ResBlock(128, 128))
        self.layer3 = nn.Sequential(ResBlock(128, 256, stride=2), ResBlock(256, 256))
        self.pool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Linear(256, num_classes)

    def forward(self, x):
        x = self.stem(x)
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.pool(x).flatten(1)
        return self.fc(x)


model = SmallResNet().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.AdamW(model.parameters(), lr=LR, weight_decay=1e-4)

for epoch in range(EPOCHS):
    model.train()
    for images, labels in train_loader:
        images, labels = images.to(device), labels.to(device)
        logits = model(images)
        loss = criterion(logits, labels)
        optimizer.zero_grad(set_to_none=True)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()

    model.eval()
    correct = total = 0
    with torch.no_grad():
        for images, labels in test_loader:
            images, labels = images.to(device), labels.to(device)
            preds = model(images).argmax(dim=1)
            correct += (preds == labels).sum().item()
            total += labels.size(0)
    print(f"epoch={epoch+1} acc={correct/total:.4f}")

Success Criteria / 完成标准

• ✅ Validation accuracy reaches a strong baseline / 验证集准确率达到可靠 baseline
• ✅ Confusion matrix and class-level errors are analyzed / 完成 confusion matrix 和类别级错误分析
• ✅ TensorBoard logs are complete / TensorBoard 日志完整
• ✅ Exported model passes inference sanity check / 导出模型通过推理检查