深度学习Pytorch框架

深度学习Pytorch框架

文章目录

      • 深度学习Pytorch框架
  • 前言
        • 1. Pytorch命令之``nn.Sequential``
        • 2. Pytorch命令之``nn.Conv2d``
        • 3. Pytorch命令之``nn.BatchNorm2d``
        • 4. Pytorch命令之``nn.MaxPool2d``
        • 5. Pytorch命令之``nn.linear``


前言

最近在学习Pytorch深度学习框架,由于初次接触,故记录一下学习的历程~


Author:qyan.li

Date:2021.11.17

1. Pytorch命令之nn.Sequential

个人简单理解:nn.Sequential通过序列创建神经网络结构

1 Pytorch官方文档Doc:

A sequential container. Modules will be added to it in the order they are passed in the constructor. Alternatively, an OrderedDict of modules can be passed in.

2 解释说明:

nn.Sequential本质上为序列化的容器,其中可存储各个模块,模块于容器中的顺序即为input输入其中用于输出output的顺序,同时支持字典的方式实现序列化容器的构建

import torch
from torch import nn
from collections import OrderedDict    # 需导入OrderedDict,否则会报错

def Test():
    # 此种方式仅可以使用索引访问某一层
    Module1 = nn.Sequential(
        nn.Conv2d(1,20,5),
        nn.ReLU(),
        nn.Conv2d(20,64,5),
        nn.ReLU()
    )
    print(Module1)

    print("----------------------------")
	# 此种方式可借助于曾名访问某一层
    Module2 = nn.Sequential(OrderedDict([
        ("con1",nn.Conv2d(1,20,5)),
        ("Relu1",nn.ReLU()),
        ("con2",nn.Conv2d(20,64,5)),
        ("Relu2",nn.ReLU())])
    )
    print(Module2)

if __name__ == '__main__':
    Test()

    '''output---
Sequential(
  (0): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))
  (1): ReLU()
  (2): Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
  (3): ReLU()
	)
----------------------------
Sequential(
  (con1): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))
  (Relu1): ReLU()
  (con2): Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
  (Relu2): ReLU()
	)
    '''

参考文献:https://blog.csdn.net/qq_27825451/article/details/90551513

2. Pytorch命令之nn.Conv2d

Conv2d在pytorch中负责构建卷积层操作-convolution

1 Pytorch官方文档Doc:

class 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)

2 参数说明:

in_channels->输入维度

out_channels->输出维度

kernel_size->卷积和大小(可用于确定输出像素矩阵的宽度和高度)

stride = 1->卷积操作步长

padding = 0->补零操作(说明上下左右补零的个数)padding = 1->input:33*33 output:35*35

padding_mode = ‘zeros’->周围补零

    '''以图像为例说明:
    	num:输入图像的个数
    	dimension:每幅图像的维度:如RGB
    	width:像素矩阵宽度
    	height:像素矩阵高度
    '''
    
import torch
from torch import nn

def Test():

    # input:(num,dimension,width,height)
    input = torch.randn(3,1,4,6);
    
    # in_channels:input_dimension out_channels:output_dimension
    conv = nn.Conv2d(in_channels = 1,out_channels = 100,kernel_size = (2,3))
    
    # output(p,q) input(x,y) conv(m,n)  p = x-m+1;q = n-y+1
    output = conv(input)
    print('input:',input.data)
    print('output:',output.data)


if __name__ == '__main__':
    Test()
    
'''output:
input: torch.Size([3, 1, 4, 6])
output: torch.Size([3, 100, 3, 4])
'''
    

参考文献: https://blog.csdn.net/qq_42079689/article/details/102642610

3. Pytorch命令之nn.BatchNorm2d

卷积处理之后,在非线性激活函数之前,添加BatchNorm进行数据归一化处理,使其分布一致,将数据强行拉回方差为0,均值为1的正态分布上,一方面使得数据分布一致,另外一方面避免梯度消失

参考文献: https://blog.csdn.net/bigFatCat_Tom/article/details/91619977

  • Pytorch命令之nn.ReLu

    ReLu函数在pytorch中负责构建非线性激活函数,保证网络的非线性特征

    1 Pytorch官方文档Doc:

    class torch.nn.``ReLU(inplace=False)

    2 参数说明:

    inplace->True说明输入input会被改变,而False不会被改变

    (inplace参数设置应考虑后续操作是否会对input产生需求)

    import torch
    from torch import nn
    
    def Test():
        # ReLu->max(0,x)
        input = torch.randn(2,3)
        relu = nn.ReLU(inplace = False)
        output = relu(input)
        print('input:',input.data)
        print('output:',output.data)
    
    if __name__ == '__main__':
        Test()
        
    '''output:
    input: tensor([[ 1.1905, -0.5330, -1.0013],
            [-0.7853,  1.6066, -1.0514]])
    output: tensor([[1.1905, 0.0000, 0.0000],
            [0.0000, 1.6066, 0.0000]])
    '''
    

4. Pytorch命令之nn.MaxPool2d

nn.MaxPool2d用于构建pytorch中池化操作,主要包括maxpooling,averagepooling

1 Pytorch官方文档Doc:

class torch.nn.``MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

2 参数说明:

kernel_size->移动茶窗大小

stride->步长

padding->池化操作时周围是否补零

ceil_mode->True向上取整,False向下取整

import torch
from torch import nn

def Test():

    # MaxPool2d3d or 4d
    # (num,width,height)
    input = torch.randn(3,2,4)
    maxpooling = nn.MaxPool2d(kernel_size = (2,2),stride = 2)
    output = maxpooling(input)
    print('input:',input)
    print('output:',output)


if __name__ == '__main__':
    Test()
    
'''output:
input: tensor([[[-0.9491,  0.3658, -0.8858,  0.0594],
         [ 1.8162, -0.6154,  0.1346, -1.7614]],

        [[-1.3035, -0.6148,  0.9820, -1.0435],
         [ 0.4091, -2.3076,  0.5005,  0.1074]],

        [[ 0.8871,  0.9837,  0.2303,  0.4890],
         [ 0.1333,  0.2272,  0.6926,  0.3049]]])
output: tensor([[[1.8162, 0.1346]],

        [[0.4091, 0.9820]],

        [[0.9837, 0.6926]]])
'''

Tips:输入必须为三维数据:torch.randn(3,2,4)->表明共有3个数据,数据大小宽度width = 2,长度为length = 4

原因:3d相较于2d多出的一维用于将2d的数据全部放置于统一的input中

否则会报错:RuntimeError: non-empty 3D or 4D (batch mode) tensor expected for input

5. Pytorch命令之nn.linear

nn.linear主要用于构建神经网络架构中的全链接层,用于决定最终的输出

Pytorch官方文档Doc:

class torch.nn.``Linear(in_features, out_features, bias=True, device=None, dtype=None)

参数说明:

in_features:输入向量的维度(size of each input sample)

out_features:输出向量的维度(size of each output sample)

bias:全链接层是否会学习到偏置(bias)

import torch
from torch import nn
from collections import OrderedDict

def Test():
    input = torch.randn(100,256)
    fc = nn.Linear(256,10)
    output = fc(input)
    print(output.size())

if __name__ == '__main__':
    Test()

    
'''ouput---
input->torch.Size([100,256])
ouput->torch.Size([100, 10])
'''

out_features->不仅是输出的维度,同时也是分类问题中的类别数目(例如:手写数字识别问题中,输入图像经过全链接层会输出10维的数据,每个数据代表该数字属于0-9类别的概率)

你可能感兴趣的:(人工智能,深度学习,pytorch,神经网络)