CNN成长路:从AlexNet到EfficientNet(01)

一、说明

        在 10年的深度学习中,进步是多么迅速!早在 2012 年,Alexnet 在 ImageNet 上的准确率就达到了 63.3% 的 Top-1。现在,我们超过90%的EfficientNet架构和师生训练(teacher-student)。

        如果我们在 Imagenet 上绘制所有报告作品的准确性,我们会得到这样的结果:

CNN成长路:从AlexNet到EfficientNet(01)_第1张图片

来源:Papers with Code - Imagenet Benchmark

在本文中,我们将重点介绍卷积神经网络(CNN)架构的演变。我们将专注于基本原则,而不是报告简单的数字。为了提供另一种视觉概览,可以在单个图像中捕获2018年之前表现最佳的CNN:

CNN成长路:从AlexNet到EfficientNet(01)_第2张图片

截至 2018 年的架构概述。资料来源:Simone Bianco et al. 2018

不要惊慌失措。所有描述的体系结构都基于我们将要描述的概念。

请注意,每秒浮点运算数 (FLOP) 表示模型的复杂性,而在垂直轴上,我们有 Imagenet 精度。圆的半径表示参数的数量。

从上图中可以看出,更多的参数并不总是能带来更好的准确性。我们将尝试对CNN进行更广泛的思考,看看为什么这是正确的。

如果您想从头开始了解卷积的工作原理,请推荐 Andrew 的 Ng 课程。

二、第一阶段:CNN架构的递进

2.1 术语解释

        但首先,我们必须定义一些术语:

  • 更宽的网络意味着卷积层中更多的特征图(过滤器)

  • 更深的网络意味着更多的卷积层

  • 具有更高分辨率的网络意味着它处理具有更大宽度和深度(空间分辨率)的输入图像。这样,生成的特征图将具有更高的空间维度。

CNN成长路:从AlexNet到EfficientNet(01)_第3张图片

架构扩展。来源:谭明兴,Quoc V. Le 2019

架构工程就是关于扩展的。我们将彻底使用这些术语,因此在继续之前请务必理解它们。

2.2 AlexNet: ImageNet Classification with Deep Convolutional Neural Networks (2012)

        Alexnet [1] 由 5 个从 11x11 内核开始的卷积层组成。它是第一个采用最大池化层、ReLu 激活函数和 3 个巨大线性层的 dropout 的架构。该网络用于具有 1000 个可能类的图像分类,这在当时是疯狂的。现在,您可以在 35 行 PyTorch 代码中实现它:

class AlexNet(nn.Module):
    def __init__(self, num_classes: int = 1000) -> None:
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(64, 192, kernel_size=5, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(192, 384, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
        )

        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))
        self.classifier = nn.Sequential(
            nn.Dropout(),
            nn.Linear(256 * 6 * 6, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Linear(4096, num_classes),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

        这是第一个在 Imagenet 上成功训练的卷积模型,当时在 CUDA 中实现这样的模型要困难得多。Dropout 在巨大的线性变换中大量使用,以避免过度拟合。在 2015-2016 年自动微分出现之前,在 GPU 上实现反向传播需要几个月的时间。

2.3 VGG (2014)

        著名的论文“用于大规模图像识别的非常深度卷积网络”[2]使深度一词病毒式传播。这是第一项提供不可否认证据的研究,证明简单地添加更多层可以提高性能。尽管如此,这一假设在一定程度上是正确的。为此,他们只使用3x3内核,而不是AlexNet。该架构使用 224 × 224 个 RGB 图像进行训练。

        主要原理是一叠三3×3 转换层类似于单个7×7 层。甚至可能更好!因为它们在两者之间使用三个非线性激活(而不是一个),这使得函数更具鉴别性。

        其次,这种设计减少了参数的数量。具体来说,您需要3*(3^2) C^2= 27 \times C^2 权重,与7×7 需要的转换层(1*72)C^2=49C^2  参数(增加 81%)。

        直观地,它可以被视为对7×7 转换过滤器,限制它们具有 3x3 非线性分解。最后,这是规范化开始成为一个相当成问题的架构。

        尽管如此,预训练的VGG仍然用于生成对抗网络中的特征匹配损失,以及神经风格转移和特征可视化。

        以我的拙见,检查凸网相对于输入的特征非常有趣,如以下视频所示:

        最后,在Alexnet旁边进行视觉比较:

CNN成长路:从AlexNet到EfficientNet(01)_第4张图片

来源:斯坦福大学2017年深度学习讲座:CNN架构

2.4 InceptionNet/GoogleNet (2014)

        在VGG之后,Christian Szegedy等人的论文“Go Deep with Convolutions”[3]是一个巨大的突破。

        动机:增加深度(层数)并不是使模型变大的唯一方法。如何增加网络的深度和宽度,同时将计算保持在恒定的水平?

        这一次的灵感来自人类视觉系统,其中信息在多个尺度上进行处理,然后在本地聚合[3]。如何在不发生记忆爆炸的情况下实现这一目标?

        答案是1×1 卷 积!主要目的是通过减少每个卷积块的输出通道来减小尺寸。然后我们可以处理具有不同内核大小的输入。只要填充输出,它就与输入相同。

        要找到具有单步幅且无扩张的合适填充,请填充p和内核k被定义为out=in(输入和输出空间调光):

        out=in+2*p-k+1,这意味着p=(k-1)/2..在 Keras 中,您只需指定 padding='same'。这样,我们可以连接与不同内核卷积的特征。

        然后我们需要1×1 卷积层将特征“投影”到更少的通道,以赢得计算能力。有了这些额外的资源,我们可以添加更多的层。实际上,1×1 convs 的工作方式类似于低维嵌入。

有关 1x1 转换的快速概述,请推荐来自著名 Coursera 课程的以下视频:

        这反过来又允许通过使用Inception模块不仅增加深度,而且增加著名的GoogleNet的宽度。核心构建块称为 inception 模块,如下所示:

CNN成长路:从AlexNet到EfficientNet(01)_第5张图片

       

        整个架构被称为GoogLeNet或InceptionNet。从本质上讲,作者声称他们试图用正常的密集层近似稀疏的凸网(如图所示)。

        为什么?因为他们相信只有少数神经元是有效的。这符合Hebbian原则:“一起放电的神经元,连接在一起”。

        此外它使用不同内核大小的卷积(5×55×5,3×33×3,1×11×1) 以捕获多个比例下的细节.

通常,对于驻留在全局的信息,首选较大的内核,对于本地分发的信息,首选较小的内核。

        此外1×1 卷积用于在计算成本高昂的卷积(3×3 和 5×5)之前计算约简。

        InceptionNet/GoogLeNet架构由9个堆叠在一起的初始模块组成,其间有最大池化层(将空间维度减半)。它由 22 层组成(27 层带有池化层)。它在上次启动模块之后使用全局平均池化。

        我写了一个非常简单的 Inception 块实现,可能会澄清一些事情:

import torch
import torch.nn as nn

class InceptionModule(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(InceptionModule, self).__init__()
        relu = nn.ReLU()
        self.branch1 = nn.Sequential(
                  nn.Conv2d(in_channels, out_channels=out_channels, kernel_size=1, stride=1, padding=0),
                  relu)

        conv3_1 = nn.Conv2d(in_channels, out_channels=out_channels, kernel_size=1, stride=1, padding=0)
        conv3_3 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1)
        self.branch2 = nn.Sequential(conv3_1, conv3_3,relu)

        conv5_1 = nn.Conv2d(in_channels, out_channels=out_channels, kernel_size=1, stride=1, padding=0)
        conv5_5 = nn.Conv2d(out_channels, out_channels, kernel_size=5, stride=1, padding=2)
        self.branch3 = nn.Sequential(conv5_1,conv5_5,relu)

        max_pool_1 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
        conv_max_1 = nn.Conv2d(in_channels, out_channels=out_channels, kernel_size=1, stride=1, padding=0)
        self.branch4 = nn.Sequential(max_pool_1, conv_max_1,relu)

    def forward(self, input):
        output1 = self.branch1(input)
        output2 = self.branch2(input)
        output3 = self.branch3(input)
        output4 = self.branch4(input)
        return torch.cat([output1, output2, output3, output4], dim=1)

model = InceptionModule(in_channels=3,out_channels=32)
inp = torch.rand(1,3,128,128)
print(model(inp).shape)
torch.Size([1, 128, 128, 128])

        当然,您可以在激活函数之前添加规范化层。但由于归一化技术不是很成熟,作者引入了两个辅助分类器。原因是:梯度消失问题)。

2.5 Inception V2, V3 (2015)

后来,在论文“重新思考计算机视觉的初始体系结构”中,作者基于以下原则改进了Inception模型:

  • 将 5x5 和 7x7(在 InceptionV3 中)卷积分别分解为两个和三个 3x3 顺序卷积。这提高了计算速度。这与 VGG 的原理相同。

  • 他们使用了空间上可分的卷积。简单地说,一个 3x3 内核被分解为两个较小的内核:一个 1x3 和一个 3x1 内核,它们按顺序应用。

  • 初始模块变得更宽(更多特征图)。

  • 他们试图在网络的深度和宽度之间以平衡的方式分配计算预算。

  • 他们添加了批量规范化。

inception 模型的更高版本是 InceptionV4 和 Inception-Resnet。

2.6 ResNet:用于图像识别的深度残差学习(2015)

所有预先描述的问题(例如梯度消失)都通过两个技巧得到解决:

  • 批量归一化和

  • 短跳跃连接

        而不是H(x)=F(x) ,我们要求他们模型学习差异(残差)H'(x)=F(x)+x,这意味着H( x) - x=F(x)将是剩余部分 [4]。

CNN成长路:从AlexNet到EfficientNet(01)_第6张图片

来源:斯坦福大学2017年深度学习讲座:CNN架构

        通过这个简单但有效的模块,作者设计了从18层(Resnet-18)到150层(Resnet-150)的更深层次的架构。

        对于最深的模型,他们采用了 1x1 卷积,如右图所示:

CNN成长路:从AlexNet到EfficientNet(01)_第7张图片

图片来源:何开明等人,2015年。来源:用于图像识别的深度残差学习

瓶颈层(1×1)层首先减小然后恢复通道尺寸,使3×3层具有较少的输入和输出通道。

        总的来说,这里是整个架构的草图:

        有关更多详细信息,您可以在ResNets上观看Henry AI Labs的精彩视频:

你可以通过直接从Torchvision导入一堆ResNet来玩它们:

import torchvision
pretrained = True

# A lot of choices :P
model = torchvision.models.resnet18(pretrained)
model = torchvision.models.resnet34(pretrained)
model = torchvision.models.resnet50(pretrained)
model = torchvision.models.resnet101(pretrained)
model = torchvision.models.resnet152(pretrained)
model = torchvision.models.wide_resnet50_2(pretrained)
model = torchvision.models.wide_resnet101_2(pretrained)

n.models.wide_resnet101_2(pretrained)

试试吧!

你可能感兴趣的:(机器学习和深度学习,人工智能,神经网络)