torch笔记十三 | 卷积网络

1. 卷积层

概念
对全连接层使用平移不变性和局部性得到卷积层。卷积层将输入和核矩阵进行交叉相关，加上偏移后得到输出。核矩阵和偏移是可学习的参数；核矩阵的大小、填充（通常为核减一）、步幅是超参数。

维度的变化

步长为1的时候，输入X：h x w
核W：a x b
输出Y：（h-a+1）x（w-b+1）

填充

在输入周围添加额外的行/列，控制输出的减少量。填充P行Q列，输出的形状为：（h-a+P+1）x（w-b+Q+1）。通常取P=a-1，Q=b-1，（填充数通常为卷积核大小减1）使得输出形状保持不变。当a为奇数的时候，在上下两侧各填充padding=P/2；当a为偶数的时候（其实很少使用边长为偶数的卷积核），在上下两侧中，有一侧多一行。深度学习框架中的padding=1，表示在图的四周都添加一层0。

步幅

步幅是指行/列的滑动步长，可以成倍地减少输出的形状。给定高度s1和宽度s2的步幅，输出的形状是[(h-a+P+s1)/s1] x [(w-b+Q+s2)/s2]。如果P=a-1，Q=b-1，（填充数为卷积核大小减1），输出的形状是[(h-a-1)/s1] x [(w-b-1)/s2]；如果输入高度和宽度可以被步幅整除，输出形状为（h/s1）x（w/s2）。

多输入多输出通道

彩色图像RGB三个通道，转为灰度会丢失信息。

多个输入通道：每个通道都有一个卷积核，那么相应通道和相应的卷积核做卷积计算，然后按元素相加，结果是所有通道卷积结果的和。

多个输出通道（以RGB图像为例）：对每一个输出通道都有一个三维卷积核，计算得到每个输出通道中三维卷积核的数值。每一个输出通道可以认为是识别某一个特定的模式；将每个输出通道输入到下一层，加权求和。

例子：输入一张猫的原始图片，前面的层一般识别一些角度的边，胡须耳朵纹理等信息，后面的层会不断的把纹理组合起来，比如一个通道识别出来的是猫头，眼睛等，再往后最后一层就识别出这是一只猫。

1x1卷积层

卷积核的高和宽都是1，每次只看一个像素，不改变特征图的高和宽。不会识别空间信息，只是融合通道，使得每个输出通道的数值都是输入通道对应位置数值的加权和，相当于一个全连接层。

卷积核膨胀（dilation）

如果我们设置的dilation=0的话，左图。蓝色为输入，绿色为输出，可见卷积核为3x3的卷积核。如果我们设置的是dilation=1，那么效果如图蓝色为输入，绿色为输出，卷积核仍为3x3，但是这里卷积核点与输入之间距离为1的值相乘来得到输出。

好处：这样单次计算时覆盖的面积（即感受域）由dilation=0时的3*3=9变为了dilation=1时的5x5=25。在增加了感受域的同时却没有增加计算量，保留了更多的细节信息，对图像还原的精度有明显的提升。

池化层

有窗口大小、填充和步幅超参数；返回窗口中的最大或者平均；可以缓解卷积层对位置的敏感性。

机器学习本质上来说就是一个压缩算法，输入一张图片输出一个值。
一般来说，不会手写神经网络，常套用和修改经典的网络结构，使用ResNet居多。
一般特征图长宽减半的同时，通道数扩大到两倍。

2. LeNet网络

90年代，神经网络第一次兴起。1998年提出LeNet网络。思想：先使用卷积层来学习图片空间信息，然后使用全连接层来转换到类别空间。

实现

import torch
from torch import nn, optim
import torch.utils.data as Data
import torchvision.transforms as transforms
import torchvision
import sys
import time

# 1.读入数据集

mnist_train = torchvision.datasets.FashionMNIST(root=".", train=True, download=True,
                                                transform=transforms.ToTensor())

mnist_test = torchvision.datasets.FashionMNIST(root=".", train=False, download=True,
                                               transform=transforms.ToTensor())
batch_size = 256
if sys.platform.startswith("win"):
    num_workers = 0
else:
    num_workers = 8
train_iter = Data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=num_workers)
test_iter = Data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=num_workers)

# 2.搭建lenet
class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        self.c1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5)
        self.a1 = nn.Sigmoid()
        self.p1 = nn.MaxPool2d(kernel_size=2, stride=2)

        self.c2 = nn.Conv2d(6, 16, 5)
        self.a2 = nn.Sigmoid()
        self.p2 = nn.MaxPool2d(2, 2)

        self.l1 = nn.Linear(16*4*4, 120)
        self.a3 = nn.Sigmoid()
        self.l2 = nn.Linear(120, 84)
        self.a4 = nn.Sigmoid()
        self.l3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.c1(x)
        x = self.a1(x)
        x = self.p1(x)

        x = self.c2(x)
        x = self.a2(x)
        x = self.p2(x)

        x = x.view(x.shape[0], -1)      # 将特征图拉直
        x = self.l1(x)
        x = self.a3(x)
        x = self.l2(x)
        x = self.a4(x)
        y = self.l3(x)
        return y
net = LeNet()
net = net.cuda(0)					# 将net放到GPU

# 3.配置方法
loss = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.01)

# 4.训练
start = time.time()
for epoch in range(10):
    for X, y in train_iter:
        X, y = X.cuda(), y.cuda()	# 将tensor放到GPU
        out = net(X)
        l = loss(out, y)
        optimizer.zero_grad()
        l.backward()
        optimizer.step()
    print("epoch: %d    loss: %f" % (epoch, l.item()))
print("time: %f" % (time.time()-start))

3. AlexNet

在2000年时，机器学习最火的是核方法。神经网络被核方法取代，原因：① 核方法有一套完整的泛函过来的数学定理，能够计算复杂度等等，学术界喜欢理论；② 神经网络深的东西做不动了。过程：提取特征、选择核函数计算相关性、凸优化问题、漂亮的定理。

2010年，数据量的增加和计算能力的提升，神经网络再次兴起。李飞飞等提出了ImageNet数据集（2010），包含了自然物体的彩色图片。2012年提出的AlexNet，夺得冠军，其实就是更深更大的LeNet（复杂度包括参数个数、运算次数），标志着新一轮的神经网络热潮的开始。主要改进：丢弃法、ReLu、MaxPooling。引起了计算机视觉方法论的改变。之前，图像->人工特征提取->机器学习模型（SVM）；现在，图像->通过CNN学习特征->Softmax回归，后面的两个模型在一起训练更加高效，端到端，从原始的pixel、字符串、信号等到最终的分类、预测直接通过神经网络直接过去。

架构

更大的核窗口和步长，因为图片更大了。更大的池化窗口，使用最大池化层。2x2池化可以理解为一个像素可以往一边移动一点，不影响结果；3x3池化可以理解为像素往左往右移动一下，不影响输出。

激活函数从Sigmoid变到了ReLu（减缓梯度消失），隐藏全连接层后加入了丢弃层，数据增强（随即裁剪、随机亮度、色温）。卷积对位置，亮度比较敏感，在输入里面增加大量的变种，在训练的时候模拟这种变化，使得网络对这些因素不敏感。神经网络能记住所有数据，这样做可以使得记住的能力变低。

4. VGG

AlexNet比LeNet更深更大来得到更好的精度，能不能更深更大？选项：

• 更多的全连接层（太贵）
• 更多的卷积层
• 将卷积层组合成块

VGG块

3x3卷积（超参数是n层，m通道），2x2最大池化

架构

多个VGG块后接全连接层，VGG使用可重复使用的卷积块来构建深度卷积网络，不同次数的重复块和超参数得到不同的架构，VGG-16（13个卷积层，3个全连接层），VGG-19。

PS：

训练loss一直下降，测试loss不降原因：① 测试代码写错了。② 测试集和数据集相差比较大，确实长得很不一样。

测试acc是有可能大于训练acc的，当训练数据比较多，数据增强加入的噪声比较多的时候，测试acc比训练acc高是很正常的。

5. 小结

LeNet：2个 卷积+池化层， 2个全连接层

AlexNet：更大更深，ReLu，Dropout，数据增强

VGG：更深更大的AlexNet（重复的VGG块）

6. 网络中的网络（NiN）

现在很少使用。卷积层需要较少的参数（输入通道数x输出通道数x高x宽），但卷积层的第一个全连接层的参数（通道数x宽x高x全连接神经元个数）较多，可能会带来过拟合。思想就是完全不用全连接层。

NiN块

一个卷积层后跟两个1x1卷积层（相当于全连接层）。注意1x1的卷积层（步幅1，无填充），不改变输出高宽，对于每个像素做全连接，对每个像素增加了非线性性，可以等价于全连接层。

架构

无全连接层；交替使用NiN块和步幅为2的最大池化层，逐步减小高宽和增大通道数；最后使用全局平均池化层得到输出（输入通道数需要是类别数）。不容易过拟合，更少的参数个数。

7. 含并行连结的网络（GoogLeNet ）

Inception块：小学生才做选择题，我全要了。有4条不同超参数的卷积层和池化层的路，4个路径从不同的层面抽取信息，每条路上通道数可能不同，降低通道数来控制模型复杂度，输入输出等高等宽，然后在输出通道维堆在一起。

结构：（假设输入192x28x28）

• 1x1 conv。192-64
• 1x1 conv，3x3 conv。192-96-128
• 1x1 conv，5x5 conv。192-16-32
• 3x3 maxpooling，1x1 conv。192-192-32

输出：256x28x28。跟单3x3或5x5卷积层相比，Inception块有更少的参数个数和计算复杂度。

GoogLeNet：5个stage（高宽减半为一个stage），9个Inception块。是第一个达到上百层的网络，后续有一系列的变种改进（V3，V4）

8. 批量归一化

当神经网络比较深的时候，数据在网络底部传入，损失在网络顶部计算，出现在最后，而使用BP算法，误差反向传播，后面的层训练比较快。底部的层训练的比较慢，而底层（抽取物体的边缘啊纹理啊等底层特征）一变化，后面所有的都要跟着变化，使得最后的那些层需要重新学习多次，导致收敛变慢。我们可以在学习底部层的时候避免变化顶部层吗？

为什么会发生变化呢？原因是数据的方差均值的分布在不同层之间变化。批量归一化尝试把minibatch里面的均值和方差固定住，固定每层的输出和梯度的分布，相对来说比较稳定。首先，计算均值和方差，然后再做额外的调整（可学习的参数）:

$$x_{i+1}=\gamma \frac{x_i-{\mu }_B}{{\sigma }_B}+\beta$$

可学习的参数为 $\gamma$ 和 $\beta$，作用在全连接和卷积层输出上，激活函数前。批量归一化是一个线性变换，对全连接层，作用在特征维；对卷积层，作用在通道维。它可能就是通过在每个小批量里加入噪声来控制模型复杂度（随机偏移，随机缩放）。因此没必要跟丢弃法混合使用。BN只一般用于深层网络，浅层MLP加上BN效果并不明显。

批量归一化固定小批量中的均值和方差，然后学习出适合的偏移和缩放；可以加速收敛速度，但一般不改变模型精度。直观理解：用了BN之后，发现可以使用较大的学习率，对每层的均值和方差都放到一起了，就不会出现学习率太大的话，上面的层梯度比较大炸掉了；学习率太小的话，下面的层梯度太小算不动。现在把每层的输入都放到一个差不多的分布里面，可以统一使用一个大一些的学习率。

9.残差网络（ResNet）

残差块加入快速通道来得到f(x)=x+g(x)的结构。高宽减半ResNet块时，需要快速通道上有1x1的卷积改变通道数。架构：5个stage。ResNet152（152个卷积层）、101、50、34、18。

残差块使得很深的网络更加容易训练，由于连接的存在，不管网络再深，也能把下面小层的先训练好，甚至可以训练一千层的网络。残差网络的跳跃连接对随后的深层神经网络设计产生了深远影响，很多网络都采用跳跃连接。

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


# 1. 残差块
class Residual(nn.Module):
    def __init__(self, input_channels, num_channels, use_1x1conv=False, strides=1):# 输入通道数，输出通道数，快速通道是否使用1x1卷积层，第一个卷积层的步长(控制是否宽高减半)
        super(Residual, self).__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)
        self.relu = nn.ReLU(inplace=True)  # inplace节省内存

    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)


# 1.输入和输出形状一致
blk = Residual(input_channels=3, num_channels=3)
# 2.增加输出通道数的同时，减半输出的高和宽
blk = Residual(input_channels=3, num_channels=6, use_1x1conv=True, strides=2)
X = torch.randn(6, 3, 4, 4)
Y = blk(X)
print(Y.shape)

输出：
torch.Size([6, 3, 4, 4])
torch.Size([6, 6, 2, 2])

# 2.第一个stage
b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),    # TODO padding
                   nn.BatchNorm2d(64), nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

# 3.定义残差stage

# 输入通道数、输出通道数、需要残差块的个数、是否第一个残差stage
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:  # 除了第一个残差stage（b2），其余stage的第一个残差块高宽减半
            blk.append(
                Residual(input_channels, num_channels, use_1x1conv=True, strides=2)
            )
        else:
            blk.append(Residual(num_channels, num_channels))
    return blk


b2 = nn.Sequential(*resnet_block(input_channels=64, num_channels=64, num_residuals=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))

# 定义网络
net = nn.Sequential(b1, b2, b3, b4, b5, nn.AdaptiveAvgPool2d((1, 1)),
                    nn.Flatten(), nn.Linear(512, 10))

X = torch.randn(size=(1, 1, 224, 224))
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__, X.shape)

输出：
Sequential torch.Size([1, 64, 56, 56])
Sequential torch.Size([1, 64, 56, 56])	# 第一个残差stage并没有变换尺寸
Sequential torch.Size([1, 128, 28, 28])
Sequential torch.Size([1, 256, 14, 14])
Sequential torch.Size([1, 512, 7, 7])
AdaptiveAvgPool2d torch.Size([1, 512, 1, 1])
Flatten torch.Size([1, 512])
Linear torch.Size([1, 10])

经典的ResNet网络的结构：

ResNet是如何消除梯度消失的？