【AI】Pytorch_损失函数&优化器

原创 已于 2024-09-06 00:58:27 修改 · 2.1k 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#人工智能 #pytorch #python

于 2024-09-03 21:51:28 首次发布

建议点赞收藏关注！持续更新至pytorch大部分内容更完。
本文已达到10w字，故按模块拆开，详见目录导航。

整体框架如下
数据及预处理
模型及其构建
损失函数及优化器

本节目录

损失函数

损失函数loss，代价函数cost，目标函数objective
在这里插入图片描述
交叉熵=信息熵+相对熵
(1)熵用来描述一个事件的不确定性，不确定性越大则熵越大.
(2)信息熵是自信息的期望，自信息用于衡量单个输出单个事件的不确定性.
(3)相对熵又叫做KL散度，用于衡量两个分布之间的差异，即两个分布之间的距离，但不是距离的函数，不具备对称性。
下图公式中都是，P是真实的分布，Q是模型输出的分布，Q需要逼近、拟合P的分布.
(4)交叉熵用于衡量两个分布之间的相似度.
(5)P是真实的分布，即训练集中样本的分布。由于训练集是固定的，概率分布也是固定的，H§是个常数.故优化交叉熵等价于优化相对熵。
在这里插入图片描述

在这里插入图片描述
上图是一个伯努利分布，可以发现当概率是0.5时熵最大（为0.69），0.69这个数字经常会碰到：模型训练坏了、模型的训练第一个iteration，此时不具备判断能力，因为对于任何输出判别的概率都是1/2。

创建损失函数 （共18个）

nn.CrossEntropyLoss

nn.CrossEntropyLoss(weight=None, ignore_index=- 100,  reduction='mean' )
'''
size_average=None, reduce=None,这俩个参数已废弃
weight:各类别loss设置权值
ignore_index:忽略某个类别而不计算它的loss
reduction:计算模式，可为none/sum/mean
none 逐个元素计算这么多个loss
sum 所有元素求和，返回标量
mean 加权平均，返回标量
'''

交叉熵这里的不是按照书中公式所计算的，这里其实是nn.LogSoftmax()与nn.NLLLoss()结合进行计算的。它采用softmax对数据进行了归一化，把数据值归一化到概率输出的形式。交叉熵损失函数常常用于分类任务中。交叉熵是衡量两个概率分布之间的差异，交叉熵值越低，表示两个概率分布越近。
运用softmax可以将输出值转换归一化到0～1之间作为概率。
在这里插入图片描述
首先上图 这里x是输出的一个概率值，class是一个类别值。
第二式中的(分式)就是softmax的公式，对比第一式即交叉熵公式，可知 这个xi是已经取到的，所以p(xi)=1，并且第二式只是计算其中一个的交叉熵，故也没有N项求和符号。
当调用这个方法时传入了weight参数，则计算公式为第三式

# fake data
#二分类任务，输出神经元2个，batchsize是3，即三个样本：[1,2] [1,3] [1,3]
inputs = torch.tensor([[1, 2], [1, 3], [1, 3]], dtype=torch.float)
#dtype必须是long，有多少个样本，tensor（1D）就有多长。而且这里的类别label也是从0开始标号的
target = torch.tensor([0, 1, 1], dtype=torch.long)

# ----------------------------------- 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)
    #输出为[1.3133, 0.1269, 0.1269] 1.5671 0.5224
    
# --------------------------------- compute by hand
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]

    # 第二项 map指对其每一个神经元进行运算
    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)


# ----------------------------------- weight -----------------------------------
flag = 0
# flag = 1
if flag:
    # def loss function
'''
有多少个类别weights这个向量就要设置多长，
每一个类别都必须设置weight，
如果不想关注这个weight，就将其设置为1就不会变的。

如果类别是mean，则每个weight数值多大不重要，重要在于他们之间的比例。

结果可以看出来，原先得到的loss基础上，如果数据label==0则用weight[0]=1倍，故与之前相等。而label==1的后两个数据的loss变成了之前的2倍(因为weight==2)

在sum模式下，weight==2也代表label==1的这一个数据就占两份1在分母中，在本例中为 三个数据loss之和/(1+2+2)
'''
    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)
    #权值为[1,2],则输出[1.3133, 0.2539, 0.2539] 1.8210 0.3642
    # target=[0,1,1]所以对应0的需要乘以权值1，对应1的需要乘以权值2.
    # 1.3133是1.3133*1=1.3133，0.2530是0.1269*2=0.2539，0.2530是0.1269*2=0.2539.
    #0.3642是1.8210/(1+2+2)=0.3642，分母是权值的份数（5）.


# --------------------------------- compute by hand ：手动计算
flag = 0
# flag = 1
if flag:
    weights = torch.tensor([1, 2], dtype=torch.float)
    #weights_all=5 计算sum公式中除掉的分母，份数
    weights_all = np.sum(list(map(lambda x: weights.numpy()[x], target.numpy())))  # [0, 1, 1] ---> # [1 2 2]

    mean = 0
    loss_sep = loss_none.detach().numpy()
    for i in range(target.shape[0]):
#输出每一个样本在这平均值loss中贡献的数目
        x_class = target.numpy()[i]
        tmp = loss_sep[i] * (weights.numpy()[x_class] / weights_all)
        mean += tmp

    print(mean)

nn.NLLLoss

nn.NLLLoss(weight=None, size_average=None, ignore_index=- 100, reduce=None, reduction='mean')
'''
实现负对数似然函数中的负号功能，简单来说就是取负号
'''

# fake data
#二分类任务，输出神经元2个，batchsize是3，即三个样本：[1,2] [1,3] [1,3]
inputs = torch.tensor([[1, 2], [1, 3], [1, 3]], dtype=torch.float)
#dtype必须是long，有多少个样本，tensor（1D）就有多长。
target = torch.tensor([0, 1, 1], dtype=torch.long)

# ----------------------------------- 2 NLLLoss -----------------------------------
flag = 0
# 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("NLL Loss", loss_none_w, loss_sum, loss_mean)
    #输出[-1,-3,-3] -7 -2.3333
    # target[0, 1, 1]
    #-1是因为第一个样本[1,2]是第0类，因此只对第一个神经元输出操作：-1*1。
    #-3是因为第二个样本[1,3]是第1类，因此只对第二个神经元输出操作：-1*3。
    #-3是因为第三个样本[1,3]是第1类，因此只对第二个神经元输出操作：-1*3。
    #求mean时的分母是权重weight的和。

BCE Loss

xn是模型输出的概率取值，yn是标签（二分类中对应0或1）。
在这里插入图片描述

nn.BCELoss(weight=None, size_average=None, reduce=None, reduction='mean')
'''
二分类交叉熵损失函数
注意：输入值取值在[0,1]，利用sigmoid函数可实现
'''

# ----------------------------------- 3 BCE Loss -----------------------------------
flag = 0
# flag = 1
if flag:
#同样是二分类，每个样本有两个神经元
    inputs = torch.tensor([[1, 2], [2, 2], [3, 4], [4, 5]], dtype=torch.float) #4个样本
    target = torch.tensor([[1, 0], [1, 0], [0, 1], [0, 1]], dtype=torch.float) #float类型，每个神经元一一对应去计算loss，而不是之前是整个向量去计算loss

    target_bce = target

    #一定要加上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)
    #输出[[0.3133, 2.1269], [0.1269, 2.1269], [3.0486, 0.0181], [4.0181, 0.0067]] 11.7856 1.4732
    #每个神经元一一对应去计算loss,因此loss个数是2*4=8个


# --------------------------------- compute by hand
flag = 0
# flag = 1
if flag:

    idx = 0

    x_i = inputs.detach().numpy()[idx, idx]
    y_i = target.numpy()[idx, idx]              #

    # loss
    # l_i = -[ y_i * np.log(x_i) + (1-y_i) * np.log(1-y_i) ]      # np.log(0) = nan
    l_i = -y_i * np.log(x_i) if y_i else -(1-y_i) * np.log(1-x_i)

    # 输出loss
    print("BCE inputs: ", inputs)
    print("第一个loss为: ", l_i) #0.3133

BCEwithLogitsLoss

在这里插入图片描述
σ是sigmoid函数

nn.BCEWithLogitsLoss(weight=None, size_average=None, reduce=None, reduction='mean', pos_weight=None)
'''
结合sigmoid与二分类交叉熵
注意：网络最后不要加sigmoid函数，再加这个值就不准确了

这个损失函数存在的原因：有的时候不希望模型里有sigmoid在最后一层。

多了一个参数pos_weight 正样本权值
（1）pos_weight用于均衡正负样本，正样本的loss需要乘以pos_weight。
比如正样本100个，负样本300个，此时可以将pos_weight设置为3，就可以实现正负样本均衡。
（2）pos_weight里是一个tensor列表，需要和标签个数相同，比如现在有一个多标签分类，类别有200个，那么 pos_weight 就是为每个类别赋予的权重值，长度为200
（3）如果现在是二分类，只需要将正样本loss的权重写上即可，比如我们有正负两类样本，正样本数量为100个，负样本为400个，我们想要对正负样本的loss进行加权处理，将正样本的loss权重放大4倍，通过这样的方式缓解样本不均衡问题：

'''
criterion = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([4]))


# ----------------------------------- 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) 不能加sigmoid！！！

    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)
    #输出[[0.3133, 2.1269], [0.1269, 2.1269], [3.0486, 0.0181], [4.0181, 0.0067]] 11.7856 1.4732

# --------------------------------- pos weight

# 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

    # itarget
    # inputs = torch.sigmoid(inputs)

    weights = torch.tensor([1], dtype=torch.float)

    #pos_w = torch.tensor([1], dtype=torch.float)  #设置为1时，loss输出与原先一致。
    pos_w = torch.tensor([3], dtype=torch
最低0.47元/天 解锁文章

200万优质内容无限畅学
详解pytorch的损失函数、优化器、embedding
weixin_43178406的博客
03-29 663
本文主要介绍了pytorch的损失函数、优化器、embedding，希望能对学习pytorch的同学有所帮助。 文章目录 1. softmax问题 2. pytorch都有哪些损失函数 3. 优化器 4. embedding 5. 使用GPU 6. tensor与numpy相互转化 6.1 tensor转numpy 6.2 numpy转tensor
PyTorch学习笔记（6）损失函数与优化器
游星的博客
08-20 519
损失函数与优化器初体验
pytorch的损失函数和优化器
m0_45827246的博客
01-06 1933
1. 损失函数 pytorch的损失函数可以调用torch.nn.functional库中的函数，通过传入神经网络预测值和目标值来计算损失函数；也可以使用torch.nn中的模块，新建一个模块实例，通过调用相关的模块计算最终的损失函数。 训练数据一般是以迷你批次的形式输入神经网络，最后预测的值也是迷你批次的形式输出，但实际上损失函数的输出结果应该是一个标量张量。所以，对于迷你批次的归约，一种方法是对迷你批次的损失函数求和，另一种是对迷你批次的损失函数求平均。一般默认的是对迷你批次的损失函数求平均。 对于回归
PyTorch入门（七）：神经网络模型—损失函数、优化器、以及网络模型的读取保存
最新发布
记录学习的博客
07-03 648
神经网络模型—损失函数、优化器、以及网络模型的读取保存
【pytorch】损失函数和优化器
m0_51332973的博客
12-23 454
损失函数MSE 均方差损失 用 torch.nn.MSELoss() 表示 import torch import torch.nn as nn # 初始化数据集 X = torch.tensor([1, 2, 3, 4], dtype=torch.float32) Y = torch.tensor([2, 4, 6, 8], dtype=torch.float32) w = torch.tensor(0.0, dtype=torch.float32, requires_grad=True)#这里只有一个
pytorch损失函数与优化器
weixin_44853840的博客
05-09 742
目录损失函数优化器模型建立总结 损失函数 torch.nn 中存在很多封装好的损失函数。比如均方差损失，用 torch.nn.MSELoss() 表示。 import torch import torch.nn as nn # 初始化数据集 X = torch.tensor([1, 2, 3, 4], dtype=torch.float32) Y = torch.tensor([2, 4, 6, 8], dtype=torch.float32) w = torch.tensor(0.0, dtype=to
【PyTorch】第五节：损失函数与优化器
荷叶田田的博客
04-14 925
在上一节实验中，我们初步完成了梯度下降算法求解线性回归问题的实例。在这个过程中，我们自己定义了损失函数和权重的更新，其实PyTorch 也为我们直接定义了相应的工具包，使我们能够简洁快速的实现损失函数、权重的更新和梯度的求解。
PyPI 官网下载 | pytorch_toolbelt-0.3.0.tar.gz
02-10
2. **训练和评估辅助工具**：例如，优化器配置，损失函数，以及训练和验证循环的便捷实现，帮助用户快速搭建和调整模型。 3. **可视化和日志记录**：工具包可能集成TensorBoard或其他可视化工具，以便于监控训练...
PyTorch_tutorial_余霆嵩
01-08
PyTorch提供了多种优化算法，如SGD（随机梯度下降）、Adam、RMSprop等，这些优化器负责更新网络的权重和偏置，以最小化损失函数。 **数据加载(DataLoader)** 在处理大规模数据集时，DataLoader类用于加载和预处理...
深度学习pytorch——激活函数&损失函数（持续更新）
2201_76139143的博客
03-22 2585
论生物神经元与神经网络中的神经元联系——为什么使用激活函数？我们将生物体中的神经元与神经网络中的神经元共同分析。从下图可以看出神经网络中的神经元与生物体中的神经元有很多相似之处，由于只有刺激达到一定的程度人体才可以感受到刺激，并且人体对刺激做出的响应是有限的，所以在输出之前应该经过激活函数。这个激活函数可以将原来发散的数据变成收敛的数据。什么是梯度？函数在某一点的梯度是这样一个向量，它的方向与的方向一致，而它的模为方向。
d2lzh_pytorch_深度学习_pytorch_d2lzh_pytorch下载_deeplearning_d2lzh_py
09-11
优化器如SGD、Adam等，用于更新网络权重以最小化损失函数，实现模型的训练。 7. **损失函数** 损失函数衡量模型预测与真实结果的差异，常见的有交叉熵损失、均方误差等。PyTorch内置了多种损失函数，可直接在模型...
Pytorch学习笔记--损失函数以及优化器的使用
aaaax__的博客
10-09 557
输出结果为：tensor(0.6667) #（（1-1）+（2-2）+（5-3））/2。2.为我们更新输出提供一定的依据（反向传播）1.计算实际输出和目标之间的差距。
pytorch损失函数、反向传播、优化器【小土堆】
superiser的博客
02-07 1898
（链接可以直接跳转）
pytorch常见的损失函数和优化器
weixin_50752408的博客
03-19 986
是学习率（learning rate）的缩写，是指在每次参数更新时，更新的幅度大小。学习率的选择是机器学习中的一个重要问题，它决定了模型在训练过程中参数更新的速度和稳定性，对模型的性能和训练效率都有重要影响。通常情况下，选择合适的学习率需要根据具体的模型和数据集进行调参，可以通过尝试不同的学习率来找到最佳的取值。是一个方法，用于获取一个模型中需要更新的参数。在PyTorch中，模型通常是由多个层（如全连接层、卷积层等）组成的，每个层都有自己的权重和偏置，这些权重和偏置是需要在训练过程中不断调整的。
Pytorch系列之——损失函数、优化器
Despacito1006的博客
09-06 1231
权值初始化 前面我们介绍了如何搭建网络模型，在模型搭建好之后一个非常重要的步骤就是对模型当中的权值进行初始化。正确的权值初始化可以加快模型的收敛，而不恰当的权值初始化可能会引发梯度的消失或爆炸，最终导致模型无法训练。 梯度消失与爆炸 Xavier方法与Kaiming方法 常用初始化方法 梯度消失与爆炸 首先观察模型是怎么对W2进行求导的，我们有： H2=H1∗W2 H_{2} = H_{1} * W_{2}H2​=H1​∗W2​ ΔW2=∂Loss∂out∗∂out∂H2∗∂H2∂w2=∂Loss∂o
PyTorch优化函数
远方
03-08 1544
PyTorch优化器导入 文章目录一、导入PyTorch二、定义模型三、导入优化器导入优化器1 :梯度下降法SGD导入优化器2 :SGD+momentum导入优化器3 :Adagrad导入优化器4 :RMSprop导入优化器5 :Adadelte导入优化器6 :Adam 一、导入PyTorch import torch import torch.nn as nn 二、定义模型 net = nn....
pytorch 神经网络的优化函数
qq_43349542的博客
04-10 392
下面展示优化函数的 使用代码。 // optimizer import torch import torch.utils.data as Data import matplotlib.pyplot as plt #超参数 LR = 0.01 BATCH_SIZE = 32 EPOCH = 12 #生成伪数据 x=torch.unsqueeze(torch.linspace(-1,1,1000),dim= 1) # x data (tensor) ,shape=(100,1) y = x.pow(2) +
4_损失函数和优化器
m0_74357009的博客
08-04 1223
常见的损失函数包括均方误差（Mean Squared Error, MSE）、交叉熵损失（Cross Entropy Loss）、对数损失（Log Loss）等，具体选择哪种损失函数取决于问题的类型和输出的形式。在监督学习任务中，我们通常希望模型的预测尽可能接近真实的目标值。反向传播是一种有效的训练神经网络的方法，它利用链式法则计算损失函数对每个模型参数的梯度，并根据梯度更新参数。用于优化神经网络模型的库，它的主要作用是实现各种优化算法，帮助模型在训练过程中更新参数以最小化损失函数。有需要可以自己查用法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

七灵微

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值