torch.nn神经网络（1）--卷积函数使用与卷积层

torch.nn神经网络

1.nn.Module神经网络的使用

首先导入所需的模板：

import torch
from torch import nn

定义一个类，使其继承于nn.Module类：
①定义初始化函数时需要先完成其父类的初始化操作。
②同时定义一个forward函数，进行神经网络正向传播的作用。

class ChenYu(nn.Module):
    def __init__(self):
        super().__init__()          #首先要完成父类的初始化

    def forward(self,input):            #forward表示正向传播
        output=input+1
        return output

定义完成后实例化这个类，并进行传参，即可实现：

chenyu=ChenYu()
x = torch.tensor(1.0)
output = chenyu(x)
print(output)

运行结果👇： 这里初始化x为tensor类型的值为1.0的属性，经过神经网络的正向传播完成+1操作后，最终返回的结果为2.0

tensor(2.)

2.torch.nn.functional的使用

在Pytorch官方文档中我们可以看到torch.nn.functional的介绍：
关于该函数的使用方法👇：

关于函数的参数定义👇：

tips:这里对各参数进行一个解释：

F.conv2d(input,kernel,stride=2,padding=1)
input 代表输入
kernel 代表用于计算的卷积核
stride 代表没卷积核移动的步大小
padding 代表周围用于补充的数据

我们想要构造一个卷积网络，使用Fonctional.conv2d()函数构造如下的卷积网络：

首先需要导入模块：

import  torch
import torch.nn.functional as F

定义输入图像的55的矩阵，及33的卷积核矩阵，使用torch.tenser()函数将其转化为tensor类型：

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]])              #卷积核  二维矩阵 转为tensor类型

使用torch.reshape()函数对其进行改变：

input=torch.reshape(input,(1,1,5,5))
kernel=torch.reshape(kernel,(1,1,3,3))

调用函数生成神经网络对数据进行处理：

output = F.conv2d(input,kernel,stride=1)
print('output',output)

output2 = F.conv2d(input,kernel,stride=2)
print('output2',output2)

output3 = F.conv2d(input,kernel,stride=1,padding=1)
print('output3',output3)

output4 = F.conv2d(input,kernel,stride=1,padding=0)
print('output4',output4)

output5 = F.conv2d(input,kernel,stride=2,padding=1)
print('output5',output5)

得到的结果为：

output tensor([[[[10, 12, 12],
          [18, 16, 16],
          [13,  9,  3]]]])
output2 tensor([[[[10, 12],
          [13,  3]]]])
output3 tensor([[[[ 1,  3,  4, 10,  8],
          [ 5, 10, 12, 12,  6],
          [ 7, 18, 16, 16,  8],
          [11, 13,  9,  3,  4],
          [14, 13,  9,  7,  4]]]])
output4 tensor([[[[10, 12, 12],
          [18, 16, 16],
          [13,  9,  3]]]])
output5 tensor([[[[ 1,  4,  8],
          [ 7, 16,  8],
          [14,  9,  4]]]])

3.nn.Module的卷积层

首先，导入模块并且载入数据集（采用的数据集为CIFAR10,DataLoader设置的batchsize为64：

import torch
import torchvision
from torch import nn
from torch.nn import Conv2d
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)

定义类，继承父类nn.Module,在其中定义卷积层Conv2d,设置输入channel为3，输出channel为6，stride为1，padding=0.

class ChenYu(nn.Module):
    def __init__(self):
        super(ChenYu, 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  x

初始化类，并对数据集中的每个数据都进行卷积：

for data in dataloader:
    imgs , target = data
    output = chenyu(imgs)
    #输入的图像原始size为：torch.Size([64,3,32,32])
    #卷积后的图像size为：[64,6,30,30]    
    writer.add_images('input',imgs,step)      记录输入图像的信息          
    output = torch.reshape(output,(-1,3,30,30))
    #使用reshape函数，将torch.Size([64,6,32,32])  --->[xxx,3,30,30]   通道数从6变为3
    writer.add_images('output',output,step)   记录卷积后图像的信息

    step = step+1
write.close()

最终输出的结果展示：