LeNet

最新推荐文章于 2024-07-25 23:06:58 发布
最新推荐文章于 2024-07-25 23:06:58 发布
阅读量215 收藏 2
点赞数 1
文章标签： 可视化 神经网络 深度学习 tensorflow 卷积神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42411502/article/details/117464163
版权

LeNet的结构如图所示，其网状结构比较简单，如果不包括输入，它一共是7层，输入层图像为32*32

卷积神经网络3D可视化传送门

  • C1 卷积层1

卷积核(过滤器)：6个5*5

特征图：6个28*28

训练参数：1 *(5 * 5) * 6+6=156

原图经过卷积核后生成的特征图大小计算：
(输入-卷积核+加边像素)/步长+1 →(32-5+0)/1+1

训练参数的计算方法：原图数量 * (卷积核大小) * 卷积核个数 +偏置项，其中池化层不需要训练参数，一个卷积核对应一个偏置项

此外，我们发现，即便步长为1，经过卷积后特征图片的尺寸变小了。但是由于过滤器在移动到边缘的时候就结束了，中间的像素点比边缘的像素点参与计算的次数要多。因此越是边缘的点，对输出的影响就越小，就有可能丢失边缘的信息。Padding,在图片外围补充一些像素点，这些像素点的值初始化为0

  • S2 池化层1

池化窗口：6个2*2

特征图：6个14*14

池化的目的是降低数据的维度，过程很简单就是向下采样，一般有两种生成池化特征的方式，分别为最大值池化，平均值池化

  • C3 卷积层2

卷积核：16个5*5

特征图：16个10*10

训练参数：6 * (5 * 5) * 16+16 =2416

如图所示，C3与S2的连接组合方式并不是固定的，C3的每一张特征图可以连接S2层中的全部或者部分特征图

  • S4 池化层2

池化窗口：16个2*2

特征图：16个5*5

  • C5 全连接层1

神经元结点：120个

训练参数：16 * (5 * 5)*120 +120=48120

每个神经元结点与S4层的16张特征图进行全连接

  • F6 全连接层2

神经元结点：84个

训练参数：120 * 84+84=10164

每个神经元与F5的120神经元全连接

  • OUTPUT 输出层

神经元结点：10个

训练参数：84 * 10+10=850

把输出神经元节点数设为10，代表0~9的分值

每个神经元与F6的84个神经元全连接

  • 1.构建LeNet

import torch
from torch import nn,optim
from torchvision import datasets,transforms
import torch.nn.functional as F
#datasets是加载图像数据的方法,transforms是图像数据预处理的方法

#定义数据预处理的方法
transform=transforms.Compose([
    transforms.ToTensor(),
    #将数据转化为Tensor对象
    transforms.Normalize((0.1307,),(0.3081,))
    #将数据进行归一化处理
])

#使用datasets.MNIST()函数分别下载训练数据集和测试数据集
trainset=datasets.MNIST('data',train=True,download=True,transform=transform)
testset=datasets.MNIST('data',train=False,download=True,transform=transform)
#第一个参数表示数据集下载并存储的目标文件夹，第二个参数True表示加载训练数据集，False表示加载测试数据集
#第三个参数表示自动下载，第四个参数表示使用刚才定义的数据预处理的方法

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet,self).__init__()
        #c1,c3定义卷积层,nn.Conv2d()函数为我们简化了卷积层的搭建
        #第一个参数表示输入一张灰度图，第二个参数表示输出六张特征图
        #第三个参数(5,5)可以简化成5，表示大小为5*5的卷积核过滤器
        self.c1=nn.Conv2d(1,6,(5,5))
        self.c3=nn.Conv2d(6,16,5)
        #fc1,fc2,fc3定义连接层
        #输入特征为16*4*4，输出为120
        self.fc1=nn.Linear(16*4*4,120)
        self.fc2=nn.Linear(120,84)
        self.fc3=nn.Linear(84,10)

    def forward(self,x):
        x=F.max_pool2d(F.relu(self.c1(x)),2)
        #对c1特征图进行池化，池化核大小2*2，可以简化参数为2
        #c1卷积之后，使用relu()函数增加网络的非线性拟合能力
        x=F.max_pool2d(F.relu(self.c3(x)),2)
        x=x.view(-1,self.num_flat_features(x))
        #view函数将x的形状转化成1维的向量
        #在函数的参数中经常可以看到 - 1
        #例如x.view(-1, 4)这里 - 1,表示一个不确定的数，就是你如果不确定你想要reshape成几行，但是你很肯定要reshape成4列，那不确定的地方就可以写成 - 1例如一个长度的16向量x，
        #x.view(-1, 4)等价于x.view(4, 4)
        x=F.relu(self.fc1(x))
        #增加全连接后的非线性拟合能力
        x=F.relu(self.fc2(x))
        ##输出结果一般不使用relu激活
        x=self.fc3(x)
        return x

    # 自定义num_flat_features()用于计算特征点的总数
    #假设批量输入4张图片，信息为[4,16,4,4],表示经过view函数之前的是x是4维的，转化成特征图16张，每张4*4
    #因此计算特征点总数只需要后面的三维度size=x.size()[1:],即[16,4,4],16*4*4=256
    def num_flat_features(self, x):
        size = x.size()[1:]
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

CUDA=torch.cuda.is_available()
if CUDA:
    lenet=LeNet().cuda()
else:
    lenet=LeNet()

criterion=nn.CrossEntropyLoss()
#momentum=0.9,动量0.9抱歉，目前不晓得干啥用的
optimizer=optim.SGD(lenet.parameters(),lr=0.001,momentum=0.9)

#随后使用PyTorch的数据加载工具DataLoad来加载训练数据
trainloader=torch.utils.data.DataLoader(trainset,batch_size=4,shuffle=True,num_workers=0)
#其中batch_size表示一次性加载的数据量，shuffle=True遍历不同批次的数据时打乱顺序，num_workers=0表示使用0个子进程加载数据(2为报错点)

#下面开始训练LeNet，完全遍历训练数据2次
def train(model,criterion,optimizer,epochs=1):
    for epoch in range(epochs):
        running_loss=0.0
        for i,data in enumerate(trainloader,0):
            #enumerate表示从第0项开始枚举对trainloader中的数据进行枚举，返回i是序号，data是我们需要的数据
            inputs,labels=data
            if CUDA:
                inputs,labels=inputs.cuda(),labels.cuda()

            optimizer.zero_grad()
            outputs=model(inputs)
            loss=criterion(outputs,labels)
            loss.backward()
            optimizer.step()

            running_loss+=loss.item()
            #对输入每一个训练数据后的loss值进行累加，每训练1000次打印一次loss的均值
            if i%1000==999:
                print('[Epoch:%d,Batch:%5d] loss:%.3f' % (epoch+1,i+1,running_loss/1000))
                running_loss=0.0
    print('Finished Training')

train(lenet,criterion,optimizer,epochs=2)

  • 2.训练

[Epoch:1,Batch: 1000] loss:1.301
[Epoch:1,Batch: 2000] loss:0.340
[Epoch:1,Batch: 3000] loss:0.214
[Epoch:1,Batch: 4000] loss:0.166
[Epoch:1,Batch: 5000] loss:0.151
[Epoch:1,Batch: 6000] loss:0.132
[Epoch:1,Batch: 7000] loss:0.129
[Epoch:1,Batch: 8000] loss:0.108
[Epoch:1,Batch: 9000] loss:0.112
[Epoch:1,Batch:10000] loss:0.111
[Epoch:1,Batch:11000] loss:0.084
[Epoch:1,Batch:12000] loss:0.086
[Epoch:1,Batch:13000] loss:0.085
[Epoch:1,Batch:14000] loss:0.085
[Epoch:1,Batch:15000] loss:0.075
[Epoch:2,Batch: 1000] loss:0.061
[Epoch:2,Batch: 2000] loss:0.049
[Epoch:2,Batch: 3000] loss:0.072
[Epoch:2,Batch: 4000] loss:0.066
[Epoch:2,Batch: 5000] loss:0.070
[Epoch:2,Batch: 6000] loss:0.066
[Epoch:2,Batch: 7000] loss:0.072
[Epoch:2,Batch: 8000] loss:0.057
[Epoch:2,Batch: 9000] loss:0.061
[Epoch:2,Batch:10000] loss:0.050
[Epoch:2,Batch:11000] loss:0.059
[Epoch:2,Batch:12000] loss:0.059
[Epoch:2,Batch:13000] loss:0.044
[Epoch:2,Batch:14000] loss:0.059
[Epoch:2,Batch:15000] loss:0.056
Finished Training

从结果可以看出，我们的训练是有效的，损失值loss的平均值从1.301逐渐优化下降到0.056

  • 3.存储与加载

训练完神经网络之后，需要存储训练好的参数，以方便以后使用。
存储方式有两种，第一种是：存储与加载模型。第二种是：存储和加载模型参数。

方法一：

//存储
torch.save(lenet,'model.pkl')
//加载
lenet=torch.load('model.pkl')

方法二：(更推荐)

//存储
torch.save(lenet.state_dict(),'model.pkl')
//加载
lenet.load_state_dict(torch.load('model.pkl'))

利用os包的exists()方法检查是否存在模型参数文件。构造load_param()和save_param()方便随时调用

def load_param(model,path):
    if os.path.exists(path):
        model.load_state_dict(torch.load(path))
def save_param(model,path):
    torch.save(model.state_dict(),path)

  • 4.测试

神经网络模型经过长时间的训练之后，能在训练集的数据上表现得很好，但是不一定在测试集上表现得很好，为此，设置train=False准备测试集，并设置testloader对测试集进行加载

testset=datasets.MNIST('data',train=False,download=True,transform=transform)

下面对训练完成的神经网络添加测试模块

def test(testloader,model):
    corret=0
    total=0
    for data in testloader:
        images,labels=data
        if CUDA:
            images=images.cuda()
            labels=labels.cuda()
        outputs=model(images)
        #找出每一组10个输出值中最大的那个值,0是每列的最大值，1是每行的最大值,并将该值所在的序号保存在predicted中
        _,predicted=torch.max(outputs.data,1)
        #total用于累计labels的总数
        total+=labels.size(0)
        #corret用于累计正确的结果
        corret+=(predicted==labels).sum()
    print('Accuracy on the test set: %d %%' %(100*corret/total))

  • 5.测试结果

Finished Training
Accuracy on the test set: 98 %

  • 6.完整程序

import torch
import os
from torch import nn,optim
from torchvision import datasets,transforms
import torch.nn.functional as F
#datasets是加载图像数据的方法,transforms是图像数据预处理的方法

#定义数据预处理的方法
transform=transforms.Compose([
    transforms.ToTensor(),
    #将数据转化为Tensor对象
    transforms.Normalize((0.1307,),(0.3081,))
    #将数据进行归一化处理
])

#使用datasets.MNIST()函数分别下载训练数据集和测试数据集
trainset=datasets.MNIST('data',train=True,download=True,transform=transform)
testset=datasets.MNIST('data',train=False,download=True,transform=transform)
#第一个参数表示数据集下载并存储的目标文件夹，第二个参数True表示加载训练数据集，False表示加载测试数据集
#第三个参数表示自动下载，第四个参数表示使用刚才定义的数据预处理的方法

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet,self).__init__()
        #c1,c3定义卷积层,nn.Conv2d()函数为我们简化了卷积层的搭建
        #第一个参数表示输入一张灰度图，第二个参数表示输出六张特征图
        #第三个参数(5,5)可以简化成5，表示大小为5*5的卷积核过滤器
        self.c1=nn.Conv2d(1,6,(5,5))
        self.c3=nn.Conv2d(6,16,5)
        #fc1,fc2,fc3定义连接层
        #输入特征为16*4*4，输出为120
        self.fc1=nn.Linear(16*4*4,120)
        self.fc2=nn.Linear(120,84)
        self.fc3=nn.Linear(84,10)

    def forward(self,x):
        x=F.max_pool2d(F.relu(self.c1(x)),2)
        #对c1特征图进行池化，池化核大小2*2，可以简化参数为2
        #c1卷积之后，使用relu()函数增加网络的非线性拟合能力
        x=F.max_pool2d(F.relu(self.c3(x)),2)
        x=x.view(-1,self.num_flat_features(x))
        #view函数将x的形状转化成1维的向量
        #在函数的参数中经常可以看到 - 1
        #例如x.view(-1, 4)这里 - 1,表示一个不确定的数，就是你如果不确定你想要reshape成几行，但是你很肯定要reshape成4列，那不确定的地方就可以写成 - 1例如一个长度的16向量x，
        #x.view(-1, 4)等价于x.view(4, 4)
        x=F.relu(self.fc1(x))
        #增加全连接后的非线性拟合能力
        x=F.relu(self.fc2(x))
        ##输出结果一般不使用relu激活
        x=self.fc3(x)
        return x

    # 自定义num_flat_features()用于计算特征点的总数
    #假设批量输入4张图片，信息为[4,16,4,4],表示经过view函数之前的是x是4维的，转化成特征图16张，每张4*4
    #因此计算特征点总数只需要后面的三维度size=x.size()[1:],即[16,4,4],16*4*4=256
    def num_flat_features(self, x):
        size = x.size()[1:]
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

CUDA=torch.cuda.is_available()
if CUDA:
    lenet=LeNet().cuda()
else:
    lenet=LeNet()

criterion=nn.CrossEntropyLoss()
#momentum=0.9,动量0.9抱歉，目前不晓得干啥用的
optimizer=optim.SGD(lenet.parameters(),lr=0.001,momentum=0.9)

#随后使用PyTorch的数据加载工具DataLoad来加载训练数据
trainloader=torch.utils.data.DataLoader(trainset,batch_size=4,shuffle=True,num_workers=0)
#其中batch_size表示一次性加载的数据量，shuffle=True遍历不同批次的数据时打乱顺序，num_workers=0表示使用0个子进程加载数据(2为报错点)

testloader=torch.utils.data.DataLoader(testset,batch_size=4,shuffle=False)

#下面开始训练LeNet，完全遍历训练数据2次
def train(model,criterion,optimizer,epochs=1):
    for epoch in range(epochs):
        running_loss=0.0
        for i,data in enumerate(trainloader,0):
            #enumerate表示从第0项开始枚举对trainloader中的数据进行枚举，返回i是序号，data是我们需要的数据
            inputs,labels=data
            if CUDA:
                inputs,labels=inputs.cuda(),labels.cuda()

            optimizer.zero_grad()
            outputs=model(inputs)
            loss=criterion(outputs,labels)
            loss.backward()
            optimizer.step()

            running_loss+=loss.item()
            #对输入每一个训练数据后的loss值进行累加，每训练1000次打印一次loss的均值
            if i%1000==999:
                print('[Epoch:%d,Batch:%5d] loss:%.3f' % (epoch+1,i+1,running_loss/1000))
                running_loss=0.0
    print('Finished Training')

#存储与加载
def load_param(model,path):
    if os.path.exists(path):
        model.load_state_dict(torch.load(path))
def save_param(model,path):
    torch.save(model.state_dict(),path)


#下面对训练完成的神经网络添加测试模块
def test(testloader,model):
    corret=0
    total=0
    for data in testloader:
        images,labels=data
        if CUDA:
            images=images.cuda()
            labels=labels.cuda()
        outputs=model(images)
        #找出每一组10个输出值中最大的那个值,0是每列的最大值，1是每行的最大值,并将该值所在的序号保存在predicted中
        _,predicted=torch.max(outputs.data,1)
        #total用于累计labels的总数
        total+=labels.size(0)
        #corret用于累计正确的结果
        corret+=(predicted==labels).sum()
    print('Accuracy on the test set: %d %%' %(100*corret/total))

load_param(lenet,'model.pkl')
train(lenet,criterion,optimizer,epochs=2)
save_param(lenet,'model.pkl')
test(testloader,lenet)
Tsukinousag1
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LeNet：开山之作，手写数字识别的先驱
AI大模型应用之禅
05-22 641
1. 背景介绍 1.1 手写数字识别的重要性 手写数字识别是计算机视觉领域的一个经典问题，其目标是将手写数字图像自动识别为对应的数字。这项技术在许多领域都有着广泛的应用，例如： 邮政编码识别: 自动识别信封上的邮政编码，提高邮件分拣效率
卷积池化与LeNet5网络模型
空字符
11-11 1494
1 前言 经过前面三篇文章的介绍，我们已经知道了卷积的原理、卷积的计算过程以及池化的原理和过程等。在接下来的这篇文章中，笔者将开始介绍如何通过Pytorch这一深度学习框架来实现卷积和池化的操作，以及各个API的使用介绍和说明。最后，笔者还会介绍卷积神经网络的入门级网络结构LeNet5，我们也将会通过LeNet5这个网络来完成fashion mnist数据集的分类任务。 2 API接口介绍 在Pytorch中，对于网络中的一些基本功能函数（例如：卷积、池化、激活函数等）都被放在了torch.nn.funct
LeNet 神经网络
晓野豬
06-07 1822
  LeNet 原是 LeNet1 - LeNet5 这系列网络的合称，但现在所说的 LeNet 则一般特指 LeNet5 (后文统一称为 LeNet)。LeNet 是 Yann LeCun 教授于 1998 年在论文《Gradient-Based Learning Applied to Document Recognition》中提出的 ，设计之初只是用于手写数字的识别，到如今已成为卷积神经网络的 HelloWorld。受限于计算机的算力不足，加之支持向量机 (核学习方法) 的兴起，CNN 方法并未成为当
CNN——LeNet
weixin_64924692的博客
01-03 980
LeNet是Yann LeCun于1988年提出的用于手写体数字识别的网络结构，它是最早发布的卷积神经网络之一，可以说LeNet是深度CNN网络的基石。当时，LeNet取得了与支持向量机（support vector machines）性能相媲美的成果，成为监督学习的主流方法。LeNet当时被广泛用于自动取款机（ATM）机中，帮助识别处理支票的数字。下面是整个网络的结构图LeNet共有8层，其中包括输入层，3个卷积层，2个子采样层（也就是现在的池化层），1个全连接层和1个高斯连接层。。
通过PyTorch构建的LeNet-5网络对手写数字进行训练和识别
网络资源是无限的
06-25 2183
通过PyTorch构建的LeNet-5网络对手写数字进行训练和识别
LeNet详解
热门推荐
1
08-06 9万+
       LeNet-5是一个较简单的卷积神经网络。下图显示了其结构：输入的二维图像，先经过两次卷积层到池化层，再经过全连接层，最后使用softmax分类作为输出层。关于CNN参见：https://blog.csdn.net/qq_42570457/article/details/81458077        LeNet-5 这个网络虽然很小，但是它包含了深度学习的基本模块：卷积层，池...
LeNet代码详解
m0_53955985的博客
11-15 107
对LeNet代码实现详细讲解
LeNet模型
m0_51797359的博客
08-08 1563
LeNet模型讲解
pytorch实现Lenet
anxinbuxinan的博客
08-31 175
LeNet是一种经典的卷积神经网络（Convolutional Neural Network，CNN），也被称为LeNet-5。它由Yann LeCun等人在1998年提出，是用于手写数字识别任务的早期深度学习模型。LeNet网络结构相对简单，主要由卷积层、池化层和全连接层组成。它的主要特点是通过多层卷积和池化操作对输入进行特征提取，并使用全连接层进行分类。LeNet在当时取得了很好的效果，奠定了卷积神经网络在计算机视觉领域的基础。它的设计和思想对之后更复杂的深度学习模型的发展有着重要影响。
CNN与LeNet
Bebr的博客
12-29 2018
目录 前言 目录 相关资料 LeNet论文翻译 2 用于字符识别的卷积神经网络 A 卷积网络 B LeNet-5 LeNet论文解读 神经元模型 从传统神经网络到CNN 连接数和参数个数的计算 特征图连接方式 结束语 相关资料 下面列出的论文都是我学习CNN过程中精读过的论文，也是我认为学习CNN必读的论文，论文的顺序基本上就是CNN结构演化的历史。 LeNet:《G...
LeNet5_LeNet5
09-11
**LeNet5详解** LeNet5是Yann LeCun在1998年提出的一种经典卷积神经网络（Convolutional Neural Network, CNN）架构，主要用于解决手写数字识别问题，尤其是OCR（Optical Character Recognition）应用。在这个项目...
Lenet matlab code
03-01
标题中的“Lenet matlab code”指的是使用MATLAB语言实现的LeNet神经网络模型。LeNet是由Yann LeCun在1998年提出的一种卷积神经网络（Convolutional Neural Network, CNN）架构，主要用于图像识别，尤其是手写数字...
tensorflow lenet5
10-23
本文将深入探讨如何使用TensorFlow实现经典的LeNet-5网络，并结合CIFAR-10数据集进行图像分类任务。 LeNet-5是由Yann LeCun在1998年提出的，是卷积神经网络（CNN）的早期代表作，主要用于手写数字识别。它的结构...
lenet-5模型的手写数字识别
04-17
LeNet-5是由Yann LeCun等人在1998年提出的一种卷积神经网络（Convolutional Neural Network, CNN），它在当时被广泛应用于OCR（Optical Character Recognition）系统，特别是对手写数字的识别。 LeNet-5模型的核心...
认识神经网络【多层感知器数学原理】
逐梦苍穹的博客
07-24 1360
简单认识神经网络，学习多层感知器的数学原理和公式
深度学习1-简介
shangjg3的博客
07-25 1195
通过确定这两张真实图像的潜变量，对它们的值进行插值，然后用这些中间变量生成新图像，我们能创造出既视觉上合理，又融合了两张原始图像特征的中间图像。因此，它面临一个选择，是利用已知的策略（沿地面滑行）还是探索其他可能的行动（可能实现更快的移动）。也许代理已经学会了如何获得适度的奖励，它应该继续遵循这个策略（利用现有知识），还是尝试不同的行动以寻找改进的机会（探索新的可能性）？第三，如果我们在两组潜变量之间的映射或潜变量到图像的映射中引入随机性，那么我们可以生成多个都与描述相匹配的图像（见图 1.12）。
深度学习的矩阵计算
最新发布
weixin_45706801的博客
07-25 438
在NumPy中，切片（slicing）是一种选择数组元素子集的方法。切片操作基于索引，但允许你指定一个范围的索引，而不是单个索引。这对于处理多维数组（NumPy中的ndarray对象）特别有用。
lenet pytorch
10-17
LeNet是一个经典的卷积神经网络模型，由Yann LeCun等人在1998年提出，用于手写数字识别任务。在PyTorch中，可以通过构建一个继承自`nn.Module`的LeNet类来实现LeNet模型。以下是一个简单的LeNet实现示例： ```...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值