精华内容
下载资源
问答
  • 查看模型参数(以AlexNet为例) import torch import torch.nn as nn import torchvision class AlexNet(nn.Module): def __init__(self,num_classes=1000): super(AlexNet,self).__init__() self.feature...

    查看模型参数(以AlexNet为例)

    import torch
    import torch.nn as nn
    import torchvision
    
    class AlexNet(nn.Module):
        def __init__(self,num_classes=1000):
            super(AlexNet,self).__init__()
            self.feature_extraction = nn.Sequential(
                nn.Conv2d(in_channels=3,out_channels=96,kernel_size=11,stride=4,padding=2,bias=False),
                nn.ReLU(inplace=True),
                nn.MaxPool2d(kernel_size=3,stride=2,padding=0),
                nn.Conv2d(in_channels=96,out_channels=192,kernel_size=5,stride=1,padding=2,bias=False),
                nn.ReLU(inplace=True),
                nn.MaxPool2d(kernel_size=3,stride=2,padding=0),
                nn.Conv2d(in_channels=192,out_channels=384,kernel_size=3,stride=1,padding=1,bias=False),
                nn.ReLU(inplace=True),
                nn.Conv2d(in_channels=384,out_channels=256,kernel_size=3,stride=1,padding=1,bias=False),
                nn.ReLU(inplace=True),
                nn.Conv2d(in_channels=256,out_channels=256,kernel_size=3,stride=1,padding=1,bias=False),
                nn.ReLU(inplace=True),
                nn.MaxPool2d(kernel_size=3, stride=2, padding=0),
            )
            self.classifier = nn.Sequential(
                nn.Dropout(p=0.5),
                nn.Linear(in_features=256*6*6,out_features=4096),
                nn.ReLU(inplace=True),
                nn.Dropout(p=0.5),
                nn.Linear(in_features=4096, out_features=4096),
                nn.ReLU(inplace=True),
                nn.Linear(in_features=4096, out_features=num_classes),
            )
        def forward(self,x):
            x = self.feature_extraction(x)
            x = x.view(x.size(0),256*6*6)
            x = self.classifier(x)
            return x
    
    
    if __name__ =='__main__':
        # model = torchvision.models.AlexNet()
        model = AlexNet()
        
        # 打印模型参数
        #for param in model.parameters():
            #print(param)
        
        #打印模型名称与shape
        for name,parameters in model.named_parameters():
            print(name,':',parameters.size())
    
    
    feature_extraction.0.weight : torch.Size([96, 3, 11, 11])
    feature_extraction.3.weight : torch.Size([192, 96, 5, 5])
    feature_extraction.6.weight : torch.Size([384, 192, 3, 3])
    feature_extraction.8.weight : torch.Size([256, 384, 3, 3])
    feature_extraction.10.weight : torch.Size([256, 256, 3, 3])
    classifier.1.weight : torch.Size([4096, 9216])
    classifier.1.bias : torch.Size([4096])
    classifier.4.weight : torch.Size([4096, 4096])
    classifier.4.bias : torch.Size([4096])
    classifier.6.weight : torch.Size([1000, 4096])
    classifier.6.bias : torch.Size([1000])
    

    计算参数量与可训练参数量

    def get_parameter_number(model):
        total_num = sum(p.numel() for p in model.parameters())
        trainable_num = sum(p.numel() for p in model.parameters() if p.requires_grad)
        return {'Total': total_num, 'Trainable': trainable_num}
    

    第三方工具

    from torchstat import stat
    import torchvision.models as models
    model = models.alexnet()
    stat(model, (3, 224, 224))
    

    在这里插入图片描述

    from torchvision.models import alexnet
    import torch
    from thop import profile
    model = alexnet()
    input = torch.randn(1, 3, 224, 224)
    flops, params = profile(model, inputs=(input, ))
    print(flops, params)
    

    在这里插入图片描述

    展开全文
  • 参考这两文章的部分笔记和理解:...id=0DRtwE6Ehttp://blog.csdn.net/dcxhun3/article/details/46878999输入input: 32 x 32 的图像使用: 6 5x5 stride为 1的卷积核神经元 个数: (32-5+1) * (32 ...

    参考这个文章的部分笔记和理解:
    http://blog.csdn.net/dcxhun3/article/details/46878999

    输入input: 32 x 32 的图像
    使用:    6个 5x5  stride为 1的卷积核

    神经元 个数: (32-5+1) * (32 -5 +1) = 28 * 28 个。也就是每一个feature map的大小就是28 * 28 。  
    其中,32-5是卷积核可以滑过并得到一次计算结果的次数(因为步幅是1),+1是卷积核放在最开始的位置上还没开始滑动时的一次计算结果。
    那么这一层一共有 (5*5 +1)*6个可训练参数,其中5*5为卷积核的大小,1为一个bias参数, 6为6种卷积核。
    注意如果是三通道,三个通道的权重并不共享。 所以对于以上的计算,三通道的参数数量应该还要乘以3。

    个人总结的 feature map 和 神经元的关系 及其他概念的关系 :

    feature map 和 神经元的关系:
    单个卷积核情况下:
     神经元是 前一层wx+b 到下一层的计算过程,所谓这一层的连接数,也就是有多少个 wx+b的连接(一个卷积核有多个w只有一个bias)
     一个feature map 是多个(比如M个)神经元计算的结果汇总
    多个卷积核情况下:
    同一层可以有多个(比如N个)卷积核,每个卷积核对应(卷积的结果是)一个feature map ,也就是这一层有N个feature map, 那这一层共有 N*M个神经元。(如果每个fm的神经元个数不一样,则累加每个fm的神经元个数)

    可训练参数个数, 与神经元的个数无关,只与卷积核的大小及卷积核的个数相关,还有通道数
    神经元个数,       除了卷积核大小和个数,还与步幅相关。步幅越大,神经元个数越小

    feature map的每个点都是一个神经元的输出。所以 神经元个数 = 特征图大小
    连接个数= sigma(单个卷积核参数个数*神经元个数)  (单个卷积核会用同样的卷积核参数,每多滑动一下,多生成参数个连接)

    CNN权值共享就是同一个Feature Map中神经元权值共享,该Feature Map中的所有神经元使用同一个权值。这与全连接相比,参数减少太多了(整个图像的矩阵大小到卷积核的矩阵大小)

    展开全文
  • LSTM参数个数计算

    万次阅读 多人点赞 2018-09-21 16:53:35
    今天看程序看到了LSTM,原理都懂,但是想看看参数的个数是怎么...LSTM这一层的参数个数是 1255424 个,这一看还有整有零的,好奇怎么算出来的,于是百度搜了下,得到这么一个公式: 设 LSTM 输入维度为 x_dim, 输...

    今天看程序看到了LSTM,原理都懂,但是想看看参数的个数是怎么算出来的,先简单介绍下我的网络前两层:

    (1)第一层是一个 embedding 层,输出是 100 维的。

    (2)第二层是一个 LSTM 层,输出是 512 维的。

    LSTM这一层的参数个数是 1255424 个,这一看还有整有零的,好奇怎么算出来的,于是百度搜了下,得到这么一个公式:

    设 LSTM 输入维度为 x_dim, 输出维度为 y_dim,那么参数个数 n 为:

    n = 4 * ((x_dim + y_dim) * y_dim + y_dim)

    对应我的网络结构就是:n = 4 * ((100 + 512) * 512 + 512) = 1255424

     

    LSTM 的原理以及公式的又来可以参考这个链接https://www.cnblogs.com/wushaogui/p/9176617.html

    展开全文
  • C1层LeNet5-S2层LeNet5-C3层LeNet5-S4层LeNet5-C5层LeNet5-F6层LeNet5-OUTPUT层计算公式LeNet5实战定义网络模型初始化模型参数训练测试准确率预测结果 神经网络 神经网络可以看成一端到端的黑盒,中间是隐藏层...

    神经网络

    在这里插入图片描述
    神经网络可以看成一个端到端的黑盒,中间是隐藏层(可以很深),两边是输入与输出层,完整的神经网络学习过程如下:

    1. 定义网络结构(指定输入层、隐藏层、输出层的大小)
    2. 初始化模型参数
    3. 循环操作:
      3.1. 执行前向传播(输入参数,计算一个个结点的值得到y’,即预测值)
      3.2. 计算损失函数(拿y’-y计算Loss)
      3.3. 执行后向传播(求梯度,为了更新参数)
      3.4. 权值更新

    CNN卷积神经网络

    CNN的由来

    卷积神经网络(CNN)是人工神经网络的一种,是多层感知机(MLP)的一个变种模型,它是从生物学概念中演化而来的。

    Hubel和Wiesel早期对猫的视觉皮层的研究中得知在视觉皮层存在一种细胞的复杂分布,这些细胞对于外界的输入局部是很敏感的,它们被称为“感受野”(细胞),它们以某种方法来覆盖整个视觉域。这些细胞就像一些滤波器一样,够更好地挖掘出自然图像中的目标的空间关系信息。
    视觉皮层存在两类相关的细胞,S细胞(Simple Cell)和C(Complex Cell)细胞。S细胞在自身的感受野内最大限度地对图像中类似边缘模式的刺激做出响应,而C细胞具有更大的感受野,它可以对图像中产生刺激的模式的空间位置进行精准地定位。

    在这里插入图片描述
    卷积神经网络已成为语音和图像识别的研究热点,80年代末,Yann LeCun就作为贝尔实验室的研究员提出了卷积网络技术,并展示如何使用它来大幅度提高手写识别能力。在图像识别领域,CNN已经成为一种高效的识别方法

    CNN的应用广泛,包括图像分类,目标检测,目标识别,目标跟踪,文本检测和识别以及位置估计等。

    CNN的基本概念:

    • 局部感受野(local receptive fields)
    • 共享权重(shared weights)
    • 池化(pooling)

    局部感受野

    局部感受野(local receptive fields):图像的空间联系是局部的,就像人通过局部的感受野去感受外界图像一样,每个神经元只感受局部的图像区域,然后在更高层,将这些感受不同局部的神经元综合起来就可以得到全局的信息了。
    在这里插入图片描述
    CNN中相邻层之间是部分连接,即某个神经单元的感知区域来自于上层的部分神经单元。这个与MLP多层感知机不同,MLP是全连接,某个神经单元的感知区域来自于上层的所有神经单元。
    在这里插入图片描述

    共享权重

    共享权重(shared weights):共享权重即参数共享,隐藏层的参数个数和隐藏层的神经元个数无关,只和滤波器的大小和滤波器种类的多少有关。也就是说,对于一个特征图,它的每一部分的卷积核的参数都是一样的。
    在这里插入图片描述
    左图是没有参数共享的情况,右图进行了参数共享

    如果要提取不同的特征,就需要多个滤波器。每种滤波器的参数不一样,表示它提出输入图像的不同特征。这样每种滤波器进行卷积图像就得到对图像的不同特征的反映,我们称之为Feature Map;100种卷积核就有100个Feature Map,这100个Feature Map就组成了一层神经元。

    池化

    池化(pooling)原理:根据图像局部相关的原理,图像某个邻域内只需要一个像素点就能表达整个区域的信息, 池化也称为混合、下采样,目的是减少参数量。分为最大池化,最小池化,平均池化。

    在这里插入图片描述

    CNN的结构

    CNN的网络结构如下:

    • 输入层,Input,输入可以是灰度图像或RGB彩色图像(三通道)。对于输入的图像像素分量为 [0, 255],为了计算方便一般需要归一化(如果使用sigmoid激活函数,会归一化到[0, 1],如果使用tanh激活函数,则归一化到[-1, 1])
    • 卷积层,C*,特征提取层,得到特征图,目的是使原信号特征增强,并且降低噪音;
    • 池化层,S*,特征映射层,将C*层多个像素变为一个像素,目的是在保留有用信息的同时,尽可能减少数据量
    • 光栅化:为了与传统的多层感知器MLP全连接,就是把池化层得到的特征图拉平
    • 多层感知器(MLP):最后一层为分类器,多分类使用Softmax,二分类可以使用Logistic Regression
      在这里插入图片描述
      卷积过程包括:用一个可训练的滤波器fx去卷积一个输入的图像(第一阶段是输入的图像,后面的阶段就是卷积特征图),然后加一个偏置bx,得到卷积层Cx
      下采样(池化)过程包括:每邻域四个像素求和变为一个像素,然后通过标量Wx+1加权,再增加偏置bx+1,然后通过一个sigmoid激活函数,产生一个缩小四倍的特征映射图Sx+1。(下图很重要,下面可训练参数量的计算就可以从这里看出)
      在这里插入图片描述
      卷积神经网络就是让权重在不同位置共享的神经网络,在下图中,局部区域圈起来的所有节点会被连接到下一层的一个节点上(卷积核,称为 kernel 或 filter 或 feature detector,filter的范围叫做filter size,比如 2x2的卷积核)
      在这里插入图片描述
      上图的运算过程可用如下公式表示(上图有重要作用,下面的连接数和神经元个数就可以从这里看出来):
      在这里插入图片描述
      CNN学习可以帮我们进行特征提取,比如我们想要区分人脸和狗头,那么通过CNN学习,背景部位的激活度基本很少。
      CNN layer越多,学习到的特征越高阶,如下图所示:
    • layer 1、layer 2学习到的特征基本上是颜色、边缘等低层特征
    • layer 3开始稍微变得复杂,学习到的是纹理特征,比如网格纹理
    • layer 4学习到的是比较有区别性的特征,比如狗头
    • layer 5学习到的则是完整的,具有辨别性关键特征
      在这里插入图片描述

    光栅化

    光栅化(Rasterization):为了与传统的MLP(多层感知机)全连接,把上一层的所有Feature Map的每个像素依次展开,排成一列。
    图像经过下采样后,得到的是一系列的特征图,而多层感知器接受的输入是一个向量,所以需要将这些特征图中的像素依次取出,排列成一个向量。
    在这里插入图片描述

    LeNet5详解

    1990年,LeCun发表了一篇奠定现在CNN结构的重要文章,他们构建了一个叫做LeNet-5的多层前馈神经网络,并将其用于手写体识别。就像其他前馈神经网络,它也可以使用反向传播算法来训练。它之所以有效,是因为它能从原始图像学习到有效的特征,几乎不用对图像进行预处理。

    LeNet5共有7层(不包含输入层):
    在这里插入图片描述

    LeNet5-C1层

    LeNet5的第一层是卷积层

    • 输入图片大小:32*32
    • 卷积窗大小:5*5(作者定义)
    • 卷积窗种类:6(作者定义)
    • 输出特征图数量:6
      由于卷积窗种类是6,故输出的输出特征图数量也是6
    • 输出特征图大小:(32-5+1)*(32-5+1)=28*28
      输出特征图大小计算可参考神经网络之多维卷积的那些事中的特征图大小计算方式
    • 可训练参数量:(5*5+1)*6(5*5)*6+6
      参数量就是卷积核中元素的个数+偏置bias,总共6种卷积核
    • 计算量:(5*5+1)*6*28*28
      每一个像素的计算量是(5*5+1),总共6*28*28个像素,所以总的计算量是(5*5+1)*6*28*28
    • 神经元数量:(28*28)*6)
      参考上面卷积的计算方式和图像就可以看出,计算出的一个结果(像素点)就是一个神经元
    • 连接数:(5*5+1)*6*28*28
      参考上面卷积的计算方式和图像就可以看出,输入特征图的每个像素是一个神经元,输出特征图的每个像素也是一个神经元,只要参与了计算,两个神经元之间就算做一个连接因此卷积中连接数与计算数是一样的

    LeNet5-S2层

    在这里插入图片描述LeNet5的第二层是池化层(池化核大小2*2,步长为2)

    • 输入大小:(28*28)*6
    • 采样区域(池化核大小):2*2 (作者定义)
    • 下采样数量:6
      这6个下采样的方式其实是一样的
    • 输出特征图大小:14*14
      输出特征图大小计算可参考神经网络之多维卷积的那些事中的特征图大小计算方式,卷积和池化输出特征图大小的计算方式是通用的
    • 可训练参数量:(1+1)*6
      池化层的可训练参数量不是池化核元素的个数,而是每一个池化都有一个权重w和偏置b,总共6个下采样,故可训练参数是(1+1)*6
    • 计算量 :(2*2+1)*14*14*6
      对于池化层的计算量,可能不同地方的描述不一样,我的理解是,采样区域是2*2 ,要找到最大的采样点,需要比较3次,也就是3次计算,才能找到最大值(如果采样区域是3*3,那么需要比较8次才能找到最大值),然后这个最大值再乘以权重w,加上偏置b,因此得到一个像素点的计算量是3+1+1=(2*2-1+1+1)=(2*2+1),总共14*14*6个像素点,可得总共的计算量为(2*2+1)*14*14*6
    • 神经元数量:(14*14)*6
      计算出的一个结果(像素点)就是一个神经元
    • 连接数:(2*2+1)*[(14*14)*6]
      每四个输入的像素点(输入四个神经元),输出的像素点为1个(输出一个神经元),再加上一个偏置的点(偏置神经元),可得每计算一个像素点的连接数是(2*2+1),总共(14*14)*6个像素点,故总的连接数为(2*2+1)*[(14*14)*6],可以看到,池化中计算量和连接数也是一样的

    LeNet5-C3层

    在这里插入图片描述
    LeNet5的第3层是卷积层

    • 输入图片大小:(14*14)*6
    • 卷积窗大小:5*5(作者定义)
    • 卷积窗种类:16(作者定义)
    • 输出特征图数量:16
    • 输出特征图大小:(14-5+1)*(14-5+1)=10*10
    • 可训练参数量:(6*5*5+1)*16
      每张图片的输入通道是6,我们需要用对应维度的卷积核做卷积运算,也就是要用6*5*5的卷积做运算,输出通道是16,因此要有16个这样的卷积核,每个卷积核再加上一个偏置bias,所以参数量是(6*5*5+1)*16,可参考神经网络之多维卷积的那些事
    • 计算量:(6*5*5+1)*16*10*10
      一个像素点的计算量为(6*5*5+1),总的输出像素个数为16*10*10,故总的计算量为(6*5*5+1)*16*10*10,这里要注意:多维卷积计算后需要把每个卷积的计算结果相加,这个相加的结果才是一个像素点,这个计算就忽略不计了
    • 神经元数量:10*10*16
      参考上面卷积的计算方式和图像就可以看出,计算出的一个结果(像素点)就是一个神经元
    • 连接数:(6*5*5+1)*16*10*10

    LeNet5-S4层

    在这里插入图片描述

    LeNet5的第四层是池化层(池化核大小2*2,步长为2)

    • 输入大小:(10*10)*16
    • 采样区域(池化核大小):2*2 (作者定义)
    • 下采样数量:16
    • 输出特征图大小:5*5
    • 可训练参数量:(1+1)*16
    • 计算量 :(2*2+1)*5*5*16
    • 神经元数量:5*5*16
    • 连接数:(2*2+1)*5*5*16

    LeNet5-C5层

    在这里插入图片描述
    LeNet5的第5层是卷积层

    • 输入图片大小:(5*5)*16
    • 卷积窗大小:5*5(作者定义)
    • 卷积窗种类:120(作者定义)
    • 输出特征图数量:120
    • 输出特征图大小:(5-5+1)*(5-5+1)=1*1
    • 可训练参数量:(16*5*5+1)*120
    • 计算量:(16*5*5+1)*1*1*120
    • 神经元数量:1*1*120
    • 连接数:(16*5*5+1)*1*1*120

    LeNet5-F6层

    在这里插入图片描述
    LeNet5的第六层是全连接层

    • 输入图片大小:(1*1)*120
    • 卷积窗大小:1*1(作者定义)
    • 卷积窗种类:84(作者定义)
    • 输出特征图数量:84
    • 输出特征图大小:1*1
    • 可训练参数量:(120+1)*84(全连接层)
      这里相当于84个线性模型,即MLP多层感知机
    • 计算量:(120+1)*84
    • 神经元数量:84
    • 连接数:(120+1)*84(全连接层)

    LeNet5-OUTPUT层

    在这里插入图片描述

    LeNet5的第7层是输出层

    • 输入图片大小:1*84
    • 输出特征图数量:1*10
      输出1000000000,则表明是数字0的分类

    计算公式

    卷积层:设卷积核大小为k*k,步长为1,输入特征图(输入图片)大小为n*n,输入通道是a,输出通道是b(输出通道就是卷积核的种类数)

    • 输出特征图大小:(n-k+1)*(n-k+1)=m*m
    • 可训练参数量:(a*k*k+1)*b
    • 计算量:(a*k*k+1)*b*m*m
    • 神经元数量:m*m*b
    • 连接数:(a*k*k+1)*b*m*m

    卷积步长为n的输出特征图大小计算方式可参考神经网络之多维卷积的那些事

    池化层:设池化核大小为k*k,步长是stride,输入特征图(输入图片)大小为n*n,输入通道是a,输出通道是a(池化层输入通道和输出通道是样的)

    • 输出特征图大小: n − k s t r i d e + 1 = m \frac{ n-k}{stride} + 1=m stridenk+1=m
      可参考神经网络之多维卷积的那些事中的特征图大小计算方式
    • 可训练参数量:(1+1)*a
      池化层可训练的参数量和池化核大小没有关系
    • 计算量:(k*k+1)*(m*m*a)
    • 神经元数量:m*m*a
    • 连接数:(k*k+1)*(m*m*a)

    LeNet5实战

    定义网络模型

    import torch
    from torch import nn,optim
    import torchvision
    import torch.nn.functional as F
    #没参数可以用nn,也可以用F,有参数的只能用nn
    class LeNet5(nn.Module):
        def __init__(self):
            super().__init__()
            #定义卷定义层卷积层,1个输入通道,6个输出通道,5*5的filter,28+2+2=32
            #左右、上下填充padding
            #MNIST图像大小28,LeNet大小是32
            self.conv1 = nn.Conv2d(1,6,5,padding=2)
            #定义第二层卷积层
            self.conv2 = nn.Conv2d(6,16,5)
            
            #定义3个全连接层
            self.fc1 = nn.Linear(16*5*5,120)
            self.fc2 = nn.Linear(120,84)
            self.fc3 = nn.Linear(84,10)
            
        #前向传播
        def forward(self,x):
            #先卷积,再调用relue激活函数,然后再最大化池化
            x=F.max_pool2d(F.relu(self.conv1(x)),(2,2))
            x=F.max_pool2d(F.relu(self.conv2(x)),(2,2))        
            #num_flat_features=16*5*5
            x=x.view(-1,self.num_flat_features(x))
    
            #第一个全连接
            x=F.relu(self.fc1(x))
            x=F.relu(self.fc2(x))
            x=self.fc3(x)
            return x
        def num_flat_features(self,x):
            size=x.size()[1:]
            num_features=1
            for s in size:
                num_features=num_features*s
            return num_features 
    

    初始化模型参数

    import torchvision.datasets as datasets
    #import torchvision.transforms as transforms 
    from torchvision import transforms
    
    from torch.utils.data import DataLoader
    
    #超参数定义
    #人为定义的参数是超参数,训练的是参数
    EPOCH = 10               # 训练epoch次数
    BATCH_SIZE = 64     # 批训练的数量
    LR = 0.001                # 学习率
    
    #首次执行download=True,下载数据集
    #mnist存在的路径一定不要出现 -.?等非法字符
    train_data=datasets.MNIST(root='./dataset',train=True,transform=transforms.ToTensor(),download=False)
    test_data=datasets.MNIST(root='./dataset',train=False,transform=transforms.ToTensor(),download=False)
    
    import matplotlib.pyplot as plt
    %matplotlib inline
    print('训练集大小',train_data.train_data.size())
    print('训练集标签个数',train_data.train_labels.size())
    plt.imshow(train_data.train_data[0].numpy(),cmap='gray')
    plt.show()
    

    输出:

    	训练集大小 torch.Size([60000, 28, 28])
    	训练集标签个数 torch.Size([60000])
    

    在这里插入图片描述

    #如果有dataloader 的话一般都是在dataset里,dataloader和dataset 这俩一般一起用的
    #使用DataLoader进行分批
    #shuffle=True是设置随机数种子
    train_loader=DataLoader(dataset=train_data,batch_size=BATCH_SIZE,shuffle=True)
    test_loader=DataLoader(dataset=test_data,batch_size=BATCH_SIZE,shuffle=True)
    
    #创建model
    model=LeNet5()
    #定义损失函数
    criterion=nn.CrossEntropyLoss()
    #定义优化器
    optimizer=optim.Adam(model.parameters(),lr=1e-3)
    
    #device  cuda:0是指使用第一个gpu
    device=torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
    # device=torch.device('cpu')
    print(device,type(device))
    model.to(device)
    

    训练

    
    # 训练
    for epoch in range(EPOCH):
        for i,data in enumerate(train_loader):
            inputs,labels=data
            #可能会使用GPU,注意掉就不会在gpu里运行了
            inputs,labels=inputs.to(device),labels.to(device)
            # print(type(inputs),inputs.size(),'\n',inputs)
            #前向传播
            outpus=model(inputs)
            
            #计算损失函数
            loss=criterion(outpus,labels)
            #清空上一轮梯度
            optimizer.zero_grad()
            #反向传播
            loss.backward()
            #参数更新
            optimizer.step()
     
        print('epoch {} loss:{:.4f}'.format(epoch+1,loss.item()))
    

    输出:

    epoch 1 loss:0.1051
    epoch 2 loss:0.0102
    epoch 3 loss:0.1055
    epoch 4 loss:0.0070
    epoch 5 loss:0.2846
    epoch 6 loss:0.1184
    epoch 7 loss:0.0104
    epoch 8 loss:0.0014
    epoch 9 loss:0.0141
    epoch 10 loss:0.0126
    

    测试准确率

    #保存训练模型
    torch.save(model,'dataset/mnist_lenet.pt')
    model=torch.load('dataset/mnist_lenet.pt')
    
    #测试
    """
    训练完train_datasets之后,model要来测试样本了。
    在model(test_datasets)之前,需要加上model.eval(). 
    否则的话,有输入数据,即使不训练,它也会改变权值。
    """
    model.eval()
    correct=0
    total=0
    
    for data in test_loader:
        images,labels=data
        images,labels=images.to(device),labels.to(device)
        #前向传播  model(images)  和 model.forward(x)一样的
        out=model(images)
        """
        首先得到每行最大值所在的索引(比图第7个分类是最大值,则索引是7)
        然后,与真实结果比较(如果一个样本是图片7,那么该labels是7),如果相等,则加和
        """
        _,predicted=torch.max(out.data,1)
        total=total+labels.size(0)
        correct=correct+(predicted==labels).sum().item()
        
    #输出测试的准确率
    print('10000张测试图像 准确率:{:.4f}%'.format(100*correct/total))
    

    输出:

    	10000张测试图像 准确率:98.9400%
    

    预测结果

    #记住,输入源一定要转化为torch.FloatTensor,否则无法预测,并且一定要加model.eval(),否则会更新权重
    def predict_Result(img):
        """
        预测结果,返回预测的值
        img,numpy类型,二值图像
        """
        model.eval()
        img=torch.from_numpy(img).type(torch.FloatTensor).unsqueeze(0).unsqueeze(1)
        img=img.to(device)
        out=model(img)
        _,predicted=torch.max(out.data,1)
        return predicted.item()
        
    img2=train_data.train_data[167].numpy()
    plt.imshow(img2,cmap='gray')
    print('预测结果:',predict_Result(img2))
    

    输出:

    在这里插入图片描述

    展开全文
  • keras搭建卷积神经网络构建模型参数个数计算方式 计算过程 (1)用一十二个333的卷积核对三通道图像1501503进行卷积。每一个卷积核有一个偏置。则此层参数个数为(333+1)12=336。 (2)经过上面的操作,生成了一...
  • pytorch 计算网络参数个数

    千次阅读 2018-08-23 11:28:08
    params = list(net.parameters()) k = 0 for i in params:  l = 1  print("该层的结构:" + str(list(i.size())))  for j in i.size():  l *= j  print("该层参数和:"...总参数数量...
  • 慢慢填坑中,今天来仔细讲一下卷基层和全连接层训练参数个数如何确定的问题。我们以Mnist为例,首先贴出网络配置文件: name: "LeNet" layer { name: "mnist" type: "Data" top: "data" top: "label" data_...
  • 图:卷积神经网络的概念示范:输入图像通过和三个可训练的滤波器和可加偏置进行卷积,滤波过程如图一,卷积后在C1层产生三个特征映射图,然后特征映射图中每组的四个像素再进行求和,加权值,加偏置,通过一个...
  • CNN参数个数和连接个数计算详解

    万次阅读 2017-09-18 15:29:31
    之前所讲的图像处理都是小 patchs ,比如28*28或者36*36之类,考虑如下情形,对于一副1000*1000的图像,即106,当隐层也有106节点时,那么W(1)的数量将达到1012级别,为了减少参数规模,加快训练速度,CNN应运而生。...
  • 本篇文章来自于learnopencv....在这篇文章中,我们分享了一些公式来计算张量(图像)的大小和卷积神经网络(CNN)中每一层的参数个数。 此帖子不定义CNN中使用的基本术语...
  • 深度神经网络-权值参数个数计算

    千次阅读 2017-05-16 20:15:50
    详细解释CNN卷积神经网络各层的参数和链接个计算 ... 图:卷积神经网络的概念示范:输入图像通过和三个可训练的滤波器和可加偏置进行卷积,滤波过程如图一,卷积后在C1层产生三个特征映射图,然后特征
  • AI:神经网络在深度学习过程中每层训练的网络参数...计算每一层神经网络在深度学习过程中的训练参数个数的常规公式2为: total_params_count = (filter_height * filter_width * input_channels + 1) * number_of_...
  • 1. RNN 模型 Embedding Embedding(input_dim, output_dim,input_length) input_dim 表示字典的大小...训练参数的数目为:input_dim✖️output_dim; model = Sequential() model.add(Embedding(10000, 64, inpu...
  • 1、卷积网络实例分析 构建卷积网络如下: from tensorflow.python.keras import datasets, models, ... # 第1层卷积,卷积核大小为3*3,32卷积核,28*28为待训练图片的大小 model.add(layers.Conv2D(32, (3, 3),
  • DNN:LSTM的前向计算参数训练

    千次阅读 2018-11-29 17:26:55
    LSTM的参数训练和前向计算比RNNs还是稍微复杂一些。 长短时记忆网络的前向计算 前面描述的开关是怎样在算法中实现的呢?这就用到了门(gate)的概念。门实际上就是一层全连接层,它的输入是一向量,输出是一...
  • LeNet-5网络结构及训练参数计算

    千次阅读 2018-01-30 21:09:28
    经典神经网络诞生记:  1、LeNet,1998年 2、AlexNet,2012年 3、ZF-net,2013年 4、GoogleNet... ...LeNet-5是由 Yann LeCun 等人于1998年提出的,是一用于识别手写数字的网络,其网络结构图如下所示:
  • 感想:最近在研究卷积神经网络的构建和训练,权重(参数)是一非常重要的概念,卷积层会用多不同的卷积核,每卷积核有m*n权重,用来提取和强化图像的特征,主要利用了图像的局部相关性。全连接层,顾名思义...
  • 一、CNN概述  卷积神经网络是一个多层的神经网络,每层由多个二维平面...1. 输入图像通过和三个可训练的滤波器和可加偏置进行卷积,滤波过程如图1,卷积后在C1层产生三个特征映射图 2. 然后特征映射图中每组的4个...
  •  图:卷积神经网络的概念示范:输入图像通过和三个可训练的滤波器和可加偏置进行卷积,滤波过程如图一,卷积后在C1层产生三个特征映射图,然后特征映射图中每组的四个像素再进行求和,加权值,加偏置,通过一个...
  • CNN中计算量和参数计算方法

    千次阅读 2019-07-05 17:51:12
    摘要: 我们在设计一个CNN网络时,通常要考虑两个事情,一个是这个网络需要的计算量有多大,一个是这个模型的参数量有...参数量以参数个数为单位,要计算内存或显存的,用参数量乘以每个参数所占的字节即可。 ...
  • 卷积神经网络是一多层的神经网络,每层由多二维平面组成(每层有多Feature Map,每Feature Map通过一种卷积滤波器提取输入的一种特征),而每平面由多独立神经元组成。 图1 卷积神经网络的概念...
  • 双线性插值方法在初始化神经网络的可训练参数,Mask R-CNN和deeplab中都有使用,在本篇博客中,笔者分别借用c++和python的两种源码,与大家分享双线性插值在初始化神经网络可训练参数方面的原理,欢迎阅读与分享。
  • 这两天在使用yolov3-tiny,记录下一些训练参数和其取值的意义。 在不检测目标占比小的情况时,可以选用的yolov3-tiny模型 1.模型训练参数 yolo训练时输出的各项参数(这图用的是yolov3-tiny训练,所以只有16和23这...
  • yolo 学习系列(三):训练参数与网络参数 1 训练参数 博主在使用 yolov2-tiny-voc 训练 人 这一类目标物体时,训练过程中在终端输出的参数如图所示,了解这些参数的含义有助于了解训练过程中的训练效果。...
  • 卷积神经网络参数量和计算量的计算

    万次阅读 多人点赞 2019-08-15 15:49:08
    0 前言 我们在设计一个CNN网络时,通常要考虑两个事情,一个是这个网络需要的计算量有多大,一个是这个模型的...参数量以参数个数为单位,要计算内存或显存的,用参数量乘以每个参数所占的字节即可。 1 计算量 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 277,080
精华内容 110,832
关键字:

计算可训练参数个数