PyTorch nn Conv2d в Python

PyTorch nn conv2d определяется как двумерная свертка, которая применяется к входным данным, указанным пользователем, и конкретная форма входных данных задается в виде каналов, длины и ширины, а выходные данные имеют форму запутанного характера.

Синтаксис:

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)

Ниже приведены параметры PyTorch nn conv2d:

• in_channels используется как несколько каналов во входном изображении.
• out_channels используется как количество каналов, созданных сверткой.
• kernel_size используется для определения размера сверточного ядра.
• шаг используется для управления шагом для взаимной корреляции, одного числа или кортежа. значение шага по умолчанию — 1.
• дополнение используется для управления количеством заполнения, применяемого к входным данным. Это может быть строка или кортеж с указанием количества неявного заполнения. Значение заполнения по умолчанию — 0.
• расширение используется для управления расстоянием между элементами ядра, а значение расширения по умолчанию равно 1.
• группы используются для управления соединением между входами и выходами. Значение групп по умолчанию — 1.
• смещение: значение смещения по умолчанию — True. Если это правда, это добавляет обучаемую предвзятость к выходным данным. Если оно ложно, это не добавляет к выходным данным никакой обучаемой предвзятости.

• Пример
• Функционал PyTorch nn conv2d
• Заполнение
• Группа
• Расширение
• PyTorch nn conv2d в CNN
• Смещение
• Транспонирование
• Параметры
• Вес
• Входные и выходные каналы

Пример

PyTorch nn conv2d применяет 2d-свертку к входному сигналу, состоящему из нескольких входных плоскостей.

Это простая арифметическая операция, внутри которой мы перемещаем матрицу или ядро весов над двумерными данными и выполняем поэлементное умножение данных.

В следующем коде мы импортируем все необходимые библиотеки, такие как import torch, import torch.nn как nn.

• n = nn.Conv2d(18, 35, 5, шаг=2) используется с квадратными ядрами и равным шагом.
• input = torch.randn(22, 18, 52, 102) используется для описания переменной с помощью функции torch.random().
• вывод = n(вход) используется для объявления выходной переменной.
• print(output) используется для печати вывода с помощью функции print().

# Importing Libraries
import torch
import torch. nn as nn

# With square kernels and equal stride
n = nn.Conv2d(18, 35, 5, stride=2)

# Describe the variable
input = torch.randn(22, 18, 52, 102)

# Declare the output variable
output = n(input)
# Print output
print(output)

После запуска приведенного выше кода мы получаем следующий вывод, в котором мы видим, что PyTorch nn conv2d с квадратным ядром и значением квадратного шага печатается на экране.

Функционал PyTorch nn conv2d

В этом разделе мы узнаем о функционале PyTorch nn conv2d в Python.

Функционал PyTorch nn conv2d применяет 2D-свертку к входному изображению, собранному из нескольких входных плоскостей.

Синтаксис:

torch.nn.functional.conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)

Параметр:

• input: ввод определяется как входной тензор формы(мини-пакет, in_channels).
• weight: вес определяется как фильтр формы(out_channels)
• bias: смещение определяется как необязательный тензор смещения формы(out_channels). Значение смещения по умолчанию — Нет.
• step: шаг свертывающегося ядра. Значение шага по умолчанию — 1.
• padding: используется для управления количеством заполнения, применяемого к входным данным. Это может быть строка или кортеж с указанием количества неявного заполнения. Значение заполнения по умолчанию — 0.
• dilation: используется для управления расстоянием между элементами ядра, значение расширения по умолчанию равно 1.
• groups используются для управления соединением между входами и выходами. Значение групп по умолчанию — 1.

Заполнение

Заполнение PyTorch nn conv2d определяется как параметр, который используется для управления размером заполнения, применяемого к входным данным.

Это может быть строка или кортеж с заданным количеством неявного заполнения, а значение заполнения по умолчанию равно 0.

В следующем коде мы импортируем все необходимые библиотеки, такие как import torch, import torch.nn как nn.

• a = nn.Conv2d(20, 37, 7, шаг=2) используется с квадратными ядрами и равным шагом.
• a = nn.Conv2d(20, 37,(7, 9), шаг=(2, 1), дополнение=(4, 2)) используется с неквадратными ядрами, неравным шагом и заполнением.
• input = torch.randn(24, 20, 54, 104): здесь мы описываем входную переменную с помощью функции torch.randn().
• print(output) используется для печати вывода с помощью функции print().

# Importing Libraries
import torch
import torch. nn as nn

# Declaring a variable by using square kernels and equal stride
a = nn.Conv2d(20, 37, 7, stride=2)

# Declaring a variable by using Non-square kernels and unequal stride and padding
a = nn.Conv2d(20, 37,(7, 9), stride=(2, 1), padding=(4, 2))

# Describe the variable
input = torch.randn(24, 20 , 54, 104)
output = a(input)

# Print output
print(output)

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором мы видим, что значение заполнения PyTorch nn conv2d печатается на экране.

Группа

Группа PyTorch nn conv2d определяется как параметр, который используется для управления соединением между входами и выходами, а значение группы по умолчанию равно 1.

Код:

В следующем коде сначала мы импортируем все необходимые библиотеки, такие как import torch и import torch.nn как nn.

• n = nn.Conv2d(22, 37, 7, шаг=2) используется с квадратными ядрами и равным шагом.
• input = torch.randn(26, 22, 48, 48) используется для описания переменной с помощью функции torch.random().
• вывод = n(вход) используется для объявления выходной переменной.
• print(output) используется для печати вывода с помощью функции print().

# Importing libraries
import torch
import torch. nn as nn

# With square kernels and equal stride
n = nn.Conv2d(22, 37, 7, stride=2)

# Describe the input variable
input = torch.randn(26, 22, 48, 48)
output = n(input)

# Print the output
print(output)

Выход:

В приведенном ниже выводе вы можете видеть, что значения группы PyTorch nn conv2d выводятся на экран.

Расширение

Расширение PyTorch nn conv2d определяется как параметр, который используется для управления расстоянием между элементами ядра, а значение расширения по умолчанию равно 1.

Код:

В следующем коде мы импортируем некоторые необходимые библиотеки, такие как import torch, import torch.nn как nn.

• n = nn.Conv2d(19, 36, 6, шаг=2) используется с квадратными ядрами и равным шагом.
• m = nn.Conv2d(19, 36,(6, 8), шаг=(2, 1), дополнение=(7, 5)) используется как неквадратные ядра и неравный шаг и с заполнением.
• m = nn.Conv2d(19, 36,(6, 8), шаг =(2, 1), заполнение =(7, 5), расширение =(6, 4)) используется в качестве неквадратных ядер и неравного шага. и с заполнением и расширением.
• input = torch.randn(23, 19, 53, 103): здесь объявляется входная переменная с использованием метода torch.randn().
• print(output) используется для печати вывода с помощью функции вывода().

# Importing Libraries
import torch
import torch.nn as nn

# Declaring a variable by using square kernels and equal stride
n = nn.Conv2d(19, 36, 6, stride=2)

# Declaring a variable by using non-square kernels and unequal stride and padding
m = nn.Conv2d(19, 36,(6, 8), stride=(2, 1), padding=(7, 5))

# Declaring a variable by using non-square kernels, unequal stride, padding and dilation
m = nn.Conv2d(19, 36,(6, 8), stride=(2, 1), padding=(7, 5), dilation=(6, 4))

# Declaring the variable
input = torch.randn(23, 19, 53, 103)
output = m(input)

# Print the output
print(output)

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором мы видим, что значения расширения PyTorch nn conv2d печатаются на экране.

PyTorch nn conv2d в CNN

Прежде чем двигаться дальше, мы должны иметь некоторые знания о сверточных нейронных сетях(CNN).

Сверточная нейронная сеть — это тип искусственной нейронной сети, которая используется для распознавания изображений.

Здесь мы используем conv2d для работы со сверточной нейронной сетью. Это простая математическая операция, в которой мы перемещаем матрицу или ядро весов над двумерными данными и выполняем поэлементное умножение данных.

Код:

В следующем коде мы импортируем некоторые библиотеки, такие как импорт факела и импорт переменной из torch.autograd, импорт torchvision.datasets, импорт torch.nn.init.

• Batch_size = 34 используется в качестве гиперпараметра.
• traindata = dtsets.MNIST(root=’MNIST_data/’, train=True, Transform=transforms.ToTensor(), download=True) используется в качестве набора данных mnist для обучения.
• dataloader = torch.utils.data.DataLoader(dataset=traindata, patch_size=batch_size, shuffle=True) используется в качестве загрузчика набора данных.
• class CNN(torch.nn.Module): Здесь мы создаем класс модели с помощью методов init() и front().
• CNNmodel = CNN() используется для создания экземпляра модели.

import torch
from torch.autograd import Variable
import torchvision.datasets as dtsets
import torchvision.transforms as transforms
import torch.nn.init

# hyperparameters
batch_size = 34
keepprobab = 1

# MNIST dataset
traindata = dtsets.MNIST(root='MNIST_data/',
                          train=True,
                          transform=transforms.ToTensor(),
                          download=True)

testdata = dtsets.MNIST(root='MNIST_data/',
                         train=False,
                         transform=transforms.ToTensor(),
                         download=True)

# dataset loader
dataloader = torch.utils.data.DataLoader(dataset=traindata,
                                          batch_size=batch_size,
                                          shuffle=True)

# Display informations about the dataset
print('Train dataset:\t',traindata)
print('\nTest dataset:\t',testdata)

# Implementation of CNN/Convnet Model
class CNN(torch.nn.Module):

    def __init__(self):
        super(CNN, self).__init__()
        self.layer1 = torch.nn.Sequential(
            torch.nn.Conv2d(1, 34, kernel_size=3, stride=1, padding=1),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(kernel_size=2, stride=2),
            torch.nn.Dropout(p=1 - keepprobab))
        self.layer2 = torch.nn.Sequential(
            torch.nn.Conv2d(34, 66, kernel_size=3, stride=1, padding=1),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(kernel_size=2, stride=2),
            torch.nn.Dropout(p=1 - keepprobab))
        self.layer3 = torch.nn.Sequential(
            torch.nn.Conv2d(66, 130, kernel_size=3, stride=1, padding=1),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(kernel_size=2, stride=2, padding=1),
            torch.nn.Dropout(p=1 - keepprobab))

        # L4 FC 4x4x130 inputs -> 627 outputs
        self.fc1 = torch.nn.Linear(4 * 4 * 130, 627, bias=True)
        torch.nn.init.xavier_uniform(self.fc1.weight)
        self.layer4 = torch.nn.Sequential(
            self.fc1,
            torch.nn.ReLU(),
            torch.nn.Dropout(p=1 - keepprobab))
        # L5 Final FC 627 inputs -> 12 outputs
        self.fc2 = torch.nn.Linear(627, 12, bias=True)
        torch.nn.init.xavier_uniform_(self.fc2.weight) # initialize parameters

    def forward(self, y):
        output = self.layer1(y)
        output = self.layer2(output)
        output = self.layer3(output)
        output = output.view(output.size(0), -1)   # Flatten them for FC
        output = self.fc1(output)
        output = self.fc2(output)
        return output


#instantiate CNN model
CNNmodel = CNN()
CNNmodel

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором мы видим, что значения PyTorch nn conv2d в CNN печатаются на экране.

Смещение

Смещение PyTorch nn conv2d определяется как необязательный тензор смещения формы(out_channels). Значение смещения по умолчанию — Нет.

Код:

В следующем коде сначала мы импортируем библиотеки, такие как import torch.

• input = torch.ones(2,2,7,7): Здесь мы описываем входную переменную с помощью функции torch.ones().
• print(«Input = «,input) используется для печати входных данных с помощью функции print().
• m = torch.nn.Conv2d(in_channels = 1, out_channels = 1, kernel_size = 3): Здесь мы используем модуль conv2d.
• print(«Parameters = «,list(m.parameters())) используется для печати списка параметров.
• print(«bias = «,m.bias) используется для печати смещения.

# Import library
import torch

# Describe the input variable
input = torch.ones(2,2,7,7)

print("Input = ",input)

# Using conv2d module
m = torch.nn.Conv2d(in_channels = 1, out_channels = 1, kernel_size = 3)

# Print the list of the parametrs
print("Net = ",m)
print("Parameters = ",list(m.parameters()))

# Print the bias
print("bias = ",m.bias)

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором мы видим, что значение смещения PyTorch nn conv2d печатается на экране.

Транспонирование

PyTorch convtranspose2d применяет оператор двумерной транспонирования свертки к входному изображению, собранному из некоторых входных плоскостей.

Синтаксис:

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

Параметры:

• in_channels используются как несколько каналов во входных изображениях.
• out_channels используется как несколько каналов, созданных свертками.
• kernel_size используется как размер сверточного ядра.
• stride используется для управления шагом на основе взаимной корреляции.
• padding: контролирует количество неявного заполнения нулями.
• output_padding: контролирует дополнительный размер, добавляемый к одной стороне выходной фигуры.
• expansion: контролирует расстояние между точками ядра.
• groups: управляет соединениями между входами и выходами.

Пример:

В следующем коде сначала мы импортируем все необходимые библиотеки, такие как import torch, import torch.nn как nn.

• a = nn.ConvTranspose2d(18, 35, 5, шаг=2) используется как квадратное ядро и равный шаг.
• a = nn.ConvTranspose2d(18, 35,(3, 5), шаг=(2, 1), дополнение=(4, 2)) используется в качестве неквадратных ядер и неравного шага с заполнением.
• inp = torch.randn(1, 18, 14, 14) используется как точный размер вывода, который также можно указать в качестве аргумента.
• torch.Size([1, 18, 8, 8]) используется для печати размера на экране.

#Importing libraries
import torch 
import torch.nn as nn
# With square kernels and equal stride
a = nn.ConvTranspose2d(18, 35, 5, stride=2)
# non-square kernels and unequal stride and with padding
a = nn.ConvTranspose2d(18, 35,(3, 5), stride=(2, 1), padding=(4, 2))
inp = torch.randn(22, 18, 52, 102)
out = a(inp)
# exact output size can be also specified as an argument
inp = torch.randn(1, 18, 14, 14)
dsample = nn.Conv2d(18, 18, 5, stride=2, padding=1)
usample = nn.ConvTranspose2d(18, 18, 5, stride=2, padding=1)
m = dsample(inp)
m.size()
torch.Size([1, 18, 8, 8])
out = usample(m, output_size=inp.size())
out.size()

Выход:

В приведенном ниже выводе вы можете видеть, что размер транспонирования PyTorch nn conv2d печатается на экране.

Параметры

Прежде чем двигаться дальше, мы должны иметь некоторые знания о параметрах.

Параметры — это измеримые факторы, установленные как один из наборов, описывающих систему или задающих условия ее функционирования.

Код:

В следующем коде мы импортируем все необходимые библиотеки, такие как import torch, import torch.nn как nn.

• p = nn.Conv2d(22, 39, 5, шаг=2) используется с квадратными ядрами и равным шагом, а квадратное ядро и равный шаг являются параметрами, которые используются в методе nn.conv2d().
• inp = torch.randn(26, 22, 56, 106) используется для описания переменной с помощью функции torch.random().
• out = p(inp) используется для объявления выходной переменной.
• print(out) используется для печати вывода с помощью функции print().

# Importing Libraries
import torch
import torch. nn as nn

# With square kernels and equal stride
p = nn.Conv2d(22, 39, 5, stride=2)

# Describe the variable
inp = torch.randn(26, 22, 56, 106)

# Declare the output variable
out = p(inp)
# Print output
print(out)

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором мы видим, что значения параметров PyTorch nn conv2d печатаются на экране.

Вес

Вес PyTorch nn conv2d используется для выполнения свертки в 2d-данные и некоторых дополнительных опций, таких как заполнение и т. д.

Код:

В следующем коде мы импортируем библиотеку, например import torch.

• inp = torch.ones(1,1,6,6) используется для описания входной переменной с помощью функции torch.ones().
• print(«Input = «,inp) используется для печати входных значений.
• print(«Parameters = «,list(m.parameters())) используется для печати списка параметров.
• print(«Weight = «,m.weight) используется для печати весов.
• print(«bias = «,m.bias) используется для печати смещения.

# Import library
import torch

# Describe the input variable
inp = torch.ones(1,1,6,6)

# Print input
print("Input = ",inp)

m = torch.nn.Conv2d(in_channels = 1, out_channels = 1, kernel_size = 3)

# Print the parameter list
print("net = ",m)
print("Parameters = ",list(m.parameters()))
# Print the weight
print("Weight = ",m.weight)
# Print the bias
print("bias = ",m.bias)

out = m(inp)

print("Output = ",out)

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором мы видим, что вес PyTorch nn conv2d печатается на экране.

Входные и выходные каналы

Входные каналы PyTorch nn conv2d используются как несколько каналов во входном изображении. Выходные каналы PyTorch conv2d используются как количество каналов, созданных сверткой.

Код:

В следующем выводе мы импортируем все необходимые библиотеки, такие как import torch и импортируем переменную из torch.autograd, импортируем torch.nn как nn и импортируем torch.nn.functional.

• class model(nn.Module): здесь мы создаем класс модели с помощью функций init() и front().
• model = model() используется для создания экземпляра модели.
• print(model) используется для печати модели с помощью функции print().

# Importing Libraries
import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as fun

# Create model class
class model(nn.Module):

    def __init__(self):
        super(model, self).__init__()
        # 1 input image channel, 8 output channels, 7x7 square convolution
        self.conv1 = nn.Conv2d(1, 8, 7)
        self.conv2 = nn.Conv2d(8, 18, 7)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(18 * 7 * 7, 140)
        self.fc2 = nn.Linear(140, 86)
        self.fc3 = nn.Linear(86, 12)

    def forward(self, y):
        # Max pooling over a(2, 2) window
        y = fun.max_pool2d(fun.relu(self.conv1(y)),(2, 2))
        # If the size is a square you can only specify a single number
        y = fun.max_pool2d(fun.relu(self.conv2(y)), 2)
        y = y.view(-1, self.numflat_featurs(y))
        y = fun.relu(self.fc1(y))
        y = fun.relu(self.fc2(y))
        y = self.fc3(y)
        return y

    def numflat_featurs(self, y):
      # all dimensions except the batch dimension
        size = y.size()[1:]  
        numfeaturs = 1
        for i in size:
            numfeaturs *= i
        return numfeaturs

# Instantiate the model
model = model()
# Print the model
print(model)

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором мы видим, что входные и выходные каналы PyTorch nn conv2d печатаются на экране.