pytorch自带网络_Pytorch 中交叉熵 Loss 趣解

最新推荐文章于 2024-05-13 23:20:43 发布
最新推荐文章于 2024-05-13 23:20:43 发布
阅读量158 收藏
点赞数
文章标签： pytorch自带网络 交叉熵损失函数和focal loss 多分类svm的hinge loss公式推导 挑选出tensor中等于0的索引

16f26aeeba981bc68102c0009b212a21.png

背景

最近一直在总结Pytorch中Loss的各种用法，交叉熵是深度学习中最常用的计算方法，写这个稿子把交叉熵的来龙去脉做一个总结。

什么是交叉熵

信息量

引用百度百科中信息量的例子来看，

在日常生活中，极少发生的事件一旦发生是容易引起人们关注的，而司空见惯的事不会引起注意，也就是说，极少见的事件所带来的信息量多。如果用统计学的术语来描述，就是出现概率小的事件信息量多。因此，事件出现得概率越小，信息量愈大。即信息量的多少是与事件发生频繁(即概率大小)成反比。

故越小概率的事情发生的事件本身具有的信息量就越大。例如在去年夏天，小卡拒了湖人投奔快船还捎带打劫雷霆了一个泡椒，这种闷声大发财的事情就有很大的信息量。

ac13810c814bcec91e068c4e90800395.png

信息量的计算公式为：

信息熵

理解了信息量之后，信息熵的理解也就不再困难了。熵原本是热力学中的一个概念，是用来衡量混乱程度的物理量。信息熵则是借用热力学的概念，衡量在事件发生前对于产生信息量的期望。即信息量是确定的具体事件发生后的信息的度量，信息熵是事件发生前预估的期望。

信息熵的计算公式为：

可以看到信息熵是一个求和的函数，是求得信息量的期望。还是以小卡为例，小卡转会前，假设去湖人的概率是0.4，去其他30支球队的概率分别为(计算方便)，猛龙概率为0(心疼...)，那么小卡转会的信息熵为

所以小卡转会这个事件预计的信息量为，但是实际小卡去了快船，实际的信息量为。因为这是一个非常轰动的事件，所以实际的信息量大于了估计所得的期望。

dc6cde9fe74d6ab24a73419d5b2c5ef5.png

KL散度与交叉熵

理解了信息量和信息熵之后，接下来就是交叉熵的概念了。介绍交叉熵之前，Loss是绕不开的。Loss的通俗解释就是预测值和真实值的差异，然后有各种各样的方法来衡量这个差异有多大，本文所介绍的交叉熵也是一种衡量Loss的方法。

KL散度

在讲交叉熵之前，有一个类似的东西叫KL散度，KL散度是用来衡量两个分布之间差异的指标，计算公式为

公式里面是真实值，是预测值，如果与相同时，即两者之间没有差异。

交叉熵

现在我们将KL散度的公式进行变形，

其中是真实值的信息熵，第二项

就是多分类的交叉熵。因此KL散度也被成为相对熵。对于二分类而言，交叉熵为

二分类交叉熵

Pytorch总共提供了两种二分类交叉熵，一种是nn.BCELoss，另一种是nn.BCEWithLogitsLoss，这两个的差别非常细微，nn.BCEWithLogitsLoss=nn.Sigmoid+nn.BCELoss。这里结合Pytorch的代码做一下验证，首先先验证nn.BCELoss，

m = nn.Sigmoid()loss = nn.BCELoss()input = torch.randn(3, requires_grad=True)# tensor([1.5051, 2.5170, 0.7961], requires_grad=True)target = torch.empty(3).random_(2)# tensor([1., 1., 1.])m(input)# tensor([0.8183, 0.9253, 0.6891], grad_fn=)output = loss(m(input), target)# tensor(0.2168, grad_fn=)

对于nn.BCEWithLogitsLoss而言，使用的代码为

# tensor([1.5051, 2.5170, 0.7961], requires_grad=True)loss1 = nn.BCEWithLogitsLoss()output1 = loss1(input, target)# tensor(0.2168, grad_fn=)

可以看到两者的输入完全相同，输出nn.BCEWithLogitsLoss完全等于nn.BCELoss加上nn.Sigmoid。

多分类交叉熵

对于多分类交叉熵函数而言，一般使用nn.CrossEntropyLoss，该函数的计算流程为：

  1. 在输入值上施加nn.Softmax函数
  2. 对于第一步所得结果使用log函数，将较为耗时的乘法运算改为加法运算，并将其归一化到之间
  3. 将第二步所得输出输入nn.NLLLoss函数中，nn.NNLLLoss的作用就是接受负对数似然值，然后对其求平均。

具体的案例在下一节的CIFAR-10的分类问题中。

实际应用

分类问题

这里我们使用Pytorch自带的CIFAR-10的数据集进行分类，训练的网络为

import torch.nn as nnimport torch.nn.functional as Fclass Net(nn.Module):    def __init__(self):        super(Net, self).__init__()        self.conv1 = nn.Conv2d(3, 6, 5)        self.pool = nn.MaxPool2d(2, 2)        self.conv2 = nn.Conv2d(6, 16, 5)        self.fc1 = nn.Linear(16 * 5 * 5, 120)        self.fc2 = nn.Linear(120, 84)        self.fc3 = nn.Linear(84, 10)    def forward(self, x):        x = self.pool(F.relu(self.conv1(x)))        x = self.pool(F.relu(self.conv2(x)))        x = x.view(-1, 16 * 5 * 5)        x = F.relu(self.fc1(x))        x = F.relu(self.fc2(x))        x = self.fc3(x)        return x

网络结构如下图所示：

5f4e98a1794f42dc90101c4b70e5f6a6.png

使用的loss为nn.CrossEntropyLoss，使用的优化器为SGD优化器，batch size为4，分类的图片类别为10类。

网络的输入为：

52928e3d212b8b71304ce218286a8a0d.png

网络的输出为

tensor([[ 0.1788,  2.7710, -1.7293, -0.7374, -0.2494, -1.8283,  3.9494, -2.5115,         -3.8941,  3.0328],        [-2.4240, -2.4709,  2.3784,  2.9654,  1.3043,  2.0047,  0.7166,  1.0876,         -1.9398, -1.9151],        [ 2.8583, -2.6383,  1.5032,  0.3617,  1.3289, -1.2958,  0.0279, -2.3972,          2.3778, -2.0852],        [-2.8961, -2.9959,  2.6880,  2.5834,  2.5803,  2.3840,  2.4317,  0.9671,         -3.0246, -2.5225]], grad_fn=)

输出是一个4×10的矩阵，对应的label为，

label = tensor([9, 5, 8, 6]) #truck, dog, ship, frog

将网络直接的输出输入到nn.softmax可得，并验证加和结果为

softmax_func=nn.Softmax(dim=1)# tensor([[1.3065e-02, 1.7453e-01, 1.9384e-03, 5.2261e-03, 8.5139e-03, 1.7555e-03,#         5.6710e-01, 8.8657e-04, 2.2246e-04, 2.2676e-01],#         [1.8934e-03, 1.8066e-03, 2.3061e-01, 4.1479e-01, 7.8778e-02, 1.5870e-01,#          4.3770e-02, 6.3433e-02, 3.0727e-03, 3.1494e-03],#         [4.4119e-01, 1.8093e-03, 1.1379e-01, 3.6341e-02, 9.5598e-02, 6.9270e-03,#          2.6028e-02, 2.3025e-03, 2.7287e-01, 3.1457e-03],#         [8.3395e-04, 7.5479e-04, 2.2197e-01, 1.9993e-01, 1.9930e-01, 1.6378e-01,#          1.7178e-01, 3.9713e-02, 7.3344e-04, 1.2118e-03]],#       grad_fn=)softmax_func(outputs).sum(1)# tensor([1.0000, 1.0000, 1.0000, 1.0000], grad_fn=)

接下来，将nn.softmax的输出输入torch.log可以得到

log_outputs=torch.log(soft_output)# tensor([[-4.3379, -1.7457, -6.2459, -5.2541, -4.7661, -6.3450, -0.5672, -7.0281,#         -8.4108, -1.4839],#        [-6.2694, -6.3163, -1.4670, -0.8800, -2.5411, -1.8407, -3.1288, -2.7578,#         -5.7852, -5.7605],#        [-0.8183, -6.3148, -2.1734, -3.3148, -2.3476, -4.9723, -3.6486, -6.0738,#         -1.2988, -5.7617],#        [-7.0893, -7.1891, -1.5052, -1.6098, -1.6130, -1.8093, -1.7616, -3.2261,#         -7.2178, -6.7157]], grad_fn=)

最后将log_outputs通过nn.NLLLoss并与nn.CrossEntropy对比

nllloss_func=nn.NLLLoss()nlloss_output=nllloss_func(log_outputs,labels)# tensor(1.5962, grad_fn=)criterion = nn.CrossEntropyLoss()criterion(outputs, labels)# tensor(1.5962, grad_fn=)

可以发现经过组合的loss和直接用nn.CrossEntroyLoss得到的loss是一样的。

下一次推送我们将会解析一下Kaiming大神的Focal Loss。

参考文献

[1] https://gombru.github.io/2018/05/23/cross_entropy_loss/

[2]https://www.baidu.com/link?url=mm7cnRyOERSRY_TPjZ8WbzU3im5Hq1JstcfLngNj4y0P5H4gC9lAhGLWnTBAgoucSnBu-Ek_fwM-RuyWSOfPxv4Idbxr0hm-udxOVd3Yz4rFgPymoQpsOb8_UsSmub-I&wd=&eqid=b0181d0f0002cd51000000045eccec89

[3] https://pytorch.org/docs/master/generated/torch.nn.BCELoss.html

[4] https://pytorch.org/docs/master/generated/torch.nn.NLLLoss.html

推荐阅读

(点击标题可跳转阅读)

干货 | 公众号历史文章精选

我的深度学习入门路线

我的机器学习入门路线图

重磅！

AI有道年度技术文章电子版PDF来啦！

a1aab60bb346cb9eafde611c4acdc936.png

扫描下方二维码，添加 AI有道小助手微信，可申请入群，并获得2020完整技术文章合集PDF(一定要备注：入群 + 地点 + 学校/公司。例如：入群+上海+复旦。 

2d9dcb00bdd85aa89b3f96003c78fa7a.png

长按扫码，申请入群

(添加人数较多，请耐心等待)

最新 AI 干货，我在看 fe7a6750f103a348435eef84f6118670.png

weixin_39611546
关注
pytorch：交叉熵（cross entropy）
weixin_62637793的博客
11-16 8146
entropy中文叫做熵，也叫不确定性，某种程度上也叫惊喜度（measure of surprise）
Pytorch中的交叉熵函数CrossEntropyLoss()
不愿透漏姓名的王建森的博客
05-05 1万+
分类问题中，交叉熵函数是比较常用也是比较基础的损失函数，原来就是了解，但一直搞不懂他是怎么来的？为什么交叉熵能够表征真实样本标签和预测概率之间的差值？趁着这次学习把这些概念系统学习了一下。 交叉熵的数学原理 首先说起交叉熵，脑子里就会出现这个东西： L=−[ylog⁡y^+(1−y)log⁡(1−y^)]L=-[y\log{\hat{y}}+(1-y)\log{(1-\hat{y})}] L=−[...
交叉熵的数学原理及应用——pytorch中的CrossEntropyLoss()函数
weixin_30691871的博客
12-25 2771
分类问题中，交叉熵函数是比较常用也是比较基础的损失函数，原来就是了解，但一直搞不懂他是怎么来的？为什么交叉熵能够表征真实样本标签和预测概率之间的差值？趁着这次学习把这些概念系统学习了一下。 首先说起交叉熵，脑子里就会出现这个东西： 随后我们脑子里可能还会出现Sigmoid()这个函数: pytorch中的CrossEntropyLoss()函数实际就是先...
pytorch——交叉熵
qq_46126537的博客
08-07 718
cross_entropy=softmax+log+nll_loss 交叉熵损失一般适用于分类问题 MSE可以用在一些比较前沿的算法中 import torch import torch.nn.functional as F x=torch.randn(1,784) w=torch.randn(10,784) logits=x@w.t() pred=F.softmax(logits,dim=1) pred_log=torch.log(pred) print(F.nll_loss(pred_log,tor
PyTorch: 交叉熵
2205_75881260的博客
03-07 277
当P=Q时，H(p,Q)=H(P)=-P(i)*log2[P(i)].sum()=Q时，H(P,Q)=-P(i)*log2[Q(i)].sum()#uncertainty越高，信息越多；entropy越高，信息越少。#分类问题使用交叉熵：cross entropy,而不使用mse。#Entropy=-P(i)*log2[P(i)]的求和。3. 交叉熵Cross Entropy。#二值分类：cat和dog。2. 熵Entropy。
pytorch中交叉熵
geter_CS的博客
04-08 1万+
关于pytorch中交叉熵的使用，pytorch的交叉熵是其loss function的一种且包含了softmax的过程。 pytorch中交叉熵函数是nn.CrossEntropyLoss()。其参数包括：weight，size_averaged，reduce weight参数通常默认值是0，如果你的训练样本很不均衡的话，可以设置其值。 size_averaged参数是设置是否取均值，默认...
python实现 交叉熵损失函数_PyTorch的SoftMax交叉熵损失和梯度用法
weixin_29305337的博客
01-17 1408
在PyTorch中可以方便的验证SoftMax交叉熵损失和对输入梯度的计算关于softmax_cross_entropy求导的过程,可以参考HERE示例：# -*- coding: utf-8 -*-import torchimport torch.autograd as autogradfrom torch.autograd import Variableimport torch.nn.func...
Pytorch：交叉熵损失(CrossEntropyLoss)以及标签平滑(LabelSmoothing)的实现
u013250861的博客
08-28 1914
一般情况下我们都是直接调用Pytorch自带的交叉熵损失函数计算loss，但涉及到魔改以及优化时，我们需要自己动手实现loss function，在这个过程中如果能对交叉熵损失的代码实现有一定的了解会帮助我们写出更优美的代码。其次是标签平滑这个trick通常简单有效，只需要改改损失函数既可带来性能上的提升，通常与交叉熵配合食用。因此，本文基于这两个出发点，介绍基于Pytorch框架下的交叉熵损失实现以及标签平滑的实现。.........
基于pytorch的fcn_FCN 的简单实现
weixin_35063366的博客
12-24 1462
学习了沐神的 gluon 课程，觉得里面有关于 fcn 的课程 特别有用，于是总结一下，同时使用 pytorch 重新实现，不仅实现 gluon 教程中的部分，同时实现论文中更精细的形式。介绍语义分割是一种像素级别的处理图像方式，对比于目标检测其更加精确，能够自动从图像中划分出对象区域并识别对象区域中的类别，比如下面这个效果上面是输入的图片，下面是希望得到的效果，也就是希望能够对区域进行像素级别的...
Pytorch 常见损失函数实现
ssshyeong的博客
09-25 1586
Pytorch 常见损失函数实现1.CrossEntropyLoss()函数1.1.基本计算公式1.2.Pytorch自带计算2.Focal Loss2.1.基本计算公式基本计算表达式：2.2.Pytorch实现3.二分类Dice Loss3.1.基本计算公式3.2.Pytorch实现4.多分类Dice Loss损失函数4.1.基本计算思路4.2.Pytorch实现 1.CrossEntropyLoss()函数 1.1.基本计算公式 1.2.Pytorch自带计算 Pytorch中计算的交叉熵： 其中自带
pytorch之交叉熵（笔记四）
影子
05-08 322
师傅说过一句话：线性回归用二次代价函数，分类使用交叉熵。 通过一个例子观察一下： 通过观察发现，输入是0.82的比输入是0.98的收敛的更快，为什么呢？为我们通过sigmod函数观察一下。 原因是在0.98的时候收敛的比较平缓，因为斜率比较小，0.82的时候斜率大，收敛的就比较快。 交叉熵的概念 交叉熵和二次代价函数对比。 二次代价函数：代码请参考（我的博客pytorch之mnist手写数字识别（笔记三））：https://mp.csdn.net/editor/html/11..
Pytorch计算交叉熵
weixin_44777283的博客
04-29 75
【代码】Pytorch计算交叉熵。
Pytorch踩坑记之交叉熵（nn.CrossEntropy，nn.NLLLoss，nn.BCELoss的区别和使用）
热门推荐
watermelon1123的博客
06-06 4万+
目录 nn.Softmax和nn.LogSoftmax nn.NLLLoss nn.CrossEntropy nn.BCELoss 总结 在Pytorch中的交叉熵函数的血泪史要从nn.CrossEntropyLoss()这个损失函数开始讲起。从表面意义上看，这个函数好像是普通的交叉熵函数，但是如果你看过一些Pytorch的资料，会告诉你这个函数其实是softmax()和交叉熵的结合体...
Pytorch 中的交叉熵CrossEntropyLoss
赫凯的博客
11-07 537
损失函数中出镜率还是特别高的，每次用它的时候需要把数据结构调整对了，交叉熵就是预测分类的所属概率，比如这个图片是属于哪一类，属于狗？猫？马？什么的，用网络训完之后会得到一个每个分类的预测概率。 看下面代码 import torch import torch.nn as nn loss = nn.CrossEntropyLoss() input = torch.randn(3, 5, requir...
必能读懂的 交叉熵详解，pytorch中交叉熵的使用
Defiler_Lee的博客
03-12 2454
目录 1. 交叉熵详解 1.1信息量 1.2 熵 1.3 相对熵（KL散度） 1.4交叉熵 1.5 小结 2. 交叉熵的应用（pytorch中） 2.1交叉熵在分类任务中的计算过程 2.2 log_softmax()函数 2.3nll_loss()函数 2.4cross_entropy()函数 2.5 函数的其他调用方式 1. 交叉熵详解 1.1...
Pytorch中的CrossEntropy
KK的博客
04-06 2662
Pytorch中的CrossEntropy表达式如何计算得到输出 Pytorch中的CrossEntropy 表达式 (1) 二分类 在二分的情况下，模型最后需要预测的结果只有两种情况，对于每个类别我们的预测得到的概率为 p 和1-p 。此时表达式为： 其中： yi —— 表示样本i的label，正类为1，负类为0 pi —— 表示样本i预测为正的概率 (2) 多分类 多分类的情况实际上就是...
Pytorch常用的函数(十)交叉熵损失函数nn.BCELoss()、nn.BCELossWithLogits()、nn.CrossEntropyLoss()详解
最新发布
qq_44665283的博客
05-13 2176
Pytorch常用的函数(九)交叉熵损失函数nn.BCELoss()、nn.BCELossWithLogits()、nn.CrossEntropyLoss()详解
[pytorch] 二分类交叉熵逆样本频率权重
THE XING
02-15 1692
通常，由于类别不均衡，需要使用weighted cross entropy loss平衡。 def inverse_freq(label): """ 输入label [N,1,H,W],1是channel数目 """ den = label.sum() # 0 _,_,h,w= label.shape num = h*w alpha = den/num #...
Pytorch教程(3)——交叉熵CrossEntropyLoss()
某热心知名群众的博客
06-18 691
交叉熵的计算公式 输入的x的shape为(batch_size, num_class)，一般求loss为对batch_size求均值，后进行backward 计算公式 这里class指的是某一类： 不带权重 loss(x,class)=−logexp(x[class])Σjexp(x[j])loss(x, class)=-log\frac{exp(x[class])}{\Sigma_{j}exp(x[j])}loss(x,class)=−logΣj​exp(x[j])exp(x[class])​ 带权重
请用pytorch搭建transformer时间序列预测网络
05-02
好的，以下是使用 PyTorch 搭建 Transformer 时间序列预测网络的代码。 首先，需要导入必要的库： ```python import torch import torch.nn as nn import torch.optim as optim import numpy as np ``` 然后，我们定义一个 Transformer 模型类，其中包括了编码器、解码器和最终的输出层。 ```python class TransformerTimeSeries(nn.Module): def __init__(self, input_size, output_size, d_model, nhead, num_encoder_layers, num_decoder_layers, dim_feedforward, dropout): super(TransformerTimeSeries, self).__init__() self.input_size = input_size self.output_size = output_size self.d_model = d_model self.nhead = nhead self.num_encoder_layers = num_encoder_layers self.num_decoder_layers = num_decoder_layers self.dim_feedforward = dim_feedforward self.dropout = dropout self.encoder = nn.TransformerEncoder( nn.TransformerEncoderLayer(d_model=d_model, nhead=nhead, dim_feedforward=dim_feedforward, dropout=dropout), num_layers=num_encoder_layers ) self.decoder = nn.TransformerDecoder( nn.TransformerDecoderLayer(d_model=d_model, nhead=nhead, dim_feedforward=dim_feedforward, dropout=dropout), num_layers=num_decoder_layers ) self.linear = nn.Linear(d_model, output_size) def forward(self, src, tgt): src_mask = self.generate_square_subsequent_mask(src.size(0)).to(src.device) tgt_mask = self.generate_square_subsequent_mask(tgt.size(0)).to(tgt.device) memory = self.encoder(src, src_mask) output = self.decoder(tgt, memory, tgt_mask=tgt_mask) output = self.linear(output) return output def generate_square_subsequent_mask(self, sz): mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1) mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0)) return mask ``` 在这个模型中，我们使用了 PyTorch 自带的 Transformer 编码器和解码器，并且定义了一个线性层作为最终的输出层。在 `forward` 函数中，我们通过编码器得到了输入序列的表示 `memory`，然后将其传递给解码器，解码器再根据目标序列生成预测结果。 接下来，我们定义一个函数来训练这个模型。 ```python def train(model, optimizer, criterion, train_loader, num_epochs): for epoch in range(num_epochs): train_loss = 0.0 for i, (inputs, targets) in enumerate(train_loader): optimizer.zero_grad() outputs = model(inputs, targets[:-1]) loss = criterion(outputs.reshape(-1, outputs.size(-1)), targets[1:].reshape(-1)) loss.backward() optimizer.step() train_loss += loss.item() print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, train_loss/len(train_loader))) ``` 在这个函数中，我们使用交叉熵损失函数，并且在训练过程中使用了梯度下降优化器。每个 epoch 中，我们遍历训练数据集，计算损失并更新模型参数，最后输出平均损失。 最后，我们可以使用定义好的模型和训练函数来训练我们的时间序列预测网络了。 ```python # 定义超参数 input_size = 1 output_size = 1 d_model = 16 nhead = 4 num_encoder_layers = 2 num_decoder_layers = 2 dim_feedforward = 64 dropout = 0.1 num_epochs = 100 learning_rate = 0.001 # 准备数据 train_data = np.sin(np.linspace(0, 100, 1000)) train_data = torch.from_numpy(train_data).float().unsqueeze(-1) train_loader = torch.utils.data.DataLoader(train_data, batch_size=32) # 定义模型和优化器 model = TransformerTimeSeries(input_size, output_size, d_model, nhead, num_encoder_layers, num_decoder_layers, dim_feedforward, dropout) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=learning_rate) # 训练模型 train(model, optimizer, criterion, train_loader, num_epochs) ``` 在这个例子中，我们使用了一个简单的正弦函数来作为训练数据集。你可以根据你的需求替换成其他的时间序列数据集。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值