Dynamic Computation Graph

What Is PyTorch, and How Does It Work?

PyTorch is an optimized Deep Learning tensor library based on Python and Torch and is mainly used for applications using GPUs and CPUs. PyTorch is favored over other Deep Learning frameworks like TensorFlow and Keras since it uses dynamic computation graphs and is completely Pythonic. It allows scientists, developers, and neural network debuggers to run and test portions of the code in real-time. Thus, users don’t have to wait for the entire code to be implemented to check if a part of the code works or not.

The two main features of PyTorch are:

• Tensor Computation (similar to NumPy) with strong GPU (Graphical Processing Unit) acceleration support
• Automatic Differentiation for creating and training deep neural networks

Basics of PyTorch

The basic PyTorch operations are pretty similar to Numpy. Let’s understand the basics first.

• Introduction to Tensors

In machine learning, when we represent data, we need to do that numerically. A tensor is simply a container that can hold data in multiple dimensions. In mathematical terms, however, a tensor is a fundamental unit of data that can be used as the foundation for advanced mathematical operations. It can be a number, vector, matrix, or multi-dimensional array like Numpy arrays. Tensors can also be handled by the CPU or GPU to make operations faster. There are various types of tensors like Float Tensor, Double Tensor, Half Tensor, Int Tensor, and Long Tensor, but PyTorch uses the 32-bit Float Tensor as the default type.

• Mathematical Operations

The codes to perform mathematical operations are the same in PyTorch as in Numpy. Users need to initialize two tensors and then perform operations like addition, subtraction, multiplication, and division on them.

• Matrix Initialization and Matrix Operations

To initialize a matrix with random numbers in PyTorch, use the function randn() that gives a tensor filled with random numbers from a standard normal distribution. Setting the random seed at the beginning will generate the same numbers every time you run this code. Basic matrix operations and transpose operation in PyTorch are also similar to NumPy.

Common PyTorch Modules

In PyTorch, modules are used to represent neural networks.

• Autograd

The autograd module is PyTorch’s automatic differentiation engine that helps to compute the gradients in the forward pass in quick time. Autograd generates a directed acyclic graph where the leaves are the input tensors while the roots are the output tensors.

• Optim

The Optim module is a package with pre-written algorithms for optimizers that can be used to build neural networks.

• nn

The nn module includes various classes that help to build neural network models. All modules in PyTorch subclass the nn module.

Dynamic Computation Graph

Computational graphs in PyTorch allow the framework to calculate gradient values for the neural networks built. PyTorch uses dynamic computational graphs. The graph is defined indirectly using operator overloading while the forward computation gets executed. Dynamic graphs are more flexible than static graphs, wherein users can make interleaved construction and valuation of the graph. These are debug-friendly as it allows line-by-line code execution. Finding problems in code is a lot easier with PyTorch Dynamic graphs – an important feature that makes PyTorch such a preferred choice in the industry.

Computational graphs in PyTorch are rebuilt from scratch at every iteration, allowing the use of random Python control flow statements, which can impact the overall shape and size of the graph every time an iteration occurs. The advantage is – there’s no need to encode all possible paths before launching the training. You run what you differentiate.

Data Loader

Working with large datasets requires loading all data into memory in one go. This causes memory outage, and programs run slowly. Besides, it’s hard to maintain data samples processing code. PyTorch offers two data primitives – DataLoader and Dataset – for parallelizing data loading with automated batching and better readability and modularity of codes. Datasets and DataLoader allow users to use their own data as well as pre-loaded datasets. While Dataset houses the samples and the respective labels, DataLoader combines dataset and sampler and implements an iterable around the Dataset so users can easily access samples.

Solving an Image Classification Problem Using PyTorch

Have you ever built a neural network from scratch in PyTorch? If not, then this guide is for you.

• Step 1 – Initialize the input and output using tensor.
• Step 2 – Define the sigmoid function that will act as an activation function. Use a derivative of the sigmoid function for the backpropagation step.
• Step 3 – Initialize the parameters such as the number of epochs, weights, biases, learning rate, etc., using the randn() function. This completes the creation of a simple neural network consisting of a single hidden layer and an input layer, and an output layer.

The forward propagation step is used to calculate output, while the backward propagation step is used for error calculation. The error is used to update the weights and biases.

Next, we have our final neural network model based on a real-world case study, where the PyTorch framework helps create a deep learning model.

The task at hand is an image classification problem, where we find out the type of apparel by looking at different apparel images.

• Step 1 – Classify the image of apparel into different classes.

There are two folders in the dataset – one for the training set and the other for the test set. Each folder contains a .csv file that has the image id of any image and the corresponding label name. Another folder contains the images of the specific set.

• Step 2 – Load the Data

Import the required libraries and then read the .csv file. Plot a randomly selected image to better understand how the data looks. Load all training images with the help of the train.csv file.

• Step 3 – Train the Model

Build a validation set to check the performance of the model on unseen data. Define the model using the import torch package and the needed modules. Define parameters like the number of neurons, epochs, and learning rate. Build the model, and then train it for a particular number of epochs. Save training and validation loss in case of each epoch—plot, the training, and validation loss, to check if they are in sync.

• Step 4 – Getting Predictions

Finally, load the test images, make predictions, and submit the predictions. Once the predictions are submitted, use the accuracy percentage as a benchmark to try and improve by altering the different parameters of the model.

Stay ahead of the tech-game with our Professional Certificate Program in AI and Machine Learning in partnership with Purdue and in collaboration with IBM. Explore more!

Stay Updated With Developments in the Field of Deep Learning

Summing up, PyTorch is an essential deep learning framework and an excellent choice as the first deep learning framework to learn. If you’re interested in computer vision and deep learning, check out our tutorials on Deep Learning applications and neural networks.