Pytorch实战（一）：LeNet神经网络

---

  LeNet神经网络是第一个卷积神经网络（CNN），首次采用了卷积层、池化层这两个全新的神经网络组件，接收灰度图像，并输出其中包含的手写数字，在手写字符识别任务上取得了瞩目的准确率。LeNet网络的一系列的版本，以LeNet-5版本最为著名，也是LeNet系列中效果最佳的版本。LeNet神经网络输入图像大小必须为32x32，且所用卷积核大小固定为5x5，模型结构如下：

模型参数：

• INPUT（输入层）：输入图像尺寸为32x32，且是单通道灰色图像。
• C1（卷积层）：使用6个5x5大小的卷积核，步长为1，卷积后得到6张28×28的特征图。
• S2（池化层）：使用了6个2×2 的平均池化，池化后得到6张14×14的特征图。
• C3（卷积层）：使用了16个大小为5×5的卷积核，步长为1，得到 16 张10×10的特征图。
• S4（池化层）：使用16个2×2的平均池化，池化后得到16张5×5 的特征图。
• C5（卷积层）：使用120个大小为5×5的卷积核，步长为1，卷积后得到120张1×1的特征图。
• F6（全连接层）：输入维度120，输出维度是84（对应7x12 的比特图）。
• OUTPUT（输出层）：使用高斯核函数，输入维度84，输出维度是10（对应数字 0 到 9）。

该模型有如下特点：

• 1.首次提出卷积神经网络基本框架： 卷积层，池化层，全连接层。
• 2.卷积层的权重共享，相较于全连接层使用更少参数，节省了计算量与内存空间。
• 3.卷积层的局部连接，保证图像的空间相关性。
• 4.使用映射到空间均值下采样，减少特征数量。
• 5.使用双曲线（tanh）或S型（sigmoid）形式的非线性激活函数。

一、模型实现

1.1数据集的下载

  使用torchversion内置的MNIST数据集，训练集大小60000，测试集大小10000，图像大小是1×28×28，包括数字0~9共10个类。

from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms
import torchvision
# 下载训练、测试数据集
mnist_train = torchvision.datasets.MNIST(root='./dataset/',train=True, download=True, transform=transforms.ToTensor())
mnist_test = torchvision.datasets.MNIST(root='./dataset/',train=False, download=True, transform=transforms.ToTensor())
print('mnist_train基本信息为：',mnist_train)
print('-----------------------------------------')
print('mnist_test基本信息为：',mnist_test)
print('-----------------------------------------')
img,label=mnist_train[0]
print('mnist_train[0]图像大小及标签为：',img.shape,label)

1.2加载数据集

trainDataLoader = DataLoader(mnist_train, batch_size=64, num_workers=5, shuffle=True)
testDataLoader = DataLoader(mnist_test, batch_size=64, num_workers=0, shuffle=True)
write = SummaryWriter('./log')
step = 0
for images, labels in testDataLoader:write.add_images(tag='train', images, global_step=step)step += 1
write.close()

  注意不能使用for images, labels in testDataLoader.dataset，testDataLoader.dataset[0]是保存图像（28
，28）和对应标签的元组，而Tensorboard的add_images只能输入NCHW格式对象，使用该代码会报错：

size of input tensor and input format are different. tensor shape: (1, 28, 28), input_format: NCHW

数据加载器按batch_size对数据及标签进行封装名，可直接作为输入。查看封装的元组：

for data in testDataLoader:print('type(data)：',type(data))img,label=dataprint('type(img)：',type(img),'img.shape：',img.shape)print('type(label)：',type(label),'label.shape：',label.shape)

1.3模型训练

  LeNet模型的输入为（32，32）的图片，而MNIST数据集为（28，28）的图片，故需对原图片进行填充。搭建模型：

class LeNet(nn.Module):def __init__(self):super(LeNet, self).__init__()self.model = nn.Sequential(  #MNIST数据集图像大小为28x28，而LeNet输入为32x32，故需填充nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, stride=1, padding=2),  #C1层共六个卷积核，故out_channels=6nn.AvgPool2d(kernel_size=2, stride=2),  #C2层使用平均池化nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5),nn.AvgPool2d(kernel_size=2, stride=2),nn.Flatten(),nn.Conv2d(in_channels=16 * 5 * 5, out_channels=120),nn.Linear(in_features=120, out_features=84),nn.Linear(in_features=84, out_features=10))def forward(self, x):return self.model(x)# 初始化模型对象
myLeNet = LeNet()

  设置损失函数、优化器并训练模型：

# 设置损失函数为交叉熵损失函数
loss_fn = nn.CrossEntropyLoss()
loss_fn = loss_fn.to(device)
# 设置优化器，使用Adam优化算法
learning_rate = 1e-2
optimizer = torch.optim.Adam(myLeNet.parameters(), lr=learning_rate)
total_train_step = 0  # 总训练次数
epoch = 10  # 训练轮数
writer = SummaryWriter(log_dir='./runs/LeNet/')
for i in range(epoch):print("-----第{}轮训练开始-----".format(i + 1))myLeNet.train()  # 训练模式train_loss = 0for data in trainDataLoader:imgs, labels = dataimgs = imgs.to(device)  # 适配GPU/CPUlabels = labels.to(device)outputs = myLeNet(imgs)loss = loss_fn(outputs, labels)#计算损失函数optimizer.zero_grad()  # 清空之前梯度loss.backward()  # 反向传播optimizer.step()  # 更新参数total_train_step += 1  # 更新步数train_loss += loss.item()writer.add_scalar("train_loss_detail", loss.item(), total_train_step)writer.add_scalar("train_loss_total", train_loss, i + 1)writer.close()

1.4模型预测

myLeNet.eval() 
total_test_loss = 0  # 当前轮次模型测试所得损失
total_accuracy = 0  # 当前轮次精确率
with torch.no_grad():  # 关闭梯度反向传播for data in testDataLoader:imgs, targets = dataimgs = imgs.to(device)targets = targets.to(device)outputs = myLeNet(imgs)loss = loss_fn(outputs, targets)total_test_loss = total_test_loss + loss.item()accuracy = (outputs.argmax(1) == targets).sum()total_accuracy = total_accuracy + accuracy
writer.add_scalar("test_loss", total_test_loss, i+1)
writer.add_scalar("test_accuracy", total_accuracy/len(mnist_test), i+1)

https://blog.csdn.net/qq_43307074/article/details/126022041?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522171938503416800186515588%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=171938503416800186515588&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_alltop_click~default-2-126022041-null-null.142^v100pc_search_result_base3&utm_term=LeNet&spm=1018.2226.3001.4187

https://blog.csdn.net/hellocsz/article/details/80764804?ops_request_misc=&request_id=&biz_id=102&utm_term=LeNet&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduweb~default-1-80764804.142^v100pc_search_result_base3&spm=1018.2226.3001.4187

https://blog.csdn.net/qq_45034708/article/details/128319241?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522171936257316800222847105%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=171936257316800222847105&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_alltop_positive~default-1-128319241-null-null.142^v100pc_search_result_base3&utm_term=LeNet&spm=1018.2226.3001.4187