Getting Started with PyTorch in Google Colab (2025 Guide)

Getting Started with PyTorch in Google Colab: A Beginner’s Guide

PyTorch is a powerful deep learning framework designed for Python, offering an intuitive API and strong GPU acceleration. Whether you’re a researcher, a student, or a developer, learning PyTorch can significantly enhance your machine learning skills. Google Colab, a cloud-based Jupyter notebook service, provides an easy way to use PyTorch without worrying about hardware limitations.

This guide will walk you through the essentials of getting started with PyTorch in Google Colab, including setting up a GPU, performing basic tensor operations, and leveraging CUDA for accelerated computing.

What is Google Colab?

Google Colab (Colaboratory) is a free cloud-based Jupyter notebook environment that allows users to write and execute Python code without any setup. It provides free access to powerful hardware, including GPUs and TPUs, making it a popular choice for machine learning projects.

Key Features of Google Colab:

• Free access to GPUs and TPUs
• No installation required; works in a web browser
• Integration with Google Drive for seamless file storage
• Easy collaboration and sharing

What is PyTorch?

PyTorch is an open-source machine learning library developed by Facebook’s AI Research lab (FAIR). It is widely used for applications in deep learning, computer vision, and natural language processing (NLP).

Key Features of PyTorch:

• Dynamic Computation Graphs: Unlike TensorFlow’s static computation graph, PyTorch enables dynamic computation, making debugging and experimentation more intuitive.
• GPU Acceleration: PyTorch seamlessly integrates with CUDA, allowing deep learning models to run efficiently on GPUs.
• Autograd Module: Provides automatic differentiation for neural networks, simplifying backpropagation.
• TorchScript: Enables transitioning from research to production by allowing models to be optimized and deployed efficiently.
• Strong Community and Ecosystem: PyTorch has an active community with extensive resources, making learning and development smoother.

Setting Up PyTorch in Google Colab

Step 1: Open Google Colab

• Go to Google Colab
• Sign in with your Google account
• Create a new notebook via File > New Notebook

You can also create a notebook in Colab via Google Drive

• Go to Google Drive
• Create a folder of any name in the drive to save the project
• Create a new notebook via Right click > More > Colaboratory

To rename the notebook, just click on the file name present at the top of the notebook.

Step 2: Enable GPU Support

By default, Google Colab runs on a CPU. To enable GPU acceleration:

1. Click Runtime in the menu.
2. Select Change runtime type.
3. Choose GPU from the Hardware accelerator dropdown.
4. Click Save.

To verify that the GPU is enabled, run the following command:

import torch
print(torch.cuda.is_available())

If it returns True, your GPU is ready to use!

Google Colab provides up to 12 hours of continuous execution time per session. However, if the session remains idle for more than 60 minutes, it may be disconnected. This means that all data, including Disk, RAM, and CPU cache, will be erased when the session expires.

Understanding PyTorch Tensors

PyTorch uses tensors, which are similar to NumPy arrays but can run on GPUs for faster computations.

Creating Tensors

import torch

# Creating a tensor of ones
x = torch.ones(3, 2)
print(x)

# Creating a random tensor
y = torch.rand(3, 3)
print(y)

Converting Between PyTorch and NumPy

PyTorch tensors can be easily converted to NumPy arrays and vice versa:

import numpy as np

tensor = torch.tensor([1, 2, 3])
numpy_array = tensor.numpy()
print(type(numpy_array))  # Output: <class 'numpy.ndarray'>

# Convert NumPy array to PyTorch tensor
new_tensor = torch.from_numpy(numpy_array)
print(type(new_tensor))  # Output: <class 'torch.Tensor'>

PyTorch to NumPy Bridge

Converting a PyTorch tensor to a NumPy array is useful in various scenarios. This can be done using .numpy() on a PyTorch tensor:

x = torch.linspace(0, 1, steps=5)  # Creating a tensor using linspace
x_np = x.numpy()  # Convert tensor to NumPy
print(type(x), type(x_np))  # Check the types

To convert a NumPy array back to a PyTorch tensor, use .from_numpy():

import numpy as np

a = np.random.randn(5)  # Generate a random NumPy array
a_pt = torch.from_numpy(a)  # Convert NumPy array to a tensor
print(type(a), type(a_pt))

During conversion, PyTorch tensors and NumPy arrays share their underlying memory locations, meaning changes in one will reflect in the other.

More Tensor Operations

Creating Tensors with Specific Values

# Creating a tensor of zeros
x = torch.zeros(3, 2)
print(x)

# Creating a tensor with random values
x = torch.rand(3, 2)
print(x)

# Creating a tensor with values from a normal distribution
x = torch.randn(3, 3)
print(x)

Reproducibility with Random Seeds

To ensure that random values generated by PyTorch remain consistent across runs, you can set a manual seed:

torch.manual_seed(2)
x = torch.rand(3, 2)
print(x)

Performing Basic Tensor Operations

Arithmetic Operations

x = torch.tensor([1, 2, 3])
y = torch.tensor([4, 5, 6])

# Addition
z = x + y
print(z)

# Subtraction
z = x - y
print(z)

Reshaping Tensors

x = torch.tensor([[1, 2], [3, 4], [5, 6]])
reshaped_x = x.view(2, 3)
print(reshaped_x)

Mathematical Operations

# Creating two tensors
x = torch.ones([3, 2])
y = torch.ones([3, 2])

# Adding two tensors
z = x + y  # Method 1
z = torch.add(x, y)  # Method 2

# Subtracting two tensors
z = x - y  # Method 1
z = torch.sub(x, y)  # Method 2

In-Place Operations

PyTorch provides in-place operations that modify tensors directly. These operations have an underscore (_) suffix:

y.add_(x)  # Tensor y is updated with the sum of x and y

Utilizing CUDA for GPU Acceleration

One of the biggest advantages of PyTorch is its support for CUDA, which enables deep learning models to run efficiently on GPUs.

Checking for CUDA Support

print(torch.cuda.is_available())  # Should return True if GPU is enabled

Moving Tensors to GPU

cuda_device = torch.device("cuda")
x = torch.ones(3, 2, device=cuda_device)
y = torch.ones(3, 2, device=cuda_device)
z = x + y
print(z)

Moving Results Back to CPU

z_cpu = z.cpu()
print(z_cpu)

Automatic Differentiation

PyTorch provides an autograd package that allows automatic differentiation, making gradient computation for tensor operations effortless. It follows a define-by-run paradigm, meaning that backpropagation is defined dynamically as the computation graph is built.

Example: Automatic Differentiation

Let’s see how to use PyTorch’s automatic differentiation in practice:

import torch

# Creating a tensor with requires_grad=True to track computations
x = torch.ones(3, 2, requires_grad=True)
print(x)

# Performing a tensor operation
y = x + 5
print(y)  # y has grad_fn since it is derived from x

# Further operations
z = y * y + 1
print(z)

# Summing up all elements
t = torch.sum(z)
print(t)

# Performing backpropagation
t.backward()

# Printing the gradient of x
torch.autograd.grad(t, x)
print(x.grad)

Explanation of Backpropagation

1. Initialization: We create x with requires_grad=True so PyTorch tracks computations.
2. Tensor Operations: y is derived from x, and z is computed using y.
3. Summation: We compute t = torch.sum(z), which is a scalar value.
4. Calling backward(): Computes the gradient of t with respect to x.
5. Checking Gradients: The .grad attribute stores computed gradients.

The gradient values are derived from:

d(t)/dx = 2y at x = 1 and y = 6, giving 12 as the gradient values.

Conclusion

PyTorch is an essential tool for deep learning, and Google Colab makes it incredibly easy to start working with it. In this guide, we covered:

• Setting up PyTorch in Google Colab
• Creating and manipulating tensors
• Performing mathematical operations
• Utilizing CUDA for GPU acceleration
• Understanding automatic differentiation

Now that you have a solid foundation, you can explore more advanced topics like building neural networks, training deep learning models, and working with datasets. Ready to build your first deep learning model? Start coding in Google Colab today!