AlexNet 2012

AlexNet            

Alexnet是一年一度的ImageNet大型视觉识别挑战赛(ILSVRC)2012年冠军，ILSVRC使用ImageNet的一个子集，分为1000种类别，每种类别中都有大约1000张图像，大约有120万张训练图像，50,000张验证图像和150,000张测试图像。 Alexnet共有600000000训练参数和650000神经元。

基本结构

卷积层：5层

全连接层：3层

深度：8层

参数个数：60M

神经元个数：650k

分类数目：1000类

Conv1:输入图像规格：224*224*3

padding之后为227*227*3

Kernel size:11*11*3  stride:4  num_output:96

New_feture_size=(img_size-filter_size)/stride+1

(227-11)/4+1=55

输出：55*55*96(290400)

激活函数Relu以后输出的还是55*55*96

Maxpooling:kernel size:3*3      stride:2

(55-3)/2+1=27

输出：27*27*96

局部相应归一化后输出的还是27*27*96,分为两组，

每组分别为（27*27*48）

训练参数：96*11*11*3=34848

Conv2:输入图像规格：27*27*96  padding：2

Kernel size:5*5*48   stride:1   num_output:256

(27-5+2*2)/1+1=27

输出：两组27*27*128

激活函数Relu以后输出的还是27*27*128

Maxpooling:kernel size:3*3   stride:2

(27-3)/2+1=13

输出：两组13*13*128

归一化后输出的还是两组13*13*128

训练参数：256*5*5*48=307200

Conv3:

输入规格：两组13*13*128  padding：1

Kernel size:3*3*256  stride:1   num_output:192

(13-3+1*2)/1+1=13

输出：两组13*13*192

通过激活函数还是输出：两组13*13*192

训练参数：384*3*3*256=884736

Conv4:

输入规格：两组13*13*192  padding：1

Kernel size:3*3*192   stride:1   num_output:192

(13-3+1*2)/1+1=13

输出：两组13*13*192

通过激活函数还是输出：两组13*13*192

训练参数：384*3*3*192=663552

Conv5:

输入规格：两组13*13*192  padding：1

Kernel size:3*3*192 stride:1  num_output:128

(13-3+1*2)/1+1=13

输出：两组13*13*128

通过激活函数还是输出：两组13*13*128

Pooling:kernel size:3*3      stride:2

(13-3)/2+1=6

输出：两组6*6*128

训练参数：256*3*3*192=442368

FC6 全连接层:

输入规格：两组6*6*128

Kernel size:6*6*256

通过4096个神经元输出运算结果，这4096个运算结果通过relu激活函数生成4096个值，并通过drop运算后输出4096个本层结果

dropout:通过定义的概率来随机删除一些神经元,同时保持输入层与输出层神经元不变

训练参数：4096*6*6*256=37748736

FC7:第六层输出的4096个数据与第七层的4096个神经元进行全连接，

然后经由relu7进行处理后生成4096个数据，

再经过dropout7处理后输出4096个数据。

训练参数：4096*4096=16777216

 

FC8:第七层输出的4096个数据与第八层的1000个神经元进行全连接

训练参数：4096*1000=4096000

import torch.nn as nn
import torch.utils.model_zoo as model_zoo

# __all__ = ['AlexNet', 'alexnet']
#
#
# model_urls = {
#     'alexnet': 'https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth',
# }
# 在PyTorch中, 类nn.Conv2d()是卷积核模块。卷积核及其调用例子如下：
#
# nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0,dilation=1,groups=1, bias=True）
# nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1,

class AlexNet(nn.Module):

    def __init__(self,num_classes=1000):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 96, kernel_size=11, stride=4),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),

            nn.Conv2d(96, 256, kernel_size=5, stride=1,padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),

            nn.Conv2d(256, 384, kernel_size=3, stride=1,padding=1),
            nn.ReLU(inplace=True),

            nn.Conv2d(384, 384, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),

            nn.Conv2d(384, 256, kernel_size=3,stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
        )
        self.classifier = nn.Sequential(
            nn.Dropout(),
            nn.Linear(256 * 6 * 6, 4096),
            # 两组128,6,6
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), 256 * 6 * 6)
        x = self.classifier(x)
        return x

alex=AlexNet()
print(alex)

# def alexnet(pretrained=False, model_root=None, **kwargs):
#     model = AlexNet(**kwargs)
#     if pretrained:
#         model.load_state_dict(model_zoo.load_url(model_urls['alexnet'], model_root))
#     return model