PyTorch is an open-source machine learning library for Python that is widely used in research and industry. It was developed by Facebook’s AI Research group and provides a flexible and efficient platform for building and training deep neural networks. In this overview, we will cover the basics of PyTorch and provide code examples to demonstrate its capabilities.

## Tensors

Tensors are the basic data structure in PyTorch, similar to NumPy arrays. They are multidimensional arrays that can be used to store and manipulate data for machine learning tasks. Here is an example of creating a tensor in PyTorch:

```
import torch
# Create a tensor of size 2x3 with random values
x = torch.rand(2, 3)
print(x)
```

This will create a tensor with size 2×3 and fill it with random values. We can access individual elements of the tensor using indexing:

```
# Access the element at row 1, column 2
print(x[1, 2])
```

## Autograd

PyTorch’s autograd package provides automatic differentiation for tensors, allowing gradients to be computed automatically for backpropagation. Here is an example of using autograd to compute the gradient of a function:

```
import torch
# Define a function
def f(x):
return x ** 2 + 2 * x + 1
# Create a tensor and set requires_grad=True to track computation with it
x = torch.tensor(2.0, requires_grad=True)
# Compute the function
y = f(x)
# Compute the gradient of y with respect to x
y.backward()
# Print the gradient
print(x.grad)
```

This will compute the gradient of the function `f(x) = x ** 2 + 2 * x + 1`

with respect to x at x=2, using PyTorch’s autograd package. The gradient will be printed as a tensor with value 6.

## Neural Networks

PyTorch provides a simple and flexible API for building and training neural networks. Here is an example of defining a simple neural network using PyTorch:

```
import torch
import torch.nn as nn
# Define a neural network with one hidden layer
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(10, 5)
self.fc2 = nn.Linear(5, 1)
def forward(self, x):
x = torch.relu(self.fc1(x))
x = self.fc2(x)
return x
# Create a random input tensor
x = torch.randn(1, 10)
# Create an instance of the network
net = Net()
# Compute the output of the network
output = net(x)
print(output)
```

This will define a neural network with one hidden layer and print its output for a random input tensor. The network consists of two fully connected layers (`fc1`

and `fc2`

) with ReLU activation in between.