常用分类网络结构学习笔记

开源代码地址：https://github.com/shanglianlm0525/PyTorch-Networks

VGG Net

输入是大小为224224的RGB图像，预处理：计算出三个通道的平均值，在每个像素上减去平均值（处理后迭代更少，更快收敛，数据标准化）
卷积层：使用非常小的33的卷积核，在有些卷积层里使用11的卷积核；卷积步长（stride）设置为1个像素，33卷积层的填充设置为1个像素。池化层采用max pooling,共有5层（224-112-56-28-14-7），在一部分卷积层后，max-pooling的窗口是22，步长设置为2
全连接层：三个全连接层，前两个均有4096个通道，第三个有1000个，用来分类。
softmax:分类函数
激活函数：ReLU函数
特点：
1，选择采用33的卷积核是因为33是最小的能够捕捉像素8邻域信息的的尺寸。
2，使用11的卷积核目的是在不影响输入输出的维度情况下，对输入进行形变，再通过ReLU进行非线性处理，提高决策函数的非线性。
3，2个33卷积堆叠等于1个55卷积，3个33堆叠等于1个77卷积，感受野大小不变，而采用更多层、更小的卷积核可以引入更多非线性（更多的隐藏层，从而带来更多非线性函数），提高决策函数判决力，并且带来更少参数。
4.每个VGG网络都有3个FC层，5个池化层，1个softmax层。
5，在FC层中间采用dropout层，防止过拟合

import torch.nn as nn
import math


class VGG(nn.Module):

    def __init__(self, features, num_classes=1000, init_weights=True):
        super(VGG, self).__init__()
        self.features = features
        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),
        )
        if init_weights:
            self._initialize_weights()

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, math.sqrt(2. / n))
                if m.bias is not None:
                    m.bias.data.zero_()
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()
            elif isinstance(m, nn.Linear):
                m.weight.data.normal_(0, 0.01)
                m.bias.data.zero_()


def make_layers(cfg, batch_norm=False):
    layers = []
    in_channels = 3
    for v in cfg:
        if v == 'M':
            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
        else:
            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
            if batch_norm:
                layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
            else:
                layers += [conv2d, nn.ReLU(inplace=True)]
            in_channels = v
    return nn.Sequential(*layers)


cfg = {
   
    'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
    'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
    'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
    'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
}


def vgg11(**kwargs):
    model = VGG(make_layers(cfg['A']), **kwargs)
    return model


def vgg11_bn(**kwargs):
    model = VGG(make_layers(cfg['A'], batch_norm=True), **kwargs)
    return model


def vgg13(**kwargs):
    model = VGG(make_layers(cfg['B']), **kwargs)
    return model


def vgg13_bn(**kwargs):
    model = VGG(make_layers(cfg['B'], batch_norm=True), **kwargs)
    return model


def vgg16(**kwargs):
    model = VGG(make_layers(cfg['D']), **kwargs)
    return model


def vgg16_bn(**kwargs):
    model = VGG(make_layers(cfg['D'], batch_norm=True), **kwargs)
    return model


def vgg19(**kwargs):
    model = VGG(make_layers(cfg['E']), **kwargs)
    return model


def vgg19_bn(**kwargs):
    model = VGG(make_layers(cfg['E'], batch_norm=True), **kwargs)
    return model


if __name__ == '__main__':
    # 'VGG', 'vgg11', 'vgg11_bn', 'vgg13', 'vgg13_bn', 'vgg16', 'vgg16_bn', 'vgg19_bn', 'vgg19'
    # Example
    net11 = vgg11()
    print(net11)

ResNet

面临问题：深度学习的网络深度遭遇瓶颈，在不断加深神经网络的深度时，会出现退化(Degradation)问题，即准确率会先上升然后达到饱和，再持续增加深度会导致准确率下降。这并不是过拟合问题，因为不光在测试集上误差增大，训练集本身误差也会增大。原因是随着网络越来越深，训练变得原来越难，网络的优化变得越来越难。理论上，越深的网络，效果应该更好；但实际上，由于训练难度，过深的网络会产生退化问题，效果反而不如相对较浅的网络。而残差网络就可以解决这个问题的，残差网络越深，训练集上的效果会越好

残差模块

残差模块的计算方式：$F(x)=W_2\ast relu(W_1\ast x)$
残差模块输出：$relu(F(x)+x)$
残差块误差优化： 残差网络通过加入 shortcut connections（或称为 skip connections），变得更加容易被优化。在不用skip连接之前，假设输入是$x$，最优输出是$x$，此时的优化目标是预测输出H(x)=x，加入skip连接后，优化输出H(x)与输入x的差别，即为残差F(x)=H(x)−x，此时的优化目标是F(x)的输出值为0。后者会比前者更容易优化。
**用残差更容易优化：**引入残差后的映射对输出的变化更敏感。设$H1(x)$是加入skip连接前的网络映射，$H2(x)$是加入skip连接的网络映射。对于输入x=5，设此时H1(5)=5.1，H2(x)=5.1,H2(5)=F(5)+5,F(5)=0.1当输出变为5.2时，H1(x)由5.1变为5.2，F(x)由0.1变为0.2，明显后者输出变化对权重的调整作用更大，所以效果更好。残差的思想都是去掉相同的主体部分，从而突出微小的变化。
简单的加法不会给网络增加额外的参数和计算量，同时可以大大增加模型的训练速度，提高训练效果。并且当模型的层数加深时，能够有效地解决退化问题。
**残差网络为什么是有效的：**对于大型的网络，无论把残差块添加到神经网络的中间还是末端，都不会影响网络的表现。因为可以给残差快中的weight设置很大的L2正则化水平，使得F(x)=0，这样使得加入残差块至少不会使得网络变差，此时的残块等价于恒等映射。若此时残差块中的weight学到了有用的信息，那就会比恒等映射更好，对网络的性能有帮助。
总结： ResNet有很多旁路支线可以将输入直接连到后面的层，使得后面的层可以直接学习残差，简化了学习难度。传统的卷积层和全连接层在信息传递时，或多或少会存在信息丢失，损耗等问题。ResNet将输入信息绕道传到输出，保护了信息的完整性。

ResNet网络搭建 PyTorch

import torch
import torch.nn as nn
import torch.nn.functional as F
# 用于ResNet18和34的残差块，用的是2个3x3的卷积
class BasicBlock(nn.Module):
    expansion = 1
    def __init__(self, in_planes, planes, stride=1):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3,
                               stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
                               stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.shortcut = nn.Sequential()
        # 经过处理后的x要与x的维度相同(尺寸和深度)
        # 如果不相同，需要添加卷积+BN来变换为同一维度
        if stride != 1 or in_planes != self.expansion*planes:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_planes, self.expansion*planes,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(self.expansion*planes)
            )

    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += self.shortcut(x)
        out = F.relu(out)
        return out


# 用于ResNet50,101和152的残差块，用的是1x1+3x3+1x1的卷积
class Bottleneck(nn.Module):
    # 前面1x1和3x3卷积的filter个数相等，最后1x1卷积是其expansion倍
    expansion = 4

    def __init__(self, in_planes, planes, stride=