Upload 27 files

'created app'

README.md

@@ -1,13 +0,0 @@
----
-title: S12
-emoji: 🐠
-colorFrom: gray
-colorTo: red
-sdk: gradio
-sdk_version: 3.39.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,156 @@
+import numpy as np
+import gradio as gr
+from PIL import Image
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.image import show_cam_on_image
+import torch
+from torchvision import transforms 
+from model import CustomResNet
+from utils.utils import wrong_predictions
+from utils.dataloader import get_dataloader
+import random 
+from collections import OrderedDict
+import os
+
+test_o = get_dataloader()
+# test_o=next(iter(test_o))   
+
+
+examples_dir = os.path.join(os.getcwd(), 'examples')
+examples = [[os.path.join(examples_dir, img), 0.5] for img in os.listdir(examples_dir)]
+
+
+model = CustomResNet()
+model.load_state_dict(torch.load('modelp.ckpt')['state_dict'])#, strict = False)
+model = model.cpu()
+
+classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
+norm_mean=(0.4914, 0.4822, 0.4465) 
+norm_std=(0.2023, 0.1994, 0.2010)
+misclassified_images, all_predictions = wrong_predictions(model,test_o, norm_mean, norm_std, classes, 'cpu')
+
+layers = ['layer_1', 'layer_3']
+# layers = [model.layer_1, model.layer_2, model.layer_3]
+def inference(input_img, transparency, layer_num, top_classes):
+    input_img_ori = input_img.copy()
+    transform = transforms.ToTensor()
+    # transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize(
+    #     mean=[0.485,0.456,0.406],
+    #     std=[0.229, 0.224, 0.255]
+    # )])
+    inv_normalize = transforms.Normalize(
+        mean=[-0.485/0.229, -0.456/0.224, -0.406/0.255],
+        std=[1/0.229, 1/0.224, 1/0.255]
+    )
+    input_img = transform(input_img)
+    # input_img = input_img.to(device)
+    input_img = input_img.unsqueeze(0)
+    outputs = model(input_img)
+    _, prediction = torch.max(outputs, 1)
+    softmax = torch.nn.Softmax(dim=0)
+    outputs = softmax(outputs.flatten())
+    # print(outputs)
+    confidences = {classes[i]: float(outputs[i]) for i in range(10)}
+    confidences = OrderedDict(sorted(confidences.items(), key=lambda x:x[1], reverse=True))
+    # print(confidences)
+    filtered_confidences ={}# OrderedDict()
+    for i, (key, val) in enumerate(confidences.items()):
+        if i ==  top_classes:
+            break
+        filtered_confidences[key] = val
+
+
+    if layer_num == 1:
+        target_layers = [model.layer_1]
+    elif layer_num == 2:
+        target_layers = [model.layer_2]
+    else:
+        target_layers = [model.layer_3]
+    cam = GradCAM(model=model, target_layers=target_layers, use_cuda=False)
+    grayscale_cam = cam(input_tensor=input_img, targets=None)
+    grayscale_cam = grayscale_cam[0, :]
+    img = input_img.squeeze(0)
+    img = inv_normalize(img)
+    rgb_img = np.transpose(img, (1, 2, 0))
+    rgb_img = np.array(np.clip(rgb_img,0,1), np.float32)
+    visualization = show_cam_on_image(rgb_img, grayscale_cam, use_rgb=True, image_weight=transparency)
+
+    # visualization = input_img_ori
+    return filtered_confidences, visualization
+    # return filtered_confidences, superimposed_img
+
+def get_misclassified_images(num):
+    outputimgs = []
+    # misclassified_images = wrong_predictions(model,test_o, norm_mean, norm_std, classes, 'cpu')
+    for i in range(int(num)):
+        # misclassified_images[0][0].cpu().numpy()
+        inv_normalize = transforms.Normalize(
+            mean=[-0.485/0.229, -0.456/0.224, -0.406/0.255],
+            std=[1/0.229, 1/0.224, 1/0.255]
+        )
+        inv_tensor = np.array(inv_normalize(misclassified_images[random.randint(2,98)][0]).cpu().permute(1,2,0)*255, dtype='uint8')
+        outputimgs.append(inv_tensor)
+    return outputimgs
+
+
+def get_gradcam_images(num, transparency, layer_num):
+    outcoms=[]
+    for i in range(int(num)):
+        input_img = all_predictions[random.randint(2,98)][0]
+        inv_normalize = transforms.Normalize(
+            mean=[-0.485/0.229, -0.456/0.224, -0.406/0.255],
+            std=[1/0.229, 1/0.224, 1/0.255]
+        )
+        input_img = input_img.unsqueeze(0)
+        if layer_num == 1:
+            target_layers = [model.layer_1]
+        elif layer_num == 2:
+            target_layers = [model.layer_2]
+        else:
+            target_layers = [model.layer_3]
+
+        cam = GradCAM(model=model, target_layers=target_layers, use_cuda=False)
+        grayscale_cam = cam(input_tensor=input_img, targets=None)
+        grayscale_cam = grayscale_cam[0, :]
+        img = input_img.squeeze(0)
+        img = inv_normalize(img)
+        rgb_img = np.transpose(img, (1, 2, 0))
+        rgb_img = np.array(np.clip(rgb_img,0,1), np.float32)
+        visualization = show_cam_on_image(rgb_img, grayscale_cam, use_rgb=True, image_weight=transparency)
+        outcoms.append(visualization)
+    return outcoms
+
+# demo = gr.Interface(inference, [gr.Image(shape=(32, 32)), gr.Slider(0, 1)], ["text", gr.Image(shape=(32, 32)).style(width=128, height=128)])
+inference_new_image = gr.Interface(
+    inference, 
+    inputs = [gr.Image(shape=(32, 32), label="Input Image"), gr.Slider(0, 1, value = 0.3, label="transparency?"), gr.Slider(1, 3, value = 1,step=1, label="layer?"),
+              gr.Slider(1, 10, value = 3, step=1, label="top classes?")], 
+    
+    outputs = [gr.Label(),gr.Image(shape=(32, 32), label="Model Prediction").style(width=300, height=300)],
+    title = 'gradio app',
+    description = 'for dl purposes',
+    examples = examples,
+)
+
+misclassified_interface = gr.Interface(
+    get_misclassified_images, 
+    inputs = [gr.Number(value=10, label="images number")], 
+    
+    outputs = [gr.Gallery(label="misclassified images")],
+    title = 'gradio app',
+    description = 'for dl purposes'
+)
+
+gradcam_images = gr.Interface(
+    get_gradcam_images, 
+    inputs = [gr.Number(value=10, label="images number"), gr.Slider(0, 1, value = 0.3, label="transparency?"), gr.Slider(1, 3, value = 1,step=1, label="layer?")], 
+    
+    outputs = [gr.Gallery(label="gradcam images")],
+    title = 'gradio app',
+    description = 'for dl purposes'
+)
+
+
+demo = gr.TabbedInterface([inference_new_image, misclassified_interface, gradcam_images], tab_names=["Input image", "Misclassified Images", "grad cam images"], 
+                          title="customresnet gradcam")
+demo.launch()

model.py

@@ -0,0 +1,272 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+import os
+
+from pytorch_lightning import LightningModule
+from torch.utils.data import DataLoader, random_split
+from torchmetrics import Accuracy
+from torchvision import transforms
+from torchvision.datasets import CIFAR10
+
+# from utils.dataloader import get_dataloader
+from utils.dataset import get_dataset
+
+import matplotlib.pyplot as plt
+
+PATH_DATASETS = os.environ.get("PATH_DATASETS", ".")
+AVAIL_GPUS = min(1, torch.cuda.device_count())
+BATCH_SIZE = 512 if AVAIL_GPUS else 64
+
+
+# transforms with albumentations 
+# find_lr coupled with one_cycle lr
+
+
+class BasicBlock(LightningModule):
+
+    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()
+
+    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 CustomBlock(LightningModule):
+    def __init__(self, in_channels, out_channels):
+        super(CustomBlock, self).__init__()
+
+        self.inner_layer = nn.Sequential(
+            nn.Conv2d(
+                in_channels=in_channels,
+                out_channels=out_channels,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+                bias=False,
+            ),
+            nn.MaxPool2d(kernel_size=2),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(),
+        )
+
+        self.res_block = BasicBlock(out_channels, out_channels)
+
+    def forward(self, x):
+        x = self.inner_layer(x)
+        r = self.res_block(x)
+
+        out = x + r
+
+        return out
+
+
+class CustomResNet(LightningModule):
+    def __init__(self, num_classes=10,data_dir=PATH_DATASETS, hidden_size=16, lr=2e-4):
+        super(CustomResNet, self).__init__()
+
+        self.data_dir = data_dir
+        self.hidden_size = hidden_size
+        self.learning_rate = lr
+
+        self.train_losses = []
+        self.test_losses = []
+        self.train_acc = []
+        self.test_acc = []
+
+        self.lr_change = []
+        # self.outputs=[]
+        self.train_step_losses = []
+        self.train_step_acc = []
+
+        self.val_step_losses = []
+        self.val_step_acc = []
+
+        test_incorrect_pred = {'images': [], 'ground_truths': [], 'predicted_vals': []}
+
+        self.accuracy = Accuracy(task='multiclass',num_classes=num_classes)
+
+        self.transform = transforms.Compose(
+            [
+                transforms.ToTensor(),
+                transforms.Normalize((0.1307,), (0.3081,)),
+            ]
+        )
+
+        self.prep_layer = nn.Sequential(
+            nn.Conv2d(
+                in_channels=3,
+                out_channels=64,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+                bias=False,
+            ),
+            nn.BatchNorm2d(64),
+            nn.ReLU(),
+        )
+
+        self.layer_1 = CustomBlock(in_channels=64, out_channels=128)
+
+        self.layer_2 = nn.Sequential(
+            nn.Conv2d(
+                in_channels=128,
+                out_channels=256,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+                bias=False,
+            ),
+            nn.MaxPool2d(kernel_size=2),
+            nn.BatchNorm2d(256),
+            nn.ReLU(),
+        )
+
+        self.layer_3 = CustomBlock(in_channels=256, out_channels=512)
+
+        self.max_pool = nn.Sequential(nn.MaxPool2d(kernel_size=4))
+
+        self.fc = nn.Linear(512, num_classes)
+
+    def forward(self, x):
+        x = self.prep_layer(x)
+        x = self.layer_1(x)
+        x = self.layer_2(x)
+        x = self.layer_3(x)
+        x = self.max_pool(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+        return x
+    
+    def training_step(self, batch, batch_idx):
+        x, y = batch
+        logits = self(x)
+        loss = F.cross_entropy(logits, y)
+        preds = torch.argmax(logits, dim=1)
+        acc = (preds == y).cpu().float().mean()
+
+        # Calling self.log will surface up scalars for you in TensorBoard
+        self.log("train_loss", loss, prog_bar=True)
+        self.log("train_acc", acc, prog_bar=True)
+        self.train_step_acc.append(acc)
+        self.train_step_losses.append(loss.cpu().item())
+        
+        return {'loss':loss, 'train_acc': acc}
+
+    def on_train_epoch_end(self):
+        # batch_losses = [x["train_loss"] for x in outputs] #This part
+        epoch_loss = sum(self.train_step_losses)/len(self.train_step_losses)
+        # batch_accs =  [x["train_acc"] for x in outputs]   #This part
+        epoch_acc = sum(self.train_step_acc)/len(self.train_step_acc)
+        self.log("train_loss_epoch", epoch_loss, prog_bar=True)
+        self.log("train_acc_epoch", epoch_acc, prog_bar=True)
+        self.train_acc.append(epoch_acc)
+        self.train_losses.append(epoch_loss)
+        self.lr_change.append(self.scheduler.get_last_lr()[0])
+        self.train_step_losses.clear()
+        self.train_step_acc.clear()
+        return epoch_acc
+        
+    def validation_step(self, batch, batch_idx):
+        x, y = batch
+        logits = self(x)
+        loss = F.cross_entropy(logits, y)
+        preds = torch.argmax(logits, dim=1)
+        acc = (preds == y).cpu().float().mean()
+
+        # Calling self.log will surface up scalars for you in TensorBoard
+        self.log("val_loss", loss, prog_bar=True)
+        self.log("val_acc", acc, prog_bar=True)
+        self.val_step_acc.append(acc)
+        self.val_step_losses.append(loss.cpu().item())
+        return {'val_loss':loss, 'val_acc': acc}
+
+    def on_validation_epoch_end(self):
+        # batch_losses = [x["val_loss"] for x in outputs] #This part
+        epoch_loss = sum(self.val_step_losses)/len(self.val_step_losses)
+        # batch_accs =  [x["val_acc"] for x in outputs]   #This part
+        epoch_acc = sum(self.val_step_acc)/len(self.val_step_acc)
+        self.log("val_loss_epoch", epoch_loss, prog_bar=True)
+        self.log("val_acc_epoch", epoch_acc, prog_bar=True)
+        self.test_acc.append(epoch_acc)
+        self.test_losses.append(epoch_loss)
+        self.val_step_losses.clear()
+        self.val_step_acc.clear()
+        return epoch_acc
+
+    def test_step(self, batch, batch_idx):
+        # Here we just reuse the validation_step for testing
+        return self.validation_step(batch, batch_idx)
+
+    def configure_optimizers(self):
+        self.optimizer = torch.optim.SGD(self.parameters(), lr=self.learning_rate, momentum=0.9, weight_decay=5e-4)
+
+        self.scheduler=torch.optim.lr_scheduler.OneCycleLR(self.optimizer,max_lr=self.learning_rate,epochs=30,steps_per_epoch=len(self.cifar_full)//BATCH_SIZE)
+        lr_scheduler = {'scheduler': self.scheduler, 'interval': 'step'}
+        return {'optimizer': self.optimizer, 'lr_scheduler': lr_scheduler}
+
+    ####################
+    # DATA RELATED HOOKS
+    ####################
+
+    def prepare_data(self):
+        # download
+        CIFAR10(self.data_dir, train=True, download=True)
+        CIFAR10(self.data_dir, train=False, download=True)
+
+    def setup(self, stage=None):
+
+        # Assign train/val datasets for use in dataloaders
+        if stage == "fit" or stage is None:
+            # cifar_full = CIFAR10(self.data_dir, train=True, transform=self.transform)
+            self.cifar_full = get_dataset()[0]
+            self.cifar_train, self.cifar_val = random_split(self.cifar_full, [45000, 5000])
+
+        # Assign test dataset for use in dataloader(s)
+        if stage == "test" or stage is None:
+            # self.cifar_test = CIFAR10(self.data_dir, train=False, transform=self.transform)
+            self.cifar_test = get_dataset()[1]
+
+    def train_dataloader(self):
+        cifar_full = get_dataset()[0]
+        return DataLoader(cifar_full, batch_size=BATCH_SIZE, num_workers=os.cpu_count())
+        # return get_dataloader()[0]
+
+
+    def val_dataloader(self):
+        return DataLoader(self.cifar_val, batch_size=BATCH_SIZE, num_workers=os.cpu_count())
+        # return get_dataloader()[1]
+
+    def test_dataloader(self):
+        return DataLoader(self.cifar_test, batch_size=BATCH_SIZE, num_workers=os.cpu_count())
+        # return get_dataloader()[1]
+
+    def draw_graphs(self):
+        fig, axs = plt.subplots(2,2,figsize=(15,10))
+        axs[0, 0].plot(self.train_losses)
+        axs[0, 0].set_title("Training Loss")
+        axs[1, 0].plot(self.train_acc)
+        axs[1, 0].set_title("Training Accuracy")
+        axs[0, 1].plot(self.test_losses)
+        axs[0, 1].set_title("Test Loss")
+        axs[1, 1].plot(self.test_acc)
+        axs[1, 1].set_title("Test Accuracy")
+
+    def draw_graphs_lr(self):
+        # fig, axs = plt.subplots(1,1,figsize=(15,10))
+        plt.plot(self.lr_change)

modelp.ckpt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:362e063f506824562fe59f8732ac5ae0db714cff4829400c05718fbac0f68b3e
+size 52634750

requirements.txt

@@ -0,0 +1,6 @@
+torch
+torchvision
+torch-lr-finder
+grad-cam
+pillow
+numpy

utils/dataloader.py

@@ -0,0 +1,13 @@
+import torch
+from utils.dataset import get_dataset
+
+batch_size = 10
+
+kwargs = {'batch_size': batch_size, 'shuffle': True, 'num_workers': 2, 'pin_memory': True}
+
+def get_dataloader():
+    test_data = get_dataset()
+    test_loader = torch.utils.data.DataLoader(test_data, **kwargs)
+    # train_loader = torch.utils.data.DataLoader(train_data, **kwargs)
+
+    return test_loader

utils/dataset.py

@@ -0,0 +1,26 @@
+import torch
+from torchvision import datasets, transforms
+
+from .transforms import test_transforms, train_transforms
+
+
+class Cifar10SearchDataset(datasets.CIFAR10):
+    def __init__(self, root="~/data/cifar10", train=True, download=True, transform=None):
+        super().__init__(root=root, train=train, download=download, transform=transform)
+
+    def __getitem__(self, index):
+        image, label = self.data[index], self.targets[index]
+
+        if self.transform is not None:
+            transformed = self.transform(image=image)
+            image = transformed["image"]
+
+        return image, label
+
+def get_dataset():
+    # train_data = Cifar10SearchDataset(
+    #     root='./data/cifar10', train=True, download=True, transform=train_transforms)
+    test_data = Cifar10SearchDataset(
+        root='./data/cifar10', train=False, download=True, transform=test_transforms)
+
+    return test_data

utils/find_LR.py

@@ -0,0 +1,13 @@
+from torch_lr_finder import LRFinder
+
+def find_lr(model,optimizer, criterion, device,train_loader):
+    lr_finder = LRFinder(model, optimizer, criterion, device=device)
+    lr_finder.range_test(
+        train_loader,
+        step_mode="exp",
+        end_lr=10,
+        num_iter=200,
+    )
+    mx_lr = lr_finder.plot(suggest_lr=True, skip_start=0, skip_end=0)
+    lr_finder.reset()
+    return mx_lr

utils/gradcam.py

@@ -0,0 +1,175 @@
+from torch.nn import functional as F
+import cv2
+import torch
+import matplotlib.pyplot as plt
+import numpy as np
+
+def denormalize(img):
+  mean = (0.49139968, 0.48215841, 0.44653091)
+  std = (0.24703223, 0.24348513, 0.26158784)
+  img = img.cpu().numpy().astype(dtype=np.float32)
+  
+  for i in range(img.shape[0]):
+    img[i] = (img[i]*std[i])+mean[i]
+  
+  return np.transpose(img, (1,2,0))
+
+class GradCAM:
+    """ Class for extracting activations and 
+    registering gradients from targetted intermediate layers 
+    target_layers = list of convolution layer index as shown in summary
+    """
+    def __init__(self, model, candidate_layers=None):
+        def save_fmaps(key):
+          def forward_hook(module, input, output):
+              self.fmap_pool[key] = output.detach()
+
+          return forward_hook
+
+        def save_grads(key):
+          def backward_hook(module, grad_in, grad_out):
+              self.grad_pool[key] = grad_out[0].detach()
+
+          return backward_hook
+
+        self.device = next(model.parameters()).device
+        self.model = model
+        self.handlers = []  # a set of hook function handlers
+        self.fmap_pool = {}
+        self.grad_pool = {}
+        self.candidate_layers = candidate_layers  # list
+
+        for name, module in self.model.named_modules():
+            if self.candidate_layers is None or name in self.candidate_layers:
+                self.handlers.append(module.register_forward_hook(save_fmaps(name)))
+                self.handlers.append(module.register_backward_hook(save_grads(name)))
+
+    def _encode_one_hot(self, ids):
+        one_hot = torch.zeros_like(self.nll).to(self.device)
+        print(one_hot.shape)
+        one_hot.scatter_(1, ids, 1.0)
+        return one_hot
+
+    def forward(self, image):
+        self.image_shape = image.shape[2:] # HxW
+        self.nll = self.model(image)
+        #self.probs = F.softmax(self.logits, dim=1)
+        return self.nll.sort(dim=1, descending=True)  # ordered results
+
+    def backward(self, ids):
+        """
+        Class-specific backpropagation
+        """
+        one_hot = self._encode_one_hot(ids)
+        self.model.zero_grad()
+        self.nll.backward(gradient=one_hot, retain_graph=True)
+
+    def remove_hook(self):
+        """
+        Remove all the forward/backward hook functions
+        """
+        for handle in self.handlers:
+            handle.remove()
+
+    def _find(self, pool, target_layer):
+        if target_layer in pool.keys():
+            return pool[target_layer]
+        else:
+            raise ValueError("Invalid layer name: {}".format(target_layer))
+
+    def generate(self, target_layer):
+        fmaps = self._find(self.fmap_pool, target_layer)
+        grads = self._find(self.grad_pool, target_layer)
+        weights = F.adaptive_avg_pool2d(grads, 1)
+
+        gcam = torch.mul(fmaps, weights).sum(dim=1, keepdim=True)
+        gcam = F.relu(gcam)
+        # need to capture image size duign forward pass
+        gcam = F.interpolate(
+            gcam, self.image_shape, mode="bilinear", align_corners=False
+        )
+
+        # scale output between 0,1
+        B, C, H, W = gcam.shape
+        gcam = gcam.view(B, -1)
+        gcam -= gcam.min(dim=1, keepdim=True)[0]
+        gcam /= gcam.max(dim=1, keepdim=True)[0]
+        gcam = gcam.view(B, C, H, W)
+
+        return gcam
+
+def generate_gradcam(misclassified_images, model, target_layers,device):
+    images=[]
+    labels=[]
+    for i, (img, pred, correct) in enumerate(misclassified_images):
+        images.append(img)
+        labels.append(correct)
+    
+    model.eval()
+    
+    # map input to device
+    images = torch.stack(images).to(device)
+    
+    # set up grad cam
+    gcam = GradCAM(model, target_layers)
+    
+    # forward pass
+    probs, ids = gcam.forward(images)
+    
+    # outputs agaist which to compute gradients
+    ids_ = torch.LongTensor(labels).view(len(images),-1).to(device)
+    
+    # backward pass
+    gcam.backward(ids=ids_)
+    layers = []
+    for i in range(len(target_layers)):
+        target_layer = target_layers[i]
+        print("Generating Grad-CAM @{}".format(target_layer))
+        # Grad-CAM
+        layers.append(gcam.generate(target_layer=target_layer))
+        
+    # remove hooks when done
+    gcam.remove_hook()
+    return layers, probs, ids
+
+def plot_gradcam_images(gcam_layers, target_layers, classes, image_size,predicted, misclassified_images):
+    
+    images=[]
+    labels=[]
+    for i, (img, pred, correct) in enumerate(misclassified_images):
+      images.append(img)
+      labels.append(correct)
+
+    c = len(images)+1
+    r = len(target_layers)+2
+    fig = plt.figure(figsize=(60,30))
+    fig.subplots_adjust(hspace=0.01, wspace=0.01)
+    ax = plt.subplot(r, c, 1)
+    ax.text(0.3,-0.5, "INPUT", fontsize=28)
+    plt.axis('off')
+    for i in range(len(target_layers)):
+      target_layer = target_layers[i]
+      ax = plt.subplot(r, c, c*(i+1)+1)
+      ax.text(0.3,-0.5, target_layer, fontsize=28)
+      plt.axis('off')
+
+      for j in range(len(images)):
+        img = np.uint8(255 * denormalize(images[j].view(image_size)))
+        if i==0:
+          ax = plt.subplot(r, c, j+2)
+          ax.text(0, 0.2, f"actual: {classes[labels[j]]} \npred: {classes[predicted[j][0]]}", fontsize=18)
+          plt.axis('off')
+          plt.subplot(r, c, c+j+2)
+          plt.imshow(img)
+          plt.axis('off')
+          
+        
+        heatmap = 1-gcam_layers[i][j].cpu().numpy()[0] # reverse the color map
+        heatmap = np.uint8(255 * heatmap)
+        heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+        superimposed_img = cv2.resize(cv2.addWeighted(img, 0.5, heatmap, 0.5, 0), (128,128))
+        plt.subplot(r, c, (i+2)*c+j+2)
+        plt.imshow(superimposed_img, interpolation='bilinear')
+        
+        plt.axis('off')
+    plt.show()

utils/one_cycle_lr.py

@@ -0,0 +1,14 @@
+import torch.optim as optim
+
+
+def get_onecycle_scheduler(optimizer,mx_lr,train_loader,num_epochs):
+    return optim.lr_scheduler.OneCycleLR(
+    optimizer,
+    max_lr=mx_lr,
+    epochs=num_epochs,
+    steps_per_epoch=len(train_loader),
+    pct_start=5/num_epochs,
+    div_factor=100,
+    three_phase=False,
+    final_div_factor=100,
+    anneal_strategy='linear')

utils/transforms.py

@@ -0,0 +1,43 @@
+import cv2
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+# import torchvision.transforms as transforms
+
+norm_mean=(0.4914, 0.4822, 0.4465) 
+norm_std=(0.2023, 0.1994, 0.2010)
+
+train_transforms = A.Compose(
+    [
+    A.Sequential([
+        A.PadIfNeeded(
+            min_height=40,
+            min_width=40,
+            border_mode=cv2.BORDER_CONSTANT,
+            value=(norm_mean[0]*255, norm_mean[1]*255, norm_mean[2]*255)
+        ),
+        A.RandomCrop(
+            height=32,
+            width=32
+        )
+    ], p=1),
+    A.CoarseDropout(
+            max_holes=2,
+            max_height=16,
+            max_width=16,
+            min_holes=1,
+            min_height=8,
+            min_width=8,
+            fill_value=tuple((x * 255.0 for x in norm_mean)),
+            p=0.8,
+        ),
+    A.Normalize(norm_mean, norm_std),
+    ToTensorV2()
+]
+)
+
+test_transforms = A.Compose(
+    [
+    A.Normalize(norm_mean, norm_std, always_apply=True),
+    ToTensorV2()
+]
+)

utils/utils.py

@@ -0,0 +1,125 @@
+import torch
+# import torch.nn as nn
+import torch.nn.functional as F
+# import torch.optim as optim
+import numpy as np
+
+# from tqdm import tqdm
+
+import matplotlib.pyplot as plt
+
+
+def return_dataset_images(train_loader, total_images):
+    batch_data, batch_label = next(iter(train_loader)) 
+
+    fig = plt.figure()
+
+    for i in range(total_images):
+        plt.subplot(3,4,i+1)
+        plt.tight_layout()
+        # plt.imshow(batch_data[i].squeeze(0), cmap='gray')
+        plt.imshow(batch_data[i].permute(1,2,0), cmap='gray')
+        plt.title(batch_label[i].item())
+        plt.xticks([])
+        plt.yticks([])
+
+def GetCorrectPredCount(pPrediction, pLabels):
+    return pPrediction.argmax(dim=1).eq(pLabels).sum().item()
+
+
+def get_incorrrect_predictions(model, loader, device):
+    """Get all incorrect predictions
+    Args:
+        model (Net): Trained model
+        loader (DataLoader): instance of data loader
+        device (str): Which device to use cuda/cpu
+    Returns:
+        list: list of all incorrect predictions and their corresponding details
+    """
+    model.eval()
+    incorrect = []
+    with torch.no_grad():
+        for data, target in loader:
+            data, target = data.to(device), target.to(device)
+            output = model(data)
+            loss = F.nll_loss(output, target)
+            pred = output.argmax(dim=1)
+            for d, t, p, o in zip(data, target, pred, output):
+                if p.eq(t.view_as(p)).item() == False:
+                    incorrect.append(
+                        [d.cpu(), t.cpu(), p.cpu(), o[p.item()].cpu()])
+
+    return incorrect
+
+def plot_incorrect_predictions(predictions, class_map, count=10):
+    """Plot Incorrect predictions
+    Args:
+        predictions (list): List of all incorrect predictions
+        class_map (dict): Lable mapping
+        count (int, optional): Number of samples to print, multiple of 5. Defaults to 10.
+    """
+    print(f'Total Incorrect Predictions {len(predictions)}')
+
+    if not count % 5 == 0:
+        print("Count should be multiple of 10")
+        return
+
+    classes = list(class_map.values())
+
+    fig = plt.figure(figsize=(10, 5))
+    for i, (d, t, p, o) in enumerate(predictions):
+        ax = fig.add_subplot(int(count/5), 5, i + 1, xticks=[], yticks=[])
+        ax.set_title(f'{classes[t.item()]}/{classes[p.item()]}')
+        plt.imshow(d.cpu().numpy().transpose(1, 2, 0))
+        if i+1 == 5*(count/5):
+            break
+
+def wrong_predictions(model,test_loader, norm_mean, norm_std, classes, device):
+    wrong_images=[]
+    wrong_label=[]
+    correct_label=[]
+
+    correct_images=[]
+    correct_images_labels=[]
+
+    model.eval()
+    with torch.no_grad():
+        for data, target in test_loader:
+            data, target = data.to(device), target.to(device)
+            output = model(data)
+            pred = output.argmax(dim=1, keepdim=True).squeeze()  # get the index of the max log-probability
+
+            wrong_pred = (pred.eq(target.view_as(pred)) == False)
+            wrong_images.append(data[wrong_pred])
+            wrong_label.append(pred[wrong_pred])
+            correct_label.append(target.view_as(pred)[wrong_pred])  
+
+            # wrong_pred = (pred.eq(target.view_as(pred)) == False)
+            correct_images.append(data)
+            correct_images_labels.append(pred)
+
+            wrong_predictions = list(zip(torch.cat(wrong_images),torch.cat(wrong_label),torch.cat(correct_label)))
+            all_predictions = list(zip(torch.cat(correct_images),torch.cat(correct_images_labels),torch.cat(correct_images_labels)))
+            if len(wrong_predictions)>100:
+                break
+        print(f'Total wrong predictions are {len(wrong_predictions)}')
+
+        # plot_misclassified(wrong_predictions, norm_mean, norm_std, classes)
+
+    return wrong_predictions, all_predictions
+    
+def plot_misclassified(wrong_predictions, norm_mean, norm_std, classes):
+    fig = plt.figure(figsize=(10,12))
+    fig.tight_layout()
+    for i, (img, pred, correct) in enumerate(wrong_predictions[:20]):
+        img, pred, target = img.cpu().numpy().astype(dtype=np.float32), pred.cpu(), correct.cpu()
+        for j in range(img.shape[0]):
+            img[j] = (img[j]*norm_std[j])+norm_mean[j]
+
+        img = np.transpose(img, (1, 2, 0)) #/ 2 + 0.5
+        ax = fig.add_subplot(5, 5, i+1)
+        ax.axis('off')
+        ax.set_title(f'\nactual : {classes[target.item()]}\npredicted : {classes[pred.item()]}',fontsize=10)
+        ax.imshow(img)
+
+    plt.show()