CNN 经典架构解析与 PyTorch 实战

技巧：LeNet-5 适合 MNIST 这类小尺寸图像分类任务，是入门 CNN 的最佳实践案例。

1.2 AlexNet：深度学习里程碑

AlexNet 是 2012 年 ImageNet 竞赛的冠军模型，它将 CNN 深度提升到 8 层，标志着深度学习时代的到来。

• 核心改进
  • ReLU 激活函数：替代 Sigmoid，缓解梯度消失。
  • Dropout 层：随机失活神经元，降低过拟合。
  • 多 GPU 并行：拆分模型提升训练效率。
• 结构特点：包含 11×11、5×5、3×3 等多种卷积核尺寸，采用最大池化保留纹理特征。

1.3 VGGNet：统一卷积核的典范

VGGNet 的核心创新在于使用小尺寸卷积核（3×3）替代大尺寸卷积核。通过堆叠多个 3×3 卷积核，既能达到与大核相同的感受野，又能减少参数量（2×3² < 5²）。

• 优势：增加非线性，提升表达能力。
• 注意：VGG-16/19 参数量较大（约 138M），对计算资源要求高，移动端慎用。

1.4 ResNet：突破深层瓶颈

ResNet（残差网络）通过残差连接解决了'网络越深性能越差'的退化问题，支持训练超过 1000 层的网络。

• 原理：引入捷径分支，公式为 $y = F(x) + x$。当残差映射 $F(x)=0$ 时，模型退化为恒等映射，保证深层性能不低于浅层。
• 残差块类型：
  • 普通残差块：适用于较浅网络。
  • 瓶颈残差块：适用于深层网络（如 ResNet-50），通过 1×1 卷积降维。

实战：PyTorch 实现瓶颈残差块

class Bottleneck(nn.Module):
    expansion = 4  # 通道数扩展倍数

    def __init__(self, in_channels, out_channels, stride=1, downsample=None):
        super(Bottleneck, self).__init__()
        # 1×1 卷积：降维
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        # 3×3 卷积：特征提取
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)
        # 1×1 卷积：升维
        self.conv3 = nn.Conv2d(out_channels, out_channels * self.expansion, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(out_channels * self.expansion)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample  # 下采样模块，用于匹配捷径分支维度

    def forward(self, x):
        identity = x  # 捷径分支输入
        out = self.relu(self.bn1(self.conv1(x)))
        out = self.relu(self.bn2(self.conv2(out)))
        out = self.bn3(self.conv3(out))
        if self.downsample is not None:
            identity = self.downsample(x)  # 调整捷径分支维度
        out += identity  # 残差连接
        out = self.relu(out)
        return out

2. 实战：基于 ResNet-50 的图像分类

本节以 CIFAR-10 数据集为例，完整实现基于 ResNet-50 的图像分类模型。

2.1 模型搭建

class ResNet(nn.Module):
    def __init__(self, block, layers, num_classes=1000):
        super(ResNet, self).__init__()
        self.in_channels = 64
        # 初始卷积层：7×7 卷积 + 最大池化
        self.conv1 = nn.Conv2d(3, self.in_channels, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(self.in_channels)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

        # 残差块堆叠
        self.layer1 = self._make_layer(block, 64, layers[0])
        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)

        # 全局平均池化 + 全连接层
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512 * block.expansion, num_classes)

        # 初始化权重
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)

    def _make_layer(self, block, out_channels, blocks, stride=1):
        downsample = None
        if stride != 1 or self.in_channels != out_channels * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2d(self.in_channels, out_channels * block.expansion, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels * block.expansion),
            )
        layers = []
        layers.append(block(self.in_channels, out_channels, stride, downsample))
        self.in_channels = out_channels * block.expansion
        for _ in range(1, blocks):
            layers.append(block(self.in_channels, out_channels))
        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.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

def resnet50(num_classes=1000):
    return ResNet(Bottleneck, [3, 4, 6, 3], num_classes=num_classes)

# 测试模型
model = resnet50(num_classes=10)  # CIFAR-10 为 10 分类
test_input = torch.randn(2, 3, 224, 224)  # 2 张 224×224 彩色图
output = model(test_input)
print(f"ResNet-50 输出形状：{output.shape}")  # 输出：torch.Size([2, 10])

2.2 数据预处理与训练配置

import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
import torch.optim as optim

# 数据增强与预处理
transform_train = transforms.Compose([
    transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

transform_val = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

# 加载 CIFAR-10 数据集
train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)
val_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_val)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=2)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False, num_workers=2)

# 定义损失函数和优化器
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = resnet50(num_classes=10).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=5e-4)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)

2.3 训练与验证循环

def train_one_epoch(model, loader, criterion, optimizer, device):
    model.train()
    total_loss = 0.0
    correct = 0
    total = 0
    for batch_idx, (inputs, targets) in enumerate(loader):
        inputs, targets = inputs.to(device), targets.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
        _, predicted = outputs.max(1)
        total += targets.size(0)
        correct += predicted.eq(targets).sum().item()
        if batch_idx % 100 == 0:
            print(f'Batch {batch_idx}: Loss {loss.item():.4f}, Acc {100.*correct/total:.2f}%')
    return total_loss / len(loader), 100.*correct/total

def validate(model, loader, criterion, device):
    model.eval()
    total_loss = 0.0
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, targets in loader:
            inputs, targets = inputs.to(device), targets.to(device)
            outputs = model(inputs)
            loss = criterion(outputs, targets)
            total_loss += loss.item()
            _, predicted = outputs.max(1)
            total += targets.size(0)
            correct += predicted.eq(targets).sum().item()
    return total_loss / len(loader), 100.*correct/total

# 开始训练
num_epochs = 100
best_acc = 0.0
for epoch in range(num_epochs):
    print(f'\nEpoch {epoch+1}/{num_epochs}')
    train_loss, train_acc = train_one_epoch(model, train_loader, criterion, optimizer, device)
    val_loss, val_acc = validate(model, val_loader, criterion, device)
    scheduler.step()
    print(f'Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.2f}%')
    print(f'Val Loss: {val_loss:.4f}, Val Acc: {val_acc:.2f}%')
    # 保存最佳模型
    if val_acc > best_acc:
        best_acc = val_acc
        torch.save(model.state_dict(), 'resnet50_cifar10_best.pth')
        print(f'Saved Best Model with Acc: {best_acc:.2f}%')
print(f'Training Finished. Best Val Acc: {best_acc:.2f}%')

3. 结果分析与选型指南

训练完成后，ResNet-50 在 CIFAR-10 上的验证准确率通常可达 90% 以上。在实际项目中，不同架构的选型建议如下：

技巧：优先选择 ResNet 系列作为基础架构，再根据任务需求进行定制化修改，是最高效的开发策略。

CNN 的进阶过程是'问题驱动 - 结构创新 - 性能突破'的循环。掌握这些经典架构的设计思路，才能灵活应对不同的视觉任务需求。