此文章是vip文章,如何查看?  

1,点击链接获取密钥 http://nicethemes.cn/product/view29882.html

2,在下方输入文章查看密钥即可立即查看当前vip文章


CNN典型模型及pytorch实现 —— GoogleNet

  • 时间:
  • 浏览:
  • 来源:互联网

目录

Inception 结构

1*1的卷积

GoogleNet 结构

GoogleNet_Model代码(Pytorch)


14年的冠军 model;

GoogleNet(把网络结构增加到了22层)证明了用更多的卷积、更深的层次,可以得到更好的效果;

但是纯粹增大网络也有一些缺点:

  1. 参数太多,容易过拟合;
  2. 网络越大,计算的复杂度越大;
  3. 网络越深,越容易出现梯度消失或梯度弥散;

为了在增加网络深度和宽度的同时减少参数,提出了 Inception;

GoogleNet 和 AlexNet 结构的区别在于中间有好几个 Inception 结构;

GoogleNet 参数总量并不大,但是计算次数非常多;


Inception 结构(有多个版本,以下为v1版本):

把输入一分为四,做不同大小的卷积(多尺度卷积),再聚合;

思想来源于1*1的卷积 + 激活函数;

v1(原始版本):

将1*1、3*3、5*5的卷积层和3*3的池化层堆叠在一起,能提取输入的每个细节,5*5能覆盖大部分的接受层的输入,实际上在每个卷积层后还有RELU激活函数(图中未画出),增加网络的非线性特征;

v1存在的问题:所有的卷积都是在上一层的输出上做的,5*5的卷积核计算量会非常大,造成特征图的厚度非常大,导致参数非常多;

经过不同的卷积和池化后,得到的输出大小、以及将四种不同类型,但大小相同的特征图堆叠起来,新的特征图的大小如下图:

参数数量如下:

【1*1 conv,128】28*28*128*1*1*256

【3*3 conv,192】28*28*192*3*3*256

【5*5 conv,96】28*28*96*5*5*256

参数总量共854M;

为了解决v1计算量很大,占用太多计算资源的问题,又提出一种新的结构:加入了1*1的卷积进行数据的降维,结构图如下:

每层特征相应图的大小及通道数如下图所示:

参数数量如下:

【1*1 conv,64】28*28*64*1*1*256

【1*1 conv,64】28*28*64*1*1*256

【1*1 conv,128】28*28*128*1*1*256

【3*3 conv,192】28*28*192*3*3*64

【5*5 conv,96】28*28*96*5*5*64

【1*1 conv,64】28*28*64*1*1*256

参数总量共358M;

可以看出,加了1*1的卷积后,参数量大大减少了(由原来的 854M 减为 358M);

Inception 结构的三个步骤:

  1. 通过3*3的池化和三种不同尺度的卷积核,以四种方式对输入的响应图进行特征提取;
  2. 为降低计算量,用1*1卷积核进行降维,让信息通过更少的连接传递达到更稀疏的特性;
  3. 在输出层之前有一个并置层,将四种不同类型的,但是大小相等的四张图并排叠在一起,形成一种新的特征响应图;

1*1的卷积(输入为m通道,输出为n通道):

卷积核大小为1;

相当于对所有的输入特征响应图做一次线性组合,输出一组新的特征相应图;

若 m>n,训练后相当于数据的降维(1*1卷积最大的作用),再接新的卷积层只需要在更少的n个通道上做卷积,节省了计算资源;

若把激活函数考虑进来,1*1卷积后加激活函数,那么就是神经网络,这就是Network in Network 的含义;


GoogleNet 结构:

22层;

参数有500万个,远小于 AlexNet 和 VGG(约为 AlexNet 参数的1/12);

采用 Inception 结构,不仅进一步提升了预测分类的成功率,而且极大的减少了参数量;

此模型特点:

  1. 采用模块化的结构,方便增添和修改;
  2. 网络最后用 average pooling 代替全连接层,将模型准确率提高了 0.6%;
  3. 网络移除了全连接层,但保留 Dropout 层;
  4. 网络增加了两个辅助的 softmax,用于向前传递导数,辅助分类器,避免梯度消失;

GoogleNet 共9个 Inception 模块(18层)、3个卷积层,1个softmax全连接层,共22层;

输入:input后接1卷积层+1池化层+2*卷积层+1池化层;

中间:9个 Inception 结构;

最后:分类输出层(舍弃了两层全连接层,参数大大减少),最后一个 Inception 模块输出7*7大小、1024通道的特征相应图,对每个特征相应图求平均池化,得到1024维的向量,再通过全连接得到和输出数目对应的1000维的向量用于分类;

两个辅助的Softmax,辅助的分类器,主要用来向前传递导数,将中间某一层的输出用于分类,并按照较小的权重(一般取0.3)加到最终分类中,相当于做了模型的融合,增加了反向传播的梯度信号,避免梯度消失和梯度发散,提供了额外的正则化,对网络的训练很有帮助,在实际测试中,这两个Softmax会被去掉;


GoogleNet_Model代码(Pytorch):

import torch
from torch import nn
import torch.nn.functional as F


class InceptionModel(nn.Module):
    def __init__(self, input_11, output_11, input_33_1, output_33_1,
                 input_33_2, output_33_2, input_55_1, output_55_1,
                 input_55_2, output_55_2, input_pool, output_pool):
        super(InceptionModel, self).__init__()
        self.layer1_1 = nn.Sequential(
            nn.Conv2d(input_11, output_11, 1, 1),
            nn.ReLU()
        )
        self.layer3_3 = nn.Sequential(
            nn.Conv2d(input_33_1, output_33_1, 1, 1),
            nn.ReLU(),
            nn.Conv2d(input_33_2, output_33_2, 3, 1, 1),
            nn.ReLU()
        )
        self.layer5_5 = nn.Sequential(
            nn.Conv2d(input_55_1, output_55_1, 1, 1),
            nn.ReLU(),
            nn.Conv2d(input_55_2, output_55_2, 5, 1, 2),
            nn.ReLU()
        )
        self.layer_pool = nn.Sequential(
            nn.MaxPool2d(3, 1, 1),
            nn.Conv2d(input_pool, output_pool, 1, 1),
            nn.ReLU()
        )

    def forward(self, x):
        x1 = self.layer1_1(x)
        x2 = self.layer3_3(x)
        x3 = self.layer5_5(x)
        x4 = self.layer_pool(x)
        x = [x1, x2, x3, x4]
        out = torch.cat(x, 1)
        print(out.shape)
        return out


class AddCla(nn.Module):
    def __init__(self, input_filter):
        super(AddCla, self).__init__()
        self.layer1 = nn.Sequential(
            nn.MaxPool2d(5, 3),
            nn.Conv2d(input_filter, 128, 1, 1),
        )
        self.layer2 = nn.Linear(128*4*4, 1024)
        self.layer3 = nn.Linear(1024, 1000)

    def forward(self, x):
        x = self.layer1(x)
        x = x.view(x.size(0), -1)
        x = self.layer2(x)
        x = self.layer3(x)
        output = F.softmax(x, dim=1)
        return output


class GoogleNet(nn.Module):
    def __init__(self):
        super(GoogleNet, self).__init__()
        self.layer_maxpooling = nn.Sequential(
            nn.MaxPool2d(3, 2, 1)
        )
        self.layer1 = nn.Sequential(
            nn.Conv2d(3, 64, 7, 2, 3)
        )
        self.layer2_3 = nn.Sequential(
            nn.Conv2d(64, 64, 1, 1),
            nn.Conv2d(64, 192, 3, 1, 1)
        )
        self.layer4_5 = InceptionModel(input_11=192, output_11=64, input_33_1=192, output_33_1=96,
                                       input_33_2=96, output_33_2=128, input_55_1=192, output_55_1=16,
                                       input_55_2=16, output_55_2=32, input_pool=192, output_pool=32)
        self.layer6_7 = InceptionModel(input_11=256, output_11=128, input_33_1=256, output_33_1=128,
                                       input_33_2=128, output_33_2=192, input_55_1=256, output_55_1=32,
                                       input_55_2=32, output_55_2=96, input_pool=256, output_pool=64)
        self.layer8_9 = InceptionModel(input_11=480, output_11=192, input_33_1=480, output_33_1=96,
                                       input_33_2=96, output_33_2=208, input_55_1=480, output_55_1=16,
                                       input_55_2=16, output_55_2=48, input_pool=480, output_pool=64)
        self.layer10_11 = InceptionModel(input_11=512, output_11=160, input_33_1=512, output_33_1=112,
                                       input_33_2=112, output_33_2=224, input_55_1=512, output_55_1=24,
                                       input_55_2=24, output_55_2=64, input_pool=512, output_pool=64)
        self.layer12_13 = InceptionModel(input_11=512, output_11=128, input_33_1=512, output_33_1=128,
                                       input_33_2=128, output_33_2=256, input_55_1=512, output_55_1=24,
                                       input_55_2=24, output_55_2=64, input_pool=512, output_pool=64)
        self.layer14_15 = InceptionModel(input_11=512, output_11=112, input_33_1=512, output_33_1=144,
                                       input_33_2=144, output_33_2=288, input_55_1=512, output_55_1=32,
                                       input_55_2=32, output_55_2=64, input_pool=512, output_pool=64)
        self.layer16_17 = InceptionModel(input_11=528, output_11=256, input_33_1=528, output_33_1=160,
                                       input_33_2=160, output_33_2=320, input_55_1=528, output_55_1=32,
                                       input_55_2=32, output_55_2=128, input_pool=528, output_pool=128)
        self.layer18_19 = InceptionModel(input_11=832, output_11=256, input_33_1=832, output_33_1=160,
                                       input_33_2=160, output_33_2=320, input_55_1=832, output_55_1=32,
                                       input_55_2=32, output_55_2=128, input_pool=832, output_pool=128)
        self.layer20_21 = InceptionModel(input_11=832, output_11=384, input_33_1=832, output_33_1=192,
                                       input_33_2=192, output_33_2=384, input_55_1=832, output_55_1=48,
                                       input_55_2=48, output_55_2=128, input_pool=832, output_pool=128)
        self.pooling = nn.AvgPool2d(7, 1)
        self.layer22 = nn.Linear(1024, 1000)

    def forward(self, x):
        x = self.layer1(x)
        x = self.layer_maxpooling(x)
        x = self.layer2_3(x)
        x = self.layer_maxpooling(x)
        x = self.layer4_5(x)
        x = self.layer6_7(x)
        x = self.layer_maxpooling(x)
        x = self.layer8_9(x)
        addcla1 = AddCla(512)(x)
        x = self.layer10_11(x)
        x = self.layer12_13(x)
        x = self.layer14_15(x)
        addcla2 = AddCla(528)(x)
        x = self.layer16_17(x)
        x = self.layer_maxpooling(x)
        x = self.layer18_19(x)
        x = self.layer20_21(x)
        x = self.pooling(x)
        x = nn.Dropout(0.4)(x)
        x = x.view(x.size(0), -1)
        x = self.layer22(x)
        output = F.softmax(x, dim=1)
        return output, addcla1, addcla2

 

本文链接http://element-ui.cn/news/show-577290.aspx