卷积神经网络进阶（AlexNet、VGG、NiN、GoogleNet）

Habiba ·

更新时间:2024-11-13

· 555 次阅读

深度卷积神经网络AlexNet

重要的计算例题：通道数为3，宽高均为224的输入，经过一层输出通道数为96，卷积核大小为11，步长为4，无padding的卷积层后，得到的feature map的宽高为：
(原始宽高 - kernel_size)/步长下取整 + 1
即（224-11）/4下取整 +1 = 54

在特征提取方面，主要存在两种主流认知：

机器学习的特征提取:手工定义的特征提取函数神经网络的特征提取：通过学习得到数据的多级表征，并逐级表⽰越来越抽象的概念或模式。 AlexNet

深度卷积神经网络AlexNet首次证明了学习到的特征可以超越⼿⼯设计的特征，从而⼀举打破计算机视觉研究的前状。

AlexNet(右)和LetNet的区别：
在这里插入图片描述
AlexNet主要的区别：

输出维度大，提取的特征多用的最大池化，可以提取最重要的特征卷积核更大用的是ReLU函数作为激活函数，因为sigmoid函数在正饱和区和负饱和区导数都接近0，因此容易出现梯度消失的问题，而且ReLU函数导数是1，收敛快用Dropout（丢弃法）来控制全连接层的模型复杂度。即让全连接层某些隐藏单元停止工作

AlexNet主要结构如图所示：包含了一共五个卷积层，三个最大池化层，和三个全连接层构成。第一个卷积层用的1111的卷积核，输出通道为96，步长为4。后面的层结构如图

输入宽和高：224
经过第一个卷积层图像大小的变化：(224-11)/4+1 = 54 (这里的除法下取整)
经过第一个池化层：(54-3)/2+1 = 26
经过第二个卷积层：(4+26-5)/1+1 = 26 (加4是因为两个维度各pad了2个单位)
经过第二个池化层：(26-3)/2+1 = 12
经过第三个卷积层：(2+12-3)/1+1 = 12
经过第四个卷积层：(2+12-3)/1+1 = 12
经过第五个卷积层：(2+12-3)/1+1 = 12
经过最后一个池化层：(12-3)/2+1 = 5
所以最后输出的图像为55的feature map

AlexNet的代码实现

import time
import torch
from torch import nn, optim
import torchvision
import numpy as np
import sys
sys.path.append("/home/kesci/input/") 
import d2lzh1981 as d2l
import os
import torch.nn.functional as F
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
class AlexNet(nn.Module):
    def __init__(self):
        super(AlexNet, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(1, 96, 11, 4), # in_channels, out_channels, kernel_size, stride, padding
            nn.ReLU(),
            nn.MaxPool2d(3, 2), # kernel_size, stride
            # 减小卷积窗口，使用填充为2来使得输入与输出的高和宽一致，且增大输出通道数
            nn.Conv2d(96, 256, 5, 1, 2),
            nn.ReLU(),
            nn.MaxPool2d(3, 2),
            # 连续3个卷积层，且使用更小的卷积窗口。除了最后的卷积层外，进一步增大了输出通道数。
            # 前两个卷积层后不使用池化层来减小输入的高和宽
            nn.Conv2d(256, 384, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(384, 384, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(384, 256, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d(3, 2)
        )
         # 这里全连接层的输出个数比LeNet中的大数倍。使用丢弃层来缓解过拟合
        self.fc = nn.Sequential(
            nn.Linear(256*5*5, 4096),
            nn.ReLU(),
            nn.Dropout(0.5),
            #由于使用CPU镜像，精简网络，若为GPU镜像可添加该层
            #nn.Linear(4096, 4096),
            #nn.ReLU(),
            #nn.Dropout(0.5),
            # 输出层。由于这里使用Fashion-MNIST，所以用类别数为10，而非论文中的1000
            nn.Linear(4096, 10),
        )
    def forward(self, img):
        feature = self.conv(img)
        output = self.fc(feature.view(img.shape[0], -1))
        return output

net = AlexNet()
print(net)

在这里插入图片描述
载入数据集：

def load_data_fashion_mnist(batch_size, resize=None, root='/home/kesci/input/FashionMNIST2065'):
    """Download the fashion mnist dataset and then load into memory."""
    trans = []
    if resize:
        trans.append(torchvision.transforms.Resize(size=resize))
    trans.append(torchvision.transforms.ToTensor())
    transform = torchvision.transforms.Compose(trans)
    mnist_train = torchvision.datasets.FashionMNIST(root=root, train=True, download=True, transform=transform)
    mnist_test = torchvision.datasets.FashionMNIST(root=root, train=False, download=True, transform=transform)
    train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=2)
    test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=2)
    return train_iter, test_iter
#batchsize=128
batch_size = 16
# 如出现“out of memory”的报错信息，可减小batch_size或resize
train_iter, test_iter = load_data_fashion_mnist(batch_size,224)
for X, Y in train_iter:
    print('X =', X.shape,
        '\nY =', Y.type(torch.int32))
    break

训练：

lr, num_epochs = 0.001, 3
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
d2l.train_ch5(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs)

使用重复元素的网络（VGG）

VGG：通过重复使⽤简单的基础块来构建深度模型。由多个block组成

一个Block:数个相同的填充为1、窗口形状为3×3的卷积层,接上一个步幅为2、窗口形状为2×2的最大池化层（图中有误，是22不是33）。

卷积层保持输入的高和宽不变，而池化层则对其减半。
在这里插入图片描述
经过一个vgg block ，feature map高和宽会减半

网络中的网络NiN

NiN由多个nin block构成
使用2个11的卷积层代替全连接层

每个nin block由一个可以自行设置的卷积层和两个11的卷积层构成
每个block之间添加一个最大池化层

⽤了输出通道数等于标签类别数的NiN块，然后使⽤全局平均池化层对每个通道中所有元素求平均并直接⽤于分类。比如最后的nin block输出通道为10个，那么全局平均池化层在这10个通道上分别取平均值，得到最终结果

最后加上一个全局平均池化层，GlobalAvgPool2d
可以减少参数，缓解过拟合

1*1卷积层的作用：

代替全连接层放缩通道数：通过控制卷积核的数量达到通道数的放缩。增加非线性。1×1卷积核的卷积过程相当于全连接层的计算过程，并且还加入了非线性激活函数，从而可以增加网络的非线性。计算参数少

代码部分：
一个block

def nin_block(in_channels, out_channels, kernel_size, stride, padding):
    blk = nn.Sequential(nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding),
                        nn.ReLU(),
                        nn.Conv2d(out_channels, out_channels, kernel_size=1),
                        nn.ReLU(),
                        nn.Conv2d(out_channels, out_channels, kernel_size=1),
                        nn.ReLU())
    return blk

全部

class GlobalAvgPool2d(nn.Module):
    # 全局平均池化层可通过将池化窗口形状设置成输入的高和宽实现
    def __init__(self):
        super(GlobalAvgPool2d, self).__init__()
    def forward(self, x):
        return F.avg_pool2d(x, kernel_size=x.size()[2:])
        #调用avg_pool2d函数就行，kernel_size改为x的宽和高
#拼接起来
net = nn.Sequential(
    nin_block(1, 96, kernel_size=11, stride=4, padding=0),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nin_block(96, 256, kernel_size=5, stride=1, padding=2),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nin_block(256, 384, kernel_size=3, stride=1, padding=1),
    nn.MaxPool2d(kernel_size=3, stride=2), 
    nn.Dropout(0.5),
    # 标签类别数是10
    nin_block(384, 10, kernel_size=3, stride=1, padding=1),
    #注意最后一个block输出通道10个，和分类个数一致
    GlobalAvgPool2d(), 
    # 将四维的输出转成二维的输出，其形状为(批量大小, 10)
    d2l.FlattenLayer())

训练，输出经过每一层的变化

X = torch.rand(1, 1, 224, 224)
for name, blk in net.named_children(): 
    X = blk(X)
    print(name, 'output shape: ', X.shape)

在这里插入图片描述

GoogLeNet 由Inception基础块组成 Inception块相当于⼀个有4条线路的⼦⽹络。它通过不同窗口形状的卷积层和最⼤池化层来并⾏抽取信息，并使⽤1×1卷积层减少通道数从而降低模型复杂度。可以⾃定义的超参数是每个层的输出通道数，我们以此来控制模型复杂度。

一个inception结构如图：
在这里插入图片描述
四条线路分别的代码实现“

class Inception(nn.Module):
    # c1 - c4为每条线路里的层的输出通道数
    def __init__(self, in_c, c1, c2, c3, c4):
        super(Inception, self).__init__()
        # 线路1，单1 x 1卷积层
        self.p1_1 = nn.Conv2d(in_c, c1, kernel_size=1)
        # 线路2，1 x 1卷积层后接3 x 3卷积层
        self.p2_1 = nn.Conv2d(in_c, c2[0], kernel_size=1)
        self.p2_2 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1)
        # 线路3，1 x 1卷积层后接5 x 5卷积层
        self.p3_1 = nn.Conv2d(in_c, c3[0], kernel_size=1)
        self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_size=5, padding=2)
        # 线路4，3 x 3最大池化层后接1 x 1卷积层
        self.p4_1 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
        self.p4_2 = nn.Conv2d(in_c, c4, kernel_size=1)
    def forward(self, x):
        p1 = F.relu(self.p1_1(x))
        p2 = F.relu(self.p2_2(F.relu(self.p2_1(x))))
        p3 = F.relu(self.p3_2(F.relu(self.p3_1(x))))
        p4 = F.relu(self.p4_2(self.p4_1(x)))
        return torch.cat((p1, p2, p3, p4), dim=1)  # 在通道维上连结输出

完整的googlenet模型结构：
在这里插入图片描述
完整代码搭建：
其中重要的是每个卷积层输入和输出的设置关联，如代码中注释所述
b1由一个7*7卷积层和一个最大池化层组成
b2由2个卷积层和一个最大池化层组成
b3由2个inception和一个最大池化层组成
b4由5个inception和一个最大池化
b5由2个inception和一个全局平均池化层组成
最后由一个flatten层展平操作和一个全连接层输出

b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
                   nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
b2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=1),
                   nn.Conv2d(64, 192, kernel_size=3, padding=1),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
#b3第一个inception的输入通道是上一个maxpool的输出通道也就是192，
    #线路1的输出设为64，
    #线路2第一个卷积层的输出设为96，第二个卷积层的输入是上一个的输出96，输出设为128
    #线路3的第一个卷积层输出16，第二个卷积层输出32
    #线路4的卷积层输出是32
    #那么b3第二个inception的输入就是上一个inception的四条线输出总和64+128+32+32 = 256
    #同理计算每一条线路的输出
    #b4的inception输入也由b3的最后一个inception的输出计算所得
b3 = nn.Sequential(Inception(192, 64, (96, 128), (16, 32), 32),
                   Inception(256, 128, (128, 192), (32, 96), 64),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
b4 = nn.Sequential(Inception(480, 192, (96, 208), (16, 48), 64),
                   Inception(512, 160, (112, 224), (24, 64), 64),
                   Inception(512, 128, (128, 256), (24, 64), 64),
                   Inception(512, 112, (144, 288), (32, 64), 64),
                   Inception(528, 256, (160, 320), (32, 128), 128),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
b5 = nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128),
                   Inception(832, 384, (192, 384), (48, 128), 128),
                   d2l.GlobalAvgPool2d())
net = nn.Sequential(b1, b2, b3, b4, b5, 
                    d2l.FlattenLayer(), nn.Linear(1024, 10))
net = nn.Sequential(b1, b2, b3, b4, b5, d2l.FlattenLayer(), nn.Linear(1024, 10))
X = torch.rand(1, 1, 96, 96)
for blk in net.children(): 
    X = blk(X)
    print('output shape: ', X.shape)
#batchsize=128
batch_size = 16
# 如出现“out of memory”的报错信息，可减小batch_size或resize
#train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)
lr, num_epochs = 0.001, 5
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
d2l.train_ch5(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs)

总结：

卷积层的主要作用是做特征提取 AlexNet开始使用ReLU作为激活函数 VGG开始使用重复的block搭建 nin也有block组成，且每个block选择使用2个1*1的卷积层代替全连接层，最后通过一个全局平均池化层在每个输出通道求平均作为输出 googlenet由inception和其他卷积核组成，每个inception有四条线路，在线路末尾合并，整个googlenet最后用一个全局平均池化层和一个全连接层输出结果
作者：Zed

googlenet vgg 卷积神经网络 alexnet 神经网络卷积

1024 个赞