Upload 4 files

datasets.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""
+Module containing wrapper classes for PyTorch Datasets
+Author: Shilpaj Bhalerao
+Date: Jun 25, 2023
+"""
+# Standard Library Imports
+from typing import Tuple
+
+# Third-Party Imports
+from torchvision import datasets, transforms
+
+
+class AlbumDataset(datasets.CIFAR10):
+    """
+    Wrapper class to use albumentations library with PyTorch Dataset
+    """
+    def __init__(self, root: str = "./data", train: bool = True, download: bool = True, transform: list = None):
+        """
+        Constructor
+        :param root: Directory at which data is stored
+        :param train: Param to distinguish if data is training or test
+        :param download: Param to download the dataset from source
+        :param transform: List of transformation to be performed on the dataset
+        """
+        super().__init__(root=root, train=train, download=download, transform=transform)
+
+    def __getitem__(self, index: int) -> Tuple:
+        """
+        Method to return image and its label
+        :param index: Index of image and label in the dataset
+        """
+        image, label = self.data[index], self.targets[index]
+
+        if self.transform:
+            transformed = self.transform(image=image)
+            image = transformed["image"]
+        return image, label

resnet.py

@@ -0,0 +1,76 @@
+"""
+ResNet in PyTorch.
+For Pre-activation ResNet, see 'preact_resnet.py'.
+
+Reference:
+[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
+    Deep Residual Learning for Image Recognition. arXiv:1512.03385
+"""
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+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
+
+
+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
+
+
+def ResNet18():
+    return ResNet(BasicBlock, [2, 2, 2, 2])
+
+
+def ResNet34():
+    return ResNet(BasicBlock, [3, 4, 6, 3])