pytorch07：损失函数与优化器

一、损失函数是什么

从下面的一元函数可以看出，直线拟合的点和真实值之间存在误差，这个误差就是损失函数。
损失函数：计算一个样本的差异。
代价函数：样本数据集所有损失的平均值。
目标函数：代价函数+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: str

    def __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 function
    loss_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')  # 求损失的平均值

    # forward
    loss_none = loss_f_none(inputs, target)
    loss_sum = loss_f_sum(inputs, target)
    loss_mean = loss_f_mean(inputs, target)

    # view
    print("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)

    # 输出loss
    loss_1 = -x_class + log_sigma_exp_x

    print("第一个样本loss为: ", loss_1)

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

2.2.3 加权重损失

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

# ----------------------------------- weight -----------------------------------
# flag = 0
flag = 1
if flag:
    # def loss function
    weights = 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')

    # forward
    loss_none_w = loss_f_none_w(inputs, target)
    loss_sum = loss_f_sum(inputs, target)
    loss_mean = loss_f_mean(inputs, target)

    # view
    print("\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')

    # forward
    loss_none_w = loss_f_none_w(inputs, target)
    loss_sum = loss_f_sum(inputs, target)
    loss_mean = loss_f_mean(inputs, target)

    # view
    print("\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')
    # forward
    loss_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)

    # view
    print("\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')

    # forward
    loss_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)

    # view
    print("\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 os

BASE_DIR = os.path.dirname(os.path.abspath(__file__))
import torch
import torch.optim as optim
from common_tools import set_seed

set_seed(1)  # 设置随机种子

weight = torch.randn((2, 2), requires_grad=True)
weight.grad = torch.ones((2, 2))  # 手动设置梯度为1

optimizer = 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 plt

torch.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 /.125
    max_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.125
        x.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 = 100
    num_lr = 10
    lr_min, lr_max = 0.01, 0.2  # .5 .3 .2

    lr_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.grad
            x.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 = 8x


    iteration = 100
    m = 0.0  # .9 .63

    lr_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 m
        momentum_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的改进