[土堆]深度学习快速入门教程笔记——损失函数、反向传播与优化器——013

已于 2023-10-28 19:57:43 修改
阅读量166 收藏
点赞数
分类专栏： [土堆]Pytorch笔记 文章标签： 深度学习 笔记 人工智能
于 2023-10-28 19:56:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73697075/article/details/134093244
版权

1.损失函数

  1. 衡量模型性能： 损失函数能够量化模型的预测结果与实际标签之间的误差。通过最小化损失函数，我们可以使得模型的预测结果尽可能接近实际标签，从而提高模型的性能。

  2. 指导模型学习： 在训练过程中，优化算法（比如梯度下降）使用损失函数的梯度信息来更新模型参数。通过最小化损失函数，模型可以根据训练数据不断调整自身的参数，使得预测结果更加准确。

2.L1loss函数

该函数在Pytorch官网解释如下：

计算示例如下：

代码示例:

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)
inputs = torch.reshape(inputs,(1,1,1,3))
targets = torch.reshape(targets,(1,1,1,3))
loss = L1Loss()  # 默认为 maen
result = loss(inputs,targets)
print(result)
result: tensor(0.6667)

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)
inputs = torch.reshape(inputs,(1,1,1,3))
targets = torch.reshape(targets,(1,1,1,3))
loss = L1Loss(reduction='sum') # 修改为sum，三个值的差值，然后取和
result = loss(inputs,targets)
print(result)
RESULT: tensor(2.)

 2.MSE损失函数

该函数在Pytorch官网解释如下：

import torch
from torch.nn import L1Loss
from torch import nn
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,1,1,3))
loss_mse = nn.MSELoss()
result_mse = loss_mse(inputs,targets)
print(result_mse)

 result：tensor(1.3333)

4.交叉熵损失函数

 交叉熵损失函数数学公式如下图所示：

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

x = torch.tensor([0.1,0.2,0.3])
y = torch.tensor([1])
x = torch.reshape(x,(1,3)) # 1的 batch_size，有三类
loss_cross = nn.CrossEntropyLoss()
result_cross = loss_cross(x,y)
print(result_cross)
result：tensor(1.1019)

5.数据集计算损失函数

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

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

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()        
        self.model1 = Sequential(
            Conv2d(3,32,5,padding=2),
            MaxPool2d(2),
            Conv2d(32,32,5,padding=2),
            MaxPool2d(2),
            Conv2d(32,64,5,padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024,64),
            Linear(64,10)
        )
        
    def forward(self, x):
        x = self.model1(x)
        return x
    
loss = nn.CrossEntropyLoss() # 交叉熵    
tudui = Tudui()
for data in dataloader:
    imgs, targets = data
    outputs = tudui(imgs)
    result_loss = loss(outputs, targets) # 计算实际输出与目标输出的差距
    print(result_loss)
Files already downloaded and verified
tensor(2.2994, grad_fn=<NllLossBackward0>)
tensor(2.2952, grad_fn=<NllLossBackward0>)
tensor(2.3162, grad_fn=<NllLossBackward0>)
tensor(2.3234, grad_fn=<NllLossBackward0>)
tensor(2.2983, grad_fn=<NllLossBackward0>)
tensor(2.3051, grad_fn=<NllLossBackward0>)……

6.损失函数反向传播 

损失函数的反向传播（Backpropagation）是深度学习中用于训练神经网络的关键算法。在训练过程中，我们的目标是最小化损失函数，使得模型的预测结果尽可能接近实际标签。反向传播算法是一种计算梯度的方法，它允许我们根据损失函数的梯度信息来更新神经网络的参数，使得损失函数逐渐减小，从而提高模型的性能。

以下是损失函数反向传播的基本步骤：

  1. 前向传播（Forward Propagation）： 首先，通过神经网络的前向传播过程，将输入数据送入网络，逐层计算神经网络的输出值（预测值）。

  2. 计算损失（Compute Loss）： 使用损失函数计算预测值与真实标签之间的差距（损失值）。损失函数的选择通常依赖于具体的问题类型。

  3. 反向传播（Backward Propagation）： 反向传播是指从损失函数开始，沿着神经网络的反方向计算损失函数对每个参数的梯度。这是通过链式法则实现的，将梯度从输出层传递回输入层。

    • 计算输出层的梯度： 首先，计算损失函数对输出层的输出的梯度。

    • 计算隐藏层的梯度： 然后，使用链式法则，将输出层的梯度向前传递到隐藏层，并计算隐藏层的梯度。

    • 更新参数： 最后，使用计算得到的梯度信息，通过梯度下降或其它优化算法，更新神经网络的参数，减小损失函数的值。

  4. 迭代优化： 重复进行前向传播、损失计算和反向传播的过程，直到损失函数收敛到一个满意的值或达到预定的训练次数。

通过反向传播，神经网络能够根据损失函数的梯度信息，调整网络中的权重和偏置，从而使得网络的预测结果逐渐接近实际标签，实现模型的训练和优化。

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

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

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()        
        self.model1 = Sequential(
            Conv2d(3,32,5,padding=2),
            MaxPool2d(2),
            Conv2d(32,32,5,padding=2),
            MaxPool2d(2),
            Conv2d(32,64,5,padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024,64),
            Linear(64,10)
        )
        
    def forward(self, x):
        x = self.model1(x)
        return x
    
loss = nn.CrossEntropyLoss() # 交叉熵    
tudui = Tudui()
for data in dataloader:
    imgs, targets = data
    outputs = tudui(imgs)
    result_loss = loss(outputs, targets) # 计算实际输出与目标输出的差距
    result_loss.backward()  
# 计算出来的 loss 值有 backward 方法属性，反向传播来计算每个节点的更新的参数。
#这里查看网络的属性 grad 梯度属性刚开始没有，反向传播计算出来后才有，
#后面优化器会利用梯度优化网络参数。

 7.优化器

在深度学习中，优化器（Optimizer）是一种用于最小化（或最大化）损失函数的算法。它的主要作用是根据损失函数的梯度信息，调整模型的参数，使得损失函数逐渐减小，从而提高模型的性能。不同的优化器采用不同的策略来更新模型的参数。

以下是一些常用的优化器：

  1. 梯度下降法（Gradient Descent）： 是最基本的优化算法之一。它根据损失函数的梯度信息，以学习率为参数，沿着梯度的反方向更新模型的参数，使得损失函数逐渐减小。

  2. 随机梯度下降法（Stochastic Gradient Descent，SGD）： 是梯度下降法的变种，每次迭代中只随机选择一个样本来计算梯度并更新参数。SGD的优势在于对大规模数据集的训练速度较快。

  3. 批量梯度下降法（Batch Gradient Descent）： 在每次迭代中，使用整个训练数据集计算梯度。这种方法通常能够更准确地估计梯度，但计算开销较大。

  4. 小批量梯度下降法（Mini-batch Gradient Descent）： 是SGD和批量梯度下降法的折中方案。每次迭代中，随机选择一小部分样本（mini-batch）来计算梯度并更新参数。这种方法通常被广泛使用，因为它兼具计算效率和梯度估计的准确性。

  5. 自适应学习率优化器： 这类优化器根据参数的历史梯度信息自适应地调整学习率。常见的自适应学习率优化器包括Adagrad、RMSprop和Adam。它们分别考虑了参数的历史梯度平方和、指数加权移动平均以及梯度的一阶和二阶矩估计，以动态地调整学习率，提高了训练的效率和稳定性。

  6. 学习率衰减（Learning Rate Decay）： 在训练过程中逐渐降低学习率，使得模型在接近最优解时更加稳定。学习率衰减可以与上述任何一种优化器结合使用。

优化器使用步骤：（以SGD为例）

#构造一个优化器对象
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
for input, target in dataset:
    optimizer.zero_grad() #梯度要清零，如果梯度不清零会导致梯度累加。
    output = model(input)
    loss = loss_fn(output, target)
    loss.backward()
    optimizer.step() #所有优化器都实现了一个step()方法，用于更新参数。

3.神经网络优化多轮

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

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

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()        
        self.model1 = Sequential(
            Conv2d(3,32,5,padding=2),
            MaxPool2d(2),
            Conv2d(32,32,5,padding=2),
            MaxPool2d(2),
            Conv2d(32,64,5,padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024,64),
            Linear(64,10)
        )
        
    def forward(self, x):
        x = self.model1(x)
        return x
    
loss = nn.CrossEntropyLoss() # 交叉熵    
tudui = Tudui()
optim = torch.optim.SGD(tudui.parameters(),lr=0.01)   # 随机梯度下降优化器
for epoch in range(20):
    running_loss = 0.0
    for data in dataloader:
        imgs, targets = data
        outputs = tudui(imgs)
        result_loss = loss(outputs, targets) # 计算实际输出与目标输出的差距
        optim.zero_grad()  # 梯度清零
        result_loss.backward() # 反向传播，计算损失函数的梯度
        optim.step()   # 根据梯度，对网络的参数进行调优
        running_loss = running_loss + result_loss
    print(running_loss) # 对这一轮所有误差的总和

4.神经网络学习率优化

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

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

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()        
        self.model1 = Sequential(
            Conv2d(3,32,5,padding=2),
            MaxPool2d(2),
            Conv2d(32,32,5,padding=2),
            MaxPool2d(2),
            Conv2d(32,64,5,padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024,64),
            Linear(64,10)
        )
        
    def forward(self, x):
        x = self.model1(x)
        return x
    
loss = nn.CrossEntropyLoss() # 交叉熵    
tudui = Tudui()
optim = torch.optim.SGD(tudui.parameters(),lr=0.01)   # 随机梯度下降优化器
scheduler = torch.optim.lr_scheduler.StepLR(optim, step_size=5, gamma=0.1) 
# 每过 step_size 更新一次优化器，更新是学习率为原来的学习率的的 0.1 倍    
for epoch in range(20):
    running_loss = 0.0
    for data in dataloader:
        imgs, targets = data
        outputs = tudui(imgs)
        result_loss = loss(outputs, targets) # 计算实际输出与目标输出的差距
        optim.zero_grad()  # 梯度清零
        result_loss.backward() # 反向传播，计算损失函数的梯度
        optim.step()   # 根据梯度，对网络的参数进行调优
        scheduler.step() # 学习率太小了，所以20个轮次后，相当于没走多少
        running_loss = running_loss + result_loss
    print(running_loss) # 对这一轮所有误差的总和

优化结果：

tensor(357.9097, grad_fn=<AddBackward0>)
tensor(351.5848, grad_fn=<AddBackward0>)
tensor(329.7575, grad_fn=<AddBackward0>)
tensor(315.6645, grad_fn=<AddBackward0>)
tensor(307.6896, grad_fn=<AddBackward0>)
tensor(299.2968, grad_fn=<AddBackward0>)
tensor(290.0585, grad_fn=<AddBackward0>)
tensor(282.6966, grad_fn=<AddBackward0>)
tensor(275.7931, grad_fn=<AddBackward0>)
tensor(269.5059, grad_fn=<AddBackward0>)
tensor(263.6960, grad_fn=<AddBackward0>)
tensor(258.2791, grad_fn=<AddBackward0>)
tensor(253.1974, grad_fn=<AddBackward0>)
tensor(248.5044, grad_fn=<AddBackward0>)
tensor(244.2687, grad_fn=<AddBackward0>)
tensor(240.4644, grad_fn=<AddBackward0>)
tensor(236.9770, grad_fn=<AddBackward0>)
tensor(233.7112, grad_fn=<AddBackward0>)

Asa13opp
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PyTorch学习笔记（6）损失函数与优化器
游星的博客
08-20 437
损失函数与优化器初体验
[土堆]深度学习快速入门教程笔记——线性层及其他层——011
m0_73697075的博客
10-27 1197
神经网络是一种受到人脑神经元结构启发的计算模型，用于机器学习和人工智能任务。它由大量相互连接的人工神经元（也称为节点或神经元）组成，这些神经元按层次排列，分为输入层、隐藏层（可以有多个）和输出层。
损失函数及优化器
霜叶的博客
09-23 276
1、损失函数 2、优化器
损失函数和优化器
weixin_52366977的博客
09-14 1112
用于将梯度清零，pytorch不会自动清零梯度，所以每次更新前会进行该操作获取当前模型的当前参数，返回一个字典，key为各层参数名，value为参数值用于将state_dict 中的参数加载到当前网络，常用于迁移学习给 optimizer 管理的参数组中增加一组参数，可为该组参数定制 lr, momentum, weight_decay 等，在 finetune 中常用。执行一步权值更新, 其中可传入参数 closure（一个闭包）。如，当采用 LBFGS优化方法时，需要多次计算，
pytorch-损失函数-优化器
点绛唇
08-31 252
损失函数和构建网络有点类似，都是有“输入”和“输出”来组成，然后还有就是，同样也需要进行反向传播。 import torch import torch.nn as nn import torch.optim as optim # ============================ step 3/5 损失函数 ============================ criterion = nn.CrossEntropyLoss() .
学习笔记(b站视频)PyTorch深度学习快速入门教程（绝对通俗易懂！）小土堆
06-03
本教程基于"B站"上的视频课程“PyTorch深度学习快速入门教程”，由"小土堆"主讲，旨在帮助初学者迅速掌握PyTorch的基础知识。 首先，我们需要理解PyTorch的核心概念：张量(Tensors)。张量是PyTorch中的基本数据结构...
深度学习 Pytorch 小土堆笔记
02-02
小土堆Pytorch笔记
PyTorch深度学习 —— 基于小土堆视频等资料.zip
05-09
"小土堆"可能是对某个教程或系列视频的昵称，这些资源可能涵盖了PyTorch的基础到高级应用，帮助学习者深入理解这一框架。 一、PyTorch基础 1. 张量(Tensors)：PyTorch的核心是张量，它是多维数组，可以进行各种数学...
神经网络深度学习小土堆笔记
最新发布
06-22
神经网络深度学习小土堆笔记
最全面的 深度学习 笔记【土堆 Pytorch】【李沐 动手学深度学习】【吴恩达 深度学习】
05-16
1. **基础知识**：从最基础的张量操作开始，介绍Pytorch的核心概念和使用方法，包括自动求导机制、模型构建、损失函数和优化器等。 2. **神经网络构建**：逐步讲解如何使用Pytorch构建和训练神经网络，涵盖了全连接...
Pytorch深度学习快速入门教程 -- 土堆教程笔记（一）
weixin_43636084的博客
07-25 1311
Pytorch入门学习（一）
pytorch深度学习小土堆的训练模型
weixin_44095244的博客
10-06 440
1.将建立的深度学习的模型放入一个py文件中，在mian函数中进行全1的模型检测 import torch from torch import nn from torch.nn import Conv2d, MaxPool2d, Flatten,Linear,Sequential class Tudui(nn.Module): def __init__(self): super(Tudui, self).__init__() self.model1 = Sequ
Pytorch深度学习快速入门教程 -- 土堆教程笔记（二）
weixin_43636084的博客
07-25 1037
Pytorch入门学习（二）
3.损失函数，反向传播，优化器
sgfsfgs的博客
08-07 1887
本文讲解了常见的一些损失函数，对于交叉熵损失函数进行了重点描述，也讲了反向传播和优化器部分，同时采用自适应学习率算法能够加速loss的收敛情况。
CS231N 笔记2_损失函数和优化器
时光机 °的博客
11-08 828
多类SVM损失函数，又称hinge loss： 这个函数可以认为是计算得分比正确分类的得分还要大的，以及差不多的。至于数字1，只是一个约定俗成的数字，其本身并不具有特殊意义，其数字的大小会随着W的变化而改变。 SVM loss和softmax的对数似然损失函数的对比： SVM对边界上及内部（得分大于正确项）的数字敏感，对边界外的数字不作用；而Softmax的对数似然综合考虑所有的得
【PyTorch】第五节：损失函数与优化器
荷叶田田的博客
04-14 723
在上一节实验中，我们初步完成了梯度下降算法求解线性回归问题的实例。在这个过程中，我们自己定义了损失函数和权重的更新，其实PyTorch 也为我们直接定义了相应的工具包，使我们能够简洁快速的实现损失函数、权重的更新和梯度的求解。
day4_cs231n _ 损失函数与优化器
weixin_38646522的博客
03-06 1614
    今天我们要讨论损失函数(loss function)与优化器(optimizer)，上周我们说到了线性分类器，我们将图片当成一个矩阵放入计算机中，其次我们寻找一个权值矩阵W，这个W我们可以当做是每一行像素的得分来理解，然后根据这个W与我们的数据矩阵进行点积，最终算出一个得分，其实在于深度学习中，我们所要做的工作就是寻找这么权值矩阵。对于任意一个W矩阵，我们都会得到一个得分，就如下图中。我们...
3 损失函数和优化
fffupeng的博客
06-07 2150
为了描述之前建立的线性分类器的分类效果，我们引入的损失函数，顾名思义，损失函数越大误差也就越大。 在下图的任务中，将测试图片猫、车和青蛙输入网络，输出了一系列的数值，如下表。 很显然我们希望图片对应的分类数值越高越好，例如猫的图片对应cat，但是数值只有3.2，还不如对应的car的数值，所以该线性分类器会将猫这张图片分类为car。 下面引入svm loss函数： 其中Sj和Sy
深度学习（十）优化器与损失函数
QuinnHanz的博客
05-31 1874
sorry,笔记正在上传中。。。
"PyTorch入门实战学习笔记：小土堆教程全解析，附代码整合及学习视频链接
本文是根据b站上的PyTorch深度学习快速入门教程整理的学习笔记和代码整合。通过学习视频链接 https://www.bilibili.com/video/BV1hE411t7RN?spm_id_from=333.337.search-card.all.click ，作者整理出了一些PyTorch...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值