pytorch的八种损失函数测试

最新推荐文章于 2024-09-05 16:09:42 发布
最新推荐文章于 2024-09-05 16:09:42 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： Pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41487299/article/details/106295085
版权

1 L1Loss
创建一个标准来测量标准中每个元素之间的平均绝对误差（MAE）输入：math：x和目标：mat​​h：y
在这里插入图片描述
where :math:N is the batch size. If :attr:reduction is not 'none'(default 'mean')

import torch.nn as nn
import torch
lossfun=nn.L1Loss()
input=torch.randn(3,5,requires_grad=True)
print(input)
target=torch.randn(3,5)
print(target)
output=lossfun(input,target)
print(output)

输出：

tensor([[ 0.7341,  0.8461,  0.4790, -0.9401, -0.4948],
        [-0.2035, -0.9376,  1.4283, -0.6767, -0.8932],
        [-0.7168,  0.5816, -0.7438,  0.7729, -1.3174]], requires_grad=True)
tensor([[ 0.5610, -0.6015, -1.0363, -0.8383, -0.7778],
        [-0.3118, -0.0527,  1.6309, -0.1973, -0.9312],
        [-0.2851,  1.9037,  0.1077, -0.2446,  0.4352]])
tensor(0.7073, grad_fn=<L1LossBackward>)

由此我们可以看出L1损失函数的输入和输出的维度是相同的，是直接使用两个向量的对应的元素想减得到最后的误差，例如 |x1-y1|。

2、NLLLoss

负对数似然损失。用C类训练分类问题很有用。这里的C是分类数目。
在这里插入图片描述

m=nn.LogSoftmax(dim=1)
loss=nn.NLLLoss()
input=torch.randn(3,5,requires_grad=True)
print(input)
target=torch.tensor([1,0,4])
print(m(input))
output=loss(m(input),target)
print(output)

输出：

tensor([[-0.0511,  0.8704, -0.8625, -0.1377,  1.0202],
        [ 0.7554, -0.1908,  0.2453, -0.0432,  1.4448],
        [-0.3516, -0.2297,  0.1724,  0.3413, -1.3402]], requires_grad=True)
tensor([[-2.0533, -1.1318, -2.8647, -2.1399, -0.9820],
        [-1.4887, -2.4349, -1.9988, -2.2872, -0.7992],
        [-1.8230, -1.7010, -1.2990, -1.1300, -2.8115]],
       grad_fn=<LogSoftmaxBackward>)
tensor(1.8107, grad_fn=<NllLossBackward>)

LogSoftmax就是输入数据在softmax之后取一个对数，输出的数值都在0~1之间，求的是一个概率。
NLLLoss的结果就是把上面的输出与Label对应的那个值拿出来，再将取出的值去掉负号，再求均值。
注意以上的“与Label对应的那个值”指的是位置的对应，而不是数值上的接近。
如上的的标签为（1,0,4），就分别取出第一行的第二个数，第二行的第一个数，第三行的第五个数。即（1.1318+1.4887+2.8115）/3=1.8107。

3、PoissonNLLLoss

目标的泊松分布具有负对数似然损失。
在这里插入图片描述

loss=nn.PoissonNLLLoss()
log_input=torch.randn(5,2,requires_grad=True)
print(log_input)
target=torch.randn(5,2)
print(target)
output=loss(log_input,target)
print(output)

输出：

tensor([[ 1.1679, -0.0214],
        [-0.8557, -0.0265],
        [ 0.9068,  0.7410],
        [ 2.1148, -0.3213],
        [-0.1708, -1.1462]], requires_grad=True)
tensor([[-0.2232,  0.8796],
        [-0.1447, -1.0068],
        [ 0.7258, -1.8143],
        [-1.0545,  1.1487],
        [-0.9435, -1.4581]])
tensor(2.1924, grad_fn=<MeanBackward1>)

查看实现源码之后，还是没能知道具体的实现步骤，发现如上申明的PoissonNLLLoss 中的计算代码时：
loss = torch.exp(input) - target * input
ret = torch.mean(loss)
如有知晓具体解答过程的，望解答。

4、KLDivLoss

KL散度，也叫相对熵，是用于连续分布的有用距离度量，并且在对（离散采样）连续输出分布的空间进行直接回归时通常很有用。
在这里插入图片描述
主要参数reduction中，除了经典的三个以外，还多出了batchmean这一选项，如果给reduction赋值为’batchmean’，那么就代表着在batchsize维度求平均值（就是计算得到的每一个元素的损失全部加起来之后除以batchsize，而不是mean计算方法下的元素个数）。

inputs=torch.tensor([[0.5,0.3,0.2],[0.2,0.3,0.5]])
target=torch.tensor([[0.9,0.05,0.05],[0.1,0.7,0.2]],dtype=torch.float)
loss_f_none=nn.KLDivLoss(reduction='none')
loss_f_mean=nn.KLDivLoss(reduction='mean')
loss_f_bs_mean=nn.KLDivLoss(reduction='batchmean')
loss_none=loss_f_none(inputs,target)
loss_mean=loss_f_mean(inputs,target)
loss_bs_mean=loss_f_bs_mean(inputs,target)
print("loss_none:\n{}\nloss_mean:\n{}\nloss_bs_mean:\n{}".format(loss_none, loss_mean, loss_bs_mean))

输出：

loss_none:
tensor([[-0.5448, -0.1648, -0.1598],
        [-0.2503, -0.4597, -0.4219]])
loss_mean:
-0.3335360586643219
loss_bs_mean:
-1.000608205795288

5、MSELoss

创建一个标准来测量输入：math：x和目标：mat​​h：`y中每个元素之间的均方误差（L2范数平方）在这里插入图片描述

lossfun=nn.MSELoss()
lossfun1=nn.MSELoss(reduction='none')
input=torch.randn(3,5,requires_grad=True)
print(input)
target=torch.randn(3,5)
print(target)
output=lossfun(input,target)
print(output)
output=lossfun1(input,target)
print(output)

输出：

tensor([[-1.0748, -0.7300, -0.7085,  1.4914,  1.5150],
        [ 0.7312, -1.6615,  0.8111,  1.7772,  1.0513],
        [ 0.9700, -0.7969, -1.0133, -0.5023,  0.3190]], requires_grad=True)
tensor([[-1.6405,  1.9781, -0.7997, -1.3708, -1.4618],
        [ 0.0414,  0.5810, -0.1028,  0.4886, -0.3905],
        [-0.2697,  1.0235, -1.3026,  3.2425, -0.2109]])
tensor(3.6022, grad_fn=<MseLossBackward>)
tensor([[3.2006e-01, 7.3339e+00, 8.3100e-03, 8.1922e+00, 8.8612e+00],
        [4.7579e-01, 5.0289e+00, 8.3517e-01, 1.6605e+00, 2.0787e+00],
        [1.5369e+00, 3.3140e+00, 8.3715e-02, 1.4023e+01, 2.8076e-01]],
       grad_fn=<MseLossBackward>)

第三个输出的reduction为默认的“mean”，给第四个输出取了平均值。我们来根据公式计算这个对应的损失值。(x1-y1)2=(-1.0748+1.6405)2=0.320001649.

6、BCELoss

创建一个标准，用于测量目标和输出之间的二进制交叉熵：
在这里插入图片描述

m=nn.Sigmoid()
loss=nn.BCELoss()
loss1=nn.BCELoss(reduction='none')
input=torch.randn(3,requires_grad=True)
print(input)
target=torch.empty(3).random_(2)
print(target)
print(m(input))
output=loss(m(input),target)
print(output)
output=loss1(m(input),target)
print(output)

输出：

tensor([-0.1348, -0.2154,  0.1736], requires_grad=True)
tensor([1., 1., 1.])
tensor([0.4663, 0.4464, 0.5433], grad_fn=<SigmoidBackward>)
tensor(0.7265, grad_fn=<BinaryCrossEntropyBackward>)
tensor([0.7628, 0.8066, 0.6101], grad_fn=<BinaryCrossEntropyBackward>)

将x1和y1带入上面的公式去计算，发现l1=-W1[-0.33133]。至于W1是多少，我就不得而知了。

7、CrossEntropyLoss

该标准将nn.LogSoftmax和nn.NLLLoss合并到一个类中。
在这里插入图片描述

loss=nn.CrossEntropyLoss()
input=torch.randn(3,5,requires_grad=True)
print(input)
target=torch.empty(3,dtype=torch.long).random_(5)
print(target)
output=loss(input,target)
print(output)

输出：

tensor([[ 1.1205, -0.7146,  0.2124, -0.3854, -0.5209],
        [-1.4408, -1.5053, -1.4333, -1.7397, -0.3800],
        [-0.6021,  0.6240, -0.1252, -0.3854, -1.0135]], requires_grad=True)
tensor([1, 1, 4])
tensor(2.3155, grad_fn=<NllLossBackward>)

这个函数和NLLLoss()的区别在于就是不用自己申明一个nn.Logsoftmax().

8、SoftMarginLoss
创建一个标准，优化输入张量：math：x和目标张量：math：`y（包含1或-1）之间的两类分类逻辑损失。
在这里插入图片描述

inputs = torch.tensor([[0.3, 0.7], [0.5, 0.5]])
target = torch.tensor([[-1, 1], [1, -1]], dtype=torch.float)

loss_f = nn.SoftMarginLoss(reduction='none')
loss = loss_f(inputs, target)

print("SoftMargin: ", loss)

SoftMargin:  tensor([[0.8544, 0.4032],
        [0.4741, 0.9741]])

参考文献：

Pytorch详解NLLLoss和CrossEntropyLoss
Pytorch的各种损失函数
18种损失函数全详解及其PyTorch实现与机制

永远的小白虾
关注
专栏目录
pytorch测试loss的简易方法
AlphaFinance
10-29 591
import torch import torch.nn as nn model = nn.Linear(10, 1) criterion = nn.BCEWithLogitsLoss() x = torch.randn(16, 10) y = torch.empty(16).random_(2) # (16, ) out = model(x) # (16, 1) out = out.squeeze(dim=-1) # (16, ) loss = criterion(out, y) print
pytorch自定义交叉熵损失函数
jacke121的专栏
07-21 2603
import torch import torch.nn as nn import numpy as np class CrossEntropyLoss(nn.Module): def __init__(self): super(CrossEntropyLoss, self).__init__() def forward(self, output, label): first = [-output[i][label[i]] for i in ran...
pytorch 损失函数
最新发布
浩瀚之水的专栏
09-05 1009
计算出来的结果已经对mini-batch取了平均。一、损失函数列表创建一个衡量输入x模型预测输出)和目标y之间差的绝对值的平均值的标准。x和y可以是任意形状，每个包含n个元素。对n个元素对应的差值的绝对值求和，得出来的结果除以n。如果在创建L1Loss实例的时候在构造函数中传入，那么求出来的绝对值的和将不会除以n创建一个衡量输入x模型预测输出)和目标y之间均方误差标准。x和y可以是任意形状，每个包含n个元素。对n个元素对应的差值的绝对值求和，得出来的结果除以n。如果在创建MSELoss。
pytorch函数测试
juluwangriyue的博客
03-14 2966
pytorch函数测试1、函数测试1.1、测试 .sum(dim=(m,n))1.2、测试.sum(dim=-1) 主要针对不知道函数结果的操作进行测试 1、函数测试 1.1、测试 .sum(dim=(m,n)) f = torch.arange(4 * 5 * 6).view(1,1, 4, 5, 6) f.shape Out[19]: torch.Size([1, 1, 4, 5, 6]) f Out[20]: tensor([[[[[ 0, 1, 2, 3, 4, 5],
【TensorFlow-windows】部分损失函数测试
风翼冰舟的博客
05-13 511
前言 在TensorFlow中提供了挺多损失函数的，这里主要测试一下均方差与交叉熵相关的几个函数的计算流程。主要是测试来自于tf.nn与tf.losses的mean_square_error、sigmoid_cross_entry、softmax_cross_entry、sparse_softmax_cross_entry 国际惯例，参考博客： 官方文档 一文搞懂交叉熵在机器学习中的使用，透彻理解...
PyTorch学习笔记：nn.KLDivLoss——KL散度损失
qq_50001789的博客
02-10 1万+
PyTorch学习笔记：nn.KLDivLoss——KL散度损失
定制化深度学习：在PyTorch中实现自定义损失函数
07-19
例如，`torch.nn.MSELoss` 和 `torch.nn.CrossEntropyLoss` 分别对应上述提到的两种常见损失函数。然而，在实际应用中，我们可能会遇到一些特殊情况，比如需要考虑数据集的不平衡性或者特定任务的特殊需求，这时候就...
【pytorch笔记】损失函数nll_loss
GentleCP的博客
06-07 2万+
本文主要讲解在使用pytorch中对损失函数`nll_loss`的一些理解与思考。
Simple-SSIM-Loss:使用PyTorch简单而天真地实现结构相似性损失
03-07
"使用PyTorch简单而天真地实现"表明这个项目是用Python的深度学习框架PyTorch编写的，旨在简化SSIM损失函数的实现，便于理解和应用。 描述中提到"实现SSIM丢失功能"，这表明项目提供了一个能够在训练神经网络时使用...
Pytorch系列之——损失函数、优化器
Despacito1006的博客
09-06 1112
权值初始化 前面我们介绍了如何搭建网络模型，在模型搭建好之后一个非常重要的步骤就是对模型当中的权值进行初始化。正确的权值初始化可以加快模型的收敛，而不恰当的权值初始化可能会引发梯度的消失或爆炸，最终导致模型无法训练。 梯度消失与爆炸 Xavier方法与Kaiming方法 常用初始化方法 梯度消失与爆炸 首先观察模型是怎么对W2进行求导的，我们有： H2=H1∗W2 H_{2} = H_{1} * W_{2}H2​=H1​∗W2​ ΔW2=∂Loss∂out∗∂out∂H2∗∂H2∂w2=∂Loss∂o
在论文中总能看到，训练损失曲线图，验证损失曲线图，为什么很少看到测试损失曲线图呢？
qlkaicx的博客
01-17 1490
训练损失曲线图、验证损失曲线图都是机器学习中常用的图表，用于展示模型训练和验证过程中的损失变化情况。训练损失曲线图：它显示了模型在训练数据上的损失随训练迭代次数的变化情况。随着训练的进行，模型不断优化参数，损失逐渐降低。训练损失曲线图可以帮助我们了解模型在训练集上的表现。验证损失曲线图：与训练损失曲线图类似，但它显示了模型在验证数据上的损失随训练迭代次数的变化情况。验证损失用于调整模型超参数和防止过拟合。验证损失曲线图可以帮助我们了解模型在未见过的数据上的表现。
深入解析：训练损失与测试损失的关系
qlkaicx的博客
06-11 1256
训练损失的好坏对测试损失确实有重大影响，但这种影响并非总是直接正相关。为了确保深度学习模型在实际应用中具有良好的性能和泛化能力，重要的是要通过各种技术和策略来监控和优化训练过程中的损失。理解并应用这些策略，将有助于开发出更加健壮和有效的深度学习模型。
损失函数与反向传播
红凯的博客
05-09 3056
损失函数 Loss Functions：来计算搭建模型预测的输出值和真实值之间的误差 1、实际计算输出和目标之间的差距 2、为我们更新输出提供一定的依据（反向传播） 3、损失函数越小越好 import torch from torch.nn import L1Loss from torch import nn #[1,2,3]是实际的数据 inputs = torch.tensor([1, 2, 3], dtype=torch.float32) targets = torch.tensor([1, 2,
NLLLOSS & CrossEntropyLoss
梁小憨憨的博客
09-17 1476
今天在看论文的时候，看到了NLLLOSS函数，嗯？这是个啥，然后就查了查，原来是跟CrossEntropyLoss一样的，这里整理一下，方便以后查阅。
[土堆]深度学习快速入门教程笔记——损失函数、反向传播与优化器——013
m0_73697075的博客
10-28 233
损失函数能够量化模型的预测结果与实际标签之间的误差。通过最小化损失函数，我们可以使得模型的预测结果尽可能接近实际标签，从而提高模型的性能。在训练过程中，优化算法（比如梯度下降）使用损失函数的梯度信息来更新模型参数。通过最小化损失函数，模型可以根据训练数据不断调整自身的参数，使得预测结果更加准确。
深入理解 TORCH.NN
我的学习笔记
02-26 3万+
原文地址：WHAT IS TORCH.NN REALLY? 本人英语学渣，如有错误请及时指出以便更正 pytorch提供了许多优雅的类和模块帮助我们构建与训练网络，比如 torch.nn, torch.optim,Dataset等。为了充分利用这些模块的功能，灵活操作它们解决各种不同的问题，我们需要更好地理解当我们调用这些模块时它们到底干了些什么，为此，我们首先不调用这些模块实现MNIST手写字...
Pytorch详解NLLLoss和CrossEntropyLoss
热门推荐
牛哥的博客
12-24 13万+
pytorch的官方文档写的也太简陋了吧…害我看了这么久… NLLLoss 在图片单标签分类时，输入m张图片，输出一个m*N的Tensor，其中N是分类个数。比如输入3张图片，分三类，最后的输出是一个3*3的Tensor，举个例子： 第123行分别是第123张图片的结果，假设第123列分别是猫、狗和猪的分类得分。 可以看出模型认为第123张都更可能是猫。 然后对每一行使用Softmax，这样可以...
Pytorch的backward()相关理解
jacke121的专栏
10-10 1万+
Pytorch的backward()相关理解 版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/douhaoexia/article/details/78821428 最近一直在用pytorch做GAN相关的实验，pytorch 框架灵活易用，很适合学术界开展研究工作。 这两天遇到了一些模型参数寻优的问题，才发现自己对pytorch的自动求导和...
pytorch bp神经网络 测试函数
08-26
在PyTorch中，可以使用以下步骤构建和训练...通过调用`model(test_inputs)`计算测试输出，并使用损失函数计算测试损失。 这是一个简单的BP神经网络的构建、训练和测试过程示例。你可以根据自己的需求进行修改和扩展。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值