1 模型介绍

2012年，$AlexKrizhevsky$、$IlyaSutskever$在多伦多大学Geoff Hinton的实验室设计出了一个深层的卷积神经网络AlexNet，夺得了2012年ImageNet LSVRC的冠军，且准确率远超第二名（top5错误率为15.3%，第二名为26.2%），引起了很大的轰动。AlexNet可以说是具有历史意义的一个网络结构。

2 模型结构

从图中可以看出，AlexNet网络结构分为上下两层，分别对应两个GPU的操作过程，除了中间某些层（$C_3$卷积层和$F_{6-8}$全连接层会有GPU间的交互）外，其他层两个GPU分别计算结果。除去局部响应规范化操作（Local Responsible Normalization, LRN），AlexNet一共包含8层，前5层由卷积层（其中卷积层1、2、5后含有下采样层）组成，而剩下的3层为全连接层。最后一层全连接层的输出作为$softmax$的输入，得到1000个图像分类标签对应的概率值。除了GPU并行结构的设计，AlexNet网络结构与LeNet十分相似，其网络的参数配置如下表所示。

Layer Name	Kernel Size	Kernel Num	Stride	Padding	Input Size	Output Size
Conv1	$11\times 11$	$48(\times 2_{GPU})$	$4$	$[1,2]$	$224\times 224\times 3$	$55\times 55\times 96$
Maxpool1	$3\times 3$	$/$	$2$	$0$	$55\times 55\times 96$	$27\times 27\times 96$
Conv2	$5\times 5$	$128(\times 2_{GPU})$	$1$	$[2,2]$	$27\times 27\times 96$	$27\times 27\times 256$
Maxpool2	$3\times 3$	$/$	$2$	$0$	$27\times 27\times 256$	$13\times 13\times 256$
Conv3	$3\times 3$	$192(\times 2_{GPU})$	$1$	$[1,1]$	$13\times 13\times 256$	$13\times 13\times 384$
Conv4	$3\times 3$	$192(\times 2_{GPU})$	$1$	$[1,1]$	$13\times 13\times 384$	$13\times 13\times 384$
Conv5	$3\times 3$	$128(\times 2_{GPU})$	$1$	$[1,1]$	$13\times 13\times 384$	$13\times 13\times 256$
Maxpool3	$3\times 3$	$/$	$2$	$0$	$13\times 13\times 256$	$6\times 6\times 256$
FC1	$2048$	$/$	$/$	$/$	$6\times 6\times 256$	4096
FC2	$2048$	$/$	$/$	$/$	4096	4096
FC3	$1000$	$/$	$/$	$/$	4096	1000

为了简化网络结构，将作者原论文中的在两个GPU上的并行结构合并，接下来我们对AlexNet的每一层作详细的分析。

1、Conv1: kernels:48×2=96；kernel_size:11；padding:[1, 2] ；stride:4

卷积层1输入的尺寸为224×224，卷积核的数量为96，论文中两片GPU分别计算48个核; 卷积核的大小为 11 × 11 × 3 ；卷积核步距stride = 4；padding=[1, 2]表示在原输入图像上左侧补一列0，右侧2列0，上侧一行0，下侧2行0。

输出feature map的尺寸为：N = (W − F + 2P ) / S + 1 = [ 224 - 11 + (1 + 2)] / 4 + 1 = 55

2、Maxpool1: kernel_size:3；pading:0；stride:2

卷积层Conv1之后接着进行了局部响应规范化操作（Local Response Normalized），将规范化的结果送入大小为$3\times 3$，步距为2的池化核进行最大池化下采样。

输出的feature map尺寸为：N = (W − F + 2P ) / S + 1 = (55 - 3) / 2 + 1 = 27

3、Conv2: kernels:128×2=256； kernel_size:5； padding: [2, 2]； stride:1

卷积层2使用256个卷积核做常规的卷积操作

输出的feature map尺寸为：N = (W − F + 2P ) / S + 1 = (27 - 5 + 4) / 1 + 1 = 27

4、Maxpool2: kernel_size:3； pading:0； stride:2

与下采样层Conv2类似，在上述卷积层之后接着进行了局部响应规范化操作，然后将结果送入大小为$3\times 3$，步距为2的池化核进行最大池化下采样。

输出的feature map尺寸为：N = (W − F + 2P ) / S + 1 = (27 - 3) / 2 + 1 = 13

5、Conv3: kernels:192×2=384； kernel_size:3； padding: [1, 1]； stride:1

与Conv1和Conv2不同，Conv3、Conv4、Conv5后均不接局部响应归一化LRN层

输出的feature map尺寸为：N = (W − F + 2P ) / S + 1 = (13 - 3 + 2) / 1 + 1 = 13

6、Conv4: kernels:192×2=384； kernel_size:3； padding: [1, 1]； stride:1

输出的feature map尺寸为：N = (W − F + 2P ) / S + 1 = (13 - 3 + 2) / 1 + 1 = 13

7、Conv5: kernels:128×2=256； kernel_size:3； padding: [1, 1]； stride:1

输出的feature map尺寸为：N = (W − F + 2P ) / S + 1 = (13 - 3 + 2) / 1 + 1 = 13

8、Maxpool3: kernel_size:3 padding: 0 stride:2

输出的feature map尺寸为：N = (W − F + 2P ) / S + 1 = (13 - 3) / 2 + 1 = 6

9、全连接层FC1、FC2、FC3

FC1和FC2分别有4096个神经元，FC3输出softmax为1000个（ImageNet数据集分类类别）。

3 模型创新

1、使用ReLU作为激活函数代替了传统的Sigmoid和Tanh

ReLU为非饱和函数，论文中验证其效果在较深的网络超过了Sigmoid，成功解决了Sigmoid在网络较深时的梯度弥散问题。

2、在多个GPU上进行模型的训练，不但可以提高模型的训练速度，还能提升数据的使用规模

3、使用LRN对局部的特征进行归一化

结果作为ReLU激活函数的输入能有效降低错误率

4、使用随机丢弃技术（dropout）选择性地忽略训练中的单个神经元

在AlexNet的最后几个全连接层中使用了Dropout来避免模型的过拟合

5、重叠最大池化（overlapping max pooling）

即池化范围z与步长s存在关系$z>s$（如最大池化下采样中核大小为$3\times 3$，步距为2），避免平均池化（average pooling）的平均效应

4 Pytorch模型搭建

注：由于LRN层对训练结果影响不大，故代码中去除了LRN层

import torch
import torch.nn as nn


class AlexNet(nn.Module):
    def __init__(self, num_classes=1000):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2),  # [None, 3, 224, 224] --> [None, 96, 55, 55]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),  # [None, 96, 55, 55] --> [None, 96, 27, 27]
            nn.Conv2d(96, 256, kernel_size=5, padding=2),  # [None, 96, 27, 27] --> [None, 256, 27, 27]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),  # [None, 256, 27, 27] --> [None, 256, 13, 13]
            nn.Conv2d(256, 384, kernel_size=3, padding=1),  # [None, 256, 27, 27] --> [None, 384, 13, 13]
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 384, kernel_size=3, padding=1),  # [None, 384, 13, 13] --> [None, 384, 13, 13]
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 256, kernel_size=3, padding=1),  # [None, 384, 13, 13] --> [None, 256, 13, 13]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2)  # [None, 256, 13, 13] --> [None, 256, 6, 6]
        )

        self.classifier = nn.Sequential(
            nn.Dropout(p=0.2),
            nn.Linear(256 * 6 * 6, 2048),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.2),
            nn.Linear(2048, 2048),
            nn.ReLU(inplace=True),
            nn.Linear(2048, num_classes)
        )

    def forward(self, inputs):
        x = self.features(inputs)
        x = torch.flatten(x, start_dim=1)
        outputs = self.classifier(x)
        return outputs