《动手学深度学习——卷积神经网络、LeNet、卷积神经网络进阶》笔记

动手学深度学习：卷积神经网络，LeNet，卷积神经网络进阶 卷积神经网络基础

目录：
1、卷积神经网络的基础概念
2、卷积层和池化层
3、填充、步幅、输入通道和输出通道
4、卷积层的简洁实现
5、池化层的简洁实现

1、卷积神经网络的基础概念

最常见的二维卷积层，常用于处理图像数据。

二维互相关运算
二维互相关（cross-correlation）运算的输入是一个二维输入数组和一个二维核（kernel）数组，输出也是一个二维数组，其中核数组通常称为卷积核或过滤器（filter）。卷积核的尺寸通常小于输入数组，卷积核在输入数组上滑动，在每个位置上，卷积核与该位置处的输入子数组按元素相乘并求和，得到输出数组中相应位置的元素。图1展示了一个互相关运算的例子，阴影部分分别是输入的第一个计算区域、核数组以及对应的输出。
图1 二维互相关运算
3、填充、步幅、输入通道和输出通道
卷积层的两个超参数，即填充和步幅，它们可以对给定形状的输入和卷积核改变输出形状。
填充
填充（padding）是指在输入高和宽的两侧填充元素（通常是0元素），图2里我们在原输入高和宽的两侧分别添加了值为0的元素。
图2 在输入的高和宽两侧分别填充了0元素的二维互相关计算
，如果原输入的高和宽是nhn_hn 列，则输出形状为：(nh+ph−kh+1)×(nw+pw−kw+1)(n_h+p_h-k_h+1)\times(n_w+p_w-k_w+1)
我们在卷积神经网络中使用奇数高宽的核，比如3×33 \times 33×3，5×55 \times 55×5的卷积核，对于高度（或宽度）为大小为2k+12 k + 12k+1的核，令步幅为1，在高（或宽）两侧选择大小为kkk的填充，便可保持输入与输出尺寸相同。
步幅
在互相关运算中，卷积核在输入数组上滑动，每次滑动的行数与列数即是步幅（stride）。此前我们使用的步幅都是1，图3展示了在高上步幅为3、在宽上步幅为2的二维互相关运算。
图3 高和宽上步幅分别为3和2的二维互相关运算
一般来说，当高上步幅为shs_hs 时，输出形状为：
⌊(nh+ph−kh+sh)/sh⌋×⌊(nw+pw−kw+sw)/sw⌋\lfloor(n_h+p_h-k_h+s_h)/s_h\rfloor \times \lfloor(n_w+p_w-k_w+s_w)/s_w\rfloor
如果ph=kh−1p_h=k_h-1p−1，pw=kw−1p_w=k_w-1p −1，那么输出形状将简化为⌊(nh+sh−1)/sh⌋×⌊(nw+sw−1)/sw⌋\lfloor(n_h+s_h-1)/s_h\rfloor \times \lfloor(n_w+s_w-1)/s_w\rfloor⌊(n ⌋。更进一步，如果输入的高和宽能分别被高和宽上的步幅整除，那么输出形状将是(nh/sh)×(nw/sw)(n_h / s_h) \times (n_w/s_w)(nh=p时，我们称填充为ppp；当sh=sw=ss_h = s_w = ss h =s w =s时，我们称步幅为sss。
多输入通道和多输出通道
多输入通道
卷积层的输入可以包含多个通道，图4展示了一个含2个输入通道的二维互相关计算的例子。
图4 含2个输入通道的互相关计算
假设输入数据的通道数为cic_ic i ，卷积核形状为kh×kwk_h\times k_wk w ，我们为每个输入通道各分配一个形状为kh×kwk_h\times k_wk 的核数组，将cic_ic i 个互相关运算的二维输出按通道相加，得到一个二维数组作为输出。我们把cic_ic i 个核数组在通道维上连结，即得到一个形状为ci×kh×kwc_i\times k_h\times k_wc 的卷积核。
之前的输入和输出都是二维数组，但真实数据的维度经常更高。例如，彩色图像在高和宽2个维度外还有RGB（红、绿、蓝）3个颜色通道。假设彩色图像的高和宽分别是hhh和www（像素），那么它可以表示为一个3×h×w3 \times h \times w3×h×w的多维数组，我们将大小为3的这一维称为通道（channel）维。
多输出通道
卷积层的输出也可以包含多个通道，设卷积核输入通道数和输出通道数分别为cic_ic 。如果希望得到含多个通道的输出，我们可以为每个输出通道分别创建形状为ci×kh×kwc_i\times k_h\times k_wc 的核数组，将它们在输出通道维上连结，卷积核的形状即co×ci×kh×kwc_o\times c_i\times k_h\times k_wc 对于输出通道的卷积核，我们提供这样一种理解，一个ci×kh×kwc_i \times k_h \times k_wc i的核数组可以提取某种局部特征，但是输入可能具有相当丰富的特征，我们需要有多个这样的ci×kh×kwc_i \times k_h \times k_wc
的核数组，不同的核数组提取的是不同的特征。
1x1卷积层
通常称这样的卷积运算为1×11 \times 11×1卷积，称包含这种卷积核的卷积层为1×11 \times 11×1卷积层。图5展示了使用输入通道数为3、输出通道数为2的1×11\times 11×1卷积核的互相关计算。
图5 1x1卷积核的互相关计算。输入和输出具有相同的高和宽
1×11 \times 11×1卷积核可在不改变高宽的情况下，调整通道数。1×11 \times 11×1卷积核不识别高和宽维度上相邻元素构成的模式，其主要计算发生在通道维上。假设我们将通道维当作特征维，将高和宽维度上的元素当成数据样本，那么1×11\times 11×1卷积层的作用与全连接层等价。
卷积层与全连接层的对比
二维卷积层经常用于处理图像，与此前的全连接层相比，它主要有两个优势：
一是全连接层把图像展平成一个向量，在输入图像上相邻的元素可能因为展平操作不再相邻，网络难以捕捉局部信息。而卷积层的设计，天然地具有提取局部信息的能力。
二是卷积层的参数量更少。不考虑偏置的情况下，一个形状为(ci,co,h,w)(c_i, c_o, h, w)(c i ,c o ,h,w)的卷积核的参数量是ci×co×h×wc_i \times c_o \times h \times wc×h×w，与输入图像的宽高无关。假如一个卷积层的输入和输出形状分别是(c1,h1,w1)(c_1, h_1, w_1)©，如果要用全连接层进行连接，参数数量就是c1×c2×h1×w1×h2×w2c_1 \times c_2 \times h_1 \times w_1 \times h_2 \times w_2c。使用卷积层可以以较少的参数数量来处理更大的图像。

4、 卷积层的简洁实现
我们使用Pytorch中的nn.Conv2d类来实现二维卷积层，主要关注以下几个构造函数参数：

in_channels (python:int) – Number of channels in the input imag
out_channels (python:int) – Number of channels produced by the convolution
kernel_size (python:int or tuple) – Size of the convolving kernel
stride (python:int or tuple, optional) – Stride of the convolution. Default: 1
padding (python:int or tuple, optional) – Zero-padding added to both sides of the input. Default: 0
bias (bool, optional) – If True, adds a learnable bias to the output. Default: True

forward函数的参数为一个四维张量，形状为(N,Cin,Hin,Win)(N, C_{in}, H_{in}, W_{in})(N,C in,H in ,W in )，返回值也是一个四维张量，形状为(N,Cout,Hout,Wout)(N, C_{out}, H_{out}, W_{out})(N,C
out ,H out,W out )，其中NNN是批量大小，C,H,WC, H, WC,H,W分别表示通道数、高度、宽度。

X = torch.rand(4, 2, 3, 5)
print(X.shape)

conv2d = nn.Conv2d(in_channels=2, out_channels=3, kernel_size=(3, 5), stride=1, padding=(1, 2))
Y = conv2d(X)
print('Y.shape: ', Y.shape)
print('weight.shape: ', conv2d.weight.shape)
print('bias.shape: ', conv2d.bias.shape)
 

5、 池化层的简洁实现
我们使用Pytorch中的nn.MaxPool2d实现最大池化层，关注以下构造函数参数：
kernel_size – the size of the window to take a max over
stride – the stride of the window. Default value is kernel_size
padding – implicit zero padding to be added on both sides
forward函数的参数为一个四维张量，形状为(N,C,Hin,Win)(N, C, H_{in}, W_{in})(N,C,H in ,W in )，返回值也是一个四维张量，形状为(N,C,Hout,Wout)(N, C, H_{out}, W_{out})(N,C,H out ,W out )，其中NNN是批量大小，C,H,WC, H, WC,H,W分别表示通道数、高度、宽度。

X = torch.arange(32, dtype=torch.float32).view(1, 2, 4, 4)
pool2d = nn.MaxPool2d(kernel_size=3, padding=1, stride=(2, 1))
Y = pool2d(X)
print(X)
print(Y)

平均池化层使用的是nn.AvgPool2d，使用方法与nn.MaxPool2d相同。

二、LeNet

目录： 1、LeNet模型 2、LeNet模型实战

使用全连接层的局限性：
图像在同一列邻近的像素在这个向量中可能相距较远。它们构成的模式可能难以被模型识别。
对于大尺寸的输入图像，使用全连接层容易导致模型过大。
使用卷积层的优势：
卷积层保留输入形状。
卷积层通过滑动窗口将同一卷积核与不同位置的输入重复计算，从而避免参数尺寸过大。
LeNet 模型
LeNet分为卷积层块和全连接层块两个部分。下面我们分别介绍这两个模块。
卷积层块里的基本单位是卷积层后接平均池化层：卷积层用来识别图像里的空间模式，如线条和物体局部，之后的平均池化层则用来降低卷积层对位置的敏感性。

卷积层块由两个这样的基本单位重复堆叠构成。在卷积层块中，每个卷积层都使用5×55 \times 55×5的窗口，并在输出上使用sigmoid激活函数。第一个卷积层输出通道数为6，第二个卷积层输出通道数则增加到16。

全连接层块含3个全连接层。它们的输出个数分别是120、84和10，其中10为输出的类别个数。

LeNet 模型实战

下面我们通过Sequential类来实现LeNet模型。

#import
import sys
sys.path.append("/home/kesci/input")
import d2lzh1981 as d2l
import torch
import torch.nn as nn
import torch.optim as optim
import time

#net
class Flatten(torch.nn.Module):  #展平操作
    def forward(self, x):
        return x.view(x.shape[0], -1)

class Reshape(torch.nn.Module): #将图像大小重定型
    def forward(self, x):
        return x.view(-1,1,28,28)      #(B x C x H x W)
    
net = torch.nn.Sequential(     #Lelet                                                  
    Reshape(),
    nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, padding=2), #b*1*28*28  =>b*6*28*28
    nn.Sigmoid(),                                                       
    nn.AvgPool2d(kernel_size=2, stride=2),                              #b*6*28*28  =>b*6*14*14
    nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5),           #b*6*14*14  =>b*16*10*10
    nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),                              #b*16*10*10  => b*16*5*5
    Flatten(),                                                          #b*16*5*5   => b*400
    nn.Linear(in_features=16*5*5, out_features=120),
    nn.Sigmoid(),
    nn.Linear(120, 84),
    nn.Sigmoid(),
    nn.Linear(84, 10)
)

#接下来我们构造一个高和宽均为28的单通道数据样本，并逐层进行前向计算来查看每个层的输出形状。

#print
X = torch.randn(size=(1,1,28,28), dtype = torch.float32)
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__,'output shape: \t',X.shape)
 
Reshape output shape: torch.Size([1, 1, 28, 28])
Conv2d output shape: torch.Size([1, 6, 28, 28])
Sigmoid output shape: torch.Size([1, 6, 28, 28])
AvgPool2d output shape: torch.Size([1, 6, 14, 14])
Conv2d output shape: torch.Size([1, 16, 10, 10]