1, Neural network module
Neural Network
1. Import package
import torch.nn
2. Inherit
You need to define a class, inherit nn.Module, and override the__ init__ And forward method
3. Specific code
import torch from torch import nn # It needs to be implemented after inheriting nn.Module__ init__ And forward method # Forward is forward propagation class NNModule(nn.Module): def __init__(self): super(NNModule, self).__init__() def forward(self, input_data): output_data = input_data + 1 return output_data nn_m = NNModule() # definition x = torch.tensor(1.0) result = nn_m(x) # Add input print(result)
2, Convolution layer
Convolution Layers Conv1d is one-dimensional convolution Conv2d is two-dimensional convolution Conv3d is three-dimensional convolution
1,torch.nn.functional.conv2d
(1) Import package from torch.nn import functional function
functional.conv2d It is 2D convolution
(2) Parameter details:
- Input: input (minibatch, in_channels, iH, iW) input channel, height, width
- Weight: convolution kernel (weight) (out_channels, in_channels/group, kH, kW)
- bias: offset
- Stripe: filter the number of cells to jump during scanning, which can be a single number or tuple (sH, sW). The default is 1
- padding: the filling size of the blank area. It can be a single tuple (dH, dW). The default value is 0
(3) Operation sequence: input image (5) × 5) - > convolution kernel (3) × 3) - > output after convolution
The corresponding positions are multiplied and added to obtain the convolution output
(4) torch.nn.functional.conv2d specific code
import torch from torch.nn import functional as F # input image inputData = 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]]) # Convolution kernel kernelData = torch.tensor([[1, 2, 1], [0, 1, 0], [2, 1, 0]]) # Because it is not satisfied with the input format of conv2d, the input and convolution kernel are reset to the size parameters input_data = torch.reshape(inputData, (1, 1, 5, 5)) # batch_size in_channels iH iW kernel = torch.reshape(kernelData, (1, 1, 3, 3)) print(input_data.shape) print(kernel.shape) # The stripe kernel moves 1 bit by default # Output after convolution output = F.conv2d(input_data, kernel, stride=1) print(output) output2 = F.conv2d(input_data, kernel, stride=2) print(output2) # Space around padding output3 = F.conv2d(input_data, kernel, stride=1, padding=1) print(output3)
2,Conv2d Two dimensional convolution
(1) Import package from torch.nn import Conv2d
(2) Parameter details:
torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, group=1, bias=True, padding_mode='zeros')
- in_channels(int): enter the number of picture channels
- out_channels(int): the number of output channels after convolution
- kernel_size(int or tuple): the size of convolution kernel. If defined as 3, it is 3 × Convolution kernel size of 3
Optional: optional
- String (int or tuple, optional): the step size during convolution. The default value is 1
- padding(int or tuple, optional): blank extension of the original image. The default value is 0
- padding_mode(string, optional): refers to the filling mode, 'zeros',' reflect ',' replicate ' or 'circular'. Default: 'zeros'
- Translation (string, optional): the distance of the corresponding bit of convolution check, which is 1 by default
- groups(int, optional): the number of blocked connections from the input channel to the output channel. The default is 1
- bias(bool, optional): offset or not
(3) Convolution formula
That is, the input is multiplied by the same position as the convolution and added
Blue is the input image, green is the output image, and the shadow part is the convolution kernel
(4) Input image (5) × 5) in_channel=1 ——> Convolution kernel (3 × 3)——> Output after convolution out_channel=1
Input image (5) × 5) in_channel = 1 Convolution kernel 1 - > output after convolution out_channel=2
Convolution kernel 2 - >
Number of output channels = number of convolution kernels
N is batch_size batch quantity
C is channel, input channel and output channel
H is the high of input and output
W is the width of input and output
(5) Specific code
from torch import nn from torch.utils.data import DataLoader import torchvision from torch.nn import Conv2d import ssl from torch.utils.tensorboard import SummaryWriter import torch ssl._create_default_https_context = ssl._create_unverified_context dataset = torchvision.datasets.CIFAR10(root="./dataset", train=False, transform=torchvision.transforms.ToTensor(), download=True) dataloader = DataLoader(dataset, batch_size=64) class TestImage(nn.Module): def __init__(self): super(TestImage, self).__init__() # Define the convolution layer input channel 3, the number of cores 3, the output channel 6, and the step size 1 self.conv1 = Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0) def forward(self, x): x = self.conv1(x) # Put x into the convolution layer conv1 return x ti = TestImage() # Display image writer = SummaryWriter("logs") step = 0 for data in dataloader: images, target = data output = ti(images) print(images.shape) print(output.shape) # torch.Size([64, 3, 32, 32]) enter the size writer.add_image("input", images, step, dataformats="NCHW") # Torch. Size ([64, 6, 30, 30]) - > [XXX, 3, 30, 30] output size # Change the picture to the specified output size because of the output error output = torch.reshape(output, (-1, 3, 30, 30)) writer.add_image("output", output, step, dataformats="NCHW") step = step + 1 writer.close()