pytorch07:损失函数与优化器

2024-01-08 10:54:22

在这里插入图片描述

一、损失函数是什么

从下面的一元函数可以看出,直线拟合的点和真实值之间存在误差,这个误差就是损失函数。
损失函数:计算一个样本的差异。
代价函数:样本数据集所有损失的平均值。
目标函数:代价函数+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 x^2 x2使用梯度下降的方法更新参数,使其到达最低点,发现在计算到第三次的时候,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^2 m2…,距离当前时刻越远的值,对当前的影响越小,因为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的改进

文章来源:https://blog.csdn.net/J_oshua/article/details/135372256
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。