AlexNet，ZFNet详解

1 AlexNet

网络结构

对于AlexNet网络来说，因为当时资源环境受限，他从第一步卷积开始就把一个图像分到两个GPU上训练，然后中间进行组合最后进行融合成全连接成1000个置信度

1 得到一张3x224x224的图像，然后进行11x11的卷积，卷积两次，分别分配到不同的GPU上

分别得到，两个48x55x55的feature map，然后进行最大池化操作从48x55x55变成48x27x27

2 分别进行相同的卷积，使用5x5卷积，不改变feature map的尺寸，只改变其通道数，从48x27x27变成128x27x27，然后进行最大池化操作从128x27x27变成128x13x13

3 然后两个feature map进行融合，然后继续分成两个，每一个的尺寸从 128x13x13变成 256x13x13，然后分别再进行3x3卷积，也不改变feature map的尺寸，只改变其通道数，从256x13x13 变成 192x13x13

4 两个分别进行两次卷积，不改变feature map的尺寸，只改变其通道数，最后从192x13x13变成128x13x13，然后再进行一次最大池化操作128x13x13变成128x6x6

5 然后合并进行全连接线性转换，再分成两个，具体不用讲了，看图可知

下面就是具体操作，其中下面两个11x11是分成了两个，然后后面其他的操作都一样所以放一块了直接写，合并里面并没有写

其中，还有一个东西没有写，局部响应归一化

Local Response Normalization(LRN, 局部响应归一化)， 主要是对ReLU激活函数的输出进行局部归一化操作(和LN差不多)，我觉得知道作用就行

LRN归一化： 对局部神经元的活动创建了竞争机制， 使得其中响应比较大的值变得相对更大，并抑制其它反馈较小的神经元， 增强了模型的泛化能力。 本质上， LRN是仿造生物学上活跃的神经元对于相邻神经元的抑制现象 (侧抑制) 。

2 ZFNet

基于AlexNet进行微调 ，修改窗口大小和步长 ，使用稠密单GPU的网络结构替换AlexNet的稀疏双GPU结构，如下图：

网络结构跟AlexNet类似，就是变成了从AlexNet的两个GPU变成了一个GPU的结构，更加容易理解和复现，具体代码复现：

import torch
import torch.nn as nn


class ZFNet(nn.Module):
    def __init__(self):
        super(ZFNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(in_channels=3, out_channels=96, kernel_size=(7, 7), stride=(2, 2), padding=1),
            nn.ReLU(),
            nn.LocalResponseNorm(size=30),
            nn.MaxPool2d(kernel_size=(3, 3), stride=(2, 2), padding=1),
            nn.Conv2d(in_channels=96, out_channels=256, kernel_size=(5, 5), stride=(2, 2), padding=0),
            nn.ReLU(),
            nn.LocalResponseNorm(size=50),
            nn.MaxPool2d(kernel_size=(3, 3), stride=(2, 2), padding=1),
            nn.Conv2d(256, 384, kernel_size=(3, 3), stride=(1, 1), padding='same'),
            nn.ReLU(),
            nn.Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding='same'),
            nn.ReLU(),
            nn.Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding='same'),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(3, 3), stride=(2, 2))
        )

        self.classify = nn.Sequential(
            nn.Linear(6 * 6 * 256, 4096),
            nn.ReLU(),
            nn.Linear(4096, 4096),
            nn.ReLU(),
            nn.Linear(4096, 1000)
        )

    def forward(self, x):
        """
        :param x: 原始图像数据, [N,1,224,224]
        :return:
        """
        z = self.features(x)  # [N,1,224,224] -> [N,256,6,6]
        z = z.view(-1, 256 * 6 * 6)  # reshape
        z = self.classify(z)
        return z


if __name__ == '__main__':
    net = ZFNet()
    img = torch.randn(2, 3, 224, 224)
    scores = net(img)
    print(scores)
    probs = torch.softmax(scores, dim=1)  # 求解概率值
    print(probs)