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

于 2023-09-16 15:10:48 发布
阅读量186 收藏
点赞数 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")
【小土堆】Pytorch学习笔记_P23/24_损失函数/优化器
qq_40979183的博客
03-30 127
​ # 课程链接 PyTorch深度学习快速入门教程（绝对通俗易懂！）【小土堆】_哔哩哔哩_bilibili # 笔记内容 （1）P23_损失函数 （2）P24_优化器（一） ​
反向传播是什么意思
最新发布
m0_72232218的博客
01-23 1470
这个过程实际上是在利用梯度信息不断调整模型参数，使得模型的输出逐渐接近实际标签，从而提高模型的性能。反向传播（Backpropagation）是指在神经网络中使用梯度下降等优化算法进行模型训练时，通过计算损失函数对模型参数的梯度，然后反向传播这些梯度从输出层到输入层，以更新模型参数的过程。（Forward Propagation）： 通过神经网络，使用当前的模型参数，将输入数据从输入层传递到输出层，得到模型的预测结果。： 使用梯度下降或其他优化算法，沿着梯度的负方向更新模型参数，以减小损失函数的值。
train函数中出现的loss不能反向传播
weixin_42067873的博客
11-08 902
在图像分割任务中，我换了个MS-SSIM+L1损失函数，该损失函数的要求是输入两张图片，我的网络输出的是经过softmax的概率值。上述train过程中使用了argmax函数，影响了losses反向传播的过程，导致训练没有任何效果（损失值固定不变）
反向传播
weixin_43282288的博客
10-22 285
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...
【09】损失函数与反向传播
cocapop的博客
04-06 1235
损失函数大致可以分成两类：回归（Regression）和分类（Classification）。
07-《创新思维与创业教育》第七章-简版(P23)ppt课件(全).pptx
05-28
07-《创新思维与创业教育》第七章-简版(P23)ppt课件(全).pptx
【课程设计】理工学院单片机课程设计说明书 工件计数与成箱包装WORD档P23.doc
07-03
【课程设计】理工学院单片机课程设计说明书 工件计数与成箱包装WORD档P23
北师大初中数学八年级下册一元一次不等式与一次函数PPT课件.pptx
10-11
这篇PPT课件主要涉及了初中数学八年级下册的一元一次不等式与一次函数的相关知识，适合用于教学或自我学习。以下是课件中涉及的主要知识点的详细说明： 1. **一次函数**：一次函数通常表示为y = mx + b的形式，其中...
p23_1.mcworld
10-28
p23_1.mcworld
loss反向传播出错问题
aihaiming2013的专栏
09-27 490
在使用mse损失函数进行对抗攻击的时候，loss反向传播一直报错，最终改成如下形式才能够正常运行 loss11 = F.mse_loss(logits, logits_target, reduction='none').sum(axis=1) loss12 = F.mse_loss(logits, logits_true, reduction='none').sum(axis=1) loss1 = 4 * loss11 - loss12 loss = torch.mean(loss) optimizer
损失函数和反向传播
ggj0727的博客
08-05 1219
L1LOSS
为什么BCELoss算出的损失为负数？
Bean冷的心的博客
09-14 8039
今天在做一个简单的线性回归问题： 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)
损失函数与反向传播
z1139269312的博客
10-26 346
注意输入和输出的大小 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,
读懂反向传播算法（bp算法）
weixin_43615742的博客
05-28 842
读懂反向传播算法（bp算法） 文章目录读懂反向传播算法（bp算法）介绍思想定义元素损失函数对参数的偏导链式法则总结 介绍 反向传播算法可以说是神经网络最基础也是最重要的知识点。基本上所以的优化算法都是在反向传播算出梯度之后进行改进的。同时，也因为反向传播算法是一个递归的形式，一层一层的向后传播误差即可，很容易实现（这部分听不懂没关系，下面介绍）。不要被反向传播吓到，掌握其核心思想就很容易自己手推出...
CV面试题目--基础理论部分
you 是 mine
07-23 2557
1. 如何应对图片光照变化大 1、直方图均衡化 2、对比度拉伸，或者调节 3、若受光源影响，使得图片整体色彩往一方面移动，用白平衡算法进行修正，使其发黄、发蓝、发红的照片更加趋于自然光下的图像 4、若是过爆或者过暗，可是设计阈值函数，不用全局阈值，对特定区域进行特定阈值分割。 5、若是太暗，可以采用对数变化，对数图像增强是图像增强的一种常见方法，其公式为：S = c log (r+1)，对数使亮度比较低的像素转换成亮度比较高的，而亮度较高的像素则几乎没有变化，这样就使图片整体变亮。 6、采用拉普拉斯算子增强
PyTorch入门（三）损失函数与反向传播
1900的博客
12-24 5527
误差函数与反向传播（误差函数、梯度下降、优化器）
深入理解神经网络中的反向传播过程
。
04-20 1347
神经网络目录写在前面神经网络结构神经网络作用神经网络传播过程前向传播1.输入层---->隐含层2.隐含层---->输出层反向传播1.计算总误差2.隐含层---->输出层的权值更新3.隐含层---->隐含层的权值更新总结python实现代码 写在前面 本文转自 作者：Charlotte77 出处：http://www.cnblogs.com/charlotte77/ 最近几天...
HC18P23XL OTP单片机：功能与应用
"HC18P23XL是一款由上海芯圣电子股份有限公司推出的8位OTP单片机，集成了丰富的功能，如8×16位一次性编程ROM，512×8位数据寄存器RAM，6个双向I/O口，3个Timer定时器/计数器，2个CCP模块，UART和SPI通信接口，以及8...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值