实战——使用ResNet实现猫狗分类（PyTorch）

一、引言：为什么选择ResNet与猫狗分类？

在计算机视觉领域，图像分类是基础且重要的任务。猫狗分类作为经典案例，既能验证模型性能，又具备实际应用价值（如宠物识别、内容审核）。传统CNN（卷积神经网络）在深层网络中面临梯度消失问题，而ResNet（残差网络）通过引入残差连接（Residual Block），有效解决了这一问题，成为深度学习领域的里程碑模型。

本文将基于PyTorch框架，从零实现一个完整的猫狗分类流程，包括数据加载、模型构建、训练优化及结果评估。通过实战，读者将掌握：

1. 如何使用PyTorch加载与预处理图像数据；
2. ResNet的核心结构与实现细节；
3. 迁移学习的应用技巧；
4. 模型训练与调优的实战经验。

二、环境准备与数据集

1. 环境配置

• Python版本：3.8+
• 依赖库：

  pip install torch torchvision matplotlib numpy

• 硬件要求：GPU（推荐NVIDIA显卡）以加速训练。

2. 数据集准备

使用Kaggle公开的猫狗分类数据集（Dogs vs. Cats），包含25,000张训练图像（12,500猫/12,500狗）和12,500张测试图像。数据目录结构如下：

data/
  train/
    cat.0.jpg
    dog.0.jpg
    ...
  test/
    1.jpg
    2.jpg
    ...

3. 数据预处理

使用torchvision.transforms进行图像标准化与增强：

import torchvision.transforms as transforms
transform = transforms.Compose([
    transforms.Resize(256),          # 调整图像大小
    transforms.CenterCrop(224),      # 中心裁剪
    transforms.ToTensor(),           # 转为Tensor
    transforms.Normalize(           # 标准化（均值与标准差）
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    )
])

三、ResNet模型实现

1. 残差块（Residual Block）

ResNet的核心是残差连接，其公式为：
输出 = F(x) + x
其中F(x)是卷积层的输出，x是输入。代码实现如下：

import torch.nn as nn
class ResidualBlock(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)
        # 1x1卷积调整维度（当输入输出通道数不同时）
        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):
        residual = x
        out = nn.functional.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += self.shortcut(residual)  # 残差连接
        out = nn.functional.relu(out)
        return out

2. 完整ResNet模型

以ResNet-18为例，构建包含4个残差块组的网络：

class ResNet(nn.Module):
    def __init__(self, num_classes=2):
        super().__init__()
        self.in_channels = 64
        # 初始卷积层
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3)
        self.bn1 = nn.BatchNorm2d(64)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        # 4个残差块组
        self.layer1 = self._make_layer(64, 2, stride=1)
        self.layer2 = self._make_layer(128, 2, stride=2)
        self.layer3 = self._make_layer(256, 2, stride=2)
        self.layer4 = self._make_layer(512, 2, stride=2)
        # 全局平均池化与分类层
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512, num_classes)
    def _make_layer(self, out_channels, num_blocks, stride):
        strides = [stride] + [1] * (num_blocks - 1)
        layers = []
        for stride in strides:
            layers.append(ResidualBlock(self.in_channels, out_channels, stride))
            self.in_channels = out_channels
        return nn.Sequential(*layers)
    def forward(self, x):
        x = nn.functional.relu(self.bn1(self.conv1(x)))
        x = self.maxpool(x)
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.fc(x)
        return x

3. 迁移学习优化

为加速训练，可直接加载预训练的ResNet模型（如PyTorch内置的torchvision.models.resnet18），并替换最后的全连接层：

import torchvision.models as models
def get_pretrained_resnet(num_classes=2):
    model = models.resnet18(pretrained=True)
    model.fc = nn.Linear(model.fc.in_features, num_classes)  # 替换分类层
    return model

四、模型训练与评估

1. 数据加载器

使用torch.utils.data.DataLoader批量加载数据：

from torch.utils.data import DataLoader
from torchvision.datasets import ImageFolder
train_dataset = ImageFolder('data/train', transform=transform)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

2. 训练循环

定义损失函数（交叉熵）与优化器（Adam）：

import torch.optim as optim
model = get_pretrained_resnet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
def train(model, train_loader, criterion, optimizer, epochs=10):
    model.train()
    for epoch in range(epochs):
        running_loss = 0.0
        for inputs, labels in train_loader:
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            running_loss += loss.item()
        print(f'Epoch {epoch+1}, Loss: {running_loss/len(train_loader):.4f}')

3. 评估指标

计算准确率：

def evaluate(model, test_loader):
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, labels in test_loader:
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print(f'Accuracy: {100 * correct / total:.2f}%')

五、实战优化技巧

1. 学习率调度：使用torch.optim.lr_scheduler.StepLR动态调整学习率。
2. 数据增强：在transforms中加入随机旋转、翻转等操作提升泛化能力。
3. 早停机制：监控验证集损失，避免过拟合。
4. 模型保存：保存最佳模型权重：

   torch.save(model.state_dict(), 'best_model.pth')

六、总结与扩展

通过本文，读者已掌握：

• ResNet的核心原理与PyTorch实现；
• 迁移学习在图像分类中的应用；
• 完整的训练-评估流程。

扩展方向：

1. 尝试更深的ResNet变体（如ResNet-50）；
2. 部署模型到移动端或Web服务；
3. 探索多标签分类或目标检测任务。

ResNet的成功证明了残差连接在深度学习中的普适性，而猫狗分类案例则为初学者提供了低门槛的实践入口。希望本文能成为读者深度学习之路的实用指南！