总结2-深度学习网络搭建学习

1. 分享一个PyTorch医学图像分割开源库
2. 从实战的角度看看，稍微有点收获，视频：CNN 从0到1助你快速入门PyTorch和TensorFlow。github网页：Convolutional Neural Network
3. 常用激活函数（激励函数）理解与总结

------------------Pytorch学习--------------

1. 书籍，深度学习框架与pytorch入门与实践：第四章 神经网络工具箱nn
2. 《PyTorch的nn.Linear（）详解》 ，官网《torch.nn.Linear》
   学习具体参数，
   
   class：torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)
   
3. 《Conv2d函数详解（Pytorch）》，官网《torch.nn.Conv2d》
   学习具体参数，了解推算过程。
   定义：torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)[
    

   >>> # With square kernels and equal stride
   >>> m = nn.Conv2d(16, 33, 3, stride=2)
   >>> input = torch.randn(20, 16, 50, 100)
   >>> output = m(input)

4. 《pytorch avg_pool2d》，官网《torch.nn.AvgPool2d》。走一遍例子，熟悉一下平均池化的具体参数。
   定义：
   torch.nn.AvgPool2d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None)
    

   >>> # pool of square window of size=3, stride=2
   >>> m = nn.AvgPool2d(3, stride=2)
   >>> input = torch.randn(20, 16, 50, 32)
   >>> output = m(input)

   
    
5. 批标准化。
   机器学习中，进行模型训练之前，需对数据做归一化处理，使其分布一致。在深度神经网络训练过程中，通常一次训练是一个batch，而非全体数据。每个batch具有不同的分布产生了internal covarivate shift问题——在训练过程中，数据分布会发生变化，对下一层网络的学习带来困难。
   
   Batch Normalization将数据拉回到均值为0，方差为1的正态分布上(归一化)，一方面使得数据分布一致，另一方面避免梯度消失、梯度爆炸。 Batch Noramlization 是想让输入满足同一个分布， 那么是让输入的什么特征满足同一分布呢？就是让每张图片的相同通道的所有像素值的均值和方差相同。比如我们有两张图片（都为3通道），我们现在只说R通道，我们希望第一张图片的R通道的均值 和 第二张图片R通道的均值相同，方差同理。
   
   为了减小Internal Covariate Shift，对神经网络的每一层做归一化不就可以了，假设将每一层输出后的数据都归一化到0均值，1方差，满足正态分布。但是，此时有一个问题，每一层的数据分布都是标准正太分布，导致其完全学习不到输入数据的特征，因为，费劲心思学习到的特征分布被归一化了，因此，直接对每一层做归一化显然是不合理的。 但是如果稍作修改，加入可训练的参数做归一化，那就是Batch Norm实现的。
   
   这篇文章解释了整个过程，《Pytorch：nn.BatchNorm2d()函数》
   分别描述一遍：
   《pytorch中BatchNorm1d、BatchNorm2d、BatchNorm3d》
   《pytorch——nn.BatchNorm1d()》，官网《nn > BatchNorm1d》；

   代码验证批处理的过程参考《【PyTorch】详解pytorch中nn模块的BatchNorm2d()函数》；
   定义：
   torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None)

   >>> # With Learnable Parameters
   >>> m = nn.BatchNorm2d(100)
   >>> input = torch.randn(20, 100, 35, 45)
   >>> output = m(input)

   
   优点：

   ①不仅仅极大提升了训练速度，收敛过程大大加快；

   ②还能增加分类效果，一种解释是这是类似于Dropout的一种防止过拟合的正则化表达方式，所以不用Dropout也能达到相当的效果；

   ③另外调参过程也简单多了，对于初始化要求没那么高，而且可以使用大的学习率等。

6.  nn.dropout:
   我们在前向传播的时候，让某个神经元的激活值以一定的概率p停止工作，这样可以使模型泛化性更强，因为它不会太依赖某些局部的特征。网络可以防止出现过拟合。
   测试代码参考这篇《torch.nn.dropout和torch.nn.dropout2d的区别》，网络中实际使用参考这篇《pytorch之Dropout》
   定义：
   torch.nn.Dropout(p=0.5, inplace=False)

   >>> m = nn.Dropout(p=0.2)
   >>> input = torch.randn(20, 16)
   >>> output = m(input)

7. 激活函数：
   原理：激活函数对于人工神经网络模型去学习、理解非常复杂和非线性的函数来说具有十分重要的作用。它们将非线性特性引入到我们的网络中。在神经元中，输入的 inputs 通过加权，求和后，还被作用了一个函数，这个函数就是激活函数。引入激活函数是为了增加神经网络模型的非线性。没有激活函数的每层都相当于矩阵相乘。就算你叠加了若干层之后，无非还是个矩阵相乘罢了。”
   如果不用激励函数（其实相当于激励函数是f(x) = x），在这种情况下你每一层节点的输入都是上层输出的线性函数，很容易验证，无论你神经网络有多少层，输出都是输入的线性组合，与没有隐藏层效果相当，这种情况就是最原始的感知机（Perceptron）了，那么网络的逼近能力就相当有限。正因为上面的原因，我们决定引入非线性函数作为激励函数，这样深层神经网络表达能力就更加强大（不再是输入的线性组合，而是几乎可以逼近任意函数）。
   参数解释，参考官网《nn.ReLU》。
   示例参考《关于nn.ReLU函数》。
8. torch.nn.Sequential：网络模块有序初始化，自动实现了forword函数，必须确保前一个模块的输出大小和下一个模块的输入大小是一致的。具体讲解，参考《pytorch系列7 -----nn.Sequential讲解》 
    

   from collections import OrderedDict
   net3= nn.Sequential(OrderedDict([
             ('conv1', nn.Conv2d(3, 3, 3)),
             ('bn1', nn.BatchNorm2d(3)),
             ('relu1', nn.ReLU())
           ]))
   print('net3:', net3)

   输出：
   net3: Sequential(
     (conv1): Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1))
     (bn1): BatchNorm2d(3, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
     (relu1): ReLU()
   )

9. nn.ModuleList，和Sequential比，Modulelist内部没有forword功能，没有顺序性要求，也没有级联需求。ModuleList是Module的子类，当在Module中使用它的时候，就能自动识别为子module。
10. 损失函数nn.CrossEntropyLoss:

    # Example of target with class probabilities
    loss = nn.CrossEntropyLoss()
    input = t.randn(3, 5, requires_grad=True)
    target = t.randn(3, 5).softmax(dim=1)
    output = loss(input, target)
    output.backward()

    # batch_size=3，计算对应每个类别的分数（只有两个类别）
    score = t.randn(3, 2)
    # 三个样本分别属于1，0，1类，label必须是LongTensor
    label = t.Tensor([1, 0, 1]).long()
    
    # loss与普通的layer无差异
    criterion = nn.CrossEntropyLoss()
    loss = criterion(score, label)
    loss

11. 优化器torch.optim：，使用方法，参考教程《优化器：torch.optim》。如何自适应调整学习率，参考《PyTorch 笔记（18）— torch.optim 优化器的使用》
     
12. 初始化策略torch.nn.init: PyTorch中nn.Module的模块参数都采取了较为合理的初始化策略，因此一般不用我们考虑。当我们在使用Parameter时，自定义初始化则尤为重要，因t.Tensor()返回的是内存中的随机数，很可能会有极大值，这在实际训练网络中会造成溢出或者梯度消失。PyTorch中nn.init模块就是专门为初始化而设计。
    初始化Tensor的分布，参考这篇《torch.nn.init 官方使用手册「总结」》、还有官网《torch.nn.init》
    例子：

    import torch 
    import torch.nn as nn
    
    w = torch.empty(3,5)
    
    #1.均匀分布 - u(a,b)
    #torch.nn.init.uniform_(tensor, a=0.0, b=1.0)
    print(nn.init.uniform_(w))
    # =======================================================
    # tensor([[0.9160, 0.1832, 0.5278, 0.5480, 0.6754],
    #         [0.9509, 0.8325, 0.9149, 0.8192, 0.9950],
    #         [0.4847, 0.4148, 0.8161, 0.0948, 0.3787]])
    # =======================================================

13. nn.Module深入分析:ddd
    如果想要更深入地理解nn.Module，究其原理是很有必要的。首先来看看nn.Module基类的构造函数：

    def __init__(self):
        self._parameters = OrderedDict()
        self._modules = OrderedDict()
        self._buffers = OrderedDict()
        self._backward_hooks = OrderedDict()
        self._forward_hooks = OrderedDict()
        self.training = True

    其中每个属性的解释如下：
    _parameters：字典，保存用户直接设置的parameter，self.param1 = nn.Parameter(t.randn(3, 3))会被检测到，在字典中加入一个key为'param'，value为对应parameter的item。而self.submodule = nn.Linear(3, 4)中的parameter则不会存于此。
    _modules：子module，通过self.submodel = nn.Linear(3, 4)指定的子module会保存于此。
    _buffers：缓存。如batchnorm使用momentum机制，每次前向传播需用到上一次前向传播的结果。
    _backward_hooks与_forward_hooks：钩子技术，用来提取中间变量，类似variable的hook。
    training：BatchNorm与Dropout层在训练阶段和测试阶段中采取的策略不同，通过判断training值来决定前向传播策略。
    上述几个属性中，_parameters、_modules和_buffers这三个字典中的键值，都可以通过self.key方式获得，效果等价于self._parameters['key'].
    
    
     
14. ddd
15. ddd