ResNet-18在Cifar-10图像分类中的PyTorch实践

2026年1月8日 互联网

ResNet-18在Cifar-10图像分类中的PyTorch实践

一、引言

Cifar-10数据集作为计算机视觉领域的经典基准，包含10类共6万张32x32彩色图像，常用于验证模型在有限数据下的泛化能力。ResNet-18作为残差网络的轻量级版本，通过跳跃连接缓解梯度消失问题，在保持较高精度的同时降低计算复杂度。本文将结合PyTorch框架，系统介绍从数据加载到模型部署的全流程实现，并提供优化建议。

二、环境准备与数据加载

2.1 环境配置

建议使用PyTorch 1.8+版本，配合CUDA 10.2+以支持GPU加速。通过pip install torch torchvision安装基础库，并确保NumPy、Matplotlib等辅助工具已就绪。

2.2 数据预处理

Cifar-10原始数据需进行标准化与增强：

  1. import torchvision.transforms as transforms
  3. transform_train = transforms.Compose([
  4.     transforms.RandomCrop(32, padding=4),  # 随机裁剪增强
  5.     transforms.RandomHorizontalFlip(),      # 水平翻转
  6.     transforms.ToTensor(),                  # 转为Tensor
  7.     transforms.Normalize((0.4914, 0.4822, 0.4465),  # 均值
  8.                          (0.2470, 0.2435, 0.2616))  # 标准差
  9. ])
  11. transform_test = transforms.Compose([
  12.     transforms.ToTensor(),
  13.     transforms.Normalize((0.4914, 0.4822, 0.4465),
  14.                          (0.2470, 0.2435, 0.2616))
  15. ])

通过torchvision.datasets.CIFAR10加载数据集，并使用DataLoader实现批量读取：

  1. trainset = torchvision.datasets.CIFAR10(
  2.     root='./data', train=True, download=True, transform=transform_train)
  3. trainloader = torch.utils.data.DataLoader(
  4.     trainset, batch_size=128, shuffle=True, num_workers=2)

三、ResNet-18模型构建

3.1 残差块实现

核心在于BasicBlock类，通过跳跃连接实现特征传递：

  1. import torch.nn as nn
  2. import torch.nn.functional as F
  4. class BasicBlock(nn.Module):
  5.     expansion = 1
  6.     def __init__(self, in_channels, out_channels, stride=1):
  7.         super(BasicBlock, self).__init__()
  8.         self.conv1 = nn.Conv2d(in_channels, out_channels, 
  9.                                kernel_size=3, stride=stride, padding=1, bias=False)
  10.         self.bn1 = nn.BatchNorm2d(out_channels)
  11.         self.conv2 = nn.Conv2d(out_channels, out_channels*self.expansion,
  12.                                kernel_size=3, stride=1, padding=1, bias=False)
  13.         self.bn2 = nn.BatchNorm2d(out_channels*self.expansion)
  14.         self.shortcut = nn.Sequential()
  15.         if stride != 1 or in_channels != out_channels*self.expansion:
  16.             self.shortcut = nn.Sequential(
  17.                 nn.Conv2d(in_channels, out_channels*self.expansion,
  18.                           kernel_size=1, stride=stride, bias=False),
  19.                 nn.BatchNorm2d(out_channels*self.expansion)
  20.             )
  22.     def forward(self, x):
  23.         residual = x
  24.         out = F.relu(self.bn1(self.conv1(x)))
  25.         out = self.bn2(self.conv2(out))
  26.         out += self.shortcut(residual)
  27.         out = F.relu(out)
  28.         return out

3.2 完整网络架构

通过堆叠残差块构建18层网络：

  1. class ResNet(nn.Module):
  2.     def __init__(self, block, num_blocks, num_classes=10):
  3.         super(ResNet, self).__init__()
  4.         self.in_channels = 64
  5.         self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
  6.         self.bn1 = nn.BatchNorm2d(64)
  7.         self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
  8.         self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
  9.         self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
  10.         self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
  11.         self.linear = nn.Linear(512*block.expansion, num_classes)
  13.     def _make_layer(self, block, out_channels, num_blocks, stride):
  14.         strides = [stride] + [1]*(num_blocks-1)
  15.         layers = []
  16.         for stride in strides:
  17.             layers.append(block(self.in_channels, out_channels, stride))
  18.             self.in_channels = out_channels * block.expansion
  19.         return nn.Sequential(*layers)
  21.     def forward(self, x):
  22.         out = F.relu(self.bn1(self.conv1(x)))
  23.         out = self.layer1(out)
  24.         out = self.layer2(out)
  25.         out = self.layer3(out)
  26.         out = self.layer4(out)
  27.         out = F.avg_pool2d(out, 4)
  28.         out = out.view(out.size(0), -1)
  29.         out = self.linear(out)
  30.         return out
  32. def ResNet18():
  33.     return ResNet(BasicBlock, [2, 2, 2, 2])

四、模型训练与优化

4.1 训练配置

使用交叉熵损失与Adam优化器：

  1. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
  2. net = ResNet18().to(device)
  3. criterion = nn.CrossEntropyLoss()
  4. optimizer = torch.optim.Adam(net.parameters(), lr=0.001)

4.2 训练循环

实现100轮训练，每轮输出损失与准确率：

  1. for epoch in range(100):
  2.     running_loss = 0.0
  3.     correct = 0
  4.     total = 0
  5.     for i, (inputs, labels) in enumerate(trainloader, 0):
  6.         inputs, labels = inputs.to(device), labels.to(device)
  7.         optimizer.zero_grad()
  8.         outputs = net(inputs)
  9.         loss = criterion(outputs, labels)
  10.         loss.backward()
  11.         optimizer.step()
  13.         running_loss += loss.item()
  14.         _, predicted = torch.max(outputs.data, 1)
  15.         total += labels.size(0)
  16.         correct += (predicted == labels).sum().item()
  18.     print(f'Epoch {epoch+1}, Loss: {running_loss/(i+1):.3f}, '
  19.           f'Acc: {100*correct/total:.2f}%')

4.3 性能优化技巧

  1. 学习率调度：采用torch.optim.lr_scheduler.StepLR动态调整学习率
  2. 混合精度训练：使用torch.cuda.amp加速计算
  3. 梯度裁剪：防止梯度爆炸，设置nn.utils.clip_grad_norm_
  4. 早停机制：监控验证集损失，提前终止无效训练

五、模型评估与部署

5.1 测试集评估

在测试集上验证模型泛化能力：

  1. testset = torchvision.datasets.CIFAR10(
  2.     root='./data', train=False, download=True, transform=transform_test)
  3. testloader = torch.utils.data.DataLoader(
  4.     testset, batch_size=128, shuffle=False, num_workers=2)
  6. net.eval()
  7. correct = 0
  8. total = 0
  9. with torch.no_grad():
  10.     for inputs, labels in testloader:
  11.         inputs, labels = inputs.to(device), labels.to(device)
  12.         outputs = net(inputs)
  13.         _, predicted = torch.max(outputs.data, 1)
  14.         total += labels.size(0)
  15.         correct += (predicted == labels).sum().item()
  17. print(f'Test Accuracy: {100*correct/total:.2f}%')

5.2 模型导出

将训练好的模型导出为ONNX格式，便于跨平台部署：

  1. dummy_input = torch.randn(1, 3, 32, 32).to(device)
  2. torch.onnx.export(net, dummy_input, "resnet18_cifar10.onnx",
  3.                   input_names=["input"], output_names=["output"])

六、总结与展望

本文通过完整的代码实现，展示了ResNet-18在Cifar-10分类任务中的PyTorch实践。实验表明，在标准数据增强下，该模型可达93%以上的测试准确率。未来工作可探索：

  1. 引入注意力机制提升特征表达能力
  2. 结合知识蒸馏技术压缩模型规模
  3. 扩展至更复杂的数据集（如ImageNet）

开发者可通过调整残差块数量、优化超参数等方式进一步改进性能，同时利用PyTorch的动态计算图特性快速迭代实验。

最新文章