AlexNet网络详解+pytorch实现

1.网络模型介绍

关于特征图尺寸的计算，大家可以在这个链接查看公式：
特征图尺寸计算

第一层：
1.输入尺寸为227 * 227 * 3，使用11 * 11 * 3的卷积核，步长为4，输出通道为96，输出特征尺寸为：55 * 55 * 96
2.使用relu激活函数
3.使用尺寸为3 * 3，步长为22的按最大值池化（maxpooling），输出特征图大小为27 * 27 * 96
4.使用归一化
第二层：
1.输入尺寸为27 * 27 * 96，使用大小为 5 * 5，步长为11的卷积核，填充为2，输出通道为256，输出为27 * 27 * 256
2.使用relu激活函数
3.使用尺寸为3 * 3，大小为2 * 2的按最大值池化（maxpooling），输出特征图大小为13 * 13 * 256
4.使用归一化
第三层+第四层：
1.输入尺寸为13 * 13 * 256，使用大小为3 * 3，步长为1*1的卷积核，填充为2，输出通道为384，输出为13 * 13 * 384
2.relu激活函数
第五层：
1.输入尺寸为13 * 13 * 384，使用大小为3 * 3，步长为1 * 1的卷积核，填充为1，输出通道为256，输出为13 * 13 * 256
2.relu激活函数
3.使用尺寸为3 * 3，步长为2 * 2的按最大值池化（maxpooling），输出特征图大小为6 * 6 * 256
第六层：
1.输入 尺寸为6 * 6 * 256，使用全连接层，输出通道为4096，输出为1 * 4096
2.relu激活函数
第七层：
1.输入尺寸为1 * 4096，输出通道为4096，输出为1 * 4096
2.relu激活函数
3.使用dropout函数，丢弃部分参数
第八层：
1.输入尺寸为1 * 4096，输出通道为1000，输出尺寸为1 * 1000，为softmax分类

2.pytorch实现AlexNet

import torch
import torch.nn as nn

class AlexNet(nn.Module):
    def __init__(self):
        super(AlexNet, self).__init__()
        self.conv1 = nn.Sequential(nn.Conv2d(3, 96, 11, 4),
                                   nn.ReLU(),
                                   nn.MaxPool2d(3, 2),
                                   nn.BatchNorm2d(96))
        self.conv2 = nn.Sequential(nn.Conv2d(96, 256, 5, 1, 2),
                                   nn.ReLU(),
                                   nn.MaxPool2d(3, 2),
                                   nn.BatchNorm2d(256))
        self.conv3 = nn.Sequential(nn.Conv2d(256, 384, 3, 1, 2),
                                   nn.ReLU())
        self.conv4 = nn.Sequential(nn.Conv2d(256, 384, 3, 1, 2),
                                   nn.ReLU())
        self.conv5 = nn.Sequential(nn.Conv2d(384, 256, 3, 1, 1),
                                   nn.ReLU(),
                                   nn.MaxPool2d(3, 2))
        self.conv6 = nn.Sequential(nn.Linear(256, 4096),
                                   nn.Dropout(0.5),
                                   nn.ReLU())
        self.conv7 = nn.Sequential(nn.Linear(4096, 4096),
                                   nn.Dropout(0.5),
                                   nn.ReLU())
        self.out = nn.Linear(4096, 1000)

    def forward(self, input):
        x = self.conv1(input)
        x = self.conv2(x)
        x = self.conv3(x)
        x = self.conv4(x)
        x = self.conv5(x)
        x = self.conv6(x)
        x = self.conv7(x)
        x = self.out(x)
        return x
        
net = AlexNet()
print(net)

输出参数层：

AlexNet(
  (conv1): Sequential(
    (0): Conv2d(3, 96, kernel_size=(11, 11), stride=(4, 4))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )
  (conv2): Sequential(
    (0): Conv2d(96, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )
  (conv3): Sequential(
    (0): Conv2d(256, 384, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2))
    (1): ReLU()
  )
  (conv4): Sequential(
    (0): Conv2d(256, 384, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2))
    (1): ReLU()
  )
  (conv5): Sequential(
    (0): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (conv6): Sequential(
    (0): Linear(in_features=256, out_features=4096, bias=True)
    (1): Dropout(p=0.5, inplace=False)
    (2): ReLU()
  )
  (conv7): Sequential(
    (0): Linear(in_features=4096, out_features=4096, bias=True)
    (1): Dropout(p=0.5, inplace=False)
    (2): ReLU()
  )
  (out): Linear(in_features=4096, out_features=1000, bias=True)
)

Process finished with exit code 0