torch_07_卷积神经网络案例分析

1. LeNet（1998）

 """
 note:
 LeNet:
 输入体：32*32*1
 卷积核：5*5
 步长：1
 填充：无
 池化：2*2
 代码旁边的注释：卷积或者池化后的数据的尺寸
 """
 import torch
 import torch.nn as nn

 class LeNet(nn.Module):
     def __init__(self):
         super(LeNet,self).__init__()
         layer1 = nn.Sequential()
         layer1.add_module('conv1',nn.Conv2d(1,6,5,1,padding=0))# 没有填充 ，b,6,28*28
         layer1.add_module('pool1',nn.MaxPool2d(2,2))   # 6,14*14 (28-2)/2+1 = 14
         self.layer1= layer1

         layer2 = nn.Sequential()
         layer2.add_module('conv2', nn.Conv2d(6, 16, 5, 1, padding=0))  # 没有填充 b,16,10*10
         layer2.add_module('pool2', nn.MaxPool2d(2, 2))  # 16,5*5
         self.layer2 = layer2

         layer3 = nn.Sequential()
         layer3.add_module('fc1',nn.Linear(400,120))
         layer3.add_module('fc2',nn.Linear(120,84))
         layer3.add_module('fc3',nn.Linear(84,10))
         self.layer3 = layer3

         def forward(self,x):
             x = self.layer1(x)
             x = self.layer2(x)
             x = x.view(x.size(0),-1)  # 将多维数据排列成一行：1*400（16*5*5）
             x = self.layer3(x)
             return x

2.AlexNet（2012）:层数更深，同时第一次引入了激活层ReLU，在全连接层引入了Dropout层防止过拟合

3.VGGNet（2014）：有16~19层网络，使用了3*3的卷积滤波器和2*2的池化层。只是对网络层进行不断的堆叠，并没有太大的创新，增加深度缺失可以一定程度改善模型效果。

4.GoogleLeNet:(InceptionNet)(2014):比VGGNet更深的网络结构，一共22层，但是它的参数比AlexNet少了12倍，同时有很高的计算效率，因为它采用了一种有效的Inception模块，而且它也没有全连接层。Inception模块设计了一个局部的网络拓扑结构，然后将这些模块堆叠在一起形成一个抽象层次的网络结构。具体来说是运用几个并行的滤波器对输入进行卷积核池化，这些滤波器有不同的感受野，最后将输出的结果按深度拼接在一起形成输出层。缺点：参数太多，导致计算复杂。这些模块增加了一些1*1的卷积层来降低输入层的维度，使网络参数减少，从而减少网络的复杂性。

 """
 GooglNet的Inceoption模块，整个GoogleNet都是由这些Inception模块组成的
 nn.BatchNorm1d:在每个小批量数据中，计算输入各个维度的均值和标注差。
 num_features:期望输入大小：batch_size * num_features
 torch.cat:将不同尺度的卷积深度相加，只是深度不同，数据体大小是一样的
 (0)表示增加行，（1）表示增加列
 """

 import torch.nn as nn
 import torch
 import torch.nn.functional as F

 class BasicConv2d(nn.Module):
     def __init__(self,in_channels,out_channles,**kwargs):
         super(BasicConv2d,self).__init__()
         self.conv = nn.Conv2d(in_channels,out_channles,bias=False,**kwargs)
         self.bn = nn.BatchNorm1d(out_channles,eps=0.001)

     def forward(self,x):
         x = self.conv(x)
         x = self.bn(x)
         return F.relu(x,inplace = True)

 class Inception(nn.Module):
     def __init__(self,in_channles,pool_features):
         super(Inception,self).__init__()
         self.branch1x1 = BasicConv2d(in_channles,64,kernel_size = 1)

         self.branch5x5_1 = BasicConv2d(in_channles,48,kernel_size = 1)
         self.branch5x5_2 = BasicConv2d(48,64,kernel_size = 5,padding = 2)

         self.branch3x3dbl_1 = BasicConv2d(in_channles,64,kernel_size = 1)
         self.branch3x3dbl_2 = BasicConv2d(64,96,kernel_size = 3,padding = 1)
         #self.branch3x3dbl_3 = BasicConv2d(96,96,kernel_size = 3,padding = 1)

         self.branch_pool = BasicConv2d(in_channles,pool_features,kenel_size = 1)

         def forward(self, x):
             branch1x1 = self.branch1x1(x)

             branch5x5 = self.branch5x5_1(x) # 核是1
             branch5x5 = self.branch5x5_2(branch5x5)  #核是5

             branch3x3 = self.branch3x3dbl_1(x) # 核是1
             branch3x3 = self.branch3x3dbl_2(branch3x3)

             branch_pool = F.avg_pool2d(x,kernel_size = 3,stride = 1,padding = 1)
             branch_pool = self.branch_pool(branch_pool)

             outputs = [branch1x1,branch5x5,branch3x3,branch_pool]
             return torch.cat(outputs,1)

5.ResNet(2015)

　　在不断加深神经网络的时候，会出现准确率先上升然后达到饱和，再持续增加深度会导致模型准确率下降，这并不是过拟合问题，因为不仅在验证集上误差增加，训练集本身误差也会增加，假设一个比较浅的网络达到了饱和的准确率，那么在后面加上几个恒等的映射层，误差不会增加，也就是说更深的模型起码不会使得模型效果下降。假设某个神经网络的输入是x，期望输出值是H（x），如果直接把输入x传到输出作为初始结果，那么此时需要学习的目标就是F(x) = H（x）- x，即残差。ResNet相当于将学习目标改变了，不再学习一个完整的输出H（x），而是学习输出和输入的差别 H（x）-x

 import torch
 import torch.nn as nn

 def conv3x3(in_planes,out_plans,stride = 1):
     return nn.Conv2d(
         in_planes,
         out_plans,kernel_size=3,
         stride=stride,
         padding=1,
         bias = False
     )

 class BasicBlock(nn.Module):
     def __init__(self,inplanes,planes,stride = 1,downsample = None):
         super(BasicBlock,self).__init__()
         self.conv1 = conv3x3(inplanes,planes,stride)
         self.bn1 = nn.BatchNorm2d(planes)
         self.relu = nn.ReLU(inplace=True)
         self.conv2 = conv3x3(planes,planes)
         self.bn2 = nn.BatchNorm2d(planes)
         self.downsample = downsample
         self.stride = stride

     def forward(self,x):
         residual = x
         out = self.conv1(x)

         out = self.bn1(out)
         out = self.relu(out)

         out = self.conv2(out)
         out = self.bn2(out)

         if self.downsample is not None:
             residual = self.downsample(x)

         out += residual
         out = self.relu(out)
         return out