视觉神经网络的演化（1）-- 早期探索

发表于 2019-08-18 更新于 2024-04-05

LeNet可以说是CNN的开端，麻雀虽小，但五脏俱全，卷积层、池化层、全连接层，这些都是现代CNN网络的基本组件。而AlexNet是另一个具有历史意义的网络结构，它的成功表示了深度学习重回历史舞台。

LeNet-5

下图是广为流传LeNet的网络结构，随着网络越来越深，图像的宽度和高度都在缩小，信道数量一直在增加。目前，一个或多个卷积层后边跟一个池化层，再接上一个全连接层的排列方式很常用。

import torch
from torch import nn

class LeNet5(nn.Module):
    '''
    LeNet5网络
    INPUT  -> 图像规格(28, 28, 1), 待分类数(10)
    '''
    def __init__(self):
        super(LeNet5, self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(1, 6, kernel_size=5, padding=2, bias=False),
            # 卷积后图像尺寸 = (28+2*2-5)/步长+1 = 28
            nn.Tanh(),
            nn.MaxPool2d(kernel_size=2, stride=2)
            # 经过池化层后图像尺寸 = (28-2)/步长+1 = 14
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(6, 16, kernel_size=5, bias=False),
            # 卷积后图像尺寸 = (14-5)/步长+1 = 10
            nn.Tanh(),
            nn.MaxPool2d(kernel_size=2, stride=2)
            # 经过池化层后图像尺寸 = (10-2)/步长+1 = 5
        )
        self.classifier = nn.Sequential(
            nn.Linear(16*5*5, 120),
            nn.Tanh(),
            nn.Linear(120, 84),
            nn.Tanh(),
            nn.Linear(84, 10)
        )

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        # nn.Linear()的输入输出都是一维数组，所以要把tensor展成一维
        x = x.view(x.size(0), 16*5*5)
        # x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x

model = LeNet5()
print(model)

input_tensor = torch.randn((1, 1, 32, 32))
input_var = torch.autograd.Variable(input_tensor)
out = model(input_var)

AlexNet

AlexNet 可以说是具有历史意义的一个网络结构，可以说在AlexNet之前，深度学习已经沉寂了很久。历史的转折在2012年到来，AlexNet 在当年的ImageNet图像分类竞赛中，top-5错误率比上一年的冠军下降了十个百分点，而且远远超过当年的第二名。
AlexNet的诞生开启了深度学习的时代，虽然后来大量比AlexNet更快速更准确的卷积神经网络结构相继出现，但是AlexNet作为开创者依旧有着很多值得学习参考的地方，之后在Imagenet上取得更好结果的ZF-net，VGG等网络，都是在其基础上修改得到。

该网络包括：卷积层 5个，池化层 3个，全连接层：3个（其中包含输出层）。

创新
（1）采用了ReLU激活函数，而不像早期卷积神经网络所采用的Tanh或Sigmoid激活函数
（2）用多层小卷积代替单个大卷积层。
（3）提出了LRN层（局部响应归一化层），增强模型泛化能力。
（4）每个全连接层后面加上Dropout层减少了模型的过拟合问题。
（5）使用了数据增强。

import torch
from torch import nn

class AlexNet(nn.Module):
    '''
    AlexNet网络
    INPUT  -> 图像规格(227, 227, 3), 待分类数(1000)
    '''
    def __init__(self):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 96, kernel_size=11, stride=4, bias=False),
            # 卷积后图像尺寸 (227-11)/步长+1 = 55
            nn.LocalResponseNorm(96),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            # 经过池化层后图像尺寸 (55-3)/步长+1 = 27
            nn.Conv2d(96, 256, kernel_size=5, padding=2, bias=False),
            # 卷积后图像尺寸 (27+2*2-5)/步长+1 = 27
            nn.LocalResponseNorm(256),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            # 经过池化层后图像尺寸 (27-3)/步长+1 = 13
            nn.Conv2d(256, 384, kernel_size=3, padding=1, bias=False),
            # 卷积后图像尺寸 (13+1*2-3)/步长+1 = 13
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 384, kernel_size=3, padding=1, bias=False),
            # 卷积后图像尺寸 (13+1*2-3)/步长+1 = 13
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 256, kernel_size=3, padding=1, bias=False),
            # 卷积后图像尺寸 (13+1*2-3)/步长+1 = 13
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2)
            # 经过池化层后图像尺寸 (13-3)/步长+1 = 6
        )
        self.classifier = nn.Sequential(
            nn.Linear(256*6*6, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 1000),
        )

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

model = AlexNet()
print(model)

input_tensor = torch.randn((1, 3, 227, 227))
input_var = torch.autograd.Variable(input_tensor)
out = model(input_var)