AlexNet网络详解

文章目录

1 模型介绍
2 模型结构
3 模型创新
4 Pytorch模型搭建

1 模型介绍

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

2 模型结构

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

Layer Name	Kernel Size	Kernel Num	Stride	Padding	Input Size	Output Size
Conv1	11×1111\times1111×11	48(×2GPU)48(\times2_{GPU})48(×2GPU)	444	[1,2][1,2][1,2]	224×224×3224\times224\times3224×224×3	55×55×9655\times55\times9655×55×96
Maxpool1	3×33\times33×3	///	222	000	55×55×9655\times55\times9655×55×96	27×27×9627\times27\times9627×27×96
Conv2	5×55\times55×5	128(×2GPU)128(\times2_{GPU})128(×2GPU)	111	[2,2][2,2][2,2]	27×27×9627\times27\times9627×27×96	27×27×25627\times27\times25627×27×256
Maxpool2	3×33\times33×3	///	222	000	27×27×25627\times27\times25627×27×256	13×13×25613\times13\times25613×13×256
Conv3	3×33\times33×3	192(×2GPU)192(\times2_{GPU})192(×2GPU)	111	[1,1][1,1][1,1]	13×13×25613\times13\times25613×13×256	13×13×38413\times13\times38413×13×384
Conv4	3×33\times33×3	192(×2GPU)192(\times2_{GPU})192(×2GPU)	111	[1,1][1,1][1,1]	13×13×38413\times13\times38413×13×384	13×13×38413\times13\times38413×13×384
Conv5	3×33\times33×3	128(×2GPU)128(\times2_{GPU})128(×2GPU)	111	[1,1][1,1][1,1]	13×13×38413\times13\times38413×13×384	13×13×25613\times13\times25613×13×256
Maxpool3	3×33\times33×3	///	222	000	13×13×25613\times13\times25613×13×256	6×6×2566\times6\times2566×6×256
FC1	204820482048	///	///	///	6×6×2566\times6\times2566×6×256	4096
FC2	204820482048	///	///	///	4096	4096
FC3	100010001000	///	///	///	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×33\times33×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×33\times33×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>sz>sz>s（如最大池化下采样中核大小为3×33\times33×3，步距为2），避免平均池化（average pooling）的平均效应

4 Pytorch模型搭建

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

import torch
import torch.nn as nnclass 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