一、开发背景
LeNet是一系列网络的合称，包括LeNet1-LeNet5，由Yann LeCun等人 在1990年《Handwritten Digit Recognition with a Back-Propagation Network》中提出，是卷积神经网络的开山之作，也是将深度学习推向繁荣的一座里程碑。
LeNet是一种图像分类模型，应用于支票或邮件编码上的手写数字的识别，该作者的Yann LeCun也被称为卷积神经网络之父，深度学习在现在的发展离不开这位伟大科学家辛勤付出。
2018 年，LeCun 因深度学习的研究贡献，与 Yoshua Bengio、Geoffrey Hinton 共同获得了计算机科学最高荣誉图灵奖
LeNet首次采用了卷积层、池化层这两个全新的神经网络组件，接收灰度图像，并输出其中包含的手写数字，在手写字符识别任务上取得了瞩目的准确率。LeNet网络的一系列的版本，以LeNet-5版本最为著名，也是LeNet系列中效果最佳的版本。
二、网络结构
该网络只有7层的神经网络，包括3个卷积层，2个池化层，1个全连接层，1个输出层。其中所有卷积层的卷积核大小都为5*5，步长=1，池化方法为平均池化，激活函数为 Sigmoid（目前使用的Lenet已改为ReLu），网络结构如下：
详细的过程可以看后边的代码，代码中都包含详细的注释。
三、模型特点
- 首次提出卷积神经网络基本框架： 卷积层，池化层，全连接层；
- 卷积层的权重共享，相较于全连接层使用更少参数，节省了计算量与内存空间；
- 卷积层的局部连接，保证图像的空间相关性；
- 使用映射到空间均值下采样，减少特征数量；
- 使用双曲线（tanh）或S型（sigmoid）形式的非线性激活函数
四、代码实现
- model.py：定义LeNet网络模型
- train.py：加载数据集并训练，计算loss和accuracy，保存训练好的网络参数
- predict.py：用自己的数据集进行分类测试
（一）model.py
# 定义了网络模型
import torch
from torch import nn
# 定义网络模型
# MyLeNet5（子类）继承nn.Moudle（父类）
class MyLeNet5(nn.Module): # 括号里面是他爹
# 子类继承中重新定义Moudle类的__init__和forward（）函数
# init()函数：进行初始化，申明模型中各层的定义
def __init__(self):
# super:引入父类的初始化方法给子类进行初始化
super(MyLeNet5,self).__init__()
# 卷积层，输入大小为28*28，输出大小为28*28，输入通道为1，输出为6，卷积核为5*5，扩充边缘为2
self.c1 = nn.Conv2d(in_channels=1,out_channels=6,kernel_size=5,padding=2)
# 使用sigmoid作为激活函数
self.Sigmoid = nn.Sigmoid()
# Avgpool2d:二维平均池化操作
# 池化层，输入大小为28*28，输出大小为14*14，输入通道6，输出通道为6，卷积核为2，步长为2
self.s2 = nn.AvgPool2d(kernel_size=2,stride=2)
# 卷积层，输入大小14*14，输出大小为10*10，输入通道为6，输出为16，卷积核为5
self.c3 = nn.Conv2d(in_channels=6,out_channels=16,kernel_size=5)#默认填充为0
# 池化层，输入为10*10，输出为5*5，输入通道为16，输出为16.卷积核为2，步长为2
self.s4 = nn.AvgPool2d(kernel_size=2,stride=2)
# 卷积层，输入大小为5*5，输出大小为1*1，输入通道为16，输出为120，卷积核为5
self.c5 = nn.Conv2d(in_channels=16,out_channels=120,kernel_size=5)
# Flatten()：将张量（多维数组）平坦化处理，张量的第0维表示的是batch——size（数量），所以Flatten（）默认从第二维开始平坦化
self.flatten = nn.Flatten()
# linear(infeatures,outfeatures)
# infeature指的是样本的大小
# outfeatures指的是样本的输出的维度的大小，也代表了该全连接层的神经元个数
self.f6 = nn.Linear(120,84)
self.output = nn.Linear(84,10)
# forword():定义了前向传播的过程，描述了各层之前恶的连接关系
def forward(self,x):
# 这里讲述的是正常的前向传播的过程，到最后的输出，这里是这样讲述的。
x = self.Sigmoid(self.c1(x))
x = self.s2(x)
x=self.Sigmoid(self.c3(x))
x = self.s4(x)
x = self.c5(x)
x = self.flatten(x)
x = self.f6(x)
x = self.output(x)
return x
# 测试代码
# 每个.py文件，都包含内置的变量__name__,当该模块被直接执行的时候，__name__等于文件名
# 如果该模块import到其他模块，则该模块的__name__等于模块名称
# “__main__” 始终指当前执行模块的名称（包含后缀.py）
#if确保只有单独运行该模块时，此表达式才成立，才可以进入此判断语法，执行其中的测试代码，反之不行
if __name__ == "__main__":
# rand返回一个张量，包含了从区间【0，1）的均匀分布中随机抽取的一组随机数，此处为思维张量
x = torch.rand([1,1,28,28]) # 对于处理灰度图的时候，需要的输入张量的格式
# 模型实例化
model = MyLeNet5()
y=model(x)
print(y)(二)train.py
import torch
from torch import nn
from model import MyLeNet5 # 引入这个类，定义模型
from torch.optim import lr_scheduler
# lr_scheduler:提供了一些根据epoch训练次数来调整学习率的方法
from torchvision import datasets,transforms
# 这个库：是pytorch的一个图形库，服务于pytorch深度学习框架，主要用于构建计算机视觉模型
# transfroms 主要是用于常见的一些图形变换，datasets：包含加载数据的函数及常用的数据集接口
import os # 这个英文翻译过来是操作系统的意思，该模块封装了常见文件和目录的操作
# 将数据转换为张量格式为了便于后来的操作
# Compose（）：这个的作用是将多个transfroms的操作整合在一起 ，组合多个数据转换操作的函数，汉昭给定的顺序
# ToTensor（）：将numpy的ndarray或者PIL.Image读的图片转化为形状为（C,H,W）的tensor格式，并且归一化到[0,1]之间
data_transfrom = transforms.Compose(
[transforms.ToTensor()]
) # 定义了一个包含这个功能的转换，括号里面的内容还可以添加，这里都没添加了，然后
# 加载数据集
# MNIST数据集来自美国国家标准与技术研究所，训练集和测试集，由分别来自250个不同人手写的数字构成。
# MNIST数据集包含：Training set images、Training set labels、Test set images、Test set labels
# train = true是训练集，false为测试集
train_dataset = datasets.MNIST(root='./data',train=True,transform=data_transfrom,download=True)
# DataLoader:将读取的数据按照batch size大小封装并行训练
# dataset：加载的数据集
# batch_size(int,optional):每个batch加载多少个样本（默认为1）
# shuffle（bool，optional）：设置为True时会再每个epoch重新打乱数据 就是对所有的数据集进行打乱数据
train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,batch_size=16,shuffle=True)
# 加载测试数据集
test_dataset = datasets.MNIST(root='./data',train=False,transform=data_transfrom,download=True)
test_dataloader = torch.utils.data.DataLoader(dataset = test_dataset,batch_size = 16,shuffle = True)
# 如果有NVIDIA显卡，转到GPU进行训练，否则用CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# 模型实例化，将模型转到device
model = MyLeNet5().to(device)
#定义损失函数（交叉熵损失）
loss_fn = nn.CrossEntropyLoss()
# 定义优化器（随机梯度下降法）
# params（iterself）:要训练的参数，一般传入的是model.parameters()
# lr(float):learning_rate学习率，也就是步长
# momentum（float，可选）：动量因子（默认为0），矫正优化率。
optimizer = torch.optim.SGD(model.parameters(),lr=1e-3,momentum=0.9)
# 学习率，每隔10轮变为原来的0.1，防止的是局部最优解
# StepLR：用于调整学习率，一般情况下设置随着epoch的增大而逐渐减小学习率而达到更好的训练效果
# optimizer：需要更改学习率的优化器
# step_size(int):每训练step_size个epoch，更新一次参数
# gamma（float）:更新学习率的乘法因子
lr_scheduler = lr_scheduler.StepLR(optimizer,step_size=10,gamma=0.1)
# 定义训练函数
def train(dataloader,model,loss_fn,optimizer):
loss,current,n = 0.0,0.0,0
# dataloader:传入数据（数据包括：训练数据和标签）简称数据迭代器
# enumerate():用于将一个可以遍历的数据对象，组合为一个索引序列，一般用于for循环当中
# 上边这个玩意返回值有两个：一个是序号，一个是数据（包含训练数据和标签）
# x：训练数据（inputs）张量类型的，y是标签也是张量类型的
for batch,(x,y) in enumerate(dataloader):
# 前向传播
x,y = x.to(device),y.to(device)
# 计算训练值
output = model(x) # 在本案例中，output就是一个16*10的一个向量
# 计算观测值（label）与训练值的损失函数
cur_loss = loss_fn(output,y)
# torch.max(input,dim)函数
# input是具体的tentor，dim是max函数索引的维度，0是每列的最大值，1是每行的最大值输出
# 函数会返回两个tensor，第一个tensor是每行的最大值：第二个tensor是每行最大值的索引
_,pred = torch.max(output,axis=1)
# 计算每批次的准确率
# output。shape[0]一维长度为该批次的数量
# torch.sum()对输入的张良数据的某一维度求和
cur_acc = torch.sum(y == pred)/output.shape[0]
# 反向传播
#清空过往梯度
optimizer.zero_grad() # 固定的操作，将参数的梯度置0
#反向传播，计算当前梯度
cur_loss.backward() # 进行反向传播计算梯度，并且保存在原始的向量中去 # 用损失函数的结果进行反向传播计算梯度
# 根据梯度更新网络参数
optimizer.step() # 使用定义的优化器来更新网络参数
# .item():得到元素张量的元素值
loss+=cur_loss.item()
current+=cur_acc.item()
n=n+1
train_loss = loss/n
train_acc = current/n
# 计算训练的错误率
print('train_loss' + str(train_loss))
# 计算训练的准确率
print('train_acc' + str(train_acc))
# 定义验证函数
def val(dataloader,model,loss_fn):
#model.eval():设置为验证模式，如果模型中有Batch Normalization或者Dropout，则不启用，以防止改变均值
model.eval()
loss,current,n = 0.0,0.0,0
# with torch.no_grad():将with语句包裹起来的部分停止梯度的更新，从而节省了GPU算力和显存，但是并不会影响dropout和BN层的行为
with torch.no_grad():
for batch,(x,y) in enumerate(dataloader):
# 前向传播
x,y = x.to(device),y.to(device)
output = model(x)
cur_loss = loss_fn(output,y)
_, pred = torch.max(output, axis=1)
cur_acc = torch.sum(y == pred) / output.shape[0]
loss += cur_loss.item()
current += cur_acc.item()
n = n + 1
# 计算验证的错误率
print("val_loss：" + str(loss / n))
# 计算验证的准确率
print("val_acc：" + str(current / n))
# 返回模型准确率
return current / n
# 开始训练，训练次数 用于判断最佳模型
epoch = 10
min_acc = 0
for t in range(epoch):
print(f'epoch{t+1}\n---------------')
# 训练模型
train(train_dataloader, model, loss_fn, optimizer)
# 验证模型
a = val(test_dataloader, model, loss_fn)
# 保存最好的模型权重
if a > min_acc:
folder = 'save_model'
# path.exists：判断括号里的文件是否存在，存在为True，括号内可以是文件路径
if not os.path.exists(folder):
# os.mkdir() ：用于以数字权限模式创建目录
os.mkdir('save_model')
min_acc = a
print('save best model')
# torch.save(state, dir)保存模型等相关参数，dir表示保存文件的路径+保存文件名
# model.state_dict()：返回的是一个OrderedDict，存储了网络结构的名字和对应的参数
torch.save(model.state_dict(), 'save_model/best_model.pth')
print('Done!')
注意：在运行这段代码的时候，可能会出现报错，显示http，这个原因是因为下载的数据集是从torch的库中去下载的，这个库在国外，加上服务器经常维护的原因，导致在国内访问不了，这个时候，有3个解决方案：1 用魔法去下载 2 点进去报错的链接，在官网上下载 3 多试几次，总有一次是可以下载成功的
运行结果如下：
可以看出，训练10轮的后，训练集和验证集的精度和损失，并把训练好的模型保存在代码文件夹下。
（三）predict.py
import torch
from model import MyLeNet5
from torch.autograd import Variable
from torchvision import datasets, transforms
from torchvision.transforms import ToPILImage
# Compose()：将多个transforms的操作整合在一起
data_transform = transforms.Compose([
# ToTensor()：数据转化为Tensor格式
transforms.ToTensor()
])
# 加载训练数据集
train_dataset = datasets.MNIST(root='./data', train=True, transform=data_transform, download=True)
# 给训练集创建一个数据加载器, shuffle=True用于打乱数据集，每次都会以不同的顺序返回
train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=16, shuffle=True)
# 加载测试数据集
test_dataset = datasets.MNIST(root='./data', train=False, transform=data_transform, download=True)
test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=16, shuffle=True)
# 如果有NVIDA显卡，转到GPU训练，否则用CPU
device = 'cuda' if torch.cuda.is_available() else 'cpu'
# 模型实例化，将模型转到device
model = MyLeNet5().to(device)
# 加载train.py里训练好的模型
model.load_state_dict(torch.load(r"D:\cv\第三章\CNN\LeNet\save_model\best_model.pth"))
# 结果类型
classes = [
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
]
# 把Tensor转化为图片，方便可视化
show = ToPILImage()
# 进入验证阶段
for i in range(10):
x, y = test_dataset[i][0], test_dataset[i][1]
# show()：显示图片
show(x).show()
# unsqueeze(input, dim)，input(Tensor)：输入张量，dim (int)：插入维度的索引，最终将张量维度扩展为4维
x = Variable(torch.unsqueeze(x, dim=0).float(), requires_grad=False).to(device)
with torch.no_grad():
pred = model(x)
# argmax(input)：返回指定维度最大值的序号
# 得到验证类别中数值最高的那一类，再对应classes中的那一类
predicted, actual = classes[torch.argmax(pred[0])], classes[y]
# 输出预测值与真实值
print(f'predicted: "{predicted}", actual:"{actual}"')运行结果如下：
可以看出效果还是非常好的。
大多数都是借鉴的，大家有问题直接提问。