从零实现LeNet手写数字识别：PyTorch完整指南与代码解析

一、LeNet模型架构解析

作为卷积神经网络的开山之作，LeNet-5由Yann LeCun于1998年提出，其设计思想奠定了现代CNN的基础架构。该模型专为手写数字识别设计，在MNIST数据集上取得了99%以上的准确率。

1.1 核心架构组成

LeNet-5包含7层结构（不含输入层）：

• C1卷积层：6个5×5卷积核，输出6个28×28特征图
• S2池化层：2×2平均池化，步长2，输出6个14×14特征图
• C3卷积层：16个5×5卷积核，采用部分连接模式
• S4池化层：2×2平均池化，输出16个7×7特征图
• C5卷积层：120个5×5卷积核，输出120个1×1特征图
• F6全连接层：84个神经元
• Output层：10个神经元对应0-9数字

1.2 关键设计思想

1. 局部感知与权值共享：通过卷积核实现局部特征提取，大幅减少参数量
2. 空间下采样：池化层降低特征图分辨率，增强平移不变性
3. 层次化特征提取：从边缘到纹理再到整体形状的渐进式特征学习

二、PyTorch实现全流程

2.1 环境准备

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
# 设备配置
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

2.2 数据加载与预处理

# 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))  # MNIST均值标准差
])
# 加载数据集
train_dataset = datasets.MNIST(
    root='./data', 
    train=True, 
    download=True, 
    transform=transform
)
test_dataset = datasets.MNIST(
    root='./data', 
    train=False, 
    download=True, 
    transform=transform
)
# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

2.3 模型定义

class LeNet5(nn.Module):
    def __init__(self):
        super(LeNet5, self).__init__()
        # C1卷积层
        self.conv1 = nn.Conv2d(1, 6, kernel_size=5, stride=1, padding=2)
        # S2池化层
        self.pool1 = nn.AvgPool2d(kernel_size=2, stride=2)
        # C3卷积层
        self.conv2 = nn.Conv2d(6, 16, kernel_size=5)
        # S4池化层
        self.pool2 = nn.AvgPool2d(kernel_size=2, stride=2)
        # C5全连接层（展平后）
        self.fc1 = nn.Linear(16*5*5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
    def forward(self, x):
        # C1 + ReLU
        x = torch.relu(self.conv1(x))
        # S2
        x = self.pool1(x)
        # C3 + ReLU
        x = torch.relu(self.conv2(x))
        # S4
        x = self.pool2(x)
        # 展平操作
        x = x.view(-1, 16*5*5)
        # F5 + ReLU
        x = torch.relu(self.fc1(x))
        # F6 + ReLU
        x = torch.relu(self.fc2(x))
        # Output层
        x = self.fc3(x)
        return x
model = LeNet5().to(device)

2.4 训练过程实现

def train(model, train_loader, criterion, optimizer, epoch):
    model.train()
    train_loss = 0
    correct = 0
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
        pred = output.argmax(dim=1, keepdim=True)
        correct += pred.eq(target.view_as(pred)).sum().item()
    train_loss /= len(train_loader.dataset)
    accuracy = 100. * correct / len(train_loader.dataset)
    print(f'Train Epoch: {epoch} \tLoss: {train_loss:.4f} \tAccuracy: {accuracy:.2f}%')
    return train_loss, accuracy
def test(model, test_loader, criterion):
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += criterion(output, target).item()
            pred = output.argmax(dim=1, keepdim=True)
            correct += pred.eq(target.view_as(pred)).sum().item()
    test_loss /= len(test_loader.dataset)
    accuracy = 100. * correct / len(test_loader.dataset)
    print(f'\nTest set: Average loss: {test_loss:.4f}, Accuracy: {accuracy:.2f}%\n')
    return test_loss, accuracy
# 初始化参数
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 训练循环
epochs = 10
train_losses, train_accs = [], []
test_losses, test_accs = [], []
for epoch in range(1, epochs + 1):
    train_loss, train_acc = train(model, train_loader, criterion, optimizer, epoch)
    test_loss, test_acc = test(model, test_loader, criterion)
    train_losses.append(train_loss)
    train_accs.append(train_acc)
    test_losses.append(test_loss)
    test_accs.append(test_acc)

三、性能优化与结果分析

3.1 训练过程可视化

# 绘制损失曲线
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(range(1, epochs+1), train_losses, label='Train Loss')
plt.plot(range(1, epochs+1), test_losses, label='Test Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
# 绘制准确率曲线
plt.subplot(1, 2, 2)
plt.plot(range(1, epochs+1), train_accs, label='Train Accuracy')
plt.plot(range(1, epochs+1), test_accs, label='Test Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy (%)')
plt.legend()
plt.tight_layout()
plt.show()

3.2 典型优化策略

1. 学习率调整：

   scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)
   # 在每个epoch后调用scheduler.step()

2. 批归一化改进：

   # 在卷积层后添加批归一化
   self.bn1 = nn.BatchNorm2d(6)
   # forward中修改为：
   x = torch.relu(self.bn1(self.conv1(x)))

3. 数据增强：

   transform = transforms.Compose([
    transforms.RandomRotation(10),
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
   ])

四、完整代码与部署建议

4.1 完整实现代码

（见前文各代码段整合）

4.2 模型部署建议

1. 模型导出：
   ```python

   保存模型

   torch.save(model.state_dict(), ‘lenet5_mnist.pth’)

加载模型

loaded_model = LeNet5().to(device)
loaded_model.load_state_dict(torch.load(‘lenet5_mnist.pth’))

2. **ONNX格式转换**：
```python
dummy_input = torch.randn(1, 1, 28, 28).to(device)
torch.onnx.export(model, dummy_input, "lenet5.onnx")

1. 性能优化技巧：

• 使用混合精度训练（torch.cuda.amp）
• 启用CUDA图加速（对于固定输入尺寸）
• 采用分布式训练（多GPU场景）

五、实践中的常见问题

1. 过拟合问题：

• 解决方案：增加L2正则化（weight_decay=0.001）
• 添加Dropout层（在全连接层后）

1. 收敛速度慢：

• 调整初始学习率（建议0.001-0.01）
• 采用学习率预热策略

1. 硬件利用不足：

• 确保使用num_workers参数加速数据加载
• 检查CUDA是否可用（torch.cuda.is_available()）

六、扩展应用方向

1. 模型改进：

• 替换为ReLU6激活函数
• 引入残差连接
• 使用深度可分离卷积

1. 数据集扩展：

• EMNIST（扩展字母识别）
• SVHN（街景门牌号）
• 自定义手写数据集

1. 实际应用：

• 银行支票数字识别
• 工业产品编号识别
• 教育领域的手写作业批改

本实现完整展示了从LeNet架构设计到PyTorch实现的完整流程，通过10个epoch的训练即可在测试集上达到99%以上的准确率。代码经过严格测试，可直接用于教学演示或实际项目开发。建议读者尝试修改网络结构、调整超参数，观察对模型性能的影响，从而深入理解卷积神经网络的工作原理。