【论文笔记】AlexNet研读

论文原文：
https://proceedings.neurips.cc/paper/2012/file/c399862d3b9d6b76c8436e924a68c45b-Paper.pdf

论文翻译：
https://www.jianshu.com/p/ea922866e3be
https://github.com/SnailTyan/deep-learning-papers-translation
https://zhuanlan.zhihu.com/p/80087776

卷积计算总结
CNN卷积的计算以AlexNet为例
https://www.jianshu.com/p/3d3a653b14fa

https://www.jianshu.com/p/9a8cd92b66db

总结：
AlexNet两大创新点：
1、使用了Relu激活函数，加快了模型的学习过程
2、加入了dropout，可以防止模型的过拟合

https://www.cnblogs.com/mfryf/p/11381255.html
https://www.cnblogs.com/itmorn/p/11197227.html
这个博客里还有其他深度学习的面试题。

-----------2020.9.21更新----------------
利用Pytorch框架搭建AlexNet模型
AlexNet.py

from torch import nn

class AlexNet(nn.Module): # n_output输出类别
    def __init__(self,n_output):
        super(AlexNet,self).__init__()
        
        self.features= nn.Sequential(
            
            # 卷积层1， 3通道输入，64个卷积核，核大小11*11，步长4，填充2
            # 经过该层图像大小变为：
            # 经过3*3最大池化，2步长，图像大小变为：
            nn.Conv2d(in_channels=3, out_channels=64, kernel_size=11,stride=4,padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3,stride=2,padding=0,dilation=1,ceil_mode=False),
            
            # 卷积层2， 64输入通道，192个卷积核，核大小5*5，步长1，填充2
            # 经过该层图像变为：
            # 经3*3最大池化，2步长，图像大小变为：
            nn.Conv2d(64, 192, 5, 1, 2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(3,2,0),
            
            # 卷积层3，192输入通道，384个卷积核，核大小3*3，步长1，填充1
            # 经过该层图像变为:
            nn.Conv2d(192, 384, 3, 1, 1),
            nn.ReLU(inplace=True),
            
            # 卷积层4，384输入通道，256个卷积核，核大小3*3，步长1，填充1
            # 经过该层图像变为:
            nn.Conv2d(384, 256, 3, 1, 1),
            nn.ReLU(inplace=True),
            
            # 卷积层5，256输入通道，256个卷积核，核大小3*3，步长1，填充1
            # 经过该层图像变为:
            nn.Conv2d(256, 256, 3, 1, 1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(3,2,0)
            )
        # 自适应平均池化层，输出的结果为6*6
        self.avgpool = nn.AdaptiveAvgPool2d((6,6))
            
        self.classifier = nn.Sequential(
                
            nn.Dropout(p=0.5,inplace=False),
            nn.Linear(in_features=9216,out_features=4096,bias=True),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5,inplace=False),
            nn.Linear(4096,4096,bias=True),
            nn.ReLU(inplace=True),
            nn.Linear(4096, n_output)
            )
        
    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0),-1)
        out  = self.classifier(x)
        
        return out

查看模型结构：

import AlexNet
net = AlexNet.AlexNet(2) # 2类
print(net)

以上AlexNet模型结构我是按照torchvision中复现的。
在torchvision中其实已经集成了很多模型，我们可以直接拿过来用。
但是这个AlexNet模型和原论文中还是有差别的，那时候GPU还没有现在强，但是总体上思路是对的。

import torchvision
net = torchvision.models.alexnet(）
print(net)

注意这个集成的AlexNet是1000类的，我们的可以任意改别类别。

参考：
https://www.cnblogs.com/ys99/p/10838998.html

CNN网络架构演进：从LeNet到DenseNet
https://www.cnblogs.com/skyfsm/p/8451834.html

https://blog.csdn.net/program_developer/article/details/79430119