精华内容
下载资源
问答
  • pytorch实现lenet5

    2020-08-14 17:10:10
    Pytorch 搭建的LeNet-5网络,使用Minist数据集,测试集准确率接近98.4%。文件内包含代码、Minist数据集和训练好的模型参数。
  • LeNet5_LeNet5

    2021-09-11 04:56:41
    自己搭建了LeNet5网络结构,可以用于练习实现数字手写体识别或者小规模数据集的图片分类
  • 手写体识别 lenet5 LeNet5由7层CNN(不包含输入层)组成,上图中输入的原始图像大小是32×32像素,卷积层用Ci表示,子采样层(pooling,池化)用Si表示,全连接层用Fi表示。下面逐层介绍其作用和示意图上方的数字...
  • 完全实现lenet5全7层,为了更好的理解代码,需要提前了解下面的知识 1, lenet5的7层结构,包括每一层的含义和参数个数,重点是c2到s3层的部分连接原理 2, 了解卷积求导,pool求导,全连接层求导,softmax求导
  • tensorflow lenet5

    2018-10-23 15:20:17
    使用tensorflow实现lenet网络,使用的事cifar10这个数据集。
  • LeNet5神经网络模型在手写数字识别中的识别率很高,通过训练得到0.985精度的参数,可以用于训练更高精度的初始参数。其中卷积核选择表(O:true, X: false): { O, X, X, X, O, O, O, X, X, O, O, O, O, X, O, O,...
  • LeNet5.zip

    2020-07-10 16:12:15
    LeNet5.zip
  • 基于卷积神经网络的图像识别,网络结构为lenet5,在训练集上的正确率可以达到90+,测试集正确率在60-70%。
  • 今天小编就为大家分享一篇pytorch绘制并显示loss曲线和acc曲线,LeNet5识别图像准确率,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 6000张28x28 手写数字图片,lenet的网络实现,个人简单的改进的一个网络,包括训练的模型。
  • cifar10_lenet5.py

    2021-02-19 17:06:38
    在 Tensorflow 框架下利用 tf.Keras来构建 LeNet5 模型
  • LeNet5卷积神经网络–TensorFlow2结果展示loss和acc曲线图参数数量程序 结果展示 acc = 89.36% loss和acc曲线图 参数数量 程序 # -*- coding: utf-8 -*- """ Created on Tue Apr 14 2020 @author: jiollos """ # ...
  • lenet5卷积神经网络实现MNIST手写数字识别。代码分为前向传播、反向传播、模型测试三个部分,有详细的注释
  • 基于python2.7的LeNet5源代码实现,效果很不错。
  • LeNet5

    2020-08-23 20:49:07
    class LeNet5(nn.Module): def __init__(self): super(LeNet5,self).__init__() self.conv1 = nn.Sequential( nn.Conv2d(1,6,5,1,2) , nn.ReLU() , nn.MaxPool2d(2,2) ) self.conv2 = nn.Sequential( nn.Conv2d...
    import  torch.nn as nn
    
    class LeNet5(nn.Module):
        def __init__(self):
            super(LeNet5,self).__init__()
    
            self.conv1 = nn.Sequential( nn.Conv2d(1,6,5,1,2)   , nn.ReLU() , nn.MaxPool2d(2,2)   )
            self.conv2 = nn.Sequential( nn.Conv2d(6,16,5)      , nn.ReLU() , nn.MaxPool2d(2,2)   )
            self.fc1   = nn.Sequential( nn.Linear(16*5*5,120)  , nn.ReLU()                       )
            self.fc2   = nn.Sequential( nn.Linear(120,84)      , nn.ReLU()                       )
            self.fc3   = nn.Linear(84,10)
    
        def forward(self,pic):
            pic = self.conv1(pic)
            pic = self.conv2(pic)
            pic = pic.view(pic.size()[0],-1)
            pic = self.fc1(pic)
            pic = self.fc2(pic)
            pic = self.fc3(pic)
    
            return  pic

     

    展开全文
  • 基于Python+Theano实现的逻辑回归Lenet5源代码,内附有详细注释,让新手尽可能了解每一个函数及变量的作用。这个源代码还需要mlp.py,可以从我的资源中免费下载到:...
  • keras-lenet5-mnist.py

    2019-11-27 20:25:30
    文件为py文件,用pycharm打开即可,使用lenet-5训练三次即可达到0.98识别率,非常简单,适合新手入门。。。。。。。
  • matlab精度检验代码LeNet-5从零开始并使用tensorflow 该存储库包含Matlab从头开始使用Lenet-5的代码,也使用tensorflow。 这是我的课程CS698U中的一项作业。 作业的问题陈述 实施和培训LeNet-5 CNN以进行MNIST数字...
  • 根据YANN LECUN的论文《Gradient-based Learning Applied To Document Recognition》设计的LeNet-5神经网络,C语言写成,不依赖任何第三方库。 MNIST手写字符集初代训练识别率97%,多代训练识别率98%。搬运至GitHub...
  • LeNet-5 这实现了略微修改的LeNet-5 [LeCun et al。,1998a],并在上达到了约99%的准确度。 设置 使用以下命令安装所有依赖项 $ pip install -r requirements.txt 用法 启动visdom服务器进行可视化 $ python -m ...
  • Pytorch搭建LeNet5

    2021-08-06 14:47:16
    Pytorch搭建LeNet5 1. LeNet神经网络介绍 LeNet神经网络由深度学习三巨头之一的Yan LeCun提出,他同时也是卷积神经网络 (CNN,Convolutional Neural Networks)之父。LeNet主要用来进行手写字符的识别与分类,并在...

    Pytorch搭建LeNet5

    1. LeNet神经网络介绍

    LeNet神经网络由深度学习三巨头之一的Yan LeCun提出,他同时也是卷积神经网络 (CNN,Convolutional Neural Networks)之父。LeNet主要用来进行手写字符的识别与分类。LeNet的实现确立了CNN的结构,现在神经网络中的许多内容在LeNet的网络结构中都能看到,例如卷积层,Pooling层,ReLU层。虽然LeNet早在20世纪90年代就已经提出了,但由于当时缺乏大规模的训练数据,计算机硬件的性能也较低,因此LeNet神经网络在处理复杂问题时效果并不理想。虽然LeNet网络结构比较简单,但是刚好适合神经网络的入门学习。

    2. LeNet神经网络结构
    在这里插入图片描述

    • 卷积层块里的基本单位是卷积层后接最大池化层:卷积层用来识别图像里的空间模式,如线条和物体局部,之后的最大池化层则用来降低卷积层对位置的敏感性。

    • 卷积层块由两个这样的基本单位重复堆叠构成。在卷积层块中,每个卷积层都使用5×5的窗口,并在输出上使用ReLU激活函数。

    • 第一个卷积层输出通道数为6,第二个卷积层输出通道数则增加到16。这是因为第二个卷积层比第一个卷积层的输入的高和宽要小,所以增加输出通道使两个卷积层的参数尺寸类似。

    • 卷积层块的两个最大池化层的窗口形状均为2×2,且步幅为2。由于池化窗口与步幅形状相同,池化窗口在输入上每次滑动所覆盖的区域互不重叠。

    • 卷积层块的输出形状为(批量大小, 通道, 高, 宽)

    in_put = torch.rand(1, 1, 32, 32)       # 随机构建一张一个通道的32*32的输入图片
    
    • 当卷积层块的输出传入全连接层块时,全连接层块会将小批量中每个样本变平(flatten)
    - output = output.view(img.size(0), -1)
    
    • 也就是说,全连接层的输入形状将变成二维,其中第一维是小批量中的样本,第二维是每个样本变平后的向量表示,且向量长度为通道、高和宽的乘积。

    • 全连接层块含3个全连接层。它们的输出个数分别是120、84和10,其中10为输出的类别个数。

    3. Pytorch搭建LeNet5

    import torch.nn as nn
    from collections import OrderedDict
    import torch
    
    
    # 利用torch.nn.Sequential和collections.OrderedDict()来构建每一个layer
    class C1(nn.Module):
        def __init__(self):
            super(C1, self).__init__()
    
            self.c1 = nn.Sequential(OrderedDict([    # 1代表输入通道数,6代表输出通道数,5代表卷积核的大小5x5,默认stride=1
                ('c1', nn.Conv2d(1, 6, 5)),     # 6@28×28
                ('relu1', nn.ReLU()),           
                ('s2', nn.MaxPool2d(2, 2))      # 6@14x14,通道数不变,超参数2分别表示池化大小和步长
            ]))
    
        def forward(self, img):
            output = self.c1(img)               # 输入是1x32x32
            return output
    
    
    class C3(nn.Module):
        def __init__(self):
            super(C3, self).__init__()
    
            self.c3 = nn.Sequential(OrderedDict([
                ('c3', nn.Conv2d(6, 16, 5)),    # 16@10×10
                ('relu2', nn.ReLU()),
                ('s4', nn.MaxPool2d(2, 2))      # 16@5×5
            ]))
    
        def forward(self, img):
            output = self.c3(img)
            return output
    
    
    class C5(nn.Module):
        def __init__(self):
            super(C5, self).__init__()
    
            self.c5 = nn.Sequential(OrderedDict([
                ('c5', nn.Conv2d(16, 120, 5)),  # 120@1x1
                ('relu3', nn.ReLU())
            ]))
    
        def forward(self, img):
            output = self.c5(img)
            return output
    
    
    class F6(nn.Module):
        def __init__(self):
            super(F6, self).__init__()
    
            self.f6 = nn.Sequential(OrderedDict([
                ('f4', nn.Linear(120, 84)),
                ('relu4', nn.ReLU())
            ]))
    
        def forward(self, img):
            output = self.f6(img)
            return output
    
    
    class F7(nn.Module):
        def __init__(self):
            super(F7, self).__init__()
    
            self.f7 = nn.Sequential(OrderedDict([
                ('f7', nn.Linear(84, 10)),
                ('sig8', nn.LogSoftmax(dim=-1))
            ]))
    
        def forward(self, img):
            output = self.f7(img)
            return output
    
    
    class LeNet5(nn.Module):
        """
        Input - 1x32x32
        Output - 10
        """
        def __init__(self):
            super(LeNet5, self).__init__()
    
            self.c1 = C1()
            self.c3_1 = C3()
            self.c3_2 = C3()
            self.c5 = C5()
            self.f6 = F6()
            self.f7 = F7()
    
        def forward(self, img):
            output = self.c1(img)
    
            x = self.c3_1(output)
            output = self.c3_2(output)
    
            output += x
    
            output = self.c5(output)
            output = output.view(img.size(0), -1)       # 将卷积层的输出摊平为120维向量
            output = self.f6(output)                    # 全连接层将120维变为84维
            output = self.f7(output)                    # 全连接层将84维变为10维,用于预测输出的结果
            return output
    
    
    if __name__ == '__main__':
    
        model = LeNet5()                        # 网络实例化
        print(model)
        in_put = torch.rand(1, 1, 32, 32)       # 随机构建一张一个通道的32*32的输入图片
        out = model(in_put)
        print(out)                              # 哪一维的数字最大,输入就属于那一类别
    
    
    LeNet5(
      (c1): C1(
        (c1): Sequential(
          (c1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
          (relu1): ReLU()
          (s2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
        )
      )
      (c3_1): C3(
        (c3): Sequential(
          (c3): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
          (relu2): ReLU()
          (s4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
        )
      )
      (c3_2): C3(
        (c3): Sequential(
          (c3): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
          (relu2): ReLU()
          (s4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
        )
      )
      (c5): C5(
        (c5): Sequential(
          (c5): Conv2d(16, 120, kernel_size=(5, 5), stride=(1, 1))
          (relu3): ReLU()
        )
      )
      (f6): F6(
        (f6): Sequential(
          (f4): Linear(in_features=120, out_features=84, bias=True)
          (relu4): ReLU()
        )
      )
      (f7): F7(
        (f7): Sequential(
          (f7): Linear(in_features=84, out_features=10, bias=True)
          (sig8): LogSoftmax()
        )
      )
    )
    tensor([[-2.2676, -2.2554, -2.3434, -2.3523, -2.4532, -2.2200, -2.1823, -2.3595,
             -2.3212, -2.2984]], grad_fn=<LogSoftmaxBackward>)
    
    Process finished with exit code 0
    
    

    参考
    https://www.jianshu.com/p/cd73bc979ba9
    https://tangshusen.me/Dive-into-DL-PyTorch/#/chapter05_CNN/5.5_lenet

    展开全文
  • 最后,笔者还会介绍卷积神经网络的入门级网络结构LeNet5,我们也将会通过LeNet5这个网络来完成fashion mnist数据集的分类任务。 2 API接口介绍 在Pytorch中,对于网络中的一些基本功能函数(例如:卷积、池化、激活...

    1 前言

    经过前面三篇文章的介绍,我们已经知道了卷积的原理卷积的计算过程以及池化的原理和过程等。在接下来的这篇文章中,笔者将开始介绍如何通过Pytorch这一深度学习框架来实现卷积和池化的操作,以及各个API的使用介绍和说明。最后,笔者还会介绍卷积神经网络的入门级网络结构LeNet5,我们也将会通过LeNet5这个网络来完成fashion mnist数据集的分类任务。

    2 API接口介绍

    在Pytorch中,对于网络中的一些基本功能函数(例如:卷积、池化、激活函数等)都被放在了torch.nn.functional这个模块中。因此,为了方便后续的使用,按惯例我们都会以import torch.nn.functional as F的方式来导入各类基本功能函数,然后以F.的方式来进行调用。

    2.1 卷积操作

    在介绍如何使用卷积这一功能函数前,我们先来介绍一下Pytorch中如何表示(类)图像数据。在Pytorch(tensorflow)中,都是通过四个维度来对图像数据进行表示,分别是:样本个数(batch_size)、高度(heigh)、宽度(width)和通道数(channel)。但是对于不同的深度学习框架来说,其在这个维度上的默认顺序并不一样。在Pytorch中,这四个维度的顺序为[batch_size,channels,heigh,width];但是在tensorflow中,这一顺序却为[batch_size,heigh,width,channels]。可以看出,两者仅仅是把通道数这一维度放到了不同的位置上。

    同样的,对于卷积核来说也需要用四个维度来进行表示,分别是:高度(heigh)、宽度(width)、上一层输入的通道数(in_channels)和输出特征图的通道数(卷积核个数)(out_channels)。在Pytorch中,这四个维度的顺序为[out_channels,in_channels,heigh,width];而在tensorflow中,这一顺序却是[heigh,width,in_channels,out_channels]。所以,需要注意的就是在使用不同的深度学习框架时一定要弄清楚输入数据的形式。

    2.1.1 单卷积核卷积

    如图1所示,在上一篇文章中我们以该图中的示例介绍了如何手动的来计算卷积的结果,现在我们看看如何通过框架来进行计算。

    图 1. conv2d的使用

    首先我们需要将卷入和卷积核这两个变量给定义出来:

    inputs = torch.tensor([0, 2, 0, 1, 0, 0, 2, 0, 1, 1, 2, 1, 2, 0, 0, 1, 0, 0, 1, 0, -1, 1, 1, 0, 1,
                           0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0,
                           # [batch_size,in_channels,high,width]
                           1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0]).reshape([1, 3, 5, 5])
    
    
    filters = torch.tensor([[[[2, 0, 0],
                              [1, 0, 1],
                              [0, 3, 0]],
                             [[1, 0, 1],
                              [0, 0, 0],
                              [1, 1, 0]],
                             [[0, 0, 1],
                              [1, 1, 1],
                              [1, 1, 0]]]])  # [1,3,3,3] [ [filter_nums/output_channels,input_channels,high,width]
    
    bias = torch.tensor([1])
    

    可以看到,对于inputs来说我们首先定义了75个值,然后再将其reshape成了图像的表示格式;而对于filters来说,我们在定义的时候就直接写成了框架所需要的形式。

    接下来,我们仅仅只需要通过下面一行代码就能够完成对于卷积的计算过程:

    result = F.conv2d(inputs, filters, bias=bias, stride=1, padding=0)
    

    其中strid=1表示移动一次的步长设为1,padding=0表示不进行填充。

    最后,计算得到的结果为:

    卷积后的结果: tensor([[[[ 7, 18,  6],
              [10, 11, 11],
              [15, 13,  7]]]])
    结果的形状: torch.Size([1, 1, 3, 3])
    

    2.1.2 多卷积核卷积

    如图2所示为多卷积核的计算场景。同上面一样,我们只需要分别定义出输入和卷积核,通过F.conv2d()函数就能计算得到卷积后的结果。

    图 2. conv2d的使用
    filters = torch.tensor([[[[2, 0, 0],
                              [1, 0, 1],
                              [0, 3, 0]],
                             [[1, 0, 1],
                              [0, 0, 0],
                              [1, 1, 0]],
                             [[0, 0, 1],
                              [1, 1, 1],
                              [1, 1, 0]]],
                            [[[0, 1, 0],
                              [1, 1, 1],
                              [0, 1, 0]],
                             [[0, 1, 0],
                              [1, 0, 1],
                              [0, 1, 0]],
                             [[1, 0, 1],
                              [0, 1, 0],
                              [1, 0, 1]]]
                            ])  # [2,3,3,3] [ [filter_nums/output_channels,input_channels,high,width]
    bias = torch.tensor([1, -3])
    result = F.conv2d(inputs, filters, padding=0, bias=bias)
    

    最后得到的计算结果为:

    卷积后的结果: tensor([[[[ 7, 18,  6],
              [10, 11, 11],
              [15, 13,  7]],
    
             [[ 6,  5,  5],
              [ 7,  4,  3],
              [ 3,  6,  1]]]])
    结果的形状: torch.Size([1, 2, 3, 3])
    

    2.2 池化操作

    说完了卷积的操作,我们最后再来简单的看看如何进行池化操作,然后就进入到LeNet5网络的介绍。

    图 3. 最大池化操作

    如图3所示为最大池化的计算原理,在Pytorch中我们在定义好输入的特征图后,通过F.max_pool2d()便可以得到池化后的结果。

    feature_maps = torch.tensor(
        [5, 2, 0, 1, 0, 0, 2, 3, 0, 7, 2, 3, 2,
         2, 1, 1, 6, 4, 8, 1, 2, 7, 1, 5, 9,
         4, 2, 0, 1, 0, 2, 7, 1, 3, 6, 2, 4, 2,
         2, 3, 2, 6, 9, 8, 0, 10, 7, 2, 5, 7],dtype=torch.float32).reshape([1, 2, 5, 5])
    print(feature_maps)
    result = F.max_pool2d(input=feature_maps, kernel_size=[3, 3], stride=[1, 1])
    print(result)
    

    其中,kernel_size=[3,3]stride=[1,1]分别表示池化的窗口大小为 3 × 3 3\times3 3×3以及移动的步长为 1 1 1。当然,这种情况下还可以直接写成kernel_size=3,stride=1

    最后,计算后的结果为:

    tensor([[[[ 5.,  3.,  7.],
              [ 6.,  8.,  8.],
              [ 7.,  8.,  9.]],
    
             [[ 7.,  7.,  6.],
              [ 9.,  9.,  9.],
              [10.,  9.,  9.]]]])
    

    3 LeNet5网络

    3.1 网络结构

    在介绍完卷积操作后,我们再来看如何实现一个简单的LeNet5网络结构。

    图4. LeNet5网络结构图

    如图4所示就是LeNet5的网络结构图,顺便插一句这里的5指的是包含有5个网络权重层(不含参数的层不计算在内)的网络层,即两个卷积层和三个全连接层。根据图4中各层输出的结果,我们可以推算得到其各层对应的超参数及卷积核形状应如下表所示:

    表 1. LeNet5参数表

    网络层输入形状参数输出形状参数量
    卷积层C1[1,32,32]kernel_size=[5,5,1,6]stride=1[6,28,28] 5 × 5 × 1 × 6 = 150 5\times5\times1\times6=150 5×5×1×6=150
    池化层S2[6,28,28]kernel_size=[2,2]stride=2[6,14,14] 0 0 0
    卷积层C3[6,14,14]kernel_size=[5,5,6,16]stride=1[16,10,10] 5 × 5 × 6 × 16 = 2400 5\times5\times6\times16=2400 5×5×6×16=2400
    池化层S4[16,10,10]kernel_size=[2,2]stride=2[16,5,5] 0 0 0
    全连接层C5[1,400]weight_size=[400,120][1,120] 400 × 120 = 48000 400\times120=48000 400×120=48000
    全连接层C6[1,120]weight_size=[120,84][1,84] 120 × 84 = 10080 120\times84=10080 120×84=10080
    输出层[1,84]weight_size=[84,10][1,10] 84 × 10 = 840 84\times10=840 84×10=840

    从表5可以看出每层权重参数的一个具体情况,包括参数的形状和数量。对于整个LeNet5网络来说,其参数量就应该是 150 + 2400 + 48000 + 10080 + 840 = 61470 150+2400+48000+10080+840=61470 150+2400+48000+10080+840=61470

    LeNet5的网络结构总体上来说还比较简单,

    完整内容点击:卷积池化与LeNet5网络模型

    3.2 网络实现

    在介绍完了LeNet5的网络结构后,下面我们就来看看如何通过Pytorch框架对其进行实现。首先需要明白的是,我们在利用框架实现一些网络结构时,我们只需要写出网络对应的前向传播过程即可。剩余其它部分的编码基本上就是按部就班,几乎可以进行通用。

    • 前向传播

      class LeNet5(nn.Module):
          def __init__(self, ):
              super(LeNet5, self).__init__()
              self.conv = nn.Sequential(  # [n,1,28,28]
                  nn.Conv2d(1, 6, 5, padding=2),  # (in_channels, out_channels, kernel_size])
                  nn.ReLU(),  # [n,6,24,24]
                  nn.MaxPool2d(2, 2),  # kernel_size, stride  [n,6,14,14]
                  nn.Conv2d(6, 16, 5),  # [n,16,10,10]
                  nn.ReLU(),
                  nn.MaxPool2d(2, 2)  # [n,16,5,5]
              )
              self.fc = nn.Sequential(
                  nn.Flatten(),
                  nn.Linear(16 * 5 * 5, 120),
                  nn.ReLU(),
                  nn.Linear(120, 84),
                  nn.ReLU(),
                  nn.Linear(84, 10)
              )
      

      如上代码所示就是我们实现的LeNet5网络的前向传播部分,可以看到通过pytorch很容易的就完成了。同时,这里需要说明的是:

      nn.Sequential里面输入的必须是网络层(即要继承自类nn.Module),所以nn.Conv2d(其内部同样是通过F.conv2d来实现的)作为一个网络层其只需要按序传入in_channelsout_channelskernel_size

    完整内容点击:卷积池化与LeNet5网络模型

    • 模型配置

      在定义好前向传播后,我们还可以对整个网络(或者是其中一层)的参数设置情况进行输出:

      if __name__ == '__main__':
          model = LeNet5()
          print(model)
          print(model.fc[3])
      
      #
      LeNet5(
        (conv): Sequential(
          (0): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
          (1): ReLU()
          (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
          (3): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
          (4): PrintLayer()
          (5): ReLU()
          (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
        )
        (fc): Sequential(
          (0): Flatten()
          (1): Linear(in_features=400, out_features=120, bias=True)
          (2): ReLU()
          (3): Linear(in_features=120, out_features=84, bias=True)
          (4): ReLU()
          (5): Linear(in_features=84, out_features=10, bias=True)
        )
      )
      
      Linear(in_features=120, out_features=84, bias=True)
      

      同时,若是需要查看每一层计算后输出的形状,那么只需要将如下定义的打印层出入到nn.Sequential()中的相应位置即可。

      class PrintLayer(nn.Module):
          def __init__(self):
              super(PrintLayer, self).__init__()
      
          def forward(self, x):
              print(x.shape)
              return x
      
    • 训练结果

      对于其它部分的代码在此就不再赘述,可以直接参见源码[2]。

      Epochs[4/5]---batch[937/550]---acc 0.9219---loss 0.2219
      Epochs[4/5]---batch[937/600]---acc 0.9062---loss 0.2414
      Epochs[4/5]---batch[937/650]---acc 0.8438---loss 0.3668
      Epochs[4/5]---batch[937/700]---acc 0.875---loss 0.3722
      Epochs[4/5]---batch[937/750]---acc 0.9062---loss 0.4362
      Epochs[4/5]---batch[937/800]---acc 0.9688---loss 0.1389
      Epochs[4/5]---batch[937/850]---acc 0.9062---loss 0.3012
      Epochs[4/5]---batch[937/900]---acc 0.9062---loss 0.2476
      Epochs[4/5]--acc on test 0.8703
      

      可以看到,大约在5个Epochs后,模型在测试集上的准确率达到了0.87。

    4 总结

    在本篇文章中,笔者首先介绍了在pytorch和tensorflow中是如何来表示图片以及在两个框架中的区别;接着介绍了pytorch中卷积和池化操作两个API的使用方法,示例了如何通过pytorch来完成卷积和池化的计算过程;最后介绍了卷积网络中的LeNet5网络,包括模型的结构、参数量的计算以及如何通过pytorch来实现等。在下一篇的文章中,我们将开始学习卷积网络中的第二个经典模型AlexNet。

    本次内容就到此结束,感谢您的阅读!如果你觉得上述内容对你有所帮助,欢迎关注并传播本公众号!若有任何疑问与建议,请添加笔者微信’nulls8’或文末留言进行交流。青山不改,绿水长流,我们月来客栈见!

    引用

    [1] LeCun, Y., Bottou, L., Bengio, Y., & Haffner, P. (1998). Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11), 2278-2324.

    [2]https://github.com/moon-hotel/DeepLearningWithMe

    推荐阅读

    展开全文
  • 实现了的Lenet经典的卷积神经网络,只要修改相应的读取数据的绝对路径即可运行
  • python_caffe_lenet5

    2016-10-28 14:30:10
    基于caffe的lenet5 python实现,从零开始了解lenet5网络和caffe框架,搭配flask可以轻松搭建、实现一个自己的手写数字识别系统。
  • LeNet5-MNIST-示例 它包含一个 iPython Notebook,可在 MNIST 数据集上训练和测试 LeNet5 卷积神经网络。 依赖关系 Python 2.7 , numpy/scipy , Theano 该代码已从其原始形式改编,以允许参数调整。 根据给定的参数...
  • lenet5手写字体识别

    2015-10-23 11:25:05
    LeNet5对应的手写字体识别,无监督学习的方法去pre-training(预训练)stacked CNN的每层网络,然后用BP算法对整个网络进行fine-tuning(微调),并且上一层的输出作为下一层的输入。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,811
精华内容 9,924
关键字:

lenet5

友情链接: DataBase 5.0.zip