CIFAR100数据集实战指南：从数据加载到模型训练的全流程解析

1次阅读

共计 2648 个字符，预计需要花费 7 分钟才能阅读完成。

CIFAR100 作为经典的图像分类基准数据集，包含 100 个细粒度类别（如 ’ 苹果 ’、’ 梨 ’）和 20 个粗粒度超类（如 ’ 水果 ’）。这种层级结构带来两个典型挑战：

小样本问题：每个细分类仅 500 张训练图（32×32 低分辨率），模型容易欠拟合
跨类相似性：如 ’ 摩托车 ’ 与 ’ 自行车 ’ 的视觉差异小于同类不同品种的狗

对比 TensorFlow/Keras 的 tf.keras.datasets.cifar100.load_data()，PyTorch 的torchvision.datasets.CIFAR100 提供更灵活的数据流控制：

# Python 3.8+  | PyTorch 1.10+
from torchvision import datasets

# 自动下载并解压到./data 目录
train_set = datasets.CIFAR100(
    root='./data', 
    train=True, 
    download=True,
    transform=None  # 后续自定义
)

关键差异点：

惰性加载：PyTorch 仅在迭代时读取图片，节省内存
Transform 链式操作：支持组合多种预处理（见下文）

CIFAR100 的官方推荐标准化参数（基于 ImageNet 统计）：

from torchvision import transforms

train_transform = transforms.Compose([transforms.RandomCrop(32, padding=4),  # 保持分辨率不变的数据增广
    transforms.RandomHorizontalFlip(),
    transforms.ColorJitter(brightness=0.2, contrast=0.2),  # 颜色扰动
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5071, 0.4867, 0.4408],  # 各通道均值
        std=[0.2675, 0.2565, 0.2761]   # 各通道标准差
    )
])

通过 WeightedRandomSampler 调整样本分布：

from torch.utils.data import WeightedRandomSampler
import numpy as np

# 计算每个类别的样本数
class_counts = np.bincount(train_set.targets)
# 计算采样权重（逆频率）weights = 1. / class_counts[train_set.targets]
sampler = WeightedRandomSampler(
    weights=weights,
    num_samples=len(weights),
    replacement=True  # 允许重复采样少数类
)

基于 ResNet18 简化版（参数量约 1 /10）：

import torch.nn as nn

class TinyResNet(nn.Module):
    def __init__(self, num_classes=100):
        super().__init__()
        self.features = nn.Sequential(nn.Conv2d(3, 16, 3, padding=1),
            nn.BatchNorm2d(16),
            nn.ReLU(),
            nn.MaxPool2d(2),

            # 残差块
            ResidualBlock(16, 32),
            ResidualBlock(32, 64),
            nn.AdaptiveAvgPool2d(1)
        )
        self.classifier = nn.Linear(64, num_classes)

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)
        return self.classifier(x)

class ResidualBlock(nn.Module):
    def __init__(self, in_ch, out_ch):
        super().__init__()
        self.conv1 = nn.Conv2d(in_ch, out_ch, 3, padding=1)
        self.bn1 = nn.BatchNorm2d(out_ch)
        self.conv2 = nn.Conv2d(out_ch, out_ch, 3, padding=1)
        self.bn2 = nn.BatchNorm2d(out_ch)
        self.shortcut = nn.Sequential(nn.Conv2d(in_ch, out_ch, 1) if in_ch != out_ch else nn.Identity(),
            nn.BatchNorm2d(out_ch)
        )

    def forward(self, x):
        residual = self.shortcut(x)
        x = nn.ReLU()(self.bn1(self.conv1(x)))
        x = self.bn2(self.conv2(x))
        return nn.ReLU()(x + residual)

学习率：初始建议 0.1（使用 CosineAnnealing 衰减）
Batch Size：128-256（需根据 GPU 显存调整）
优化器：SGD with momentum=0.9 + weight_decay=5e-4

避免使用官方测试集进行调参：

from torch.utils.data import random_split

train_size = int(0.8 * len(train_set))
val_size = len(train_set) - train_size
train_subset, val_set = random_split(
    train_set, 
    [train_size, val_size],
    generator=torch.Generator().manual_seed(42)  # 固定随机种子
)