引言

原文连接：GoogLeNet

网络创新：

局部特征结构：inception模块

对特征并行地执行多个大小不同的卷积和池化运算，最后拼接到一起。
优点：1 * 1 3*3 5 * 5 卷积运算对应不同的特征图区域，可以得到更好的图像表征信息
注意：每个分支所得的特征矩阵高和宽必须相同

初级：

改进inception v1：

运用到了多个1 * 1的卷积模块
inception v1的参数量是AlexNet 的1/12 ， VGGNet的1/3 ,适合处理大规模的数据

inception v2

Inceptionv3：

inceptionv4：

1 * 1的卷积模块

辅助分类器

网络模型

注：上表中的“#3x3 reduce”，“#5x5 reduce”表示在3x3，5x5卷积操作之前使用了1x1卷积的数量

代码实现

import torch
from torch import nn
from  torch.nn.functional import relu
import torch.nn.functional as F
from inception_v1 import  Inceptionv1 ,BasicConv2d

class GoogLeNet(nn.Module):
    def __init__(self,aux_add = False,class_num =1000,init_weight = False):
        super(GoolLeNet, self).__init__()
        self.aux_add = aux_add


        #input batch*3*244*244  output 112*112
        self.conv1 = BasicConv2d(in_channels=3,out_channels=64,kernel_size=7,stride=2,padding=3) # (224-7+2*p)/2+1 = 112 向下取整
        self.maxpool1 =  nn.MaxPool2d(kernel_size=3,stride=2,ceil_mode=True)
        self.conv2 =  BasicConv2d(in_channels=64,out_channels=192,kernel_size=1)  #output 56*56
        self.conv3 = BasicConv2d(in_channels=64, out_channels=192, kernel_size=3, padding=1)  # output 56*56
        self.maxpool2 = nn.MaxPool2d(kernel_size=3,stride=2)

        self.inception3a = Inceptionv1(in_dim = 192,hid_1_1=64 ,hid_2_1=96,hid_2_3=128,hid_3_1=16,out_3_5=32,out_4_1=32)
        self.inception3b = Inceptionv1(in_dim = 256,hid_1_1=128 ,hid_2_1=128,hid_2_3=192,hid_3_1=32,out_3_5=96,out_4_1=64)
        self.maxpool3 = nn.MaxPool2d(kernel_size=3,stride=2)

        self.inception4a = Inceptionv1(in_dim=480,hid_1_1=192 ,hid_2_1=96,hid_2_3=208,hid_3_1=16,out_3_5=48,out_4_1=64)
        self.inception4b = Inceptionv1(in_dim=512, hid_1_1=160, hid_2_1=112, hid_2_3=244, hid_3_1=24, out_3_5=64,out_4_1=64)
        self.inception4c = Inceptionv1(in_dim=512, hid_1_1=128, hid_2_1=128, hid_2_3=256, hid_3_1=24, out_3_5=64, out_4_1=64)
        self.inception4d = Inceptionv1(in_dim=512, hid_1_1=256, hid_2_1=160, hid_2_3=320, hid_3_1=32, out_3_5=128,out_4_1=128)
        self.inception4e = Inceptionv1(in_dim=528, hid_1_1= 256, hid_2_1=160, hid_2_3=320, hid_3_1=32, out_3_5=128, out_4_1=128)
        self.maxpool4 = nn.MaxPool2d(kernel_size=3,stride=2)

        self.inception5a = Inceptionv1(in_dim=832,hid_1_1=256 ,hid_2_1=160,hid_2_3=320,hid_3_1=32,out_3_5=128,out_4_1=128)
        self.inception5a = Inceptionv1(in_dim=832, hid_1_1=256, hid_2_1=160, hid_2_3=320, hid_3_1=32, out_3_5=128,out_4_1=128)

        if self.aux_add:
            self.aux1 = InceptionAux(512,class_num)
            self.aux2 = InceptionAux(528,class_num)

        self.avgpool = nn.AdaptiveAvgPool2d((1,1))
        self.dropout = nn.Dropout(p=0.4)  #0.4的效果更好
        self.fc  = nn.Linear(1024,class_num)

        if init_weight:
            self._initialize_weights()



    def forward(self,x):
        #Nx3x244x244
        x = self.conv1(x)
        #Nx64x12x112
        x = self.maxpool1(x)
        #Nx64x56x56
        x = self.conv2(x)
        #Nx64x56x56
        x = self.conv3(x)
        # N x 192 x 56 x 56
        x = self.maxpool2(X)

        # N x 192 x 28 x 28
        x = self.inception3a(x)
        # N x 256 x 28 x 28
        x = self.inception3b(x)
        # N x 480 x 28 x 28
        x = self.maxpool3(x)
        # N x 480 x 14 x 14
        x = self.inception4a(x)
        # N x 512 x 14 x 14

        if self.training and self.aux_logits:  # eval model lose this layer
            aux1 = self.aux1(x)

        x = self.inception4b(x)
        # N x 512 x 14 x 14
        x = self.inception4c(x)
        # N x 512 x 14 x 14
        x = self.inception4d(x)
        # N x 528 x 14 x 14
        if self.training and self.aux_add:  # eval model lose this layer
            aux2 = self.aux2(x)

        x = self.inception4e(x)
        # N x 832 x 14 x 14
        x = self.maxpool4(x)
        # N x 832 x 7 x 7
        x = self.inception5a(x)
        # N x 832 x 7 x 7
        x = self.inception5b(x)
        # N x 1024 x 7 x 7

        x = self.avgpool(x)
        # N x 1024 x 1 x 1
        x = torch.flatten(x, 1)
        # N x 1024
        x = self.dropout(x)
        x = self.fc(x)
        # N x 1000 (num_classes)
        if self.training and self.aux_add:   # eval model lose this layer
            return x, aux2, aux1
        return




    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.constant_(m.bias, 0)


class InceptionAux(nn.Module):
    def __init__(self,in_channel,class_num):
        super(InceptionAux,self).__init__
        self.averagePool  = nn.AvgPool2d(kernel_size=5,stride=3)
        # output[batch, 128, 4, 4]
        self.conv1 = nn.Conv2d(in_channels=in_channel,out_channels=128,kernel_size=1,stride=1)
        self.fc1 = nn.Linear(2048,1024)
        self.fc2 = nn.Linear(1024,class_num)

    def forward(self,x):
        # inception_4a aux1: N x 512 x 14 x 14, inception_4b aux2: N x 528 x 14 x 14
        x = self.averagePool(x)
        # aux1: N x 512 x 4 x 4,   aux2: N x 528 x 4 x 4
        x = self.conv1(x)
        # N x 128 x 4 x 4

        x  = torch.flatten(x,1)
        x = nn.Dropout(x, 0.5, training=self.training)  #在训练时设为training，在测试时为False就是model.train()和model.eval()
        # N*2048
        x = relu(self.fc1(x),inplace=True)
        x = nn.Dropout(x,0.5,training = self.training)
        # N x 1024
        x = self.fc2(x)
        # N x num_classes
        return x