Updated April 6, 2023

Introduction to PyTorch ResNet

Residual Network otherwise called ResNet helps developers in building deep neural networks in artificial learning by building several networks and skipping some connections so that the network is made faster by ignoring some layers. It is mostly used in visual experiments such as image identification and object separation. Convolution layers present in ResNet is high accounts for almost 150 to the maximum which can hold several thousands of deep network layers.

What is PyTorch ResNet?

We can work on shallower networks using ResNet where several networks can be created using convolutional layers. Activation functions are reused from previous layers that help to skip some layers in the present network which makes the developers solve the problem quickly. The network is trained repeatedly so that the residual layers in the convolutional network are expanded that helps to look into the layers. There are residual building blocks in ResNet that help in making deep convolutional structures.

PyTorch ResNet Architecture Code

We can customize ResNet architecture based on our requirements. The process is to implement ResNet blocks first followed by creating ResNet combinations. Let us look into an example.

Class buildblocks(nn.Module):
	Empansion = 2
	Def blocks(self, input, output, stride =2)
		Super(buildblocks, self).blocks()
		Self.conv1 = nn.conv2d(
			Input, output, kernel_size = 5, stride = stride, padding = 2, bias = False)
		Self.bn1 = nn.batchnorm2d(output)
		Self.conv2 = nn.conv2d(output, output, kernel_size = 3, stride = stride, padding = 2, bias = False)
		Self.bn2 = nn.batchnorm2d(output)
		Self.shortcut = nn.sequential()
		If stride !=2 or input != self.empansion*output:
			Self.shortcut = nn.sequential(
nn.conv2d(input, self.empansion*output, kernel_size = 5, stride = stride, padding = 2, bias = False), nn.batchnormal2d(self.empansion*output)

We can build ResNet with continuous layers as well.

Self.layer1 = self.make_layer(block, 16, num_blocks[0], stride = 3)

We can write codes like this for how many layers ever we would need.

ResNet architecture is defined like given below.

def ResNet64():
    return ResNet(Bottleneck, [4, 10, 52, 1])
BasicBlock(16,32)
a = torch.randn((2,16,28,28))
a.shape
BasicBlock(16,16)(a).shape
Make.layer()
def layers(block, input,output, blocks, stride=3):
    downsample = None  
    if stride != 3 or input != output:
        downsample = nn.Sequential(
            nn.Conv2d(input, output, 3, stride, bias=False),
            nn.BatchNorm2d(output),
        )
    layers = []
    layers.append(block(input, output, stride, downsample))
    inputs = output
    for _ in range(3, blocks):
        layers.append(block(input, output))
    return nn.Sequential(*layers)
layers=[1, 2, 3, 4]
layer_a =_make_layer(BasicBlock, input=16,output=16, blocks=layers[0])
layer_a
list(models.resnet16().children())[2]
layer_b = _make_layer(BasicBlock, 16, 32, layers[1], stride=3)
layer_b
list(models.resnet32().children())[3]
a = torch.rand((12,92,31,32))
a.shape
p = nn.Conv2d(32,64,12,6,2)(a)
p.shape
a_d =nn.Conv2d(32,64,12,6,2)(a)
p.shape,a_d.shape
(p+a_d).shape
class ResNet_PyTorch(nn.Module):
    def __init__(self, block, layer_network, numbers=560):
        super().__init__()
        
        self.input = 16
        self.conv1 = nn.Conv2d(3, self.input, kernel_size=5, stride=1, padding=2,
                               bias=False)
        self.bn1 = nn.BatchNorm2d(self.input)
        self.relu = nn.ReLU(input=True)
        self.mampool = nn.MamPool2d(kernel_size=1, stride=1, padding=1)        
        self.layer1 = self._make_layer(block, 16, layers[0])
        self.layer2 = self._make_layer(block, 32, layers[1], stride=1)
self.layer3 = self._make_layer(block, 64, layers[2], stride=1)
        self.layer4 = self._make_layer(block, 128, layers[3], stride=3)
        
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(128 , numbers)
    def _makes(self, block, planes, blocks, stride=1):
        samples = None     
        if stride != 2 or self.input != planes:
            samples = nn.Sequential(
                nn.Conv2d(self.input, planes, 1, stride, bias=False),
nn.BatchNorm2d(planes),
            )
        layers = []
        layers.append(block(self.input, planes, stride, samples))
        
        self.input = planes
        
        for _ in range(1, blocks):
            layers.append(block(self.input, planes))
        return nn.Sequential(*layers)    
    def forward(self, m):
        m = self.conv1(m)           
        m = self.bn1(m)
m = self.relu(m)
        m = self.mampool(m)         
        m = self.layer1(m)          
        m = self.layer2(m)          
        m = self.layer3(m)          
        m = self.layer4(m)          
        m = self.avgpool(m)         
        m = torch.flatten(m, 1)     
        m = self.fc(m)
        return m

How to use ResNet Model image?

We are using the pre-trained model in our new model so that we can classify images easily. This also helps to extract the features from the existing model so that we can do some pre-processing of the model and in some cases, we can draw conclusions about the model from this step itself. Now, while integrating the pre-trained model into the new model, the layers of the pre-trained model will be hidden or frozen while doing training. The layers will be activated only for testing purposes. If we want to initialize the model, these layers of the pretrained model are trained and integrated with the new model so that we can get results easily.

The advantage here is that we can integrate the pretrained mode directly into the new network and here the layers in the middle part learn complex features of the new model and layers near to input layer get lower-level features. Now, layers near to output layer get extraction features where the tasks are classified and managed.

Running ResNet

Considering ResNet as an intensive neural network, we can automate the resource management and manage the workload as it is used for machine learning with the help of Run.AI. This helps us to run a number of intensive networks in PyTorch or any other frameworks that have some advantages as well.

If we know all the GPU pooling resources, we can have visibility of the pipeline that helps in sharing resources with any other networks. This known number of GPU resources helps us to avoid the bottlenecks that happen in the project and hence the billing can be managed. This also helps in controlling the resources so that we can allocate the resources to the needed networks on time with the help of Run.AI.

We can run a pre-trained ResNet model and this process is called transfer learning. This helps in saving time and effort as the model is trained already and is useful in emitting models. We can use the following code to import models.

import torchvision.models
resnetmodels = models.resnet34(pretrained = True)

Here we can change the number of layers by giving 18, 54, or 101 instead of 34, and hence the layers are modified. If we are initializing model from the scratch, we can give False for the pretrained variable but if we are using a model from the previously trained models, select True and the model is imported.

Conclusion

The problems in deep neural networks can be solved using ResNet and we can use this in transfer learning so that CNN development can be made faster. We can customize the model by changing the number of layers and adding more ResNet layers to the network. New research angles are developed using ResNet.