Pytorch学习日志(10)——卷积神经网络案例分析

LeNet

一共有7层，其中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,3,1))
        layer1.add_module('pool1',nn.MaxPool2d(2,2))
        self.layer1 = layer1

        layer2 = nn.Sequential()
        layer2.add_module('conv2',nn.Conv2d(6,16,5))
        layer2.add_module('pool2',nn.MaxPool2d(2,2))
        self.layer2 = layer2

        layer3 = nn.Sequential()
        layer3.add_module('fc1',nn.Linear(400,120)) 5*5*16
        layer3.add_module('fc2',nn.Linear(120,84))
        layer3.add_module('fc2',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)
        x = self.layer3(x)
        return x

AlexNet

层数更深，引入了ReLU，在全连接层引入了Dropout层防止过拟合。

import torch
import torch.nn as nn
class AlexNet(nn.Module):
    def __init__(self,num_class):
        super(AlexNet,self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3,64,kernel_size=11,stride=4,padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel=3,stride=2), #覆盖的池化更不容易过拟合

            nn.Conv2d(64,192,kernel_size=5,padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel=3,stride=2),

            nn.Conv2d(192,384,kernel_size=3,padding=1),
            nn.ReLU(inplace=True),

            nn.Conv2d(384,256,kernel_size=3,padding=2),
            nn.ReLU(inplace=True),

            nn.Conv2d(256,256,kernel_size=3,padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel=3,stride=2)
            )
        self.classifier = nn.Sequential(
            nn.Dropout() #一定概率随机丢弃神经元。
            nn.Linear(256*6*6,4096)
            nn.ReLU(inplace=True)
            nn.Dropout()
            nn.Linear(4096,4096)
            nn.ReLU(inplace=True)
            nn.Linear(4096,num_classes)
            )
    def forward(self,x):
        x = self.features(x)
        x = x.view(x.size(0),256*6*6)
        x = self.classifier(x)
        return x

ReLU函数的意义

一般激活函数具有两个作用。其一、无论卷积还是全连接层，实质上都是线性运算，通过加入非线性的激活函数可以增强网络的非线性映射能力，相当于kernel method。其二、神经网络一般通过BP算法优化，激活函数可以加快网络收敛速度。传统神经网络激活函数通常为反正切或是sigmoid，AlexNet使用RELU作为激活函数，相比于反正切，该方法训练速度大约有6倍提升。RELU激活函数简单到难以置信，也就是说我们放弃了小于0的那部分导数，同时正数部分的导数为1啊！BP时自然会快啦！

VGGNet

变化：替换成许多小滤波器；增加爱了网络深度。

更多的小滤波器减少参数，增加了网络深度。

VGG只是对网络进行了不断的堆叠，没有过多的创新点，但是确实有所提升。

import torch
import torch.nn as nn
class VGG(nn.Module):
    def __init__(self,num_classes):
        super(VGG,self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3,64,kernel_size=3,padding=1),
            nn.ReLU(True),

            nn.Conv2d(64,64,kernel_size=3,padding=1),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),

            nn.Conv2d(64,128,kernel_size=3,padding=1)
            nn.ReLU(True),

            nn.Conv2d(128,128,kernel_size=3,padding=1),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),

            nn.Conv2d(128,256,kernel_size=3,padding=1),
            nn.ReLU(True),

            nn.Conv2d(256,256,kernel_size=3,padding=1),
            nn.ReLU(True),

            nn.Conv2d(256,256,kernel_size=3,padding=1),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),

            nn.Conv2d(256,512,kernel_size=3,padding=1),
            nn.ReLU(True),

            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.ReLU(True),

            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),

            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.ReLU(True),

            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.ReLU(True),

            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),
        )
        self.classifier = nn.Sequential(
            nn.Linear(512*7*7,4096),
            nn.ReLU(True)
            nn.Dropout()
            nn.Linear(4096,4096),
            nn.ReLU(True)
            nn.Dropout()
            nn.Linear(4096,num_classes)
        )

        def forward(self,x):
            x = self.features(x)
            x = x.view(x.size(0),-1)
            #x = x.view(x.size()[0], -1) 
            # 这句话的出现就是为了将前面操作输出的多维度的tensor展平成一维
            # 然后输入分类器，-1是自适应分配，
            # 指在不知道函数有多少列的情况下，根据原tensor数据自动分配列数。
            x = x.self.classifier(x)
            return x