外贸网站模板下载,升级的网站显示什么,南京市城乡建设局网站,vr全景怎么做小程序文章目录 1. 图像识别1.1 模式识别1.2 图像识别的过程1.3 图像识别的应用 2. 深度学习发展2.1 深度学习为何崛起2.2 分类与检测2.3 常见的卷积神经网络 3. VGG3.1 VGG163.2 VGG16的结构#xff1a;3.3 使用卷积层代替全连接3.4 1*1卷积的作用3.5 VGG16代码示例 4. 残差模型-Re… 文章目录 1. 图像识别1.1 模式识别1.2 图像识别的过程1.3 图像识别的应用 2. 深度学习发展2.1 深度学习为何崛起2.2 分类与检测2.3 常见的卷积神经网络 3. VGG3.1 VGG163.2 VGG16的结构3.3 使用卷积层代替全连接3.4 1*1卷积的作用3.5 VGG16代码示例 4. 残差模型-Resnet4.1 Resnet4.2 BatchNormalization4.3 ResNet50代码示例 5. 迁移学习Inception5.1 卷积神经网络迁移学习-fine tuning5.2 Inception5.3 Inception module5.4 InceptionV1--Googlenet5.5 InceptionV25.6 InceptionV3-网络结构图5.7 Inception V35.8 Inception V45.9 Inception结构总结5.10 卷积神经网络迁移学习5.11 InceptionV3示例 6. 模型轻量化-Mobilenet6.1 Mobilenet—深度可分离卷积depthwise separable convolution6.2 Mobilenet--depthwise separable convolution6.3 Mobilenet6.4 MobileNet代码示例 7. 卷积神经网络的设计技巧 1. 图像识别
图像识别技术是信息时代的一门重要的技术其产生目的是为了让计算机代替人类去处理大量的物 理信息。随着计算机技术的发展人类对图像识别技术的认识越来越深刻图像识别技术的定义为利用计算机对图像进行处理、分析和理解以识别不同模式的目标和对象的 技术。图像识别技术的过程分为信息的获取、预处理、特征抽取和选择、分类器设计和分类决策。
1.1 模式识别
模式识别是人工智能和信息科学的重要组成部分。模式识别是指对表示事物或现象的不同 形式的信息做分析和处理从而得到一个对事物或现象做出描述、辨认和分类等的过程。计算机的图像识别技术就是模拟人类的图像识别过程。在图像识别的过程中进行模式识别 是必不可少的。模式识别原本是人类的一项基本智能。但随着计算机的发展和人工智能的兴起人类本身 的模式识别已经满足不了生活的需要于是人类就希望用计算机来代替或扩展人类的部分 脑力劳动。这样计算机的模式识别就产生了。简单地说模式识别就是对数据进行分类它是一门与数学紧密结合的科学其中所用的 思想大部分是概率与统计。
1.2 图像识别的过程
图像识别技术的过程分以下几步
信息的获取是指通过传感器将光或声音等信息转化为电信息。也就是获取研究对象的基本信息并通过某种方法将其转变为机器能够认识的信息。预处理主要是指图像处理中的去噪、平滑、变换等的操作从而加强图像的重要特征。图像增强。特征抽取和选择是指在模式识别中需要进行特征的抽取和选择。特征抽取和选择在图像识别过程中是非常关键的技术之一。分类器设计是指通过训练而得到一种识别规则通过此识别规则可以得到一种特征分类使图像识别技术能够得到高识别率。分类决策是指在特征空间中对被识别对象进行分类从而更好地识别所研究的对象具体属于哪一类。
1.3 图像识别的应用
图像分类网络搜索以图搜图智能家居电商购物“相似款拍照识别/扫描识别”农林业森林调查。金融安防医疗娱乐监管
2. 深度学习发展
2.1 深度学习为何崛起
数据规模推动深度学习进步 2.2 分类与检测
当我们面对一张图片的时候最基础的任务就是这张图片是什么是风景图还是人物图、是描写建筑物的还是关于食物的这就是分类。当知道了图像的类别的时候进一步的就是检测了例如我知道这个图像是关于人脸的那么这个人脸在哪里能不能把它框出来。物体分类与检测在很多领域得到广泛应用包括安防领域的人脸识别、行人检测、智能视频分析、行人跟踪等交通领域的交通场景物体识别、车辆计数、逆行检测、车牌检测与识别以及互联网领域的基于内容的图像检索、相册自动归类等。
2.3 常见的卷积神经网络 3. VGG
VGG之所以经典在于它首次将深度学习做得非常“深”达到了16-19层同时它用了非常“小”的卷积核3X3
3.1 VGG16
VGG给我们的启发只是在于我们可以让网络变得更深并在此基础上注意过拟合的问题。
3.2 VGG16的结构
一张原始图片被resize到(224,224,3)。conv1两次[3,3]卷积网络输出的特征层为64输出为(224,224,64)再2X2最大池化输出net为 (112,112,64)。conv2两次[3,3]卷积网络输出的特征层为128输出net为(112,112,128)再2X2最大池化输出 net为(56,56,128)。conv3三次[3,3]卷积网络输出的特征层为256输出net为(56,56,256)再2X2最大池化输出net 为(28,28,256)。conv3三次[3,3]卷积网络输出的特征层为256输出net为(28,28,512)再2X2最大池化输出net 为(14,14,512)。conv3三次[3,3]卷积网络输出的特征层为256输出net为(14,14,512)再2X2最大池化输出net 为(7,7,512)。利用卷积的方式模拟全连接层效果等同输出net为(1,1,4096)。共进行两次。利用卷积的方式模拟全连接层效果等同输出net为(1,1,1000)。 最后输出的就是每个类的预测。 VGG使用比较小的卷积核如33的卷积核而Alexnet使用了比较大的卷积核如1111卷积核使用小的卷积核的好处在于可以获得更加细节的信息。 3.3 使用卷积层代替全连接
卷积层和全连接层的区别卷积层为局部连接而全连接层则使用图像的全局信息。可以想象一下最大的局部是不是就等于全局了这首先说明全连接层使用卷积层来替代的可行性。
eg: 输入有[5044]个神经元结点输出有500个节点则一共需要5044*500400000个权值参数W和 500个偏置参数b 卷积层和全连接层都是进行了一个点乘操作它们的函数形式相同。因此全连接层可以转化为对应的卷积层。我们只需要把卷积核变成跟输入的一个feature map大小hw一样就可以了这样的话就相当于使得卷积跟全连接层的参数一样多。 比如VGG16中, 第一个全连接层的输入是77512, 输出是4096。这可以用一个卷积核大小77, 步长(stride)为1, 没有填补(padding)输出通道数4096的卷积层等效表示其输出为11*4096和全连接层等价。后续的全连接层可以用1x1卷积等效替代。 简而言之, 全连接层转化为卷积层的规则是将卷积核大小设置为输入的空间大小。 3.4 1*1卷积的作用
实现特征通道的升维和降维 通过控制卷积核的数量达到通道数大小的放缩。而池化层只能改变高度和宽度无法改变通道数。
3.5 VGG16代码示例
import torch.nn as nnclass VGG16(nn.Module):def __init__(self, num_classes1000):super(VGG16, self).__init__()# VGG16 有五个卷积块# 下面我们定义每一个卷积块内部的卷积层结构# 其中M 代表最大池化层self.features nn.Sequential(# 第一个卷积块包含两个卷积层每个都有 64 个 3x3 的卷积核nn.Conv2d(3, 64, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(64, 64, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.MaxPool2d(kernel_size2, stride2),# 第二个卷积块包含两个卷积层每个都有 128 个 3x3 的卷积核nn.Conv2d(64, 128, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(128, 128, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.MaxPool2d(kernel_size2, stride2),# 第三个卷积块包含三个卷积层每个都有 256 个 3x3 的卷积核nn.Conv2d(128, 256, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(256, 256, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(256, 256, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.MaxPool2d(kernel_size2, stride2),# 第四个卷积块包含三个卷积层每个都有 512 个 3x3 的卷积核nn.Conv2d(256, 512, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(512, 512, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(512, 512, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.MaxPool2d(kernel_size2, stride2),# 第五个卷积块也包含三个卷积层每个都有 512 个 3x3 的卷积核nn.Conv2d(512, 512, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(512, 512, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(512, 512, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.MaxPool2d(kernel_size2, stride2),)# VGG16 的三个全连接层self.classifier nn.Sequential(nn.Linear(512 * 7 * 7, 4096), # 7x7 是特征图的大小假设输入图像是 224x224nn.ReLU(True),nn.Dropout(),nn.Linear(4096, 4096),nn.ReLU(True),nn.Dropout(),nn.Linear(4096, num_classes),)def forward(self, x):x self.features(x)x x.view(x.size(0), -1) # flatten the tensorx self.classifier(x)return x# 实例化 VGG16 模型
model VGG16()
print(model)
4. 残差模型-Resnet
Residual net(残差网络)将靠前若干层的某一层数据输出直接跳过多层引入到后面数据层的输入 部分。
残差神经单元假定某段神经网络的输入是x期望输出是H(x)如果我们直接将输入x传到输出作为初始结果那么我们需要学习的目标就是F(x) H(x) - x这就是一个残差神经单元相当于将学习目标改变了不再是学习一个完整的输出H(x)只是输出和输入的差别 H(x) - x 即残差。 4.1 Resnet
普通的直连的卷积神经网络和ResNet的最大区别在于ResNet有很多旁路的支线将输入直接连到后面的层使得后面的层可以直接学习残差这种结构也被称为shortcut或skip connections。传统的卷积层或全连接层在信息传递时或多或少会存在信息丢失、损耗等问题。ResNet在某种程度上解决了这个问题通过直接将输入信息绕道传到输出保护信息的完整性整个网络只需要学习输入、输出差别的那一部分简化了学习目标和难度。
ResNet50有两个基本的块分别名为Conv Block和Identity Block其中Conv Block输入和输出的维度是不一样的所以不能连续串联它的作用是改变网络的维度Identity Block输入维度和输出维度相同可以串联用于加深网络的。 4.2 BatchNormalization
BatchNormalization
所有输出保证在0~1之间。所有输出数据的均值接近0标准差接近1的正太分布。使其落入激活函数的敏感区避免梯度消失加快收敛。加快模型收敛速度并且具有一定的泛化能力。可以减少dropout的使用。 4.3 ResNet50代码示例
import torch
import torch.nn as nnclass IdentityBlock(nn.Module):def __init__(self, in_channels, filters, kernel_size, stride):super(IdentityBlock, self).__init__()filters1, filters2, filters3 filters# 主路径的第一部分self.conv1 nn.Conv2d(in_channels, filters1, (1, 1))self.bn1 nn.BatchNorm2d(filters1)self.relu1 nn.ReLU()# 主路径的第二部分self.conv2 nn.Conv2d(filters1, filters2, kernel_size, stridestride, padding1)self.bn2 nn.BatchNorm2d(filters2)self.relu2 nn.ReLU()# 主路径的第三部分self.conv3 nn.Conv2d(filters2, filters3, (1, 1))self.bn3 nn.BatchNorm2d(filters3)self.relu nn.ReLU()def forward(self, x):identity xx self.conv1(x)x self.bn1(x)x self.relu1(x)x self.conv2(x)x self.bn2(x)x self.relu2(x)x self.conv3(x)x self.bn3(x)x identityx self.relu(x)return xclass ConvBlock(nn.Module):def __init__(self, in_channels, filters, kernel_size, stride):super(ConvBlock, self).__init__()filters1, filters2, filters3 filters# 主路径的第一部分self.conv1 nn.Conv2d(in_channels, filters1, (1, 1), stridestride)self.bn1 nn.BatchNorm2d(filters1)self.relu1 nn.ReLU()# 主路径的第二部分self.conv2 nn.Conv2d(filters1, filters2, kernel_size, padding1)self.bn2 nn.BatchNorm2d(filters2)self.relu2 nn.ReLU()# 主路径的第三部分self.conv3 nn.Conv2d(filters2, filters3, (1, 1))self.bn3 nn.BatchNorm2d(filters3)# 快捷路径self.shortcut_conv nn.Conv2d(in_channels, filters3, (1, 1), stridestride)self.shortcut_bn nn.BatchNorm2d(filters3)self.relu nn.ReLU()def forward(self, x):identity self.shortcut_conv(x)identity self.shortcut_bn(identity)x self.conv1(x)x self.bn1(x)x self.relu1(x)x self.conv2(x)x self.bn2(x)x self.relu2(x)x self.conv3(x)x self.bn3(x)x identityx self.relu(x)return xclass ResNet50(nn.Module):def __init__(self, num_classes1000):super(ResNet50, self).__init__()self.pad nn.ZeroPad2d((3, 3, 3, 3))self.conv1 nn.Conv2d(3, 64, (7, 7), stride(2, 2))self.bn1 nn.BatchNorm2d(64)self.relu nn.ReLU()self.maxpool nn.MaxPool2d((3, 3), stride(2, 2))# 第一阶段self.stage2a ConvBlock(64, [64, 64, 256], 3, stride(1, 1))self.stage2b IdentityBlock(256, [64, 64, 256], 3, stride(1, 1))self.stage2c IdentityBlock(256, [64, 64, 256], 3, stride(1, 1))# 第二阶段self.stage3a ConvBlock(256, [128, 128, 512], 3, stride(2, 2))self.stage3b IdentityBlock(512, [128, 128, 512], 3, stride(1, 1))# ... 继续其余的阶段self.avgpool nn.AdaptiveAvgPool2d((1, 1))self.fc nn.Linear(2048, num_classes)def forward(self, x):x self.pad(x)x self.conv1(x)x self.bn1(x)x self.relu(x)x self.maxpool(x)# 第一阶段x self.stage2a(x)x self.stage2b(x)x self.stage2c(x)# 第二阶段x self.stage3a(x)x self.stage3b(x)# ... 继续其余的阶段x self.avgpool(x)x torch.flatten(x, 1)x self.fc(x)return xmodel ResNet50()
print(model)
5. 迁移学习Inception
5.1 卷积神经网络迁移学习-fine tuning
在实践中由于数据集不够大很少有人从头开始训练网络。常见的做法是使用预训练的网络例如在ImageNet上训练的分类1000类的网络来重新fine-tuning也叫微调或者当做特征提取器。迁移学习简单的讲就是将一个在数据集上训练好的卷积神经网络模型通过简单的调整快速移动到另外一个数据集上。随着模型的层数及模型的复杂度的增加模型的错误率也随着降低。但是要训练一个复杂的卷积神经网络需要非常多的标注信息同时也需要几天甚至几周的时间为了解决标注数据和训练时间的问题就可以使用迁移学习。
常见的两类迁移学习场景
卷积网络当做特征提取器。使用在ImageNet上预训练的网络去掉最后的全连接层剩余部分当做特征提取器例如AlexNet在最后分类器前是4096维的特征向量。这样提取的特征叫做CNN codes。得到这样的特征后可以使用线性分类器Liner SVM、Softmax等来分类图像。Fine-tuning卷积网络。替换掉网络的输入层数据使用新的数据继续训练。Fine-tune时可以选择fine-tune全部层或部分层。通常前面的层提取的是图像的通用特征generic features例如边缘检测色彩检测这些特征对许多任务都有用。后面的层提取的是与特定类别有关的特征因此fine-tune时常只需要Fine-tuning后面的层。
有论文依据表明可以保留训练好的inception模型中所有卷积层的参数只替换最后一层全连接层。在最后这一层全连接层之前的网络称为瓶颈层。原理在训练好的inception模型中因为将瓶颈层的输出再通过一个单层的全连接层神经网络可以很好的区分1000种类别的图像所以可以认为瓶颈层输出的节点向量可以被作为任何图像的一个更具有表达能力的特征向量。于是在新的数据集上可以直接利用这个训练好的神经网络对图像进行特征提取然后将提取得到的特征向量作为输入来训练一个全新的单层全连接神经网络处理新的分类问题。一般来说在数据量足够的情况下迁移学习的效果不如完全重新训练。但是迁移学习所需要的训练时间和训练样本要远远小于训练完整的模型。这其中说到inception模型其实它是和Alexnet结构完全不同的卷积神经网络。在Alexnet模型中不同卷积层通过串联的方式连接在一起而inception模型中的inception结构是将不同的卷积层通过并联的方式结合在一起
5.2 Inception
Inception 网络是 CNN 发展史上一个重要的里程碑。在 Inception 出现之前大部分流行CNN 仅仅是把卷积层堆叠得越来越多使网络越来越深以此希望能够得到更好的性能。但是存在以下问题
图像中突出部分的大小差别很大。由于信息位置的巨大差异为卷积操作选择合适的卷积核大小就比较困难。信息分布更全局性的图像偏好较大的卷积核信息分布比较局部的图像偏好较小的卷积核。非常深的网络更容易过拟合。将梯度更新传输到整个网络是很困难的。简单地堆叠较大的卷积层非常消耗计算资源。
5.3 Inception module
解决方案 为什么不在同一层级上运行具备多个尺寸的滤波器呢网络本质上会变得稍微「宽一些」而不是「更深」。作者因此设计了 Inception 模块。
Inception 模块 Inception module 它使用 3 个不同大小的滤波器1x1、3x3、5x5对输入执行卷积操作此外它还会执行最大池化。所有子层的输出最后会被级联起来并传送至下一个Inception 模块。
一方面增加了网络的宽度另一方面增加了网络对尺度的适应性 实现降维的 Inception 模块 如前所述深度神经网络需要耗费大量计算资源。为了降低算力成本作者在 3x3 和 5x5 卷积层之前添加额外的 1x1 卷积层来限制输入通道的数量。尽管添加额外的卷积操作似乎是反直觉的但是 1x1 卷积比 5x5 卷积要廉价很多而且输入通道数量减少也有利于降低算力成本。
5.4 InceptionV1–Googlenet
GoogLeNet采用了Inception模块化9个的结构共22层为了避免梯度消失网络额外增加了2个辅助的softmax用于向前传导梯度。
5.5 InceptionV2
Inception V2 在输入的时候增加了BatchNormalization
所有输出保证在0~1之间。所有输出数据的均值接近0标准差接近1的正太分布。使其落入激活函数的敏感区避免梯度消失加快收敛。加快模型收敛速度并且具有一定的泛化能力。可以减少dropout的使用。
V2
作者提出可以用2个连续的3x3卷积层(stride1)组成的小网络来代替单个的5x5卷积 层这便是InceptionV2结构。5x5卷积核参数是3x3卷积核的25/92.78倍。 此外作者将 n*n 的卷积核尺寸分解为 1×n 和 n×1 两个卷积。
前面三个原则用来构建三种不同类型 的 Inception 模块
5.6 InceptionV3-网络结构图
InceptionV3 整合了前面 Inception v2 中提到的所有升级还使用了7x7 卷积
5.7 Inception V3
Inception V3设计思想和Trick
分解成小卷积很有效可以降低参数量减轻过拟合增加网络非线性的表达能力。卷积网络从输入到输出应该让图片尺寸逐渐减小输出通道数逐渐增加即让空间结构化将空间信息转化为高阶抽象的特征信息。Inception Module用多个分支提取不同抽象程度的高阶特征的思路很有效可以丰富网络的表达能力
5.8 Inception V4 左图是基本的Inception v2/v3模块使用两个3x3卷积代替5x5卷积并且使用average pooling该模块主要处理尺寸为35x35的feature map中图模块使用1xn和nx1卷积代替nxn卷积同样使用average pooling该模块主要处理尺寸为17x17的feature map右图将3x3卷积用1x3卷积和3x1卷积代替。
总的来说Inception v4中基本的Inception module还是沿袭了Inception v2/v3的结构只是结构看起来更加简洁统一并且使用更多的Inception module实验效果也更好。
5.9 Inception结构总结
Inception模型优势
采用了1x1卷积核性价比高用很少的计算量既可以增加一层的特征变换和非线性变换。提出Batch Normalization通过一定的手段把每层神经元的输入值分布拉到均值0方差1的正态分布使其落入激活函数的敏感区避免梯度消失加快收敛。引入Inception module4个分支结合的结构。
5.10 卷积神经网络迁移学习
现在在工程中最为常用的还是vgg、resnet、inception这几种结构设计者通常会先直接套用原版的模型对数据进行训练一次然后选择效果较为好的模型进行微调与模型缩减。工程上使用的模型必须在精度高的同时速度要快。常用的模型缩减的方法是减少卷积的个数与减少resnet的模块数。
5.11 InceptionV3示例
#-------------------------------------------------------------#
# InceptionV3的网络部分
#-------------------------------------------------------------#
from __future__ import print_function
from __future__ import absolute_importimport warnings
import numpy as npfrom keras.models import Model
from keras import layers
from keras.layers import Activation,Dense,Input,BatchNormalization,Conv2D,MaxPooling2D,AveragePooling2D
from keras.layers import GlobalAveragePooling2D,GlobalMaxPooling2D
from keras.engine.topology import get_source_inputs
from keras.utils.layer_utils import convert_all_kernels_in_model
from keras.utils.data_utils import get_file
from keras import backend as K
from keras.applications.imagenet_utils import decode_predictions
from keras.preprocessing import imagedef conv2d_bn(x,filters,num_row,num_col,strides(1, 1),paddingsame,nameNone):if name is not None:bn_name name _bnconv_name name _convelse:bn_name Noneconv_name Nonex Conv2D(filters, (num_row, num_col),stridesstrides,paddingpadding,use_biasFalse,nameconv_name)(x)x BatchNormalization(scaleFalse, namebn_name)(x)x Activation(relu, namename)(x)return xdef InceptionV3(input_shape[299,299,3],classes1000):img_input Input(shapeinput_shape)x conv2d_bn(img_input, 32, 3, 3, strides(2, 2), paddingvalid)x conv2d_bn(x, 32, 3, 3, paddingvalid)x conv2d_bn(x, 64, 3, 3)x MaxPooling2D((3, 3), strides(2, 2))(x)x conv2d_bn(x, 80, 1, 1, paddingvalid)x conv2d_bn(x, 192, 3, 3, paddingvalid)x MaxPooling2D((3, 3), strides(2, 2))(x)#--------------------------------## Block1 35x35#--------------------------------## Block1 part1# 35 x 35 x 192 - 35 x 35 x 256branch1x1 conv2d_bn(x, 64, 1, 1)branch5x5 conv2d_bn(x, 48, 1, 1)branch5x5 conv2d_bn(branch5x5, 64, 5, 5)branch3x3dbl conv2d_bn(x, 64, 1, 1)branch3x3dbl conv2d_bn(branch3x3dbl, 96, 3, 3)branch3x3dbl conv2d_bn(branch3x3dbl, 96, 3, 3)branch_pool AveragePooling2D((3, 3), strides(1, 1), paddingsame)(x)branch_pool conv2d_bn(branch_pool, 32, 1, 1)# 64649632 256 nhwc-0123x layers.concatenate([branch1x1, branch5x5, branch3x3dbl, branch_pool],axis3,namemixed0)# Block1 part2# 35 x 35 x 256 - 35 x 35 x 288branch1x1 conv2d_bn(x, 64, 1, 1)branch5x5 conv2d_bn(x, 48, 1, 1)branch5x5 conv2d_bn(branch5x5, 64, 5, 5)branch3x3dbl conv2d_bn(x, 64, 1, 1)branch3x3dbl conv2d_bn(branch3x3dbl, 96, 3, 3)branch3x3dbl conv2d_bn(branch3x3dbl, 96, 3, 3)branch_pool AveragePooling2D((3, 3), strides(1, 1), paddingsame)(x)branch_pool conv2d_bn(branch_pool, 64, 1, 1)# 64649664 288 x layers.concatenate([branch1x1, branch5x5, branch3x3dbl, branch_pool],axis3,namemixed1)# Block1 part3# 35 x 35 x 288 - 35 x 35 x 288branch1x1 conv2d_bn(x, 64, 1, 1)branch5x5 conv2d_bn(x, 48, 1, 1)branch5x5 conv2d_bn(branch5x5, 64, 5, 5)branch3x3dbl conv2d_bn(x, 64, 1, 1)branch3x3dbl conv2d_bn(branch3x3dbl, 96, 3, 3)branch3x3dbl conv2d_bn(branch3x3dbl, 96, 3, 3)branch_pool AveragePooling2D((3, 3), strides(1, 1), paddingsame)(x)branch_pool conv2d_bn(branch_pool, 64, 1, 1)# 64649664 288 x layers.concatenate([branch1x1, branch5x5, branch3x3dbl, branch_pool],axis3,namemixed2)#--------------------------------## Block2 17x17#--------------------------------## Block2 part1# 35 x 35 x 288 - 17 x 17 x 768branch3x3 conv2d_bn(x, 384, 3, 3, strides(2, 2), paddingvalid)branch3x3dbl conv2d_bn(x, 64, 1, 1)branch3x3dbl conv2d_bn(branch3x3dbl, 96, 3, 3)branch3x3dbl conv2d_bn(branch3x3dbl, 96, 3, 3, strides(2, 2), paddingvalid)branch_pool MaxPooling2D((3, 3), strides(2, 2))(x)x layers.concatenate([branch3x3, branch3x3dbl, branch_pool], axis3, namemixed3)# Block2 part2# 17 x 17 x 768 - 17 x 17 x 768branch1x1 conv2d_bn(x, 192, 1, 1)branch7x7 conv2d_bn(x, 128, 1, 1)branch7x7 conv2d_bn(branch7x7, 128, 1, 7)branch7x7 conv2d_bn(branch7x7, 192, 7, 1)branch7x7dbl conv2d_bn(x, 128, 1, 1)branch7x7dbl conv2d_bn(branch7x7dbl, 128, 7, 1)branch7x7dbl conv2d_bn(branch7x7dbl, 128, 1, 7)branch7x7dbl conv2d_bn(branch7x7dbl, 128, 7, 1)branch7x7dbl conv2d_bn(branch7x7dbl, 192, 1, 7)branch_pool AveragePooling2D((3, 3), strides(1, 1), paddingsame)(x)branch_pool conv2d_bn(branch_pool, 192, 1, 1)x layers.concatenate([branch1x1, branch7x7, branch7x7dbl, branch_pool],axis3,namemixed4)# Block2 part3 and part4# 17 x 17 x 768 - 17 x 17 x 768 - 17 x 17 x 768for i in range(2):branch1x1 conv2d_bn(x, 192, 1, 1)branch7x7 conv2d_bn(x, 160, 1, 1)branch7x7 conv2d_bn(branch7x7, 160, 1, 7)branch7x7 conv2d_bn(branch7x7, 192, 7, 1)branch7x7dbl conv2d_bn(x, 160, 1, 1)branch7x7dbl conv2d_bn(branch7x7dbl, 160, 7, 1)branch7x7dbl conv2d_bn(branch7x7dbl, 160, 1, 7)branch7x7dbl conv2d_bn(branch7x7dbl, 160, 7, 1)branch7x7dbl conv2d_bn(branch7x7dbl, 192, 1, 7)branch_pool AveragePooling2D((3, 3), strides(1, 1), paddingsame)(x)branch_pool conv2d_bn(branch_pool, 192, 1, 1)x layers.concatenate([branch1x1, branch7x7, branch7x7dbl, branch_pool],axis3,namemixed str(5 i))# Block2 part5# 17 x 17 x 768 - 17 x 17 x 768branch1x1 conv2d_bn(x, 192, 1, 1)branch7x7 conv2d_bn(x, 192, 1, 1)branch7x7 conv2d_bn(branch7x7, 192, 1, 7)branch7x7 conv2d_bn(branch7x7, 192, 7, 1)branch7x7dbl conv2d_bn(x, 192, 1, 1)branch7x7dbl conv2d_bn(branch7x7dbl, 192, 7, 1)branch7x7dbl conv2d_bn(branch7x7dbl, 192, 1, 7)branch7x7dbl conv2d_bn(branch7x7dbl, 192, 7, 1)branch7x7dbl conv2d_bn(branch7x7dbl, 192, 1, 7)branch_pool AveragePooling2D((3, 3), strides(1, 1), paddingsame)(x)branch_pool conv2d_bn(branch_pool, 192, 1, 1)x layers.concatenate([branch1x1, branch7x7, branch7x7dbl, branch_pool],axis3,namemixed7)#--------------------------------## Block3 8x8#--------------------------------## Block3 part1# 17 x 17 x 768 - 8 x 8 x 1280branch3x3 conv2d_bn(x, 192, 1, 1)branch3x3 conv2d_bn(branch3x3, 320, 3, 3,strides(2, 2), paddingvalid)branch7x7x3 conv2d_bn(x, 192, 1, 1)branch7x7x3 conv2d_bn(branch7x7x3, 192, 1, 7)branch7x7x3 conv2d_bn(branch7x7x3, 192, 7, 1)branch7x7x3 conv2d_bn(branch7x7x3, 192, 3, 3, strides(2, 2), paddingvalid)branch_pool MaxPooling2D((3, 3), strides(2, 2))(x)x layers.concatenate([branch3x3, branch7x7x3, branch_pool], axis3, namemixed8)# Block3 part2 part3# 8 x 8 x 1280 - 8 x 8 x 2048 - 8 x 8 x 2048for i in range(2):branch1x1 conv2d_bn(x, 320, 1, 1)branch3x3 conv2d_bn(x, 384, 1, 1)branch3x3_1 conv2d_bn(branch3x3, 384, 1, 3)branch3x3_2 conv2d_bn(branch3x3, 384, 3, 1)branch3x3 layers.concatenate([branch3x3_1, branch3x3_2], axis3, namemixed9_ str(i))branch3x3dbl conv2d_bn(x, 448, 1, 1)branch3x3dbl conv2d_bn(branch3x3dbl, 384, 3, 3)branch3x3dbl_1 conv2d_bn(branch3x3dbl, 384, 1, 3)branch3x3dbl_2 conv2d_bn(branch3x3dbl, 384, 3, 1)branch3x3dbl layers.concatenate([branch3x3dbl_1, branch3x3dbl_2], axis3)branch_pool AveragePooling2D((3, 3), strides(1, 1), paddingsame)(x)branch_pool conv2d_bn(branch_pool, 192, 1, 1)x layers.concatenate([branch1x1, branch3x3, branch3x3dbl, branch_pool],axis3,namemixed str(9 i))# 平均池化后全连接。x GlobalAveragePooling2D(nameavg_pool)(x)x Dense(classes, activationsoftmax, namepredictions)(x)inputs img_inputmodel Model(inputs, x, nameinception_v3)return modeldef preprocess_input(x):x / 255.x - 0.5x * 2.return xif __name__ __main__:model InceptionV3()model.load_weights(inception_v3_weights_tf_dim_ordering_tf_kernels.h5)img_path elephant.jpgimg image.load_img(img_path, target_size(299, 299))x image.img_to_array(img)x np.expand_dims(x, axis0)x preprocess_input(x)preds model.predict(x)print(Predicted:, decode_predictions(preds))
6. 模型轻量化-Mobilenet
MobileNet模型是Google针对手机等嵌入式设备提出的一种轻量级的深层神经网络其使用的核心思想便是深度可分离卷积 depthwise separable convolution。
6.1 Mobilenet—深度可分离卷积depthwise separable convolution 6.2 Mobilenet–depthwise separable convolution
对于一个卷积点而言 假设有一个3×3大小的卷积层其输入通道为16、输出通道为32。具体为32个3×3大小的卷积核会遍历16个通道中的每个数据最后可得到所需的32个输出通道所需参数为16×32×3×34608个。
应用深度可分离卷积用16个3×3大小的卷积核分别遍历16通道的数据得到了16个特征图谱接着用32个1×1大小的卷积核遍历这16个特征图谱所需参数为16×3×316×32×1×1656个。
可以看出来depthwise separable convolution可以减少模型的参数。
6.3 Mobilenet 6.4 MobileNet代码示例
#-------------------------------------------------------------#
# MobileNet的网络部分
#-------------------------------------------------------------#
import warnings
import numpy as npfrom keras.preprocessing import imagefrom keras.models import Model
from keras.layers import DepthwiseConv2D,Input,Activation,Dropout,Reshape,BatchNormalization,GlobalAveragePooling2D,GlobalMaxPooling2D,Conv2D
from keras.applications.imagenet_utils import decode_predictions
from keras import backend as Kdef MobileNet(input_shape[224,224,3],depth_multiplier1,dropout1e-3,classes1000):img_input Input(shapeinput_shape)# 224,224,3 - 112,112,32x _conv_block(img_input, 32, strides(2, 2))# 112,112,32 - 112,112,64x _depthwise_conv_block(x, 64, depth_multiplier, block_id1)# 112,112,64 - 56,56,128x _depthwise_conv_block(x, 128, depth_multiplier,strides(2, 2), block_id2)# 56,56,128 - 56,56,128x _depthwise_conv_block(x, 128, depth_multiplier, block_id3)# 56,56,128 - 28,28,256x _depthwise_conv_block(x, 256, depth_multiplier,strides(2, 2), block_id4)# 28,28,256 - 28,28,256x _depthwise_conv_block(x, 256, depth_multiplier, block_id5)# 28,28,256 - 14,14,512x _depthwise_conv_block(x, 512, depth_multiplier,strides(2, 2), block_id6)# 14,14,512 - 14,14,512x _depthwise_conv_block(x, 512, depth_multiplier, block_id7)x _depthwise_conv_block(x, 512, depth_multiplier, block_id8)x _depthwise_conv_block(x, 512, depth_multiplier, block_id9)x _depthwise_conv_block(x, 512, depth_multiplier, block_id10)x _depthwise_conv_block(x, 512, depth_multiplier, block_id11)# 14,14,512 - 7,7,1024x _depthwise_conv_block(x, 1024, depth_multiplier,strides(2, 2), block_id12)x _depthwise_conv_block(x, 1024, depth_multiplier, block_id13)# 7,7,1024 - 1,1,1024x GlobalAveragePooling2D()(x)x Reshape((1, 1, 1024), namereshape_1)(x)x Dropout(dropout, namedropout)(x)x Conv2D(classes, (1, 1),paddingsame, nameconv_preds)(x)x Activation(softmax, nameact_softmax)(x)x Reshape((classes,), namereshape_2)(x)inputs img_inputmodel Model(inputs, x, namemobilenet_1_0_224_tf)model_name mobilenet_1_0_224_tf.h5model.load_weights(model_name)return modeldef _conv_block(inputs, filters, kernel(3, 3), strides(1, 1)):x Conv2D(filters, kernel,paddingsame,use_biasFalse,stridesstrides,nameconv1)(inputs)x BatchNormalization(nameconv1_bn)(x)return Activation(relu6, nameconv1_relu)(x)def _depthwise_conv_block(inputs, pointwise_conv_filters,depth_multiplier1, strides(1, 1), block_id1):x DepthwiseConv2D((3, 3),paddingsame,depth_multiplierdepth_multiplier,stridesstrides,use_biasFalse,nameconv_dw_%d % block_id)(inputs)x BatchNormalization(nameconv_dw_%d_bn % block_id)(x)x Activation(relu6, nameconv_dw_%d_relu % block_id)(x)x Conv2D(pointwise_conv_filters, (1, 1),paddingsame,use_biasFalse,strides(1, 1),nameconv_pw_%d % block_id)(x)x BatchNormalization(nameconv_pw_%d_bn % block_id)(x)return Activation(relu6, nameconv_pw_%d_relu % block_id)(x)def relu6(x):return K.relu(x, max_value6)def preprocess_input(x):x / 255.x - 0.5x * 2.return xif __name__ __main__:model MobileNet(input_shape(224, 224, 3))img_path elephant.jpgimg image.load_img(img_path, target_size(224, 224))x image.img_to_array(img)x np.expand_dims(x, axis0)x preprocess_input(x)print(Input image shape:, x.shape)preds model.predict(x)print(np.argmax(preds))print(Predicted:, decode_predictions(preds,1)) # 只显示top1
7. 卷积神经网络的设计技巧
问题背景
想要熟练掌握训练神经网络的能力并不是那么容易。与先前的机器学习思维一样细节决定成败。但是训练神经网络有更多的细节需要处理。你的数据和硬件有什么限制你应该从何种网络开始你应该建立多少卷积层你的激励函数怎样去设置学习速率是调整神经网络训练最重要的超参数也是最难优化的参数之一。太小你可能永远不会得到一个解决方案太大你可能刚好错过最优解。如果用自适应的学习速率的方法这就意味着你要花很多钱在硬件资源上以此来满足对计算的需求。设计选择和超参数的设置极大地影响了CNN的训练和性能但对于深度学习领域新进入者来说设计架构直觉的培养可能就需要资源的稀缺性和分散性。 1 架构遵循应用 你也许会被 Google Brain 或者 Deep Mind 这些有想象力的实验室所发明的那些耀眼的新模型所吸引但是其中许多要么是不可能实现的要么是不实用的对于你的需求。或许你应该使用对你的特定应用最有意义的模型这种模型或许非常简单但是仍然很强大例如 VGG。
2 路径的激增 每年ImageNet Challenge的赢家都比上一年的冠军使用更加深层的网络。从AlexNet 到Inception到Resnets有”网络的路径数量成倍增长”的趋势。
3 追求简约 更大的并不一定是更好的。
4增加对称性 无论是在建筑上还是在生物上对称性被认为是质量和工艺的标志。
5 金字塔形状 你总是在表征能力和减少冗余或者无用信息之间权衡。CNNs通常会降低激活函数的采样并会增加从输入层到最终层之间的连接通道。
6 过渡训练 另一个权衡是训练准确度和泛化能力。用正则化的方法类似 drop-out 或 drop-path进行提升泛化能力这是神经网络的重要优势。用比实际用例更难的问题训练网络以提高泛化性能。
7 覆盖问题的空间 为了扩大训练数据和提升泛化能力要使用噪声和人工增加训练集的大小。例如随机旋转、裁剪和一些图像增强操作。
8 递增的功能结构 当架构变得成功时它们会简化每一层的“工作”。在非常深的神经网络中每个层只会递增地修改输入。在ResNets中每一层的输出可能类似于输入。所以在实践中请在ResNet中使用短的跳过长度。
9 标准化层的输入 标准化是可以使计算层的工作变得更加容易的一条捷径并且在实际中可以提升训练的准确性。标准化把所有层的输入样本放在了一个平等的基础上类似于单位转换这允许反向传播可以更有效地训练。
10使用微调过的预训练网络fine tuning 机器学习公司 Diffbot 的 CEO Mike Tung 说“如果你的视觉数据和 ImageNet 相似那么用预训练网络会帮助你学习得更快”。低水平的CNN通常可以被重复使用因为它们大多能够检测到像线条和边缘这些常见的模式。比如用自己设计的层替换分类层并且用你特定的数据去训练最后的几个层。
11使用循环的学习率 学习率的实验会消耗大量的时间并且会让你遇到错误。自适应学习率在计算上可能是非常昂贵的但是循环学习率不会。使用循环学习率时你可以设置一组最大最小边界并且在这个范围改变它。
