【第二周】卷积神经网络

一、卷积神经网络

1. 卷积层

填充 & 步长

感受野

1×1 卷积层

• 调整网络层的通道数量和控制模型复杂性：它可以将输入特征图的通道数进行调整，通过调整通道数，可以控制模型的复杂度和参数量，同时也可以改变特征图的维度。

• 跨通道信息融合：它可以通过在通道维度上进行卷积操作，将不同通道的特征进行融合，从而提取更丰富的特征表示。这种特征融合可以帮助网络更好地捕捉到不同通道之间的相关性，提升模型性能。

2. 池化层

3. 全连接层

4. 激活函数

二、经典卷积神经网络

1. LeNet-5

import torch
from torch import nn


LeNet = nn.Sequential(
		nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Flatten(),
    nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(),
    nn.Linear(120, 84), nn.Sigmoid(),
    nn.Linear(84, 10))

2. AlexNet

ImageNet Classification with Deep Convolutional Neural Networks

https://proceedings.neurips.cc/paper/2012/hash/c399862d3b9d6b76c8436e924a68c45b-Abstract.html

🏙️ AlexNet 和 LeNet 网络对比

AlexNet的架构与LeNet相似，但使用了更多的卷积层和更多的参数来拟合大规模的数据集。

import torch
from torch import nn


AlexNet = nn.Sequential(
    # 这里使用一个11*11的更大窗口来捕捉对象。
    # 同时，步幅为4，以减少输出的高度和宽度。
    # 另外，输出通道的数目远大于LeNet
    nn.Conv2d(1, 96, kernel_size=11, stride=4, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    # 减小卷积窗口，使用填充为2来使得输入与输出的高和宽一致，且增大输出通道数
    nn.Conv2d(96, 256, kernel_size=5, padding=2), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    # 使用三个连续的卷积层和较小的卷积窗口。
    # 除了最后的卷积层，输出通道的数量进一步增加。
    # 在前两个卷积层之后，汇聚层不用于减少输入的高度和宽度
    nn.Conv2d(256, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nn.Flatten(),
    # 这里，全连接层的输出数量是LeNet中的好几倍。使用dropout层来减轻过拟合
    nn.Linear(6400, 4096), nn.ReLU(),
    nn.Dropout(p=0.5),
    nn.Linear(4096, 4096), nn.ReLU(),
    nn.Dropout(p=0.5),
    # 最后是输出层。
    nn.Linear(4096, 1000))

• 使用 作为激活函数，加速学习过程，解决了 函数的梯度消失问题。

• 随机失活（Dropout）：减少过拟合现象并提高模型的泛化能力。

• 最大池化（Max Pooling）：增强的模型特征提取能力。

• 局部响应值归一化（Local Response Normalization）：增强模型的泛化能力并减少过拟合。

• 数据增强技术（Data Augmentation）：进一步扩充数据，更大的样本量有效地减少了过拟合。

• GPU加速计算：在GPU硬件上运行的深度卷积神经网络，实现了并行运算。

激活函数（ReLU VS. Sigmoid）

1. 解决梯度消失问题： 函数在输入值非常大或非常小的情况下，梯度接近于0，这可能会导致反向传播时梯度消失，从而难以更新深层网络的参数。而 函数在输入大于0时，梯度始终为1，可以有效地缓解梯度消失问题。

2. 计算效率高： 函数的计算复杂度比 函数低。 只需要判断输入是否大于0，而 函数需要进行指数运算，计算开销更大。

3. 稀疏激活： 在输入小于0时，输出为0，这意味着在任何时候，只有部分神经元被激活，造成了稀疏激活。这种稀疏性可能会带来一些优点，如减少神经元之间的依赖性，提高模型的泛化能力。

随机失活（Dropout）

最大池化（Max Pooling）

1. 保留主要特征：最大池化操作是取一块区域内的最大值作为输出，这样可以保留这块区域内的主要特征，而忽略一些不重要的信息。而平均池化是取平均值，可能会混淆主要信息和次要信息。

2. 更强的空间不变性：最大池化由于只关注最大值，所以比平均池化具有更好的空间不变性。这意味着，即使图像发生一些小的平移，最大池化的输出也不会改变太多。

3. 提高模型的非线性：最大池化本身是一个非线性操作，可以增加模型的非线性，有助于模型学习更复杂的特征。

局部响应值归一化（Local Response Normalization）

数据增强（Data Augmentation）

1. 平移、翻转和对称
• 随机裁剪（crop），例如，在训练时将256 * 256的图像随机裁剪为224 * 224。
• 水平翻转，可以将样本数量翻倍。

2. 改变RGB通道强度
• 对RGB空间进行高斯扰动，例如，每个RGB图像的像素：
经过变换后变为：

GPU加速计算

3. VGG

Very Deep Convolutional Networks for Large-Scale Image Recognition

In this work we investigate the effect of the convolutional network depth on its accuracy in the large-scale image recognition setting. Our main contribution is a thorough evaluation of networks...

http://arxiv.org/abs/1409.1556/

🏙️ VGG 和 AlexNet 网络对比

import torch
from torch import nn


def vgg_block(num_convs, in_channels, out_channels):
    layers = []
    for _ in range(num_convs):
        layers.append(nn.Conv2d(in_channels, out_channels,
                                kernel_size=3, padding=1))
        layers.append(nn.ReLU())
        in_channels = out_channels
    layers.append(nn.MaxPool2d(kernel_size=2,stride=2))
    return nn.Sequential(*layers)


def vgg(conv_arch):
    in_channels, conv_blks = 1, []
    # 卷积层部分
    for (num_convs, out_channels) in conv_arch:
        conv_blks.append(vgg_block(num_convs, in_channels, out_channels))
        in_channels = out_channels

    return nn.Sequential(
        *conv_blks, nn.Flatten(),
        # 全连接层部分
        nn.Linear(out_channels * 7 * 7, 4096), nn.ReLU(), nn.Dropout(0.5),
        nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(0.5),
        nn.Linear(4096, 10))


conv_arch = {
    "vgg11": ((1, 64), (1, 128), (2, 256), (2, 512), (2, 512)),
    "vgg13": ((2, 64), (2, 128), (2, 256), (2, 512), (2, 512)),
    "vgg16": ((2, 64), (2, 128), (3, 256), (3, 512), (3, 512)),
    "vgg19": ((2, 64), (2, 128), (4, 256), (4, 512), (4, 512)),
}

VGG_11 = vgg(conv_arch["vgg11"])

4. GoogLeNet

Going Deeper with Convolutions

We propose a deep convolutional neural network architecture codenamed "Inception", which was responsible for setting the new state of the art for classification and detection in the ImageNet Large-Scale Visual Recognition Challenge 2014 (ILSVRC 2014). The main hallmark of this architecture is the improved utilization of the computing resources inside the network.

http://arxiv.org/abs/1409.4842

Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift

Training Deep Neural Networks is complicated by the fact that the distribution of each layer's inputs changes during training, as the parameters of the previous layers change. This slows down the training by requiring lower learning rates and careful parameter initialization, and makes it notoriously hard to train models with saturating nonlinearities.

http://arxiv.org/abs/1502.03167

Rethinking the Inception Architecture for Computer Vision

Convolutional networks are at the core of most state-of-the-art computer vision solutions for a wide variety of tasks. Since 2014 very deep convolutional networks started to become mainstream, yielding substantial gains in various benchmarks.

http://arxiv.org/abs/1512.00567

Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning

Very deep convolutional networks have been central to the largest advances in image recognition performance in recent years. One example is the Inception architecture that has been shown to achieve very good performance at relatively low computational cost.

http://arxiv.org/abs/1602.07261

Inception块

• 辅助分类器：解决由于模型深度过深导致的梯度消失的问题。

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


class Inception(nn.Module):
    # c1--c4是每条路径的输出通道数
    def __init__(self, in_channels, c1, c2, c3, c4, **kwargs):
        super(Inception, self).__init__(**kwargs)
        # 线路1，单1x1卷积层
        self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1)
        # 线路2，1x1卷积层后接3x3卷积层
        self.p2_1 = nn.Conv2d(in_channels, c2[0], kernel_size=1)
        self.p2_2 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1)
        # 线路3，1x1卷积层后接5x5卷积层
        self.p3_1 = nn.Conv2d(in_channels, c3[0], kernel_size=1)
        self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_size=5, padding=2)
        # 线路4，3x3最大汇聚层后接1x1卷积层
        self.p4_1 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
        self.p4_2 = nn.Conv2d(in_channels, 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)


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.ReLU(),
                   nn.Conv2d(64, 192, kernel_size=3, padding=1),
                   nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

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),
                   nn.AdaptiveAvgPool2d((1,1)),
                   nn.Flatten())

GoogLeNet = nn.Sequential(b1, b2, b3, b4, b5, nn.Linear(1024, 10))

5. ResNet

Deep Residual Learning for Image Recognition

Deeper neural networks are more difficult to train. We present a residual learning framework to ease the training of networks that are substantially deeper than those used previously. We...

http://arxiv.org/abs/1512.03385

存在的问题

• 梯度消失或梯度爆炸
• 梯度消失：误差梯度小于 1，反向传播时，随着网络加深，梯度逐渐趋近于 的现象
• 梯度爆炸：误差梯度大于 1，反向传播时，随着网络加深，梯度逐渐趋近于 的现象

• 退化问题（degradation problem）
• 在解决了梯度消失、爆炸问题后，仍然存在深层网络的效果可能比浅层网络差的现象

Residual 模块

• 残差的思想：去掉相同的主体部分，从而突出微小的变化。

• 可以被用来训练非常深的网络。

ResNet 的网络设计规律

🏙️ 34 层 ResNet 示意图

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


class Residual(nn.Module):
    def __init__(self, input_channels, num_channels,
                 use_1x1conv=False, strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(input_channels, num_channels,
                               kernel_size=3, padding=1, stride=strides)
        self.conv2 = nn.Conv2d(num_channels, num_channels,
                               kernel_size=3, padding=1)
        if use_1x1conv:
            self.conv3 = nn.Conv2d(input_channels, num_channels,
                                   kernel_size=1, stride=strides)
        else:
            self.conv3 = None
        self.bn1 = nn.BatchNorm2d(num_channels)
        self.bn2 = nn.BatchNorm2d(num_channels)

    def forward(self, X):
        Y = F.relu(self.bn1(self.conv1(X)))
        Y = self.bn2(self.conv2(Y))
        if self.conv3:
            X = self.conv3(X)
        Y += X
        return F.relu(Y)


def resnet_block(input_channels, num_channels, num_residuals,
                 first_block=False):
    blk = []
    for i in range(num_residuals):
        if i == 0 and not first_block:
            blk.append(Residual(input_channels, num_channels,
                                use_1x1conv=True, strides=2))
        else:
            blk.append(Residual(num_channels, num_channels))
    return blk


b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
                   nn.BatchNorm2d(64), nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True))
b3 = nn.Sequential(*resnet_block(64, 128, 2))
b4 = nn.Sequential(*resnet_block(128, 256, 2))
b5 = nn.Sequential(*resnet_block(256, 512, 2))

ResNet = nn.Sequential(b1, b2, b3, b4, b5,
                    nn.AdaptiveAvgPool2d((1,1)),
                    nn.Flatten(), nn.Linear(512, 10))

批量归一化（Batch Normalization）

Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift

Training Deep Neural Networks is complicated by the fact that the distribution of each layer's inputs changes during training, as the parameters of the previous layers change. This slows down the training by requiring lower learning rates and careful parameter initialization, and makes it notoriously hard to train models with saturating nonlinearities.

https://arxiv.org/abs/1502.03167

Batch Normalization详解以及pytorch实验_太阳花的小绿豆的博客-CSDN博客_pytorch batchnormal

Batch Normalization是google团队在2015年论文《Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift》提出的。通过该方法能够加速网络的收敛并提升准确率。在网上虽然已经有很多相关文章，但基本都是摆上论文中的公式泛泛而谈，bn真正是如何运作的很少...

https://blog.csdn.net/qq_37541097/article/details/104434557

拓展：ResNeXt

Aggregated Residual Transformations for Deep Neural Networks

We present a simple, highly modularized network architecture for image classification. Our network is constructed by repeating a building block that aggregates a set of transformations with the...

https://arxiv.org/abs/1611.05431

三、问题总结

1. shuffle=True：每个epoch都会对数据进行随机打乱顺序。这意味着每次迭代时，数据的顺序都会被打乱，使得模型在训练过程中能够更好地学习数据的不同特征。

2. shuffle=False：数据将按照原始顺序进行加载，不随机打乱顺序。这通常在验证或测试过程中使用，以确保模型对数据的处理是有序的，可以进行可靠的评估和预测。

• Epoch 是指将整个训练数据集完整地过一遍的次数。在每个epoch中，模型会根据训练数据来进行前向传播、计算损失、反向传播更新参数等操作，以逐渐优化模型。

• Batch 是指将训练数据集划分为小块进行训练的单位。将数据集分成多个batch的目的是为了减少内存的使用和加速训练过程。每个epoch包含多个batch。

• 调整网络层的通道数量和控制模型复杂性：它可以将输入特征图的通道数进行调整，通过调整通道数，可以控制模型的复杂度和参数量，同时也可以改变特征图的维度。

• 跨通道信息融合：它可以通过在通道维度上进行卷积操作，将不同通道的特征进行融合，从而提取更丰富的特征表示。这种特征融合可以帮助网络更好地捕捉到不同通道之间的相关性，提升模型性能。

1. 池化层的改变：LeNet 中使用的是平均池化（average pooling），而代码练习二中使用的是最大池化（max pooling）。最大池化在保留主要特征的同时减少了特征图的维度，有助于提取更显著的特征。

2. 激活函数的改变：LeNet 中使用的是 Sigmoid 激活函数，而代码练习二中使用的是 ReLU（Rectified Linear Unit）激活函数。ReLU 在计算上更加高效，并且可以缓解梯度消失问题，有助于网络的训练和收敛。

• 数据清洗和预处理：确保数据集中没有错误、缺失或异常值，并进行适当的数据标准化、归一化或缩放，以便模型更好地理解和处理数据。

• 数据增强：通过对原始数据进行变换、旋转、平移、缩放等操作，生成更多的训练样本。数据增强可以增加模型的鲁棒性和泛化能力。

• 模型融合：将多个不同模型的预测结果进行融合，可以通过投票、加权平均或堆叠等方式来提高准确率。模型融合可以充分利用不同模型的优势，提高整体性能。

• 过拟合处理：如果模型在训练集上表现很好，但在测试集上表现较差，可能存在过拟合问题。可以通过正则化技术（如L1、L2正则化）、早停法、dropout等方法来减少过拟合。

• 更多数据：增加训练数据量可以帮助模型更好地学习数据的特征和模式。可以通过收集更多的数据、合成数据或使用迁移学习等方法来增加数据量。