二、神经网络基础与搭建

神经网络基础

前言
一、神经网络
- 1.1 基本概念
- 1.2 工作原理
二、激活函数
- 2.1 sigmoid激活函数
- - 2.1.1 公式
  - 2.1.2 注意事项
- 2.2 tanh激活函数
- - 2.2.1 公式
  - 2.2.2 注意事项
- 2.3 ReLU激活函数
- - 2.3.1 公式
  - 2.3.2 注意事项
- 2.4 SoftMax激活函数
- - 2.4.1 公式
  - 2.4.2 Softmax的性质
  - 2.4.3 Softmax的应用
  - 2.4.4 代码演示
  - 2.4.5 数学计算举例
  - 2.4.6 Softmax的注意事项
三、参数初始化
- 3.1 均匀分布初始化
- 3.2 正态分布初始化
- 3.3 全0初始化
- 3.4 全1初始化
- 3.5 固定值初始化
- 3.6 Kaiming 初始化，也叫做 HE 初始化
- - 3.6.1 正态化的Kaiming 初始化
  - 3.6.2 均匀分布的Kaiming 初始化
- 3.7 Xavier 初始化，也叫做 Glorot初始化
- - 3.7.1 正态化的Xavier初始化
  - 3.7.2 均匀分布的Xavier初始化
四、构建简单的神经网络
总结

前言

前面我们学习了深度学习当中的基础——张量，接下来我们了解神经网络中的知识。

一、神经网络

神经网络是一种模拟人脑神经元结构和功能的计算模型，旨在解决复杂的模式识别和预测问题

1.1 基本概念

神经元：神经元是神经网络的基本组成单元，它接收输入信号，通过对输入信号的处理产生输出信号。每个神经元都有多个输入和一个输出，输入可以是其他神经元的输出，也可以是外部输入信号。
层级结构：神经网络由多个层级结构组成，包括输入层、隐藏层和输出层。输入层接收来自外部环境的数据，每个神经元代表一个输入特征；隐藏层负责对输入数据进行非线性变换，提取特征；输出层输出预测结果，每个神经元代表一个输出值。
连接权重：连接不同神经元之间的权重，决定信号的传递强度。这些权重在神经网络的训练过程中不断调整，以实现更好的预测性能。
激活函数：激活函数用于对神经元输出进行非线性变换，引入非线性特性。常见的激活函数包括sigmoid函数、ReLU函数、tanh函数等。不同的激活函数有不同的性质，可以根据具体的任务需求选择不同的激活函数。

1.2 工作原理

层级传播：信号通过逐层传递，最终到达输出层。
输出预测：输出层的神经元输出预测结果。
误差反向传播：根据预测结果与真实值的误差，通过反向传播算法更新连接权重。反向传播算法通过从输出层向输入层反向传播误差，依次更新权重和偏置，使得网络的预测能力逐渐提高。

二、激活函数

用于对每层的输出数据进行变换，从而为整个网络注入了非线性因素，此时的神经网络就可以拟合各种曲线，提高应对复杂问题的拟合能力。

2.1 sigmoid激活函数

2.1.1 公式

$f(x)=\frac{1}{1+e^{-x}}$

求导后的公式：
- $f'(x)=(\frac{1}{1+e^{-x}})'=\frac{1}{1+e^{-x}}(1-\frac{1}{1+e^{-x}})=f(x)(1-f(x))$

import torch
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号

# 创建画布和坐标轴
_, axes = plt.subplots(1, 2)
# sigmoid函数图像
x = torch.linspace(-20, 20, 1000)
# 输入值x通过sigmoid函数转换成激活值y
y = torch.sigmoid(x)
axes[0].plot(x, y)
axes[0].grid()
axes[0].set_title('Sigmoid 函数图像')

# sigmoid导数图像
x = torch.linspace(-20, 20, 1000, requires_grad=True)
torch.sigmoid(x).sum().backward()

# y = 2 * torch.dot(x, x)
# y.backward()
# x.detach():输入值x的数值
# x.grad:计算梯度，求导
axes[1].plot(x.detach(), x.grad)
axes[1].grid()
axes[1].set_title('Sigmoid 导数图像')
plt.show()

函数图像如下

2.1.2 注意事项

sigmoid函数可以将任意值的输入映射到（0，1）之间，从图中我们可以看出，当输入的值大致在 < -6 或者 >6 的时候，此时输入任何值得到的激活值都差不多，这样就会导致丢失部分信息。
对于sigmoid函数而言，输入值在[-6,6]之间才会有明显差异，输入值在[-3,3]之间才会有比较好的结果。
由导函数的图像，导数的数值范围是（0,025），当输入*< -6 或者 >6 的时候，sigmoid激活函数图像的导数接近于0，此时网络参数将更新缓慢或者无法更新。
一般来说，sigmoid的网络在五层之内就会产生梯度消失的现象，而且该激活函数不以0为中心，所以在实践中，使用很少。一般只用于二分类的输出层。

2.2 tanh激活函数

2.2.1 公式

$f(x)=\frac{1-e^{-2x}}{1+e^{-2x}}$

求导后的公式：
$f'(x)=(\frac{1-e^{-2x}}{1+e^{-2x}})'=1-f^2(x)$

import torch
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号

# 创建画布和坐标轴
_, axes = plt.subplots(1, 2)
# 函数图像
x = torch.linspace(-20, 20, 1000)
y = torch.tanh(x)
axes[0].plot(x, y)
axes[0].grid()
axes[0].set_title('Tanh 函数图像')

# 导数图像
x = torch.linspace(-20, 20, 1000, requires_grad=True)
torch.tanh(x).sum().backward()
axes[1].plot(x.detach(), x.grad)
axes[1].grid()
axes[1].set_title('Tanh 导数图像')
plt.show()

2.2.2 注意事项

Tanh函数将输入映射在（-1,1）之间，图像以0为中心，在0点对称，当输入 < -3 或者 >3 的时会被映射成 -1 或者 1 。导函数的取值范围（0，1），当输入的值 < -3 或者 >3 的时，其导函数近似0。
与sigmoid相比，它是以0为中心，并且梯度相对于sigmoid大，使得其收敛速度要比sigmoid快，减少迭代刺水。然而，从图中可以看出，Tanh两侧的导数也为0，同样会出现梯度消失的情况。
若使用的时候，可以再隐藏层使用Tanh函数，在输出层使用sigmoid函数。

2.3 ReLU激活函数

2.3.1 公式

$f (x) = ma x (0, x)$

求导后的公式：
$f^{'} (x) = 0 或者 1$

# 创建画布和坐标轴
import torch
from matplotlib import pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号

_, axes = plt.subplots(1, 2)
# 函数图像
x = torch.linspace(-20, 20, 1000)
y = torch.relu(x)
axes[0].plot(x, y)
axes[0].grid()
axes[0].set_title('ReLU 函数图像')
# 导数图像
x = torch.linspace(-20, 20, 1000, requires_grad=True)
torch.relu(x).sum().backward()
axes[1].plot(x.detach(), x.grad)
axes[1].grid()
axes[1].set_title('ReLU 导数图像')
plt.show()

2.3.2 注意事项

ReLU 激活函数将小于0的值映射为 0，而大于 0 的值则保持不变，它更加重视正信号，而忽略负信号，这种激活函数运算更为简单，能够提高模型的训练效率。
当x<0时，ReLU导数为0，而当x>0时，则不存在饱和问题。所以，ReLU能够在x>0时保持梯度不衰减，从而缓解梯度消失问题。然而，随着训练的推进，部分输入会落入小于0区域，导致对应权重无法更新。这种现象被称为“神经元死亡”
ReLU是目前最常用的激活函数。
- 与sigmoid相比，RELU的优势是:采用sigmoid函数，计算量大(指数运算)，反向传播求误差梯度时，计算量相对大，而采用Relu激活函数，整个过程的计算量节省很多。
- siqmoid函数反向传播时，很容易就会出现梯度消失的情况，从而无法完成深层网络的训练。
- Relu会使一部分神经元的输出为0，这样就造成了网络的稀疏性，并且减少了参数的相互依存关系，缓解了过拟合问题的发生。

2.4 SoftMax激活函数

2.4.1 公式

Softmax函数的本质是一种归一化函数，它将一个数值向量归一化为一个概率分布向量，且各个概率之和为1。对于一个给定的实数向量z，Softmax函数首先计算每一个元素的指数（e的幂），然后每个元素的指数与所有元素指数总和的比值，就形成了Softmax函数的输出。
$\text{Softmax}(z_i) = \frac{e^{z_i}}{\sum_{j=1}^{K} e^{z_j}}$
其中， $z_i$ 表示输入向量 $z$ 的第 $i$ 个分量， $K$ 是类别总数，即向量 $z$ 的维度， $e$ 是自然对数的底数。
实际计算的时候需要输入向量减去向量中的最大值
- 在实际应用中，直接计算 $e^{z_i}$ 可能会导致数值溢出，特别是当输入值很大时。为了防止这种情况，可以在计算前减去向量中的最大值。

2.4.2 Softmax的性质

归一化：Softmax保证所有输出值的和为1，使其可以被解释为概率。
可微性：Softmax函数在整个定义域内可微，这使得它可以在基于梯度的优化算法中使用，例如反向传播。
敏感性：Softmax对输入值非常敏感，尤其是当有一个输入远大于其他输入时。

2.4.3 Softmax的应用

多类别分类问题：Softmax函数常用于多类别分类问题中，将输入向量映射为各个类别的概率。在神经网络中，Softmax通常作为输出层的激活函数，将网络的输出转换为类别概率。
交叉熵损失函数：在训练神经网络时，Softmax函数通常与交叉熵损失函数结合使用。交叉熵损失函数用于衡量预测概率分布与真实标签之间的差异，从而进行模型的训练和优化。

2.4.4 代码演示

import torch

scores = torch.tensor([0.2, 0.02, 0.15, 0.15, 1.3, 0.5, 0.06, 1.1, 0.05, 3.75])
# dim = 0,按行计算
probabilities = torch.softmax(scores, dim=0)
print(probabilities)

2.4.5 数学计算举例

0、背景：
- 假设我们有一个神经网络，用于识别手写数字（0 到 9）。神经网络的输出层有 10 个神经元，每个神经元对应一个数字类别。在训练完成后，对于一个新的输入图像，神经网络的输出层会产生一个 10 维的实数向量。我们需要将这个向量转换为一个概率分布，以便确定哪个数字最有可能是正确的。
1、输入向量
- $z = [1.0, 2.0, 3.0, 4.0, 1.0, 0.5, 0.0, - 1.0, - 2.0, - 3.0]$
2、减去最大值
- 为了防止数值溢出，我们先减去向量中的最大值（4.0）
- $z^{'} = [1.0 - 4.0, 2.0 - 4.0, 3.0 - 4.0, 4.0 - 4.0, 1.0 - 4.0, 0.5 - 4.0, 0.0 - 4.0, - 1.0 - 4.0, - 2.0 - 4.0, - 3.0 - 4.0]$
- $z^{'} = [- 3.0, - 2.0, - 1.0, 0.0, - 3.0, - 3.5, - 4.0, - 5.0, - 6.0, - 7.0]$
3、计算指数
- $e^{z'} = [e^{-3.0},e^{-2.0},e^{-1.0},e^{0.0},e^{-3.0},e^{-3.5},e^{-4.0},e^{-5.0},e^{-6.0},e^{-7.0}]$
```
import numpy as np

z_prime = np.array([-3.0, -2.0, -1.0, 0.0, -3.0, -3.5, -4.0, -5.0, -6.0, -7.0])
exp_z_prime = np.exp(z_prime)	
print(exp_z_prime)
```
- [‘0.0497870684’, ‘0.1353352832’, ‘0.3678794412’, ‘1.0000000000’, ‘0.0497870684’, ‘0.0301973834’, ‘0.0183156389’, ‘0.0067379470’, ‘0.0024787522’, ‘0.0009118820’]
4、计算分母
- $\sum_{i=1}^{10}e^{z'}= 0.0497870684+0.1353352832+0.3678794412+1.0000000000+0.0497870684+0.0301973834+0.0183156389+0.0067379470+0.0024787522+0.0009118820$
- $\sum_{i=1}^{10}e^{z'}= 1.6614304647$
5、计算Softmax
- 将每个指数除以总和，得到概率分布
- $softmax(z_i) = \frac{e^{z'}}{\sum_{i=1}^{10}e^{z'}}$

sum_exp_z_prime = np.sum(exp_z_prime)
softmax_output = exp_z_prime / sum_exp_z_prime
print(softmax_output)

- 输出结果为：[0.0299663871,0.0814570854,0.2214233150,0.6018909737,0.0299663871,
			  0.0181755325,0.0110240177,0.0040555095,0.0014919386,0.0005488535]

6、结果解释
- 第四个元素的概率最高为0.6018909737，所以预测为数字 3
- 其他数字概率较小，所以表示其他数字的可能性较小

2.4.6 Softmax的注意事项

输入值范围：Softmax函数的输入值可以是任意实数，但通常在实际应用中，输入值是经过神经网络计算得到的logits（即未归一化的得分或置信度）。
数值稳定性：在计算Softmax函数时，由于涉及到指数运算，可能会出现数值溢出或下溢的问题。为了解决这个问题，通常会对输入值进行适当的缩放或平移处理。
互斥类别：Softmax函数适用于类别互斥的情况，即每个样本只能属于一个类别。如果问题是多标签分类（即一个样本可能属于多个类别），则需要使用其他方法，如sigmoid函数或其他多标签分类算法。

三、参数初始化

import torch
import torch.nn.functional as F
import torch.nn as nn

3.1 均匀分布初始化

权重参数初始化从区间均匀随机取值。即在( $\frac{-1}{\sqrt{d}},\frac{1}{\sqrt{d}}$ )均匀分布中生成当前神经元的权重，其中 $d$ 为每个神经元的输入数量

linear = nn.Linear(5, 3)
# 从0-1均匀分布产生参数
nn.init.uniform_(linear.weight)
print(linear.weight.data)

3.2 正态分布初始化

随机初始化从均值为0，标准差是1的高斯分布中取样，使用一些很小的值对参数 $W$ 进行初始化

linear = nn.Linear(5, 3)
nn.init.normal_(linear.weight, mean=0, std=1)
print(linear.weight.data)

3.3 全0初始化

将神经网络中的所有权重参数初始化为 0

linear = nn.Linear(5, 3)
nn.init.zeros_(linear.weight)
print(linear.weight.data)

3.4 全1初始化

将神经网络中的所有权重参数初始化为 1

linear = nn.Linear(5, 3)
nn.init.ones_(linear.weight)
print(linear.weight.data)

3.5 固定值初始化

将神经网络中的所有权重参数初始化为某个固定值

linear = nn.Linear(5, 3)
nn.init.constant_(linear.weight, 5)  # 里边写 几 就是 用哪个值初始化
print(linear.weight.data)

3.6 Kaiming 初始化，也叫做 HE 初始化

3.6.1 正态化的Kaiming 初始化

$\sqrt{\frac{2}{fan_{in}}}$
$fan_{in}$ 输入神经元的个数

# kaiming 正态分布初始化
linear = nn.Linear(5, 3)
nn.init.kaiming_normal_(linear.weight)
print(linear.weight.data)

3.6.2 均匀分布的Kaiming 初始化

$fan_{in}$ 输入神经元的个数
它从 $[- l imi t ， l imi t]$ 中的均匀分布中抽取样本, $l imi t$ 是 $\sqrt{\frac{6}{fan_{in}}}$

# kaiming 均匀分布初始化
linear = nn.Linear(5, 3)
nn.init.kaiming_uniform_(linear.weight)
print(linear.weight.data)

3.7 Xavier 初始化，也叫做 Glorot初始化

3.7.1 正态化的Xavier初始化

$\sqrt{\frac{2}{fan_{in}+fan_{out}}}$
$fan_{in}$ 输入神经元的个数
$fan_{out}$ 输出的神经元个数

# xavier 正态分布初始化
linear = nn.Linear(5, 3)
nn.init.xavier_normal_(linear.weight)
print(linear.weight.data)

3.7.2 均匀分布的Xavier初始化

它从 $[- l imi t ， l imi t]$ 中的均匀分布中抽取样本, $l imi t$ 是 $\sqrt{\frac{6}{fan_{in}+fan_{out}}}$

# xavier 均匀分布初始化
linear = nn.Linear(5, 3)
nn.init.xavier_uniform_(linear.weight)
print(linear.weight.data)

四、构建简单的神经网络

案例：我们构建如下网络
要求如下：
- 第1个隐藏层：权重初始化采用标准化的xavier初始化激活函数使用sigmoid
- 第2个隐藏层：权重初始化采用标准化的He初始化激活函数采用relu
- out输出层线性层，采用 softmax 做数据分类输出

"""
在pytorch中定义深度神经网络其实就是层堆叠的过程，继承自nn.Module，实现两个方法：
	1、__init__方法中定义网络中的层结构，主要是全连接层，并进行初始化
	2、forward方法，在实例化模型的时候，底层会自动调用该函数。该函数中可以定义学习率，为初始化定义的layer传入数据等。
"""
import torch
import torch.nn as nn
from torchsummary import summary  # 计算模型参数,查看模型结构, pip install torchsummary

# 创建神经网络模型类
class Model(nn.Module):
    # 初始化属性值
    def __init__(self):
        super(Model, self).__init__() # 调用父类的初始化属性值
        self.linear1 = nn.Linear(3, 3) # 创建第一个隐藏层模型, 3个输入特征,3个输出特征
        nn.init.xavier_normal_(self.linear1.weight) # 初始化权
        # 创建第二个隐藏层模型, 3个输入特征(上一层的输出特征),2个输出特征
        self.linear2 = nn.Linear(3, 2)
        # 初始化权重
        nn.init.kaiming_normal_(self.linear2.weight)
        # 创建输出层模型
        self.out = nn.Linear(2, 2)

    # 创建前向传播方法,自动执行forward()方法
    def forward(self, x):
        # 数据经过第一个线性层
        x = self.linear1(x)
        # 使用sigmoid激活函数
        x = torch.sigmoid(x)
        # 数据经过第二个线性层
        x = self.linear2(x)
        # 使用relu激活函数
        x = torch.relu(x)
        # 数据经过输出层
        x = self.out(x)
        # 使用softmax激活函数
        # dim=-1:每一维度行数据相加为1
        x = torch.softmax(x, dim=-1)
        return x

if __name__ == "__main__":
    # 实例化model对象
    my_model = Model()
    # 随机产生数据
    my_data = torch.randn(5, 3)
    print("mydata shape", my_data.shape)
    # 数据经过神经网络模型训练
    output = my_model(my_data)
    print("output shape-->", output.shape)
    # 计算模型参数
    # 计算每层每个神经元的w和b个数总和
    summary(my_model, input_size=(3,), batch_size=5) 
    # 查看模型参数
    print("======查看模型参数w和b======")
    for name, parameter in my_model.named_parameters():
        print(name, parameter)