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

卷积神经网络：LeNet模型

news 2025/7/23 7:36:37

一、LeNet简介

LeNet由Yann Lecun 提出，是一种经典的卷积神经网络，是现代卷积神经网络的起源之一，主要用于解决手写数字识别问题。LeNet又称LeNet-5,具有一个输入层，两个卷积层，两个池化层，3个全连接层（其中最后一个全连接层为输出层）。

各个结构作用：

卷积层：提取特征图的特征，浅层的卷积提取的是一些纹路、轮廓等浅层的空间特征，对于深层的卷积，可以提取出深层次的空间特征。

池化层： 1、降低维度 2、最大池化或者平均池化，在本网络结构中使用的是最大池化。

全连接层： 1、输出结果 2、位置：一般位于CNN网络的末端。 3、操作：需要将特征图reshape成一维向量，再送入全连接层中进行分类或者回归。

LeNet-5，其结构简洁且具有明确的层次划分，专为处理 32×32 像素的单通道（灰度）图像设计，具体层结构如下：

输入层
- 接收 32×32×1 的灰度图像（如手写数字图片）。
C1：卷积层
- 卷积核尺寸：5×5
- 卷积核数量：6
- 输出特征图尺寸：28×28×6（因无填充，32-5+1=28）
- 作用：提取图像的低级特征（如边缘、拐角、纹理等）。
S2：池化层（下采样层）
- 采用平均池化，池化窗口 2×2，步长 2
- 输出特征图尺寸：14×14×6（28÷2=14）
- 作用：降低特征图尺寸，减少计算量，同时增强特征的平移不变性。
C3：卷积层
- 卷积核尺寸：5×5
- 卷积核数量：16
- 输出特征图尺寸：10×10×16（14-5+1=10）
- 作用：结合 S2 层的特征，提取更复杂的中级特征（如数字的局部结构）。
S4：池化层
- 平均池化，窗口 2×2，步长 2
- 输出特征图尺寸：5×5×16（10÷2=5）
- 作用：进一步降维，保留关键特征。
C5：卷积层（等效全连接层）
- 卷积核尺寸：5×5
- 卷积核数量：120
- 输出特征图尺寸：1×1×120（5-5+1=1）
- 作用：因输出为 1×1，等效于全连接层，整合 S4 层的特征，输出 120 维特征向量。
F6：全连接层
- 输入：120 维
- 输出：84 维
- 作用：对 C5 层的特征进行非线性变换，进一步抽象特征。
输出层
- 采用径向基函数（RBF）作为激活函数（原始设计），输出 10 维向量（对应 0-9 共 10 个数字）。
- 现代应用中常替换为 Softmax 激活函数，输出类别概率分布。

最简单的LeNet模型。

import torch
import torch.nn as nn
import torch.nn.functional as Fclass LeNet(nn.Module):def __init__(self):super(LeNet, self).__init__()# 定义卷积层self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, stride=1)self.conv2 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5, stride=1)# 定义全连接层self.fc1 = nn.Linear(16 * 5 * 5, 120)self.fc2 = nn.Linear(120, 84)self.fc3 = nn.Linear(84, 10)# 定义激活函数self.relu = nn.ReLU()def forward(self, x):# 卷积层 + 池化层 + 激活函数x = self.relu(self.conv1(x))x = F.avg_pool2d(x, kernel_size=2, stride=2)x = self.relu(self.conv2(x))x = F.avg_pool2d(x, kernel_size=2, stride=2)# 展平特征图x = torch.flatten(x, 1)# 全连接层x = self.relu(self.fc1(x))x = self.relu(self.fc2(x))x = self.fc3(x)return x# 创建模型实例
model = LeNet()# 打印模型结构
print(model)

二、Mnist数据集

MNIST是一个手写数字集合，该数据集来自美国国家标准与技术研究所, National Institute of Standards and Technology (NIST). 训练集 (training set) 由来自 250 个不同人手写的数字构成, 其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员. 测试集(test set) 也是同样比例的手写数字数据。

MNIST数据集简介

该数据集包含60,000个用于训练的示例和10,000个用于测试的示例。
数据集包含了0-9共10类手写数字图片,每张图片都做了尺寸归一化，都是28x28大小的灰度图。
MNIST数据集包含四个部分：训练集图像：train-images-idx3-ubyte.gz（9.9MB，包含60000个样本）训练集标签：train-labels-idx1-ubyte.gz（29KB，包含60000个标签）测试集图像：t10k-images-idx3-ubyte.gz（1.6MB，包含10000个样本）测试集标签：t10k-labels-idx1-ubyte.gz（5KB，包含10000个标签）

import torch
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import numpy as np
import struct# 图像预处理：将图像转换为 (784, 1) 的张量
transform = transforms.Compose([transforms.ToTensor(),               # 转为 [0,1] 范围的 Tensortransforms.Lambda(lambda x: x.view(-1, 1))  # 展平为 (784, 1)
])# 加载 MNIST 训练集和测试集
train_dataset = datasets.MNIST(root='./dataset',train=True,transform=transform,download=True
)test_dataset = datasets.MNIST(root='./dataset',train=False,transform=transform,download=True
)# 使用 DataLoader 批量加载
train_loader = DataLoader(dataset=train_dataset,batch_size=64,shuffle=True
)test_loader = DataLoader(dataset=test_dataset,batch_size=64,shuffle=False
)# ✅ 打印训练集和测试集的样本数量
print(f"训练集样本数量: {len(train_dataset)}")
print(f"测试集样本数量: {len(test_dataset)}")# ✅ 控制台输出矩阵的代码
print("=" * 140)
print("图像矩阵的十六进制表示（非零值用红色标出）：")
data = train_dataset[0][0].squeeze().numpy()  # 获取第一张图像并转换为 numpy 数组
rows = 28
columns = 28counter = 0
for i in range(rows):row = data[i * columns: (i + 1) * columns]for value in row:integer_part = int(value * 100)# 防止溢出 unsigned short (0~65535)integer_part = max(0, min(65535, integer_part))hex_bytes = struct.pack('H', integer_part)hex_string = hex_bytes.hex()if hex_string == '0000':print(hex_string + ' ', end="")else:print(f'\033[31m{hex_string}\033[0m' + " ", end="")counter += 1if counter % 28 == 0:print()  # 换行
print("=" * 140)# 示例：取出第一个 batch 的数据
for images, labels in train_loader:print("Batch Images Shape:", images.shape)    # [batch_size, 784, 1]print("Batch Labels Shape:", labels.shape)    # [batch_size]# 显示第一张图像img = images[0].reshape(28, 28).numpy()plt.imshow(img, cmap='gray')plt.title(f"Label: {labels[0].item()}")plt.axis('off')plt.show()break  # 只显示一个 batch

三、LeNet手写数字识别

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
import time
from matplotlib import pyplot as pltpipline_train = transforms.Compose([# 随机旋转图片# MNIST 是手写数字数据集，左右翻转可能造成语义错误（例如，6 和 9 会被混淆）。所以不建议使用# transforms.RandomHorizontalFlip(),# 将图片尺寸resize到32x32transforms.Resize((32, 32)),# 将图片转化为Tensor格式transforms.ToTensor(),# 正则化(当模型出现过拟合的情况时，用来降低模型的复杂度)transforms.Normalize((0.1307,), (0.3081,))
])
pipline_test = transforms.Compose([# 将图片尺寸resize到32x32transforms.Resize((32, 32)),transforms.ToTensor(),transforms.Normalize((0.1307,), (0.3081,))
])
# 下载数据集
train_set = datasets.MNIST(root="./dataset", train=True, download=True, transform=pipline_train)
test_set = datasets.MNIST(root="./dataset", train=False, download=True, transform=pipline_test)
# 加载数据集
trainloader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)
testloader = torch.utils.data.DataLoader(test_set, batch_size=32, shuffle=False)# 构建LeNet模型
class LeNet(nn.Module):def __init__(self):super(LeNet, self).__init__()self.conv1 = nn.Conv2d(1, 6, 5)self.relu = nn.ReLU()self.maxpool1 = nn.MaxPool2d(2, 2)self.conv2 = nn.Conv2d(6, 16, 5)self.maxpool2 = nn.MaxPool2d(2, 2)self.fc1 = nn.Linear(16 * 5 * 5, 120)self.fc2 = nn.Linear(120, 84)self.fc3 = nn.Linear(84, 10)def forward(self, x):x = self.conv1(x)x = self.relu(x)x = self.maxpool1(x)x = self.conv2(x)x = self.maxpool2(x)x = x.view(-1, 16 * 5 * 5)x = F.relu(self.fc1(x))x = F.relu(self.fc2(x))x = self.fc3(x)return x# 创建模型，部署gpu
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = LeNet().to(device)
# 定义优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)def train_runner(model, device, trainloader, optimizer, epoch):model.train()total_loss = 0total_correct = 0total_samples = 0for i, (inputs, labels) in enumerate(trainloader):inputs, labels = inputs.to(device), labels.to(device)optimizer.zero_grad()outputs = model(inputs)loss = F.cross_entropy(outputs, labels)predict = outputs.argmax(dim=1)correct = (predict == labels).sum().item()loss.backward()optimizer.step()total_loss += loss.item()total_correct += correcttotal_samples += labels.size(0)if i % 100 == 0:print(f"Epoch {epoch}, Batch {i}, Loss: {loss.item():.6f}, Accuracy: {correct / labels.size(0) * 100:.2f}%")avg_loss = total_loss / len(trainloader)avg_acc = total_correct / total_samplesprint(f"Epoch {epoch} - Average Loss: {avg_loss:.6f}, Accuracy: {avg_acc * 100:.2f}%")return avg_loss, avg_accdef test_runner(model, device, testloader):# 模型验证, 必须要写, 否则只要有输入数据, 即使不训练, 它也会改变权值# 因为调用eval()将不启用 BatchNormalization 和 Dropout, BatchNormalization和Dropout置为Falsemodel.eval()# 统计模型正确率, 设置初始值correct = 0.0test_loss = 0.0total = 0# torch.no_grad将不会计算梯度, 也不会进行反向传播with torch.no_grad():for data, label in testloader:data, label = data.to(device), label.to(device)output = model(data)test_loss += F.cross_entropy(output, label).item()predict = output.argmax(dim=1)# 计算正确数量total += label.size(0)correct += (predict == label).sum().item()# 计算损失值print("test_avarage_loss: {:.6f}, accuracy: {:.6f}%".format(test_loss / total, 100 * (correct / total)))# 调用
epoch = 5
Loss = []
Accuracy = []
for epoch in range(1, epoch + 1):print("start_time", time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))loss, acc = train_runner(model, device, trainloader, optimizer, epoch)Loss.append(loss)Accuracy.append(acc)test_runner(model, device, testloader)print("end_time: ", time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())), '\n')print('Finished Training')plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.plot(Loss)
plt.title('Training Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')plt.subplot(1, 2, 2)
plt.plot(Accuracy)
plt.title('Training Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.tight_layout()
plt.show()