Exploring Deep Learning with PyTorch: Lecture 2 on Automatic Differentiation using torch.autograd and backward

In Lecture 2 of Dive Into Deep Learning, we will be focusing on PyTorch’s automatic differentiation capabilities using the torch.autograd module. PyTorch provides automatic differentiation for all operations on Tensors, which allows us to easily compute gradients of our loss function with respect to our model parameters. This is essential for optimizing our models using techniques like stochastic gradient descent.

Let’s start by importing the necessary libraries:

import torch

Next, let’s create a simple example to demonstrate automatic differentiation in PyTorch. We will define a simple linear regression model and compute the gradients of the loss function with respect to the model parameters.

# Define the input data and the true weights
x = torch.tensor([1.0, 2.0, 3.0, 4.0])
y = torch.tensor([2.0, 4.0, 6.0, 8.0])
w = torch.tensor([0.0], requires_grad=True)

# Define the linear regression model
def linear_model(x, w):
    return x * w

# Define the loss function (mean squared error)
def loss_function(y_pred, y):
    return torch.mean((y_pred - y)**2)

# Run the model
y_pred = linear_model(x, w)
loss = loss_function(y_pred, y)

print(f'Initial loss: {loss.item()}')

Next, we will compute the gradients of the loss function with respect to the model parameters using PyTorch’s automatic differentiation capabilities. We can do this by calling the backward() method on the loss tensor.

loss.backward()

After calling backward(), the gradients of the loss function with respect to the model parameters are stored in the grad attribute of each parameter tensor. We can access these gradients using the grad attribute.

print(f'Gradient of the loss with respect to w: {w.grad.item()}')

Finally, we can update the model parameters using gradient descent. We can do this by manually updating the values of the model parameters based on the gradients and the learning rate.

learning_rate = 0.01
with torch.no_grad():
    w -= learning_rate * w.grad

# Reset the gradients
w.grad.zero_()

# Compute the new loss
y_pred = linear_model(x, w)
loss = loss_function(y_pred, y)

print(f'Updated loss: {loss.item()}')

This is a simple example, but it demonstrates the power of PyTorch’s automatic differentiation capabilities. With automatic differentiation, we can easily compute gradients of our loss function with respect to our model parameters, allowing us to optimize our models using techniques like stochastic gradient descent.

In summary, PyTorch’s torch.autograd module provides automatic differentiation capabilities that allow us to easily compute gradients of our loss function with respect to our model parameters. By utilizing automatic differentiation in PyTorch, we can efficiently optimize our models using techniques like stochastic gradient descent. Try experimenting with different models and loss functions to further explore PyTorch’s automatic differentiation capabilities.