PyTorch

PyTorch

Original author(s)	Adam Paszke Sam Gross Soumith Chintala Gregory Chanan
Developer(s)	Meta AI
Initial release	September 2016 (2016-09)
Stable release	2.4.0  / 24 July 2024 (24 July 2024)
Repository	github.com/pytorch/pytorch
Written in	Python C++ CUDA
Operating system	Linux macOS Windows
Platform	IA-32, x86-64, ARM64
Available in	English
Type	Library for machine learning and deep learning
License	BSD-3
Website	pytorch.org

PyTorch is a machine learning framework based on the Torch library, used for applications such as computer vision and natural language processing, originally developed by Meta AI and now part of the Linux Foundation umbrella. It is free and open-source software released under the modified BSD license. Although the Python interface is more polished and the primary focus of development, PyTorch also has a C++ interface.

A number of pieces of deep learning software are built on top of PyTorch, including Tesla Autopilot, Uber's Pyro, Hugging Face's Transformers, PyTorch Lightning, and Catalyst.

PyTorch provides two high-level features:

• Tensor computing (like NumPy) with strong acceleration via graphics processing units (GPU)
• Deep neural networks built on a tape-based automatic differentiation system

History

Meta (formerly known as Facebook) operates both PyTorch and Convolutional Architecture for Fast Feature Embedding (Caffe2), but models defined by the two frameworks were mutually incompatible. The Open Neural Network Exchange (ONNX) project was created by Meta and Microsoft in September 2017 for converting models between frameworks. Caffe2 was merged into PyTorch at the end of March 2018. In September 2022, Meta announced that PyTorch would be governed by PyTorch Foundation, a newly created independent organization – a subsidiary of Linux Foundation.

PyTorch 2.0 has been released on 15 March 2023.

As of 2023-07-23, below are the published PyTorch versions inception to date:

index	PyTorch Version	torchvision	torchtext	torchaudio	PyTorch Release Date
0	2.0.0	0.15.1	0.15.1	2.0.1	2023-03-15 00:00:00
1	1.13.0	0.14.0	0.14.0	0.13.0	2022-10-28 00:00:00
2	1.12.0	0.13.0	0.13.0	0.12.0	2022-06-28 00:00:00
3	1.11.0	0.12.0	0.12.0	0.11.0	2022-02-10 00:00:00
4	1.10.1	0.11.2	0.11.1	0.10.1	2021-12-15 00:00:00
5	1.1	0.11.0	0.11.0	0.10.0	2021-10-21 00:00:00
6	1.9.1	0.10.1	0.10.1	0.9.1	2021-09-21 00:00:00
7	1.9.0	0.10.0	0.10.0	0.9.0	2021-06-15 00:00:00
8	1.8.1	0.9.1	nan	nan	2021-03-25 00:00:00
9	1.8.0	0.9.0	0.9.0	0.8.0	2021-03-04 00:00:00
10	1.7.1	0.8.2	0.8.1	0.7.2	2020-12-10 00:00:00
11	1.7.0	0.8.0 + 0.8.1	0.8.0	nan	2020-10-27 00:00:00
12	1.6.0	0.7.0	0.7.0	0.6.0	2020-07-28 00:00:00
13	1.5.1	0.6.1	nan	0.5.1	2020-06-18 00:00:00
14	1.5.0	0.6.0	0.6.0	0.5.0	2020-04-21 00:00:00
15	1.4.0	0.5.0	0.5.0	0.4.0	2020-01-15 00:00:00
16	1.3.1	0.4.2	nan	0.3.2	2019-11-07 00:00:00
17	1.3.0	0.4.1	nan	0.3.1	2019-10-22 00:00:00
18	1.2.0	0.4.0	nan	0.3.0	2019-08-08 00:00:00
19	1.1.0	0.3.0	nan	nan	2019-04-30 00:00:00
20	1.0.0	0.2.2	nan	nan	2018-12-07 00:00:00
21	0.4.1	nan	nan	nan	2018-07-26 00:00:00
22	0.4.0	0.2.1	0.2.3	nan	2018-04-24 00:00:00
23	0.3.1	nan	nan	nan	2018-04-03 00:00:00
24	0.3.0	nan	nan	nan	2018-01-25 00:00:00
25	initial	nan	nan	nan	2016-09

PyTorch tensors

Main article: Tensor (machine learning)

PyTorch defines a class called Tensor (torch.Tensor) to store and operate on homogeneous multidimensional rectangular arrays of numbers. PyTorch Tensors are similar to NumPy Arrays, but can also be operated on a CUDA-capable NVIDIA GPU. PyTorch has also been developing support for other GPU platforms, for example, AMD's ROCm and Apple's Metal Framework.

PyTorch supports various sub-types of Tensors.

Note that the term "tensor" here does not carry the same meaning as tensor in mathematics or physics. The meaning of the word in machine learning is only tangentially related to its original meaning as a certain kind of object in linear algebra.

Modules

Autograd module

PyTorch uses a method called automatic differentiation. A recorder records what operations have performed, and then it replays it backward to compute the gradients. This method is especially powerful when building neural networks to save time on one epoch by calculating differentiation of the parameters at the forward pass.

Optim module

torch.optim is a module that implements various optimization algorithms used for building neural networks. Most of the commonly used methods are already supported, so there is no need to build them from scratch.

nn module

PyTorch autograd makes it easy to define computational graphs and take gradients, but raw autograd can be a bit too low-level for defining complex neural networks. This is where the nn module can help. The nn module provides layers and tools to easily create a neural networks by just defining the layers of the network.

PyTorch also contains many other useful submodules such as data loading utilities and distributed training functions.

Example

The following program shows the low-level functionality of the library with a simple example

import torch
dtype = torch.float
device = torch.device("cpu") # This executes all calculations on the CPU
# device = torch.device("cuda:0") # This executes all calculations on the GPU

# Creation of a tensor and filling of a tensor with random numbers
a = torch.randn(2, 3, device=device, dtype=dtype)
print(a) # Output of tensor A
# Output: tensor([[-1.1884,  0.8498, -1.7129],
#                  [-0.8816,  0.1944,  0.5847]])

# Creation of a tensor and filling of a tensor with random numbers
b = torch.randn(2, 3, device=device, dtype=dtype)
print(b) # Output of tensor B
# Output: tensor([[ 0.7178, -0.8453, -1.3403],
#                  [ 1.3262,  1.1512, -1.7070]])

print(a*b) # Output of a multiplication of the two tensors
# Output: tensor([[-0.8530, -0.7183,  2.58],
#                  [-1.1692,  0.2238, -0.9981]])

print(a.sum()) # Output of the sum of all elements in tensor A
# Output: tensor(-2.1540)

print(a[1,2]) # Output of the element in the third column of the second row (zero based)
# Output: tensor(0.5847)

print(a.max()) # Output of the maximum value in tensor A
# Output: tensor(-1.7129)

The following code-block shows an example of the higher level functionality provided nn module. A neural network with linear layers is defined in the example.

import torch
from torch import nn # Import the nn sub-module from PyTorch

class NeuralNetwork(nn.Module): # Neural networks are defined as classes
    def __init__(self): # Layers and variables are defined in the __init__ method
        super(NeuralNetwork, self).__init__() # Must be in every network.
        self.flatten = nn.Flatten() # Defining a flattening layer.
        self.linear_relu_stack = nn.Sequential( # Defining a stack of layers.
            nn.Linear(28*28, 512), # Linear Layers have an input and output shape
            nn.ReLU(), # ReLU is one of many activation functions provided by nn
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10), 
        )

    def forward(self, x): # This function defines the forward pass.
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

See also

• Comparison of deep learning software
• Differentiable programming
• DeepSpeed
• Torch (machine learning)

External links

• Official website