框架中有一个非常重要且好用的包：torchvision，顾名思义这个包主要是关于计算机视觉cv的。这个包主要由3个子包组成，分别是：torchvision.datasets、torchvision.models、torchvision.transforms。

具体介绍可以参考官网：https://pytorch.org/docs/master/torchvision

具体代码可以参考github：https://github.com/pytorch/vision

承接上一篇，今天来看看inception V3的pytorch实现。

关于inception系列的论文笔记可以查看https://blog.csdn.net/sinat_33487968/article/details/83588372

首先因为有很多卷积的操作是重复的，所以定义了一个BasicConv2d的类，

class BasicConv2d(nn.Module):

    def __init__(self, in_channels, out_channels, **kwargs):
        super(BasicConv2d, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, bias=False, **kwargs)
        self.bn = nn.BatchNorm2d(out_channels, eps=0.001)

    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        return F.relu(x, inplace=True)

这个类实现了最基本的卷积加上BN的操作，因为in_channels和out_channels是我们可以自己定义的，而且**kwargs的意思是能接收多个赋值，这也意味着我们我可以定义卷积的stride大小，padding的大小等等。我们将会在下面的inception模块中不断复用这个类。

 

然后inception系列的网络架构最最重点对的当然是module的构建，这里实现了inceptionA~E五种不同结构的inception module，但是我发现并没有在原论文里面完全一样，可能是实现的时候修改了吧。不管怎么样，module的样子大概就是下图这样：

来看看这个inceptionA。这里的结构大致是一个module里面有四个分支，__init__里面就是结构的定义。第一个分支是branch1，只有一个1*1的卷积；第二个分支是两个5*5的卷积；第三个分支是三个3*3的卷积；而第四个分支没有卷积，是一个简单的pooling。你可能会有疑问为什么不同的卷积核的输出大小是一样大，因为这里特别的针对每个分支有不同的padding（零填充），然后每个分支stride的步数都为1，最后就回输出大小相同的卷积结果。

值得我们注意的是最后outputs = [branch1x1, branch5x5, branch3x3dbl, branch_pool]这个操作就是将不同的分支都concaternation相结合在一起。

class InceptionA(nn.Module):

    def __init__(self, in_channels, pool_features):
        super(InceptionA, self).__init__()
        self.branch1x1 = BasicConv2d(in_channels, 64, kernel_size=1)

        self.branch5x5_1 = BasicConv2d(in_channels, 48, kernel_size=1)
        self.branch5x5_2 = BasicConv2d(48, 64, kernel_size=5, padding=2)

        self.branch3x3dbl_1 = BasicConv2d(in_channels, 64, kernel_size=1)
        self.branch3x3dbl_2 = BasicConv2d(64, 96, kernel_size=3, padding=1)
        self.branch3x3dbl_3 = BasicConv2d(96, 96, kernel_size=3, padding=1)

        self.branch_pool = BasicConv2d(in_channels, pool_features, kernel_size=1)

    def forward(self, x):
        branch1x1 = self.branch1x1(x)

        branch5x5 = self.branch5x5_1(x)
        branch5x5 = self.branch5x5_2(branch5x5)

        branch3x3dbl = self.branch3x3dbl_1(x)
        branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)
        branch3x3dbl = self.branch3x3dbl_3(branch3x3dbl)

        branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
        branch_pool = self.branch_pool(branch_pool)

        outputs = [branch1x1, branch5x5, branch3x3dbl, branch_pool]
        return torch.cat(outputs, 1)

同理其他的module也是大同小异，这里就不多说了。我们来看一下特别的network in network in network结构，这里的意思是有一个特殊的module它里面有两重分支。

在这里这个分支叫InceptionE。下面完整的代码可以看到在第二个分支self.branch3x3_1后面有两个层self.branch3x3_2a和self.branch3x3_2b，他们就是在第一层传递之后第二层分叉了，最后又在重点结合在一起。怎么做到的呢？

branch3x3 = [
            self.branch3x3_2a(branch3x3),
            self.branch3x3_2b(branch3x3),
        ] 

这里就是将两个结果合并在一起，最后再做一次最后的合并：

outputs = [branch1x1, branch3x3, branch3x3dbl, branch_pool]

branch3x3 = torch.cat(branch3x3, 1)

class InceptionE(nn.Module):

    def __init__(self, in_channels):
        super(InceptionE, self).__init__()
        self.branch1x1 = BasicConv2d(in_channels, 320, kernel_size=1)

        self.branch3x3_1 = BasicConv2d(in_channels, 384, kernel_size=1)
        self.branch3x3_2a = BasicConv2d(384, 384, kernel_size=(1, 3), padding=(0, 1))
        self.branch3x3_2b = BasicConv2d(384, 384, kernel_size=(3, 1), padding