[pytorch入门] 6. 神经网络

这篇具有很好参考价值的文章主要介绍了[pytorch入门] 6. 神经网络。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

基本介绍

  • torch.nn:
    [pytorch入门] 6. 神经网络,# pytorch,深度学习,pytorch,神经网络,人工智能
    • Containers:基本骨架
    • Convolution Layers: 卷积层
    • Pooling layers:池化层
    • Non-linear Activations (weighted sum, nonlinearity):非线性激活
    • Normalization Layers:正则化层

Containers类

介绍

containers相对重要的一个类,主要给神经网络定义了一些骨架、一些结构,后面那些类都是要向骨架中填充的东西
里面有6个模块,其中module模块是里面最重要的一个模块
[pytorch入门] 6. 神经网络,# pytorch,深度学习,pytorch,神经网络,人工智能
一般自己定义类,然后继承nn.module
里面一定要写的两个函数:__init__()和forward函数(前向传播)

from torch import nn
import torch
class Test(nn.Module):
    def __init__(self):
        super().__init__()

    def forward(self,input):
        output = input+1
        return output

test = Test()
# print(test.forward(1))
x = torch.tensor(1)
print(test(x))

Sequential 序列

将网络序列放到sequential里面,这样就可以调用一个模块连续使用自己定义的网络
这样会让代码更加简洁易懂

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())
        ]))

在下节实战中进行实例演示

Convolution 卷积

基础理解

import torch
import torch.nn.functional as F

input = 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]
                    ])

# output = torch.nn.Conv2d(input)
# print(input.shape)
# print(kernel.shape)  # 目前不符合Con2d的尺寸要求,需要进行尺寸变换

input = torch.reshape(input, (1,1,5,5))  # 1个通道,1个样本,5行5列
kernel = torch.reshape(kernel, (1,1,3,3))  # 1个通道,1个样本,3行3列

print(input.shape)
print(kernel.shape)

# 之后进行卷积操作
output1 = F.conv2d(input, kernel, stride=1, padding=0) # stride步长,padding在输入图像的四周进行填充
print(output1)

output2 = F.conv2d(input, kernel, stride=2) # stride步长,padding填充
print(output2)

output3 = F.conv2d(input, kernel, stride=1, padding=1) # stride步长,padding在输入图像的四周进行填充
print(output3)   # 会发现比padding=0时大了一圈,因为padding=1时,会在输入图像的四周填充一圈0

output4 = F.conv2d(input, kernel, stride=1, padding=2) # stride步长,padding在输入图像的四周进行填充
print(output4)   # 会发现比padding=1时大了一圈,因为padding=2时,会在输入图像的四周填充两圈0

[pytorch入门] 6. 神经网络,# pytorch,深度学习,pytorch,神经网络,人工智能

参数概念

def torch.nn.Conv2d(in_channels, out_channels, kernel_size,
 stride=1, padding=0, dilation=1, groups=1, bias=True, 
 padding_mode='zeros', device=None, dtype=None)

# in_channels:int,输入通道
# out_channels :int,输出通道
# kernel_size :int或元祖,卷积核的大小
# stride:int or tuple, optional。横向纵向的步径大小 默认为1
# padding (int, tuple or str, optional) 是否需要在输入图像的边缘进行填充,默认为0 不填充
# padding_mode (str, optional) – 'zeros', 'reflect', 'replicate' or 'circular' 控制如何填充,Default: 'zeros'即全部填充为0
# dilation (int or tuple, optional) – Spacing between kernel elements. Default: 1 卷积核之间的距离,一般为空洞卷积,不常用
# groups (int, optional) – Number of blocked connections from input channels to output channels. Default: 1
# bias (bool, optional) – If True, adds a learnable bias to the output. Default: True

实际上不需要自己写卷积核,他是会自己在输入图像中采样获得,只需要定义卷积核大小即可

使用

import torch
import torchvision
from torch.utils.data import DataLoader
from torch import nn
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, shuffle=True)

# 搭建简单神经网络
class Test(nn.Module):
    def __init__(self):
        super(Test,self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3,out_channels=6,kernel_size=3,stride=1,padding=0)

    def forward(self,x):
        x = self.conv1(x)
        return x
    
net = Test()


writer = SummaryWriter('logs')
step = 0
for data in dataloader:    # 一次性取出一个batch_size的数据,daaloader的使用见前面文章
    imgs, targets = data
    output = net(imgs)
    print(imgs.shape)
    print(output.shape)
    # print(output)
    print('-------')
    writer.add_images("input", imgs, step)

    # 但是这里output的shape是[64,6,30,30],6个通道没办法显示
    # 因此需要对output进行处理,使其变成[64,3,30,30]
    # 比较简单的方案是6个通道直接切开,变成两个bitch,每个bitch有3个通道(不是很严谨)
    # 当不知道batch_size的大小时,可以使用-1来代替,他会根据后面的数据直接计算
    output = torch.reshape(output,(-1,3,30,30))
    writer.add_images("output", output, step)
    step = step+1

[pytorch入门] 6. 神经网络,# pytorch,深度学习,pytorch,神经网络,人工智能

辨析:nn 与 nn.functional

上面卷积操作的两个代码中,一个用的torch.nn.functional中的conv2d,一个用的torch.nn中的conv2d
nn 与 nn.functional有很多相同的函数,同时也有很多差异

相同点

  • 实际功能相同,即nn.Conv2d和nn.functional.conv2d 都是进行卷积,nn.Dropout 和nn.functional.dropout都是进行dropout等
  • 运行效率近乎相同

不同点

  • nn.functional.xxx是函数接口,而nn.XXX是nn.functional.xxx的类封装,并且nn.xxx都集成于同一个祖先nn.Module。这一点导致了nn.XXX除了具有nn.functional.xxx的功能之外,内部附带了nn.Module相关的属性和方法,例如train(), eval(),load_state_dict, state_dict 等。
  • 两者的调用方式不同
    • nn.xxx需要先实例化并传入参数,然后以函数调用的方式调用实例化的对象并传入输入数据

      input = img
      conv = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, padding=1)  # 实例化
      out = conv(input) # 以函数调用的方式调用实例化的对象并传入输入数据
      
    • nn.functional.xxx同时传入输入数据和weight、bias等其他参数

      weight = torch.rand(64,3,3,3)
      bias = torch.rand(64)
      out = nn.functional.conv2d(inputs, weight, bias, padding=1) # 调用函数的同时传入数据与参数
      
  • nn.Xxx继承于nn.Module, 能够很好的与nn.Sequential结合使用, 而nn.functional.xxx无法与nn.Sequential结合使用。
    fm_layer = nn.Sequential(
                nn.Conv2d(3, 64, kernel_size=3, padding=1),
                nn.BatchNorm2d(num_features=64),
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2),
                nn.Dropout(0.2)
      
    
  • nn.xxx不需要自己定义和管理weight,而functional.xxx需要自己定义weight,每次调用的时候都需要手动传入weight,不利于代码复用
    • 使用nn.xxx定义一个CNN
      class CNN(nn.Module):
          def __init__(self):
              super(CNN, self).__init__()
              
              self.cnn1 = nn.Conv2d(in_channels=1,  out_channels=16, kernel_size=5,padding=0)
              self.relu1 = nn.ReLU()
              self.maxpool1 = nn.MaxPool2d(kernel_size=2)
              
              self.cnn2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=5,  padding=0)
              self.relu2 = nn.ReLU()
              self.maxpool2 = nn.MaxPool2d(kernel_size=2)
              
              self.linear1 = nn.Linear(4 * 4 * 32, 10)
              
          def forward(self, x):
              x = x.view(x.size(0), -1)
              out = self.maxpool1(self.relu1(self.cnn1(x)))
              out = self.maxpool2(self.relu2(self.cnn2(out)))
              out = self.linear1(out.view(x.size(0), -1))
              return out
      
    • 用nn.function.xxx的写法
      class CNN(nn.Module):
          
          
          def __init__(self):
              super(CNN, self).__init__()
              
              self.cnn1_weight = nn.Parameter(torch.rand(16, 1, 5, 5))
              self.bias1_weight = nn.Parameter(torch.rand(16))
              
              self.cnn2_weight = nn.Parameter(torch.rand(32, 16, 5, 5))
              self.bias2_weight = nn.Parameter(torch.rand(32))
              
              self.linear1_weight = nn.Parameter(torch.rand(4 * 4 * 32, 10))
              self.bias3_weight = nn.Parameter(torch.rand(10))
              
          def forward(self, x):
              x = x.view(x.size(0), -1)
              out = F.conv2d(x, self.cnn1_weight, self.bias1_weight)
              out = F.relu(out)
              out = F.max_pool2d(out)
              
              out = F.conv2d(x, self.cnn2_weight, self.bias2_weight)
              out = F.relu(out)
              out = F.max_pool2d(out)
              
              out = F.linear(x, self.linear1_weight, self.bias3_weight)
              return out
      

选择

根据问题的复杂度和个人风格喜好决定
一般在能使用nn.xxx的情况下尽量使用,因为这样更能显示出网络间的层次关系,也更加纯粹

在nn.xxx不能满足功能需求时可以使用nn.functional.xxx,因为nn.functional.xxx更接近底层,更灵活

  • pytorch官方推荐:具有学习参数的(例如,conv2d, linear, batch_norm)采用nn.Xxx方式,没有学习参数的(例如,maxpool, loss func, activation func)等根据个人选择使用nn.functional.xxx或者nn.Xxx方式。

最大池化

介绍

池化的目的是保存主要内容的同时减少数据大小

用的比较多的为MaxPool2d,取kernel覆盖范围中最大的值输出

def MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=Flse,ceil_mode=False)
  • kernel_size:采样窗口大小
  • stride:步幅,注意这里默认值不一样了,卷积层为1,这里为kernel_size的大小
  • padding:填充值
  • dilation:kernel中每个格子中间是否存在间隔,一般不对其进行设置,有间隔时也称为空洞卷积
  • ceil_mode:设置为True时使用ceil模式,设置为False时使用floor模式
    • ceil模式:kernel覆盖不足时(边界越界时),保留获取的数值
    • floor模式:kernel覆盖不足时,不保留获取的数值

使用方法

import torch
from torch import nn
input = 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)) # 使之满足输入要求

class Test(nn.Module):
    def __init__(self):
        super(Test,self).__init__()
        self.maxpool = nn.MaxPool2d(kernel_size=3,padding=0,ceil_mode=False)

    def forward(self,input):
        output = self.maxpool(input)
        return output

net = Test()
output = net(input)
print(output)

实例

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


dataset = torchvision.datasets.CIFAR10('./dataset',train=False,transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, batch_size=4)

class Test(nn.Module):
    def __init__(self):
        super(Test,self).__init__()
        self.maxpool = nn.MaxPool2d(kernel_size=3,padding=0,ceil_mode=False)

    def forward(self,input):
        output = self.maxpool(input)
        return output

net = Test()
writer = SummaryWriter('logs')
step = 0

for data in dataloader:
    imgs, targets = data
    writer.add_images('input',imgs, step)
    output = net(imgs)   # 池化不会改变channel的数量,因此不需要reshape
    writer.add_images('output',output, step)
    step = step+1
writer.close()

非线性激活

官方文档有很多非线性函数,这里举几个例子

ReLU

[pytorch入门] 6. 神经网络,# pytorch,深度学习,pytorch,神经网络,人工智能
ReLU有一个参数inplace:用于指明是否修改原值

  • inplace=True:没有返回值,直接修改原值
  • inplace=False:不修改原值,有结果作为返回值返回
from torch import nn
import torch

class Test(nn.Module):
    def __init__(self):
        super(Test, self).__init__()
        self.relu1 = nn.ReLU(inplace=False)

    def forward(self, input):
        output = self.relu1(input)
        return output

net = Test()

input = 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]])

output = net(input)
print(output)

[pytorch入门] 6. 神经网络,# pytorch,深度学习,pytorch,神经网络,人工智能

Sigmod

ReLU对图像的处理不明显,这里用sigmod举例
[pytorch入门] 6. 神经网络,# pytorch,深度学习,pytorch,神经网络,人工智能

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

dataset = torchvision.datasets.CIFAR10('./dataset',train=False,transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset=dataset, batch_size=64)

class Test(nn.Module):
    def __init__(self):
        super(Test, self).__init__()
        self.sigmoid1 = nn.Sigmoid()

    def forward(self, input):
        output = self.sigmoid1(input)
        return output

net = Test()
writer = SummaryWriter('logs')
step=0
for data in dataloader:
    imgs, targets = data
    writer.add_images('input',imgs,step)
    output = net(imgs)
    writer.add_images('output',output,step)
    step = step+1
writer.close()


Linear Layers:线性层

[pytorch入门] 6. 神经网络,# pytorch,深度学习,pytorch,神经网络,人工智能
比较常见的这种图实际上就是由线性层一个一个搭建出来的

def torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None

参数中的in_features指的就是上面输入层数据的个数(即d),out_features即为输出层个数(前半部分的输出层为中间的隐藏层),bias=True时,计算会加上偏置b

# 例:将图片(如5*5)展开成一行(如1*25),经过线性层转换为x个

import torchvision
import torch
from torch import nn
from torch.utils.data import DataLoader


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

class Test(nn.Module):
    def __init__(self):
        super(Test, self).__init__()
        self.liner1 = nn.Linear(196608,10)
    
    def forward(self, input):
        output = self.liner1(input)
        return output

net = Test()

for data in dataloader:
    imgs, targets = data
    print("原始大小:",imgs.shape) 

    # output = torch.reshape(imgs,(1,1,1,-1)) # 将imgs展开成一行 输出效果见第一张图
    # 这里也可以直接用torch.flatten(imgs)来展开
    output = torch.flatten(imgs)  # 输出效果见第二张图
    print("转化为一维", output.shape)  # 先用这个来看一下展开后的大小,这是决定了线性层的输入大小
    # break
    
    output2 = net(output)
    print("线性层转化后", output2.shape)
    break

使用reshape:
[pytorch入门] 6. 神经网络,# pytorch,深度学习,pytorch,神经网络,人工智能
使用torch.flatten:
[pytorch入门] 6. 神经网络,# pytorch,深度学习,pytorch,神经网络,人工智能

其它层

Normalization 正则化层: 采用正则化的话会提高神经网络的训练速度
Recurrent Layers:一些特定的网络结构,含有RNN、LSTM等
Transformer Layers:已经写好的特定结构,与上面类似
Dropout Layers:也是在特定网络中才需要
Distance Functions:计算两个层之间的误差
Loss Functions:计算loss文章来源地址https://www.toymoban.com/news/detail-824021.html

到了这里,关于[pytorch入门] 6. 神经网络的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Pytorch深度学习-----神经网络之线性层用法

    PyTorch深度学习——Anaconda和PyTorch安装 Pytorch深度学习-----数据模块Dataset类 Pytorch深度学习------TensorBoard的使用 Pytorch深度学习------Torchvision中Transforms的使用(ToTensor,Normalize,Resize ,Compose,RandomCrop) Pytorch深度学习------torchvision中dataset数据集的使用(CIFAR10) Pytorch深度学习--

    2024年02月14日
    浏览(34)
  • 鱼类识别Python+深度学习人工智能+TensorFlow+卷积神经网络算法

    鱼类识别系统。使用Python作为主要编程语言开发,通过收集常见的30种鱼类(‘墨鱼’, ‘多宝鱼’, ‘带鱼’, ‘石斑鱼’, ‘秋刀鱼’, ‘章鱼’, ‘红鱼’, ‘罗非鱼’, ‘胖头鱼’, ‘草鱼’, ‘银鱼’, ‘青鱼’, ‘马头鱼’, ‘鱿鱼’, ‘鲇鱼’, ‘鲈鱼’, ‘鲍鱼’, ‘鲑

    2024年02月02日
    浏览(95)
  • 动手学深度学习-pytorch版本(二):线性神经网络

    参考引用 动手学深度学习 神经网络的整个训练过程,包括: 定义简单的神经网络架构、数据处理、指定损失函数和如何训练模型 。经典统计学习技术中的 线性回归 和 softmax 回归 可以视为线性神经网络 1.1 线性回归 回归 (regression) 是能为一个或多个自变量与因变量之间关系建

    2024年02月12日
    浏览(47)
  • PyTorch深度学习实战(1)——神经网络与模型训练过程详解

    人工神经网络 ( Artificial Neural Network , ANN ) 是一种监督学习算法,其灵感来自人类大脑的运作方式。类似于人脑中神经元连接和激活的方式,神经网络接受输入,通过某些函数在网络中进行传递,导致某些后续神经元被激活,从而产生输出。函数越复杂,网络对于输入的数据拟

    2024年02月06日
    浏览(47)
  • 《动手学深度学习 Pytorch版》 9.4 双向循环神经网络

    之前的序列学习中假设的目标是在给定观测的情况下对下一个输出进行建模,然而也存在需要后文预测前文的情况。 数学推导太复杂了,略。 双向循环神经网络(bidirectional RNNs)添加了反向传递信息的隐藏层,以便更灵活地处理此类信息。 前向和反向隐状态的更新如下:

    2024年02月07日
    浏览(43)
  • 卷积神经网络——下篇【深度学习】【PyTorch】【d2l】

    5.10.1、理论部分 批量归一化可以解决深层网络中梯度消失和收敛慢的问题,通过固定每个批次的均值和方差来加速收敛,一般不改变模型精度。批量规范化已经被证明是一种不可或缺的方法,它适用于几乎所有图像分类器。 批量规划是一个线性变换 ,把参数的均值方差给拉

    2024年02月12日
    浏览(44)
  • 卷积神经网络——上篇【深度学习】【PyTorch】【d2l】

    5.1.1、理论部分 全连接层后,卷积层出现的意义? 一个足够充分的照片数据集,输入,全连接层参数,GPU成本,训练时间是巨大的。 (convolutional neural networks,CNN)是机器学习利用自然图像中一些已知结构的创造性方法,需要更少的参数,在处理图像和其他类型的结构化数据

    2024年02月12日
    浏览(43)
  • 卷积神经网络——中篇【深度学习】【PyTorch】【d2l】

    5.5.1、理论部分 两个⌈ 卷积块 ⌋ 每个卷积块中的基本单元是一个⌈ 卷积层 ⌋、一个 ⌈ sigmoid激活函数 ⌋和 ⌈ 平均汇聚层 ⌋ 三个⌈ 全连接层密集块 ⌋ 早期神经网络,先使用卷积层学习图片空间信息,然后全连接层转换到类别空间。 5.5.2、代码实现 定义一个 Sequential块

    2024年02月11日
    浏览(53)
  • 《Pytorch深度学习和图神经网络(卷 2)》学习笔记——第一章

    PyTorch深度学习和图神经网络(卷2)——开发应用一书配套代码: https://github.com/aianaconda/pytorch-GNN-2nd- 百度网盘链接:https://pan.baidu.com/s/1dnq5IbFjjdekAR54HLb9Pg 提取码:k7vi 压缩包密码:dszn 2012年起,在ILSVRC竞赛中获得冠军的模型如下 2012年:AlexNet 2013年:OverFeat 2014年:GoogLeNet、

    2024年02月16日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包