RLFN代码学习：

1、

def _make_pair(value):
    if isinstance(value, int): 
     # isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
        value = (value,) * 2  # 将value的值变成元组(value, value)
    return value


# 关于isinstance() 与 type() 区别：
# type() 不会认为子类是一种父类类型，不考虑继承关系。
# isinstance() 会认为子类是一种父类类型，考虑继承关系。
# 如果要判断两个类型是否相同推荐使用 isinstance()。

2、关于Sigmoid、ReLU、PReLU、LReLU:

激活函数：并不是去激活什么，而是指如何把“激活的神经元的特征”通过函数把特征保留并映射出来，即负责将神经元的输入映射到输出端。引入激活函数的目的：每一层输出都是上层输入的线性函数，引入非线性函数作为激活函数，这样深层神经网络就有意义了（不再是输入的线性组合，可以逼近任意函数）

（1）Sigmoid作为激活函数的特点：

优点：平滑、易于求导。

缺点：

①激活函数计算量大（在正向传播和反向传播中都包含幂运算和除法）；

②反向传播求误差梯度时，求导涉及除法；

③Sigmoid导数取值范围是[0, 0.25]，由于神经网络反向传播时的“链式反应”，很容易就会出现梯度消失的情况。例如对于一个10层的网络， 根据0.2510≈0.000000954，第10层的误差相对第一层卷积的参数W1的梯度将是一个非常小的值，这就是所谓的“梯度消失”。

④Sigmoid的输出不是0均值（即zero-centered）；这会导致后一层的神经元将得到上一层输出的非0均值的信号作为输入，随着网络的加深，会改变数据的原始分布。

（2）ReLU激活函数：

优点：①sigmoid的导数只有在0附近的时候有比较好的激活性，在正负饱和区的梯度都接近于0，所以这会造成梯度弥散，而relu函数在大于0的部分，导数为常数1的好处就是在“链式反应”中不会出现梯度消失，但梯度下降的强度就完全取决于权值的乘积，这样就可能会出现梯度爆炸问题。解决这类问题：一是控制权值，让它们在（0，1）范围内；二是做梯度裁剪，控制梯度下降强度，如ReLU(x)=min(6, max(0,x))

②实现特征的稀疏性，relu函数在负半区的导数为0 ，所以一旦神经元激活值进入负半区，那么梯度就会为0，而正值不变，这种操作被成为单侧抑制。（也就是说：在输入是负值的情况下，它会输出0，那么神经元就不会被激活。这意味着同一时间只有部分神经元会被激活，从而使得网络很稀疏，进而对计算来说是非常有效率的。）正因为有了这单侧抑制，才使得神经网络中的神经元也具有了稀疏激活性。尤其体现在深度神经网络模型(如CNN)中，当模型增加N层之后，理论上ReLU神经元的激活率将降低2的N次方倍。

描述该特征前，需要明确深度学习的目标：深度学习是根据大批量样本数据，从错综复杂的数据关系中，找到关键信息（关键特征）。换句话说，就是把密集矩阵转化为稀疏矩阵，保留数据的关键信息，去除噪音，这样的模型就有了鲁棒性。ReLU将x<0的输出置为0，就是一个去噪音，稀疏矩阵的过程。而且在训练过程中，这种稀疏性是动态调节的，网络会自动调整稀疏比例，保证矩阵有最优的有效特征。

但是ReLU 强制将x<0部分的输出置为0（置为0就是屏蔽该特征），可能会导致模型无法学习到有效特征，所以如果学习率设置的太大，就可能会导致网络的大部分神经元处于‘dead’状态，所以使用ReLU的网络，学习率不能设置太大。

③Relu函数的导数计算更快，程序实现就是一个if-else语句，而sigmoid函数要进行浮点四则运算。

④实际收敛速度较快，比 Sigmoid/tanh 快很多；

⑤比 Sigmoid 更符合生物学神经激活机制。

缺点：容易‘dead’，一个非常大的梯度经过梯度更新后很可能使参数w或者b变成了绝对值很大的参数，尤其是偏置项b变成了一个极小的数值，那么这个神经元的wx+b很有可能永远小于0，但是这种情况不是说一个极大的梯度经过以后就一定是输出永远小于0.，只能说这样的情况的确存在…对relu,没有激活意味着wx+b<0,那么该relu神经元输出就是零,那么反向传播经过该神经元的梯度就是零,那么也就意味着这个神经元失活了。

ReLU激活函数 - 知乎 (zhihu.com)

(3)LReLU：Leaky ReLU

为了防止模型的‘Dead’情况，后人将x<0部分并没有直接置为0，而是给了一个很小的负数梯度值α。Leaky ReLU中的α为常数，一般设置 0.01。这个函数通常比 Relu 激活函数效果要好，但是效果不是很稳定，所以在实际中 Leaky ReLu 使用的并不多。

PRelu（参数化修正线性单元） 中的α作为一个可学习的参数，会在训练的过程中进行更新。

RReLU（随机纠正线性单元）也是Leaky ReLU的一个变体。在RReLU中，负值的斜率在训练中是随机的，在之后的测试中就变成了固定的了。RReLU的亮点在于，在训练环节中，aji是从一个均匀的分布U(I,u)中随机抽取的数值。

3、collections.OrderedDict():   对以字典形式传入的key-value按照输入的顺序进行排序，python3.6之前的版本认为对输入是无序的，所以按字典形式输入每次输出的结果会不一致，使用collections.OrderedDict() 可以保证每次打印字典的输出是确定的

import collections
print("Regular dictionary")
d={}
d['a']='A'
d['b']='B'
d['c']='C'
d['1'] = '1'
for k,v in d.items():
    print (k,v)#这个每次运行，print的结果都不一样
print("\nOrder dictionary")
d1 = collections.OrderedDict()
d1['a'] = 'A'
d1['b'] = 'B'
d1['c'] = 'C'
d1['2'] = '2'
d1['1'] = '1'
for k,v in d1.items():
    print(k,v)#无论运行多少次，print的结果唯一
    #a A
    # b B
    # c C
    # 2 2
    # 1 1

https://blog.csdn.net/weixin_38145317/article/details/104971207

4、Module.children()和Module.modules()的区别

children()与modules()都是返回网络模型里的组成元素，但是children()返回的是最外层的元素，modules()返回的是所有的元素，包括不同级别的子元素。

import torch.nn as nn
print(list(nn.Sequential(nn.Linear(10, 20), nn.ReLU()).modules()))
# [Sequential(
#   (0): Linear(in_features=10, out_features=20, bias=True)
#   (1): ReLU()
# ), Linear(in_features=10, out_features=20, bias=True), ReLU()]
print(list(nn.Sequential(nn.Linear(10, 20), nn.ReLU()).children()))
# [Linear(in_features=10, out_features=20, bias=True), ReLU()]

 用list举例就是：

a=[1,2,[3,4]]

children返回：

1,2，[3，4]

modules返回：

[1,2,[3,4]], 1, 2, [3,4], 3, 4

 PyTorch 35.Module里的children()与modules()的区别 - 知乎 (zhihu.com)

5、model.load_state_dict(torch.load(model_path), strict=True)

属性 strict; 当strict=True,要求预训练权重层数的键值与新构建的模型中的权重层数名称完全吻合；如果新构建的模型在层数上进行了部分微调，则上述代码就会报错：说key对应不上。

此时，如果我们采用strict=False 就能够完美的解决这个问题。也即，与训练权重中与新构建网络中匹配层的键值就进行使用，没有的就默认初始化。

原文链接：https://blog.csdn.net/ChaoMartin/article/details/118686268