PyTorch新手必看：手把手教你复现LeNet和AlexNet（附完整代码和参数详解）

PyTorch实战：从LeNet到AlexNet的深度学习模型构建艺术

当你第一次在PyTorch中成功运行一个卷积神经网络时，那种兴奋感就像孩子拼出了第一块复杂拼图。LeNet和AlexNet作为计算机视觉领域的里程碑模型，不仅是理解CNN的绝佳起点，更是掌握现代深度学习框架的实践入口。本文将带你从零开始，用PyTorch完整实现这两个经典网络，并深入解析每个设计细节背后的思考。

1. 环境准备与基础概念

在开始编码之前，我们需要确保开发环境配置正确。推荐使用Python 3.8+和PyTorch 1.10+版本，这些组合经过验证具有最佳稳定性。安装PyTorch最简单的方式是通过官方提供的pip命令：

pip install torch torchvision

卷积神经网络的核心构件包括：

• 卷积层：通过滑动窗口提取局部特征
• 池化层：降低空间维度，增强平移不变性
• 全连接层：整合全局信息进行分类
• 激活函数：引入非线性表达能力

理解这些基础组件后，我们就能更好地欣赏LeNet和AlexNet的设计哲学。LeNet诞生于1998年，是首个成功应用于数字识别的CNN；而AlexNet在2012年ImageNet竞赛中一战成名，开启了深度学习的新时代。

提示：建议使用Jupyter Notebook进行实验，可以实时查看每层的输出形状变化

2. LeNet实现与逐层解析

2.1 网络架构设计

LeNet-5原始论文中描述的架构包含两个卷积层和三个全连接层。在PyTorch中，我们可以用nn.Sequential来优雅地组织这些层：

import torch import torch.nn as nn class LeNet(nn.Module): def __init__(self): super(LeNet, self).__init__() self.conv = nn.Sequential( nn.Conv2d(1, 6, kernel_size=5, padding=2), # 保持空间维度 nn.Sigmoid(), nn.AvgPool2d(kernel_size=2, stride=2), # 原始论文使用平均池化 nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(), nn.AvgPool2d(kernel_size=2, stride=2) ) self.fc = nn.Sequential( nn.Linear(16*5*5, 120), nn.Sigmoid(), nn.Linear(120, 84), nn.Sigmoid(), nn.Linear(84, 10) )

关键参数说明：

2.2 前向传播与维度变化

理解各层的维度变化对调试网络至关重要。假设输入为32×32的MNIST图像：

def forward(self, x): print(f"输入形状: {x.shape}") # [batch, 1, 32, 32] x = self.conv(x) print(f"卷积后形状: {x.shape}") # [batch, 16, 5, 5] x = x.view(x.size(0), -1) # 展平 print(f"展平后形状: {x.shape}") # [batch, 400] return self.fc(x)

维度变化流程：

1. 输入图像：1×32×32
2. 第一卷积层：6×28×28（5×5卷积，无填充）
3. 第一池化层：6×14×14（2×2下采样）
4. 第二卷积层：16×10×10
5. 第二池化层：16×5×5
6. 全连接层：120 → 84 → 10

2.3 激活函数选择

原始LeNet使用Sigmoid作为激活函数，这在当时是主流选择：

nn.Sigmoid()

Sigmoid的特性：

• 将输出压缩到(0,1)区间
• 存在梯度消失问题
• 计算量比ReLU大

虽然现代网络普遍使用ReLU，但理解Sigmoid有助于我们欣赏深度学习的发展历程。

3. AlexNet的进阶实现

3.1 架构创新点

AlexNet在LeNet基础上引入了多项关键技术：

• 使用ReLU激活函数加速训练
• 添加Dropout层防止过拟合
• 采用重叠池化(overlapping pooling)
• 使用GPU加速计算

class AlexNet(nn.Module): def __init__(self, num_classes=10): super(AlexNet, self).__init__() self.features = nn.Sequential( nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(96, 256, kernel_size=5, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(256, 384, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(384, 384, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), ) self.classifier = nn.Sequential( nn.Dropout(p=0.5), nn.Linear(256*6*6, 4096), nn.ReLU(inplace=True), nn.Dropout(p=0.5), nn.Linear(4096, 4096), nn.ReLU(inplace=True), nn.Linear(4096, num_classes), )

3.2 关键参数对比

AlexNet与LeNet的主要差异：

3.3 现代改进实现

我们可以对原始AlexNet做一些符合当前实践的调整：

# 现代优化版本 class ModernAlexNet(nn.Module): def __init__(self): super().__init__() self.net = nn.Sequential( nn.Conv2d(3, 96, 11, 4, 2), nn.ReLU(), nn.LocalResponseNorm(2), # 替代原始LRN nn.MaxPool2d(3, 2), nn.Conv2d(96, 256, 5, 1, 2), nn.ReLU(), nn.LocalResponseNorm(2), nn.MaxPool2d(3, 2), nn.Conv2d(256, 384, 3, 1, 1), nn.ReLU(), nn.Conv2d(384, 384, 3, 1, 1), nn.ReLU(), nn.Conv2d(384, 256, 3, 1, 1), nn.ReLU(), nn.MaxPool2d(3, 2), nn.AdaptiveAvgPool2d((6, 6)), # 自适应池化 nn.Flatten(), nn.Linear(256*6*6, 4096), nn.ReLU(), nn.Dropout(0.5), nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(0.5), nn.Linear(4096, 10) )

主要改进点：

• 使用nn.Flatten()替代view操作
• 添加自适应池化增强输入灵活性
• 简化了前向传播方法

4. 训练技巧与调试实战

4.1 数据准备

使用torchvision可以方便地加载标准数据集：

from torchvision import datasets, transforms transform = transforms.Compose([ transforms.Resize((32, 32)), # LeNet需要32×32输入 transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,)) ]) train_set = datasets.MNIST( root='./data', train=True, download=True, transform=transform ) train_loader = torch.utils.data.DataLoader( train_set, batch_size=64, shuffle=True )

4.2 训练循环实现

完整的训练流程包含以下步骤：

1. 初始化模型和优化器
2. 前向传播计算输出
3. 计算损失函数
4. 反向传播更新参数
5. 周期性评估验证集

model = LeNet().to(device) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9) for epoch in range(10): model.train() for images, labels in train_loader: images, labels = images.to(device), labels.to(device) optimizer.zero_grad() outputs = model(images) loss = criterion(outputs, labels) loss.backward() optimizer.step()

4.3 常见问题排查

初学者常遇到的错误及解决方案：

1. 维度不匹配错误：

   • 检查各层的输入输出维度
   • 使用print(x.shape)调试
   • 确保展平操作正确

2. 梯度消失/爆炸：

   • 尝试调整学习率
   • 使用梯度裁剪
   • 考虑批归一化

3. 过拟合：

   • 增加Dropout层
   • 添加L2正则化
   • 使用数据增强

注意：当使用GPU时，确保数据和模型都在同一设备上（.to(device)）

5. 模型可视化与理解

5.1 特征图可视化

理解卷积层提取的特征有助于调试网络：

import matplotlib.pyplot as plt def visualize_features(model, image): layers = { 'conv1': model.conv[0], 'act1': model.conv[1], 'pool1': model.conv[2] } features = {} x = image.unsqueeze(0) for name, layer in layers.items(): x = layer(x) features[name] = x fig, axes = plt.subplots(1, len(features), figsize=(15,5)) for (name, feat), ax in zip(features.items(), axes): ax.set_title(name) ax.imshow(feat[0,0].detach().numpy(), cmap='viridis') plt.show()

5.2 参数量统计

使用以下代码统计模型参数量：

def count_parameters(model): return sum(p.numel() for p in model.parameters() if p.requires_grad) print(f"LeNet参数量: {count_parameters(LeNet()):,}") print(f"AlexNet参数量: {count_parameters(AlexNet()):,}")

典型输出：

• LeNet：约60,000
• AlexNet：约60,000,000

5.3 计算量分析

使用torchsummary工具分析各层计算量：

from torchsummary import summary summary(LeNet().to(device), (1, 32, 32)) summary(AlexNet().to(device), (3, 227, 227))

输出将显示每层的输出形状和参数量，帮助理解网络结构。

6. 性能优化技巧

6.1 混合精度训练

现代GPU支持混合精度计算，可显著加速训练：

from torch.cuda.amp import GradScaler, autocast scaler = GradScaler() for epoch in range(10): for images, labels in train_loader: optimizer.zero_grad() with autocast(): outputs = model(images) loss = criterion(outputs, labels) scaler.scale(loss).backward() scaler.step(optimizer) scaler.update()

6.2 学习率调度

动态调整学习率可以提高模型性能：

scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( optimizer, mode='min', factor=0.1, patience=3 ) for epoch in range(10): train_loss = train_one_epoch() val_loss = validate() scheduler.step(val_loss)

6.3 模型保存与加载

正确保存和加载模型状态：

# 保存 torch.save({ 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), }, 'model.pth') # 加载 checkpoint = torch.load('model.pth') model.load_state_dict(checkpoint['model_state_dict']) optimizer.load_state_dict(checkpoint['optimizer_state_dict'])

7. 扩展应用与迁移学习

7.1 自定义数据集适配

将模型应用于新数据集时需要调整：

# 修改最后一层 model.fc[-1] = nn.Linear(84, new_num_classes) # 或者只训练最后一层 for param in model.parameters(): param.requires_grad = False model.fc[-1] = nn.Linear(84, new_num_classes)

7.2 特征提取器使用

预训练模型可以作为特征提取器：

features = nn.Sequential(*list(model.children())[:-1]) feature_vector = features(image)

7.3 模型量化部署

将模型转换为更高效的推理格式：

quantized_model = torch.quantization.quantize_dynamic( model, {nn.Linear}, dtype=torch.qint8 )

在实际项目中，从LeNet开始理解基础原理，再过渡到AlexNet掌握现代技巧，这种渐进式学习路径能建立扎实的直觉。当你在PyTorch中调试这些网络时，不妨多尝试修改超参数，观察它们对模型性能的影响，这种实践获得的经验远比单纯阅读理论更有价值。