Software:PyTorch

PyTorch

Original author(s)	Adam Paszke Sam Gross Soumith Chintala Gregory Chanan
Developer(s)	Meta AI
Initial release	September 2016 (2016-09)
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 an open-source machine learning library based on the Torch library, used for applications such as computer vision, deep learning research and natural language processing, originally developed by Meta AI and now part of the Linux Foundation umbrella. It is one of the most popular deep learning frameworks, alongside others such as TensorFlow, offering 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.

PyTorch utilises tensors as a intrinsic datatype, very similar to NumPy. Model training is handled by an automatic differentiation system, Autograd, which constructs a directed acyclic graph of a forward pass of a model for a given input, for which automatic differentiation utilising the chain rule, computes model-wide gradients. PyTorch is capable of transparent leveraging of SIMD units, such as GPGPUs.

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

History

In 2001, Torch was written and released under a GPL license. It was a machine-learning library written in C++ and CUDA, supporting methods including neural networks, support vector machines (SVM), hidden Markov models, etc. It was improved to Torch7 in 2012. Development on Torch ceased in 2018 and was subsumed by the PyTorch project.

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 the independent PyTorch Foundation, a newly created subsidiary of the Linux Foundation.

PyTorch 2.0 was released on 15 March 2023, introducing TorchDynamo, a Python-level compiler that makes code run up to 2x faster, along with significant improvements in training and inference performance across major cloud platforms.

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 by 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 superficially related to its original meaning as a certain kind of object in linear algebra. Tensors in PyTorch are simply multi-dimensional arrays.

PyTorch neural networks

PyTorch defines a module called nn (torch.nn) to describe neural networks and to support training. This module offers a comprehensive collection of building blocks for neural networks, including various layers and activation functions, enabling the construction of complex models. Networks are built by inheriting from the torch.nn module and defining the sequence of operations in the forward() function.

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")  # Execute all calculations on the CPU
# device = torch.device("cuda:0")  # Executes all calculations on the GPU

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

b = torch.randn(2, 3, device=device, dtype=dtype)
print(b)
# Output: tensor([[ 0.7178, -0.8453, -1.3403],
#                  [ 1.3262,  1.1512, -1.7070]])

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

print(a.sum()) 
# 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: tensor(0.8498)

The following code-block defines a neural network with linear layers using the nn module.

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().__init__()  # Must be in every network.
        self.flatten = nn.Flatten()   # Construct a flattening layer.
        self.linear_relu_stack = nn.Sequential(  # Construct 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
• PyTorch Lightning

External links

• Official website