PyTorch Conv3d - Detailed Guide

The PyTorch Conv3d is a class that applies a three-dimensional convolution over an input signal collected of some input planes. In detail, we will discuss Conv3d using PyTorch in python. And additionally, we will also cover different examples related to PyTorch Conv3d.

What is PyTorch Conv3d
PyTorch Conv3d example
PyTorch functional Conv3d
PyTorch Conv3d padding
PyTorch Conv3d group
PyTorch conv3d dilation
PyTorch Conv3d bias
PyTorch Conv3d in CNN
PyTorch Conv3d transpose
PyTorch Conv3d parameters
PyTorch Conv3d weight
PyTorch Conv3d input_channels and output_channels

Table of Contents

What is PyTorch Conv3d

In this section, we will learn about the PyTorch Conv3d in python.

The PyTorch Conv3d is defined as a three-dimensional convolution that is applied over an input signal collected of some input planes.

Syntax:

The syntax of PyTorch Conv3d is:

torch.nn.Conv3d(in_channels, out_channels, Kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', devices=None, dtype=None)

Parameters:

The following are the parameters of PyTorch Conv3d:

in_channels is used as the number of channels in the input image.
out_channels is used as the number of channels produces by the convolution.
Kernel_size is used to define as the size of the convolutional kernel.
stride is used to control the stride for the cross-correlation and a single number or a one-element tuple.
padding is used to control the amount of padding applied to the input. It can be either string or a tuple of the amount of implicit padding. The default value of padding is 0.
dilation is used to control the spacing between the kernel elements and the default value of dilation is 1.
groups are used to control the connection between the inputs and outputs. The default value of groups is 1.
bias: The default value of the bias is True. If it is true it adds a learnable bias to the output. If it is false it does not add any learnable bias to the output.

So, with this, we understood what exactly is PyTorch Conv3d and in the next section, we will illustrate an example related to it.

Read: PyTorch Early Stopping + Examples

PyTorch Conv3d example

In this section, we will learn how to implement PyTorch Conv3d with the help of an example in python.

The PyTorch Conv3d is an easy arithmetic operation inside this we skid a matrix or kernel of weights above three-dimensional data and perform the element-wise multiplication of data.

Code:

In the following code, we will import all the necessary libraries such as import torch, import torch.nn as nn.

c = nn.Conv3d(18, 35, 5, stride=2): Here we are declaring the variable by using square kernels and equal stride.
input = torch.randn(22, 18, 12, 52, 102) is used to describing the input variable by using torch.randn() function.
print(output) is used to print the output bu using the print() function.

# Importing libraries
import torch
import torch.nn as nn

# Declaring the variable by using square kernels and equal stride
c = nn.Conv3d(18, 35, 5, stride=2)

# Describing the input and output variables
input = torch.randn(22, 18, 12, 52, 102)
output = c(input)

# Print output
print(output)

Output:

After running the above code, we get the following output in which we can see that the PyTorch Conv3d values are printed on the screen.

This is how we can understand the PyTorch Conv3d with the help of an example.

Read: Keras Vs PyTorch – Key Differences

PyTorch functional Conv3d

In this section, we will learn about the PyTorch functional Conv3d in python.

The PyTorch functional Conv3d applies a three-dimensional convolution over an input image collected from some input planes.

Syntax:

The syntax of the PyTorch functional Conv3d is :

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

Parameters:

The following are the parameters of the PyTorch functional conv3d:

input: Input is defined as an input tensor of shape(minibatch, in_channels).
weight: Weight is defined as a filter of shape(out_channels).
bias: Bias is defined as an optional bias tensor of shape(out_channels). The default value of bias is None.
stride: Stride of the convolving kernel. The default value of stride is 1.
padding is used to control the amount of padding applied to the input. It can be either string or a tuple of the amount of implicit padding. The default value of padding is 0.
dilation is used to control the spacing between the kernel elements and the default value of dilation is 1.
groups are used to control the connection between the inputs and outputs. The default value of groups is 1.

Example:

In the following code, firstly we will import all the necessary libraries such as import torch, import torch.nn.functional as function.

filter = torch.randn(35, 18, 5, 5, 5): Here we are describing the variable by using torch.randn() function.
f=function.conv3d(input, filter) is used to describe the function.conv3d() function.
print(f) is used to print the output by using print() function.

# Importing Libraries
import torch
import torch.nn.functional as function
# Describing the variable by using torch.randn() function
filter = torch.randn(35, 18, 5, 5, 5)
input = torch.randn(22, 18, 52, 12, 22)
# Using conv3d() function
f=function.conv3d(input, filter)
# print output
print(f)

Output:

After running the above code, we get the following output in which we can see that the PyTorch functional Conv3d values is printed on the screen.

So, with this, we understood about the PyTorch functional Conv3d.

Read: PyTorch Batch Normalization

PyTorch Conv3d padding

In this section, we will learn about the PyTorch Conv3d padding in python.

PyTorch Cpnv3d padding is used to control the amount of padding applied to the input. It can be either string or a tuple of giving the amount of implicit padding. The default value of padding is 0.

Code:

In the following code we will import all the necessary libraries such as import torch, import torch.nn as nn.

c = nn.Conv3d(18, 35, 5, stride=2): Here we are declaring the variable by using square kernels and equal stride.
p = nn.Conv3d(18, 35, (5, 7, 4), stride=(4, 3, 3), padding=(6, 4, 0)): Here we are declaring the variable by using non-square kernels and unequal stride with padding.
input = torch.randn(22, 18, 12, 52, 102): Here we are describing the input and output variables by using torch.randn() function.
print(output) is used to print the output by using the print() function.

# Importing libraries
import torch
import torch.nn as nn
# Declaring the variable by using square kernels and equal stride
c = nn.Conv3d(18, 35, 5, stride=2)
# Declaring the variable by using non-square kernels and unequal stride with padding
p = nn.Conv3d(18, 35, (5, 7, 4), stride=(4, 3, 3), padding=(6, 4, 0))
# Describing the input and output variables
input = torch.randn(22, 18, 12, 52, 102)
output = p(input)
# Print output
print(output)

Output:

In the below output, we can see that the PyTorch Conv3d padding values are printed on the screen.

So, with this, we understood about the PyTorch Conv3d padding.

Read: PyTorch nn linear + Examples

PyTorch Conv3d group

In this section, we will learn about the PyTorch Conv3d group in python.

The PyTorch Conv3d group is used to control the connection between the inputs and outputs. The default value of groups is 1.

Code:

In the following code, we will import all the necessary libraries such as import torch and import torch.nn as nn.

g = nn.Conv3d(20, 37, 7, stride=2) is used to declaring the variable by using square kernels and equal stride.
input = torch.randn(24, 20, 14, 54, 104) is used describe the input variable by using torch.randn() function.
print(output) is used to print the output by using print() function.

# Importing libraries
import torch
import torch.nn as nn

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

# Describing the input and output variables
input = torch.randn(24, 20, 14, 54, 104)
output = g(input)

# Print output
print(output)

Output:

After running the above code, we get the following output in which we can see that the PyTorch Conv3d group values are printed on the screen.

This is how we understand about the PyTorch Conv3d group.

Read: Cross Entropy Loss PyTorch

PyTorch conv3d dilation

In this section, we will learn about the PyTorch Conv3d dilation in python.

The PyTorch Conv3d dilation is used to control the spacing between the kernel elements and the default value of dilation is 1.

Code:

In the following code, we will import all the necessary libraries such as import torch and import torch.nn as nn.

c = nn.Conv3d(18, 35, 5, stride=2): Here we are declaring the variable by using square kernels and equal stride.
p = nn.Conv3d(18, 35, (5, 7, 4), stride=(4, 3, 3), padding=(6, 4, 0)): Here we are declaring the variable by using non-square kernels and unequal stride with padding.
q = nn.Conv3d(18, 35, (5, 7, 4), stride=(4, 3, 3), padding=(6, 4, 0), dilation=(5,3,1)): Here we are declaring the variable by using non-square kernels and unequal stride with padding and dilation.
input = torch.randn(22, 18, 12, 52, 102): Here we describing the variable by using torch.randn() function.
print(output) is used to print the output by using the print() function.

# Importing libraries
import torch
import torch.nn as nn
# Declaring the variable by using square kernels and equal stride
c = nn.Conv3d(18, 35, 5, stride=2)
# Declaring the variable by using non-square kernels and unequal stride with padding
p = nn.Conv3d(18, 35, (5, 7, 4), stride=(4, 3, 3), padding=(6, 4, 0))
# Declaring the variable by using non-square kernels and unequal stride with padding and dilation
q = nn.Conv3d(18, 35, (5, 7, 4), stride=(4, 3, 3), padding=(6, 4, 0), dilation=(5,3,1))
# Describing the input and output variables
input = torch.randn(22, 18, 12, 52, 102)
output = q(input)
# Print output
print(output)

Output:

After running the above code, we get the following output in which we can see that the PyTorch Conv3d dilation values are printed on the screen.

So, with this, we understood the working of the PyTorch dilation in python.

Read: PyTorch Numpy to Tensor

PyTorch Conv3d bias

In this section, we will learn about the PyTorch Conv3d bias in python.

Before moving forward we should have a piece of knowledge about the bias. Bias takes into description the difference between the model prediction and the real outcome.

The PyTorch Conv3d bias adds a learnable bias to the output when its value is true if it is false it does not add the learnable bias to the output. The default value of bias is True.

Code:

In the following code, we will import the torch library such as import torch.

inp = torch.ones(4,4,9,9): Here we are describing the input variable by using a torch.ones() function.
c = torch.nn.Conv3d(in_channels = 1, out_channels = 1, kernel_size = 3): Here we are using the Conv3d() function.
print(“Parameters = “,list(c.parameters())) is used to print the list of the parameters by using print() function.
print(“bias = “,c.bias) is used to print the bias by using the print() function.

# Import library
import torch

# Describe the input variable
inp = torch.ones(4,4,9,9)

print("Input = ",inp)

# Using conv3d module
c = torch.nn.Conv3d(in_channels = 1, out_channels = 1, kernel_size = 3)

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

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

Output:

After running the above code, we get the following output in which we can see that the PyTorch Conv3d bias values are printed on the screen.

So, with this, we understood about the PyTorch Conv3d bias with the help of an example.

Read: PyTorch Model Summary

PyTorch Conv3d in CNN

In this section, we will learn about the PyTorch Conv3d in CNN using python.

Before moving forward we should have some piece of knowledge about Convolutional Neural networks (CNN).

Convolutional Neural Network is a type of artificial neural network that is used in image recognition.

Here we are using the PyTorch Conv3d to deal with a convolutional neural network. It is a simple mathematical operation in which we skid a matrix or kernel of weights over three-dimensional data and performs element-wise multiplication with the data.

Code:

In the following code, firstly we will import all the necessary libraries such as import torch, import Variable from torch.autograd, import torchvision.datasets, import torch.nn.init.

traindata = dtsets.MNIST(root=’MNIST_data/’, train=True, transform=transforms.ToTensor(), download=True) is used as a train MNIST dataset.
print(‘Training dataset:\t’,traindata) is sued to print the train dataset by using print() function.
class CNN(torch.nn.Module): is used to create a model class with the help of init() and forward() methods.
CNNmodel = CNN() is used to create an instance of the model.

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

# hyperparameters
batch_size = 24
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('Training dataset:\t',traindata)
print('\nTesting dataset:\t',testdata)

# Define the CNN Model class
class CNN(torch.nn.Module):

    def __init__(self):
        super(CNN, self).__init__()
        self.layer1 = torch.nn.Sequential(
            torch.nn.Conv3d(1, 24, 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.Conv3d(24, 56, 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.Conv3d(56, 120, 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))

        
        self.fc1 = torch.nn.Linear(4 * 4 * 120, 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)
        # initialize parameters
        torch.nn.init.xavier_uniform_(self.fc2.weight) 

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


#instantiate CNN model
CNNmodel = CNN()
CNNmodel

Output:

In the below output, we can see that the PyTorch Conv3 in the CNN model is printed on the screen.

This is how we can use the PyTorch Conv3d in CNN and create a CNN model.

Read: PyTorch Logistic Regression

PyTorch Conv3d transpose

In this section, we will learn about the PyTorch Conv3d transpose in python.

The PyTorch Conv3d transpose applies a 3d transposed convolution operator over input images collected of some input planes.

Syntax:

The syntax of PyTorch Conv3d transpose

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

Parameters:

The following are the parameters of PyTorch Conv3d transpose.

in_channels are the number of channels in the input image.
out_channels are the number of channels produced by the convolution.
kernel_size is used as the size of the convolving kernel.
stride is sued to control the stride from the cross-correlation.
padding is used to control the amount of implicit zero padding.
outpu_padding is used to control the additional size added to one side of the output shape.
dilation is used to control the spacing between the kernel points.
groups are used to control the connections between the inputs and outputs.

Example:

In the following code, we will import all the necessary libraries such as import torch, import torch.nn as nn.

c = nn.ConvTranspose3d(16, 33, 3, stride=2) is used to describe the variable by using square kernels and equal stride.
c = nn.ConvTranspose3d(16, 33, (3, 5, 2), stride=(2, 1, 1), padding=(0, 4, 2)) is used to describing the variable by using non-square kernels and unequal stride with padding.
inp = torch.randn(20, 16, 10, 50, 100): Here we are describing the input variable by using torch.randn() function.
print(outp) is used to print the output by using the print() function.

# Importing Libraries
import torch
import torch.nn as nn
# Describing the variable by using square kernels and equal stride
c = nn.ConvTranspose3d(16, 33, 3, stride=2)
# Describing the variable by using non-square kernels and unequal stride and with padding
c = nn.ConvTranspose3d(16, 33, (3, 5, 2), stride=(2, 1, 1), padding=(0, 4, 2))
# Declaring the input variable
inp = torch.randn(20, 16, 10, 50, 100)
outp = c(inp)
# Print output
print(outp)

Output:

After running the above code, we get the following output in which we can see that the PyTorch Conv3d transpose values are printed on the screen.

So, with this, we understood about the PyTorch Conv3d transpose with the help of an example.

Read: PyTorch Model Eval + Examples

PyTorch Conv3d parameters

In this section, we will learn about the PyTorch Conv3d parameters in python.

Before moving forward we should have a piece of knowledge about parameters. Parameters are measurable factors established as one of the sets that describe the system or set the condition of its operations.

Code:

In the following code, we will import all the necessary libraries such as import torch and import torch.nn as nn.

k = nn.Conv3d(22, 39, 9, stride=2) is used to describe the variable by using square kernels and equal stride.
inp = torch.randn(26, 22, 16, 56, 106): Here we are describing the input variable by using torch.randn() function.
print(out) is used to print the output by using the print() function.

# Importing libraries
import torch
import torch.nn as nn

# Declaring the variable by using square kernels and equal stride
k = nn.Conv3d(22, 39, 9, stride=2)

# Describing the input and output variables
inp = torch.randn(26, 22, 16, 56, 106)
out = k(inp)

# Print output
print(out)

Output:

In the below output, we can see that the PyTorch Conv3d parameters values are printed on the screen.

This is how we can describe the conv3d parameters and do the arithmetic operations.

Read: PyTorch RNN – Detailed Guide

PyTorch Conv3d weight

In this section, we will learn about the PyTorch Conv3d weight in python.

The PyTorch Conv3d weight is used to execute the convolution to 3d data and some additional options like padding etc.

Code:

In the following code, we will import the torch library such as import torch.

inpt = torch.ones(1,1,3,3,3): Here we are describing the input variable by using the torch.ones() function.
print(“Input = “,inpt) is used to print the input by using the print() function.
w = torch.nn.Conv3d(in_channels = 1, out_channels = 1, kernel_size = 3): Here we are using Conv3d() function.
print(“Parameters = “,list(w.parameters())) is used to print the list of parameters.
print(“Weight = “,w.weight) is used to print the weights.
print(“Output = “,out) is used to print the output with the help of the print() function.

# Import library
import torch

# Describe the input variable
inpt = torch.ones(1,1,3,3,3)

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

w = torch.nn.Conv3d(in_channels = 1, out_channels = 1, kernel_size = 3)

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

out = w(inpt)

print("Output = ",out)

Output:

After running the above code, we get the following output in which we can see that the PyTorch Conv3d weight is printed on the screen.

This is how we understand about the PyTorch Conv3d weight.

Read: PyTorch View Tutorial

PyTorch Conv3d input_channels and output_channels

In this section, we will learn about the PyTorch Conv3d input_channels and output_channels in python.

The PyTorch Conv3d input_channels is used as the number of channels in the input image.

The PyTorch Conv3d output_channels is used as the number of channels produces by the convolution.

Code:

In the following code, firstly we will import all the necessary libraries such as import torch, import Variable from torch.autograd, import torch.nn as nn, import torch.nn.functional.

class mod(nn.Module): Here we are creating a model class with the help of init() and forward() functions.
size = y.size()[1:] is used as all the dimensions except batch dimensions.
model = mod() is used as an instance of the model.
print(model) is used to print the model by using the print() function.

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

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

    def __init__(self):
        super(mod, self).__init__()
        # 1 input image channel, 10 output channels, 9x9 square convolution
        self.conv1 = nn.Conv3d(1, 10, 9)
        self.conv2 = nn.Conv3d(10, 20, 9)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(20 * 9 * 9, 142)
        self.fc2 = nn.Linear(142, 88)
        self.fc3 = nn.Linear(88, 14)

    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 = mod()
# Print the model
print(model)

Output:

After running the above code, we get the following output in which we can see that the PyTorch Conv3d input_channels and output_channels values are printed on the screen.

So, with this, we understood the PyTorch Conv3d input_channels and output_channels.

Also, take a look at some more Python PyTorch tutorials.

So, in this tutorial, we discussed PyTorch Conv3d and we have also covered different examples related to its implementation. Here is the list of examples that we have covered.

What is PyTorch Conv3d
PyTorch Conv3d example
PyTorch functional Conv3d
PyTorch Conv3d padding
PyTorch Conv3d group
PyTorch conv3d dilation
PyTorch Conv3d bias
PyTorch Conv3d in CNN
PyTorch Conv3d transpose
PyTorch Conv3d parameters
PyTorch Conv3d weight
PyTorch Conv3d input_channels and output_channels

Bijay Kumar

Python is one of the most popular languages in the United States of America. I have been working with Python for a long time and I have expertise in working with various libraries on Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etc… I have experience in working with various clients in countries like United States, Canada, United Kingdom, Australia, New Zealand, etc. Check out my profile.

enjoysharepoint.com/