CIFAR-10数据集详解：从入门到实战的深度学习指南

1次阅读

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

CIFAR-10 是计算机视觉领域最经典的基准数据集之一，由加拿大高级研究所（CIFAR）整理发布。这个数据集包含了 10 个类别的 60000 张 32×32 像素的彩色图像，每个类别有 6000 张图像。其中 50000 张用于训练，10000 张用于测试。

在深度学习领域，CIFAR-10 常被用于：

图像分类算法的基准测试
深度学习模型的入门教学
计算机视觉新方法的验证

相比于 MNIST 数据集，CIFAR-10 的难度更高，因为图像是彩色的、背景更复杂，更能反映真实世界的图像分类问题。

CIFAR-10 数据集由 6 个二进制文件组成：

5 个训练批次文件（data_batch_1 到 data_batch_5）
1 个测试批次文件（test_batch）

每个文件包含 10000 张图像，每张图像由 3072 个字节组成（32x32x3，RGB 三通道）。

数据集包含以下 10 个类别，均匀分布：

飞机
汽车
鸟
猫
鹿
狗
青蛙
马
船
卡车

每个数据点包含：

1 字节的标签（0-9）
3072 字节的图像数据（前 1024 字节是红色通道，接着是绿色和蓝色通道）

import torch
import torchvision
import torchvision.transforms as transforms

# 定义数据预处理
transform = transforms.Compose([transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# 加载训练集
trainset = torchvision.datasets.CIFAR10(
    root='./data', 
    train=True,
    download=True, 
    transform=transform
)
trainloader = torch.utils.data.DataLoader(
    trainset, 
    batch_size=32,
    shuffle=True, 
    num_workers=2
)

# 加载测试集
testset = torchvision.datasets.CIFAR10(
    root='./data', 
    train=False,
    download=True, 
    transform=transform
)
testloader = torch.utils.data.DataLoader(
    testset, 
    batch_size=32,
    shuffle=False, 
    num_workers=2
)

# 定义类别名称
classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

为了提高模型泛化能力，可以添加数据增强：

transform_train = transforms.Compose([transforms.RandomHorizontalFlip(),
    transforms.RandomCrop(32, padding=4),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, 3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(64 * 8 * 8, 512)
        self.fc2 = nn.Linear(512, 10)
        self.dropout = nn.Dropout(0.25)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 64 * 8 * 8)
        x = self.dropout(x)
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.fc2(x)
        return x

net = SimpleCNN()

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

for epoch in range(10):  # 训练 10 轮
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data

        optimizer.zero_grad()

        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 2000 == 1999:  # 每 2000 个小批次打印一次
            print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')
            running_loss = 0.0

print('Finished Training')