PyTorch(五)神经网络基础
创始人
2024-04-21 11:17:42
0

文章目录

    • Log
  • 一、Containers 基本骨架
    • 1. Module
    • 2. Sequential
  • 二、 Convolution Layers 卷积层
    • 1. torch.nn.functional
      • ① Conv2d
    • 2. torch.nn
      • ① Conv2d
  • 三、Pooling layers 池化层
    • 1. nn.MaxPool2d 下采样(最大池化)
  • 四、Non-linear Activations 非线性激活
    • 1. ReLU
    • 2. Sigmod
  • 五、Linear Layers 线性层
    • 1. torch.nn.Linear
  • 六、Loss Functions 损失函数
    • 1. torch.nn.L1Loss
    • 2. torch.nn.MSELoss
    • 3. torch.nn.CrossEntropyLoss
  • 七、Optimizer 优化器
    • 1. 简介
    • 2. 代码示例
  • 总结


Log

2022.11.29接着开启新的一章
2022.11.30继续学习
2022.12.01继续学习
2022.12.02继续学习
2022.12.03继续学习
2022.12.04继续学习
2022.12.08继续学习
2022.12.09继续学习
2022.12.11继续学习,结束吧


  • 关于神经网络(NN,Neural Network)的工具都在 torch.nn 里面

一、Containers 基本骨架

1. Module

  • 对于所有神经网络的一个基本的类,提供一个基本骨架,所有自建的网络都需要继承该类
  • 官方文档中的示例模板代码如下:
import torch.nn as nn
import torch.nn.functional as Fclass Model(nn.Module):		# 类名可以改成自己的,但是必须要继承 nn.Module 类def __init__(self):		# 初始化函数super().__init__()	# 这句必须要有,调用父类的初始化函数self.conv1 = nn.Conv2d(1, 20, 5)self.conv2 = nn.Conv2d(20, 20, 5)def forward(self, x):		# 前向传播函数,处理输入数据并返回处理数据部分,应该在每个子类里重写x = F.relu(self.conv1(x))return F.relu(self.conv2(x))
  • 自己重写的时候可以纯手写,也可以通过以下方式来进行快速的实现:

    • 选择 Code⟶Generate\rm Code\longrightarrow GenerateCode⟶Generate
      在这里插入图片描述
    • 选择 OverrideMethods\rm Override\ \ MethodsOverride  Methods
      在这里插入图片描述
    • 再选择要重写的函数即可:
      在这里插入图片描述
  • 改写后的示例:

import torch
from torch import nnclass MyModel(nn.Module):def __init__(self):super().__init__()def forward(self, input):output = input + 1return outputmo = MyModel()  # 创建一个神经网络
x = torch.tensor(1.0)   # 创建数据
output = mo(x)  # 使用数据
print(output)

2. Sequential

  • 使用 Sequential 的好处是使代码变得简洁,如官方文档中的模板:
model = nn.Sequential(nn.Conv2d(1,20,5),nn.ReLU(),nn.Conv2d(20,64,5),nn.ReLU())
  • 这样就使两次卷积和非线性激活的操作变得比较清晰简洁。

  • 将要实现的网络模型如下:
    在这里插入图片描述

  • 示例代码如下(其中的 paddingstride 等参数可以结合上面的图片并通过官方文档 torch.nn.Conv2d 中的 shape\rm shapeshape 部分的公式推算出):

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.tensorboard import SummaryWriterclass MyModel(nn.Module):def __init__(self):super(MyModel, 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 xmo = MyModel()
print(mo)
input = torch.ones((64, 3, 32, 32))
output = mo(input)
print(output.shape)writer = SummaryWriter("logs_seq")
writer.add_graph(mo, input)
writer.close()
  • 可视化结果如下,可以通过双击其中的结点来展开查看内部的子结构:
    在这里插入图片描述

二、 Convolution Layers 卷积层

1. torch.nn.functional

  • torch.nn 是对 torch.nn.functional 的封装,因此 torch.nn.functional 中的内容会更加详细一些。

① Conv2d

  • torch.nn.functional.conv2d 常用的参数如下:
    • input:tensor 数据类型,要求形状的格式为 (minibatch,in_channels,iH,iW)(minibatch,in\_channels,iH,iW)(minibatch,in_channels,iH,iW)
    • weight:权重,即卷积核
    • bias:偏置,缺省值为 None
    • stride:步径,缺省值为 1,该参数的输入可为单值,也可为元组(sH,sW)(sH,sW)(sH,sW),横向和纵向
    • padding:缺省值为 0
  • 卷积操作的原理这里就不做更多介绍了,下面展示的是如何使用的代码:
import torch
import torch.nn.functional as Finput = torch.tensor([[1, 2, 0, 3, 1],[0, 1, 2, 3, 1],[1, 2, 1, 0, 0],[5, 2, 3, 1, 1],[2, 1, 0, 1, 1]])kernel = torch.tensor([[1, 2, 1],[0, 1, 0],[2, 1, 0]])input = torch.reshape(input, (1, 1, 5, 5))  # 1 batch_size, 1 通道, 5×5大小
kernel = torch.reshape(kernel, (1, 1, 3, 3))print(input.shape)  # 原大小为[5, 5],reshape后大小为[1, 1, 5, 5]
print(kernel.shape)  # 原大小为[3, 3],reshape后大小为[1, 1, 3, 3]output = F.conv2d(input, kernel, stride=1)      # 步长为 1
print(output)output2 = F.conv2d(input, kernel, stride=2)      # 步长为 2
print(output2)output3 = F.conv2d(input, kernel, stride=1, padding=1)      # padding是对图像边缘的填充
print(output3)

2. torch.nn

① Conv2d

  • torch.nn.conv2d 常用的参数如下:
    • in_channels:输入通道数,彩色图像一般为 3
    • out_channels:输出通道数
    • kernel_size:卷积核大小
    • stride:步径,缺省值为 1,该参数的输入可为单值,也可为元组(sH,sW)(sH,sW)(sH,sW),纵向和横向
    • padding:缺省值为 0
    • dilation:卷积核每个对应位的距离,缺省值为 1
    • groups:缺省值为 1 ,一般情况不会用到,只在分组卷积时才会用到
    • bias:偏置,缺省值为 True,即在最后的结果上加减一个常数
    • padding_mode:缺省值为’zero’,padding 填充时会用到,选择 padding 的填充模式
  • 对于上面的概念比较模糊,可以看看这个可视化的图像来进一步理解:
    在这里插入图片描述
  • 仍然使用 CIFAR10\rm CIFAR10CIFAR10 数据集,代码示例如下:
import torch
import torchvision
from torch import nn
from torch.nn import Conv2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriterdataset = torchvision.datasets.CIFAR10("../dataset/CIFAR10", train=False, transform=torchvision.transforms.ToTensor(),download=True)
dataloader = DataLoader(dataset, batch_size=64)class MyModel(nn.Module):def __init__(self):super(MyModel, self).__init__()self.conv1 = Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)def forward(self, x):x = self.conv1(x)return xmo = MyModel()writer = SummaryWriter("logs")step = 0
for data in dataloader:imgs, targets = dataoutput = mo(imgs)print(imgs.shape)print(output.shape)# torch.Size([64, 3, 32, 32])writer.add_images("input", imgs, step)# torch.Size([64, 6, 30, 30])  -> [xxx, 3, 30, 30]output = torch.reshape(output, (-1, 3, 30, 30))writer.add_images("output", output, step)step = step + 1
  • tensorboardtensorboardtensorboard 中的结果如下:
    在这里插入图片描述

三、Pooling layers 池化层

1. nn.MaxPool2d 下采样(最大池化)

  • 与之相对应的还有 nn.MaxUnpool2d 上采样。
  • torch.nn.MaxPool2d 常用的参数如下:
    • kernel_size:卷积核大小

    • stride:步径,缺省值为卷积核大小

    • padding:缺省值为 0

    • dilation:卷积核每个对应位的距离,缺省值为 1,示意图如下:
      在这里插入图片描述

    • return_indices :缺省值为 False,用得较少

    • ceil_mode :缺省值为 False,使用 floor 模式,当值为 True 时使用 ciel 模式,和卷积核相乘时选中的图像的大小小于卷积核大小时进行保留。

  • 输入和输出的数据都是四维的,示例代码如下:
from torch import nn
from torch.nn import MaxPool2dclass MyModel(nn.Module):def __init__(self):super(MyModel, self).__init__()self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=True)def forward(self, input):output = self.maxpool1(input)return outputinput = torch.tensor([[1, 2, 0, 3, 1],[0, 1, 2, 3, 1],[1, 2, 1, 0, 0],[5, 2, 3, 1, 1],[2, 1, 0, 1, 1]], dtype=torch.float32)input = torch.reshape(input, (-1, 1, 5, 5))
print(input.shape)
mo = MyModel()
output = mo(input)
print(output)
  • 最大池化的作用就是降低数据的维度,减少数据量,提高网络的训练速度,就相当于看视频从 1080p 到 720p,传达的内容没有受到太大的影响,但是视频文件的大小却大大减少。
  • 处理图片的代码示例:
import torch
import torchvision
from torch import nn
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriterclass MyModel(nn.Module):def __init__(self):super(MyModel, self).__init__()self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=False)def forward(self, input):output = self.maxpool1(input)return outputdataset = torchvision.datasets.CIFAR10("../dataset/CIFAR10", train=False, download=True,transform=torchvision.transforms.ToTensor())dataloader = DataLoader(dataset, batch_size=64)
mo = MyModel()
writer = SummaryWriter("logs_maxpool")
step = 0for data in dataloader:imgs, targets = datawriter.add_images("inputMP", imgs, step)output = mo(imgs)writer.add_images("outputMP", output, step)step = step + 1writer.close()
  • 运行结果如下:
    在这里插入图片描述

四、Non-linear Activations 非线性激活

  • 非线性激活是为了为我们的神经网络中引入一些非线性的特质,非线性越多的话就越容易训练出符合各种特征的模型,得到更好的泛化能力。

1. ReLU

在这里插入图片描述

  • 该类实现功能如下:
    ReLU(x)=(x)+=max(0,x)\rm ReLU(x)=(x)^+=max(0,x) ReLU(x)=(x)+=max(0,x)
  • 当输入小于 0 时会被截断
  • 在定义时有一个参数为 implace,缺省值为 False,作用是是否替换输入,即当该参数为 True 时,输入数据在处理换之后会被处理结果所替代。一般不填此参数,即保留原数据防止信息的丢失。
  • 示例代码如下:
import torch
from torch import nn
from torch.nn import ReLUclass MyModel(nn.Module):def __init__(self):super(MyModel, self).__init__()self.relu1 = ReLU()def forward(self, input):output = self.relu1(input)return outputinput = torch.tensor([[1, -0.5],[-1, 3]])input = torch.reshape(input, (-1, 1, 2, 2))
print(input.shape)
mo = MyModel()
output = mo(input)
print(output)

2. Sigmod

  • 都懂,原理略
  • 示例代码如下:
import torch
import torchvision
from torch import nn
from torch.nn import ReLU, Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriterclass MyModel(nn.Module):def __init__(self):super(MyModel, self).__init__()self.relu1 = ReLU()self.sigmoid1 = Sigmoid()def forward(self, input):output = self.sigmoid1(input)return outputdataset = torchvision.datasets.CIFAR10("../dataset/CIFAR10", train=False, download=True,transform=torchvision.transforms.ToTensor())dataloader = DataLoader(dataset, batch_size=64)mo = MyModel()writer = SummaryWriter("logs_sig")
step = 0
for data in dataloader:imgs, targets = datawriter.add_images("inputSig", imgs, global_step=step)output = mo(imgs)writer.add_images("outputSig", output, step)step += 1writer.close()
  • 运行结果如下:
    在这里插入图片描述

五、Linear Layers 线性层

1. torch.nn.Linear

  • 对输入应用如下的线性变换:
    y=xAT+by=xA^T+b y=xAT+b
  • torch.nn.Linear 的参数如下:
    • in_features :输入特征数
    • out_features :输出特征数
    • bias :偏置,即上面公式中的 b,缺省值为 True
  • 示例代码如下:
import torch
import torchvision
from torch import nn
from torch.nn import Linear
from torch.utils.data import DataLoaderdataset = torchvision.datasets.CIFAR10("../dataset/CIFAR10", train=False, transform=torchvision.transforms.ToTensor(),download=True)dataloader = DataLoader(dataset, batch_size=64)class MyModel(nn.Module):def __init__(self):super(MyModel, self).__init__()self.linear1 = Linear(196608, 10)def forward(self, input):output = self.linear1(input)return outputmo = MyModel()for data in dataloader:imgs, targets = dataprint(imgs.shape)# flatten 把图像展平的函数,输入的图像为 Tensor 类型output = torch.flatten(imgs)print(output.shape)output = mo(output)print(output.shape)
  • 其中 flatten 为将图像展平的函数。

六、Loss Functions 损失函数

  • 损失函数的作用:
    • 计算实际输出和目标之间的差距
    • 为我们更新输出提供一定的依据(反向传播)

1. torch.nn.L1Loss

  • torch.nn.L1Loss使用的示例代码如下:
import torch
from torch.nn import L1Lossinputs = 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))
# mean(Defalt): (0+0+2)/3 = 0.667
# sum: 0 + 0 + 2 = 2
loss = L1Loss(reduction='sum')
result = loss(inputs, targets)print(result)
  • 其中参数 reduction 的默认值是 mean,即求平均,对于代码中的例子,对应位置作差后取平均值得到的结果为 0.667,设置参数值为 sum 后达到的结果为 2。

2. torch.nn.MSELoss

  • 平方差(MSE,mean squared error)损失 torch.nn.MSELoss 的示例代码如下:
import torch
from torch import nninputs = 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))
# (0+0+0+2**2)/3 = 1.3333
loss_mse = nn.MSELoss()
result_mse = loss_mse(inputs, targets)print(result_mse)

3. torch.nn.CrossEntropyLoss

  • 交叉熵损失 torch.nn.CrossEntropyLoss (可以到这个官方文档中查看具体的公式以及说明)的示例代码如下:
import torch
from torch import nnx = torch.tensor([0.1, 0.2, 0.3])
y = torch.tensor([1])
x = torch.reshape(x, (1, 3))
loss_cross = nn.CrossEntropyLoss()
# -0.2+ln(exp(0.1)+exp(0.2)+exp(0.3))
result_cross = loss_cross(x, y)
print(result_cross)
  • 在网络中使用该类(复用之前 Sequential 中的网络代码):
import torchvision
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoaderdataset = torchvision.datasets.CIFAR10("../dataset/CIFAR10", train=False, transform=torchvision.transforms.ToTensor(),download=True)dataloader = DataLoader(dataset, batch_size=1)class MyModel(nn.Module):def __init__(self):super(MyModel, 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 xloss = nn.CrossEntropyLoss()
mo = MyModel()
for data in dataloader:imgs, targets = dataoutputs = mo(imgs)# print(outputs)# print(targets)result_loss = loss(outputs, targets)print(result_loss)# 反向传播计算梯度result_loss.backward()

七、Optimizer 优化器

  • 利用上一个章节中的反向传播计算出的梯度,使用优化器(torch.optim)对参数进行调整,进而实现误差降低的目的。

1. 简介

  • 优化器的使用步骤:
    1. 构造优化器
      例如:optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
      选择一个优化器对应的算法,然后在优化器中放入优化的参数、学习速率(LR)以及不同算法需要的特定的参数。
    2. 调用 step() 方法
      利用之前得到的梯度对参数进行更新

2. 代码示例

  • 使用随机梯度下降算法和上一章节的网络进行的计算,要点都写在代码的注释里了:
import torch
import torchvision
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader# 使用数据集并转成 tensor 数据类型
dataset = torchvision.datasets.CIFAR10("../dataset/CIFAR10", train=False, transform=torchvision.transforms.ToTensor(),download=True)
# 使用 DataLoader 加载数据集
dataloader = DataLoader(dataset, batch_size=1)class MyModel(nn.Module):def __init__(self):super(MyModel, 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 xloss = nn.CrossEntropyLoss()
mo = MyModel()
# 使用随机梯度下降算法(SGD)
optim = torch.optim.SGD(mo.parameters(), lr=0.01)
# 进行 20 轮循环
for epoch in range(20):# 每一轮的整体 lossrunning_loss = 0.0for data in dataloader:imgs, targets = dataoutputs = mo(imgs)result_loss = loss(outputs, targets)# 梯度清零,防止对下一轮循环产生影响optim.zero_grad()# 反向传播得到梯度result_loss.backward()# 对参数调优optim.step()print(result_loss)running_loss = running_loss + result_lossprint(running_loss)

总结

  • 本篇文章主要介绍了 Pytorch\rm PytorchPytorch 中 torch.nn 有关神经网络的相关内容,包括其中的相关模块的使用方法。
  • 容器(Containers) 中介绍了 torch.nn.Module,它是所有神经网络的一个基本的类,提供一个基本骨架,所有自建的网络都需要继承该类;同时还介绍了 torch.nn.Sequential,它的作用是整合不同的操作,使代码变得简洁。
  • 卷积层(Convolution Layers) 中介绍了 torch.nn.functionaltorch.nn 中的 Conv2d 类,torch.nn 是对 torch.nn.functional 的封装,因此 torch.nn.functional 中的内容会更加详细一些。
  • 池化层(Pooling layers) 中介绍了 nn.MaxPool2d 下采样(最大池化),它的作用就是降低数据的维度,减少数据量,提高网络的训练速度。
  • 非线性激活(Non-linear Activations) 中介绍了 ReLU 以及 Sigmod 的使用,非线性激活是为了为我们的神经网络中引入一些非线性的特质,非线性越多的话就越容易训练出符合各种特征的模型,得到更好的泛化能力。
  • 线性层(Linear Layers) 中介绍了 torch.nn.Linear,作用是进行线性变换。
  • 损失函数(Loss Functions) 中介绍了 L1LossMSELossCrossEntropyLoss三种损失函数的使用方法。
  • 最后还介绍了优化器(Optimizer),它的作用是利用反向传播计算出的梯度对参数进行调整,进而实现误差降低的目的。

相关内容

热门资讯

鸿蒙怎样还原安卓系统,系统切换... 你有没有想过,鸿蒙系统竟然能还原安卓系统?这听起来是不是有点像魔法一样神奇?没错,今天就要带你一探究...
电脑安卓转苹果系统,系统迁移攻... 你有没有想过,有一天你的安卓手机突然变成了苹果的忠实粉丝,想要跳槽到iOS的阵营呢?这可不是什么天方...
安卓xp系统下载地址,轻松获取... 你有没有想过,手机系统也能穿越时空?没错,今天我要给你揭秘的就是这样一个神奇的存在——安卓XP系统。...
安卓系统怎么清理相册,安卓系统... 手机里的相册是不是越来越臃肿了?每次打开都感觉像是在翻山越岭,找一张照片都要费老鼻子劲。别急,今天就...
安卓系统安装ios转移,轻松实... 你有没有想过,手机系统之间的转换竟然也能如此神奇?没错,今天就要来聊聊安卓系统安装iOS转移这个话题...
安卓系统与ios系统的优势,系... 你有没有想过,为什么你的手机里装的是安卓系统而不是苹果的iOS系统呢?或者反过来,为什么你的朋友用的...
安卓系统游戏如何升级,轻松实现... 亲爱的安卓玩家们,你是否也和我一样,对安卓系统游戏升级这件事充满了好奇和期待呢?每次游戏更新,都仿佛...
安卓系统蛋仔派对,安卓系统下的... 你有没有发现,最近你的手机里多了一个超级好玩的游戏?没错,就是安卓系统上的“蛋仔派对”!这款游戏可是...
坚果3安卓原生系统,深度体验原... 你有没有听说过坚果3这款手机?它可是最近在数码圈里火得一塌糊涂呢!今天,我就要来给你详细介绍一下这款...
安卓子系统点不开,排查与解决指... 最近是不是你也遇到了安卓子系统点不开的烦恼?这可真是让人头疼啊!别急,今天就来给你详细解析一下这个问...
安卓系统经常误删文件,如何有效... 你有没有遇到过这种情况?手机里的文件突然不见了,找来找去,怎么也找不到。别急,这可能是安卓系统的小调...
安卓51系统如何破解,轻松解锁... 安卓51系统如何破解——探索未知的技术边界在数字化时代,手机已经成为我们生活中不可或缺的一部分。而安...
安卓系统怎么换回主题,安卓系统... 亲爱的手机控们,你是不是也和我一样,对安卓系统的主题换换换乐此不疲呢?不过,有时候换着换着,突然发现...
黑莓安卓系统 太垃圾,令人失望... 你有没有用过黑莓的安卓系统?别告诉我你没有,因为现在这个系统真的是太垃圾了!是的,你没听错,就是那个...
修改安卓系统权限代码,安卓系统... 你有没有想过,你的安卓手机里那些神秘的系统权限代码?它们就像隐藏在手机里的秘密通道,有时候让你觉得既...
虚拟大师安卓系统教程,教程详解... 你有没有想过,手机里的世界可以变得更加神奇?今天,就让我带你一起探索虚拟大师安卓系统的奥秘吧!想象你...
基于安卓系统个人博客,轻松构建... 你有没有想过,在这个信息爆炸的时代,拥有一片属于自己的网络小天地是多么酷的事情啊!想象每天都能在这里...
安卓怎么传到苹果系统,从安卓到... 你是不是也有过这样的烦恼:手机里存了好多好用的安卓应用,可是一换到苹果系统,就发现这些宝贝们都不见了...
安卓改系统字体app,安卓系统... 你有没有想过,手机上的字体也能变得个性十足?没错,就是那个安卓改系统字体app,它可是让手机界面焕然...
安卓系统重启密码错误,破解与预... 手机突然重启了,屏幕上竟然出现了密码输入的界面!这可怎么办?别急,让我来帮你一步步解决这个安卓系统重...