Implementing ResNet from Scratch using PyTorch

ResNet (or Residual Network) is a deep neural network architecture that was introduced by Kaiming He et al. in their paper "Deep Residual Learning for Image Recognition." ResNet is known for its ability to train very deep networks more effectively by utilizing skip connections or shortcuts, which help in bypassing the vanishing gradient problem.

In this tutorial, we will implement a ResNet architecture using the PyTorch deep learning library from scratch. This tutorial assumes that you have some basic knowledge of deep learning concepts and are familiar with PyTorch.

1. Import necessary libraries:
   First, we need to import the necessary libraries for our implementation. We will be using the torch and torch.nn libraries, which provide the tools for building and training deep neural networks.

import torch
import torch.nn as nn
import torch.nn.functional as F

1. Define the basic building blocks:
   We will start by defining the basic building blocks of a ResNet architecture, which include the convolutional layer, batch normalization, and the residual block.

class BasicBlock(nn.Module):
    expansion = 1

    def __init__(self, in_planes, planes, stride=1):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)

        self.shortcut = nn.Sequential()
        if stride != 1 or in_planes != self.expansion*planes:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(self.expansion*planes)
            )

    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += self.shortcut(x)
        out = F.relu(out)
        return out

In the BasicBlock class, we define the convolutional layers with batch normalization and the residual connections with skip connections. The expansion factor is set to 1 for the basic block. The forward method specifies how the input is passed through the block.

1. Define the full ResNet architecture:
   Next, we will define the full ResNet architecture by stacking multiple BasicBlocks together. We will create different versions of ResNet, such as ResNet18, ResNet34, ResNet50, ResNet101, and ResNet152, based on the number of layers.

class ResNet(nn.Module):

    def __init__(self, block, num_blocks, num_classes=10):
        super(ResNet, self).__init__()
        self.in_planes = 64

        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
        self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
        self.linear = nn.Linear(512*block.expansion, num_classes)

    def _make_layer(self, block, planes, num_blocks, stride):
        strides = [stride] + [1]*(num_blocks-1)
        layers = []
        for stride in strides:
            layers.append(block(self.in_planes, planes, stride))
            self.in_planes = planes * block.expansion
        return nn.Sequential(*layers)

    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.layer1(out)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.layer4(out)
        out = F.avg_pool2d(out, 4)
        out = out.view(out.size(0), -1)
        out = self.linear(out)
        return out

In the ResNet class, we define the full ResNet architecture by stacking multiple BasicBlocks together in the _make_layer method. The forward method specifies how the input is passed through the layers.

1. Create an instance of the ResNet model:
   Now, we can create an instance of the ResNet model with the desired parameters. For example, to create a ResNet18 model, we can use the following code:

def ResNet18():
    return ResNet(BasicBlock, [2,2,2,2])

This code creates a ResNet18 model with 2 basic blocks per layer, resulting in a total of 18 layers.

1. Train and test the ResNet model:
   Finally, we can train and test the ResNet model on a dataset. We can use the CIFAR-10 dataset as an example. Below is the code to train and test the model on the CIFAR-10 dataset:

import torchvision
import torchvision.transforms as transforms

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,
                                          shuffle=True, num_workers=2)

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

model = ResNet18()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

for epoch in range(10):  # loop over the dataset multiple times

    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data

        optimizer.zero_grad()

        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 100 == 99:    # print every 100 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 100))
            running_loss = 0.0

print('Finished Training')

correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (
    100 * correct / total))

In this code snippet, we load the CIFAR-10 dataset, create an instance of the ResNet18 model, define the loss function and optimizer, and train the model for 10 epochs. We then test the model on the test set and report the accuracy.

And that’s it! You have now successfully implemented a ResNet architecture using PyTorch from scratch. You can further customize the model by adding more layers or experimenting with different hyperparameters. Happy coding!