PyTorch-07 卷积神经网络（什么是卷积、卷积神经网络、池化层、Batch normalization、经典卷积网络、深度残差网络 ResNet、nn.Module、数据增强）

PyTorch-07 卷积神经网络（什么是卷积、卷积神经网络、池化层、Batch normalization、经典卷积网络(LeNet-5、AlexNet、VGG、GoogLeNet)、深度残差网络 ResNet、nn.Module（使用nn.Module的好处）、数据增强（Data Argumentation））

一、什么是卷积

deep learning 一般使用0-1这个范围，但是数据存储是0-255，所以我们加载进来时除以255这个分数，使其达到0-1这个区间内。

What’s wrong with Linear

全连接层，在pytorch中也叫线性层，线性层仅仅表达了全连接网络的线性部分，线性层后面会增加一个非线性单元，叫做激活函数，因此不论是叫线性层还是叫全连接层，都指的是整个网络。我们实现的时候linear是没有包含激活函数这部分的。

对于下图，这个神经网络一共有4层，3个隐藏层和1个输出层，input layer输入层是不把它计算在内的，仅仅作为数据的输入。对于某一层，是指这一层的权值w和这一层的输出加在一起叫做一层。

输入的本来是28*28的matrix，这里为了方便全连接层的处理，因此打平为784维的向量。中间节点全部去256，一共有4个hidden layer，每个hidden layer是256，和一个输出层10类。

这个网络一共有多少参数量呢？多少参数量就意味着有多少条线，784256 + 256256 + 256256 + 25610 = 390k parameter参数量。每一个参数是用一个四字节的浮点数来表示的。390k *4 = 1.6MB memory的显存

Receptive Field 感受领域（局部相关性）

模仿人眼感受局部相关性的一个机制，提出了卷积神经网络，这里卷积指的就是局部相关性，一次感受的就是一个小方块，而不是一个大区间，一次感受的是一个小的视野，。

Weight sharing 权值共享

这样一个小窗口，会扫过一个大的图片，在扫合格大的图片过程中使用了同一个权值w，也就是w这个参数是不变的，扫完一次之后，只有在back propagate反向传播之后才更新一次w。因此小窗口扫描大图片的过程中，通过局部相关性促成这种共享的机制存在，使用相同的w扫描大图的过程叫做权值共享。以后会在RNN中使用权值共享这个概念在里面。使用权值共享会让参数量下降。

用于邮编的识别：LeNet-5，会让参数量下降了原来的1/6。

Convolution Operation卷积操作

卷积操作就是小窗口33不断的与大窗体对应位置进行计算，获得一个输出点，通过不断的循环，完成对所有点的计算后生成新的窗体，该新窗体大小和原来的窗体大小是相同的。

之前的连接是2828整个大窗体的连接，每个点都通过整个大窗体来进行计算，每个节点都有784条连线；而卷积计算只会和每个节点相关的9个节点相连线，这个小窗口只有9根线进行连接，其他的775条都是断开的。


小窗体和小窗体对应大窗体位置的小窗体可以进行矩阵的计算，也可以进行相应元素上的相乘后再累加，从而会的一个点，这种相乘在累加后生成一个点的操作叫做卷积操作。

Why call Convolution?为什么叫卷积?

卷积操作在信号处理邻域中：
是一个偏移的积分运算过程。





这种信号邻域的计算如何才能对应到图片中的卷积运算中呢？
图像上的积分运行，就是对应窗口位置相乘再累加。

Convolution卷积

对一个图片进行Sharpen操作，让图片变得更锐化，因此我们就使用一个5*5的kernal核，和图片进行卷积运算。图像上的积分运行，就是对应窗口位置相乘再累加。

除了上面的Sharpen锐化操作，还有一个是Blur模糊化。

除了上面两个还有一个是Edge Detect边缘检测。

CNN on feature maps CNN专题图

每次扫描使用的不同kernal，则获得的图片是不一样的，下面可以看到小窗体在开始是红色框，第二次是绿色框，这两次计算后生成的结果是不同，因为kernal不同。

二、卷积神经网络

计算结束后，原来的图片如果是2828，由于kernal是33，在靠近到原图片的边缘时，最边缘的一圈kernal是无法靠近的，因为如果将kernal中心点对准原图片边缘的像素，则kernal会有一些超出原图像，为了不让kernal不超出原图片，所以新图片是26*26，会比原来的小一圈。

如果进行padding填充操作，即让原来的2828周围增加一圈0，就可以保证输出的新函数是2828。

多个kernal代表着有多个不同的观察角度。
原图像(1,28,28)
kernal(7,3,3)
新图像(7,26,26)
卷积运算：

Notation注意

1、Input_channels：表示输入图片有几个通道，黑白图片通道数是1，彩色图片通道数3。
2、Kernal_channels：2 ch，这里是指kernal有一个Blur和一个Edge Detect组成的2 ch，(注意，如果输入图片是三通道的，则kernal就有三个与原图片对应，但是kernal的channel不是与原图片通道数来相互对应的，是与Blur和Edge Detect来对应的，所以kernal有2 ch，可以理解为kernal的类型数量，但是有3个一样的Blur和3个一样Edge与彩色图片相互对应，这里的3表示1个ch的与原彩色图片对应的三个通道)（这个很容易混淆，需要理解）。
3、Kernal_size：3*3
4、Stride：这里指的是移动的步长，kernal小窗体移动的步长。
5、Padding：这里指填充于原图片周围的一圈0，padding=1，表示一圈0，padding=2为二圈。

更加常见的情况 Multi-Kernels

LeNet-5 邮政编码的识别的网络：

Pyramid Architecture金字塔结构

representation learning 特征学习的由来：特征不断的提取的过程。

nn.Conv2d 类接口

stride=2，会有降维的效果，输出的新图会比原图小。
这里尽量不要直接使用layer.forward()。推荐使用实例的方法，out = layer(x)，这个其实是调用的是python的魔法 .call 函数。pytorch在__call__函数中封装了一些hooks，这些hooks有一些高阶的特性，如果要使用这些hooks，就必须要使用layer()类的实例来调用，如果使用layer.forward()这种方法，就没办法使用pytorch提供的一些hooks方法。不要直接调用.forward()。

Inner weight & bias

F.conv2d 函数式接口

三、池化层 (Pooling层,即下采样）Down/up sample

Outline
▪ upsample 上采样，和图片放大非常类似。
▪ Pooling 下采样，就意味着是将feature map变小的操作。
卷积神经网络配套的一个网络层叫：Pooling层
▪ ReLU

1、Downsample 下采样

对于图片数据而言，Downsample下采样类似于降维的这种操作。

Max pooling

在卷积神经网络中，是使用max pooling来进行类似于上面那种降维操作的。

Avg pooling

就是获取小窗口所有像元的均值。

使用pytorch来完成pooling这样的操作

这里可以注意，convolution的kernal会改变原图像的channel，而这里的pooling是不会改变原图像channel的数量的。下面的代码可以看出输入和输出的channel是没有改变的，依然是16。

2、Upsample 上采样

在pytorch中如何使用 F.interpolate

interpolate表示插值的意思。
这里依然是不会改变原图像的channel数量。下面的代码是pytorch自带的实现扩大方法，的对于tensor这种数据类型的可以直接使用的。

ReLU

是将图片feature map中负的像元给去掉的过程，那些像元响应太低了，就把那些小于0的像元给去掉。下图中黑色部分就是响应太小了，去掉后就变成了右图的样子，像素值变为了0。

在pytorch中如何使用 F.relu()

inplace = True 表示可以使用原先变量的内存空间，这样可以减少内存的使用。可以发现使用relu后，输入和输出的shape是没有变化的，但是像元值发生了改变，最小值不在是负值，而变为了0。

四、Batch normalization（数据归一化方法）

重要概念，Batch normalization，这个概念会在卷积神经网络中、循环神经网络中等都会用到。
Batch Normalization是2015年一篇论文中提出的数据归一化方法，往往用在深度神经网络中激活层之前。. 其作用可以加快模型训练时的收敛速度，使得模型训练过程更加稳定，避免梯度爆炸或者梯度消失。. 并且起到一定的正则化作用，几乎代替了Dropout（dropout是指在深度学习网络的训练过程中，对于神经网络单元，按照一定的概率将其暂时从网络中丢弃）。

直观的解释Intuitive explanation

对于使用sigmoid函数来说，当输入大于某个区间范围后，sigmoid的导数会接近于0，这样就容易出现梯度离散的情况。因此很有必要对输入做一定的限制。normalization就是用来最这个限制的，让输入数据等效变换，使其输入的数据满足一定的正太分布N(0,σ^2)，希望这个值能够均匀落在0的附近，使其在小的范围内变动，这样再做下一层的时候，优化起来会更加方便。

可以发现下图中，左侧的图，x1是在一个比较小的值，x2是在一个比较大的值，因此当w1进行改变时，x1的变化会比较小，当w2进行改变时，x2会急剧的变化，这样在搜索全局最小值的过程会比较曲折一些，左图的箭头所示。
如果x1和x2的范围是一样的，w1和w2对最终loss是一样的，会形成右图圆形的路径，在进行搜索的时候，不管从哪个点出发，梯度所指的方向都是全局最小解的方向。这样搜索过程会比较快捷方便稳定。

Feature scaling特征缩放

Batch Normalization

我们这里只看Batch normalization。

这里需要注意的是，μ和σ是统计出来的，是不需要参与反向传播（back propagation）的，是根据当前的batch里面的统计数据统计出来的；但是γ和β是学出来的，是需要梯度信息的，刚开始(γ=1, β=0)是没有影响，慢慢会学到一个N(β为均值, γ为方差)的偏置。
此外μ和σ会有一个历史记录，记录每一个batch的总的均值和总的方差，总的均值和总的方差在命名上μ和σ前面增加了一个running，running-μ和running-σ²，这样命名就是表示运行时候的统计数据，表示所有training出来的总的均值和总的方差。

利用pytorch进行这样的一个计算：这里是针对1维数据进行操作的。

import torch

from torch import nn

#这里是针对一个1维的feature，原来是(28,28)，只不过拉平了，变成了784。
x = torch.rand(100,16,784) #均匀分布在0到1之间
# print(x) #均匀分布的均值肯定是0.5


#这里的参数是给定的channel数量
#这里是有多少个channel，就统计出多少个数值
#这就意味着会生成16个统计信息，这些统计信息记录了每个channel的均值和方差。
layer = nn.BatchNorm1d(16)
print(layer)
#做一次forward运行后,会生成均值和方差，为当前x的。
#做完这个后，会自动更新一个全局的running-μ和running-σ²。
#对于只做一次运算的来收，μ和σ²就直接赋值为全局的了。
out = layer(x)

# print(out)
print(layer.running_mean)
print(layer.running_mean.shape)

print(layer.running_var)
print(layer.running_var.shape)

batch normalize规范化的写法

下面的步骤就是batch normalize train的过程。
1、第一步统计当前batch的μв均值和方差σ²в，这里还自动更新running-μ和running-σ²。
2、第二步进行normalize的操作。注意在进行normalize的时候分母会加一个很小的值10^-8，这样做是为了避免除零错误。计算完成后再进行一个平移β和缩放γ，使其达到N(均值β,方差γ)的正太分布。在反向传播（back propagation） 的时候，β和γ需要梯度信息，因此这两个参数会自动更新。

利用pytorch进行这样的一个计算：这里是针对2维数据进行操作的。

import torch
from torch import nn

x = torch.rand(1,16,7,7)
# print(x)
print(x.shape)

layer = nn.BatchNorm2d(16) #这里的参数16一定要和输入数据的channel匹配起来

out = layer(x) #这里进行normalize，将数据范围很大的数据压缩到(0,1)的范围内。
# print(out)
print(out.shape)

#(γ=1, β=0)是不产生任何影响的
γ = layer.weight
print(γ)
β = layer.bias
print(β)

#这里需要注意一下：μ和σ²是没办法直接获取到的，只能查询总的均值和方差
running_μ = layer.running_mean #总的均值
print(running_μ)
running_σ = layer.running_var #总的方差
print(running_σ)

print('===========================')
#将当前layer的所有参数都打印出来
print(vars(layer))
#这四个参数（running_mean,running_var,weight,bias）都是维度为1，长度为16的
#这些参数中，'affine': True 表示γ(weight)和β(weight)需不需要自动衰减，如果是False,则weight就会自动设置为1，bias自动设置为0,且不自动更新和变换。
#'training' = True 表示当前的模式是train还是test。
#一般情况下affine和training都会设置为True。

Test

这里需要注意的是，和drop out一样，batch normalization这个layer在training和test情况下行为是不太一样的。

在training的时候，μ和σ会统计出来，并自动更新一下running，之后再反向传播（back propagation），更新一下γ和β。

在test的时候，一般我们只会test一个sample，因此μ和σ²是没法统计的，因为只有一个sample，所以就没有必要进行统计。因此在test的时候，μ和σ取的不是当前batch的μ和σ²，而在test的时候将全值running-μ和running-σ赋值为μ和σ²。此外在test的时候，是没有backward的，γ和β是不需要更新的。要实现test，就需要提前切换到test这个模式下，必须调用.eval()这个函数，设置为test模式，再调用BatchNorm1d()进行变换。

可视化Visualization

曲线图中的虚线是使用batch normalize的，实线的是没有使用的。
可以发现使用了batch normalize，收敛速度更快，精度也有所提升。我们可以查看每一层参数分布的情况，使用了后，其分布情况是围绕均值为0附近，总的来说会往0附近来靠近，并不一定是0，方差为1来进行分布，这样操作后更加利于training。这里需要注意一下，为什么不完完全全在以N(均值=0, 方差=1)这样进行分布呢？这是因为存在γ和β对其分布的调整，如果γ=1且β=0，那么其分布情况就不会是以N(均值=0, 方差=1)这样进行分布，其分布就是N(β为均值, γ为方差)这样的分布。

总结一下使用batch normalize的好处Advantage

▪ Converge faster
收敛速度更快，在使用sigmoid激活函数的时候，如果把数据限制到0均值单位方差，那么相当于只使用了激活函数中近似线性的部分，这显然会降低模型表达能力，但是收敛速度更快。

▪ Better performance
更加容易搜索出最优解

▪ Robust
▪ stable
变得更稳定了
▪ larger learning rate
更大的设置学习率的范围

五、经典卷积网络(CNN)

下图中是最近10年内的网络变化，其中柱状图上面的数字表示错误率（准确率=1-错误率）。

LeNet-5

在1989年，Yann LeCun提出了一种用反向传导进行更新的卷积神经网络，称为LeNet。
最开始的LeNet-5是用于一个手写数字的识别，手写数字的图片只有28*28，当时的网络结构并不深，而且每一层的参数量也不大，即使这样这个网络结构也是没有办法在GPU上跑的，因为当时GPU还没有，是386的年代。
这个准确度达到了99.2%，就可以很成熟的使用起来了。

所以在当时美国的支票票号识别，邮编识别就已经广泛使用了。

AlexNet

LeNet-5是80年代出来的，那个时候deep learning还没有很热，在2012年，出来了AlexNet，准确率有了很高的提升。当时是使用两个GTX580（3GB）显卡来进行该网络的运算，该网络是5个卷积层，总共是8个layers，AlexNet的小窗口是11*11的，此外第一次使用ReLU函数、Max pooling、Dropout。

VGG

VGGNet是来自于牛津大学的视觉研究组。VGG一共有6个版本（比如VGG11、VGG16、VGG19）。VGG探索出了，小的kernal窗口不但可以减少计算量，并且没有损害精度，而且计算速度很快，这也是VGG最核心的价值。探索出了更小型的kernal更好的效果。

这里我们先了解一下1*1卷积核：
1*1 Convolution
可以注意到的是，输入的channel是32，而到了输出channel就是16了。这里的输出的channel取决于kernal的channel。此外1*1的kernal可以保证输入和输出的图片大小是一样的。

GoogLeNet

这里有不同大小的kernal，此外还有一个合并的操作Filter concatenation，为满足这个操作的要求，需要确保所有不同kernal输出来的图像大小相同，因为有一个33 max pooling，所有输出来的图像大小要与max pooling输出来的相同即可。假设max pooling输出的是77的图像，则kernal输出的也必须是77（为了保证输出的是77，可以使用stride步长来控制），这样可以获得很多个（32,7,7），之后通过concatenation操作后，可以获得（32,4，7,7）的feature map。

之前使用的都是统一的kernal，而这里为什么要使用不同类型的kernal呢？这是因为每一个不同大小的kernal所感受的视野是不同，11 kernal感受的视野是一个点，33 kernal感受的视野是一个小窗体，通过综合不同大小的视野（综合局部和全局的信息），可以感受到一个跟好的信息量。

具体的结构是：

堆叠更多层更好吗？Stack more layers?

通过堆叠更多层数的时候，层数更多的时候，反而准确度并没有提升，反而training比较困难，training的error比较高，这告诉我们并不能简单的堆叠更多的层数（这里需要抛开4层到22层，这范围内是堆叠更多层数效果会有提升，但是超过20层以上之后，仅是简单的堆叠的话，training的难度非常大，training找到最优解的难度很大）。

现在我们的网络结构以及是1000多层了，那如何解决这个问题的呢？也就是ResNet。

六、深度残差网络 ResNet

残差神经网络(ResNet)是由微软研究院的何恺明、张祥雨、任少卿、孙剑等人提出的。ResNet 在2015 年的ILSVRC（ImageNet Large Scale Visual Recognition Challenge）中取得了冠军。

残差神经网络的主要贡献是发现了“退化现象（Degradation）”，并针对退化现象发明了 “快捷连接（Shortcut connection）”，极大的消除了深度过大的神经网络训练困难问题。神经网络的“深度”首次突破了100层、最大的神经网络甚至超过了1000层。

ResNet构建块Unit，选择什么样的结构合适

这个Unit选择一个2-3层的卷积层，再加一个short。为了能够shortcut，就意味着经过shortcut输出的结果要与输入时的维度相同且channel也不能衰减，即输入时256层，则shortcut时也要是256层。

我们来计算一下参数量，输出256，输入256，每一个kernal是33，则参数量大概有25625633 = 589,824 大约有600k左右。如果有三个这样的Convolution的话，还需要再乘以3。

所以为了减少这个参数量，将unit中的kernal的size减小。比如说输入时是(256,224,224)，通过第一个11 kernal时的结果是(64,224,224)；再通过第二个33 kernal时，进行padding处理后保持shape不变，依然是(64,224,224)；最后通过第三个1*1 kernal后，将输出结果恢复到原来的(256,224,224)。

输入时一个(256,224,224)，和shortcut的(256,224,224)进行对应元素位置的相加，同样大小的矩阵相加，是同位置直接相加，不改变其维度，最后结果也是(256,224,224)，是没有改变的。

再来计算一下参数量，2566411 ~ 16k；646433 ~ 36k；642561*1 ~ 16k；这样总共 Total是大约70k。和原来的600k参数量相比，大概少了9倍。

查看一下34层的ResNet的基本结构：

ResNet的爆炸性的效果

Why call Residual? 为什么叫残差呢？

F(x)表示unit卷积层学习的内容，原来学习的是H(x)，F(x) + x = H(x) 原来学习的情况。
对于unit中的卷积层来说，F(x) = H(x) - x。这个减号就是残差的由来。

跨时间维度上不同网络的比较

对于一个ResNet是如何实现的呢？

这里关键是如何实现一个Unit基本单元。

这里需要注意的是，我们可以将输入数据的channel和输出数据的channel设置成为不同的，我们只需在shortcut路径上增加一个1*1 kernal 将输入的channel通过这个kernal的channel进行调整，从而将输入的channel和输出channel有相同的数量。在shortcut的路径上增加一个调整channel的kernal，就可以不用担心输入和输出channel不同的问题了。

ResNet例子：

import  torch
from    torch import  nn
from    torch.nn import functional as F
from    torch.utils.data import DataLoader
from    torchvision import datasets
from    torchvision import transforms
from    torch import nn, optim

# from    torchvision.models import resnet18

class ResBlk(nn.Module):
    """
    resnet block
    """

    def __init__(self, ch_in, ch_out):
        """
        :param ch_in:
        :param ch_out:
        """
        super(ResBlk, self).__init__()

        self.conv1 = nn.Conv2d(ch_in, ch_out, kernel_size=3, stride=1, padding=1)
        self.bn1 = nn.BatchNorm2d(ch_out)
        self.conv2 = nn.Conv2d(ch_out, ch_out, kernel_size=3, stride=1, padding=1)
        self.bn2 = nn.BatchNorm2d(ch_out)

        self.extra = nn.Sequential()
        if ch_out != ch_in:
            # [b, ch_in, h, w] => [b, ch_out, h, w]
            self.extra = nn.Sequential(
                nn.Conv2d(ch_in, ch_out, kernel_size=1, stride=1),
                nn.BatchNorm2d(ch_out)
            )


    def forward(self, x):
        """
        :param x: [b, ch, h, w]
        :return:
        """
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        # short cut.
        # extra module: [b, ch_in, h, w] => [b, ch_out, h, w]
        # element-wise add:
        out = self.extra(x) + out

        return out




class ResNet18(nn.Module):

    def __init__(self):
        super(ResNet18, self).__init__()

        self.conv1 = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(16)
        )
        # followed 4 blocks
        # [b, 64, h, w] => [b, 128, h ,w]
        self.blk1 = ResBlk(16, 16)
        # [b, 128, h, w] => [b, 256, h, w]
        self.blk2 = ResBlk(16, 32)
        # # [b, 256, h, w] => [b, 512, h, w]
        # self.blk3 = ResBlk(128, 256)
        # # [b, 512, h, w] => [b, 1024, h, w]
        # self.blk4 = ResBlk(256, 512)

        self.outlayer = nn.Linear(32*32*32, 10)

    def forward(self, x):
        """
        :param x:
        :return:
        """
        x = F.relu(self.conv1(x))

        # [b, 64, h, w] => [b, 1024, h, w]
        x = self.blk1(x)
        x = self.blk2(x)
        # x = self.blk3(x)
        # x = self.blk4(x)

        # print(x.shape)
        x = x.view(x.size(0), -1)
        x = self.outlayer(x)


        return x



def main():
    batchsz = 32

    cifar_train = datasets.CIFAR10('cifar', True, transform=transforms.Compose([
        transforms.Resize((32, 32)),
        transforms.ToTensor()
    ]), download=True)
    cifar_train = DataLoader(cifar_train, batch_size=batchsz, shuffle=True)

    cifar_test = datasets.CIFAR10('cifar', False, transform=transforms.Compose([
        transforms.Resize((32, 32)),
        transforms.ToTensor()
    ]), download=True)
    cifar_test = DataLoader(cifar_test, batch_size=batchsz, shuffle=True)


    x, label = iter(cifar_train).next()
    print('x:', x.shape, 'label:', label.shape)

    device = torch.device('cuda')
    # model = Lenet5().to(device)
    model = ResNet18().to(device)

    criteon = nn.CrossEntropyLoss().to(device)
    optimizer = optim.Adam(model.parameters(), lr=1e-3)
    print(model)

    for epoch in range(1000):

        model.train()
        for batchidx, (x, label) in enumerate(cifar_train):
            # [b, 3, 32, 32]
            # [b]
            x, label = x.to(device), label.to(device)

            logits = model(x)
            # logits: [b, 10]
            # label:  [b]
            # loss: tensor scalar
            loss = criteon(logits, label)

            # backprop
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()


        #
        print(epoch, 'loss:', loss.item())


        model.eval()
        with torch.no_grad():
            # test
            total_correct = 0
            total_num = 0
            for x, label in cifar_test:
                # [b, 3, 32, 32]
                # [b]
                x, label = x.to(device), label.to(device)

                # [b, 10]
                logits = model(x)
                # [b]
                pred = logits.argmax(dim=1)
                # [b] vs [b] => scalar tensor
                correct = torch.eq(pred, label).float().sum().item()
                total_correct += correct
                total_num += x.size(0)
                # print(correct)

            acc = total_correct / total_num
            print(epoch, 'acc:', acc)


if __name__ == '__main__':
    main()

DenseNet

基于ResNet的短接层思路，可以推广到，每一个unit都可以和前面所有层都有一个短接，这样就有了DenseNet。

这里需要注意的是，DenseNet的每一次短接过程，其实是一个concat过程，是将之前的所有信息进行综合，不是element wise的相加操作，这样会使得最后的channel越来越大，所以DenseNet对于channel的选择要设计的很精妙，舍得后面的channel不至于过大。

七、nn.Module（使用nn.Module的好处）

pytorch中使用非常广泛的类叫nn.Module。
nn.Module类是所有网络层的父类，当需要实现自己的一个层的时候就必须要继承这个父类。

Magic

▪ Every Layer is nn.Module
nn.Module在pytorch中是一个基本的父类，当要实现一个前项计算图的时候，如果继承了nn.Module就可以非常方便的使用现成的一些类：
比如说： ▪ nn.Linear
▪ nn.BatchNorm2d
▪ nn.Conv2d

▪ nn.Module nested in nn.Module
除了使用这些类以外，还可以嵌套nested，每个nn.Module后又可以嵌套nn.Module。

使用nn.Module的好处

1、embed current layers

在nn.Module中启用了大量现成的神经网络计算的模块。使用这些现成的模块非常方便，只需要调用初始函数，再通过.__call__方法调用forward函数，就可以使用这个模块提供的功能了。
比如: ▪ Linear
▪ ReLU
▪ Sigmoid
▪ Conv2d
▪ ConvTransposed2d
▪ Dropout
▪ etc.

2、Container容器

Container就是nn.Sequential()这个类。
nn.Sequetial：按顺序包装多个网络层(使用容器的时候，容器里面的model属于容器，而这个容器属于本网络)注意哦，这个容器后面括号里都是参数所以要用逗号隔开。
sequential是一个时序模型，根据每个submodule传入的顺序写到计算图里，在forward的时候也会顺序执行。
self.net(x)就可以直接自动完成多次的forward的操作。

3、parameters 权值和偏置参数

使用nn.Module可以很好的对模型参数进行管理，named_parameters()/parameters()方法，这两个方法都会返回一个用于迭代模型参数的迭代器（named_parameters还包括参数名字）。

比如说下图中使用Container容器，将两个线性层容在一起，名为net；通过net.parameters()这个方法可以返回一个生成器，其保存着每层的weight权值和bias偏置。

import torch
from torch import nn
print(nn.Linear(4,2))
print('=======================')
net = nn.Sequential(nn.Linear(4,2),nn.Linear(2,2))
# torch.nn.Linear(in_features, # 输入的神经元个数
#            out_features, # 输出神经元个数
#            bias=True # 是否包含偏置
#            )
print(net.parameters())
print('=======================')
print(list(net.parameters()))
print('=======================')
print(list(net.parameters())[0])
print(list(net.parameters())[0].shape)
#这里为什么是(2,4)呢？因为w是输出维度在前面，所以是(2,4)，是layer0的w。
print('=======================')
print(list(net.parameters())[3])
#这里是layer1的bias偏置，所以是(2)

print('=======================')
#通过.parameters可以很好的返回一个迭代器，返回当前这个net的所有参数。
#因此继承了nn.Module就不需要额外管理这些参数。
print('=======================')

#这个参数有两种形式，
# 一个是带名字的parameters，返回一个dictionary字典，字典第一个是名字，这个名字是pytorch自动生成的。
#这里我们将字典转换为了list。
#'0.weight' 表示第0层的weight
print(list(net.named_parameters())[0])
#'0.bias' 表示第0层的bias
print(list(net.named_parameters())[1])
print('=======================')
#这里我们以字典形式打印出来
print(dict(net.named_parameters()).items())
#这里item()方法是返回这个字典中的所有属性
print('******************************')
#一个是不带名字的parameters。
print(list(net.parameters())[0])

#我们可以通过.parameter，将所有参数传入到优化器中。
#之前我们是通过[w1,b1,w2,b2]这种方式自己管理参数，将这些传入到optimizer中的。
#现在就直接将这个类的.parameters()传入其中即可，这样使用时非常非常方便的。

4. modules 查看子类

▪ modules: all nodes
对于内部的类可以做到很好的管理。所有的子节点可以称为modules。

▪ children: direct children
直接的子节点，我们称其为children。

使用nn.modules()可以查看所有的子类情况。
其返回的是module其本身0号、其直系儿子1号和其它所有子节点。

import torch
from torch import nn

class BasicNet(nn.Module):
    def __init__(self):
        super(BasicNet, self).__init__()
        self.net = nn.Linear(4, 3)

    def forward(self, x):
        return self.net(x)


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.net = nn.Sequential(BasicNet(), nn.ReLU(), nn.Linear(3, 2))

    def forward(self, x):
        return self.net(x)


net = Net()
print(list(net.named_parameters()))
print('************************')
print(list(net.modules()))

5、to(device) 切换GPU或CPU

可以非常方便的将一个类所有的成员函数、所有内部的tensor和所有的操作转移到GPU或CPU上。

这里需要特别注意，当a是tensor类型时，a.to 返回的是 a_GPU，注意这里的a_GPU和原来的a.to的a不是同一个东西，a.to的a是CPU上的。而对于nn.Module来说，net = net.to。

6、save and load 保存和加载网络中间状态

在使用pytorch进行深度学习训练的时候，经常会有些内容需要保存下来，保存到硬盘张，不管什么时候我们都可以读取到，那么这个时候，使用torch.save()就可以将内容存储器来，使用torch.load()就可以将存取的内容读取出来。
save and load保存和加载 Checkpoint 用于推理/继续训练，Checkpoint是网络的中间状态。
保存和加载是可以用于在断电等特殊情况下，不至于失去之前训练的结果，避免让其从头开始从新训练。

Save操作：

#save:
torch.save(net.state_dict(), 'ckpt.mdl')

Load操作：

net.load_state_dict(torch.load('ckpt.mdl'))

7、train / test 切换

train和test的方便切换状态。如果每个类都继承与nn.Module的话，直接通过对根节点net.train()，或.eval()，就可以切换了。

8、implement own layer 实现自己的类

比如说在pytorch中没有一个展平的功能Flatten，因此我们可以自己实现一个继承与nn.Module的用于展平功能的类。
此外还有一个是reshape操作，这个功能只有方法，没有一个类，所以很多情况下我们也需要自己创建一个继承与nn.Module的用于Reshape的类。

class Flatten(nn.Module):
    def __init__(self):
        super(Flatten, self).__init__()
    
    def forward(self, input):
        return input.view(input.size(0), -1)

实现一个自己的MyLinear，这个自己创建的类和nn.Linear功能是一样的，这里可以发现nn.Parameter()会自动将需要梯度设置为true，requires_grad=True，而且参数也会受到nn.parameters()的管理，注意类是大写的Parameter，方法是小写的parameters。
我们在forward()函数中写好我们的逻辑，再return，一定要返回。

class MyLinear(nn.Module):
    def __init__(self, inp, outp):
        super(MyLinear, self).__init__()
        
        #requires_grad = True
        self.w = nn.Parameter(torch.randn(outp,inp))
        self.b = nn.Parameter(torch.randn(outp))
        
    def forward(self,x):
        x = x @ self.w.t() + self.b
        return x

八、数据增强（Data Argumentation）

Big Data

很大的数据集是train的好坏的前提。有了Big Data神经网络就能train的很好，有了Big Data这个网络就不容易over fitting，这个是防止过拟合的关键The key to prevent Overfitting。

Limited Data 有限的数据进行优化

▪ Small network capacity
首先如果数据比较少的话，就要减少网络的参数量，这样就不容易overfitting。

▪ Regularization
如果网络结构是固定的话，我们就正则化Regularization，迫使网络的一部分权值w接近于0，这样也减少了网络的参数量。

▪ Data argumentation
对原来的数据进行增强，比如对原来的图像进行调色，旋转角度等，获得新的图片，将这些图片和原先的图片一起用于网络的训练。

Data argumentation

▪ Flip 翻转
▪ Rotate 旋转
▪ Scale 缩放
▪ Crop Part 裁剪部分
▪ Noise 白噪声
▪ Random Move 随机移动
▪ GAN 生成对抗网络

Flip翻转

水平翻转和竖直翻转：

.RandomHorizontalFlip()水平翻转、.RandomVerticalFlip()竖直翻转，这两个都是随机的，有可能做，也有可能不做。

Rotate旋转

.RandomRotation(15)会在-15°<0<15°会在个区间内随机的进行选择；如果我们要固定这个角度，.RandomRotation([0, 90, 180, 270])会随机的在0°、90°、180°和270°三个角度中选取进行旋转，如果要不旋转的那就在加一个0°，这样会将原来的照片数量变为原来的4被。

Scale缩放

Crop Part裁剪部分

随机裁剪一部分，裁切的那部分用0来填补。

Noise白噪声

pytorch没有提供这个Noise接口，需要人为在Numpy基础上添加这个。

这里需要总结一下数据增强，由于增强后的照片与原图片是比较接近的，所有数据增强是有一定的帮助的，但是帮助不会很多。