【PyTorch深度学习实践】 -- 卷积神经网络（高级篇）

最新推荐文章于 2024-08-18 09:55:45 发布

小d<>

最新推荐文章于 2024-08-18 09:55:45 发布

阅读量156

点赞数

分类专栏： PyTorch 文章标签：深度学习 cnn pytorch

本文链接：https://blog.csdn.net/qq_46656857/article/details/129295103

版权

PyTorch 专栏收录该内容

14 篇文章 6 订阅

订阅专栏

学习视频：B站刘二大人《PyTorch深度学习实践》完结合集

十、卷积神经网络（高级篇）

1. 串行的网络结构

之前的网络，不管是全连接神经网络还是卷积神经网络，都是一种串行的结构

2. GoogLeNet

2.1结构分析

GoogleNet的网络结构，里面的模块称为inception

inception模块的构成方式其实有很多种，这只是其中的一种，首先需要知道inception为什么这样构建？

因为构建的时候有一些超参数是比较难选的，比如卷积核的大小，是使用3x3，还是5x5还是使用其他的方式

GooleNet的出发点就是不知道哪个卷积核好用，那么就在一个块里面把卷积核都使用一下，然后把他们结果挪到一起，之后如果3x3的好用，自然3x3的权重就会变得比较大，其他路线的权重相对就会变得更小，所以这是提供了几种后续的神经网络的配置，然后通过训练自动的找到最优的卷积的组合，这是GooleNet设计的灵感。

Concatenate：把张量拼接到一块。4条路径算出来4个张量，所以肯定要做一个拼接。

Average Pooling：均值池化，4条分支后续要进行拼接，所以必须要保持他们的宽度和高度是一致的，输出的图像格式为（B,C,W,H），唯一可以不同的就是C（channel），不同的卷积核为了使得输出的W和H一致，可以通过padding来实现。

之前使用的是2x2的最大池化，导致图像变成了原来的一半，所以解决方案是做池化的时候认为的指定stride=1，padding= 多少，例如使用3x3的大小去做均值，可以使用padding=1，有点类似卷积的操作，但是没有卷积核，使用的可以称为均值卷积核，卷积核中的数都一样，所以均值池化可以通过设置stride和padding使得输入输出图像的大小是一致的。

1×1的卷积：

代表卷积核大小就是1x1的，1x1卷积的个数取决于输出张量的通道数

1*1卷积完成了一个信息融合，其主要的工作：改变通道数，减小复杂度
神经网络里面的问题就是运算量太大，所以我们需要思考怎么解决运算量大的问题

在原来的基础上添加了一层1x1的卷积层之后，运算量变为了原来的1/10。

2.2 Inception Module

上图最后一行少了branch = self.branch3x3_3(branch3x3)

在各个计算完成之后还需要拼接，按照各个通道进行拼接，图示化如下：

dim=1，因为我们输入的图像是（B,C,W,H），dim=1就代表C，按照通道进行拼接。
上图中，我们可以计算出输出通道数为24+16+24+24=88

2.3 代码实现

# inception模块
class Inception(nn.Module):
    def __init__(self,in_channels):
        super(Inception, self).__init__()
        self.branch1x1 = nn.Conv2d(in_channels,16,kernel_size=1)

        self.branch5x1 = nn.Conv2d(in_channels,16,kernel_size=1)
        self.branch5x2 = nn.Conv2d(16,24,kernel_size=5,padding=2)

        self.branch3x1 = nn.Conv2d(in_channels,16,kernel_size=1)
        self.branch3x2 = nn.Conv2d(16,24,kernel_size=3,padding=1)
        self.branch3x3 = nn.Conv2d(24,24,kernel_size=3,padding=1)

        self.branch_pool = nn.Conv2d(in_channels,24,kernel_size=1)

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

        branch5x5 = self.branch5x1(x)
        branch5x5 = self.branch5x2(branch5x5)

        branch3x3 = self.branch3x1(x)
        branch3x3 = self.branch3x2(branch3x3)
        branch3x3 = self.branch3x3(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,dim=1)  # 按通道进行拼接

注意初始的输入通道没有写死，而是作为in_channels入参设置。

# 网络模块
class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.conv1 = nn.Conv2d(1,10,kernel_size=5)
        self.conv2 = nn.Conv2d(88,20,kernel_size=5)

        self.incep1 = Inception(in_channels=10)
        self.incep2 = Inception(in_channels=20)

        self.mp = nn.MaxPool2d(2)
        self.fc = nn.Linear(1408,10)

    def forward(self,x):
        in_size = x.size(0)
        x = f.relu(self.mp(self.conv1(x))) # 10通道
        x = self.incep1(x)                 # 10通道变88通道
        x = f.relu(self.mp(self.conv2(x))) # 88通道变20通道
        x = self.incep2(x)                 # 20通道变88通道
        x = x.view(in_size,-1)             # 这里可以计算出拉成一维以后的大小
        x = self.fc(x)
        return x

在之前的MNIST数据集上进行测试Inception网络模型，运行结果为：‘

我们观察结果图可以发现，准确率上升到最高点后出现了下降，一般我们在训练的过程中，我们会保存我们每个epoch训练的结果，最后我们会在测试集上选用准确率高的训练模型。我们需要注意的是不是说训练的次数越多，网络的性能越好，训练的多了可能出现过拟合，导致模型的泛化能力变差。

3. Residual Net

3.1 分析

把3x3的网络一直堆下去，性能会不会变好。实验发现，层数越多，反而错误率越高。

可能的原因：梯度消失，因为我们的网络会进行反向传播，而反向传播的本质是链式法则，假如一连串的梯度是小于1的，这样乘起来就会越来越小，最终趋近于0。
而我们的权重更新是：w = w - 学习率*梯度，如果梯度接近0了，那么他们的权重w就基本得不到什么更新。

解决梯度消失的思路：

假如有一个512的隐藏层，然后后面直接接一个512x10的层进行训练，训练完成以后，把512层进行冻结;

然后再添加一个256的层，后面接256x10进行训练，训练完成以后，还是对256层进行加锁，逐层的进行训练。

通过以上这种训练方式来解决梯度消失的问题。但是在深度学习里面，这样做的话其实是一件很困难的事情，因为深度学习的层数是非常多的。

ResNet引入残差结构就是为了解决网络层数不断加深时导致的梯度消失问题

通过短路连接，可以实现在计算梯度的时候不至于接近0，而是梯度小的时候，计算的梯度值在1附近，这就是Resnet网络的智慧所在。

3.2 Residual Network

模型：

3.3 代码实现

残差代码实现：

# ResiduaBlock模块
class ResiduaBlock(nn.Module):
    def __init__(self,channels):
        super(ResiduaBlock, self).__init__()
        self.channels = channels
        self.conv1 = nn.Conv2d(channels,channels,kernel_size=3,padding=1)
        self.conv2 = nn.Conv2d(channels,channels,kernel_size=3,padding=1)
    def forward(self,x):
        y = f.relu(self.conv1(x))
        y = self.conv2(y)
        return f.relu(x+y)

网络结构代码实现：

# 网络模块
class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.conv1 = nn.Conv2d(1,16,kernel_size=5)
        self.conv2 = nn.Conv2d(16,32,kernel_size=5)
        self.mp = nn.MaxPool2d(2)

        self.rblock1 = ResiduaBlock(16)
        self.rblock2 = ResiduaBlock(32)

        self.fc = nn.Linear(512,10)

    def forward(self,x):
        in_size = x.size(0)
        x = self.mp(f.relu(self.conv1(x)))
        x = self.rblock1(x)
        x = self.mp(f.relu(self.conv2(x)))
        x = self.rblock2(x)
        x = x.view(in_size,-1)
        x = self.fc(x)
        return x