2025/1/12 12:32 tutorialspoint.

com/building-deep-learning-models-using-the-pytorch-library

Building Deep Learning Models Using the

PyTorch Library

PyTorch is a widely used open-source machine learning framework that was developed by
Facebook's AI research team. It is known for its flexibility, speed, and ability to build complex
models easily. PyTorch is based on the Torch library, which was originally developed in Lua,
and it provides Python bindings.

PyTorch is widely used in academia and industry for various machine learning tasks such as
computer vision, natural language processing, and speech recognition. In this tutorial, we will
learn how to use the PyTorch library to build a deep learning model.

Getting Started
Before we dive into using the torch library, we first need to install the library using pip.
However, since it does not come built-in, we must first install the torch library. This can be
done using the pip package manager.

To install the torch library, open your terminal and type the following command −

pip install torch

This will download and install the torch library and its dependencies. Once installed, we can
start working with torch and leverage it’s modules!

In this tutorial, we will be building a Convolutional Neural Network (CNN) for image
classification using PyTorch. Convolutional Neural Networks (CNNs) are a type of deep
learning model that is widely used for image classification tasks. In this tutorial, we will build
a CNN using PyTorch to classify images.

Step 1: Importing the Required Libraries

The first step is to import the required libraries. We will be using the torch, torch.nn, and
torchvision libraries.

import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms

Step 2: Loading and Preprocessing the Dataset

We will be using the CIFAR-10 dataset, which is a widely used dataset for image
classification tasks. The dataset consists of 60,000 32x32 color images in 10 classes, with
6,000 images per class.

https://www.tutorialspoint.com/building-deep-learning-models-using-the-pytorch-library 1/4
2025/1/12 12:32 tutorialspoint.com/building-deep-learning-models-using-the-pytorch-library
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,

download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,

download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=2)

We use the torchvision.transforms library to preprocess the images. We first convert the
images to tensors and then normalize them. We then load the dataset and create a data
loader for both the training and test sets.

Step 3: Defining the CNN Model

After preparing the data, the next step is to define the CNN model using PyTorch. In this step,
we will define the structure of our CNN model. Our model will consist of two convolutional
layers, followed by two fully connected layers.

import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
# input image channel, 3 for RGB images
# output channel, 6 for 6 filters
# kernel size = 5
self.conv1 = nn.Conv2d(3, 6, 5)
# input channel, 6 from previous layer
# output channel, 16 for 16 filters
# kernel size = 5
self.conv2 = nn.Conv2d(6, 16, 5)
# an affine operation: y = Wx + b
# 16 * 5 * 5 is the size of the image after convolutional layers
# 120 is the output size of the first fully connected layer
self.fc1 = nn.Linear(16 * 5 * 5, 120)
# 84 is the output size of the second fully connected layer
self.fc2 = nn.Linear(120, 84)
# 10 is the output size of the last fully connected layer
self.fc3 = nn.Linear(84, 10)

def forward(self, x):

# max pooling over a (2, 2) window
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
# if the size is a square you can only specify a single number
x = F.max_pool2d(F.relu(self.conv2(x)), 2)
# flatten the input for fully connected layers
x = x.view(-1, self.num_flat_features(x))
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x

def num_flat_features(self, x):

size = x.size()[1:] # all dimensions except the batch dimension
num_features = 1
for s in size:
num_features *= s
return num_features

https://www.tutorialspoint.com/building-deep-learning-models-using-the-pytorch-library 2/4
2025/1/12 12:32 tutorialspoint.com/building-deep-learning-models-using-the-pytorch-library

net = Net()

Step 4: Train the Model

Now that we have defined our CNN model, it's time to train it on our dataset. To do this, we
will use the PyTorch DataLoader class to load our data in batches and feed it into the model
for training. We will also define our loss function and optimizer.

Here is the code to train our model −

# Define the loss function and optimizer

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

# Train the model

num_epochs = 10
for epoch in range(num_epochs):
running_loss = 0.0
for i, data in enumerate(train_loader, 0):
inputs, labels = data
optimizer.zero_grad()

# Forward pass
outputs = model(inputs)
loss = criterion(outputs, labels)

# Backward and optimize

loss.backward()
optimizer.step()

# Print statistics
running_loss += loss.item()
if i % 2000 == 1999: # Print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')

We loop over our dataset for 10 epochs and train the model using the training data. In each
epoch, we reset the running loss to 0 and loop over the batches of data.

For each batch, we perform a forward pass through the model, compute the loss, perform
backpropagation, and optimize the model using the optimizer. Finally, we print the training
loss after every 2000 mini-batches.

Step 5: Evaluate the Model

Now that we have trained our model, it's time to evaluate its performance on our test dataset.
We will use the PyTorch DataLoader class to load our test data in batches and feed it into
the model for evaluation.

Here is the code to evaluate our model −

# Evaluate the model

correct = 0
total = 0
with torch.no_grad():
for data in test_loader:
images, labels = data
outputs = model(images)
https://www.tutorialspoint.com/building-deep-learning-models-using-the-pytorch-library 3/4
2025/1/12 12:32 tutorialspoint.com/building-deep-learning-models-using-the-pytorch-library
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (

100 * correct / total))

In this code, we first initialize the correct and total variables to 0. We then loop over our test
dataset using the PyTorch DataLoader class and feed the test data into the model. We use
the torch.max() function to get the index of the highest output value, which represents the
predicted class. We then compare the predicted class to the true class and update the
correct and total variables accordingly.

Finally, we print the accuracy of the model on the test dataset.

Conclusion
Concluding, PyTorch is a robust deep learning package with an easy-to-use interface for
creating and training neural networks. We covered the fundamentals of using PyTorch to
construct a convolutional neural network for image classification in this tutorial.

PyTorch's flexibility and ease of use make it an excellent choice for both researchers and
practitioners interested in experimenting with deep learning. The dynamic computational
graph and automatic differentiation engine of the library make it simple to create complex
models and optimise them efficiently. Furthermore, PyTorch has a large and active
community, which means there are a lot of resources for learning and getting help when you
need it.

Overall, PyTorch is a wonderful alternative for anyone interested in getting started with deep
learning, whether they are a newbie or a seasoned practitioner. PyTorch, with its simple API
and powerful capabilities, can help you quickly design and train deep learning models for a
variety of applications.

Related Articles
JavaScript Machine Learning: Building ML Models in the Browser
Learning Model Building in Scikit-learn: A Python Machine Learning Library
Prediction of Wine type using Deep Learning
Deep Belief Network (DBN) in Deep Learning
Building a Recommendation Engine in Python Using the LightFM library
Loan Eligibility Prediction using Machine Learning Models in Python
Relation between deep learning and machine learning
Difference between Deep Learning and Reinforcement Learning
Three Stages of Building Hypotheses or Models
Difference between Bayesian Machine Learning and Deep Learning
Deep Learning Super Sampling (DLSS) in machine learning
Difference Between AI, Machine Learning, and Deep Learning
Deep Learning and the Internet of Things
What are Autoencoders in Deep Learning?
Transformer Neural Network in Deep Learning

https://www.tutorialspoint.com/building-deep-learning-models-using-the-pytorch-library 4/4