精华内容
下载资源
问答
  • 计算可训练参数个数
    千次阅读
    2018-10-30 21:42:08

    1. RNN 模型

    • Embedding

      • Embedding(input_dim, output_dim,input_length)
        • input_dim 表示字典的大小;
        • outpu_dim 则表示嵌入的维度;
      • 训练参数的数目为:input_dim✖️output_dim;
      model = Sequential()
      model.add(Embedding(10000, 64, input_length=10))
      input_array = np.random.randint(10000, size=(32, 10))
      	# batch_size 为 32,每一条样本的长度为 10,input_array 的最大值不超过 10000-1,
      model.compile('rmsprop', 'mse')
      output_array = model.predict(input_array)
      assert output_array.shape == (32, 10, 64)
      	# 32 仍为 batch_size
      	# 10,64:则表示输入样本的每一维均映射为 64 维的嵌入向量;
      
    • SimpleRNN

      s t = tanh ⁡ ( U x t + W s t − 1 ) o t = Softmax ( V s t ) \begin{array}{l} s_t=\tanh(Ux_t+Ws_{t-1})\\ o_t=\text{Softmax}(Vs_t) \end{array} st=tanh(Uxt+Wst1)ot=Softmax(Vst)

      则训练参数的数目为:dim(U)+dim(W)+dim(V),如果隐层神经元的数目为 n,输出的维数为 k,输入的维度为 m,也即 U n × m , W n × n , V n × k U_{n\times m}, W_{n\times n}, V_{n\times k} Un×m,Wn×n,Vn×k,训练参数的数目为: n 2 + n m + k n n^2+nm+kn n2+nm+kn,如果考虑到biases,还需加上 n n n

      • 对于 SimpleRNN,计算其可训练参数时,并未计入到输出层的矩阵 V V V,此时训练参数的数目为 n 2 + n m + n n^2+nm+n n2+nm+n
      model = Sequential()
      model.add(Embedding(1000, 64))
      		# 1000*64 ⇒ 64000
      model.add(SimpleRNN(32))
      		# 64*32+32*32+32=3104
      model.summary()
      

      https://stackoverflow.com/questions/50134334/number-of-parameters-for-keras-simplernn

    • GRU

    • LSTM

      • input_dim: m, units: n
      • 可训练参数数目为:4(nm+n+n^2)
      model = Sequential()
      model.add(LSTM(256, input_shape=(16, 4096)))
      	# 4*(4096*256+256+256**2)
      model.summary()
      

    2. CNN

    • Conv1D
      • (None, 500, 128),经过 (32, 7)(32 表示 filter 的数量,7 为 kernel size)的一维卷积之后的大小为:(None, 494, 32),训练参数的数目为:712832+32 ⇒ 28704;
    更多相关内容
  • 查看模型参数(以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)
    

    在这里插入图片描述

    展开全文
  • 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))
    

    输出:

    在这里插入图片描述

    展开全文
  • 深度学习 卷积层与全连接层权重参数个数计算

    千次阅读 多人点赞 2020-08-06 14:23:45
    1、卷积网络实例分析 构建卷积网络如下: from tensorflow.python.keras import datasets, models, ... # 第1层卷积,卷积核大小为3*3,32卷积核,28*28为待训练图片的大小 model.add(layers.Conv2D(32, (3, 3),

    1、卷积网络实例分析

    构建卷积网络如下:

    from tensorflow.python.keras import datasets, models, layers
    class CNN(object):
        def __init__(self):
            model = models.Sequential()
            # 第1层卷积,卷积核大小为3*3,32个卷积核,28*28为待训练图片的大小
            model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
            # 池化层
            model.add(layers.MaxPooling2D(2, 2))
            # 第2层卷积,卷积核大小为3*3,64个卷积核
            model.add(layers.Conv2D(64, (3, 3), activation='relu'))
            # 池化层
            model.add(layers.MaxPooling2D(2, 2))
            # 第3层卷积,卷积核大小为3*3,128个卷积核
            model.add(layers.Conv2D(128, (3, 3), activation='relu'))
            # 池化层
            model.add(layers.MaxPooling2D(2, 2))
            # 拉成1维形状
            model.add(layers.Flatten())
            # 第4层全连接层,64个神经元
            model.add(layers.Dense(64, activation='relu'))
            # 第5层全连接层  10个神经元,softmax 多用于分类
            model.add(layers.Dense(10, activation='softmax'))
            model.summary()
            self.model = model
    
    if __name__ == "__main__":
        CNN()
    

    输出的网络信息如下:

    1 、卷积层参数个数计算方法:(卷积核高 * 卷积核宽 * 通道数 + 1) * 卷积核个数
    2 、当前全连接层参数个数计算方法: (上一层神经元个数 + 1) * 当前层神经元个数

    以上的1代表偏置,因为每个神经元都有一个偏置

    卷积层1: 320 = (3 * 3 * 1 +1) * 32
    卷积层2: 18496 = (3 * 3 * 32 +1) * 64
    卷积层3: 73856 = (3 * 3 * 64 +1) * 128

    全连接层1: 8256 = (128 + 1) * 64
    全连接层2: 650 = (64 + 1) * 10

    2、各层参数和链接数计算

    举例:

          下面以最经典的LeNet-5例子来逐层分析各层的参数及连接个数。   

    图2

    C1层(卷积层):是一个卷积层,由6个特征图Feature Map构成。特征图中每个神经元与5*5的邻域(滤波器)相连。

    1. 特征图大小:特征图的大小28*28,这样能防止输入的连接掉到边界之外(32-5+1=28)。

    feature map边长大小的具体计算参见:http://blog.csdn.net/qq_15192373/article/details/78393520

    2. 参数个数:C1有156个可训练参数 (每个滤波器5*5=25个unit参数和一个bias参数,一共6个滤波器,共(5*5+1)*6=156个参数)

    3. 链接个数/FLOPS个数::(5*5+1)*6 *(28*28)=122,304个。左边是滤波器在输入层滑过的神经元个数,右边是C1层每个feature map的神经元个数,左右对应关系是1对28*28,相乘即为连接数。(每个链接对应1次计算,由wa+b可知,每个参数参与1次计算,所以1个单位的偏置b也算进去)

    ----------------------------------------

    S2层(下采样层):是一个下采样层,有6个14*14的特征图。特征图中的每个单元与C1中相对应特征图的2*2邻域相连接。

    1. 特征图大小:每个单元的2*2感受野并不重叠,因此S2中每个特征图的大小是C1中特征图大小的1/4(行和列各1/2)

    2. 参数个数:S2层有 12个 (6*(1+1)=12) 可训练参数。S2层 每个滤波器路过的4个邻域 的4个输入相加,乘以1个可训练参数w,再加上1个可训练偏置b(即一个滤波器对应两个参数)。(对于子采样层,每一个特征映射图的的可变参数需要考虑你使用的采样方式而定,如文中的采样方式,每一个特征映射图的可变参数数量为2个,有的采样方式不需要参数)

    3. 链接个数/FLOPS个数:5880个连接,( (2*2+1)*6 *14*14=5880) 。左边是滤波器在C1层滑过的神经元个数,右边是S2层每个feature map的神经元个数,相乘即为连接数。

    ----------------------------------------

    C3层(卷积层):是一个卷积层,它同样通过5x5的卷积核去卷积层S2,然后得到的特征map就只有10x10个神经元,但是它有16种不同的卷积核,所以就存在16个特征map了。

    1. 特征图大小:C3中每个特征图由S2中所有6个或者几个特征map组合(几个滤波器计算的神经元的值 相加 合并成一个神经元)而成。

    为什么不把S2中的每个特征图连接到每个C3的特征图呢?原因有2点。

    第1,不完全的连接机制将连接的数量保持在合理的范围内。

    第2,也是最重要的,其破坏了网络的对称性。由于不同的特征图有不同的输入,所以迫使他们抽取不同的特征(希望是互补的)。(14-5+1=10)

    2. 参数个数:例如,存在的一个方式是:

    C3的前6个特征图:相当于需要6组滤波器,每组以S2中 3个相邻 特征图子集 为输入,共享一个偏置。(C3每个特征图 由 S2中3个特征图分别用不同滤波器 再加和得到)

    C3的接下来6个特征图:相当于需要6组滤波器,每组以S2中 4个相邻 特征图子集 为输入,共享一个偏置。(1对4)

    C3的接下来3个特征图:相当于需要3组滤波器,每组以S2中 4个不相邻 特征图子集 为输入,共享一个偏置。(1对4)

    C3的最后1个特征图:相当于需要1组滤波器,每组将S2中所有 特征图 为输入,共享一个偏置。(1对6)

        这样C3层有1516个可训练参数。计算:6*(3*25+1)+6*(4*25+1)+3*(4*25+1)+(25*6+1)=1516。此处,C3个特征图由 S2中n个卷积结果合并,然后共享1个b,组合计算得到。

    3. 链接个数/FLOPS个数:1516* 10*10=151600个连接。左边是滤波器滑过的S2层神经元个数,右边是C3层特征图大小。

    ------------------------------------------

    S4层(下采样层):是一个下采样层,由16个5*5大小的特征图构成。特征图中的每个单元与C3中相应特征图的2*2邻域相连接,跟C1和S2之间的连接一样。

    1. 特征图大小:5*5大小。每个单元的2*2感受野并不重叠,因此S2中每个特征图的大小是C1中特征图大小的1/4(行和列各1/2)

    2. 参数个数:S4层有32个可训练参数。(每个特征图1个因子w和1个偏置b,16*(1+1)=32)

    3. 链接个数/FLOPS个数:16* (2*2+1) *5*5=2000个连接。左边是滤波器在C3层滑过的神经元个数,右边是S4层神经元个数,相乘即为连接数。

    --------------------------------------------

    C5层(卷积层或第一个全连接层):是一个卷积层,有120个特征图(或者说神经元)。每个单元与S4层的全部16个单元的5*5邻域(与S4层特征图一样大)相连。(120组滤波器, 每组16个滤波器,分别与 S4层16个特征图 进行卷积, 每组得到C5层的一个神经元/特征图)

    1. 特征图大小:由于S4层特征图的大小也为5*5(同滤波器一样),故C5特征图的大小为1*1。(5-5+1=1), 这构成了S4和C5之间的全连接。之所以仍将C5标示为卷积层而非全相联层,是因为如果LeNet-5的输入变大,而其他的保持不变,那么此时特征图的维数就会比1*1大。

    2. 参数个数:120* (16*5*5+1)=48120个。滤波器个数120*16个,所以w有120*16*5*5个,同组16个滤波器共用一个b,所以有120个b。

    3. 链接个数/FLOPS个数:48120*1*1, 左边是滤波器滑过的神经元个数,右边是C5层特征图大小(其实现在已经变成了单个神经元,大小1*1),相乘即为连接数,此处也即FLOPS个数。

    --------------------------------------------

    F6层(全连接层):虽然是全连接层,得到F6层每个神经元 由 每组120个1*1的滤波器对C5层卷积,一共84组滤波器,得到84个神经元。

    1. 特征图大小:有84个单元(之所以选这个数字的原因来自于输出层的设计),与C5层全相连。

    2. 参数个数:有 84* (120*(1*1)+1)=10164 个可训练参数。如同经典神经网络,F6层计算输入向量(120)和权重向量(1*1)之间的点积,再加上一个偏置(+1)。然后将其传递给sigmoid函数产生单元i的一个状态。

    3. 链接个数/FLOPS个数:10164* 1*1,左边是滤波器在C5层滑过的神经元个数,右边是F6层特征图大小。1个链接对应1次计算。

    --------------------------------------------

    输出层:由欧式径向基函数(Euclidean Radial Basis Function)单元组成,每类一个单元,每个有84个输入。

    --------------------------------------------

    3、卷积和下采样说明

    图3 卷积和子采样过程

    卷积过程包括:用一个可训练的滤波器fx去卷积一个输入的图像(第一阶段是输入的图像,后面的阶段就是卷积特征map了),然后加一个偏置bx,得到卷积层Cx。

    子采样过程包括:每邻域四个像素求和变为一个像素,然后通过标量Wx+1加权,再增加偏置bx+1,然后通过一个sigmoid激活函数,产生一个大概缩小四倍的特征映射图Sx+1。

    展开全文
  • 参考这两文章的部分笔记和理解:...id=0DRtwE6Ehttp://blog.csdn.net/dcxhun3/article/details/46878999输入input: 32 x 32 的图像使用: 6 5x5 stride为 1的卷积核神经元 个数: (32-5+1) * (32 ...
  • AI:神经网络在深度学习过程中每层训练的网络参数...计算每一层神经网络在深度学习过程中的训练参数个数的常规公式2为: total_params_count = (filter_height * filter_width * input_channels + 1) * number_of_...
  • Keras自定义可训练参数

    千次阅读 2019-04-04 20:20:14
    Keras自定义可训练参数是在自定义层中实现的,因此需要我们自己编写一个层来实现我们需要的功能。话不多说,直接上实例。 假设我们需要自定义一个可学习的权重矩阵来对某一层的数据进行转换,则可以通过下面代码...
  • CNN参数个数和连接个数计算详解

    万次阅读 2017-09-18 15:29:31
    之前所讲的图像处理都是小 patchs ,比如28*28或者36*36之类,考虑如下情形,对于一副1000*1000的图像,即106,当隐层也有106节点时,那么W(1)的数量将达到1012级别,为了减少参数规模,加快训练速度,CNN应运而生。...
  • 图:卷积神经网络的概念示范:输入图像通过和三个可训练的滤波器和可加偏置进行卷积,滤波过程如图一,卷积后在C1层产生三个特征映射图,然后特征映射图中每组的四个像素再进行求和,加权值,加偏置,通过一个...
  • 【其它】按要求完成PPT制作:【计算题】对应课本147页,针对表2中1790-2000年数据,结合方法一、方法二给出logistic 阻滞增长模型的参数估计。 答案中给出具体r, x0,xm;且给出拟合效果图(类似图7)。【简答题】验证微分...
  • 但一神经网络模型的参数量具体是多少可能我们并不是很清楚,所以今天我们来分享每一种网络模型的参数数量计算公式。 FFNN 首先我们定义三个参数: i:输入大小 h:隐藏层大小 o:输出大小 即在前馈神经网络中...
  • 神经网络参数计算

    千次阅读 2020-09-06 12:03:51
    这篇文章主要是记录一下神经网络的参数量大致估算方法,计算过程利用的是mobilenet-v2来举例说明,如果对mobilenet-v2不太了解,可以参考文章mobilenet-v1和mobilenet-v2详解。 关于卷积参数计算的方式 假设输入...
  • 深度神经网络-权值参数个数计算

    万次阅读 2017-05-16 20:15:50
    详细解释CNN卷积神经网络各层的参数和链接个计算 ... 图:卷积神经网络的概念示范:输入图像通过和三个可训练的滤波器和可加偏置进行卷积,滤波过程如图一,卷积后在C1层产生三个特征映射图,然后特征
  • 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年提出的,是一用于识别手写数字的网络,其网络结构图如下所示:
  • 卷积层与全连接层权重(参数个数计算

    万次阅读 多人点赞 2019-09-05 10:01:36
    感想:最近在研究卷积神经网络的构建和训练,权重(参数)是一非常重要的概念,卷积层会用多不同的卷积核,每卷积核有m*n权重,用来提取和强化图像的特征,主要利用了图像的局部相关性。全连接层,顾名思义...
  • 一、CNN概述  卷积神经网络是一个多层的神经网络,每层由多个二维平面...1. 输入图像通过和三个可训练的滤波器和可加偏置进行卷积,滤波过程如图1,卷积后在C1层产生三个特征映射图 2. 然后特征映射图中每组的4个...
  • 卷积神经网络是一多层的神经网络,每层由多二维平面组成(每层有多Feature Map,每Feature Map通过一种卷积滤波器提取输入的一种特征),而每平面由多独立神经元组成。 图1 卷积神经网络的概念...
  • 计算训练参数数量 1、定义神经网络 设定简单的卷积神经网络,只有一卷积层和一全连接层。 卷积层为63×3的卷积核 输入图片为大小为1×1×32×32 从代码的角度来理解: class Net(nn.Module): def __init_...
  • 我的目的是在一个卷积操作中额外添加一个可训练的参数,该参数可以控制该卷积层参数,我一开始的定义是这样的: 1.先在__init__中定义该可训练参数: self.para = torch.nn.Parameter(torch.ones(1).to(device)....
  • 【卷积神经网络中涉及的训练参数与超参数概念理解】文前白话网络超参数1. 输入图像大小2. 卷积层超参数卷积核尺寸、卷积核数量、卷积的步长3. 池化层超参数池化核尺寸、池化步长、池化方式4. 网络训练、优化超参数...
  •  图:卷积神经网络的概念示范:输入图像通过和三个可训练的滤波器和可加偏置进行卷积,滤波过程如图一,卷积后在C1层产生三个特征映射图,然后特征映射图中每组的四个像素再进行求和,加权值,加偏置,通过一个...
  • LSTM神经元中参数个数

    千次阅读 2019-04-23 17:03:30
    LSTM的神经元个数 1. LSTM简单介绍 上图中间位置就是一LSTM cell,红框框从左到右,依次是: 忘记门层: 决定从细胞状态中丢弃什么信息,通过当前时刻输入(xtx_{t}xt​)和前一时刻输出(ht−1h_{t-1}ht−1​)...
  • 卷积神经网络的参数计算

    万次阅读 多人点赞 2018-01-08 22:39:12
    这篇文章会简单写一下卷积神经网络上参数计算方法,然后计算各个常见神经网络的参数。一是加强对网络结构的了解,另一方面对网络参数的量级有一大概的认识,也可以当作备忘录,免得想知道的时候还要再算。 ...
  • 卷积层参数计算与设置

    千次阅读 2022-03-26 16:07:10
    batch_size:相当于一次训练的样本 weight/height:图片宽和高 channels:图片通道,1是黑白,3是RGB 卷积层参数介绍: filter = 卷积核(1x1,3x3,5x5) feature map = 卷积之后得到的输出结果 weight/height:
  • 忽略padding和stride的话,输入层,卷积核和输出层的关系,以及参数量、计算量如下(第二行是一例子) 关于参数量:每卷积核有K×K×MK×K×MK×K×M个参数,那么共有N卷积核,参数量就是K×K×M×NK×K×M×NK...
  • DNN:LSTM的前向计算参数训练

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

    千次阅读 2020-03-19 15:02:38
    resnet50残差网络参数计算:https://blog.csdn.net/Seven_year_Promise/article/details/69360488
  • 模型大小 与参数计算

    千次阅读 2021-05-18 23:27:20
    有些时候,model size在实际计算时除了包含参数量以外,还包括网络架构信息和优化器信息等。比如存储一一般的CNN模型(ImageNet训练)需要大于300MB。 M和MB的换算关系: 比如说我有一模型参数量是1M,在一般的...
  • 注意:本文先区分两概念,再介绍stride = 1情况下CNN卷积的计算参数计算量。文末会附上不同stride的计算CNN参数量和计算量和使用API自动计算CNN参数量和计算量的博客。 先区分两概念: FLOPS 注意全部大写 是...
  • 许多人会有一直观的印象,也就是网络层越多,训练效果越好,但是这样的话VGG网络为什么不采取152层而是采用19层呢?其实是因为训练模型的准确度不一定和模型层呈真相关的关系。因为随着网络层的加深,网络...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 331,570
精华内容 132,628
关键字:

计算可训练参数个数