经典卷积神经网络复现

基于pytorch将经典的卷积神经网络架构复现一下

卷积神经网络基础知识

通道数：

感受野：

步幅：

填充：

滤波器：

汇聚：

池化：

LeNet-5

网络结构图

结构分析

复现代码

import torch
from torch import nn

#LeNet-5一共有7层，输入图像大小为32*32*1，输出对应10个类别的条件概率
class LeNet5(nn.Module):
    def __init__(self):
        super(LeNet5,self).__init__()
        self.layer1 = nn.Sequential(
          	#输入channels：1；输出channels：6，卷积核：5*5
            nn.Conv2d(1,6,5,1,0),
            nn.ReLU(inplace=True),
          	#2*2卷积核，步长为2进行最大池化
            nn.MaxPool2d(kernel_size=2,stride=2)
        )
        self.layer2 = nn.Sequential(
          	#输入channels：6；输出channels：16，卷积核：5*5
            nn.Conv2d(6,16,5,1,0),
            nn.ReLU(inplace=True),
          	#2*2卷积核，步长为2进行最大池化
            nn.MaxPool2d(kernel_size=2,stride=2)
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),#将卷积后的16@5*5图像输出展平
            nn.Linear(400,120),#线性层
            nn.ReLU(inplace=True),
            nn.Linear(120,84),#线性层
            nn.ReLU(inplace=True),
            nn.Linear(84,10),#线性层
            nn.Softmax(dim=1)
        )

    #前向传播计算
    def forward(self,x):
        x = self.layer1(x)
        x = self.layer2(x)
        print(x.shape)
        x = self.classifier(x)
        return x

AlexNet

网络结构图

结构细节

卷积核大小如何确定？

虽然说目前有比较火的研究方向针对这种自动神经网络结构搜索（NAS），这些自动搜索出来的网络在常规数据集上的建模结果显示（当然是达到一定的准确度）：自动搜索出来的网络中的卷积核的类别有包括各种常见的型号（3 * 3、5 * 5、7*7），且在网络中的前后排布没有规律。

nn.BatchNorm2d()的作用？

在深度神经网络中，梯度消失是一个常见的问题。BatchNorm2d通过对激活函数前添加归一化层，抑制了梯度消失的问题，从而加速了优化过程。

BatchNorm2d通过对数据的归一化处理，使得权重初始化的影响减小，无论权重的初始值如何，都可以通过归一化和仿射变换得到较好的效果。

nn.Dropout(0.5,inplace=True)的作用？

nn.Dropout模块的作用是在训练过程中随机关闭一部分神经元，以增加模型的泛化能力。通常，我们在全连接层之后应用dropout，以避免破坏卷积层中重要的空间信息。

一般建议在10%-50%之间设置dropout比例

复现代码

import torch
from torch import nn

#AlexNet的输入为224*224*3图像，输出为1000个类别的条件概率
class AlexNet(nn.Module):
    '''
    Neural network model consisting of layers proposed by AlexNet paper
    '''
    def __init__(self):
        super(AlexNet,self).__init__()
        self.layer1 = nn.Sequential(
          	#输入channels：3；输出channels：96，卷积核：11*11
            nn.Conv2d(3,96,11,4,0),
            nn.BatchNorm2d(96),
            nn.ReLU(inplace=True),
          	#3*3卷积核，步长为2进行最大池化
            nn.MaxPool2d(3,2)
        )
        self.layer2 = nn.Sequential(
          	#输入channels：96；输出channels：256，卷积核：5*5
            nn.Conv2d(96,256,5,1,2),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
          	#3*3卷积核，步长为2进行最大池化
            nn.MaxPool2d(3,2),
        )
        self.layer3 = nn.Sequential(
          	#输入channels：256；输出channels：384，卷积核：3*3
            nn.Conv2d(256,384,3,1,1),
            nn.BatchNorm2d(394),
            nn.ReLU(inplace=True),
        )
        self.layer4 = nn.Sequential(
          	#输入channels：384；输出channels：384，卷积核：3*3
            nn.Conv2d(384,384,3,1,1),
            nn.BatchNorm2d(394),
            nn.ReLU(inplace=True)
        )
        self.layer5 = nn.Sequential(
          	#输入channels：384；输出channels：256，卷积核：3*3
            nn.Conv2d(384,256,3,1,1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
          	#3*3卷积核，步长为2进行最大池化
            nn.MaxPool2d(3,2)
        )
    
        self.classifier = nn.Sequential(
            nn.Dropout(0.5,inplace=True),
            nn.Linear(256*6*6,4096),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5,inplace=True),
            nn.Linear(4096,4096),
            nn.ReLU(inplace=True),
            nn.Linear(4096,1000),
            nn.Softmax(dim=1)
        )

    #前向传播计算
    def forward(self,x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer4(x)
        x = self.layer5(x)
        output = self.classifier(x)
        return output

VGG

网络结构图

GoogleNet

网络结构图

ResNet

网络结构图