精华内容
下载资源
问答
  • 卷积神经网络五之典型的CNN网络
    千次阅读
    2020-03-26 10:32:25

    一、典型的CNN网络

    1、开山之作:LeNet-5 1998

    • LeNet-5 是一个非常成功的神经网络模型。
      • 基于 LeNet-5 的手写数字识别系统在 90 年代被美国很多银行使用,用来识别支票上面的手写数字。
      • LeNet-5 共有 7 层。
      • (不怎么会计算)

    输入层:输入图像大小为 32 × 32 = 1024。

    C1 层:这一层是卷积层。滤波器的大小是 5×5 = 25,共有 6 个滤波器。得到 6 组大小为 28 × 28 = 784 的特征映射。因此,C1 层的神经元个数为 6 × 784 = 4,704。可训练参数个数为6 × 25 + 6 = 156。连接数为 156 × 784 = 122,304(包括偏置在内,下同)。

    S2 层:这一层为子采样层。由 C1 层每组特征映射中的 2 × 2 邻域点次采样为 1 个点,也就是 4 个数的平均。也采用了激活函数,神经元个数为 6 × 14 × 14 = 1, 176,可训练参数数量为6 × (1 + 1) = 12,连接数为 6 × 196 × (4 + 1) = 5, 880。

    C3层为卷积层: LeNet-5中用一个连接表来定义输入和输出特征映射之间的依赖关系,共使用 60个 5 × 5的滤波器,得到 16组大小为 10 × 10的特征映射。神经元数量为 16 × 100 = 1, 600,可训练参数数量为 (60 × 25) + 16 = 1, 516,连接数为 100 × 1, 516 = 151, 600。

    S4层是一个汇聚层,采样窗口为 2 × 2,得到 16个 5 × 5大小的特征映射,可训练参数数量为 16 × 2 = 32,连接数为 16 × 25 × (4 + 1) = 2000。

    C5层是一个卷积层,使用 120 × 16 = 1, 920个 5 × 5的滤波器,得到 120组大小为 1 × 1的特征映射。 C5层的神经元数量为 120,可训练参数数量为 1, 920 × 25 + 120 = 48, 120,连接数为 120 × (16 × 25 + 1) = 48, 120。
    F6层是一个全连接层,有84个神经元,可训练参数数量为84×(120+1) =10, 164。连接数和可训练参数个数相同,为 10, 164。

    输出层:输出层由 10个欧氏径向基函数(Radial Basis Function, RBF)函数组成。
     

    2、王者归来:AlexNet  2012

    Imagenet数据集和ILSVRC(ImageNet Large Scale Visual Recogition Challenge),计算机视觉乃至整个人工智能发展史上的里程碑

    ImageNet 数据集最初由斯坦福大学李飞飞等人在 CVPR 2009 的一篇论文中推出。截至 2016 年,ImageNet 中含有超过 1500 万由人手工注释的图片网址,也就是带标签的图片,标签说明了图片中的内容,超过 2.2 万个类别。其中,至少有 100 万张里面提供了边框(bounding box)。

    AlexNet  2012 ILSVRC winner

      • 八层卷积神经网络,其中前5层卷积层,后边3层全连接层,65万个神经元,6000万个自由参数
      • 两个Nvidia GTX580 GPU,120万训练图像,训练了6天
      • 第一个现代深度卷积网络模型,首次使用了很多现代深度卷积网络的一些技术方法,比如使用GPU进行并行训练,采用了ReLU作为非线性激活函数,使用数据增强和Dropout防止过拟合。
    • 分为上下两个部分的网络,论文中提到这两部分网络是分别对应两个GPU,只有到了特定的网络层后才需要两块GPU进行交互,这种设置完全是利用两块GPU来提高运算的效率。
    • 网络总共的层数为8层,5层卷积,3层全连接层。
    • 第一层:卷积层1,输入为 224×224×3的图像,卷积核的数量为96,论文中两片GPU分别计算48个核; 卷积核的大小为 11×11×3 ; stride = 4, stride表示的是步长, pad = 0, 表示不扩充边缘;卷积后的feature map大小为width= (224 + 2 * padding - kernel_size) / stride + 1 = 54   height = (224 + 2 * padding - kernel_size) / stride + 1 = 54    dimention = 96然后进行 (Local Response Normalized), 后面跟着池化pool_size = (3, 3), stride = 2, pad = 0 最终获得第一层卷积的feature map为54*54*96
    • 第二层:卷积层2, 输入为上一层卷积的feature map, 卷积的个数为256个,论文中的两个GPU分别有128个卷积核。卷积核的大小为:5×5×48; pad = 2, stride = 1; 然后做 LRN, 最后 max_pooling, pool_size = (3, 3),  stride = 2;
    • 第三层:卷积3, 输入为第二层的输出,卷积核个数为384, kernel_size = (3×3×256), padding = 1, 第三层没有做LRN和Pool
    • 第四层:卷积4, 输入为第三层的输出,卷积核个数为384, kernel_size = (3×3), padding = 1, 和第三层一样,没有LRN和Pool
    • 第五层:卷积5, 输入为第四层的输出,卷积核个数为256, kernel_size = (3×3), padding = 1。然后直接进行max_pooling, pool_size = (3, 3), stride = 2;
    • 第6,7,8层是全连接层,每一层的神经元的个数为4096,最终输出softmax为1000,因为上面介绍过,ImageNet这个比赛的分类个数为1000。全连接层中使用了RELU和Dropout。

    2.1 AlexNet中使用的训练技巧

    • Relu激活函数
    • Overlapping Pooling(覆盖的池化)
    • Local Response Normalization(局部响应归一化)
    • Dropout
    • Data augmentation(数据增强
    • Overlapping Pooling(覆盖的池化)
    • 一般的池化层因为没有重叠,所以pool_size 和 stride一般是相等的。
    • 如果 stride < pool_size, 就是覆盖的池化操作。
    • 在top-1,和top-5中使用覆盖的池化操作分别将error rate降低了0.4%和0.3%。论文中说,在训练模型过程中,覆盖的池化层更不容易过拟合。
    • Local Response Normalization(局部响应归一化)
    • 传统的激活函数如tanh和sigmoid,值域都是有范围的,而ReLU激活函数得到的值域没有一个区间,所以要对ReLU得到的结果进行归一化
    • Local Response Normalization,对不同feature map相同位置的点进行归一化。
    • 参数α,β, 如何确定?
    • 论文中说在验证集中确定,最终确定的结果为:k=2,n=5,α=10−4,β=0.75
    • Data Augmentation(数据增强)
    • 数据增强防止过拟合的最简单的方法
    • 只需要对原始的数据进行合适的变换,就会得到更多有差异的数据集,防止过拟合。
    • from keras.preprocessing.image import ImageDataGenerator
    • data_augment = ImageDataGenerator(rotation_range= 10,zoom_range= 0.1, width_shift_range = 0.1,height_shift_range = 0.1, horizontal_flip = False,  vertical_flip = False)
    • model.fit_generator(data_augment.flow(X_train, y_train, batch_size=batch_size),                             epochs= epochs, validation_data = (X_test,y_test),shuffle=True)

    (三)Dropout

    • dropout是CNN中防止过拟合的大杀器
    • Dropout是指在深度学习网络的训练过程中,对于神经网络单元,按照一定的概率将其暂时从网络中丢弃。注意是暂时,对于随机梯度下降来说,由于是随机丢弃,故而每一个mini-batch都在训练不同的网络。

    3、越走越深:VGGNet   2014

    • VGGNet由牛津大学计算机视觉组和Google DeepMind公司研究员一起研发的深度卷积神经网络。
    • 它探索了卷积神经网络的深度和其性能之间的关系,通过反复的堆叠3*3的小型卷积核和2*2的最大池化层,成功的构建了16~19层深的卷积神经网络。
    • VGGNet获得了ILSVRC 2014年比赛的亚军和定位项目的冠军,在top5上的错误率为7.5%。迄今为止,VGGNet仍然是最常用的cnn架构之一。
    • VGGNet包含很多级别的网络,深度从11层到19层不等,比较常用的是VGGNet-16和VGGNet-19。
    • VGGNet全部使用3*3的卷积核和2*2的池化核,通过不断加深网络结构来提升性能。网络层数的增长并不会带来参数量上的爆炸,因为参数量主要集中在最后三个全连接层中。

    4、大浪推手:GoogLeNet 2014

    GoogLeNet是谷歌(Google)研究出来的深度网络结构,为什么不叫“GoogleNet”,而叫“GoogLeNet”,据说是为了向“LeNet”致敬,因此取名为“GoogLeNet”

    获得高质量模型最保险的做法就是增加模型的深度(层数)或者是其宽度(层核或者神经元数),但是这里一般设计思路的情况下会出现两个缺陷(1.参 数太多,容易过拟合,若训练数据集有限;2.网络越大计算复杂度越大,难以应用;3.网络越深,梯度越往后穿越容易消失,难以优化模型)。 googlenet的主要思想就是围绕这两个思路去做的:

    1.深度,层数更深,文章采用了22层,为了避免上述提到的梯度消失问题,googlenet巧妙的在不同深度处增加了两个loss来保证梯度回传消失的现象。

    2.宽度,增加了多种核 1x1,3x3,5x5,还有直接max pooling的,但是如果简单的将这些应用到feature map上的话,concat起来的feature map厚度将会很大,所以在googlenet中为了避免这一现象提出的inception具有如下结构,在3x3前,5x5前,max pooling后分别加上了1x1的卷积核起到了降低feature map厚度的作用。

    5、里程碑式创新:ResNet  2015

    问题:神经网络越深越好么?

    随着网络层级的不断增加模型精度不断得到提升,而当网络层级增加到一定的数目以后,训练精度和测试精度迅速下降,这说明当网络变得很深以后,深度网络就变得更加难以训练了。

    原因:

    • 梯度消失问题
    • 神经网络在反向传播过程中要不断地传播梯度,而当网络层数加深时,梯度在传播过程中会逐渐消失(假如采用Sigmoid函数,对于幅度为1的信号,每向后传递一层,梯度就衰减为原来的0.25,层数越多,衰减越厉害),导致无法对前面网络层的权重进行有效的调整。

    6、继往开来:DenseNet 2017

    dense block

    • 密集连接
    • 缓解梯度消失问题,加强特征传播,鼓励特征复用,极大的减少了参数量
    • DenseNet 是一种具有密集连接的卷积神经网络。在该网络中,任何两层之间都有直接的连接,也就是说,网络每一层的输入都是前面所有层输出的并集,而该层所学习的特征图也会被直接传给其后面所有层作为输入。下图是 DenseNet 的一个dense block示意图,一个block里面的结构如下,与ResNet中的BottleNeck基本一致:BN-ReLU-Conv(1×1)-BN-ReLU-Conv(3×3) ,而一个DenseNet则由多个这种block组成。每个DenseBlock的之间层称为transition layers,由BN−>Conv(1×1)−>averagePooling(2×2)组成

    密集连接不会带来冗余吗?

    • 答案是不会!
    • 关键在于网络每层计算量的减少以及特征的重复利用
    • 由于每一层阿包含之前所有层的输出信息,因此其只需要很少的特征图就够了,这也是为什么DneseNet的参数量较其他模型大大减少的原因。

     

     

    更多相关内容
  • 本节我们介绍卷积神经网络的基础概念,主要是卷积层和池化,并解释填充、步幅、输入通道和输出通道的含义 我们介绍卷积层的两个超参数,即填充和步幅,它们可以对给定形状的输入和卷积核改变输出形状。 二维互相关...
  • 卷积神经网络(ConvoluTIonalNeuralNetwork,CNN)是一种源于人工神经网络(NeuralNetwork,NN)的深度机器学习方法,近年来在图像识别领域取得了巨大的成功。CNN由于采用局部连接和权值共享,保持了网络的深层结构...
  • 种经典卷积神经网络

    千次阅读 2021-02-19 16:59:47
    除了卷积网络的“开篇之作”LeNet 以外,AlexNet、VGGNet、InceptionNet 以及 ResNet 这四种经典网络全部是在当年的 ImageNet 竞赛中问世的,它们作为深度学习的经典代表,使得 ImageNet 数据集上的错误率逐年降低。...

    本文使用六步法分别实现LeNet(1998)、AlexNet(2012)、VGGNet(2014)、InceptionNet(2014)、ResNet(2015)
    除了卷积网络的“开篇之作”LeNet 以外,AlexNet、VGGNet、InceptionNet 以及 ResNet 这四种经典网络全部是在当年的 ImageNet 竞赛中问世的,它们作为深度学习的经典代表,使得 ImageNet 数据集上的错误率逐年降低。

    LeNet

    LeNet 即 LeNet5,由 Yann LeCun 在 1998 年提出,做为最早的卷积神经网络之一,是许多神经网络架构的起点。

    LeNet5 网络结构

    通过共享卷积核减少网络参数。在统计卷积神经网络层数时,一般只统计卷积计算层和全连接计算层,其余操作可视为卷积的附属。LeNet共有5层卷积,两层卷积,三层连续的全连接。

    模型构建:

    C(6个5*5的卷积核,步长为1,不使用全零填充‘valid’)
    B(不使用批标准化None)
    A(使用Sigmoid激活函数)
    P(使用最大池化max,池化核2*2,步长为2,不使用全零填充‘valid’)
    D(None)
    
    C(6个5*5的卷积核,步长为1,不使用全零填充‘valid’)
    B(不使用批标准化None)
    A(使用Sigmoid激活函数)
    P(使用最大池化max,池化核2*2,步长为2,不使用全零填充‘valid’)
    D(None)
    
    Flatten(把卷积送过来的数据拉直)
    Dense(神经元:120,激活函数:sigmoid)
    Dense(神经元:84,激活函数:sigmoid)
    Dense(神经元:10,激活函数:softmax)
    

    LeNet源码

    class LeNet5(Model):
        def __init__(self):
            super(LeNet5, self).__init__()
            self.c1 = Conv2D(filters=6, kernel_size=(5, 5),
                             activation='sigmoid')
            self.p1 = MaxPool2D(pool_size=(2, 2), strides=2)
    
            self.c2 = Conv2D(filters=16, kernel_size=(5, 5),
                             activation='sigmoid')
            self.p2 = MaxPool2D(pool_size=(2, 2), strides=2)
    
            self.flatten = Flatten()
            self.f1 = Dense(120, activation='sigmoid')
            self.f2 = Dense(84, activation='sigmoid')
            self.f3 = Dense(10, activation='softmax')
    

    与最初的 LeNet5 网络结构相比,输入图像尺寸为 32 * 32 * 3,以适应 cifar10 数据集。模型中采用的激活函数有 sigmoid 和 softmax,池化层均采用最大池化,以保留边缘特征。

    总体上看,诞生于 1998 年的 LeNet5 与如今一些主流的 CNN 网络相比,其结构相当简单,不过它成功地利用“卷积提取特征→全连接分类”的经典思路解决了手写数字识别的问题,对神经网络研究的发展有着很重要的意义。

    AlexNet

    AlexNet 的总体结构和 LeNet5 有相似之处。改进之处在于AlexNet共有8层,由五层卷积、三层全连接组成,输入图像尺寸为 224 * 224 * 3,网络规模远大于 LeNet5;使用 Relu 激活函数;进行了舍弃(Dropout)操作,以防止模型过拟合,提升鲁棒性;增加了一些训练上的技巧,包括数据增强、学习率衰减、权重衰减(L2 正则化)等。

    AlexNet 的网络结构如图所示:
    AlexNet 的网络结构

    在 Tensorflow 框架下利用 Keras 来搭建 AlexNet 模型,这里做了一些调整,将输入图像尺寸改为 32 * 32 * 3 以适应 cifar10 数据集,并且将原始的 AlexNet 模型中的 11 * 11、7 * 7、5 * 5 等大尺寸卷积核均替换成了 3 * 3 的小卷积核。

    Keras 实现 AlexNet 模型:

    C(96个3*3的卷积核,步长为1,不使用全零填充‘valid’)
    B(不使用批标准化Yes,‘LRN’)
    A(使用rule激活函数)
    P(使用最大池化max,池化核3*3,步长为2)
    D(None)
    
    C(256*3*3,步长为1,不使用全零填充‘valid’)
    B(Yes,‘LRN’)
    A(使用Relu激活函数)
    P(max,3*3,步长为2)
    D(None)
    
    C(384*3*3,步长为1,全零填充‘same’)
    B(None)
    A(Relu)
    P(None)
    D(None)
    
    C(384*3*3,步长为1,全零填充‘same’)
    B(None)
    A(Relu)
    P(None)
    D(None)
    
    C(256*3*3,步长为1,全零填充‘same’)
    B(None)
    A(Relu)
    P(max,核3*3,步长为2)
    D(None)
    
    Flatten
    Dense(神经元:2048,激活函数:rule,Dropout:0.5)
    Dense(神经元:2048,激活函数:rule,Dropout:0.5)
    Dense(神经元:10,激活函数:softmax)
    

    AlexNet源码

    class AlexNet8(Model):
        def __init__(self):
            super(AlexNet8, self).__init__()
            self.c1 = Conv2D(filters=96, kernel_size=(3, 3))
            self.b1 = BatchNormalization()
            self.a1 = Activation('relu')
            self.p1 = MaxPool2D(pool_size=(3, 3), strides=2)
    
            self.c2 = Conv2D(filters=256, kernel_size=(3, 3))
            self.b2 = BatchNormalization()
            self.a2 = Activation('relu')
            self.p2 = MaxPool2D(pool_size=(3, 3), strides=2)
    
            self.c3 = Conv2D(filters=384, kernel_size=(3, 3), padding='same',
                             activation='relu')
                             
            self.c4 = Conv2D(filters=384, kernel_size=(3, 3), padding='same',
                             activation='relu')
                             
            self.c5 = Conv2D(filters=256, kernel_size=(3, 3), padding='same',
                             activation='relu')
            self.p3 = MaxPool2D(pool_size=(3, 3), strides=2)
    
            self.flatten = Flatten()
            self.f1 = Dense(2048, activation='relu')
            self.d1 = Dropout(0.5)
            self.f2 = Dense(2048, activation='relu')
            self.d2 = Dropout(0.5)
            self.f3 = Dense(10, activation='softmax')
    

    VGGNet

    在 AlexNet 之后,另一个性能提升较大的网络是诞生于 2014 年的 VGGNet,其 ImageNet Top5 错误率减小到了 7.3 %。

    VGGNet 网络的最大改进是在网络的深度上,由 AlexNet 的 8 层增加到了 16 层和 19 层,更深的网络意味着更强的表达能力,这得益于强大的运算能力支持。VGGNet 的另一个显著特点是仅使用了单一尺寸的 3 * 3 卷积核,事实上,3 * 3 的小卷积核在很多卷积网络中都被大量使用,这是由于在感受野相同的情况下,小卷积核堆积的效果要优于大卷积核,同时参数量也更少。VGGNet 就使用了 3 * 3 的卷积核替代了 AlexNet 中的大卷积核(11 * 11、7 * 7、5 * 5),取得了较好的效果(事实上课程中利用 Keras 实现 AlexNet 时已经采取了这种方式)。

    VGGNet16 和 VGGNet19 并没有本质上的区别,只是网络深度不同,前者 16 层(13 层卷积、3 层全连接),后者 19 层(16 层卷积、3 层全连接)。

    在这里插入图片描述
    根据特征图尺寸的变化,可以将 VGG16 模型分为六个部分(在 VGG16 中,每进行一次池化操作,特征图的边长缩小为 1/2,其余操作均未影响特征图尺寸)

    C(核:64*3*3,步长:1,填充:same ) 
    B(Yes)A(relu)
    
    C(核:64*3*3,步长:1,填充:same ) 
    B(Yes)A(relu)
    P(max,核:2*2,步长:2) D(0.2)
    
    C(核:128*3*3,步长:1,填充:same ) 
    B(Yes) A(relu)
    
    C(核:128*3*3,步长:1,填充:same ) 
    B(Yes) A(relu)
    P(max,核:2*2,步长:2) D(0.2)
    
    C(核:256*3*3,步长:1,填充:same ) 
    B(Yes) A(relu)
    
    C(核:256*3*3,步长:1,填充:same ) 
    B(Yes) A(relu)
    
    C(核:256*3*3,步长:1,填充:same ) 
    B(Yes) A(relu) 
    P(max,核:2*2,步长:2) D(0.2)
    
    C(核:512*3*3,步长:1,填充:same ) 
    B(Yes) A(relu)
    
    C(核:512*3*3,步长:1,填充:same ) 
    B(Yes) A(relu)
    
    C(核:512*3*3,步长:1,填充:same ) 
    B(Yes) A(relu) 
    P(max,核:2*2,步长:2) D(0.2)
    
    C(核:512*3*3,步长:1,填充:same ) 
    B(Yes) A(relu)
    
    C(核:512*3*3,步长:1,填充:same ) 
    B(Yes) A(relu)
    
    C(核:512*3*3,步长:1,填充:same ) 
    B(Yes) A(relu) 
    P(max,核:2*2,步长:2) D(0.2)
    
    Flatten
    Dense(神经元:512,激活:relu,Dropout:0.2)
    Dense(神经元:512,激活:relu,Dropout:0.2)
    Dense(神经元:10,激活:softmax)
    

    VGGNet源码

    class VGG16(Model):
        def __init__(self):
            super(VGG16, self).__init__()
            self.c1 = Conv2D(filters=64, kernel_size=(3, 3), padding='same')  # 卷积层1
            self.b1 = BatchNormalization()  # BN层1
            self.a1 = Activation('relu')  # 激活层1
            self.c2 = Conv2D(filters=64, kernel_size=(3, 3), padding='same', )
            self.b2 = BatchNormalization()  # BN层1
            self.a2 = Activation('relu')  # 激活层1
            self.p1 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
            self.d1 = Dropout(0.2)  # dropout层
    
            self.c3 = Conv2D(filters=128, kernel_size=(3, 3), padding='same')
            self.b3 = BatchNormalization()  # BN层1
            self.a3 = Activation('relu')  # 激活层1
            self.c4 = Conv2D(filters=128, kernel_size=(3, 3), padding='same')
            self.b4 = BatchNormalization()  # BN层1
            self.a4 = Activation('relu')  # 激活层1
            self.p2 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
            self.d2 = Dropout(0.2)  # dropout层
    
            self.c5 = Conv2D(filters=256, kernel_size=(3, 3), padding='same')
            self.b5 = BatchNormalization()  # BN层1
            self.a5 = Activation('relu')  # 激活层1
            self.c6 = Conv2D(filters=256, kernel_size=(3, 3), padding='same')
            self.b6 = BatchNormalization()  # BN层1
            self.a6 = Activation('relu')  # 激活层1
            self.c7 = Conv2D(filters=256, kernel_size=(3, 3), padding='same')
            self.b7 = BatchNormalization()
            self.a7 = Activation('relu')
            self.p3 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
            self.d3 = Dropout(0.2)
    
            self.c8 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
            self.b8 = BatchNormalization()  # BN层1
            self.a8 = Activation('relu')  # 激活层1
            self.c9 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
            self.b9 = BatchNormalization()  # BN层1
            self.a9 = Activation('relu')  # 激活层1
            self.c10 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
            self.b10 = BatchNormalization()
            self.a10 = Activation('relu')
            self.p4 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
            self.d4 = Dropout(0.2)
    
            self.c11 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
            self.b11 = BatchNormalization()  # BN层1
            self.a11 = Activation('relu')  # 激活层1
            self.c12 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
            self.b12 = BatchNormalization()  # BN层1
            self.a12 = Activation('relu')  # 激活层1
            self.c13 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
            self.b13 = BatchNormalization()
            self.a13 = Activation('relu')
            self.p5 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
            self.d5 = Dropout(0.2)
    
            self.flatten = Flatten()
            self.f1 = Dense(512, activation='relu')
            self.d6 = Dropout(0.2)
            self.f2 = Dense(512, activation='relu')
            self.d7 = Dropout(0.2)
            self.f3 = Dense(10, activation='softmax')
    

    总体来看,VGGNet的结构是相当规整的,它继承了 AlexNet中的Relu激活函数、Dropout操作等有效的方法,同时采用了单一尺寸的 3 * 3 小卷积核,形成了规整的 C(Convolution,卷积)、B(Batch normalization)、A(Activation,激活)、P(Pooling,池化)、D(Dropout)结构,这一典型结构在卷积神经网络中的应用是非常广的。

    InceptionNet

    InceptionNet 即 GoogLeNet,诞生于 2015 年,旨在通过增加网络的宽度来提升网络的能力,与 VGGNet 通过卷积层堆叠的方式(纵向)相比,是一个不同的方向(横向)。

    InceptionNet 基本单元
    可以看到,InceptionNet 的基本单元中,卷积部分是比较统一的 C、B、A 典型结构,即卷积→BN→激活,激活均采用 Relu 激活函数,同时包含最大池化操作。

    在 Tensorflow 框架下利用 Keras 构建 InceptionNet 模型时,可以将 C、B、A 结构封装在一起,定义成一个新的 ConvBNRelu 类,以减少代码量,同时更便于阅读。

    InceptionNet引入了Inception结构块,在同一层网络内使用不同尺寸的卷积核,提升了模型的感知力,使用了批标准化,缓解了梯度消失。

    InceptionNet的核心是它的基本单元Inception结构块,无论是GoogLeNet(Inception v1),还是InceptionNet的后续版本,例如v2、v3、v4,都是基于Inception结构块搭建的网络,Inception结构块在同一层网络中使用了多个尺寸的卷积核,可以提取不同尺寸的特征。

    分支一:
    C(核:16*1*1,步长:1,填充:same )
    B(Yes) A(relu) P(None) D(None)
    
    分支二:
    C(核:16*1*1,步长:1,填充:same )
    B(Yes) A(relu) P(None) D(None)
    
    C(核:16*3*3,步长:1,填充:same )
    B(Yes) A(relu) P(None) D(None)
    
    分支三:
    C(核:16*1*1,步长:1,填充:same )
    B(Yes) A(relu) P(None) D(None)
    
    C(核:16*5*5,步长:1,填充:same )
    B(Yes) A(relu) P(None) D(None)
    
    分支四:
    P(Max, 核:3*3, 步长:1 ,填充:same )
    
    C(核:16*1*1,步长:1,填充:same )
    B(Yes) A(relu) P(None) D(None)
    

    卷积连接器将以上四个分支按照深度方向堆叠到一起,构成Inception结构块的输出。由于Inception结构块中的卷积操作均采用了CBA结构,所以将其定义成一个新的类ConvBNRelu,可以减少代码量。

    InceptionNet源码

    class ConvBNRelu(Model):
        def __init__(self, ch, kernelsz=3, strides=1, padding='same'):
            super(ConvBNRelu, self).__init__()
            self.model = tf.keras.models.Sequential([
                Conv2D(ch, kernelsz, strides=strides, padding=padding),
                BatchNormalization(),
                Activation('relu')
            ])
    
        def call(self, x):
            x = self.model(x, training=False)
            return x
    

    Inception结构块:

    class InceptionBlk(Model):
        def __init__(self, ch, strides=1):
            super(InceptionBlk, self).__init__()
            self.ch = ch
            self.strides = strides
            self.c1 = ConvBNRelu(ch, kernelsz=1, strides=strides)
            self.c2_1 = ConvBNRelu(ch, kernelsz=1, strides=strides)
            self.c2_2 = ConvBNRelu(ch, kernelsz=3, strides=1)
            self.c3_1 = ConvBNRelu(ch, kernelsz=1, strides=strides)
            self.c3_2 = ConvBNRelu(ch, kernelsz=5, strides=1)
            self.p4_1 = MaxPool2D(3, strides=1, padding='same')
            self.c4_2 = ConvBNRelu(ch, kernelsz=1, strides=strides)
    

    InceptionNet v1 模型结构图

    参数 num_layers 代表 InceptionNet 的 Block 数,每个 Block 由两个基本单元构成,每经过一个 Block,特征图尺寸变为 1/2,通道数变为 2 倍;num_classes 代表分类数,对于 cifar10数据集来说即为 10;init_ch 代表初始通道数,也即 InceptionNet 基本单元的初始卷积核个数。

    class Inception10(Model):
        def __init__(self, num_blocks, num_classes, init_ch=16, **kwargs):
            super(Inception10, self).__init__(**kwargs)
            self.in_channels = init_ch
            self.out_channels = init_ch
            self.num_blocks = num_blocks
            self.init_ch = init_ch
            self.c1 = ConvBNRelu(init_ch)
            self.blocks = tf.keras.models.Sequential()
            # InceptionNet 的基本单元,利用之前定义好的 InceptionBlk 类堆叠而成
            for block_id in range(num_blocks):
                for layer_id in range(2):
                    if layer_id == 0:
                        block = InceptionBlk(self.out_channels, strides=2)
                    else:
                        block = InceptionBlk(self.out_channels, strides=1)
                    self.blocks.add(block)
                # enlarger out_channels per block
                self.out_channels *= 2
            self.p1 = GlobalAveragePooling2D()
            self.f1 = Dense(num_classes, activation='softmax')
    

    InceptionNet 网络不再像 VGGNet 一样有三层全连接层(全连接层的参数量占 VGGNet 总参数量的 90 %),而是采用“全局平均池化+全连接层”的方式,这减少了大量的参数。

    ResNet

    ResNet 即深度残差网络,由何恺明及其团队提出,是深度学习领域又一具有开创性的工作,通过对残差结构的运用,ResNet 使得训练数百层的网络成为了可能,从而具有非常强大的表征能力。

    在这里插入图片描述

    在残差结构中,ResNet 不再让下一层直接拟合我们想得到的底层映射,而是令其对一种残差映射进行拟合。若期望得到的底层映射为H(x),我们令堆叠的非线性层拟合另一个映射 F(x) := H(x) – x,则原有映射变为 F(x) + x。对这种新的残差映射进行优化时,要比优化原有的非相关映射更为容易。

    ResNet 中的残差结构
    ResNet 引入残差结构最主要的目的是解决网络层数不断加深时导致的梯度消失问题,从之前介绍的 4 种 CNN 经典网络结构我们也可以看出,网络层数的发展趋势是不断加深的。这是由于深度网络本身集成了低层/中层/高层特征和分类器,以多层首尾相连的方式存在,所以可以通过增加堆叠的层数(深度)来丰富特征的层次,以取得更好的效果。

    但如果只是简单地堆叠更多层数,就会导致梯度消失(爆炸)问题,它从根源上导致了函数无法收敛。然而,通过标准初始化(normalized initialization)以及中间标准化层(intermediate normalization layer),已经可以较好地解决这个问题了,这使得深度为数十层的网络在反向传播过程中,可以通过随机梯度下降(SGD)的方式开始收敛。

    但是,当深度更深的网络也可以开始收敛时,网络退化的问题就显露了出来:随着网络深度的增加,准确率先是达到瓶颈(这是很常见的),然后便开始迅速下降。需要注意的是,这种退化并不是由过拟合引起的。对于一个深度比较合适的网络来说,继续增加层数反而会导致训练错误率的提升。

    ResNet 中的残差结构

    class ResnetBlock(Model):
    
        def __init__(self, filters, strides=1, residual_path=False):
            super(ResnetBlock, self).__init__()
            self.filters = filters
            self.strides = strides
            self.residual_path = residual_path
    
            self.c1 = Conv2D(filters, (3, 3), strides=strides, padding='same', use_bias=False)
            self.b1 = BatchNormalization()
            self.a1 = Activation('relu')
    
            self.c2 = Conv2D(filters, (3, 3), strides=1, padding='same', use_bias=False)
            self.b2 = BatchNormalization()
    
            # residual_path为True时,对输入进行下采样,即用1x1的卷积核做卷积操作,保证x能和F(x)维度相同,顺利相加
            if residual_path:
                self.down_c1 = Conv2D(filters, (1, 1), strides=strides, padding='same', use_bias=False)
                self.down_b1 = BatchNormalization()
            
            self.a2 = Activation('relu')
    
    class ResNet18(Model):
        def __init__(self, block_list, initial_filters=64):  # block_list表示每个block有几个卷积层
            super(ResNet18, self).__init__()
            self.num_blocks = len(block_list)  # 共有几个block
            self.block_list = block_list
            self.out_filters = initial_filters
            self.c1 = Conv2D(self.out_filters, (3, 3), strides=1, padding='same', use_bias=False)
            self.b1 = BatchNormalization()
            self.a1 = Activation('relu')
            self.blocks = tf.keras.models.Sequential()
            # 构建ResNet网络结构
            for block_id in range(len(block_list)):  # 第几个resnet block
                for layer_id in range(block_list[block_id]):  # 第几个卷积层
    
                    if block_id != 0 and layer_id == 0:  # 对除第一个block以外的每个block的输入进行下采样
                        block = ResnetBlock(self.out_filters, strides=2, residual_path=True)
                    else:
                        block = ResnetBlock(self.out_filters, residual_path=False)
                    self.blocks.add(block)  # 将构建好的block加入resnet
                self.out_filters *= 2  # 下一个block的卷积核数是上一个block的2倍
            self.p1 = tf.keras.layers.GlobalAveragePooling2D()
            self.f1 = tf.keras.layers.Dense(10, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
    

    小结

    对于这五种网络(加上最基本的 baseline 共 6 种),其测试集准确率曲线及 Loss 曲线如下。

    LeNet5:

    在这里插入图片描述

    AlexNet8:

    在这里插入图片描述
    VGGNet16:

    在这里插入图片描述
    Inception10:

    在这里插入图片描述
    ResNet18:

    在这里插入图片描述
    随着网络复杂程度的提高,以及 Relu、Dropout、BN 等操作的使用,利用各个网络训练 cifar10 数据集的准确率基本上是逐步上升的。五个网络当中,InceptionNet 的训练效果是最不理想的,首先其本身的设计理念是采用不同尺寸的卷积核,提供不同的感受野,但 cifar10 只是一个单一的分类任务,二者的契合度并不高,另外,由于本身结构的原因,InceptionNet 的参数量和计算量都比较大,训练需要耗费的资源比较多(完整的 InceptionNet v1,即 GoogLeNet 有 22 层,训练难度很大)。

    展开全文
  • 利用基于tensorflow2的keras框架,搭建CNN卷积神经网络模型,对手写数字识别数据集mnist进行分类,网络规模小,训练精度高。网络包括三个卷积层,两个池化和全连接,在测试集上实现了99%左右的识别率。
  • 它产生了具有很少的浅层神经网络。 由于这个事实,这种类型的神经网络架构已经在这项研究工作中实现。 最近,通过引入几种类型的卷积和不同类型的激活函数,对 CNN 进行了其他一些改进。 浅层网络可以测试这些...
  • 卷积神经网络原理

    千次阅读 2022-03-23 12:33:42
    简单快速了解卷积神经网络(CNN)原理

    Convolutional Neural Network(CNN)

    • 卷积层
    • 池化层(Pooling)
    • 归一化
    • 全连接
    • 把全连接层转化成卷积层

    ConvNets

    卷积神经网络的结构基于一个假设,即输入数据是图像,基于该假设,我们就向结构中添加了一些特有的性质。这些特有属性使得前向传播函数实现起来更高效,并且大幅度降低了网络中参数的数量。

    常规神经网络

    常规神经网络,神经网络的输入是一个向量,然后在一系列的隐层中对它做变换。每个隐层都是由若干的神经元组成,每个神经元都与前一层中的所有神经元连接。
    在这里插入图片描述

    举例说来,一个尺寸为200x200x3的图像,会让神经元包含200x200x3=120,000个权重值。而网络中肯定不止一个神经元,那么参数的量就会快速增加!显而易见,这种全连接方式效率低下,大量的参数也很快会导致网络过拟合。

    ConvNets

    在这里插入图片描述

    计算机认识的图片:一个有长宽的矩阵,再加上一个通道数;在RGB图片里有3个通道,R\G\B.

    一个简单的卷积神经网络是由各种层按照顺序排列组成,网络中的每个层使用一个可以微分的函数将激活数据从一个层传递到另一个层。卷积神经网络主要由三种类型的层构成:卷积层,池化(Pooling)层和全连接层(全连接层和常规神经网络中的一样)。通过将这些层叠加起来,就可以构建一个完整的卷积神经网络。

    卷积层

    卷积层是构建卷积神经网络的核心层,它产生了网络中大部分的计算量。

    如何简化计算?
    • 让不同的神经元守备不同区域
    • 共享参数
    input
    41008102
    41018002
    41008102
    40018202
    40008002
    41018102
    filter
    010
    010
    010

    在这里插入图片描述

    在前向传播的时候,让每个filter都在输入数据的宽度和高度上滑动(更精确地说是卷积),然后计算整个filter和输入数据任一处的内积。当filter沿着输入数据的宽度和高度滑过后,会生成一个2维的激活图(activation map),激活图给出了在每个空间位置处Receptive field的反应。直观地来说,网络会让filter学习到当它看到某些类型的视觉特征时就激活,具体的视觉特征可能是某些方位上的边界,或者在第一层上某些颜色的斑点.

    在这里插入图片描述

    一个channel的卷积

    在这里插入图片描述

    在每个卷积层上,我们会有一排的filter(比如16个、32、64个,需要多少个,自己定,你开心就好),每个都会生成一个不同的二维激活图。将这些激活映射在深度方向上层叠起来就生成了输出数据。

    在这里插入图片描述

    例如,在100 * 100 * 3的输入下,我定了第一层的 filter 为64个,stride=1,那么输出将是 98 * 98 * 64的矩阵

    一个filter就是一个神经元,当它滑向下一区域时,就相当于切换到下一区域的神经元,这些神经元共享同一组参数也就是filter里的参数,你定了64个filter那么将有64组filter分别扫过一整张图片.

    动画演示

    https://cs231n.github.io/assets/conv-demo/index.html

    例1:假设输入数据体尺寸为[32x32x3](比如CIFAR-10的RGB图像),如果Receptive field是5x5,那么卷积层中的每个神经元会有输入数据体中[5x5x3]区域的权重,共5x5x3=75个权重(还要加一个偏差参数)。注意这个连接在深度维度上的大小必须为3,和输入数据体的深度一致。

    例2:假设输入数据体的尺寸是[16x16x20],filter尺寸是3x3,那么卷积层中每个神经元和输入数据体就有3x3x20=180个连接。再次提示:在空间上连接是局部的(3x3),但是在深度上是和输入数据体一致的(20)。

    怎么控制输出数据?

    3个超参数控制着输出数据体的尺寸:深度(depth),步长(stride)和填充(padding)。

    • 首先,输出数据体的深度是一个超参数:它和使用的filter的数量一致,而每个filter在输入数据中寻找一些不同的东西。举例来说,如果第一个卷积层的输入是原始图像,那么在深度维度上的不同神经元将可能被不同方向的边界,或者是颜色斑点激活。我们将这些沿着深度方向排列、filter相同的神经元集合称为深度列(depth column),也有人使用纤维(fibre)来称呼它们。
    • 其次,在滑动filter的时候,必须指定步长。当步长为1,滤波器每次移动1个像素。当步长为2(或者不常用的3,或者更多,这些在实际中很少使用),filter滑动时每次移动2个像素。这个操作会让输出数据体在空间上变小。
    • 在下文可以看到,有时候将输入数据体用0在边缘处进行填充是很方便的。这个零填充(zero-padding)的尺寸是一个超参数。零填充有一个良好性质,即可以控制输出数据体的空间尺寸(最常用的是用来保持输入数据体在空间上的尺寸,这样输入和输出的宽高都相等)(你可以用0填充,也可以用均值填充,根据需求,你喜欢就好)。

    如何抓取特征

    在这里插入图片描述

    当图片上出现与filter相似的特征时,输出的值会有明显变化,训练时根据这种变化,网络会调整参数,让filter记住这个特征.

    池化层

    在这里插入图片描述

    为了控制数据体的大小,通常,在连续的卷积层之间会周期性地插入一个池化层。这样的话就能减少网络中参数的数量,使得计算资源耗费变少,也能有效控制过拟合。池化层使用MAX操作(不一定非要MAX Pooling也可以mean等等,你喜欢),对输入数据体的每一个深度切片独立进行操作,改变它的空间尺寸。最常见的形式是池化层使用尺寸2x2的filter,以步长为2来对每个深度切片进行降采样,将其中75%的激活信息都丢掉。每个MAX操作是从4个数字中取最大值(也就是在深度切片中某个2x2的区域)。深度保持不变。

    在这里插入图片描述

    是不是一定非要用池化层?

    答案是否定的。不是非得用池化,我用池化就一定好。举个栗子,Alpha Go论文中有提到,网络是19 * 19的输入,而恰巧围棋棋盘就是19*19路,Alpha Go设计者就把每一步棋子在棋盘的位置当成一张图片,那么网络就可以用CNN,而确实是用的CNN,那么在这上面使用池化的话会发生什么?会丢了棋子信息,因为每一个棋子都会影响棋局的走势,所有不能丢失任一处的棋子信息。

    归一化层

    在卷积神经网络的结构中,提出了很多不同类型的归一化层,有时候是为了实现在生物大脑中观测到的抑制机制。但是这些层渐渐都不再流行,因为实践证明它们的效果即使存在,也是极其有限的。

    全连接层

    在全连接层中,神经元对于前一层中的所有激活数据是全部连接的,这个常规神经网络中一样。

    在这里插入图片描述

    网络结构

    卷积神经网络通常是由三种层构成:卷积层,池化层(除非特别说明,一般就是最大值池化)和全连接层(简称FC)。ReLU激活函数也应该算是是一层,它逐元素地进行激活函数操作。在本节中将讨论在卷积神经网络中这些层通常是如何组合在一起的。

    层的排列规律

    卷积神经网络最常见的形式就是将一些卷积层和ReLU层放在一起,其后紧跟池化层,然后重复如此直到图像在空间上被缩小到一个足够小的尺寸,在某个地方过渡成成全连接层也较为常见。最后的全连接层得到输出,比如分类评分等。

    • INPUT -> FC,实现一个线性分类器,此处N = M = K = 0。
    • INPUT -> CONV -> RELU -> FC
    • INPUT -> [CONV -> RELU -> POOL]*2 -> FC -> RELU -> FC。此处在每个汇聚层之间有一个卷积层。
    • INPUT -> [CONV -> RELU -> CONV -> RELU -> POOL]*3 -> [FC -> RELU]*2 -> FC。此处每个汇聚层前有两个卷积层,这个思路适用于更大更深的网络,因为在执行具有破坏性的池化操作前,多重的卷积层可以从输入数据中学习到更多的复杂特征。

    层的尺寸设置规律

    • 输入层(包含图像的)应该能被2整除很多次。常用数字包括32(比如CIFAR-10),64,96(比如STL-10)或224(比如ImageNet卷积神经网络),384和512。
    • 卷积层 应该使用小尺寸滤波器(比如3x3或最多5x5),使用步长1 。还有一点非常重要,就是对输入数据进行零填充,这样卷积层就不会改变输入数据在空间维度上的尺寸。
    • 池化层 负责对输入数据的空间维度进行降采样。最常用的设置是用用2x2Receptive field的最大值池化,步长为2。注意这一操作将会把输入数据中75%的激活数据丢弃(因为对宽度和高度都进行了2的降采样)。 另一个不那么常用的设置是使用3x3的Receptive field,步长为2。最大值池化的Receptive field尺寸很少有超过3的,因为池化操作过于激烈,易造成数据信息丢失,这通常会导致算法性能变差。

    减少尺寸设置的问题:上文中展示的两种设置是很好的,因为所有的卷积层都能保持其输入数据的空间尺寸,汇聚层只负责对数据体从空间维度进行降采样。如果使用的步长大于1并且不对卷积层的输入数据使用零填充,那么就必须非常仔细地监督输入数据体通过整个卷积神经网络结构的过程,确认所有的步长和滤波器都尺寸互相吻合

    为什么在卷积层使用1的步长? 在实际应用中,更小的步长效果更好。上文也已经提过,步长为1可以让空间维度的降采样全部由汇聚层负责,卷积层只负责对输入数据体的深度进行变换。
    为何使用零填充? 使用零填充除了前面提到的可以让卷积层的输出数据保持和输入数据在空间维度的不变,还可以提高算法性能。如果卷积层值进行卷积而不进行零填充,那么数据体的尺寸就会略微减小,那么图像边缘的信息就会过快地损失掉。

    网络结构例子:

    一个用于CIFAR-10图像数据分类的卷积神经网络的结构可以是[输入层-卷积层-ReLU层-汇聚层-全连接层]。细节如下:

    • 输入[32x32x3]存有图像的原始像素值,本例中图像宽高均为32,有3个颜色通道。
    • 卷积层中,神经元与输入层中的一个局部区域相连,每个神经元都计算自己与输入层相连的小区域与自己权重的内积。卷积层会计算所有神经元的输出。如果我们使用12个滤波器(也叫作核),得到的输出数据体的维度就是[32x32x12]。
    • ReLU层将会逐个元素地进行激活函数操作,比如使用以0为阈值的 作为激活函数。该层对数据尺寸没有改变,还是[32x32x12]。
    • 池化层在在空间维度(宽度和高度)上进行降采样(downsampling)操作,数据尺寸变为[16x16x12]。
    • 全连接层将会计算分类评分,数据尺寸变为[1x1x10],其中10个数字对应的就是CIFAR-10中10个类别的分类评分值。正如其名,全连接层与常规神经网络一样,其中每个神经元都与前一层中所有神经元相连接。

    由此看来,卷积神经网络一层一层地将图像从原始像素值变换成最终的分类评分值。其中有的层含有参数,有的没有。具体说来,卷积层和全连接层(CONV/FC)对输入执行变换操作的时候,不仅会用到激活函数,还会用到很多参数(神经元的突触权值和偏差)。而ReLU层和汇聚层则是进行一个固定不变的函数操作。卷积层和全连接层中的参数会随着梯度下降被训练,这样卷积神经网络计算出的分类评分就能和训练集中的每个图像的标签吻合了。

    小结:
    • 简单案例中卷积神经网络的结构,就是一系列的层将输入数据变换为输出数据(比如分类评分)。
    • 卷积神经网络结构中有几种不同类型的层(目前最流行的有卷积层、全连接层、ReLU层和汇聚层)。
    • 每个层的输入是3D数据,然后使用一个可导的函数将其变换为3D的输出数据。
    • 有的层有参数,有的没有(卷积层和全连接层有,ReLU层和汇聚层没有)。

    案例学习

    下面是卷积神经网络领域中比较有名的几种结构:

    • LeNet: 第一个成功的卷积神经网络应用,是Yann LeCun在上世纪90年代实现的。当然,最著名还是被应用在识别数字和邮政编码等的LeNet结构。
    • AlexNet: AlexNet卷积神经网络在计算机视觉领域中受到欢迎,它由Alex Krizhevsky,Ilya Sutskever和Geoff Hinton实现。AlexNet在2012年的ImageNet ILSVRC 竞赛中夺冠,性能远远超出第二名(16%的top5错误率,第二名是26%的top5错误率)。这个网络的结构和LeNet非常类似,但是更深更大,并且使用了层叠的卷积层来获取特征(之前通常是只用一个卷积层并且在其后马上跟着一个汇聚层)。
    • ZF Net: Matthew Zeiler和Rob Fergus发明的网络在ILSVRC 2013比赛中夺冠,它被称为ZFNet(Zeiler &Fergus Net的简称)。它通过修改结构中的超参数来实现对AlexNet的改良,具体说来就是增加了中间卷积层的尺寸,让第一层的步长和滤波器尺寸更小。
    • GoogLeNet: ILSVRC 2014的胜利者是谷歌的Szeged等实现的卷积神经网络。它主要的贡献就是实现了一个奠基模块,它能够显著地减少网络中参数的数量(AlexNet中有60M,该网络中只有4M)。还有,这个论文中没有使用卷积神经网络顶部使用全连接层,而是使用了一个平均汇聚,把大量不是很重要的参数都去除掉了。GooLeNet还有几种改进的版本,最新的一个是Inception-v4。
    • VGGNet: ILSVRC 2014的第二名是Karen Simonyan和 Andrew Zisserman实现的卷积神经网络,现在称其为VGGNet。它主要的贡献是展示出网络的深度是算法优良性能的关键部分。他们最好的网络包含了16个卷积/全连接层。网络的结构非常一致,从头到尾全部使用的是3x3的卷积和2x2的汇聚。他们的预训练模型是可以在网络上获得并在Caffe中使用的。VGGNet不好的一点是它耗费更多计算资源,并且使用了更多的参数,导致更多的内存占用(140M)。其中绝大多数的参数都是来自于第一个全连接层。后来发现这些全连接层即使被去除,对于性能也没有什么影响,这样就显著降低了参数数量。
    • ResNet: 残差网络(Residual Network)是ILSVRC2015的胜利者,由何恺明等实现。它使用了特殊的跳跃链接,大量使用了批量归一化(batch normalization)。这个结构同样在最后没有使用全连接层。读者可以查看何恺明的的演讲(视频,PPT),以及一些使用Torch重现网络的实验。ResNet当前最好的卷积神经网络模型(2016年五月)。何开明等最近的工作是对原始结构做一些优化,可以看论文 Identity Mappings in Deep Residual Networks,2016年3月发表。

    把全连接层转化成卷积层(摘自CS231n课程笔记翻译:卷积神经网络笔记)

    全连接层和卷积层之间唯一的不同就是卷积层中的神经元只与输入数据中的一个局部区域连接,并且在卷积列中的神经元共享参数。然而在两类层中,神经元都是计算点积,所以它们的函数形式是一样的。因此,将此两者相互转化是可能的:

    • 对于任一个卷积层,都存在一个能实现和它一样的前向传播函数的全连接层。权重矩阵是一个巨大的矩阵,除了某些特定块(这是因为有局部连接),其余部分都是零。而在其中大部分块中,元素都是相等的(因为参数共享)。
    • 相反,任何全连接层都可以被转化为卷积层。比如,一个 的全连接层,输入数据体的尺寸是,这个全连接层可以被等效地看做一个的 卷积层。换句话说,就是将滤波器的尺寸设置为和输入数据体的尺寸一致了。因为只有一个单独的深度列覆盖并滑过输入数据体,所以输出将变成 ,这个结果就和使用初始的那个全连接层一样了。

    全连接层转化为卷积层:在两种变换中,将全连接层转化为卷积层在实际运用中更加有用。假设一个卷积神经网络的输入是224x224x3的图像,一系列的卷积层和汇聚层将图像数据变为尺寸为7x7x512的激活数据体(在AlexNet中就是这样,通过使用5个汇聚层来对输入数据进行空间上的降采样,每次尺寸下降一半,所以最终空间尺寸为224/2/2/2/2/2=7)。从这里可以看到,AlexNet使用了两个尺寸为4096的全连接层,最后一个有1000个神经元的全连接层用于计算分类评分。我们可以将这3个全连接层中的任意一个转化为卷积层:

    • 针对第一个连接区域是[7x7x512]的全连接层,令其滤波器尺寸为 ,这样输出数据体就为[1x1x4096]了。
    • 针对第二个全连接层,令其滤波器尺寸为 ,这样输出数据体为[1x1x4096]。
    • 对最后一个全连接层也做类似的,令其 ,最终输出为[1x1x1000]

    实际操作中,每次这样的变换都需要把全连接层的权重W重塑成卷积层的滤波器。那么这样的转化有什么作用呢?
    它在下面的情况下可以更高效:让卷积网络在一张更大的输入图片上滑动(译者注:即把一张更大的图片的不同区域都分别带入到卷积网络,得到每个区域的得分),得到多个输出,这样的转化可以让我们在单个向前传播的过程中完成上述的操作。

    举个例子,如果我们想让224x224尺寸的浮窗,以步长为32在384x384的图片上滑动,把每个经停的位置都带入卷积网络,最后得到6x6个位置的类别得分。上述的把全连接层转换成卷积层的做法会更简便。如果224x224的输入图片经过卷积层和汇聚层之后得到了[7x7x512]的数组,那么,384x384的大图片直接经过同样的卷积层和汇聚层之后会得到[12x12x512]的数组(因为途径5个汇聚层,尺寸变为384/2/2/2/2/2 = 12)。然后再经过上面由3个全连接层转化得到的3个卷积层,最终得到[6x6x1000]的输出(因为(12 - 7)/1 + 1 = 6)。这个结果正是浮窗在原图经停的6x6个位置的得分!(译者注:这一段的翻译与原文不同,经过了译者较多的修改,使更容易理解)

    面对384x384的图像,让(含全连接层)的初始卷积神经网络以32像素的步长独立对图像中的224x224块进行多次评价,其效果和使用把全连接层变换为卷积层后的卷积神经网络进行一次前向传播是一样的。

    自然,相较于使用被转化前的原始卷积神经网络对所有36个位置进行迭代计算,使用转化后的卷积神经网络进行一次前向传播计算要高效得多,因为36次计算都在共享计算资源。这一技巧在实践中经常使用,一次来获得更好的结果。比如,通常将一张图像尺寸变得更大,然后使用变换后的卷积神经网络来对空间上很多不同位置进行评价得到
    分类评分,然后在求这些分值的平均值。

    最后,如果我们想用步长小于32的浮窗怎么办?用多次的向前传播就可以解决。比如我们想用步长为16的浮窗。那么先使用原图在转化后的卷积网络执行向前传播,然后分别沿宽度,沿高度,最后同时沿宽度和高度,把原始图片分别平移16个像素,然后把这些平移之后的图分别带入卷积网络。(译者注:这一段的翻译与原文不同,经过了译者较多的修改,使更容易理解)

    参考台湾大学李宏毅老师的机器学习课程
    参考由杜客和猴子翻译,堃堃和李艺颖进行校对修改的cs231n笔记。来自网址:https://zhuanlan.zhihu.com/p/22038289
    图片分别平移16个像素,然后把这些平移之后的图分别带入卷积网络。(译者注:这一段的翻译与原文不同,经过了译者较多的修改,使更容易理解)
    
    
    

    参考台湾大学李宏毅老师的机器学习课程
    参考由杜客和猴子翻译,堃堃和李艺颖进行校对修改的cs231n笔记。来自网址:https://zhuanlan.zhihu.com/p/22038289

    2021-6-15
    
    展开全文
  • 卷积神经网络基础知识

    千次阅读 2022-04-10 14:12:13
    卷积神经网络基础知识:输入输出、网络结构、损失函数和评价指标。

    1 卷积神经网络是什么?

    卷积神经网络(Convolution Neural Network)可以简单理解为包含卷积操作且具有深度结构的网络,通过权值共享局部连接的方式对数据进行特征提取并进行预测的过程。在实际应用中往往采用多层网络结构,因此又被称为深度卷积神经网络。卷积神经网络通过反馈修正卷积核和偏置参数使输出与预测偏差减小。所以,构建卷积神经网络进行深度学习开发其实并不复杂。可以从四个方面展开:输入输出、网络结构、损失函数、评价指标

    2 卷积神经网络的输入输出

    卷积神经网络的输入分为两部分,一是数据,二是标签。针对计算机视觉任务来说,通常数据指的是图像数据。标签是针对图像的真实值,针对不同任务有着不同的标签,例如图像分类任务的标签是图像的类别,目标检测任务的标签是图像中的目标的类别和坐标信息等。这类标签信息一般通过人工标定方式(或者自动标定工具)生成。例如VIA标注工具

    3、卷积神经网络的网络结构

    卷积神经网络的基本结构由以下几个部分组成:输入层(input layer)卷积层(convolution layer)池化层(pooling layer)激活函数层全连接层(full-connection layer)。下面以图像分类任务简单介绍一下卷积神经网络结构,具体结构如下图所示。
    在这里插入图片描述

    3.1 输入层

    图像分类任务是输入层是 H ∗ W ∗ C H*W*C HWC的图像,其中H是指图像的长度,W是图像的宽度,C指的是图像的channel数,一般灰度图的channel数为1,彩色图的channel数为3。

    3.2 卷积层

    卷积神经网络的核心是卷积层,卷积层的核心部分是卷积操作。
    卷积层有四个重要的超参数:卷积核的大小F、卷积核的个数K、卷积的步长S和零填充数量P。
    假设输入的参数为: H × W × D H×W×D H×W×D的一个Tensor,则经过一个大小为、个数为K,步长为S和零填充数量为P的卷积操作后输出的参数为:

    H ′ = ( H − F + 2 P ) / S + 1 W ′ = ( W − F + 2 P ) / S + 1 D ′ = K \begin{matrix}H' = (H-F+2P)/S+1 \\W' = (W-F+2P)/S+1 \\ D'=K \end{matrix} H=(HF+2P)/S+1W=(WF+2P)/S+1D=K
    关于卷积计算可以参考这篇文章,我的下面图片就引自该问文,链接: 原来卷积是这么计算的_月来客栈
    其中卷积层的操作可分为四种,分别为:

    • 单输入单输出(输入channel数为1,且只有1个卷积核)
    • 单输入多输出(输入channel数为1,并有n(n>1)个卷积核)
    • 多输入单输出(输入channel数>1,只有1个卷积核)
    • 多输入多输出(输入channel数>1,并有n(n>1)个卷积核)

    3.2.1 单输入单输出

    channel数为1的图像的单一卷积核的计算过程如下图所示:
    在这里插入图片描述
    具体计算过程如下图:
    在这里插入图片描述
    channel数为3的图像的单一卷积核的计算过程如下图所示:
    在这里插入图片描述
    具体计算过程如下图:
    在这里插入图片描述
    channel数为3的图像的多卷积核的计算过程如下图所示:
    在这里插入图片描述
    计算得到的结果如下图:
    在这里插入图片描述

    3.3 池化层

    池化操作将输入矩阵某一位置相邻区域的总体统计特征作为该位置的输出,主要有平均池化(Average Pooling)、最大池化(Max Pooling)等。卷积的作用为:对每一个特征响应图独立进行, 降低特征响应图组中每个特征响应图的宽度和高度,减少后续卷积层的参数的数量, 降低计算资源耗费,进而控制过拟合,简单来说池化就是在该区域上指定一个值来代表整个区域
    池化层的超参数:池化窗口和池化步长。
    池化操作也可以看做是一种卷积操作,下面我们以最大池化来解释池化操作,具体操作如下图所示:
    在这里插入图片描述

    3.4 激活函数层

    激活函数(非线性激活函数,如果激活函数使用线性函数的话,那么它的输出还是一个线性函数。)但使用非线性激活函数可以得到非线性的输出值。常见的激活函数有Sigmoid、tanh和Relu等。一般我们使用Relu作为卷积神经网络的激活函数。
    Relu激活函数提供了一种非常简单的非线性变换方法,它的公式为:
    f ( u ) = m a x ( 0 , u ) f(u)= max(0,u) f(u)=max(0,u)
    函数图像如下所示:
    在这里插入图片描述
    ReLU激活函数相比Sigmoid、tanh等有的优点为:
    1、速度快,和sigmoid函数需要计算指数和倒数相比,relu函数其实就是一个 m a x ( 0 , u ) max(0,u) max(0,u),计算代价小。
    2、稀疏性,通过对大脑的研究发现,大脑在工作的时候只有大约5%的神经元是激活的,而采用sigmoid激活函数的激活率大约是50%。有论文声称人工神经网络在15%-30%的激活率时是比较理想的。因为Relu函数在输入小于0时是完全不激活的,因此可以获得一个更低的激活率。
    3、ReLU的求导特性也非常的好。当输⼊为负时, ReLU函数的导数为0,⽽当输⼊为正时, ReLU函数的导数为1。这就意味着要么让参数消失,要么让参数通过。并且ReLU减轻了困扰以往神经⽹络的梯度消失问题。
    注意: ReLU函数有许多变体,包括参数化ReLU(Parameterized ReLU, pReLU)函数。该变体为ReLU增减了一个线性项,因此即使参数是负的,某些信息仍然可以通过:
    p R e L U = m a x ( 0 , x ) + α m i n ( 0 , x ) pReLU = max(0,x)+\alpha min(0,x) pReLU=max(0,x)+αmin(0,x)

    3.5 全连接层

    全连接层在卷积神经网络中起到分类器的作用,如果说卷积层、池化层和激活函数层等操作是将原始数据映射到隐层特征空间的话,全连接层则起到将学到的“分布式特征表示”映射到样本标记空间的作用。

    3 卷积神经网络的损失函数

    在卷积神经网络中,我们会使用如梯度下降法(Gradient Descent) 等方法去最小化目标函数。但怎样来衡量优化目标函数的好坏呢,这就用到了损失函数。卷积神经网络中损失函数是用于衡量模型所作出的预测值和真实值(Ground Truth)之间的偏离程度,大致可分为两种:分类损失(针对离散型量)和回归损失(针对连续型变量)。

    3.1分类损失

    3.1.1 熵(Entropy)

    即“熵”,熵的概念最早起源于物理学,用于度量一个热力学系统的无序程度。在信息论里面, 熵是用于描述对事件不确定性的度量,它的计算公式如下:
    E n t r o p y , H ( p ) = − Σ p ( x i ) ∗ l o g 2 ( p ( x i ) ) Entropy,H(p) = -\varSigma p(x_i)*log_2(p(x_i)) Entropy,H(p)=Σp(xi)log2(p(xi))
    其中 p ( i ) p(i) p(i)为事件的概率分布,下面以一个例子来解释一下该公式。
    假设气象台告知我们明天晴天的概率为25%,下雨的概率为75%,则气象站传输给我们的信息熵为:
    − ( 0.25 ∗ l o g 2 ( 0.25 ) + 0.75 ∗ l o g 2 ( 0.75 ) ) = 0.81 -(0.25*log2(0.25) + 0.75*log2(0.75)) =0.81 (0.25log2(0.25)+0.75log2(0.75))=0.81
    如下图所示:
    在这里插入图片描述
    在卷积神经网络中,比如分类任务中,其实也是在做一个判断一个物体到底是不是属于某个类别,其中不确定性就越大,其信息量越大,它的熵值就越高。

    3.1.2 相对熵

    相对熵又称KL散度,用于衡量对于同一个随机变量x的两个分布p(x)和q(x)之间的差异。在机器学习中,p(x)常用于描述样本的真实分布,例如[1,0,0,0]表示样本属于第一类,而q(x)则常常用于表示预测的分布,例如[0.7,0.1,0.1,0.1]。显然使用q(x)来描述样本不如p(x)准确,q(x)需要不断地学习来拟合准确的分布p(x)。
    KL散度的计算公式为:
    D K L ( p ∣ ∣ q ) = ∑ i = 1 n p ( x i ) l o g 2 ( p ( x i ) q ( x i ) ) D_{KL}(p||q) = \displaystyle\sum_{i=1}^n p(x_i) log_2(\frac {p(x_i)} {q(x_i)}) DKL(pq)=i=1np(xi)log2(q(xi)p(xi))
    KL散度的值越小表示两个分布越接近。

    3.1.3 交叉熵(Cross Entropy)

    我们将KL散度的公式进行变形,得到:
    D K L ( p ∣ ∣ q ) = ∑ i = 1 n p ( x i ) l o g 2 ( p ( x i ) ) − ∑ i = 1 n p ( x i ) l o g 2 ( q ( x i ) ) = − H ( p ( x ) ) + [ − ∑ i = 1 n p ( x i ) l o g 2 ( q ( x i ) ) ] D_{KL}(p||q) = \displaystyle\sum_{i=1}^n p(x_i) log_2(p(x_i))- \displaystyle\sum_{i=1}^n p(x_i) log_2(q(x_i)) =-H(p(x))+[-\displaystyle\sum_{i=1}^n p(x_i) log_2(q(x_i))] DKL(pq)=i=1np(xi)log2(p(xi))i=1np(xi)log2(q(xi))=H(p(x))+[i=1np(xi)log2(q(xi))]

    前半部分就是p(x)的熵,它是一个定值,后半部分就是我们的交叉熵:
    C r o s s E n t r o p y , H ( p , q ) = − ∑ i = 1 n p ( x i ) l o g 2 ( q ( x i ) ) Cross Entropy,H(p,q) = -\displaystyle\sum_{i=1}^n p(x_i) log_2(q(x_i)) CrossEntropy,H(p,q)=i=1np(xi)log2(q(xi))
    我们常常使用KL散度来评估predict和label之间的差别,但是由于KL散度的前半部分是一个常量,所以我们常常将后半部分的交叉熵作为损失函数。假设我们当前做一个3个类别的图像分类任务,如猫、狗、猪。给定一张输入图片其真实类别是猫,模型通过训练用Softmax分类后的输出结果为:{“cat”: 0.3, “dog”: 0.45, “pig”: 0.25},那么此时交叉熵为:-1 * log(0.3) = 1.203。当输出结果为:{“cat”: 0.5, “dog”: 0.3, “pig”: 0.2}时,交叉熵为:-1 * log(0.5) = 0.301。可以发现,当预测值接近真实值时,损失将接近0。

    3.2 回归损失(Regression Loss)

    3.2.1 L1损失

    也称为Mean Absolute Error,即平均绝对误差(MAE),它衡量的是预测值与真实值之间距离的平均误差幅度,作用范围为0到正无穷。其公式如下:
    l o s s = ∑ i = 1 n ∣ y i − y ^ i ∣ loss = \displaystyle\sum_{i=1}^n|y_i - \hat y_i| loss=i=1nyiy^i

    3.2.2 L2损失

    也称为Mean Squred Error,即均方差(MSE),它衡量的是预测值与真实值之间距离的平方和,作用范围同为0到正无穷。其公式如下:
    l o s s = ∑ i = 1 n ( y i − y ^ i ) 2 loss = \displaystyle\sum_{i=1}^n(y_i - \hat y_i)^2 loss=i=1n(yiy^i)2

    3.2.3 L1与L2损失函数对比

    L1损失函数相比于L2损失函数的鲁棒性更好,因为L2将误差平方化(如果误差大于1,则误差会放大很多),模型的误差会比L1范数大的多,因此模型会对这种类型的样本更加敏感,这就需要调整模型来最小化误差。
    但L2收敛速度快,能够对梯度给予合适的惩罚权重,而不是“一视同仁”,使梯度更新的方向可以更加精确。

    3.2.4 Smooth L1损失

    即平滑的L1损失(SLL),出自Fast RCNN。SLL通过综合L1和L2损失的优点,在0点处附近采用了L2损失中的平方函数,解决了L1损失在0点处梯度不可导的问题,使其更加平滑易于收敛。此外,在|x|>1的区间上,它又采用了L1损失中的线性函数,使得梯度能够快速下降。
    s m o o t h L ( x ) = x = { 0.5 x 2 if  ∣ x ∣ < 1 ∣ x ∣ − 0.5 otherwise smooth_L(x) = x = \begin{cases} 0.5x^2 &\text{if } |x|<1 \\ |x|-0.5 &\text{otherwise} \end{cases} smoothL(x)=x={0.5x2x0.5if x<1otherwise

    4 卷积神经网络的评价指标

    评价指标是用来定量衡量模型的性能的,是作为各种模型比较的一个标准。卷积神经网络评价指标分为分类任务评价指标回归任务评价指标

    4.1 分类任务评价指标

    4.1.1 准确率/召回率/精确度/F1-score

    混淆矩阵是最基础的概念,也是最重要的概念。混淆矩阵如下表所示:

    正例(预测值)反例(预测值)
    正例(真实值)TP(True Positive)FN(False Negative)
    反例(真实值)FP(False Positive)TN(True Negative)

    准确率(Accuracy):
    A c c u r a c y = ( T P + T N ) ( T P + F N + F P + T N ) = 预 测 正 确 样 本 数 总 的 样 本 数 Accuracy = \frac {(TP+TN)} {(TP+FN+FP+TN)} = \frac {预测正确样本数}{总的样本数} Accuracy=(TP+FN+FP+TN)(TP+TN)=
    精确度:
    P r e c i s i o n = T P T P + F P = 预 测 正 确 的 正 样 本 数 预 测 为 正 的 样 本 数 Precision = \frac {TP}{TP+FP} =\frac {预测正确的正样本数}{预测为正的样本数} Precision=TP+FPTP=

    P r e c i s i o n = T N T N + F N = 预 测 正 确 的 正 样 本 数 预 测 为 负 的 样 本 数 Precision = \frac{TN}{TN+FN} =\frac {预测正确的正样本数}{预测为负的样本数} Precision=TN+FNTN=

    召回率:
    R e c a l l = T P T P + F N = 预 测 正 确 的 正 样 本 数 真 实 标 签 为 正 确 的 样 本 数 Recall = \frac {TP}{TP+FN} = \frac {预测正确的正样本数}{真实标签为正确的样本数} Recall=TP+FNTP=
    F1-score:
    F 1 s c o r e = 2 ∗ P r e c i s i o n ∗ R e c a l l P r e c i s i o n + R e c a l l F1score = \frac {2*Precision*Recall }{Precision+Recall } F1score=Precision+Recall2PrecisionRecall

    4.1.2 Precision/Recall(P-R)曲线

    Precision/Recall曲线也叫做P-R曲线,其代表的是精准率(查准率)与召回率(查全率)的关系,Precision与Recall是一对矛盾的变量。如下图所示:
    在这里插入图片描述
    其中,曲线与坐标值面积越大,性能越好(能更大的提升精确度和召回率);但是有时面积不好计算,那么就选择 y = x y = x y=x与P-R曲线的交点也叫作平衡点(BEP)比较BEP,越大的学习器越优。
    但PR曲线对正负样本不均衡问题较敏感。

    4.1.3 ROC曲线

    ROC曲线的横坐标是false positive rate(FPR):
    F P R = F P F P + T N = 将 反 例 预 测 为 正 例 的 样 本 数 标 签 为 反 的 样 本 数 FPR = \frac {FP}{FP+TN} = \frac {将反例预测为正例的样本数}{标签为反的样本数} FPR=FP+TNFP=
    纵坐标为true positive rate(TPR):
    T P R = T P T P + F N = 将 正 例 预 测 为 正 例 的 样 本 数 标 签 为 正 的 样 本 数 TPR = \frac {TP}{TP+FN} = \frac {将正例预测为正例的样本数}{标签为正的样本数} TPR=TP+FNTP=
    在这里插入图片描述
    其中ROC曲线对正负样本不均衡问题不敏感。

    4.2回归任务评价指标

    4.2.1 IOU(Intersection-over-Union)交并比

    IOU多用于检测、分割任务中,它的计算公式如下所示:
    在这里插入图片描述

    I O U = A ⋂ B A ⋃ B IOU = \frac {A \bigcap B}{A \bigcup B} IOU=ABAB

    4.2.2 AP

    PR曲线下的面积就定义为AP,由于计算积分相对困难,因此引入插值法,计算AP公式如下:
    A P = ∑ k = 1 N max ⁡ k ′ ≥ k P ( k ′ ) Δ r ( k ) AP= \displaystyle\sum_{k=1}^N \max _{ k' \geq k}P(k') \varDelta{ r(k)} AP=k=1NkkmaxP(k)Δr(k)
    在这里插入图片描述
    计算面积:
    在这里插入图片描述
    计算公式:
    在这里插入图片描述

    5 总结

    在这篇文章中,亦岚君首先引入了卷积的四个主要知识:输入输出、网络结构、损失函数和评价指标。然后围绕着这五个问题依次做了简单介绍。本次内容就到此结束,感谢您的阅读!如果你觉得上述内容对你有所帮助,欢迎关注并传播本文!
    在这里插入图片描述

    展开全文
  • 卷积神经网络的组成卷积神经网络中,有3种最主要的:卷积运算、pooling 、全连接。一个完整的神经网络就是由这三种叠加组成的。 (1)一个卷积神经网络由多种不同类型的(卷几/全连接/RELU ...
  • 卷积神经网络超详细介绍

    万次阅读 多人点赞 2018-09-19 10:16:59
    1、卷积神经网络的概念 2、 发展过程 3、如何利用CNN实现图像识别的任务 4、CNN的特征 5、CNN的求解 6、卷积神经网络注意事项 7、CNN发展综合介绍 8、LeNet-5结构分析 9、AlexNet 10、ZFNet 10.1 意义 ...
  • 几种常见卷积神经网络结构

    万次阅读 多人点赞 2020-08-25 17:03:56
    作为神经网络领域的一个重要研究分支,卷积神经网络的特点在于其每一的特征都由上一的局部区域通过共享权值的卷积核激励得到。这一特点使得卷积神经网络相比于其他神经网络方法更适合应用于图像特征的.
  • 卷积神经网络模型

    千次阅读 2022-04-09 22:51:36
    卷积神经网络模型 卷积神经网络(LeNet) 模型结构:卷积层块, 全链接层块 卷积层块:2个卷积层 + 最大池化 的结构组成。 由于LeNet是较早的CNN, 在每个卷积层 + 池化后多会跟一个sigmod 来修正输出结果。 ...
  • 卷积神经网络主要由卷积层、池化和全连接组成。排在前面的较浅的卷积层采用较小的感知域,可以学到图像的一些局部特征(如纹理特征),排在后面较深的卷积层采用较大的感知域,可以学到更加抽象的特征(如物体的...
  • 卷积神经网络优化

    千次阅读 2022-03-08 21:12:56
    文章目录卷积神经网络优化--潘登同学的深度学习笔记Alexnet网络结构连续使用小的卷积核的作用使用1*1的卷积核的作用使用1*1卷积核代替全连接Dropout技术使用方法为什么Dropout技术多用在全连接数据增强技术VGG16...
  • 卷积神经网络

    千次阅读 多人点赞 2020-01-13 07:49:37
    卷积神经网络卷积神经网络卷积一维卷积二维卷积互相关卷积的变种卷积的数学性质交换性导数卷积神经网络用卷积来代替全连接卷积层汇聚(池化)典型的卷积网络结构参数学习误差项的计算几种典型的卷积...
  • 卷积神经网络入门基础知识

    千次阅读 2021-11-17 13:24:08
    一、卷积神经网络(CNN)定义 卷积神经网络(convolutional neural network, CNN),是一种专门用来处理具有类似网格结构的数据的神经网络。卷积网络是指那些至少在网络的一中使用卷积运算来替代一般的矩阵乘法...
  • 卷积神经网络前向传播过程简要介绍 在理解卷积神经网络的反向传播之前,我们需要对卷积、池化以及卷积神经网络前向传播过程作一个简要的回顾。 卷积运算介绍 在卷积神经网络中,所谓的卷积运算,其实并不是严格的...
  • 卷积神经网络(Convolutional Neural Network,CNN) 卷积 卷积核 神经网络公式 卷积运算方式 补0...标准卷积计算举例1 x 1 卷积计算举例 全连接计算举例常见的几种卷积神经网络介绍 LeNet AlexNet VGGNet ResNet
  • 【时间序列】时间卷积神经网络

    千次阅读 2021-05-20 00:16:48
    在深度学习的知识宝库中,除了前面文章中介绍的RNN,还有一个重要的分支:卷积神经网络(CNN),其广泛应用于视觉,视频等二维或者多维的图像领域。卷积网络具有深度,可并行等多种特性,这种技术...
  • 卷积神经网络(CNN)

    千次阅读 2021-03-27 20:45:38
    5、卷积神经网络的网络一共包含几? 6、样本数据是以怎么样的方式喂入卷积神经网络的? 一、概览 卷积神经网络(Convolutional Neural Network, CNN)是一种前馈的神经网络,通过卷积操作,它的人工神经元可以响应...
  • 作者主页(文火冰糖的硅基工坊):文火冰糖(王文兵)的博客_文火冰糖的硅基工坊_CSDN博客 本文网址: ...目录第1章 卷积神经网络基础1.1 卷积神经发展与进化史1.2 卷积神经网络的核心要素1.3 卷积神经..
  • MTCNN多任务卷积神经网络介绍

    千次阅读 2022-01-13 13:23:50
    MTCNN全拼:Multi-task convolutional neural network(多任务卷积神经网络),它的输出是人脸BOX区域与个人脸特征点,它是由三网络架构组成:P-Net、R-Net、O-Net,每一对应不同的工作。 工作流程 首先将...
  • 卷积神经网络CNN历史漫步(一)

    千次阅读 2022-04-05 20:56:13
    1. 卷积神经网络CNN——起源 参考链接:CNN简史:https://zhuanlan.zhihu.com/p/39068853 神经网络这一概念最早是生物界提出的,而人工智能界的神经网络很大程度上是在模拟人类的神经元。 影响到CNN起源的相关研究是...
  • 本篇博客主要介绍了卷积神经网络的结构,并解释了使用这种结构的好处及原理,并总体分析了一个好的卷积神经网络都需要哪些部分。
  • 全连接神经网络需要非常多的计算资源才能支撑它来做反向传播和前向传播,所以说全连接神经网络可以存储非常多的参数,如果你给它的样本如果没有达到它的量级的时候,它可以轻轻松松把你给他的样本全部都记下来,这会...
  • CNN卷积神经网络总结

    千次阅读 2020-09-23 15:45:47
    1 DNN和CNN DNN(Deep Neural Networks,深度神经网络) DNN是一个全连接的深度神经网络,也可以用作图像识别,在...而对于卷积神经网络,相邻的两个网络之间只有部分节点相连,为了方便展示神经元的维度,一般会展
  • 我们训练了一个大型的深度卷积神经网络,来将在ImageNet LSVRC-2010 大赛中的120万张高清图像分为1000 个不同的类别。对测试数据,我们得到了top-1 误差率37.5%,以及top-5 误差率17.0%,这个效果比之前最顶尖的都...
  • 卷积神经网络基本知识

    万次阅读 多人点赞 2018-05-26 10:58:16
    参考:https://blog.csdn.net/yjl9122/article/details/70198357卷积神经网络(CNN)由输入、卷积层、激活函数、池化、全连接组成,即INPUT(输入)-CONV(卷积层)-RELU(激活函数)-POOL(池化)-FC(全...
  • 手把手搭建一个【卷积神经网络

    千次阅读 多人点赞 2021-05-03 22:45:11
    本文介绍卷积神经网络的入门案例,图像分类;使用到CIFAR10数据集,它包含10 类,即:“飞机”,“汽车”,“鸟”,“猫”,“鹿”, “狗”,“青蛙”,“马”,“船”,“卡车” ;共 60000 张彩色图片;通过搭建...
  • 常见的卷积神经网络模型

    千次阅读 2020-11-15 16:56:55
    文章目录一、LeNet二、AlexNet2.1 AlexNet的优点三:VGGNet3.1 VGG的特点...LeNet诞生于1994年,由深度学习三巨头之一的Yan LeCun提出,他也被称为卷积神经网络之父。        LeNe

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,880
精华内容 10,352
关键字:

五层卷积神经网络