P23 损失函数与反向传播 来自torch.nn

最新推荐文章于 2024-05-23 19:05:22 发布
最新推荐文章于 2024-05-23 19:05:22 发布
阅读量101 收藏
点赞数 1
分类专栏： 小土堆，pytorch基础 文章标签： pytorch 人工智能 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44751432/article/details/132914471
版权

一、大概意思

loss越小越好
在这里插入图片描述
科普：反向传播意思就是，尝试如何调整网络过程中的参数才会导致最终的loss变小（因为是从loss开始推导参数，和网络的顺序相反，所以叫反向传播），以及梯度的理解可以直接当成“斜率”

损失函数的意义：
在这里插入图片描述

二、看文档

在这里插入图片描述
1、L1——loss

torch.nn.L1Loss(size_average=None, reduce=None, reduction='mean')

在这里插入图片描述--------------------------------------------------------------
看下输入和输出
输入：
1、N：batchsize
2、 ， 可以是任意维度的 数据
模板target：
与输入同形式
输出，如果不指定reduction，那么和输入同形式
在这里插入图片描述
代码看下
（1）新建数据
（2）使用reshape扩展维数至四维

import torch.nn
import torch
from torch.nn import L1Loss

inputs=torch.tensor([1,2,3])
targets=torch.tensor([1,2,5])
print(inputs.shape)

inputs=torch.reshape(inputs,[1,1,1,3])
targets=torch.reshape(targets,[1,1,1,3])

print(inputs.shape)

loss=L1Loss()
result=loss(inputs,targets)

print(result)

报错，说我们数字类型不符合要求，
要浮点型，那么我们修改类型，用dtype
在这里插入图片描述


inputs=torch.tensor([1,2,3],dtype=torch.float32)
targets=torch.tensor([1,2,5],dtype=torch.float32)

这样完整代码：

import torch.nn
import torch
from torch.nn import L1Loss

inputs=torch.tensor([1,2,3],dtype=torch.float32)
targets=torch.tensor([1,2,5],dtype=torch.float32)
print(inputs.shape)

inputs=torch.reshape(inputs,[1,1,1,3])
targets=torch.reshape(targets,[1,1,1,3])

print(inputs.shape)

loss=L1Loss()
result=loss(inputs,targets)

print(result)

可以看到通过loss函数计算结果恰好是2/3=0.6667
在这里插入图片描述

现在我们指定一下reduction为求和

loss=L1Loss(reduction="sum")
result=loss(inputs,targets)
print(result)

结果显然为2
在这里插入图片描述

2、MSEloss
torch.nn.MSELoss(size_average=None, reduce=None, reduction=‘mean’)
在这里插入图片描述
在这里插入图片描述
看下代码

import torch
import torch.nn
from torch.nn import MSELoss


inputs=torch.tensor([1,2,3],dtype=torch.float32)
targets=torch.tensor([1,2,5],dtype=torch.float32)
print(inputs.shape)

inputs=torch.reshape(inputs,[1,1,1,3])
targets=torch.reshape(targets,[1,1,1,3])

print(inputs.shape)

loss=MSELoss()
result=loss(inputs,targets)
print(result)

输出结果为1.333与我们计算一致
在这里插入图片描述

在这里插入图片描述

3、CrossEntropyLoss
交叉熵：常用于分类的损失函数

t is useful when training a classification problem with C classes.
常用于训练分类问题（类别数量为C）

计算公式如下;
举例子
在这里插入图片描述

代码来看下
先看下文档中需要的shape
在这里插入图片描述

import torch
from torch.nn import CrossEntropyLoss

x=torch.tensor([0.1,0.2,0.3]) 这里x是一维的
y=torch.tensor([1])
print(x.shape)
x=torch.reshape(x,(1,3))
print(x.shape)
//因为CrossEntropyLoss中x为输入，形式为二维（batchisize，类别数量）
					y为target，所以要把x变成二维//
loss_cross=CrossEntropyLoss()
result_loss=loss_cross(x,y)
print(result_loss)

输出：
torch.Size([3])
torch.Size([1, 3])
tensor(1.1019)

**对于狗计算公式：
在这里插入图片描述

这里需要注意一下，文档中的log实际上是ln自然对数**

=-0.2+ln(exp(0.1)+exp(0.2)+exp(0.3))
在这里插入图片描述
计算正确

三、1 损失函数实战

1、先从上次学习中搭建的神经网络（sequential）复制进来

from torch.nn import Sequential
from  torch import nn
from torch.nn import Conv2d,MaxPool2d,Flatten,Linear

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model1=Sequential(
            Conv2d(in_channels=3,out_channels=32,kernel_size=5,stride=1,padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, 1, 2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, 1, 2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self,x):
        x=self.model1(x)
        return x

2、导入cifar数据集

from torch.utils.data import DataLoader

dataset=torchvision.datasets.CIFAR10("./P23_dataset",train=False,transform=torchvision.transforms.ToTensor(),
                                     download=True)
dataloader=DataLoader(dataset,batch_size=64)

3、for循环取出imgs，targets。然后通过神经网络操作

tudui=Tudui()

for data in dataloader:
    imgs,targets=data
    output=tudui(imgs)
    print(output)
    print(targets)

4、最终：

from torch.nn import Sequential
from  torch import nn
from torch.nn import Conv2d,MaxPool2d,Flatten,Linear
import torchvision
from torch.utils.data import DataLoader

dataset=torchvision.datasets.CIFAR10("./P23_dataset",train=False,transform=torchvision.transforms.ToTensor(),
                                     download=True)
dataloader=DataLoader(dataset,batch_size=64)


class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model1=Sequential(
            Conv2d(in_channels=3,out_channels=32,kernel_size=5,stride=1,padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, 1, 2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, 1, 2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self,x):
        x=self.model1(x)
        return x

tudui=Tudui()

for data in dataloader:
    imgs,targets=data
    output=tudui(imgs)
    print(output)
    print(targets)

因为设置了batchsize数据比较多，我们改为1
再看输出结果

tensor([[ 0.0835, -0.0427, -0.1136,  0.0751, -0.1241,  0.0557,  0.0384,  0.1432,
         -0.0817,  0.0711]], grad_fn=<AddmmBackward0>)
tensor([1])
tensor([[ 0.0749, -0.0500, -0.1154,  0.0736, -0.1187,  0.0532,  0.0397,  0.1437,
         -0.1071,  0.0638]], grad_fn=<AddmmBackward0>)
tensor([7])


//可以看到一张图片经过神经网络会有10个输出，输出的值代表10类不同东西的神经网络线性值
！！经弹幕大神了解到，因为没有softmax层，没归一化，没有过激活函数，所以输出的不是概率！~！！
//tensor【1】和tensor【7】则是类列表中的序号了

5、用上我们今天学的loss函数中的交叉熵


loss=nn.CrossEntropyLoss()
for data in dataloader:
    imgs,targets=data
    output=tudui(imgs)
    result_loss=loss(output,targets)
    print(output)
    print(targets)
    print(result_loss)

这样就计算出了实际输出与目标之间的误差
在这里插入图片描述
最终：

from torch.nn import Sequential
from  torch import nn
from torch.nn import Conv2d,MaxPool2d,Flatten,Linear
import torchvision
from torch.utils.data import DataLoader

dataset=torchvision.datasets.CIFAR10("./P23_dataset",train=False,transform=torchvision.transforms.ToTensor(),
                                     download=True)
dataloader=DataLoader(dataset,batch_size=1)


class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model1=Sequential(
            Conv2d(in_channels=3,out_channels=32,kernel_size=5,stride=1,padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, 1, 2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, 1, 2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self,x):
        x=self.model1(x)
        return x

tudui=Tudui()


loss=nn.CrossEntropyLoss()
for data in dataloader:
    imgs,targets=data
    output=tudui(imgs)
    result_loss=loss(output,targets)
    print(output)
    print(targets)
    print(result_loss)

三、2 反向传播实战

科普：反向传播意思就是，尝试如何调整网络过程中的参数才会导致最终的loss变小（因为是从loss开始推导参数，和网络的顺序相反，所以叫反向传播），以及梯度的理解可以直接当成“斜率”
1、添加反向传播
注意是在自己的loss上添加： result_loss.backward()
而非继承的loss函数上

loss=nn.CrossEntropyLoss()
for data in dataloader:
    imgs,targets=data
    output=tudui(imgs)
    result_loss=loss(output,targets)
    result_loss.backward()
    print("ok")

2、加入断点 debug一下
在这里插入图片描述
下面变量中：
tudui——model1——protected attributes——moudules下可以发现我们的神经网络
其中0是第一层卷积层：
在这里插入图片描述
在其下的weight权重下面，发现有grad梯度，现在还没有值
在这里插入图片描述
然后我们按下继续运行;
执行的代码是：

result_loss.backward()

在这里插入图片描述
我们发现梯度这里有了数据
在这里插入图片描述
这样就能计算出梯度
以便对loss进行优化

最终代码：

from torch.nn import Sequential
from  torch import nn
from torch.nn import Conv2d,MaxPool2d,Flatten,Linear
import torchvision
from torch.utils.data import DataLoader

dataset=torchvision.datasets.CIFAR10("./P23_dataset",train=False,transform=torchvision.transforms.ToTensor(),
                                     download=True)
dataloader=DataLoader(dataset,batch_size=1)


class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model1=Sequential(
            Conv2d(in_channels=3,out_channels=32,kernel_size=5,stride=1,padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, 1, 2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, 1, 2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self,x):
        x=self.model1(x)
        return x

tudui=Tudui()


loss=nn.CrossEntropyLoss()
for data in dataloader:
    imgs,targets=data
    output=tudui(imgs)
    result_loss=loss(output,targets)
    result_loss.backward()
    print("ok")
颦蹙遥寄
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【课程设计】理工学院单片机课程设计说明书 工件计数与成箱包装WORD档P23.doc
07-03
【课程设计】理工学院单片机课程设计说明书 工件计数与成箱包装WORD档P23
07-《创新思维与创业教育》第七章-简版(P23)ppt课件(全).pptx
05-28
07-《创新思维与创业教育》第七章-简版(P23)ppt课件(全).pptx
p23_1.mcworld
10-28
p23_1.mcworld
【ppt】 p23实变.pdf
09-19
【ppt】 p23实变.pdf
信息化和电子商务应用情况109表P23.pdf
11-28
信息化和电子商务应用情况109表P23.pdf
train函数中出现的loss不能反向传播
weixin_42067873的博客
11-08 798
在图像分割任务中，我换了个MS-SSIM+L1损失函数，该损失函数的要求是输入两张图片，我的网络输出的是经过softmax的概率值。上述train过程中使用了argmax函数，影响了losses反向传播的过程，导致训练没有任何效果（损失值固定不变）
损失函数和反向传播
ggj0727的博客
08-05 1163
L1LOSS
为什么BCELoss算出的损失为负数？
Bean冷的心的博客
09-14 7522
今天在做一个简单的线性回归问题： import torch import torch.nn as nn learning_rate = 0.01 # 1.准备数据 x = torch.rand([500, 1]) y_true = x * 3 + 0.8 # 2.通过模型计算y_predict w = torch.rand([1, 1], requires_grad=True) b = torch.tensor(0, requires_grad=True, dtype=torch.float32)
反向传播
weixin_43282288的博客
10-22 237
1、图中损失值loss为f=-12，想要知道x、y、z分别对f有多大的影响。希望loss越小越好 2、f对z的偏导为q，q=3,则希望z越越小越好 3、要计算f对x的偏导，需要先计算f对q的偏导，为z=-4，再算q对x的偏导为1，则f对x的偏导为-4，希望x越大越好，同理f对y的偏导也为-4越大越好 遵循链式法则只能一层一层的往前传 下面举稍微复杂的例子 对1/x进行求导为-1/x^2，将1...
CV面试题目--基础理论部分
you 是 mine
07-23 2437
1. 如何应对图片光照变化大 1、直方图均衡化 2、对比度拉伸，或者调节 3、若受光源影响，使得图片整体色彩往一方面移动，用白平衡算法进行修正，使其发黄、发蓝、发红的照片更加趋于自然光下的图像 4、若是过爆或者过暗，可是设计阈值函数，不用全局阈值，对特定区域进行特定阈值分割。 5、若是太暗，可以采用对数变化，对数图像增强是图像增强的一种常见方法，其公式为：S = c log (r+1)，对数使亮度比较低的像素转换成亮度比较高的，而亮度较高的像素则几乎没有变化，这样就使图片整体变亮。 6、采用拉普拉斯算子增强
土堆学习笔记——P23损失函数与反向传播
Whalawhala的博客
12-19 347
损失函数loss functionloss越小越好**
p23损失函数与反向传播
qq_45583898的博客
06-06 127
可设置L1Loss相关的计算方式 因为前面看的那个输入输出里面需要有batch_size，但是现在不需要必须输入batch_size这一参数了，所以不reshap也没问题 MSELoss CrossEntropyLoss It is useful when training a classification problem with C classes 发现CIFAR10的数据结构类似上面所举例 backward 运行完backward（）后，grad出现数值，必须有loss.bac
问题记录7：Pytorch训练网络模型过程中Loss为负值的问题及其解决方案
热门推荐
weixin_42214565的博客
10-08 2万+
1. 问题描述 在复现论文的过程中，遇到了训练模型Loss一直为负的情况。 程序主要通过深度学习实现一个分类任务。编程与debug过程全部在windows10系统，Pycharm2018v1.4的IDE下完成，主要框架为pytorch 1.2.0。复现过程中采用了交叉熵损失函数计算Loss。训练过程中输出信息如下： 输出部分的代码段： for batch_idx, (data...
Pytorch反向传播(loss.backward)报错原因及解决办法
简简单单的学习笔记，致力于帮助更多前进路上的朋友~
02-06 2万+
RuntimeError: grad can be implicitly created only for scalar outputs 错误原因及其解决办法
损失函数与反向传播
z1139269312的博客
10-26 301
注意输入和输出的大小 import torch from torch import nn from torch.nn import L1Loss inputs = torch.tensor([1,2,3],dtype=torch.float32) targets = torch.tensor([1,2,5],dtype=torch.float32) inputs = torch.reshape(inputs,(1,1,1,3)) targets = torch.reshape(targets,(1,
PyTorch入门（三）损失函数与反向传播
1900的博客
12-24 4639
误差函数与反向传播（误差函数、梯度下降、优化器）
聊聊Focal Loss及其反向传播
Zziven的博客
02-11 5992
Focal Loss: Focal Loss for Dense Object Detection  论文链接：https://arxiv.org/abs/1708.02002      我们都知道，当前的目标检测（Objece Detection)算法主要分为两大类：two-stage detector和one-stage detector。two-stage detector主要包括rcnn、...
为什么模型loss为负
小小程序员
05-27 9373
一般loss为负是在loss采用交叉熵的情况下： 可以将softmax 改为 log_softmax
Google的MLP-MIXer的复现（pytorch实现）
最新发布
qq_45689158的博客
05-23 260
2.在处理两个差异的时候，如输入维度[32,196,512],其中代表的意思分别为batch_size为32，196为图片在经过patch之后的224*224输入之后经过patch=16，变为14 * 14即196，512会在二维卷积处理之后输出的channel类似。在nn.linear那儿的in_channel与第三个维度保持一致，就可以不必将其三维的转换为二维的。在将flax框架的代码改为pytorch实现的时候，还是踩了不少的坑，在此讲一下，希望后面做的人，可以避免。
{matrix_p23,1'b0}
07-15
这看起来像是一个Verilog HDL中的代码片段。`{matrix_p23, 1'b0}` 表示一个拼接操作，将 `matrix_p23` 和 `1'b0` 进行拼接。 在Verilog HDL中，`matrix_p23` 和 `1'b0` 都是信号或变量的表示方式。这里的 `matrix_p23` 可能是一个信号或变量，而 `1'b0` 表示一个单个的位（bit）值，其中 `1` 是表示位的值，`'b0` 是表示二进制形式的表示方式。 拼接操作 `{}` 在Verilog HDL中用于将多个信号或变量按照顺序拼接成一个更大的信号或变量。 所以，`{matrix_p23, 1'b0}` 表示将 `matrix_p23` 和 `1'b0` 按顺序拼接在一起，形成一个新的信号或变量。具体的含义和用途需要根据代码上下文来确定。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值