经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)

卷积神经网络演化史

经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第1张图片

AlexNet

模型结构

经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第2张图片
经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第3张图片

贡献

  • ReLU激活函数
    经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第4张图片

  • 分布式GPU运算

  • LRN(局部响应归一化),提高泛化能力
    经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第5张图片

  • 重叠池化,池化窗的步长小于池化层的大小,在池
    化时产生重叠。

正则化方法

  • 数据集增强
  • dropout,随机关闭神经元

实现代码

import torch
from torch import nn

net = nn.Sequential(
    # 这里,我们使用一个11*11的更大窗口来捕捉对象。
    # 同时,步幅为4,以减少输出的高度和宽度。
    # 另外,输出通道的数目远大于LeNet
    nn.Conv2d(1, 96, kernel_size=11, stride=4, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    # 减小卷积窗口,使用填充为2来使得输入与输出的高和宽一致,且增大输出通道数
    nn.Conv2d(96, 256, kernel_size=5, padding=2), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    # 使用三个连续的卷积层和较小的卷积窗口。
    # 除了最后的卷积层,输出通道的数量进一步增加。
    # 在前两个卷积层之后,汇聚层不用于减少输入的高度和宽度
    nn.Conv2d(256, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(256, 256, kernel_size=3, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nn.Flatten(),
    # 这里,全连接层的输出数量是LeNet中的好几倍。使用dropout层来减轻过拟合
    nn.Dropout(p=0.5),
    nn.Linear(256*6*6, 4096), nn.ReLU(),
    nn.Dropout(p=0.5),
    nn.Linear(4096, 4096), nn.ReLU(),
    nn.Dropout(p=0.5),
    nn.Linear(4096, 1000))

VggNet

模型结构

经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第6张图片
经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第7张图片

主要贡献

  • 使用更小的卷积核
    小卷积核探测面积小,大卷积核探测面积大。使用2个3 * 3卷积核的“探测”面积等价于1一个5 * 5卷积核的“探测”面积;使用3个3 * 3卷积核的“探测”面积等价于1一个7 * 7卷积核的“探测”面积。
    小卷积核堆叠使用更少的参数;小卷积核堆叠使用更少的计算量;小卷积核堆叠的非线性表达能力更强。
    经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第8张图片

  • 更深的模型

实现代码

原始VGG网络有5个卷积块,其中前两个块各有一个卷积层,后三个块各包含两个卷积层。 第一个模块有64个输出通道,每个后续模块将输出通道数量翻倍,直到该数字达到512。由于该网络使用8个卷积层和3个全连接层,因此它通常被称为VGG-11。

def vgg_block(num_convs, in_channels, out_channels):
    layers = []
    for _ in range(num_convs):
        layers.append(nn.Conv2d(in_channels, out_channels,
                                kernel_size=3, padding=1))
        layers.append(nn.ReLU())
        in_channels = out_channels
    layers.append(nn.MaxPool2d(kernel_size=2,stride=2))
    return nn.Sequential(*layers)

conv_arch = ((1, 64), (1, 128), (2, 256), (2, 512), (2, 512))

def vgg(conv_arch):
    conv_blks = []
    in_channels = 1
    # 卷积层部分
    for (num_convs, out_channels) in conv_arch:
        conv_blks.append(vgg_block(num_convs, in_channels, out_channels))
        in_channels = out_channels

    return nn.Sequential(
        *conv_blks, nn.Flatten(),
        # 全连接层部分
        nn.Linear(out_channels * 7 * 7, 4096), nn.ReLU(), nn.Dropout(0.5),
        nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(0.5),
        nn.Linear(4096, 10))

net = vgg(conv_arch)
X = torch.randn(size=(1, 1, 224, 224))
for blk in net:
    X = blk(X)
    print(blk.__class__.__name__,'output shape:\t',X.shape)

经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第9张图片

NiN

模型结构

经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第10张图片
经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第11张图片

主要贡献

  • MlpConv 结构
    MlpConv可提取非线性特征,减少了卷积层与卷积核的数量;使用1 * 1卷积大大降低了参数规模。
    经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第12张图片

经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第13张图片

  • 全局平均池化(GAP)
    将卷积后的特征图使用与特征图等大的窗口执行平均池化,使得每一张特征图均转化为一个标量值。通过使用全局平均池化替代全连接层,极大的降低了模型参数规模,起到了正则化的作用,提高了模型性能

代码实现

def nin_block(in_channels, out_channels, kernel_size, strides, padding):
    return nn.Sequential(
        nn.Conv2d(in_channels, out_channels, kernel_size, strides, padding),
        nn.ReLU(),
        nn.Conv2d(out_channels, out_channels, kernel_size=1), nn.ReLU(),
        nn.Conv2d(out_channels, out_channels, kernel_size=1), nn.ReLU())

net = nn.Sequential(
    nin_block(1, 96, kernel_size=11, strides=4, padding=0),
    nn.MaxPool2d(3, stride=2),
    nin_block(96, 256, kernel_size=5, strides=1, padding=2),
    nn.MaxPool2d(3, stride=2),
    nin_block(256, 384, kernel_size=3, strides=1, padding=1),
    nn.MaxPool2d(3, stride=2),
    nn.Dropout(0.5),
    # 标签类别数是10
    nin_block(384, 10, kernel_size=3, strides=1, padding=1),
    nn.AdaptiveAvgPool2d((1, 1)),
    # 将四维的输出转成二维的输出,其形状为(批量大小,10)
    nn.Flatten())

GoogLeNet

模型结构

经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第14张图片
经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第15张图片
经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第16张图片
经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第17张图片

主要贡献

  1. Inception Module
    使用多个并行且较小的稠密卷积与池化近似稀疏连接;
  2. 引入1 * 1卷积改进Inception Module,降低了模型参数数量与特征图大小
  3. 加入辅助分类器解决梯度消失问题
  4. 取消全连接层,使用GAP代替

Inception 模型结构

经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第18张图片

并联执行小规模的卷积池化,使得卷积结构变得更加稀疏;
卷积采用不同大小的卷积核,可提取不同尺度上的特征;
并联的卷积与池化得到的特征图再通道上进行拼接,使得后面的层能够利用前面提取到的多尺度特征;
合并通道带来维度灾难问题,尤其是池化层。
使用 1 * 1 卷积降低了模型参数规模;
使用 1 * 1 卷积降低了通道规模;
两次卷积提高了Inception模块的非线性拟合能力

代码实现

class Inception(nn.Module):
    # c1--c4是每条路径的输出通道数
    def __init__(self, in_channels, c1, c2, c3, c4, **kwargs):
        super(Inception, self).__init__(**kwargs)
        # 线路1,单1x1卷积层
        self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1)
        # 线路2,1x1卷积层后接3x3卷积层
        self.p2_1 = nn.Conv2d(in_channels, c2[0], kernel_size=1)
        self.p2_2 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1)
        # 线路3,1x1卷积层后接5x5卷积层
        self.p3_1 = nn.Conv2d(in_channels, c3[0], kernel_size=1)
        self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_size=5, padding=2)
        # 线路4,3x3最大汇聚层后接1x1卷积层
        self.p4_1 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
        self.p4_2 = nn.Conv2d(in_channels, c4, kernel_size=1)

    def forward(self, x):
        p1 = F.relu(self.p1_1(x))
        p2 = F.relu(self.p2_2(F.relu(self.p2_1(x))))
        p3 = F.relu(self.p3_2(F.relu(self.p3_1(x))))
        p4 = F.relu(self.p4_2(self.p4_1(x)))
        # 在通道维度上连结输出
        return torch.cat((p1, p2, p3, p4), dim=1)

ResNet

模型结构

经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第19张图片

经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第20张图片
经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第21张图片

主要贡献

  1. 残差块
    经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第22张图片
    经典神经网络( AlexNet,VggNet,NiN,GoogLeNet,ResNet)_第23张图片
    快捷连接连接着两个高维端,避免违反了表示瓶颈原则;
    参数量与计算量比无瓶颈结构更少;
    引入更多的非线性层,提高了模型的表示能力

代码实现

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

class Residual(nn.Module):  #@save
    def __init__(self, input_channels, num_channels,
                 use_1x1conv=False, strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(input_channels, num_channels,
                               kernel_size=3, padding=1, stride=strides)
        self.conv2 = nn.Conv2d(num_channels, num_channels,
                               kernel_size=3, padding=1)
        if use_1x1conv:
            self.conv3 = nn.Conv2d(input_channels, num_channels,
                                   kernel_size=1, stride=strides)
        else:
            self.conv3 = None
        self.bn1 = nn.BatchNorm2d(num_channels)
        self.bn2 = nn.BatchNorm2d(num_channels)

    def forward(self, X):
        Y = F.relu(self.bn1(self.conv1(X)))
        Y = self.bn2(self.conv2(Y))
        if self.conv3:
            X = self.conv3(X)
        Y += X
        return F.relu(Y)

#残差快
def resnet_block(input_channels, num_channels, num_residuals,
                 first_block=False):
    blk = []
    for i in range(num_residuals):
        if i == 0 and not first_block:
            blk.append(Residual(input_channels, num_channels,
                                use_1x1conv=True, strides=2))
        else:
            blk.append(Residual(num_channels, num_channels))
    return blk

#ResNet的前两层跟之前介绍的GoogLeNet中的一样: 在输出通道数为64、步幅为2的 7×7 卷积层后,接步幅为2的 3×3 的最大汇聚层。 不同之处在于ResNet每个卷积层后增加了批量规范化层。

b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
                   nn.BatchNorm2d(64), nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
                   
# ResNet则使用4个由残差块组成的模块,每个模块使用若干个同样输出通道数的残差块。 第一个模块的通道数同输入通道数一致
b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True))
b3 = nn.Sequential(*resnet_block(64, 128, 2))
b4 = nn.Sequential(*resnet_block(128, 256, 2))
b5 = nn.Sequential(*resnet_block(256, 512, 2))
#在ResNet中加入全局平均汇聚层,以及全连接层输出
net = nn.Sequential(b1, b2, b3, b4, b5,
                    nn.AdaptiveAvgPool2d((1,1)),
                    nn.Flatten(), nn.Linear(512, 10))

你可能感兴趣的:(经典模型,神经网络,深度学习,cnn)