一、损失函数是什么

从下面的一元函数可以看出，直线拟合的点和真实值之间存在误差，这个误差就是损失函数。
损失函数：计算一个样本的差异。
代价函数：样本数据集所有损失的平均值。
目标函数：代价函数+Regularization(对模型的约束)
Regularization：为了防止模型过拟合，需要添加该项对模型进行约束
一般用代价函数来表示模型的损失函数

二、常见的损失函数

2.1 nn.CrossEntropyLoss交叉熵损失函数

功能： nn.LogSoftmax() 与 nn.NLLLoss() 结合，进行交叉熵计算
LogSoftmax：将数据归一化到一个概率取值的范围 0~1
NLLLoss()：使用概率值计算交叉熵

主要参数：
• weight：各类别的loss设置权值
• ignore_index：忽略某个类别
• reduction ：计算模式，可为none/sum /mean
none- 逐个元素计算
sum- 所有元素求和，返回标量
mean- 加权平均，返回标量

交叉熵损失函数继承的父类损失：

class _Loss(Module):reduction: strdef __init__(self, size_average=None, reduce=None, reduction: str = 'mean') -> None:super().__init__()if size_average is not None or reduce is not None:self.reduction: str = _Reduction.legacy_get_string(size_average, reduce)else:self.reduction = reduction

2.1.1 交叉熵的概念

熵：表示自信息的期望
自信息：用于衡量单个事件的不确定性
右图表示信息熵：当概率为0.5左右的时候，信息熵最大。
P表示原始数据的概率分布，Q表示模型输出的概率分布。
从公式可以看出优化交叉熵也就是优化相对熵，因为H§是一个常数。

2.2.2 交叉熵代码实现

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np# fake data
inputs = torch.tensor([[1, 2], [1, 3], [1, 3]], dtype=torch.float)  # 设置输入数据，两个神经元
target = torch.tensor([0, 1, 1], dtype=torch.long)  # 三个类别，第一个样本类别为0，第2,3个样本类别为1# ----------------------------------- CrossEntropy loss: reduction -----------------------------------# flag = 0
flag = 1
if flag:# def loss functionloss_f_none = nn.CrossEntropyLoss(weight=None, reduction='none')loss_f_sum = nn.CrossEntropyLoss(weight=None, reduction='sum')  # 将所有损失相加loss_f_mean = nn.CrossEntropyLoss(weight=None, reduction='mean')  # 求损失的平均值# forwardloss_none = loss_f_none(inputs, target)loss_sum = loss_f_sum(inputs, target)loss_mean = loss_f_mean(inputs, target)# viewprint("Cross Entropy Loss:\n ", loss_none, loss_sum, loss_mean)# --------------------------------- 手算公式验证 只计算第一个样本的损失----------------------------------------
# flag = 0
flag = 1
if flag:idx = 0  # 第一个样本input_1 = inputs.detach().numpy()[idx]  # 取第一个样本数据 [1, 2]target_1 = target.numpy()[idx]  # 取第一个样本的标签类别 [0]# 第一项x_class = input_1[target_1]# 第二项sigma_exp_x = np.sum(list(map(np.exp, input_1)))log_sigma_exp_x = np.log(sigma_exp_x)# 输出lossloss_1 = -x_class + log_sigma_exp_xprint("第一个样本loss为: ", loss_1)

输出结果：
使用交叉熵损失计算和手动设计公式计算得到的结果相同。

2.2.3 加权重损失

代码实现：
设计第一个样本的权重为1，后两个样本的权重为2

# ----------------------------------- weight -----------------------------------
# flag = 0
flag = 1
if flag:# def loss functionweights = torch.tensor([1, 2], dtype=torch.float)# weights = torch.tensor([0.7, 0.3], dtype=torch.float)loss_f_none_w = nn.CrossEntropyLoss(weight=weights, reduction='none')loss_f_sum = nn.CrossEntropyLoss(weight=weights, reduction='sum')loss_f_mean = nn.CrossEntropyLoss(weight=weights, reduction='mean')# forwardloss_none_w = loss_f_none_w(inputs, target)loss_sum = loss_f_sum(inputs, target)loss_mean = loss_f_mean(inputs, target)# viewprint("\nweights: ", weights)print(loss_none_w, loss_sum, loss_mean)

输出结果：
注意：在计算平均损失的时候，不再是总损失/3个样本，而是做了一个加权的求平均，第一个样本的权值是1，那就算1个样本，第2,3个样本的权值为2，所以算4个样本，损失的平均值为1.821/5=0.3642。

2.2 nn.NLLLoss

功能：实现负对数似然函数中的负号功能

主要参数：
• weight：各类别的loss设置权值
• ignore_index：忽略某个类别
• reduction:计算模式，可为none/sum/mean
none-逐个元素计算
sum-所有元素求和，返回标量
mean-加权平均，返回标量

2.2.1 代码实现

flag = 1
if flag:weights = torch.tensor([1, 1], dtype=torch.float)loss_f_none_w = nn.NLLLoss(weight=weights, reduction='none')loss_f_sum = nn.NLLLoss(weight=weights, reduction='sum')loss_f_mean = nn.NLLLoss(weight=weights, reduction='mean')# forwardloss_none_w = loss_f_none_w(inputs, target)loss_sum = loss_f_sum(inputs, target)loss_mean = loss_f_mean(inputs, target)# viewprint("\nweights: ", weights)print("NLL Loss", loss_none_w, loss_sum, loss_mean)

输出结果：
该函数只是对输出结果进行添加符号处理

2.3 nn.BCELoss

功能：二分类交叉熵,对每一个神经元一一计算loss
注意事项：输入值取值在[0,1]

主要参数：
• weight：各类别的loss设置权值
• ignore_index：忽略某个类别
• reduction ：计算模式，可为none/sum/mean
none-逐个元素计算
sum-所有元素求和，返回标量
mean-加权平均，返回标量

2.3.1 代码实现

注意：使用该函数，如果输入的值不是0~1之间的数据，需要添加sigmoid函数。

flag = 1
if flag:inputs = torch.tensor([[1, 2], [2, 2], [3, 4], [4, 5]], dtype=torch.float)target = torch.tensor([[1, 0], [1, 0], [0, 1], [0, 1]], dtype=torch.float)target_bce = target# 使用该函数一定要注意，将输出值压缩到0~1之间，使用sigmoid将输入值压缩到0~1之间inputs = torch.sigmoid(inputs)weights = torch.tensor([1, 1], dtype=torch.float)loss_f_none_w = nn.BCELoss(weight=weights, reduction='none')loss_f_sum = nn.BCELoss(weight=weights, reduction='sum')loss_f_mean = nn.BCELoss(weight=weights, reduction='mean')# forwardloss_none_w = loss_f_none_w(inputs, target_bce)loss_sum = loss_f_sum(inputs, target_bce)loss_mean = loss_f_mean(inputs, target_bce)# viewprint("\nweights: ", weights)print("BCE Loss", loss_none_w, loss_sum, loss_mean)

输出结果：
对每一个神经元计算loss

2.4 nn.BCEWithLogitsLoss

功能：结合Sigmoid与二分类交叉熵
注意事项：使用该函数，网络最后不加sigmoid函数
主要参数：
• pos _weight ：正样本的权值
• weight：各类别的loss设置权值
• ignore_index：忽略某个类别
• reduction ：计算模式，可为none/sum/mean
none-逐个元素计算
sum-所有元素求和，返回标量
mean-加权平均，返回标量

2.4.1 代码实现

# ----------------------------------- 4 BCE with Logis Loss -----------------------------------
# flag = 0
flag = 1
if flag:inputs = torch.tensor([[1, 2], [2, 2], [3, 4], [4, 5]], dtype=torch.float)target = torch.tensor([[1, 0], [1, 0], [0, 1], [0, 1]], dtype=torch.float)target_bce = target# inputs = torch.sigmoid(inputs)weights = torch.tensor([1, 1], dtype=torch.float)loss_f_none_w = nn.BCEWithLogitsLoss(weight=weights, reduction='none')loss_f_sum = nn.BCEWithLogitsLoss(weight=weights, reduction='sum')loss_f_mean = nn.BCEWithLogitsLoss(weight=weights, reduction='mean')# forwardloss_none_w = loss_f_none_w(inputs, target_bce)loss_sum = loss_f_sum(inputs, target_bce)loss_mean = loss_f_mean(inputs, target_bce)# viewprint("\nweights: ", weights)print(loss_none_w, loss_sum, loss_mean)

输出结果：

如果再使用sigmoid函数会导致损失函数发生变化，如下：

三、优化器Optimizer

3.1 什么是优化器

机器学习模型训练有以下几个步骤，优化器是在哪一步开始使用呢？
将数据输入到模型当中会得到一个output值，将output值和target目标值放入到损失函数计算损失，损失使用反向传播的方法求出训练过程中每一个参数的梯度，优化器拿到梯度，使用优化策略，减少损失。

3.1.1梯度的概念

pytorch的优化器：管理并更新模型中可学习参数的值，使得模型输出更接近真实标签
导数：函数在指定坐标轴上的变化率
方向导数：指定方向上的变化率
梯度：一个向量，方向为方向导数取得最大值的方向
梯度下降：朝着梯度的负方向取变化，也就是变化最快的

3.2 optimizer的属性

基本属性
• defaults：优化器超参数。
• state：参数的缓存，如momentum的缓存(前几次更新的梯度)。
• params_groups：管理的参数组，list类型中存储的字典类型。
• _step_count：记录更新次数，学习率调整中使用。

3.3 optimizer的方法

3.3.1 zero_grad()

作用：清空所管理参数的梯度。
为什么使用该方法，这是因为pytorch特性：张量梯度不自动清零；

代码实现：

flag = 1
if flag:print("weight before step:{}".format(weight.data))optimizer.step()  # 修改lr=1 0.1观察结果print("weight after step:{}".format(weight.data))print("weight in optimizer:{}\nweight in weight:{}\n".format(id(optimizer.param_groups[0]['params'][0]), id(weight)))# 优化器当中存储的是参数变量的地址print("weight.grad is {}\n".format(weight.grad))optimizer.zero_grad()print("after optimizer.zero_grad(), weight.grad is\n{}".format(weight.grad))

输出结果：
通过输出可以看出优化器当中存储的是参数变量的地址，不需要额外使用内存保存梯度；

3.3.2 step()

作用：执行一步更新

代码实现：

import osBASE_DIR = os.path.dirname(os.path.abspath(__file__))
import torch
import torch.optim as optim
from common_tools import set_seedset_seed(1)  # 设置随机种子weight = torch.randn((2, 2), requires_grad=True)
weight.grad = torch.ones((2, 2))  # 手动设置梯度为1optimizer = optim.SGD([weight], lr=1)
# optimizer = optim.SGD([weight], lr=0.1)# ----------------------------------- step -----------------------------------
# flag = 0
flag = 1
if flag:print("weight before step:{}".format(weight.data))optimizer.step()  # 梯度下降方法 观察结果 输入-梯度=输出print("weight after step:{}".format(weight.data))

结果输出：
当我们设置梯度为1，学习率为1的时候，输出结果=输入数据-梯度；

当我们设置梯度为1，学习率为0.1的时候，输出结果=输入数据-梯度；

3.3.3 add_param_group()

作用：添加参数组
对于不同的组有不同的超参数设置，例如一个深度学习模型，我们对特征提取模块的学习率设置小一些，让它更新慢一点，在全连接层可以设置学习率大一些。

代码实现：

flag = 1
if flag:print("optimizer.param_groups is\n{}".format(optimizer.param_groups))w2 = torch.randn((3, 3), requires_grad=True)optimizer.add_param_group({"params": w2, 'lr': 0.0001})print("optimizer.param_groups is\n{}".format(optimizer.param_groups))

输出结果：
将一个新的参数组

3.3.4 state_dict()

作用：获取优化器当前状态信息字典
当我们训练需要中断的时候可以使用该方法，将当前训练的参数保存下来。

代码实现：

flag = 1
if flag:optimizer = optim.SGD([weight], lr=0.1, momentum=0.9)opt_state_dict = optimizer.state_dict()print("state_dict before step:\n", opt_state_dict)for i in range(10):optimizer.step()  # 更新参数print("state_dict after step:\n", optimizer.state_dict())torch.save(optimizer.state_dict(), os.path.join(BASE_DIR, "optimizer_state_dict.pkl"))  # 将当前state_dict保存成为序列化信息

输出结果：
将10次step的结果保存在optimizer_state_dict.pkl当中，同时会在当前文件夹生成一个新的文件。

3.3.5 load_state_dict()

作用：加载状态信息字典
用于读取上一次训练所保存的参数；

代码实现：

flag = 1
if flag:optimizer = optim.SGD([weight], lr=0.1, momentum=0.9)state_dict = torch.load(os.path.join(BASE_DIR, "optimizer_state_dict.pkl"))#首先加载进来训练参数print("state_dict before load state:\n", optimizer.state_dict())optimizer.load_state_dict(state_dict) #将训练参数添加到优化器当中print("state_dict after load state:\n", optimizer.state_dict())

输出结果：

3.3 梯度下降

对y=4$x^2$使用梯度下降的方法更新参数，使其到达最低点，发现在计算到第三次的时候，y的值变的很大，并没有减少参数，反而变的更大。

代码实现：

import torch
import numpy as np
import matplotlib.pyplot as plttorch.manual_seed(1)def func(x_t):"""y = (2x)^2 = 4*x^2      dy/dx = 8x"""return torch.pow(2 * x_t, 2)  # 求平方# init
x = torch.tensor([2.], requires_grad=True)# ------------------------------ 绘制函数基本曲线图 ------------------------------
flag = 0
# flag = 1
if flag:x_t = torch.linspace(-3, 3, 100)y = func(x_t)plt.plot(x_t.numpy(), y.numpy(), label="y = 4*x^2")plt.grid()plt.xlabel("x")plt.ylabel("y")plt.legend()plt.show()# 横轴设为参数x，纵轴设置为y# ------------------------------ gradient descent ------------------------------
# flag = 0
flag = 1
if flag:iter_rec, loss_rec, x_rec = list(), list(), list()  # 记录迭代次数和损失lr = 1  # 学习率/1. /.5 /.2 /.1 /.125max_iteration = 4  # 设置最大迭代次数for i in range(max_iteration):y = func(x)y.backward()  # 求取x的梯度print("Iter:{}, X:{:8}, X.grad:{:8}, loss:{:10}".format(i, x.detach().numpy()[0], x.grad.detach().numpy()[0], y.item()))x_rec.append(x.item())x.data.sub_(lr * x.grad)  # x -= x.grad  数学表达式意义:  x = x - x.grad    # 0.5 0.2 0.1 0.125x.grad.zero_()iter_rec.append(i)loss_rec.append(y.item())# plt.subplot(121).plot(iter_rec.detach().numpy(), loss_rec.detach().numpy(), '-ro')plt.subplot(121).plot(iter_rec, loss_rec, '-ro')plt.xlabel("Iteration")plt.ylabel("Loss value")x_t = torch.linspace(-3, 3, 100)y = func(x_t)plt.subplot(122).plot(x_t.numpy(), y.numpy(), label="y = 4*x^2")plt.grid()y_rec = [func(torch.tensor(i)).item() for i in x_rec]plt.subplot(122).plot(x_rec, y_rec, '-ro')plt.legend()plt.show()

输出结果：

当学习率设置为1，通过输出结果可以发现，随着迭代次数的增加，数值更新的步伐越大，损失值越大。那么如何解决这个问题呢。

3.4 学习率

通过设置学习率可以控制每次梯度下降的更新步伐大小。

代码展示：

输出结果：

当学习率设置过小为0.01时，10次迭代结果如下，会发现需要迭代多长才能梯度下降到最优值：

3.5 多尺度学习率实验

经过上次两次会发现学习率过大或者过小都不合适，那么如何找到一个最优的学习率可以提高梯度下降的速率？
使用多尺度学习率做测试，选取学习率区间0.01~0.2，在该区间划分10个等间距的学习率进行实验。

代码实现：

flag = 1
if flag:iteration = 100num_lr = 10lr_min, lr_max = 0.01, 0.2  # .5 .3 .2lr_list = np.linspace(lr_min, lr_max, num=num_lr).tolist()  # 生成num_lr个等间距的数组loss_rec = [[] for l in range(len(lr_list))]# iter_rec = list()for i, lr in enumerate(lr_list):x = torch.tensor([2.], requires_grad=True)for iter in range(iteration):y = func(x)y.backward()x.data.sub_(lr * x.grad)  # x.data -= x.gradx.grad.zero_()loss_rec[i].append(y.item())for i, loss_r in enumerate(loss_rec):plt.plot(range(len(loss_r)), loss_r, label="LR: {}".format(lr_list[i]))plt.legend()plt.xlabel('Iterations')plt.ylabel('Loss value')plt.show()

实验结果：

通过实验结果发现，当学习率在0.136的时候，此时会更快降低损失，y的值更快到达最小值。

3.6 momentum动量

结合当前梯度与上一次更新信息，用于当前更新
优化器中的momentum是指动量（Momentum），它是一种在优化算法中常用的技术，用于加速参数的更新。动量是在每次更新参数时，将之前的一次更新作为一部分权重加入到当前的更新中，从而使得参数的更新更加平滑，减少了震荡。
在优化过程中，优化器会根据损失函数和模型参数计算梯度。但是，由于模型参数可能存在多个局部最小值，优化器可能会在损失函数曲面上跳跃式地移动，导致参数更新剧烈，甚至出现震荡。动量技术通过引入历史更新信息，使得优化器能够更好地平滑地移动到最优解，从而减少了震荡和过拟合的风险。
在PyTorch等深度学习框架中，优化器通常会内置动量参数，用户只需要在创建优化器时指定学习率和优化器类型，框架会自动计算动量值并应用于优化过程。

3.6.1 指数加权平均

首先了解一下指数加权平均，数学思想：要求取当前时刻的平均值，距离当前时刻越近的参数值，参考价值越大，所占的权重越大，这个权重随着时间间隔的增大呈指数下降。

代码实现：

import torch
import numpy as np
import torch.optim as optim
import matplotlib.pyplot as plt
torch.manual_seed(1)
def exp_w_func(beta, time_list):return [(1 - beta) * np.power(beta, exp) for exp in time_list]
beta = 0.9
num_point = 100
time_list = np.arange(num_point).tolist()
# ------------------------------ exponential weight ------------------------------
# flag = 0
flag = 1
if flag:weights = exp_w_func(beta, time_list)plt.plot(time_list, weights, '-ro', label="Beta: {}\ny = B^t * (1-B)".format(beta))plt.xlabel("time")plt.ylabel("weight")plt.legend()plt.title("exponentially weighted average")plt.show()print(np.sum(weights))

实现结果：

通过代码实现可以看出，距离当前时刻越远，它对当前时刻的平均值越小。

---

当设置多个beta值的实验结果如下：

flag = 1
if flag:beta_list = [0.98, 0.95, 0.9, 0.8] #设置4中不同的beta w_list = [exp_w_func(beta, time_list) for beta in beta_list]for i, w in enumerate(w_list):plt.plot(time_list, w, label="Beta: {}".format(beta_list[i]))plt.xlabel("time")plt.ylabel("weight")plt.legend()plt.show()

通过实验可以看出，beta 可以理解为记忆周期，当beta值越小，记忆周期越短，beta=0.8时，当到达20天的时候就不再关注远期的一个记忆值；beta值越大，记忆周期也就越长。

3.6.2 加Momentum更新公式

添加momentum更新之后的公式不仅仅只考虑当前的梯度，还要考虑上一次更新梯度乘以m的值，以及上上次梯度*$m^2$…，距离当前时刻越远的值，对当前的影响越小，因为m是个小于1的数。

3.6.3 momentum实验

实验一：设置momentum为0，学习率分别为0.01和0.03时函数收敛速率。
代码：

flag = 1
if flag:def func(x):return torch.pow(2 * x, 2)  # y = (2x)^2 = 4*x^2        dy/dx = 8xiteration = 100m = 0.0  # .9 .63lr_list = [0.01, 0.03]momentum_list = list()loss_rec = [[] for l in range(len(lr_list))]iter_rec = list()for i, lr in enumerate(lr_list):x = torch.tensor([2.], requires_grad=True)momentum = 0. if lr == 0.03 else mmomentum_list.append(momentum)optimizer = optim.SGD([x], lr=lr, momentum=momentum)for iter in range(iteration):y = func(x)y.backward()optimizer.step()optimizer.zero_grad()loss_rec[i].append(y.item())for i, loss_r in enumerate(loss_rec):plt.plot(range(len(loss_r)), loss_r, label="LR: {} M:{}".format(lr_list[i], momentum_list[i]))plt.legend()plt.xlabel('Iterations')plt.ylabel('Loss value')plt.show()

实验结果：

实验结果分析：因为黄色部分学习率更高，所以收敛的速率比较快。

---

实验二：设置学习率0.01时，momentum为0.9
实验结果如下：

实验结果分析：虽然0.01的学习率比较低，但是添加momentum之后收敛速率增加；为什么会出现波浪？因为在收敛到最小值的时候仍然保留着之前的权重，所以没法快速收敛到一个平稳值。

4.SGD优化器

• params：管理的参数组
• lr：初始学习率
• momentum：动量系数，贝塔
• weight_decay：L2正则化系数
• nesterov：是否采用NAG

四、常见的其他优化器

1. optim.SGD：随机梯度下降法
2. optim.Adagrad：自适应学习率梯度下降法
3. optim.RMSprop： Adagrad的改进
4. optim.Adadelta： Adagrad的改进
5. optim.Adam：RMSprop结合Momentum
6. optim.Adamax：Adam增加学习率上限
7. optim.SparseAdam：稀疏版的Adam
8. optim.ASGD：随机平均梯度下降
9. optim.Rprop：弹性反向传播
10. optim.LBFGS：BFGS的改进