一、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 F
class 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] 范围的 Tensor
transforms.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 = 28
counter = 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 += 1
if 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 plt
pipline_train = transforms.Compose([
# 随机旋转图片
# MNIST 是手写数字数据集，左右翻转可能造成语义错误（例如，6 和 9 会被混淆）。所以不建议使用
# transforms.RandomHorizontalFlip(),
# 将图片尺寸resize到32x32
transforms.Resize((32, 32)),
# 将图片转化为Tensor格式
transforms.ToTensor(),
# 正则化(当模型出现过拟合的情况时，用来降低模型的复杂度)
transforms.Normalize((0.1307,), (0.3081,))
])
pipline_test = transforms.Compose([
# 将图片尺寸resize到32x32
transforms.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 = 0
total_correct = 0
total_samples = 0
for 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 += correct
total_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_samples
print(f"Epoch {epoch} - Average Loss: {avg_loss:.6f}, Accuracy: {avg_acc * 100:.2f}%")
return avg_loss, avg_acc
def test_runner(model, device, testloader):
# 模型验证, 必须要写, 否则只要有输入数据, 即使不训练, 它也会改变权值
# 因为调用eval()将不启用 BatchNormalization 和 Dropout, BatchNormalization和Dropout置为False
model.eval()
# 统计模型正确率, 设置初始值
correct = 0.0
test_loss = 0.0
total = 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()
