神经网络

1. 走向深度：VGGNet

    随着AlexNet在2012年ImageNet大赛上大放异彩后， 卷积网络进入了飞速的发展阶段， 而2014年的ImageNet亚军结构VGGNet（Visual Geometry Group Network） 则将卷积网络进行了改良， 探索了网络深度与性能的关系， 用更小的卷积核与更深的网络结构， 取得了较好的效果， 成为卷积结构发展史上较为重要的一个网络。

    VGGNet网络结构组成如图3.12所示， 一共有6个不同的版本， 最常用的是VGG16。 从图3.12中可以看出， VGGNet采用了五组卷积与三个全连接层， 最后使用Softmax做分类。 VGGNet有一个显著的特点： 每次经过池化层（maxpool） 后特征图的尺寸减小一倍， 而通道数则增加一倍（最后一个池化层除外） 。

    AlexNet中有使用到5×5的卷积核， 而在VGGNet中， 使用的卷积核基本都是3×3， 而且很多地方出现了多个3×3堆叠的现象， 这种结构的优点在于， 首先从感受野来看， 两个3×3的卷积核与一个5×5的卷积核是一样的； 其次， 同等感受野时， 3×3卷积核的参数量更少。 更为重要的是， 两个3×3卷积核的非线性能力要比5×5卷积核强， 因为其拥有两个激活函数， 可大大提高卷积网络的学习能力。

  下面使用PyTorch来搭建VGG16经典网络结构， 新建一个vgg.py文件， 并输入以下内容 :

import torch
from torch import nn

class VGG(nn.Module):

    def __init__(self, num_classes=1000):
        super(VGG, self).__init__()
        layers = []
        in_dim = 3
        out_dim = 64

        # 循环构造卷积层， 一共有13个卷积层
        for i in range(13):
            layers += [nn.Conv2d(in_dim, out_dim, 3, 1, 1), nn.ReLU(inplace=True)]
            in_dim = out_dim
            # 在第2、 4、 7、 10、 13个卷积层后增加池化层
            if i==1 or i==3 or i==6 or i==9 or i==12:
                layers += [nn.MaxPool2d(2, 2)]
                # 第10个卷积后保持和前边的通道数一致， 都为512， 其余加倍
                if i!=9:
                    out_dim*=2
         
        self.features = nn.Sequential(*layers)
         # VGGNet的3个全连接层， 中间有ReLU与Dropout层
        self.classifier = nn.Sequential(
                nn.Linear(512*7*7, 4096),
                nn.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)
    # 这里是将特征图的维度从[1, 512, 7, 7]变到[1, 512*7*7]
        x = x.view(x.size(0), -1)
        x =  self.classifier(x)
        return x

 在终端中进入上述vgg.py文件的同级目录， 输入python3进入交互式环境， 利用下面代码调用该模块。

import torch
from vgg import VGG

vgg = VGG(21).cuda()
input = torch.randn(1, 3, 224, 224).cuda()
print(input.shape)
>> torch.Size([1, 3, 224, 224]

scores = vgg(input)
print(scores.shape)
>> torch.Size([1, 21])

features = vgg.features(input)
print(features.shape)
>> torch.Size([1, 512, 7, 7])
print(vgg.features)
>> Sequential(
  (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (1): ReLU(inplace=True)
  (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (3): ReLU(inplace=True)
  (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (6): ReLU(inplace=True)
  (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (8): ReLU(inplace=True)
  (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (11): ReLU(inplace=True)
  (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (13): ReLU(inplace=True)
  (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (15): ReLU(inplace=True)
  (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (18): ReLU(inplace=True)
  (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (20): ReLU(inplace=True)
  (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (22): ReLU(inplace=True)
  (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (25): ReLU(inplace=True)
  (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (27): ReLU(inplace=True)
  (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (29): ReLU(inplace=True)
  (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)