当前位置： 首页 > news >正文

深度学习篇---LeNet-5网络结构

news 2025/8/27 10:19:03

在 PyTorch 中实现 LeNet-5 其实很简单，就像搭积木一样把各个层按照顺序组合起来。我们可以分步骤来实现，从搭建网络结构到训练模型，每一步都很直观。

一、先明确 LeNet-5 的结构（复习）

在 PyTorch 中实现网络，首先要记住 LeNet-5 的经典结构：

输入(32×32灰度图) → 卷积层1 → 池化层1 → 卷积层2 → 池化层2 → 全连接层1 → 全连接层2 → 输出层(10个数字)

二、PyTorch 实现 LeNet-5 的步骤

步骤 1：导入必要的库

就像做菜需要先准备好厨具，实现模型前要导入 PyTorch 相关的工具：

import torch  # PyTorch的核心库
import torch.nn as nn  # 包含各种神经网络层
import torch.optim as optim  # 包含优化器（比如梯度下降）
from torch.utils.data import DataLoader  # 用于加载数据
from torchvision import datasets, transforms  # 用于处理图像数据

步骤 2：定义 LeNet-5 网络结构

在 PyTorch 中，我们通过创建一个类来定义网络，这个类要继承nn.Module（PyTorch 中所有网络的基类）。
核心是重写两个方法：__init__（定义网络层）和forward（定义数据流向）。

class LeNet5(nn.Module):def __init__(self):super(LeNet5, self).__init__()# 定义卷积层和池化层self.conv_layers = nn.Sequential(# 卷积层1：输入1个通道(灰度图)，输出6个通道，卷积核5×5nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5),nn.Tanh(),  # 激活函数，让网络能学习非线性特征# 池化层1：2×2最大池化nn.MaxPool2d(kernel_size=2, stride=2),# 卷积层2：输入6个通道，输出16个通道，卷积核5×5nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5),nn.Tanh(),# 池化层2：2×2最大池化nn.MaxPool2d(kernel_size=2, stride=2))# 定义全连接层self.fc_layers = nn.Sequential(# 全连接层1：输入是16×5×5的特征（池化后的结果），输出120nn.Linear(in_features=16*5*5, out_features=120),nn.Tanh(),# 全连接层2：输入120，输出84nn.Linear(in_features=120, out_features=84),nn.Tanh(),# 输出层：输入84，输出10（对应0-9十个数字）nn.Linear(in_features=84, out_features=10))# 定义数据在网络中的流动过程def forward(self, x):x = self.conv_layers(x)  # 先经过卷积和池化层x = x.view(-1, 16*5*5)  # 把特征图"拉平"成一维向量（为全连接层做准备）x = self.fc_layers(x)   # 再经过全连接层return x

简单解释：

  • nn.Sequential：像装积木一样把层按顺序组合起来，数据会按顺序流过每一层。
  • Conv2d：卷积层，kernel_size=5表示用 5×5 的卷积核。
  • MaxPool2d：池化层，stride=2表示每次滑动 2 步（所以尺寸会减半）。
  • Linear：全连接层，把前面的特征汇总后输出结果。

步骤 3：准备数据（以 MNIST 手写数字为例）

LeNet-5 最初就是为识别手写数字设计的，我们用经典的 MNIST 数据集来训练：

# 数据预处理：把图片转换成Tensor，并做标准化
transform = transforms.Compose([transforms.Resize((32, 32)),  # 把MNIST的28×28图片放大到32×32（LeNet-5要求的输入尺寸）transforms.ToTensor(),        # 转换成PyTorch能处理的Tensor格式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
)# 用DataLoader批量加载数据（方便训练时按批次处理）
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

步骤 4：初始化模型、损失函数和优化器

  • 模型：就是我们上面定义的 LeNet5。
  • 损失函数：衡量模型预测的错误程度（这里用交叉熵损失，适合分类问题）。
  • 优化器：用来更新模型参数（这里用 SGD，随机梯度下降）。
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  # 用GPU加速（如果有的话）
model = LeNet5().to(device)  # 初始化模型并放到GPU/CPU上criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数（自带Softmax，输出概率）
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)  # 优化器，lr是学习率

步骤 5：训练模型

训练过程就像 “学生做题纠错”：模型先猜答案，根据错误调整自己，反复多次直到准确率提高。

def train(model, train_loader, criterion, optimizer, epoch):model.train()  # 切换到训练模式for batch_idx, (data, target) in enumerate(train_loader):data, target = data.to(device), target.to(device)  # 数据放到GPU/CPU上optimizer.zero_grad()  # 清空之前的梯度output = model(data)   # 模型预测loss = criterion(output, target)  # 计算损失（预测和真实答案的差距）loss.backward()        # 反向传播，计算梯度optimizer.step()       # 根据梯度更新模型参数# 打印训练进度if batch_idx % 100 == 0:print(f'Epoch {epoch}, Batch {batch_idx}, Loss: {loss.item():.6f}')# 训练5轮（可以根据需要增加）
for epoch in range(1, 6):train(model, train_loader, criterion, optimizer, epoch)

训练的核心逻辑：

  1. 模型用当前参数做预测 → 2. 计算预测错误（损失） → 3. 反向算 “怎么调整参数能减少错误”（梯度） → 4. 按梯度调整参数 → 重复。

步骤 6：测试模型效果

训练完后，用测试集看看模型的准确率：

def test(model, test_loader):model.eval()  # 切换到评估模式（关闭 dropout 等训练特有的操作）correct = 0total = 0with torch.no_grad():  # 测试时不计算梯度（节省内存）for data, target in test_loader:data, target = data.to(device), target.to(device)output = model(data)_, predicted = torch.max(output.data, 1)  # 取概率最大的那个数字作为预测结果total += target.size(0)correct += (predicted == target).sum().item()print(f'Test Accuracy: {100 * correct / total:.2f}%')# 测试模型
test(model, test_loader)

运行后，你会看到类似这样的结果（训练 5 轮后）：
Test Accuracy: 98.50%（准确率会因训练轮数等略有差异）

三、完整代码总结

把上面的步骤整合起来，就是一个可直接运行的 LeNet-5 实现：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms# 1. 定义LeNet-5网络结构
class LeNet5(nn.Module):def __init__(self):super(LeNet5, self).__init__()# 卷积和池化层self.conv_layers = nn.Sequential(nn.Conv2d(1, 6, kernel_size=5),  # 卷积层1：1→6通道，5×5卷积核nn.Tanh(),nn.MaxPool2d(kernel_size=2, stride=2),  # 池化层1：2×2，步长2nn.Conv2d(6, 16, kernel_size=5),  # 卷积层2：6→16通道，5×5卷积核nn.Tanh(),nn.MaxPool2d(kernel_size=2, stride=2)  # 池化层2：2×2，步长2)# 全连接层self.fc_layers = nn.Sequential(nn.Linear(16*5*5, 120),  # 全连接层1：输入16×5×5，输出120nn.Tanh(),nn.Linear(120, 84),      # 全连接层2：输入120，输出84nn.Tanh(),nn.Linear(84, 10)        # 输出层：输入84，输出10（0-9）)def forward(self, x):x = self.conv_layers(x)          # 经过卷积和池化x = x.view(-1, 16*5*5)           # 拉平特征图x = self.fc_layers(x)            # 经过全连接层return x# 2. 准备数据
transform = transforms.Compose([transforms.Resize((32, 32)),       # 调整为32×32transforms.ToTensor(),             # 转为Tensortransforms.Normalize((0.1307,), (0.3081,))  # 标准化
])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)# 3. 初始化模型、损失函数和优化器
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = LeNet5().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)# 4. 训练函数
def train(model, train_loader, criterion, optimizer, epoch):model.train()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()        # 更新参数if batch_idx % 100 == 0:print(f'Epoch {epoch}, Batch {batch_idx}, Loss: {loss.item():.6f}')# 5. 测试函数
def test(model, test_loader):model.eval()correct = 0total = 0with torch.no_grad():for data, target in test_loader:data, target = data.to(device), target.to(device)output = model(data)_, predicted = torch.max(output.data, 1)total += target.size(0)correct += (predicted == target).sum().item()print(f'Test Accuracy: {100 * correct / total:.2f}%')# 6. 开始训练和测试
for epoch in range(1, 6):train(model, train_loader, criterion, optimizer, epoch)
test(model, test_loader)

四、关键知识点回顾

  1. 网络结构：卷积层负责提取特征（线条、圆圈），池化层压缩数据，全连接层做最终判断。
  2. 训练流程：通过 “预测→算错→调参” 的循环，让模型逐渐学会识别数字。
  3. PyTorch 技巧：用nn.Sequential简化层的组合，用DataLoader方便数据加载，用to(device)实现 GPU 加速。

运行这段代码后，你会得到一个能识别手写数字的 LeNet-5 模型，准确率通常能达到 98% 以上，和 LeCun 当年的结果很接近！

http://www.xdnf.cn/news/1369567.html

相关文章：

  • 病理软件Cellprofiler使用教程
  • vue2 和 vue3 生命周期的区别
  • 一篇文章拆解Java主流垃圾回收器及其调优方法。
  • LeetCode-22day:多维动态规划
  • 代码随想录Day62：图论（Floyd 算法精讲、A * 算法精讲、最短路算法总结、图论总结）
  • vue2和vue3的对比
  • TensorFlow 深度学习：使用 feature_column 训练心脏病分类模型
  • Day3--HOT100--42. 接雨水，3. 无重复字符的最长子串，438. 找到字符串中所有字母异位词
  • CentOS 7 服务器初始化：从 0 到 1 的安全高效配置指南
  • 肌肉力量训练
  • 木马免杀工具使用
  • 产品经理操作手册（3）——产品需求文档
  • 全链路营销增长引擎闭门会北京站开启倒计时，解码营销破局之道
  • 构建生产级 RAG 系统：从数据处理到智能体（Agent）的全流程深度解析
  • 书生大模型InternLM2：从2.6T数据到200K上下文的开源模型王者
  • word批量修改交叉引用颜色
  • 【SystemUI】新增实体键盘快捷键说明
  • 常用Nginx正则匹配规则
  • ruoyi-vue（十二）——定时任务，缓存监控，服务监控以及系统接口
  • 软件检测报告：XML外部实体（XXE）注入漏洞原因和影响
  • 服务器初始化流程***
  • 在分布式环境下正确使用MyBatis二级缓存
  • 在 UniApp 中，实现下拉刷新
  • Python爬虫: 分布式爬虫架构讲解及实现
  • IjkPlayer 播放 MP4 视频时快进导致进度回退的问题
  • iOS 26 正式版即将发布，Flutter 完成全新 devicectl + lldb 的 Debug JIT 运行支持
  • 深度学习（三）：PyTorch 损失函数：按任务分类的实用指南
  • Milvus介绍及多模态检索实践
  • 系统设计中的幂等性
  • 【LeetCode 热题 100】31. 下一个排列