Deep Learning PyTorch Course, What is Colab

In this lecture, we will take a detailed look at Google Colab, a tool that is essential for learning deep learning. Using Colab along with one of the deep learning libraries, PyTorch, allows for easy training and experimentation of machine learning and deep learning models. In this text, we will present an overview of Colab’s features, benefits, and an example of building a simple deep learning model with PyTorch in Python.

1. What is Google Colab?

Google Colaboratory, commonly referred to as Colab, is a free Jupyter notebook environment that supports machine learning, data analysis, and education using Python. Colab is integrated with Google Drive, enabling users to easily store and share their data.

1.1 Key Features

Support for GPU and TPU: Free NVIDIA GPU and TPU are provided to speed up the training of complex deep learning models.
Google Drive Integration: Users can easily manage and share their data and results.
Data Visualization Tools: Supports various visualization libraries such as Matplotlib and Seaborn for smooth data analysis.
Easy Library Installation: You can easily install libraries like TensorFlow and PyTorch as needed.

1.2 Benefits of Colab

There are various benefits to using Colab. First, users can perform complex tasks without consuming local computer resources as they work in a cloud environment. This is particularly advantageous for large-scale deep learning projects that require GPU. Furthermore, it allows users to visually confirm the results along with the code execution, making it useful for research and educational purposes.

2. What is PyTorch?

PyTorch is an open-source machine learning library primarily used for deep learning, implemented in Python and C++. PyTorch has the property of dynamic computational graphs, making it particularly suitable for research and prototyping. Additionally, it is highly compatible with Python, making the process of writing and debugging code easier.

2.1 Installation Method

PyTorch can be easily used in Colab. You can install the essential libraries related to PyTorch by running the cell below.

!pip install torch torchvision

3. A Simple Deep Learning Model Using PyTorch

Now, let’s implement a simple neural network model using PyTorch in Google Colab. In this example, we will create a digit recognizer using the MNIST dataset.

3.1 Preparing the Dataset

First, we prepare the MNIST dataset. MNIST consists of digit images of 28×28 pixels and is commonly used as a benchmark dataset to evaluate the performance of deep learning models.

import torch
import torchvision
import torchvision.transforms as transforms

# Define data transformations
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])

# Download training set and test set
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)

3.2 Designing the Neural Network

We will define the neural network architecture as follows. Here we will use a simple model consisting of an input layer, two hidden layers, and an output layer.

import torch.nn as nn
import torch.optim as optim

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(28 * 28, 128)  # Input layer (784 nodes) -> First hidden layer (128 nodes)
        self.fc2 = nn.Linear(128, 64)        # First hidden layer -> Second hidden layer (64 nodes)
        self.fc3 = nn.Linear(64, 10)         # Second hidden layer -> Output layer (10 nodes)

    def forward(self, x):
        x = x.view(-1, 28 * 28)  # Convert each image to a 1D vector
        x = torch.relu(self.fc1(x))  # First hidden layer
        x = torch.relu(self.fc2(x))  # Second hidden layer
        x = self.fc3(x)  # Output layer
        return x

model = SimpleNN()

3.3 Defining the Loss Function and Optimization Algorithm

We will use CrossEntropyLoss as the loss function and Adam Optimizer to train the model.

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

3.4 Training the Model

The next step is the process of training the model. We will update the model weights and reduce the loss over several epochs.

for epoch in range(5):  # Train for 5 epochs
    running_loss = 0.0
    for inputs, labels in trainloader:
        optimizer.zero_grad()  # Reset gradients
        outputs = model(inputs)  # Generate outputs by putting inputs into the model
        loss = criterion(outputs, labels)  # Calculate loss
        loss.backward()  # Backpropagation
        optimizer.step()  # Optimization
        running_loss += loss.item()  # Accumulate loss
        
    print(f'Epoch {epoch + 1}, Loss: {running_loss / len(trainloader)}')  # Output average loss

3.5 Evaluating the Model

Finally, we will evaluate the model’s performance using the test set. We will calculate the accuracy while passing through the prepared test dataset.

correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in testloader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)  # Select the class with the highest probability
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy: {100 * correct / total}%')  # Output accuracy

4. Conclusion

In this post, we explored the features and benefits of Google Colab, as well as how to build a simple deep learning model using PyTorch. Google Colab offers many advantages to data scientists and researchers, enabling them to perform deep learning in a highly useful environment alongside PyTorch. We will return with a variety of advanced topics in the future!