Pytroch_Sequential使用、损失函数、反向传播和优化器

2023-11-03 13:52
文章标签 函数 使用 优化 传播 反向 损失 sequential pytroch

本文主要是介绍Pytroch_Sequential使用、损失函数、反向传播和优化器，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Pytroch_Sequential使用、损失函数、反向传播和优化器

文章目录

    • nn.Sequential
    • 搭建小实战
    • 损失函数与反向传播
    • 优化器

nn.Sequential

nn.Sequential是一个有序的容器，用于搭建神经网络的模块被按照被传入构造器的顺序添加到nn.Sequential()容器中。

在这里插入图片描述

在这里插入图片描述

import torch.nn  as nn
from collections import OrderedDict
# Using Sequential to create a small model. When `model` is run,
# input will first be passed to `Conv2d(1,20,5)`. The output of
# `Conv2d(1,20,5)` will be used as the input to the first
# `ReLU`; the output of the first `ReLU` will become the input
# for `Conv2d(20,64,5)`. Finally, the output of
# `Conv2d(20,64,5)` will be used as input to the second `ReLU`
model = nn.Sequential(nn.Conv2d(1,20,5),nn.ReLU(),nn.Conv2d(20,64,5),nn.ReLU())# Using Sequential with OrderedDict. This is functionally the
# same as the above code
model = nn.Sequential(OrderedDict([('conv1', nn.Conv2d(1,20,5)),('relu1', nn.ReLU()),('conv2', nn.Conv2d(20,64,5)),('relu2', nn.ReLU())]))
print(model)

Sequential((conv1): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))(relu1): ReLU()(conv2): Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))(relu2): ReLU()
)

搭建小实战

还是以 C I F A R − 10 m o d e l CIFAR-10 model CIFAR−10model为例

在这里插入图片描述

  1. 输入图像是3通道的32×32的
  2. 先后经过卷积层(5×5的卷积核)
  3. 最大池化层(2×2的池化核)
  4. 卷积层(5×5的卷积核)
  5. 最大池化层(2×2的池化核)
  6. 卷积层(5×5的卷积核)
  7. 最大池化层(2×2的池化核)
  8. 拉直(flatten)
  9. 全连接层的处理，
  10. 最后输出的大小为10

基于以上的介绍，后续将利用Pytorch构建模型，实现 C I F A R − 10 m o d e l s t r u c t u r e CIFAR-10 \quad model \quad structure CIFAR−10modelstructure

参数说明：in_channels: int、out_channels: int,kernel_size: Union由input、特征图以及卷积核即可看出，而stride、padding需要通过公式计算得到。

特得到的具体的特征图尺寸的计算公式如下:
在这里插入图片描述

inputs : 3@32x32，3通道32x32的图片,5*5的kernel --> 特征图(Feature maps) : 32@32x32

即经过32个3@5x5的卷积层，输出尺寸没有变化（有x个卷积核即由x个卷积核，卷积核的通道数与输入的通道数相等）

由上述的计算公式来计算出 s t r i d e stride stride和 p a d d i n g padding padding

在这里插入图片描述

卷积层中的stride默认为1

池化层中的stride默认为kernel_size的大小

import torch
import torch.nn as nn
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

class BS(nn.Module):def __init__(self):super().__init__()self.conv1 = nn.Conv2d(in_channels=3,out_channels=32,kernel_size=5,stride=1,padding=2)  #stride和padding计算得到self.maxpool1 = nn.MaxPool2d(kernel_size=2)self.conv2 = nn.Conv2d(in_channels=32,out_channels=32,kernel_size=5,stride=1,padding=2)self.maxpool2 = nn.MaxPool2d(kernel_size=2)self.conv3 = nn.Conv2d(in_channels=32,out_channels=64,kernel_size=5,padding=2)self.maxpool3 = nn.MaxPool2d(kernel_size=2)self.flatten = nn.Flatten()  #变为63*4*4=1024self.linear1 = nn.Linear(in_features=1024, out_features=64)self.linear2 = nn.Linear(in_features=64, out_features=10)def forward(self,x):x = self.conv1(x)x = self.maxpool1(x)x = self.conv2(x)x = self.maxpool2(x)x = self.conv3(x)x = self.maxpool3(x)x = self.flatten(x)x = self.linear1(x)x = self.linear2(x)return xbs = BS()
bs

BS((conv1): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))(maxpool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(conv2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))(maxpool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(conv3): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))(maxpool3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(flatten): Flatten(start_dim=1, end_dim=-1)(linear1): Linear(in_features=1024, out_features=64, bias=True)(linear2): Linear(in_features=64, out_features=10, bias=True)
)

利用Sequential优化代码，并在tensorboard显示

.add_graph函数用于将PyTorch模型图添加到TensorBoard中。通过这个函数，您可以以可视化的方式展示模型的计算图，使其他人更容易理解您的模型结构和工作流程。

add_graph(model, input_to_model, strip_default_attributes=True)
  • model：要添加的PyTorch模型。
  • input_to_model：用于生成模型图的输入数据。
  • strip_default_attributes：是否删除模型中的默认属性，默认为True。
class BS(nn.Module):def __init__(self):super().__init__()self.model = nn.Sequential(nn.Conv2d(in_channels=3,out_channels=32,kernel_size=5,stride=1,padding=2),  #stride和padding计算得到nn.MaxPool2d(kernel_size=2),nn.Conv2d(in_channels=32,out_channels=32,kernel_size=5,stride=1,padding=2),nn.MaxPool2d(kernel_size=2),nn.Conv2d(in_channels=32,out_channels=64,kernel_size=5,padding=2),nn.MaxPool2d(kernel_size=2),nn.Flatten(),  #变为64*4*4=1024nn.Linear(in_features=1024, out_features=64),nn.Linear(in_features=64, out_features=10),)def forward(self,x):x = self.model(x)return xbs = BS()
print(bs)

BS((model): Sequential((0): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))(1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))(3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(4): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))(5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(6): Flatten(start_dim=1, end_dim=-1)(7): Linear(in_features=1024, out_features=64, bias=True)(8): Linear(in_features=64, out_features=10, bias=True))
)

# 在tensorboard中显示
input_ = torch.ones((64,3,32,32))
writer = SummaryWriter(".logs")
writer.add_graph(bs, input_)  # 定义的模型，数据
writer.close()

利用tensorboard可视化网络结构graph如下
在这里插入图片描述

损失函数与反向传播

计算模型目标输出和实际输出之间的误差。并通过反向传播算法更新模型的权重和参数，以减小预测输出和实际输出之间的误差。

  • 计算实际输出和目标输出之间的差距
  • 为更新输出提供一定依据(反向传播)

不同的模型用的损失函数一般也不一样。
在这里插入图片描述

平均绝对误差MAE Mean Absolute Error

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

在这里插入图片描述

import torch
import torch.nn as nn
# 实例化
criterion1 = nn.L1Loss(reduction='mean')#mean
criterion2 = nn.L1Loss(reduction="sum")#sum
output = torch.tensor([1.0, 2.0, 3.0])#或dtype=torch.float32
target = torch.tensor([2.0, 2.0, 2.0])#或dtype=torch.float32
# 平均值损失值
loss = criterion1(output, target)
print(loss)  # 输出：tensor(0.6667)
# 误差和
loss1 = criterion2(output,target)
print(loss1) # tensor(2.)

tensor(0.6667)
tensor(2.)

loss = nn.L1Loss()
input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)
output = loss(input, target)
output.backward()
output

tensor(1.0721, grad_fn=<MeanBackward0>)

均方误差MSE Mean-Square Error
在这里插入图片描述

torch.nn.MSELoss(size_average=None, reduce=None, reduction=‘mean’)

在这里插入图片描述

import torch.nn as nn
# 实例化
criterion1 = nn.MSELoss(reduction='mean')
criterion2 = nn.MSELoss(reduction="sum")
output = torch.tensor([1, 2, 3],dtype=torch.float32)
target = torch.tensor([1, 2, 5],dtype=torch.float32)
# 平均值损失值
loss = criterion1(output, target)
print(loss)  # 输出：tensor(1.3333)
# 误差和
loss1 = criterion2(output,target)
print(loss1) # tensor(4.)

tensor(1.3333)
tensor(4.)

交叉熵损失 CrossEntropyLoss

torch.nn.CrossEntropyLoss(weight=None,size_average=None,ignore_index=-100,reduce=None,reduction='mean',label_smoothing=0.0)

当你有一个不平衡的训练集时，这是特别有用的
在这里插入图片描述

import torch
import torch.nn as nn# 设置三分类问题，假设是人的概率是0.1，狗的概率是0.2，猫的概率是0.3
x = torch.tensor([0.1, 0.2, 0.3])
print(x)
y = torch.tensor([1]) # 设目标标签为1，即0.2狗对应的标签,目标标签张量y
x = torch.reshape(x, (1, 3))  # tensor([[0.1000, 0.2000, 0.3000]]),批次大小为1，分类数3，即为3分类
print(x)
print(y)
# 实例化对象
loss_cross = nn.CrossEntropyLoss()
# 计算结果
result_cross = loss_cross(x, y)
print(result_cross)

tensor([0.1000, 0.2000, 0.3000])
tensor([[0.1000, 0.2000, 0.3000]])
tensor([1])
tensor(1.1019)

import torch
import torchvision
from torch.utils.data import DataLoader# 准备数据集
dataset = torchvision.datasets.CIFAR10(root="dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
# 数据集加载器
dataloader = DataLoader(dataset, batch_size=1)
"""
输入图像是3通道的32×32的，
先后经过卷积层(5×5的卷积核)、
最大池化层(2×2的池化核)、
卷积层(5×5的卷积核)、
最大池化层(2×2的池化核)、
卷积层(5×5的卷积核)、
最大池化层(2×2的池化核)、
拉直、
全连接层的处理，
最后输出的大小为10
"""# 搭建神经网络
class BS(nn.Module):def __init__(self):super().__init__()self.model = nn.Sequential(nn.Conv2d(in_channels=3,out_channels=32,kernel_size=5,stride=1,padding=2),  #stride和padding计算得到nn.MaxPool2d(kernel_size=2),nn.Conv2d(in_channels=32,out_channels=32,kernel_size=5,stride=1,padding=2),nn.MaxPool2d(kernel_size=2),nn.Conv2d(in_channels=32,out_channels=64,kernel_size=5,padding=2),nn.MaxPool2d(kernel_size=2),nn.Flatten(),  #变为64*4*4=1024nn.Linear(in_features=1024, out_features=64),nn.Linear(in_features=64, out_features=10),)def forward(self, x):x = self.model(x)return x# 实例化
bs = BS()
loss = torch.nn.CrossEntropyLoss()
# 对每一张图片进行CrossEntropyLoss损失函数计算
# 使用损失函数loss计算预测结果和目标标签之间的交叉熵损失for inputs,labels in dataloader:outputs = bs(inputs)result = loss(outputs,labels)print(result)
tensor(2.3497, grad_fn=<NllLossBackward0>)
tensor(2.2470, grad_fn=<NllLossBackward0>)
tensor(2.2408, grad_fn=<NllLossBackward0>)
tensor(2.2437, grad_fn=<NllLossBackward0>)
tensor(2.3121, grad_fn=<NllLossBackward0>)
........

优化器

优化器(Optimizer)是用于更新神经网络参数的工具

它根据计算得到的损失函数的梯度来调整模型的参数，以最小化损失函数并改善模型的性能

在这里插入图片描述
常见的优化器包括:SGD、Adam

optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

model.parameters()用于获取模型的可学习参数

learning rate,lr表示学习率，即每次参数更新的步长

在每个训练批次中，需要执行以下操作:

  1. 输入训练数据到模型中，进行前向传播

  2. 根据损失函数计算损失

  3. 调用优化器的zero_grad()方法清零之前的梯度

  4. 调用backward()方法进行反向传播，计算梯度

  5. 调用优化器的step()方法更新模型参数

伪代码如下(运行不了的)

import torch
import torch.optim as optim# Step 1: 定义模型
model = ...
# Step 2: 定义优化器
optimizer = optim.SGD(model.parameters(), lr=0.01)
# Step 3: 定义损失函数
criterion = ...
# Step 4: 训练循环
for inputs, labels in dataloader:# 前向传播outputs = model(inputs)# 计算损失loss = criterion(outputs, labels)# 清零梯度optimizer.zero_grad()# 反向传播,得到梯度loss.backward()# 更新参数，根据梯度就行优化optimizer.step()

在上述模型代码中，SGD作为优化器，lr为0.01。同时根据具体任务选择适合的损失函数，例如torch.nn.CrossEntropyLoss、torch.nn.MSELoss等，以CIFRA10为例

import torch
import torch.optim as optim
import torchvision
from torch.utils.data import DataLoaderdataset = torchvision.datasets.CIFAR10(root="dataset", train=False, transform=torchvision.transforms.ToTensor(),download=True)
dataloader = DataLoader(dataset,batch_size=1)

class BS(nn.Module):def __init__(self):super().__init__()self.model = nn.Sequential(nn.Conv2d(in_channels=3,out_channels=32,kernel_size=5,stride=1,padding=2),  #stride和padding计算得到nn.MaxPool2d(kernel_size=2),nn.Conv2d(in_channels=32,out_channels=32,kernel_size=5,stride=1,padding=2),nn.MaxPool2d(kernel_size=2),nn.Conv2d(in_channels=32,out_channels=64,kernel_size=5,padding=2),nn.MaxPool2d(kernel_size=2),nn.Flatten(),  #变为64*4*4=1024nn.Linear(in_features=1024, out_features=64),nn.Linear(in_features=64, out_features=10),)def forward(self, x):x = self.model(x)return xmodel = BS()  #定义model
optimizer = optim.SGD(model.parameters(), lr=0.01)  #定义优化器SGD
criterion = nn.CrossEntropyLoss()  #定义损失函数，交叉熵损失函数'''循环一次，只对数据就行了一轮的学习'''
for inputs, labels in dataloader:# 前向传播outputs = model(inputs)# 计算损失loss = criterion(outputs, labels)# 清零梯度optimizer.zero_grad()# 反向传播loss.backward()# 更新参数optimizer.step()# 打印经过优化器后的结果print(loss)"""训练循环20次"""
# for epoch in range(20):
#     running_loss = 0.0
#     for inputs, labels in dataloader:
#         # 前向传播
#         outputs = model(inputs)
#         # 计算损失
#         loss = criterion(outputs,labels)
#         # 清零梯度
#         optimizer.zero_grad()
#         # 反向传播
#         loss.backward()
#         # 更新参数
#         optimizer.step()
#         # 打印经过优化器后的结果
#         running_loss = running_loss + loss
#     print(running_loss)

Files already downloaded and verified
tensor(2.3942, grad_fn=<NllLossBackward0>)
tensor(2.2891, grad_fn=<NllLossBackward0>)
tensor(2.2345, grad_fn=<NllLossBackward0>)
tensor(2.2888, grad_fn=<NllLossBackward0>)
tensor(2.2786, grad_fn=<NllLossBackward0>)
........

在这里插入图片描述

这篇关于Pytroch_Sequential使用、损失函数、反向传播和优化器的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/338627。

相关文章

vue使用docxtemplater导出word

vue使用docxtemplater导出word

《vue使用docxtemplater导出word》docxtemplater是一种邮件合并工具,以编程方式使用并处理条件、循环,并且可以扩展以插入任何内容,下面我们来看看如何使用docxtempl... 目录docxtemplatervue使用docxtemplater导出word安装常用语法 封装导出方
阅读更多...
SpringBoot3实现Gzip压缩优化的技术指南

SpringBoot3实现Gzip压缩优化的技术指南

《SpringBoot3实现Gzip压缩优化的技术指南》随着Web应用的用户量和数据量增加,网络带宽和页面加载速度逐渐成为瓶颈,为了减少数据传输量,提高用户体验,我们可以使用Gzip压缩HTTP响应,... 目录1、简述2、配置2.1 添加依赖2.2 配置 Gzip 压缩3、服务端应用4、前端应用4.1 N
阅读更多...
Linux换行符的使用方法详解

Linux换行符的使用方法详解

《Linux换行符的使用方法详解》本文介绍了Linux中常用的换行符LF及其在文件中的表示,展示了如何使用sed命令替换换行符,并列举了与换行符处理相关的Linux命令,通过代码讲解的非常详细,需要的... 目录简介检测文件中的换行符使用 cat -A 查看换行符使用 od -c 检查字符换行符格式转换将
阅读更多...
使用Jackson进行JSON生成与解析的新手指南

使用Jackson进行JSON生成与解析的新手指南

《使用Jackson进行JSON生成与解析的新手指南》这篇文章主要为大家详细介绍了如何使用Jackson进行JSON生成与解析处理,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录1. 核心依赖2. 基础用法2.1 对象转 jsON（序列化）2.2 JSON 转对象（反序列化）3.
阅读更多...
使用Python实现快速搭建本地HTTP服务器

使用Python实现快速搭建本地HTTP服务器

《使用Python实现快速搭建本地HTTP服务器》：本文主要介绍如何使用Python快速搭建本地HTTP服务器,轻松实现一键HTTP文件共享,同时结合二维码技术,让访问更简单,感兴趣的小伙伴可以了... 目录1. 概述2. 快速搭建 HTTP 文件共享服务2.1 核心思路2.2 代码实现2.3 代码解读3.
阅读更多...
Elasticsearch 在 Java 中的使用教程

Elasticsearch 在 Java 中的使用教程

《Elasticsearch在Java中的使用教程》Elasticsearch是一个分布式搜索和分析引擎,基于ApacheLucene构建,能够实现实时数据的存储、搜索、和分析,它广泛应用于全文... 目录1. Elasticsearch 简介2. 环境准备2.1 安装 Elasticsearch2.2 J
阅读更多...
使用C#代码在PDF文档中添加、删除和替换图片

使用C#代码在PDF文档中添加、删除和替换图片

《使用C#代码在PDF文档中添加、删除和替换图片》在当今数字化文档处理场景中,动态操作PDF文档中的图像已成为企业级应用开发的核心需求之一,本文将介绍如何在.NET平台使用C#代码在PDF文档中添加、... 目录引言用C#添加图片到PDF文档用C#删除PDF文档中的图片用C#替换PDF文档中的图片引言在当
阅读更多...
Kotlin 作用域函数apply、let、run、with、also使用指南

Kotlin 作用域函数apply、let、run、with、also使用指南

《Kotlin作用域函数apply、let、run、with、also使用指南》在Kotlin开发中,作用域函数（ScopeFunctions）是一组能让代码更简洁、更函数式的高阶函数,本文将... 目录一、引言：为什么需要作用域函数？二、作用域函China编程数详解1. apply：对象配置的 “流式构建器”最
阅读更多...
Java中List的contains()方法的使用小结

Java中List的contains()方法的使用小结

《Java中List的contains()方法的使用小结》List的contains()方法用于检查列表中是否包含指定的元素,借助equals()方法进行判断,下面就来介绍Java中List的c... 目录详细展开1. 方法签名2. 工作原理3. 使用示例4. 注意事项总结结论：List 的 contain
阅读更多...
C#使用SQLite进行大数据量高效处理的代码示例

C#使用SQLite进行大数据量高效处理的代码示例

《C#使用SQLite进行大数据量高效处理的代码示例》在软件开发中,高效处理大数据量是一个常见且具有挑战性的任务,SQLite因其零配置、嵌入式、跨平台的特性,成为许多开发者的首选数据库,本文将深入探... 目录前言准备工作数据实体核心技术批量插入：从乌龟到猎豹的蜕变分页查询：加载百万数据异步处理：拒绝界面
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2