深度之眼Pytorch打卡（十三）：Pytorch全连接神经网络部件——线性层、非线性激活层与Dropout层（即全连接层、常用激活函数与失活 ）_mlp神经网络pytorch+dropout

前言

---

  无论是做分类还是做回归，都主要包括数据、模型、损失函数和优化器四个部分。数据部分在上一篇笔记中已经基本完结，从这篇笔记开始，将学习深度学习模型。全连接网络MLP是最简单、最好理解的神经网络，于是便从这里开始。Pytorch中已经封装好了组成全连接神经网络的主要部件 ，即线性层（全连接层）、非线性激活层与dropout层等，如果模型只是单纯的线性层叠加，最后模型也是线性的，等价于只有一个线性层（把所有权值矩阵先结合相乘，最后只剩一个权值矩阵），而非线性激活层的加入才使得深度有了意义。本笔记的知识框架主要来源于深度之眼，并依此作了内容的丰富拓展，拓展内容主要源自对torch文档的翻译，和自己的粗浅理解，所用数据来源于网络。发现有人在其他平台照搬笔者笔记，不仅不注明出处，有甚者更将其作为收费文章，因此从这篇笔记开始，笔者将在文中任意位置插入识别标志。

  Pytorch线性层简单使用：深度之眼pytorch打卡（四）| 台大李宏毅机器学习 2020作业（一）：线性回归，实现多因素作用下的PM2.5预测（Pytorch版手写+nn.Linear()）

---

全连接神经网络

---

• 单层感知机

  原先的感知机是一个智能机器，现在的感知机一般是指如下所示的一种模型。它以若干特征作为输入，将每个输入特征与其对应的权值相乘后求和，这非常像一个神经元通过突触加权收集信息。由于线性运算即加法和数乘，这里的操作正是线性运算，所以这个操作被Pytorch封装成为线性层Linear。线性运算常常可以用矩阵乘法高效完成，如式（1）。

  单纯的线性模型连XOR这样的问题都解决不了，更不用说更复杂的分类。在线性层输出的后面加上一个非线性激活函数可以解决XOR问题，并且使得加深网络变得有意义。Pytorch将这个操作封装成了非线性激活层，一个线性层，加一个非线性激活层才算是构成了全连接神经网络的基本单元，此后称该单元为神经元或者节点，如图1所示。权值w和偏置b都是在输入数据中学出来的，因此该模型是自适应模型。

图1.单层感知机或全连接神经网络基本单元

• 浅层全连接网络

  输入层一般不算入层，故如图2所示的是三层全连接网络，包括两个隐藏层和一个输出层。图中的每层包含有若干上述的神经元。所谓全连接，就是某一层的每一个神经元都与前一层的所有神经元相连，并且每一个连接都独占一个权值，模型表达式与式（1）类似，只是表达式是多重的复合函数。容易知道，如果某一层的神经元数为M，而其上一层神经元数为N，则该层的参数有M*N+M个。

图2.浅层神经网络——三层全连接网络

• 深层全连接网络

  理论上而言，越深的网络有越好的问题拟合能力。但全连接网络无法做太深，因为每个连接都独用一个权值，太深了参数会非常多，容易过拟合，用Drapout可以缓解，用验证集可以监控。输入也不能太多，所以全连接网络输入常常是手工挑选好的或者是卷积神经网络输出的若干个特征，以图像全像素作为输入就常常行不通。以一幅100*100的灰度图像为例，输入就有10000个，若果此时第一层有100个神经元（节点），那么第一层的参数就有10000*100，100万个参数，只有一层并且用的图像尺寸还不算大，就有如此庞大的参数，图片更大网络更深的参数量可想而知。深层全连接网络如图2所示。

图3.深层神经网络

---

线性层——全连接层

---

• nn.Linear()

CLASS torch.nn.Linear(in_features: int, out_features: int, bias: bool = True)
1

  Linear类用矩阵乘法的形式实现对所有输入的加权求和，如式（2），由于x出现在权值矩阵左方，如果输入的是一维数据（一个样本），它应该是一个行向量，此时输入尺寸就等于向量长度。

  当输入数据是多维时，真正输入其实也只是一个一维行向量（实际应用中的一个样本，二维图像全像素作为输入时也要拉成一维向量），之所以表现为多维，是因为把多个输入并列计算，以避免循环读，提升效率（即实际应用中常见的多个样本并列组成一个大矩阵作为整体输入）。故输入尺寸in_features依旧只是行向量的尺寸，它才决定神经元个数，在输入数据中表现为最高维的尺寸，如图4中三维张量中dim=2的尺寸4。输出尺寸out_features与输入尺寸遵循一样的法则。

图3.输入尺寸确定

  当输入、输出尺寸给定后，类方法会自动创建权值张量。如果偏置bias=True，还会创建一个长度为out_features的一维偏置张量。参数被默认初始化后服从（-sqrt(k), sqrt(k)）上的均匀分布，其中k为in_features的倒数。

class Parameter(Tensor):
    def __init__(self, data: Tensor, requires_grad: builtins.bool): ...  
1
2

  Linear类继承于Module类，它是Pytorch神经网络模型的最小模块的一种。权值和偏置参数继承于Parameter类，而Parameter又继承于Tensor，所以它们本质都是张量，只是默认了需要梯度。和定义复杂的网络一样，Linear也是在__init__方法中定义它的属性参数 ，在forward方法中完成运算，即前向传播。看Linear源码，会发现在其forward方法中是直接调用functional中的函数来实现的，如下。

def linear(input, weight, bias=None):

    if input.dim() == 2 and bias is not None:   # 输入是二维时，用addmm简化计算
        # fused op is marginally faster
        ret = torch.addmm(bias, input, weight.t())  # 转置t
    else:
        output = input.matmul(weight.t())
        if bias is not None:
            output += bias
        ret = output
    return ret
    
# CSDN意疏原创笔记：https://blog.csdn.net/sinat_35907936/article/details/107727776
1
2
3
4
5
6
7
8
9
10
11
12
13

torch.addmm(input, mat1, mat2, *, beta=1, alpha=1, out=None) 
1

  该函数可以完成两个矩阵内积后再加上一个矩阵，正好适合输入数据是二维时加权求和后加上偏置的操作。

  Linear应用代码

import torch

data_in = torch.full((2, 3, 4), 2)
print(data_in)
net = torch.nn.Linear(4, 3, bias=True)  # 类实例化
net.weight.data = torch.tensor([[1, 1, 1, 1],
                                [2, 2, 2, 2],
                                [3, 3, 3, 3]], dtype=torch.float)
net.bias.data = torch.ones((1, 3), dtype=torch.float)

data_out = net(data_in) # 使用

print(data_out)

# CSDN意疏原创笔记：https://blog.csdn.net/sinat_35907936/article/details/107727776
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

  结果分析：

# data_in
tensor([[[2., 2., 2., 2.],
         [2., 2., 2., 2.],
         [2., 2., 2., 2.]],

        [[2., 2., 2., 2.],
         [2., 2., 2., 2.],
         [2., 2., 2., 2.]]])

# data_out
tensor([[[ 9., 17., 25.],   2*1+2*1+2*1+2*1+1=9
         [ 9., 17., 25.],   2*2+2*2+2*2+2*2+1=17
         [ 9., 17., 25.]],  2*3+2*3+2*3+2*3+1=25

        [[ 9., 17., 25.],
         [ 9., 17., 25.],
         [ 9., 17., 25.]]], grad_fn=<AddBackward0>)
         
# CSDN意疏原创笔记：https://blog.csdn.net/sinat_35907936/article/details/107727776
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

---

非线性激活层——常用非线性激活函数

---

• nn.Sigmoid ★

CLASS torch.nn.Sigmoid 
1

  与Linear一样，Sigmoid也是继承于Module类，是Pytorch神经网络模型的最小模块的一种。它没有其他参数，故该类源码里无__init___方法，只有用于计算的forward方法。sigmoid表达式如式（4）所示，它可以将输入映射到[0-1]之间，符合概率，做逻辑回归时常将其放在模型末尾，让两类的输出符合概率。放在模型中间时，由于它输出均值不为零，会破坏数据零均值的分布。

  导数表达式如式（5），易得其最大值是1/4。前面提到过，深度学习模型其实是一个超级复合函数，而优化时需要逐层求导更新参数。由链式求导法则，反向传播时每经过一个sigmoid就要对其求一次导来作为乘数，以最大值1/4算，每次经过一次sigmoid梯度就要衰减3/4，网络比较深时，可能还没有传到最前端，就把梯度乘到零了，容易导致梯度消失。

    x = torch.arange(-10, 10, step=0.1)
    sigmoid_layer = torch.nn.Sigmoid()    # 类实例化
    y = sigmoid_layer(x)
    y1 = y*(1-y)
    ax1 = plt.subplot(1, 2, 1)
    ax1.set_title('Sigmoid Function')
    ax1.plot(x, y)
    ax2 = plt.subplot(1, 2, 2)
    ax2.set_title('Sigmoid Derivative')
    ax2.plot(x, y1)
    plt.show()

# CSDN意疏原创笔记：https://blog.csdn.net/sinat_35907936/article/details/107727776
1
2
3
4
5
6
7
8
9
10
11
12
13

图4.Sigmoid函数及导数

• nn.Tanh

CLASS torch.nn.Tanh
1

  Tanh也是继承于Module类，波形和Sigmoid非常类似。但是它输出的均值是零，有更好的分布。并且它的导数最大值是1，梯度消失的情况比Sigmoid有所改观，但仍然对梯度有衰减，模型很深时依旧很可能梯度消失。双曲正切的函数表达式如式（6）。

  双曲正切导函数的表达式如式（7）。

    tanh_layer = torch.nn.Tanh()
    y = tanh_layer(x)
    y1 = 1-y*y
1
2
3

图4.Tanh函数及导数

• nn.ReLU ★

CLASS torch.nn.ReLU(inplace: bool = False)
1

  ReLU类继承于Module类，是Pytorch神经网络模型的最小模块的一种。修正线性单元，将负轴强制赋值为零（修正），以直接舍弃负值信息的方式来达到非线性，是最常用的激活函数之一。正轴导数恒为1，不会改变梯度的尺度，可以很大程度上缓解梯度消失，但容易引起梯度爆炸（梯度比较大时，不断相乘，没有衰减，结果nan）。

    ReLU_layer = torch.nn.ReLU()
    y = ReLU_layer(x)
    y1 = 0.5*(np.sign(x)+1)
    
# CSDN意疏原创笔记：https://blog.csdn.net/sinat_35907936/article/details/107727776
1
2
3
4
5

图4.Relu函数及导数

• nn.LeakyReLU

CLASS torch.nn.LeakyReLU(negative_slope: float = 0.01, inplace: bool = False)
1

  LeakyReLU就是在ReLU的基础上在负半轴加了一个非常小的斜率，是对ReLU的一种改进，通过negative_slope来控制斜率大小，其默认为1e-2。它一定程度上考虑了负值信息，不会像ReLU那样让这些负值输入死掉。由于带有参数，故其源码中有__init__方法。

• nn.PReLU

CLASS torch.nn.PReLU(num_parameters: int = 1, init: float = 0.25)
1

  PReLU也是在ReLU的基础上，在在负半轴加了斜率a，是对ReLU的一种改进，其中a是可以学习（训练）的参数，init是其初始值，默认0.25。P即Parameter。它一定程度上考虑了负值信息，不会像ReLU那样让这些负值输入死掉。由于带有参数，故其源码中有__init__方法。

  直接plt输出会报如下错误：RuntimeError: Can’t call numpy() on Variable that requires grad. Use var.detach().numpy()instead.，因为a继承于Parameter类，它是默认需要梯度的，这就导致了输出y也是需要梯度的。

• nn.RReLU

CLASS torch.nn.RReLU(lower: float = 0.125, upper: float = 0.3333333333333333, inplace: bool = False)
1

  RReLU也是在ReLU的基础上，在负半轴加了一个较小的斜率，是对ReLU的一种改进，斜率值在[lower, upper]内等概率随机取值，默认[1/8,1/3]中等概率随机取值，R即random。它一定程度上考虑了负值信息，不会像ReLU那样让这些负值输入死掉。由于带有参数，故其源码中有__init__方法。

• nn.ELU

CLASS torch.nn.ELU(alpha: float = 1.0, inplace: bool = False)
1

  ELU是在ReLU的基础上，在负半轴加了一个负指数函数，E即代表指数。通过参数a来控制负指数函数的幅值。表达式如式（12）

• nn.Softplus ★

CLASS torch.nn.Softplus(beta: int = 1, threshold: int = 20)
1

  Softplus是ReLU的平滑近似，将输出约束为始终为正，该函数处处导数存在，当beta*input绝对值很大时，函数输出基本接近ReLU。类属性里有一个阈值threshold，表示当beta*input大于该阈值时，恢复成线性函数，应该就是指当beta*input时直接用Relu，用1做导数，以避免Softplus复杂的导数计算。表达式如式（13）。

    x = torch.arange(-10, 10, 0.1)
    negative_slope = 0.05
    LeakyReLU_layer = torch.nn.LeakyReLU(negative_slope=negative_slope)
    PReLU_layer = torch.nn.PReLU()
    RReLU_layer = torch.nn.RReLU()
    ELu_layer = torch.nn.ELU()
    Soft_plus_layer = torch.nn.Softplus()
    y = LeakyReLU_layer(x)
    y1 = PReLU_layer(x).detach().numpy()
    y2 = RReLU_layer(x)
    y3 = ELu_layer(x)
    y4 = Soft_plus_layer(x)
1
2
3
4
5
6
7
8
9
10
11
12

图5.Relu函数的一些改进

• nn.Softmax ★

CLASS torch.nn.Softmax(dim: Optional[int] = None)
1

  Softmax将输入张量中的元素的值缩放到[0,1]之间，当参数dim=None时，表示该函数输出张量所有元素之和等于1，当dim=n时，则表示该函数输出元素在第n维度上的一组元素的和为1。Softmax常用在多元分类中，放在模型的末尾，让各类别的输出之和为1， 符合概率分布， 如图6所示。

图6.softmax函数使用

---

Dropout层——部分神经元失活

---

• nn.Dropout

CLASS torch.nn.Dropout(p: float = 0.5, inplace: bool = False)
1

  迭代过程中以概率p，随机的让某些输入变成0，即失活，默认失活概率为0.5。为了保证输入尺度不变 ，其他的元素应缩放至原来的1/(1-p)倍 如下代码中，p=0.5，故元素有一半概率失活，且剩余元素变为原来的两倍。对于全连接网络而言，每一个输入都“连着”一个权值参数，如果输入变成了0，那就意味着那些参数在这次迭代过程中不起作用，如图7。这样参数就减少了，所以可以在一定程度上缓解过拟合。

import torch

data_in = torch.full((2, 3, 4), 1)

net = torch.nn.Linear(4, 3, bias=True)
drop_out = torch.nn.Dropout()
net.weight.data = torch.tensor([[1, 1, 1, 1],
                                [2, 2, 2, 2],
                                [3, 3, 3, 3]], dtype=torch.float)
net.bias.data = torch.ones((1, 3), dtype=torch.float)
data_in = drop_out(data_in)
print(data_in)
data_out = net(data_in)
print(data_out)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

  结果：

tensor([[[2., 2., 0., 2.],   # 以概率p随机让某些输入为零，并且按照比例缩放数据
         [2., 2., 2., 2.],
         [2., 0., 2., 2.]],

        [[0., 0., 0., 0.],
         [0., 0., 2., 0.],
         [0., 2., 2., 0.]]])
tensor([[[ 7., 13., 19.],
         [ 9., 17., 25.],
         [ 7., 13., 19.]],

        [[ 1.,  1.,  1.],
         [ 3.,  5.,  7.],
         [ 5.,  9., 13.]]], grad_fn=<AddBackward0>)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

图7.dropout前后比较，一个连接就代表一个权值参数

---

参考

---

  https://baike.baidu.com/item/Sigmoid%E5%87%BD%E6%95%B0/7981407?fr=aladdin
  https://baike.baidu.com/item/%E5%8F%8C%E6%9B%B2%E6%AD%A3%E5%88%87/3194837?fromtitle=tanh&fromid=19711736&fr=aladdin