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

1次阅读

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

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

小样本问题：每个细分类仅 500 张训练图（32×32 低分辨率），相当于只有 5 张 / 类在 ImageNet 尺度下的信息量
跨类相似性：如 ” 摩托车 ” 与 ” 自行车 ” 的细分类差异仅体现在车把等细节部位
长尾分布：自然场景中粗分类的样本量差异显著（如 ” 昆虫 ” 类比 ” 车辆 ” 类样本少 30%）

对比 TensorFlow/Keras 的 tf.keras.datasets.cifar100.load_data() 与 PyTorch 方案：

API 友好度 ：PyTorch 的torchvision.datasets.CIFAR100 直接返回 PIL 图像，便于后续增强处理
数据流透明 ：DataLoader 的num_workers参数可明确控制多进程加载
调试便捷性：PyTorch 的动态图机制更利于在 Jupyter 中实时检查数据

# Python 3.8+, torch==1.12.0
import torchvision.transforms as T
from torchvision.datasets import CIFAR100

# 经验证有效的归一化参数
norm_mean = [0.5071, 0.4867, 0.4408]
norm_std = [0.2675, 0.2565, 0.2761]

train_transform = T.Compose([T.RandomCrop(32, padding=4, padding_mode='reflect'),
    T.RandomHorizontalFlip(),
    T.ColorJitter(brightness=0.2, contrast=0.2),
    T.ToTensor(),
    T.Normalize(norm_mean, norm_std)
])

train_set = CIFAR100(
    root='./data', 
    train=True, 
    download=True,
    transform=train_transform
)

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

# 计算每个类的样本权重
class_counts = np.bincount([y for _, y in train_set])
class_weights = 1. / torch.Tensor(class_counts)
samples_weights = class_weights[train_set.targets]

sampler = WeightedRandomSampler(
    weights=samples_weights,
    num_samples=len(samples_weights),
    replacement=True
)

import torch.nn as nn

class BasicBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, 
                              kernel_size=3, stride=stride, padding=1)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.conv2 = nn.Conv2d(out_channels, out_channels, 
                              kernel_size=3, stride=1, padding=1)
        self.bn2 = nn.BatchNorm2d(out_channels)

        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, 
                         kernel_size=1, stride=stride),
                nn.BatchNorm2d(out_channels)
            )

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