人工神经网络知识点讲解
人工神经网络知识点讲解
知识导图
人工神经网络
├── 基础认知
│ ├── 神经网络的核心概念
│ ├── 神经元的工作机制
│ └── 网络的层级结构
├── 激活函数
│ ├── 激活函数的作用
│ ├── 常见激活函数：sigmoid/tanh/ReLU/Softmax
│ └── 激活函数的选择
├── 参数初始化
│ ├── 7种初始化方法
│ └── 初始化方法的选择
├── 损失函数
│ ├── 分类任务损失
│ └── 回归任务损失
├── 网络优化
│ ├── 优化算法
│ └── 学习率衰减
├── 正则化方法
│ ├── 正则化的作用
│ ├── Dropout 随机失活
│ └── 批量归一化
└── 实战案例
└── 手机价格分类案例
核心名词解释
-
人工神经网络 (ANN)：也简称为神经网络 (NN)，是一种模仿生物神经网络结构和功能的计算模型，用来拟合复杂的非线性关系。
-
神经元：神经网络的基本单元，接收输入后进行加权求和，再通过激活函数输出结果，模拟生物神经元的工作方式。
-
输入层 (Input Layer)：神经网络的输入层，负责接收原始的输入数据，每个输入特征对应一个神经元。
-
隐藏层 (Hidden Layers)：输入层和输出层之间的层，负责对输入数据进行特征提取和变换，神经网络的深度由隐藏层的数量决定。
-
输出层 (Output Layer)：神经网络的输出层，负责生成最终的预测结果，根据任务的不同（分类 / 回归）有不同的设计。
-
全连接层：相邻层的所有神经元都相互连接的层，也叫稠密层，每个连接都有对应的权重和偏置。
-
内部状态值：神经元的加权求和结果，公式为
z = W⋅x\+b，是激活函数的输入。 -
激活值：激活函数对内部状态值进行非线性变换后得到的结果，是神经元的最终输出。
-
激活函数：为神经网络引入非线性因素的函数，让网络可以拟合复杂的非线性函数。
-
sigmoid：将输入映射到 (0,1) 区间的激活函数，常用于二分类的输出层。
-
tanh：将输入映射到 (-1,1) 区间的激活函数，是 sigmoid 的平移版本，解决了 sigmoid 的输出非零均值的问题。
-
ReLU：修正线性单元，是目前最常用的隐藏层激活函数，计算简单，缓解了梯度消失问题。
-
Softmax：多分类任务的输出激活函数，将输出转换为概率，所有输出的概率和为 1。
-
参数初始化：对神经网络的权重和偏置进行初始赋值的过程，合适的初始化可以让网络更快收敛，避免梯度消失 / 爆炸。
-
Xavier 初始化：也叫 Glorot 初始化，用来平衡输入和输出的方差，适合 sigmoid、tanh 这类激活函数。
-
Kaiming 初始化：也叫 HE 初始化，针对 ReLU 这类激活函数设计，考虑了 ReLU 的半正则特性，让深层网络更容易训练。
-
损失函数：用来衡量模型预测值和真实值之间差异的函数，是网络训练的优化目标。
-
交叉熵损失：分类任务中常用的损失函数，衡量预测概率分布和真实分布的差异。
-
MAE 损失：也叫 L1 损失，回归任务的损失，计算预测和真实的绝对误差。
-
MSE 损失：也叫 L2 损失，回归任务的损失，计算预测和真实的均方误差。
-
优化器：用来更新神经网络参数，最小化损失函数的算法。
-
学习率衰减：随着训练进行逐渐降低学习率的策略，让模型训练更稳定。
-
Dropout：随机失活正则化，训练时随机让部分神经元失活，防止过拟合。
-
批量归一化 (BN)：对批量数据进行标准化和重构的层，缓解梯度消失，加速训练。
-
正则化：用来防止模型过拟合的方法，通过限制模型的复杂度，提升模型的泛化能力。
一、神经网络基础认知
本章节学习目标：
知道什么是人工神经网络
了解神经网络的构成
理解内部状态和激活值的概念
1.1 什么是人工神经网络
人工神经网络（ Artificial Neural Network， 简写为 ANN）也简称为神经网络（NN），是一种模仿生物神经网络结构和功能的计算模型。
人脑可以看做是一个生物神经网络，由众多的神经元连接而成。各个神经元传递复杂的电信号，树突接收到输入信号，然后对信号进行处理，通过轴突输出信号。当电信号通过树突进入到细胞核时，会逐渐聚集电荷。达到一定的电位后，细胞就会被激活，通过轴突发出电信号。
1.2 神经元的工作机制
神经网络是由多个神经元组成，构建神经网络就是在构建神经元。
这个过程就像，来源不同树突 (树突都会有不同的权重) 的信息，进行的加权计算，输入到细胞中做加和，再通过激活函数输出细胞值。
1.3 神经网络的层级结构
神经网络中信息只向一个方向移动，即从输入节点向前移动，通过隐藏节点，再向输出节点移动。其中的基本部分是:
-
输入层（Input Layer）：即输入 x 的那一层（如图像、文本、声音等）。每个输入特征对应一个神经元。输入层将数据传递给下一层的神经元。
-
输出层（Output Layer）：即输出 y 的那一层。输出层的神经元根据网络的任务（回归、分类等）生成最终的预测结果。
-
隐藏层（Hidden Layers）：输入层和输出层之间的层，负责对输入数据进行特征提取和变换，神经网络的深度由隐藏层的数量决定。
网络的特点：
-
同一层的神经元之间没有连接
-
第 N 层的每个神经元和第 N-1 层 的所有神经元相连，这就是全连接神经网络
-
全连接神经网络接收的样本数据是二维的，数据在每一层之间需要以二维的形式传递
-
第 N-1 层神经元的输出就是第 N 层神经元的输入
-
每个连接都有一个权重值（w 系数和 b 系数）
1.4 内部状态值和激活值
每一个神经元工作时，会产生 4 个值:
前向传播会产生内部状态值（加权求和值）和激活值；反向传播时会产生激活值梯度和内部状态值梯度。
-
内部状态值:
z = W⋅x\+b-
W：权重矩阵
-
x：输入值
-
b：偏置
-
-
激活值:
a=f\(z\)-
f：激活函数
-
z：内部状态值
-
二、激活函数
本章节学习目标：
知道常见的激活函数
了解激活函数的作用
掌握激活函数的选择方法
2.1 激活函数的作用
激活函数用于对每层的输出数据进行变换，进而为整个网络注入了非线性因素。此时，神经网络就可以拟合各种曲线。
没有引入非线性因素的网络等价于使用一个线性模型来拟合。通过给网络输出增加激活函数，实现引入非线性因素，使得网络模型可以逼近任意函数，提升网络对复杂问题的拟合能力。
2.2 常见的激活函数
2.2.1 sigmoid 激活函数
sigmoid 激活函数可以将输入映射到 (0,1) 的区间，它的公式和导数公式如下：
对应的绘制代码：
# 解决OMP冲突的代码
import os
os.environ['KMP_DUPLICATE_LIB_OK']='True'
# 加这行！切换Matplotlib的后端，绕过PyCharm的兼容bug
import matplotlib
matplotlib.use('TkAgg')
# 导包
import torch
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['Microsoft YaHei'] # 指定用Windows自带的微软雅黑，支持中文
plt.rcParams['axes.unicode_minus'] = False # 顺便解决负号显示成方框的问题
# 准备数据
# 准备 -20，20的等差张量，1000点 --> x
x = torch.linspace(start=-20,end=20,steps=1000,requires_grad=False)
print(x.shape,x.ndim)
y = torch.sigmoid(x)
print(y.shape,y.ndim)
# 绘制图像
# **todo 为了把值域图像和导数图像画到一张画布上，创建一个一行两列的画布**
fig,axs = plt.subplots(1,2)
axs[0].plot(x,y)
axs[0].grid()
axs[0].set_title('sigmoid 值域图像')
# plt.show()
print('=======1=======')
# 准备数据
# # 准备x,y数据 -> **todo 注意此处的x开启自动微分，y的本质是梯度**
x = torch.linspace(start=-20,end=20,steps=1000,requires_grad=True)
print(x.shape,x.ndim)
torch.sigmoid(x).sum().backward() # -> # backward()：触发反向传播，PyTorch自动帮你计算Sigmoid对x的导数，结果会自动存在 x.grad 里
y = x.grad
print(y.shape,y.ndim)
# 绘制图像
axs[1].plot(x.detach(),x.grad)
axs[1].grid()
axs[1].set_title('Sigmoid 导数图像')
plt.show()
print('=======2=======')
2.2.2 tanh 激活函数
tanh 激活函数可以将输入映射到 (-1,1) 的区间，解决了 sigmoid 输出非零均值的问题，它的公式和导数公式如下：
对应的绘制代码：
# 创建画布和坐标轴
_, 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.3 ReLU 激活函数
ReLU 是修正线性单元，是目前最常用的隐藏层激活函数，它的公式和导数公式如下：
对应的绘制代码：
# 创建画布和坐标轴
_, 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.2.4 SoftMax 激活函数
softmax 用于多分类过程中，它是二分类函数 sigmoid 在多分类上的推广，目的是将多分类的结果以概率的形式展现出来。
Softmax 就是将网络输出的 logits 通过 softmax 函数，就映射成为 (0,1) 的值，而这些值的累和为 1（满足概率的性质），那么我们将它理解成概率，选取概率最大（也就是值对应最大的）节点，作为我们的预测目标类别。
对应的使用代码：
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=-1)
print(probabilities)
# 输出结果:
# tensor([0.0212, 0.0177, 0.0202, 0.0202, 0.0638, 0.0287, 0.0185, 0.0522, 0.0183,0.7392])
2.3 其他激活函数
还有其他的常见激活函数，比如 Leaky ReLU、PReLU、ELU 等：
2.4 激活函数的选择方法
隐藏层的选择
-
优先选择 ReLU 激活函数
-
如果 ReLu 效果不好，那么尝试其他激活，如 Leaky ReLu 等。
-
如果你使用了 ReLU， 需要注意一下 Dead ReLU 问题， 避免出现 0 梯度从而导致过多的神经元死亡。
-
少用使用 sigmoid 激活函数，可以尝试使用 tanh 激活函数
输出层的选择
-
二分类问题选择 sigmoid 激活函数
-
多分类问题选择 softmax 激活函数
-
回归问题选择 identity 激活函数
激活函数对比辨析
| 激活函数 | 输出区间 | 特点 | 适用场景 |
|---|---|---|---|
| sigmoid | (0, 1) | 输出非零均值，容易梯度消失 | 二分类输出层 |
| tanh | (-1, 1) | 输出零均值，缓解了 sigmoid 的部分问题 | 隐藏层（早期） |
| ReLU | [0, +∞) | 计算简单，缓解梯度消失，可能出现 Dead ReLU | 隐藏层（主流） |
| Softmax | (0, 1)，总和为 1 | 输出概率分布 | 多分类输出层 |
三、参数初始化
本章节学习目标：
了解常见的参数初始化方法
掌握初始化方法的选择
3.1 常见的初始化方法
参数初始化是对神经网络的权重和偏置进行初始赋值的过程，常见的 7 种初始化方法如下：
基础初始化方法
-
均匀分布初始化：权重参数初始化从区间均匀随机取值，默认区间为（0，1）。可以设置为在 (-1/√d,1/√d) 均匀分布中生成当前神经元的权重，其中 d 为神经元的输入数量
-
正态分布初始化：随机初始化从均值为 0，标准差是 1 的高斯分布中取样，使用一些很小的值对参数 W 进行初始化
-
全 0 初始化：将神经网络中的所有权重参数初始化为 0
-
全 1 初始化：将神经网络中的所有权重参数初始化为 1
-
固定值初始化：将神经网络中的所有权重参数初始化为某个固定值
进阶初始化方法
-
kaiming 初始化（HE 初始化）
HE 初始化分为正态分布的 HE 初始化、均匀分布的 HE 初始化.-
正态分布的 he 初始化：它是从 [0, std] 中抽取样本的，
std = sqrt\(2 / fan\_in\) -
均匀分布的 he 初始化：它从 [-limit，limit] 中的均匀分布中抽取样本，
limit是 sqrt\(6 / fan\_in\) -
fan_in：输入层神经元的个数
-
-
xavier 初始化（Glorot 初始化）
该方法也有两种，一种是正态分布的 xavier 初始化、一种是均匀分布的 xavier 初始化.-
正态化的 Xavier 初始化：它是从 [0, std] 中抽取样本的，
std = sqrt\(2 / \(fan\_in \+ fan\_out\)\) -
均匀分布的 Xavier 初始化：[-limit，limit] 中的均匀分布中抽取样本，
limit 是 sqrt\(6 / \(fan\_in \+ fan\_out\)\) -
fan_in：输入层神经元的个数， fan_out：输出层神经元个数
-
3.2 初始化的代码示例
import torch
import torch.nn.functional as F
import torch.nn as nn
# 1. 均匀分布随机初始化
def test01():
linear = nn.Linear(5, 3)
# 从0-1均匀分布产生参数
nn.init.uniform_(linear.weight)
print(linear.weight.data)
# 2.固定初始化
def test02():
linear = nn.Linear(5, 3)
nn.init.constant_(linear.weight, 5)
print(linear.weight.data)
# 3. 全0初始化
def test03():
linear = nn.Linear(5, 3)
nn.init.zeros_(linear.weight)
print(linear.weight.data)
# 4. 全1初始化
def test04():
linear = nn.Linear(5, 3)
nn.init.ones_(linear.weight)
print(linear.weight.data)
# 5. 正态分布随机初始化
def test05():
linear = nn.Linear(5, 3)
nn.init.normal_(linear.weight, mean=0, std=1)
print(linear.weight.data)
# 6. kaiming 初始化
def test06():
# kaiming 正态分布初始化
linear = nn.Linear(5, 3)
nn.init.kaiming_normal_(linear.weight)
print(linear.weight.data)
# kaiming 均匀分布初始化
linear = nn.Linear(5, 3)
nn.init.kaiming_uniform_(linear.weight)
print(linear.weight.data)
# 7. xavier 初始化
def test07():
# xavier 正态分布初始化
linear = nn.Linear(5, 3)
nn.init.xavier_normal_(linear.weight)
print(linear.weight.data)
# xavier 均匀分布初始化
linear = nn.Linear(5, 3)
nn.init.xavier_uniform_(linear.weight)
print(linear.weight.data)
3.3 初始化方法的选择
根据激活函数选择
-
Sigmoid/Tanh：选择 Xavier 初始化
-
ReLU/Leaky ReLU：选择 kaiming 初始化
根据网络深度选择
-
浅层网络：随机初始化即可
-
深层网络：需要考虑方差平衡，如 Xavier 或 kaiming 初始化
初始化方法对比辨析
| 初始化方法 | 核心特点 | 适用激活函数 | 适用场景 |
|---|---|---|---|
| 均匀 / 正态随机 | 简单随机初始化 | 浅层网络的激活函数 | 简单的浅层网络 |
| 全 0 / 全 1 / 固定值 | 固定值初始化 | 不推荐，容易导致对称问题 | 仅偏置可以使用，权重不推荐 |
| Xavier 初始化 | 平衡输入输出方差 | Sigmoid、Tanh | 早期的深层网络 |
| Kaiming 初始化 | 适配 ReLU 的半正则特性 | ReLU、Leaky ReLU | 现代深层网络 |
四、神经网络搭建实战
我们来构建一个简单的神经网络模型，结合我们学到的激活函数和参数初始化：
搭建步骤
在 pytorch 中定义深度神经网络其实就是层堆叠的过程，继承自 nn.Module，实现两个方法：
-
\_\_init\_\_方法中定义网络中的层结构，主要是全连接层，并进行初始化 -
forward方法，在实例化模型的时候，底层会自动调用该函数。该函数中为初始化定义的 layer 传入数据，进行前向传播等。
代码实现
from torch.nn import Module, Linear
import torch
# TODO 1.自定义模型类继承Module类
class My_Model(Module):
# TODO 2.重写init魔法方法和forward前向传播方法
def __init__(self, *args, **kwargs):
# 1.调用父类的init初始化方法
super().__init__(*args, **kwargs)
# TODO 定义神经网络结构
self.linear1 = Linear(3, 3)
self.linear2 = Linear(3, 2)
self.out = Linear(2, 2)
# 3.参数初始化(生成权重矩阵)
# 隐藏层初始化权重矩阵
torch.nn.init.xavier_normal_(self.linear1.weight)
torch.nn.init.kaiming_normal_(self.linear2.weight)
def forward(self, x):
# TODO 前向传播计算(每层都是加权求和+激活函数)
x = torch.sigmoid(self.linear1(x))
x = torch.relu(self.linear2(x))
# 下面-1代表最后一维, 也就是按照每个样本概率和为1.
x = torch.softmax(self.out(x), dim=-1)
return x
# TODO 3.创建模型对象并使用模型对象
# 创建模型对象
model = My_Model() # 自动调用init魔法方法
# 准备数据集(正态分布数据)
torch.manual_seed(66)
data = torch.randn(5, 3) # 5个样本,3个特征
# 把数据传入模型对象
output = model(data) # 自动调用forward方法
print(output)
五、损失函数
本章节学习目标：
知道分类任务的损失函数
知道回归任务的损失函数
5.1 什么是损失函数
在深度学习中，损失函数是用来衡量模型参数的质量的函数，衡量的方式是比较网络输出和真实输出的差异。
损失函数在不同的文献中名称是不一样的，主要有以下几种命名方式：
-
损失函数（Loss Function）
-
代价函数（Cost Function）
-
目标函数（Objective Function）
5.2 分类任务的损失函数
5.2.1 多分类任务：交叉熵损失
在多分类任务通常使用 softmax 将 logits 转换为概率的形式，所以多分类的交叉熵损失也叫做 softmax 损失，它的计算方法是：
其中:
-
y 是样本 x 属于某一个类别的真实概率
-
而 f (x) 是样本属于某一类别的预测分数
-
S 是 softmax 激活函数，将属于某一类别的预测分数转换成概率
-
L 用来衡量真实值 y 和预测值 f (x) 之间差异性的损失结果
从概率角度理解，我们的目的是最小化正确类别所对应的预测概率的对数的负值 (损失值最小)：
上图中的交叉熵损失为：
从概率角度理解，我们的目的是最小化正确类别所对应的预测概率的对数的负值(损失值最小)，如下图所示：
在 pytorch 中使用nn\.CrossEntropyLoss\(\)实现，代码如下：
# 分类损失函数：交叉熵损失使用nn.CrossEntropyLoss()实现。nn.CrossEntropyLoss()=softmax + 损失计算
def test01():
# 设置真实值: 可以是热编码后的结果也可以不进行热编码
# y_true = torch.tensor([[0, 1, 0], [0, 0, 1]], dtype=torch.float32)
# 注意的类型必须是64位整型数据
y_true = torch.tensor([1, 2], dtype=torch.int64)
y_pred = torch.tensor([[0.2, 0.6, 0.2], [0.1, 0.8, 0.1]], requires_grad=True, dtype=torch.float32)
# 实例化交叉熵损失
loss = nn.CrossEntropyLoss()
# 计算损失结果
my_loss = loss(y_pred, y_true).detach().numpy()
print('loss:', my_loss)
5.2.2 二分类任务：二分类交叉熵损失
在处理二分类任务时，我们不再使用 softmax 激活函数，而是使用 sigmoid 激活函数，那损失函数也相应的进行调整，使用二分类的交叉熵损失函数：
其中:
-
y 是样本 x 属于某一个类别的真实概率
-
而 y^ 是样本属于某一类别的预测概率
-
L 用来衡量真实值 y 与预测值 y^ 之间差异性的损失结果。
在 pytorch 中实现时使用nn\.BCELoss\(\)，代码如下：
def test02():
# 1 设置真实值和预测值
# 预测值是sigmoid输出的结果
y_pred = torch.tensor([0.6901, 0.5459], requires_grad=True)
y_true = torch.tensor([0, 1], dtype=torch.float32)
# 2 实例化二分类交叉熵损失
loss = nn.BCELoss()
# 3 计算损失
my_loss = loss(y_pred, y_true).detach().numpy()
print('loss：', my_loss)
5.3 回归任务的损失函数
5.3.1 MAE 损失函数（L1 Loss）
Mean absolute loss (MAE) 也被称为 L1 Loss，是以绝对误差作为距离。损失函数公式:
特点是：
-
由于 L1 loss 具有稀疏性，为了惩罚较大的值，因此常常将其作为正则项添加到其他 loss 中作为约束。
-
L1 loss 的最大问题是梯度在零点不平滑，导致会跳过极小值。
在 pytorch 中使用nn\.L1Loss\(\)实现，代码如下：
# 计算inputs与target之差的绝对值
def test03():
# 1 设置真实值和预测值
y_pred = torch.tensor([1.0, 1.0, 1.9], requires_grad=True)
y_true = torch.tensor([2.0, 2.0, 2.0], dtype=torch.float32)
# 2 实例化MAE损失
loss = nn.L1Loss()
# 3 计算损失
my_loss = loss(y_pred, y_true).detach().numpy()
print('loss：', my_loss)
5.3.2 MSE 损失函数（L2 Loss）
Mean Squared Loss (MSE) 也被称为 L2 Loss，是以均方误差作为距离。损失函数公式:
特点是：
-
L2 loss 的梯度会随着误差减小而减小，因此更容易收敛到最小值。
-
对异常值更敏感，因为它会对大的误差进行平方惩罚。
在 pytorch 中使用nn\.MSELoss\(\)实现，代码如下：
# 计算inputs与target之差的平方
def test04():
# 1 设置真实值和预测值
y_pred = torch.tensor([1.0, 1.0, 1.9], requires_grad=True)
y_true = torch.tensor([2.0, 2.0, 2.0], dtype=torch.float32)
# 2 实例化MSE损失
loss = nn.MSELoss()
# 3 计算损失
my_loss = loss(y_pred, y_true).detach().numpy()
print('loss：', my_loss)
损失函数对比辨析
| 损失函数 | 适用任务 | 特点 | 适用场景 |
|---|---|---|---|
| 交叉熵损失（CrossEntropy） | 多分类 | 衡量预测概率分布和真实分布的差异，梯度稳定 | 多分类任务 |
| 二分类交叉熵损失（BCELoss） | 二分类 | 针对二分类的交叉熵，配合 sigmoid 使用 | 二分类任务 |
| MAE 损失（L1 Loss） | 回归 | 对异常值不敏感，零点梯度不平滑 | 回归任务，对异常值鲁棒的场景 |
| MSE 损失（L2 Loss） | 回归 | 梯度随误差减小，更容易收敛，对异常值敏感 | 回归任务，数据质量较好的场景 |
六、网络优化方法
本章节学习目标：
了解常见的优化算法
掌握学习率的调整方法
6.1 梯度下降优化算法
梯度下降是神经网络优化的基础算法，常见的梯度下降变种有：
-
批量梯度下降（BGD）：使用全部样本计算梯度，更新稳定但速度慢
-
随机梯度下降（SGD）：使用单个样本计算梯度，速度快但波动大
-
小批量梯度下降（MBGD）：使用小批量样本，平衡速度和稳定性，是目前的主流
6.2 带动量的梯度下降
动量（Momentum）是模拟物理中的动量概念，积累之前的梯度方向，加速收敛，减少震荡：
6.3 自适应学习率算法
6.3.1 AdaGrad
自适应调整每个参数的学习率，对稀疏数据效果好，但学习率会单调递减：
6.3.2 RMSProp
解决 AdaGrad 学习率递减的问题，使用指数移动平均来累积梯度：
6.3.3 Adam
结合了动量和 RMSProp 的优点，是目前最常用的优化算法，自适应调整学习率，收敛速度快：
6.4 学习率衰减
随着训练的进行，逐渐降低学习率，让模型在训练后期更稳定，避免震荡：
6.4.1 等间隔学习率衰减
每经过固定的轮次，就将学习率乘以一个衰减系数：
def test_StepLR():
# 0.参数初始化
LR = 0.1 # 设置学习率初始化值为0.1
iteration = 10
max_epoch = 200
# 1 初始化参数
y_true = torch.tensor([0])
x = torch.tensor([1.0])
w = torch.tensor([1.0], requires_grad=True)
# 2.优化器
optimizer = optim.SGD([w], lr=LR, momentum=0.9)
# 3.设置学习率下降策略
scheduler_lr = optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.5)
# 4.获取学习率的值和当前的epoch
lr_list, epoch_list = list(), list()
for epoch in range(max_epoch):
lr_list.append(scheduler_lr.get_last_lr()) # 获取当前lr
epoch_list.append(epoch) # 获取当前的epoch
for i in range(iteration): # 遍历每一个batch数据
loss = ((w*x-y_true)**2)/2.0 # 目标函数
optimizer.zero_grad()
# 反向传播
loss.backward()
optimizer.step()
# 更新下一个epoch的学习率
scheduler_lr.step()
# 5.绘制学习率变化的曲线
plt.plot(epoch_list, lr_list, label="Step LR Scheduler")
plt.xlabel("Epoch")
plt.ylabel("Learning rate")
plt.legend()
plt.show()
6.4.2 指定间隔学习率衰减
在指定的轮次进行学习率衰减，更灵活：
def test_MultiStepLR():
torch.manual_seed(1)
LR = 0.1
iteration = 10
max_epoch = 200
weights = torch.randn((1), requires_grad=True)
target = torch.zeros((1))
print('weights--->', weights, 'target--->', target)
optimizer = optim.SGD([weights], lr=LR, momentum=0.9)
# 设定调整时刻数
milestones = [50, 125, 160]
# 设置学习率下降策略
scheduler_lr = optim.lr_scheduler.MultiStepLR(optimizer, milestones=milestones, gamma=0.5)
lr_list, epoch_list = list(), list()
for epoch in range(max_epoch):
lr_list.append(scheduler_lr.get_last_lr())
epoch_list.append(epoch)
for i in range(iteration):
loss = torch.pow((weights - target), 2)
optimizer.zero_grad()
# 反向传播
loss.backward()
# 参数更新
optimizer.step()
# 更新下一个epoch的学习率
scheduler_lr.step()
plt.plot(epoch_list, lr_list, label="Multi Step LR Scheduler\nmilestones:{}".format(milestones))
plt.xlabel("Epoch")
plt.ylabel("Learning rate")
plt.legend()
plt.show()
6.4.3 按指数学习率衰减
学习率按指数规律衰减：
def test_ExponentialLR():
# 0.参数初始化
LR = 0.1 # 设置学习率初始化值为0.1
iteration = 10
max_epoch = 200
# 1 初始化参数
y_true = torch.tensor([0])
x = torch.tensor([1.0])
w = torch.tensor([1.0], requires_grad=True)
# 2.优化器
optimizer = optim.SGD([w], lr=LR, momentum=0.9)
# 3.设置学习率下降策略
gamma = 0.95
scheduler_lr = optim.lr_scheduler.ExponentialLR(optimizer, gamma=gamma)
# 4.获取学习率的值和当前的epoch
lr_list, epoch_list = list(), list()
for epoch in range(max_epoch):
lr_list.append(scheduler_lr.get_last_lr())
epoch_list.append(epoch)
for i in range(iteration): # 遍历每一个batch数据
loss = ((w*x-y_true)**2)/2.0
optimizer.zero_grad()
# 反向传播
loss.backward()
optimizer.step()
# 更新下一个epoch的学习率
scheduler_lr.step()
# 5.绘制学习率变化的曲线
plt.plot(epoch_list, lr_list, label="Multi Step LR Scheduler")
plt.xlabel("Epoch")
plt.ylabel("Learning rate")
plt.legend()
plt.show()
优化方法对比辨析
| 优化算法 | 核心特点 | 适用场景 |
|---|---|---|
| SGD | 简单的随机梯度下降，收敛慢，容易震荡 | 简单任务，数据量小 |
| SGD+Momentum | 加入动量，加速收敛，减少震荡 | 大部分任务，稳定训练 |
| AdaGrad | 自适应学习率，适合稀疏数据 | 稀疏数据，NLP 任务 |
| RMSProp | 解决 AdaGrad 学习率递减问题 | 深度学习任务 |
| Adam | 结合动量和自适应学习率，收敛快 | 主流深度学习任务，默认首选 |
七、正则化方法
本章节学习目标：
知道正则化的作用
掌握随机失活 DropOut 策略
知道 BN 层的作用
7.1 正则化的作用
在设计机器学习算法时希望在新样本上的泛化能力强。许多机器学习算法都采用相关的策略来减小测试误差，这些策略被统称为正则化。
神经网络强大的表示能力经常遇到过拟合，所以需要使用不同形式的正则化策略。
7.2 Dropout 正则化
在练神经网络中模型参数较多，在数据量不足的情况下，很容易过拟合。Dropout（随机失活）是一个简单有效的正则化方法。
在训练过程中，Dropout 的实现是让神经元以超参数 p 的概率停止工作或者激活被置为 0, 未被置为 0 的进行缩放，缩放比例为 1/(1-p)。训练过程可以认为是对完整的神经网络的一些子集进行训练，每次基于输入数据只更新子网络的参数。
在测试过程中，随机失活不起作用。
代码示例：
import torch
import torch.nn as nn
def test():
# 初始化随机失活层
dropout = nn.Dropout(p=0.4)
# 初始化输入数据:表示某一层的weight信息
inputs = torch.randint(0, 10, size=[1, 4]).float()
layer = nn.Linear(4,5)
y = layer(inputs)
print("未失活FC层的输出结果：\n", y)
y = dropout(y)
print("失活后FC层的输出结果：\n", y)
输出结果:
未失活FC层的输出结果：
tensor([[-0.8369, -5.5720, 0.2258, 3.4256, 2.1919]],
grad_fn=<AddmmBackward0>)
失活后FC层的输出结果：
tensor([[-1.3949, -9.2866, 0.3763, 0.0000, 3.6531]], grad_fn=<MulBackward0>)
7.3 批量归一化（Batch Normalization）
批量归一化是对数据标准化，再对数据重构（缩放 + 平移），如下所示：
其中：
-
λ 和 β 是可学习的参数，它相当于对标准化后的值做了一个线性变换，λ 为系数，β 为偏置；
-
eps 通常指为 1e-5，避免分母为 0；
-
E (x) 表示变量的均值；
-
Var (x) 表示变量的方差；
批量归一化层在计算机视觉领域使用较多，它可以：
-
缓解梯度消失 / 爆炸问题
-
允许使用更高的学习率
-
降低对初始化的敏感程度
-
有轻微的正则化效果
代码示例：
import torch
import torch.nn as nn
m = nn.BatchNorm2d(2, eps=1e-05, momentum=0.1, affine=True) # affine参数设为True表示weight和bias将被使用
input = torch.randn(1, 2, 3, 4)
print("input-->", input)
output = m(input)
print("output-->", output)
print(output.size())
print(m.weight)
print(m.bias)
输出结果:
input--> tensor([[[[-0.2751, -1.2183, -0.5106, -0.1540],
[-0.4585, -0.5989, -0.6063, 0.5986],
[-0.4745, 0.1496, -1.1266, -1.2377]],
[[ 0.2580, 1.2065, 1.4598, 0.8387],
[-0.4586, 0.8938, -0.3328, 0.1192],
[-0.3265, -0.6263, 0.0419, -1.2231]]]])
output--> tensor([[[[ 0.4164, -1.3889, -0.0343, 0.6484],
[ 0.0655, -0.2032, -0.2175, 2.0889],
[ 0.0349, 1.2294, -1.2134, -1.4262]],
[[ 0.1340, 1.3582, 1.6853, 0.8835],
[-0.7910, 0.9546, -0.6287, -0.0452],
[-0.6205, -1.0075, -0.1449, -1.7779]]]],
grad_fn=<NativeBatchNormBackward0>)
torch.Size([1, 2, 3, 4])
Parameter containing:
tensor([1., 1.], requires_grad=True)
Parameter containing:
tensor([0., 0.], requires_grad=True)
八、实战案例：手机价格分类
本章节学习目标：
掌握构建分类模型的完整流程
动手实践整个训练和评估过程
8.1 需求分析
小明创办了一家手机公司，他不知道如何估算手机产品的价格。为了解决这个问题，他收集了多家公司的手机销售数据。该数据为二手手机的各个性能的数据，最后根据这些性能得到 4 个价格区间，作为这些二手手机售出的价格区间。
我们需要帮助小明找出手机的功能（例如：RAM 等）与其售价之间的某种关系。我们可以使用机器学习的方法来解决这个问题，也可以构建一个全连接的网络。
需要注意的是：在这个问题中，我们不需要预测实际价格，而是一个价格范围，它的范围使用 0、1、2、3 来表示，所以该问题也是一个分类问题。
I在这里插入图片描述
8.2 完整流程
我们按照四个步骤来完成这个任务：
-
准备训练集数据
-
构建要使用的模型
-
模型训练
-
模型预测评估
8.2.1 导入工具包
# 导入相关模块
import torch
from torch.utils.data import TensorDataset
from torch.utils.data import DataLoader
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import time
8.2.2 构建数据集
数据共有 2000 条，其中 1600 条数据作为训练集，400 条数据用作测试集。 我们使用 sklearn 的数据集划分工作来完成。并使用 PyTorch 的 TensorDataset 来将数据集构建为 Dataset 对象，方便构造数据集加载对象。
# 构建数据集
def create_dataset():
# 使用pandas读取数据
data = pd.read_csv('data/手机价格预测.csv')
# 特征值和目标值
x, y = data.iloc[:, :-1], data.iloc[:, -1]
# 类型转换：特征值，目标值
x = x.astype(np.float32)
y = y.astype(np.int64)
# 数据集划分
x_train, x_valid, y_train, y_valid = train_test_split(x, y, train_size=0.8, random_state=88)
# 构建数据集,转换为pytorch的形式
train_dataset = TensorDataset(torch.from_numpy(x_train.values), torch.tensor(y_train.values))
valid_dataset = TensorDataset(torch.from_numpy(x_valid.values), torch.tensor(y_valid.values))
# 返回结果
return train_dataset, valid_dataset, x_train.shape[1], len(np.unique(y))
输出结果：
输入特征数： 20
分类个数： 4
8.2.3 构建分类网络模型
构建全连接神经网络来进行手机价格分类，该网络主要由三个线性层来构建，使用 relu 激活函数。
网络共有 3 个全连接层，具体信息如下:
-
第一层：输入为维度为 20, 输出维度为: 128
-
第二层：输入为维度为 128, 输出维度为: 256
-
第三层：输入为维度为 256, 输出维度为: 4
# 构建网络模型
class PhonePriceModel(nn.Module):
def __init__(self, input_dim, output_dim):
super(PhonePriceModel, self).__init__()
# 1. 第一层: 输入为维度为 20, 输出维度为: 128
self.linear1 = nn.Linear(input_dim, 128)
# 2. 第二层: 输入为维度为 128, 输出维度为: 256
self.linear2 = nn.Linear(128, 256)
# 3. 第三层: 输入为维度为 256, 输出维度为: 4
self.linear3 = nn.Linear(256, output_dim)
def forward(self, x):
# 前向传播过程
x = torch.relu(self.linear1(x))
x = torch.relu(self.linear2(x))
output = self.linear3(x)
# 获取数据结果
return output
模型实例化的输出：
8.2.4 模型训练
网络编写完成之后，我们需要编写训练函数。所谓的训练函数，指的是输入数据读取、送入网络、计算损失、更新参数的流程，该流程较为固定。我们使用的是多分类交叉生损失函数、使用 SGD 优化方法。最终，将训练好的模型持久化到磁盘中。
# 模型训练过程
def train(train_dataset,input_dim,class_num,):
# 固定随机数种子
torch.manual_seed(0)
# 初始化数据加载器
dataloader = DataLoader(train_dataset, shuffle=True, batch_size=8)
# 初始化模型
model = PhonePriceModel(input_dim, class_num)
# 损失函数
criterion = nn.CrossEntropyLoss()
# 优化方法
optimizer = optim.SGD(model.parameters(), lr=1e-3)
# 训练轮数
num_epoch = 50
# 遍历每个轮次的数据
for epoch_idx in range(num_epoch):
# 训练时间
start = time.time()
# 计算损失
total_loss = 0.0
total_num = 0
# 遍历每个batch数据进行处理
for x, y in dataloader:
# 将数据送入网络中进行预测
output = model(x)
# 计算损失
loss = criterion(output, y)
# 梯度清零
optimizer.zero_grad()
# 反向传播
loss.backward()
# 参数更新
optimizer.step()
# 损失计算
total_num += 1
total_loss += loss.item()
# 打印损失变换结果
print('epoch: %4s loss: %.2f, time: %.2fs' %(epoch_idx + 1, total_loss / total_num, time.time() - start))
# 模型保存
torch.save(model.state_dict(), 'model/phone.pth')
训练的输出结果：
8.2.5 模型评估
使用训练好的模型，对未知的样本的进行预测的过程。我们这里使用前面单独划分出来的验证集来进行评估。
def test(valid_dataset,input_dim,class_num):
# 加载模型和训练好的网络参数
model = PhonePriceModel(input_dim, class_num)
model.load_state_dict(torch.load('model/phone.pth'))
# 构建加载器
dataloader = DataLoader(valid_dataset, batch_size=8, shuffle=False)
# 评估测试集
correct = 0
# 遍历测试集中的数据
for x, y in dataloader:
# 将其送入网络中
output = model(x)
# 获取类别结果
y_pred = torch.argmax(output, dim=1)
# 获取预测正确的个数
correct += (y_pred == y).sum()
# 求预测精度
print('Acc: %.5f' % (correct.item() / len(valid_dataset)))
输出结果:
Acc: 0.64250
8.3 调优方向
我们前面的网络模型在测试集的准确率为: 0.64250, 我们可以通过以下方面进行调优:
-
优化方法由 SGD 调整为 Adam
-
学习率由 1e-3 调整为 1e-4
-
对数据进行标准化
-
增加网络深度，即：增加网络参数量
-
调整训练轮次
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
10
0- 0
已为社区贡献8条内容
所有评论(0)