Pytorch: 优化器、损失函数与深度神经网络框架

Copyright: Jingmin Wei, Pattern Recognition and Intelligent System, School of Artificial and Intelligence, Huazhong University of Science and Technology

---

文章目录

• • • Pytorch: 优化器、损失函数与深度神经网络框架
  • @[toc]
  • • • 常用优化器
      • • 常用优化器
        • Adam 优化器
      • 损失函数
      • • 均方误差损失
        • 交叉熵损失
      • 防止过拟合
      • 网络参数初始化
      • • 针对某一层的权重进行初始化
        • 针对一个网络的权重初始化方法

常用优化器

随机梯度下降法(SGD)是机器学习中，模型能够进行学习并推理的基本算法，相关原理和代码请自行查阅资料。

随机下降的缺点在于，很难确定一个合适的学习率，且容易收敛到局部梯度最小。

解决方案有两种，引入动量的思想动态更新参数，引入动态学习率变化。

引入动量的思想动态更新参数，即综合考虑参数更新的方向和当前batch计算的梯度，综合算出更新梯度的大小和方向。增加学习参数的稳定性同时，更快的学习到收敛的参数。
$$\begin{gathered} m_t=\mu \times m_{t-1}+g_t \\ \Delta {\theta }_t=\eta \times m_t \end{gathered}$$
梯度下降方向和上次相同时，梯度会变大，否则梯度会变小。中后期学习中，梯度会在局部最优附近震荡( $g_t=0$ )，因此有一定可能跳出局部最优。

常用的动量有 Nesterov 动量。

引入动态学习率变化，即在训练开始时，参数与最优值距离较远，因此要使用较大的学习率，经过几轮训练后，则减小学习率。因此开发了诸如Adadelta，RMSProp及Adam等自适应学习率算法。

比如说 Adam，利用梯度的一阶矩和二阶矩动态地估计每一个参数的学习率，参数的更新更加的平稳，模型的收敛速度更快。

常用优化器

在optim模块，提供多种深度学习的优化算法。

import torch
from torch import nn
from torch import optim
import matplotlib.pyplot as plt

torch.optim.Adadelta()
torch.optim.Adagrad()
torch.optim.Adam()
torch.optim.ASGD()    # 平均随机梯度下降
torch.optim.LBFCS()
torch.optim.RMSprop()
torch.optim.Rprop()    # 弹性反向传播  
torch.optim.SGD()     # 随机梯度下降

Adam 优化器

以 $Adam$ 优化器为例，我们的模型在训练时使用强大而通用的 $Adam$ 优化算法， $Adam$ 优化器为目前深度学习中普遍使用且效果均不错的“万金油”优化器．其主要原理是，对梯度的一阶矩估计( $FirstMomentEstimation$ ，即梯度的均值）和二阶矩估计( $SecondMomentEstimation$ ，即梯度的未中心化的方差）进行综合考虑，计算出每一次迭代更新步长。

$Adam$ 算法在 $RMSProp$ 算法基础上对小批量随机梯度也做了指数加权移动平均 $Adam$ 算法可以看做是 $RMSProp$ 算法与动量法的结合。

$Adam$​ 算法使用了动量变量 ${\mathbf{v}}_t$​ 和 $RMSProp$​ 算法中小批量随机梯度按元素平方的指数加权移动平均变量 ${\mathbf{s}}_t$​，并在时间步 $0$​ 将它们中每个元素初始化为 $0$​ 。

给定超参数 $0\le {\beta }_1<1$​ （算法作者建议设为 $0.9$​ ），时间步 $t$​ 的动量变量 ${\mathbf{v}}_t$​ 即小批量随机梯度 ${\mathbf{g}}_t$​ 的指数加权移动平均：
$${\mathbf{v}}_t\leftarrow {\beta }_1{\mathbf{v}}_{t-1}+(1-{\beta }_1){\mathbf{g}}_t.$$
和 $RMSProp$​ 算法中一样，给定超参数 $0\le {\beta }_2<1$​ （算法作者建议设为 $0.999$ ）， 将小批量随机梯度按元素平方后的项 ${\mathbf{g}}_t\odot {\mathbf{g}}_t$ 做指数加权移动平均得到 ${\mathbf{s}}_t$​ ：
$${\mathbf{s}}_t\leftarrow {\beta }_2{\mathbf{s}}_{t-1}+(1-{\beta }_2){\mathbf{g}}_t\odot {\mathbf{g}}_t.$$
由于我们将 ${\mathbf{v}}_0$ 和 ${\mathbf{s}}_0$ 中的元素都初始化为 $0$ ， 在时间步 $t$ 我们得到 ${\mathbf{v}}_t=(1-{\beta }_1){\sum }_{i=1}^t{\beta }_1^{t-i}{\mathbf{g}}_i$ 。将过去各时间步小批量随机梯度的权值相加，得到 $(1-{\beta }_1){\sum }_{i=1}^t{\beta }_1^{t-i}=1-{\beta }_1^t$ 。需要注意的是，当 $t$ 较小时，过去各时间步小批量随机梯度权值之和会较小。例如，当 ${\beta }_1=0.9$ 时，${\mathbf{v}}_1=0.1{\mathbf{g}}_1$ 。为了消除这样的影响，对于任意时间步 $t$ ，我们可以将 ${\mathbf{v}}_t$ 再除以 $1-{\beta }_1^t$ ，从而使过去各时间步小批量随机梯度权值之和为 $1$ 。这也叫作偏差修正。在 $Adam$ 算法中，我们对变量 ${\mathbf{v}}_t$ 和 ${\mathbf{s}}_t$ 均作偏差修正：
$${\hat{\mathbf{v}}}_t\leftarrow \frac{{\mathbf{v}}_t}{1-{\beta }_1^t}$$

$${\hat{\mathbf{s}}}_t\leftarrow \frac{{\mathbf{s}}_t}{1-{\beta }_2^t}.$$

接下来， $Adam$ 算法使用以上偏差修正后的变量 ${\hat{\mathbf{s}}}_t\leftarrow \frac{{\mathbf{s}}_t}{1-{\beta }_2^t}.$和 ${\hat{\mathbf{s}}}_t$ ，将模型参数中每个元素的学习率通过按元素运算重新调整：
$${\mathbf{g}}_t^{\prime }\leftarrow \frac{\eta {\hat{\mathbf{v}}}_t}{\sqrt{{\hat{\mathbf{s}}}_t}+ϵ},$$
其中 $\eta$ 是学习率， $ϵ$ 是为了维持数值稳定性而添加的常数，如 $10^{-8}$ 。和 $AdaGrad$ 算法、$RMSProp$ 算法以及 $AdaDelta$ 算法一样，目标函数自变量中每个元素都分别拥有自己的学习率。最后，使用 ${\mathbf{g}}_t^{\prime }$ 迭代自变量：
$${\mathbf{x}}_t\leftarrow {\mathbf{x}}_{t-1}-{\mathbf{g}}_t^{\prime }.$$

torch.optim.Adam(params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8,weight_decay=0, amsgrad=False)

params,    # 待优化参数的iterable或定义了参数组的dict，通常为model.parameters()
lr=1e-3,     # 算法学习率，默认为0.001 
betas=(0.9, 0.999),    # 用于计算梯度以及梯度平方的运行平均值
eps=1e-8,    # 为了增加数值计算的稳定性而加到分母里的项
weight_decay=0,    # 权重衰减(L2惩罚)
amsgrad=False

建立测试网络，演示优化器的使用方式

# 建立一个测试网络
class TestNet(nn.Module):def __init__(self):super(TestNet, self).__init__()    # 对继承自父类的属性进行初始化# 定义隐含层self.hidden = nn.Sequential(nn.Linear(13, 10),nn.ReLU(),)# 定义预测回归层self.regression = nn.Linear(10, 1)def forward(self, x):# 定义前向传播路径x = self.hidden(x)output = self.regression(x)return output

testnet = TestNet()    # 构建对象

# 使用迭代器(优化器)，为不同层定义统一的学习率
optimizer = optim.Adam(testnet.parameters(), lr = 0.001)

# 使用迭代器(优化器)，为不同层定义不同的学习率
optimizer = optim.Adam([{'params': testnet.hidden.parameters(), 'lr': 0.0001},{'params': testnet.regression.parameters(), 'lr': 0.01}])

# 目标函数优化框架(非可正确运行实例)# 定义损失函数为交叉熵(也可以定义其他的损失函数)
loss_function = nn.CrossEntropyLoss()  for input, target in dataset:optimizer.zero_grad()    # 梯度清零output = TestNet(input)    # 计算预测值loss = loss_function(output, target)    # 计算梯度损失loss.backward()    # 损失反向传播optimizer.step()    # 更新梯度参数

optim.lr_scheduler提供了几种优化器学习率的调整方式

last_epoch, # 用来设置何时开始调整学习率，=-1表示学习率设置为初始值
step_size, # 学习率会每经过step_size后调整为原来的gamma倍
milestones, # 使用一个列表来制定需要调整学习率的epoch数值, 调整为原来的gamma倍
T_max, # T_max个epoch后重新设置学习率
eta_min, # 每个周期的最小学习率，
# 具体调整算法见教材optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=-1)
optim.lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=-1)
optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-1)
optim.lr_scheduler.ExponentialLR(optimizer, gamma, last_epoch=-1)
optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=-1)

# 设置学习率调整方式
scheduler = optim.lr_scheduler.LambdaLR()for epoch in range(100):train(...)validate(...)scheduler.step()    # 更新学习率

损失函数

用来表示某次迭代中，预测值与实际验证集之间的差距程度。

最优化问题的目标就是将损失函数最小化。

nn模块提供了多种深度学习损失函数

nn.L1Loss(), # 平均绝对值误差损失，用于回归问题
nn.MSELoss(), # 均方误差损失，用于回归问题
nn.CrossEntropyLoss(), # 交叉熵损失，用于多分类
nn.NLLLoss(), # 负对数似然函数损失，用于多分类
nn.NLLLoss2d(), # 图片负对数似然函数损失，用于图像分割
nn.KLDivLoss(), # KL散度损失，用于回归问题
nn.BCELoss(), # 二分类交叉熵损失，用于二分类
nn.MarginRankingLoss(), # 评价相似度的损失
nn.MultiLabelMarginLoss(), # 多标签分类的损失
nn.SmoothL1Loss(), # 平滑的L1损失，用于回归问题
nn.SoftMarginLoss(), # 多标签二分类问题的损失

以交叉熵和均方误差为例

均方误差损失

$loss(x,y)=1/N\cdot (x_i-y_i{)}^2$

nn.MSELoss(size_average=None, reduce=None, reduction='mean')

size_average=None, # 计算的损失为每个batch的均值，否则为每个batch的和
reduce=None, # 计算的损失会根据size_average设定，试计算每个batch的均值或和
reduction='mean', # 'none', 'mean', 'sum' 来判断损失的计算方式，默认是均值

交叉熵损失

它将LogSsoftMax和NLLLoss集成到一个类中，一般用于多分配问题

nn.CrossEntropyLoss(weight=None, size_average=None, ignore_index=-100,reduce=None, reduction='mean')

weight=None, # 是1维张量，包含n个元素，代表n类的权重，在训练样本不均衡时非常有用
ignore_index=-100, # 指定被忽略且对输入梯度没有贡献的目标值

当weight = None

$$loss(x,class)=-\log \frac{\exp (x[class])}{{\sum }_{j}x[j]}=-x[class]+\log (\sum _j\exp (x[j]))$$

当weight被指定时

$$loss(x,class)=weight[class]\times (-x[class]+log(\sum _j\exp (x[j])\left)\right)$$

防止过拟合

过拟合指，在训练集上分类或预测过匹配，测试集上结果不理想。

实质上是，模型的偏差很小，但方差很大

常用防止过拟合方法有:

1. 增加数据量。
2. 合理的数据切分。使用合理的比例切分训练集，验证集和测试集。
3. 正则化方法。即在损失函数上添加对训练参数的惩罚范数，对需要训练的参数进行约束。常用的参数有 $l_1$ 和 $l_2$ 范数。
4. Dropout。引入Dropout层，随机丢掉一些神经元，即让某几个神经元，以一定的概率p停止工作，减轻网络的过拟合现象。

网络参数初始化

为了得到高精度的训练结果，不使用默认参数初始化，而是使用一些特定的参数初始化方法。

常用初始化方法见教材，下面是参数初始化实例。

针对某一层的权重进行初始化

以一个卷积层为例

# 定义一个从3个特征映射到16个特征的卷积层
conv1 = nn.Conv2d(3, 16, 3)
# 使用标准正态分布初始化权重
torch.manual_seed(12)    # 随机数初始化种子
# 用生成的随机数代替张量conv1.weight的原始数据
nn.init.normal_(conv1.weight, mean=0, std=1)    
plt.figure(figsize=(8, 6))
plt.hist(conv1.weight.data.numpy().reshape((-1, 1)), bins=30)
plt.show()

​
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KMYO6y4n-1643884575825)(output_32_0.png)]
​

# 使用指定值初始化偏置
# 让conv1的偏置参数中的每个元素，重新初始化为0.1
nn.init.constant_(conv1.bias, val=0.1)

Parameter containing:
tensor([0.1000, 0.1000, 0.1000, 0.1000, 0.1000, 0.1000, 0.1000, 0.1000, 0.1000,0.1000, 0.1000, 0.1000, 0.1000, 0.1000, 0.1000, 0.1000],requires_grad=True)

针对一个网络的权重初始化方法

对多层网络每个层的参数进行初始化

# 建立测试网络
class TestNet(nn.Module):def __init__(self):super(TestNet, self).__init__()self.conv1 = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3)self.hidden = nn.Sequential(nn.Linear(1600, 100),nn.ReLU(),nn.Linear(100, 50),nn.ReLU())self.cla = nn.Linear(50, 10)def forward(self, x):x = self.conv1(x)x = x.view(x.shape[0], -1)x = self.hidden(x)output = self.cla(x)return output

# 输出网络结构
from torchsummary import summary
testnet = TestNet()
summary(testnet, input_size=(3, 12, 12))

----------------------------------------------------------------Layer (type)               Output Shape         Param #
================================================================Conv2d-1           [-1, 16, 10, 10]             448Linear-2                  [-1, 100]         160,100ReLU-3                  [-1, 100]               0Linear-4                   [-1, 50]           5,050ReLU-5                   [-1, 50]               0Linear-6                   [-1, 10]             510
================================================================
Total params: 166,108
Trainable params: 166,108
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.00
Forward/backward pass size (MB): 0.01
Params size (MB): 0.63
Estimated Total Size (MB): 0.65
----------------------------------------------------------------

print(testnet)

TestNet((conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1))(hidden): Sequential((0): Linear(in_features=1600, out_features=100, bias=True)(1): ReLU()(2): Linear(in_features=100, out_features=50, bias=True)(3): ReLU())(cla): Linear(in_features=50, out_features=10, bias=True)
)

为什么上述 $summary$ 写法是这样的呢？可以适当复习一下 torch.nn 章节。

首先我们设置了 $conv1的参数:in\_channels=3,out\_channels=16,kernel\_size=3$

对应到参数计算，即 $D_1=3,D_2=16$，滤波器大小为 $F\times F=3\times 3$。默认构造参数 $stride=1,padding=0,即S=1,P=0$

在 $summary$ 方法中，$input\_size=D_1\times W_1\times H_1$。即卷积层输入数据的大小为 $W_1\times H_1\times D_1=12\times 12\times 3$

这些是已知量。

---

根据卷积层计算方法：
$$W_2=\frac{W_1-F+2P}{S}+1,H_2=\frac{H_1-F+2P}{S}+1,D_2=F$$
因此，$W_2=W_1-2,H_2=H_1-2$

输出 $W_2\times H_2\times D_2=(W_1-2)\times (H_1-2)\times F=10\times 10\times 16$，总共参数量为 $1600$。

然后我们开始设置全连接层 $linear2的参数:in\_channels=?,out\_channels=?$

前一层的输出等于后一层的输入，$in\_channels=1600$，$out\_channels$ 就根据需要输出类别的实际情况来确定了。

后面的全连接层类似。

---

以上都是题外话，然后我们来为上述网络的每一层定义进行权重初始化函数

def init_weights(m):# 如果是卷积层if type(m) == nn.Conv2d:torch.nn.init.normal_(m.weight, mean=0, std=0.5)    # 正态分布# 如果是全连接层if type(m) == nn.Linear:torch.nn.init.uniform_(m.weight, a=-0.1, b=0.1)    # -0.1-0.1均匀分布m.bias.data.fill_(0.01)    # 设置偏置bias为0.01

# 使用网络的apllu方法进行权重初始化
torch.manual_seed(13)    # 随机数初始化种子
testnet.apply(init_weights)

TestNet((conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1))(hidden): Sequential((0): Linear(in_features=1600, out_features=100, bias=True)(1): ReLU()(2): Linear(in_features=100, out_features=50, bias=True)(3): ReLU())(cla): Linear(in_features=50, out_features=10, bias=True)
)