add utilities file

utilities/callbacks.py

@@ -0,0 +1,64 @@
+import pytorch_lightning as pl
+from pytorch_lightning.callbacks import Callback
+
+from .visualize import plot_model_training_curves
+
+
+class TrainingEndCallback(Callback):
+    def on_train_end(self, trainer, pl_module):
+        # Perform actions at the end of the entire training process
+        print("Training, validation, and testing completed!")
+
+        logged_metrics = pl_module.log_store
+
+        plot_model_training_curves(
+            train_accs=logged_metrics["train_acc_epoch"],
+            test_accs=logged_metrics["val_acc_epoch"],
+            train_losses=logged_metrics["train_loss_epoch"],
+            test_losses=logged_metrics["val_loss_epoch"],
+        )
+
+
+class PrintLearningMetricsCallback(Callback):
+    def on_train_epoch_end(
+        self, trainer: pl.Trainer, pl_module: pl.LightningModule
+    ) -> None:
+        super().on_train_epoch_end(trainer, pl_module)
+        print(
+            f"\nEpoch: {trainer.current_epoch}, Train Loss: {trainer.logged_metrics['train_loss_epoch']}, Train Accuracy: {trainer.logged_metrics['train_acc_epoch']}"
+        )
+        pl_module.log_store.get("train_loss_epoch").append(
+            trainer.logged_metrics["train_loss_epoch"].cpu().detach().item()
+        )
+        pl_module.log_store.get("train_acc_epoch").append(
+            trainer.logged_metrics["train_acc_epoch"].cpu().detach().item()
+        )
+
+    def on_validation_epoch_end(
+        self, trainer: pl.Trainer, pl_module: pl.LightningModule
+    ) -> None:
+        super().on_validation_epoch_end(trainer, pl_module)
+        print(
+            f"\nEpoch: {trainer.current_epoch}, Val Loss: {trainer.logged_metrics['val_loss_epoch']}, Val Accuracy: {trainer.logged_metrics['val_acc_epoch']}"
+        )
+        pl_module.log_store.get("val_loss_epoch").append(
+            trainer.logged_metrics["val_loss_epoch"].cpu().detach().item()
+        )
+        pl_module.log_store.get("val_acc_epoch").append(
+            trainer.logged_metrics["val_acc_epoch"].cpu().detach().item()
+        )
+
+
+    def on_test_epoch_end(
+        self, trainer: pl.Trainer, pl_module: pl.LightningModule
+    ) -> None:
+        super().on_test_epoch_end(trainer, pl_module)
+        print(
+            f"\nEpoch: {trainer.current_epoch}, Test Loss: {trainer.logged_metrics['test_loss_epoch']}, Test Accuracy: {trainer.logged_metrics['test_acc_epoch']}"
+        )
+        pl_module.log_store.get("test_loss_epoch").append(
+            trainer.logged_metrics["test_loss_epoch"].cpu().detach().item()
+        )
+        pl_module.log_store.get("test_acc_epoch").append(
+            trainer.logged_metrics["test_acc_epoch"].cpu().detach().item()
+        )

utilities/dataset.py

@@ -0,0 +1,61 @@
+import pytorch_lightning as pl
+from torch.utils.data import DataLoader
+from torchvision.datasets import CIFAR10
+from torchvision import transforms
+import torch
+import numpy as np
+
+
+class CIFAR10(torch.utils.data.Dataset):
+    def __init__(self, dataset, transform=None) -> None:
+        # Initialize dataset and transform
+        self.dataset = dataset
+        self.transform = transform
+
+    def __len__(self) -> int:
+        # Return the length of the dataset
+        return len(self.dataset)
+
+    def __getitem__(self, index):
+        # Get image and label
+        image, label = self.dataset[index]
+
+        # Convert PIL image to numpy array
+        image = np.array(image)
+
+        # Apply transformations
+        if self.transform:
+            image = self.transform(image=image)["image"]
+
+        return (image, label)
+
+class CIFAR10DataModule(pl.LightningDataModule):
+    def __init__(self, train_set_transforms,test_set_transforms, data_dir: str = "./data",batch_size: int = 64, num_workers: int = 4):
+        super().__init__()
+        self.data_dir = data_dir
+        self.batch_size = batch_size
+        self.num_workers = num_workers
+        self.train_set_transforms =train_set_transforms
+        self.test_set_transforms = test_set_transforms
+
+    def prepare_data(self):
+        # Download the CIFAR10 dataset
+        CIFAR10(self.data_dir, train=True, download=True)
+        CIFAR10(self.data_dir, train=False, download=True)
+
+    def setup(self, stage: str = None):
+        # Load the dataset
+        if stage == "fit" or stage is None:
+            self.cifar10_train = CIFAR10(self.data_dir, train=True, transform=self.train_set_transforms)
+            self.cifar10_val = CIFAR10(self.data_dir, train=False, transform=self.train_set_transforms)
+        if stage == "test" or stage is None:
+            self.cifar10_test = CIFAR10(self.data_dir, train=False, transform=self.test_set_transforms)
+
+    def train_dataloader(self):
+        return DataLoader(self.cifar10_train, batch_size=self.batch_size, num_workers=self.num_workers, shuffle=True)
+
+    def val_dataloader(self):
+        return DataLoader(self.cifar10_val, batch_size=self.batch_size, num_workers=self.num_workers)
+
+    def test_dataloader(self):
+        return DataLoader(self.cifar10_test, batch_size=self.batch_size, num_workers=self.num_workers)

utilities/resnet.py

@@ -0,0 +1,162 @@
+"""
+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
+import torch.nn as nn
+import torch.nn.functional as F
+import pytorch_lightning as pl
+from torchmetrics.functional import accuracy
+from torchvision import transforms
+from torch.utils.data import DataLoader
+from torchvision.datasets import CIFAR10
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+
+
+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 LitResNet(pl.LightningModule):
+    def __init__(self, block, num_blocks, num_classes=10,batch_size=128):
+        super(LitResNet, self).__init__()
+        self.batch_size = batch_size
+        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 training_step(self, batch, batch_idx):
+        x, y = batch
+        y_hat = self(x)
+        # Calculate loss
+        loss = F.cross_entropy(y_hat, y)
+        #Calculate accuracy
+        acc = accuracy(y_hat, y)
+        self.log_dict(
+            {"train_loss": loss, "train_acc": acc},
+            on_step=True,
+            on_epoch=True,
+            prog_bar=True,
+            logger=True,
+        )
+        return loss
+    
+    def validation_step(self, batch, batch_idx):
+        x, y = batch
+        y_hat = self(x)
+        loss = F.cross_entropy(y_hat, y)
+        acc = accuracy(y_hat, y)
+        self.log_dict(
+            {"val_loss": loss, "val_acc": acc},
+            on_step=True,
+            on_epoch=True,
+            prog_bar=True,
+            logger=True,
+        )
+        return loss
+
+    def test_step(self, batch, batch_idx):
+        x, y = batch
+        y_hat = self(x)
+
+        argmax_pred = y_hat.argmax(dim=1).cpu()
+        loss = F.cross_entropy(y_hat, y)
+        acc = accuracy(y_hat, y)
+        self.log_dict(
+            {"test_loss": loss, "test_acc": acc},
+            on_step=True,
+            on_epoch=True,
+            prog_bar=True,
+            logger=True,
+        )
+
+        # Update the confusion matrix
+        self.confusion_matrix.update(y_hat, y)
+
+        # Store the predictions, labels and incorrect predictions
+        x, y, y_hat, argmax_pred = (
+            x.cpu(),
+            y.cpu(),
+            y_hat.cpu(),
+            argmax_pred.cpu(),
+        )
+        self.pred_store["test_preds"] = torch.cat(
+            (self.pred_store["test_preds"], argmax_pred), dim=0
+        )
+        self.pred_store["test_labels"] = torch.cat(
+            (self.pred_store["test_labels"], y), dim=0
+        )
+        for d, t, p, o in zip(x, y, argmax_pred, y_hat):
+            if p.eq(t.view_as(p)).item() == False:
+                self.pred_store["test_incorrect"].append(
+                    (d.cpu(), t, p, o[p.item()].cpu())
+                )
+
+        return loss
+
+
+def configure_optimizers(self):
+        return torch.optim.Adam(self.parameters(), lr=0.02)
+
+def LitResNet18():
+    return LitResNet(BasicBlock, [2, 2, 2, 2])
+
+def LitResNet34(): 
+    return LitResNet(BasicBlock, [3, 4, 6, 3])
+
+
+
+

utilities/transforms.py

@@ -0,0 +1,20 @@
+# Third-Party Imports
+import torch
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+
+
+# Train Phase transformations
+train_set_transforms = {
+    'randomcrop': A.RandomCrop(height=32, width=32, p=0.2),
+    'horizontalflip': A.HorizontalFlip(),
+    'cutout': A.CoarseDropout(max_holes=1, max_height=16, max_width=16, min_holes=1, min_height=1, min_width=1, fill_value=[0.49139968*255, 0.48215827*255 ,0.44653124*255], mask_fill_value=None),
+    'normalize': A.Normalize((0.49139968, 0.48215827, 0.44653124), (0.24703233, 0.24348505, 0.26158768)),
+    'standardize': ToTensorV2(),
+}
+
+# Test Phase transformations
+test_set_transforms = {
+    'normalize': A.Normalize((0.49139968, 0.48215827, 0.44653124), (0.24703233, 0.24348505, 0.26158768)),
+    'standardize': ToTensorV2()
+}

utilities/visualise.py

@@ -0,0 +1,412 @@
+import matplotlib.pyplot as plt
+from torchvision import transforms
+import torch
+
+
+def plot_class_label_counts(data_loader, classes):
+    class_counts = {}
+    for class_name in classes:
+        class_counts[class_name] = 0
+    for _, batch_label in data_loader:
+        for label in batch_label:
+            class_counts[classes[label.item()]] += 1
+
+    fig = plt.figure()
+    plt.suptitle("Class Distribution")
+    plt.bar(range(len(class_counts)), list(class_counts.values()))
+    plt.xticks(range(len(class_counts)), list(class_counts.keys()), rotation=90)
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_data_samples(data_loader, classes):
+    batch_data, batch_label = next(iter(data_loader))
+
+    fig = plt.figure()
+    plt.suptitle("Data Samples with Labels post Transforms")
+    for i in range(12):
+        plt.subplot(3, 4, i + 1)
+        plt.tight_layout()
+        # unnormalize = T.Normalize((-mean / std).tolist(), (1.0 / std).tolist())
+        unnormalized = transforms.Normalize(
+            (-1.98947368, -1.98436214, -1.71072797), (4.048583, 4.11522634, 3.83141762)
+        )(batch_data[i])
+        plt.imshow(transforms.ToPILImage()(unnormalized))
+        plt.title(
+            classes[batch_label[i].item()],
+        )
+
+        plt.xticks([])
+        plt.yticks([])
+
+
+def plot_model_training_curves(train_accs, test_accs, train_losses, test_losses):
+    fig, axs = plt.subplots(2, 2, figsize=(15, 10))
+    axs[0, 0].plot(train_losses)
+    axs[0, 0].set_title("Training Loss")
+    axs[1, 0].plot(train_accs)
+    axs[1, 0].set_title("Training Accuracy")
+    axs[0, 1].plot(test_losses)
+    axs[0, 1].set_title("Test Loss")
+    axs[1, 1].plot(test_accs)
+    axs[1, 1].set_title("Test Accuracy")
+    plt.plot()
+
+
+def plot_incorrect_preds(incorrect, classes, num_imgs):
+    # num_imgs is a multiple of 5
+    assert num_imgs % 5 == 0
+    assert len(incorrect) >= num_imgs
+
+    # incorrect (data, target, pred, output)
+    print(f"Total Incorrect Predictions {len(incorrect)}")
+    fig = plt.figure(figsize=(10, num_imgs // 2))
+    plt.suptitle("Target | Predicted Label")
+    for i in range(num_imgs):
+        plt.subplot(num_imgs // 5, 5, i + 1, aspect="auto")
+
+        # unnormalize = T.Normalize((-mean / std).tolist(), (1.0 / std).tolist())
+        unnormalized = transforms.Normalize(
+            (-1.98947368, -1.98436214, -1.71072797), (4.048583, 4.11522634, 3.83141762)
+        )(incorrect[i][0])
+        plt.imshow(transforms.ToPILImage()(unnormalized))
+        plt.title(
+            f"{classes[incorrect[i][1].item()]}|{classes[incorrect[i][2].item()]}",
+            # fontsize=8,
+        )
+        plt.xticks([])
+        plt.yticks([])
+    plt.tight_layout()
+
+
+def display_cifar_data_samples(data_set, number_of_samples: int, classes: list):
+    """
+    Function to display samples for data_set
+    :param data_set: Train or Test data_set transformed to Tensor
+    :param number_of_samples: Number of samples to be displayed
+    :param classes: Name of classes to be displayed
+    """
+    # Get batch from the data_set
+    batch_data = []
+    batch_label = []
+    for count, item in enumerate(data_set):
+        if not count <= number_of_samples:
+            break
+        batch_data.append(item[0])
+        batch_label.append(item[1])
+    batch_data = torch.stack(batch_data, dim=0).numpy()
+
+    # Plot the samples from the batch
+    fig = plt.figure()
+    x_count = 5
+    y_count = 1 if number_of_samples <= 5 else math.floor(number_of_samples / x_count)
+
+    for i in range(number_of_samples):
+        plt.subplot(y_count, x_count, i + 1)
+        plt.tight_layout()
+        plt.imshow(np.transpose(batch_data[i].squeeze(), (1, 2, 0)))
+        plt.title(classes[batch_label[i]])
+        plt.xticks([])
+        plt.yticks([])
+
+
+# ---------------------------- MISCLASSIFIED DATA ----------------------------
+def display_cifar_misclassified_data(data: list,
+                                     classes: list[str],
+                                     inv_normalize: transforms.Normalize,
+                                     number_of_samples: int = 10):
+    """
+    Function to plot images with labels
+    :param data: List[Tuple(image, label)]
+    :param classes: Name of classes in the dataset
+    :param inv_normalize: Mean and Standard deviation values of the dataset
+    :param number_of_samples: Number of images to print
+    """
+    fig = plt.figure(figsize=(10, 10))
+
+    x_count = 5
+    y_count = 1 if number_of_samples <= 5 else math.floor(number_of_samples / x_count)
+
+    for i in range(number_of_samples):
+        plt.subplot(y_count, x_count, i + 1)
+        img = data[i][0].squeeze().to('cpu')
+        img = inv_normalize(img)
+        plt.imshow(np.transpose(img, (1, 2, 0)))
+        plt.title(r"Correct: " + classes[data[i][1].item()] + '\n' + 'Output: ' + classes[data[i][2].item()])
+        plt.xticks([])
+        plt.yticks([])
+
+
+def display_mnist_misclassified_data(data: list,
+                                     number_of_samples: int = 10):
+    """
+    Function to plot images with labels
+    :param data: List[Tuple(image, label)]
+    :param number_of_samples: Number of images to print
+    """
+    fig = plt.figure(figsize=(8, 5))
+
+    x_count = 5
+    y_count = 1 if number_of_samples <= 5 else math.floor(number_of_samples / x_count)
+
+    for i in range(number_of_samples):
+        plt.subplot(y_count, x_count, i + 1)
+        img = data[i][0].squeeze(0).to('cpu')
+        plt.imshow(np.transpose(img, (1, 2, 0)), cmap='gray')
+        plt.title(r"Correct: " + str(data[i][1].item()) + '\n' + 'Output: ' + str(data[i][2].item()))
+        plt.xticks([])
+        plt.yticks([])
+
+
+# ---------------------------- AUGMENTATION SAMPLES ----------------------------
+def visualize_cifar_augmentation(data_set, data_transforms):
+    """
+    Function to visualize the augmented data
+    :param data_set: Dataset without transformations
+    :param data_transforms: Dictionary of transforms
+    """
+    sample, label = data_set[6]
+    total_augmentations = len(data_transforms)
+
+    fig = plt.figure(figsize=(10, 5))
+    for count, (key, trans) in enumerate(data_transforms.items()):
+        if count == total_augmentations - 1:
+            break
+        plt.subplot(math.ceil(total_augmentations / 5), 5, count + 1)
+        augmented = trans(image=sample)['image']
+        plt.imshow(augmented)
+        plt.title(key)
+        plt.xticks([])
+        plt.yticks([])
+
+
+def visualize_mnist_augmentation(data_set, data_transforms):
+    """
+    Function to visualize the augmented data
+    :param data_set: Dataset to visualize the augmentations
+    :param data_transforms: Dictionary of transforms
+    """
+    sample, label = data_set[6]
+    total_augmentations = len(data_transforms)
+
+    fig = plt.figure(figsize=(10, 5))
+    for count, (key, trans) in enumerate(data_transforms.items()):
+        if count == total_augmentations - 1:
+            break
+        plt.subplot(math.ceil(total_augmentations / 5), 5, count + 1)
+        img = trans(sample).to('cpu')
+        plt.imshow(np.transpose(img, (1, 2, 0)), cmap='gray')
+        plt.title(key)
+        plt.xticks([])
+        plt.yticks([])
+
+
+# ---------------------------- LOSS AND ACCURACIES ----------------------------
+def display_loss_and_accuracies(train_losses: list,
+                                train_acc: list,
+                                test_losses: list,
+                                test_acc: list,
+                                plot_size: tuple = (10, 10)) -> NoReturn:
+    """
+    Function to display training and test information(losses and accuracies)
+    :param train_losses: List containing training loss of each epoch
+    :param train_acc: List containing training accuracy of each epoch
+    :param test_losses: List containing test loss of each epoch
+    :param test_acc: List containing test accuracy of each epoch
+    :param plot_size: Size of the plot
+    """
+    # Create a plot of 2x2 of size
+    fig, axs = plt.subplots(2, 2, figsize=plot_size)
+
+    # Plot the training loss and accuracy for each epoch
+    axs[0, 0].plot(train_losses)
+    axs[0, 0].set_title("Training Loss")
+    axs[1, 0].plot(train_acc)
+    axs[1, 0].set_title("Training Accuracy")
+
+    # Plot the test loss and accuracy for each epoch
+    axs[0, 1].plot(test_losses)
+    axs[0, 1].set_title("Test Loss")
+    axs[1, 1].plot(test_acc)
+    axs[1, 1].set_title("Test Accuracy")
+
+
+# ---------------------------- Feature Maps and Kernels ----------------------------
+
+@dataclass
+class ConvLayerInfo:
+    """
+    Data Class to store Conv layer's information
+    """
+    layer_number: int
+    weights: torch.nn.parameter.Parameter
+    layer_info: torch.nn.modules.conv.Conv2d
+
+
+class FeatureMapVisualizer:
+    """
+    Class to visualize Feature Map of the Layers
+    """
+
+    def __init__(self, model):
+        """
+        Contructor
+        :param model: Model Architecture
+        """
+        self.conv_layers = []
+        self.outputs = []
+        self.layerwise_kernels = None
+
+        # Disect the model
+        counter = 0
+        model_children = model.children()
+        for children in model_children:
+            if type(children) == nn.Sequential:
+                for child in children:
+                    if type(child) == nn.Conv2d:
+                        counter += 1
+                        self.conv_layers.append(ConvLayerInfo(layer_number=counter,
+                                                              weights=child.weight,
+                                                              layer_info=child)
+                                                )
+
+    def get_model_weights(self):
+        """
+        Method to get the model weights
+        """
+        model_weights = [layer.weights for layer in self.conv_layers]
+        return model_weights
+
+    def get_conv_layers(self):
+        """
+        Get the convolution layers
+        """
+        conv_layers = [layer.layer_info for layer in self.conv_layers]
+        return conv_layers
+
+    def get_total_conv_layers(self) -> int:
+        """
+        Get total number of convolution layers
+        """
+        out = self.get_conv_layers()
+        return len(out)
+
+    def feature_maps_of_all_kernels(self, image: torch.Tensor) -> dict:
+        """
+        Get feature maps from all the kernels of all the layers
+        :param image: Image to be passed to the network
+        """
+        image = image.unsqueeze(0)
+        image = image.to('cpu')
+
+        outputs = {}
+
+        layers = self.get_conv_layers()
+        for index, layer in enumerate(layers):
+            image = layer(image)
+            outputs[str(layer)] = image
+        self.outputs = outputs
+        return outputs
+
+    def visualize_feature_map_of_kernel(self, image: torch.Tensor, kernel_number: int) -> None:
+        """
+        Function to visualize feature map of kernel number from each layer
+        :param image: Image passed to the network
+        :param kernel_number: Number of kernel in each layer (Should be less than or equal to the minimum number of kernel in the network)
+        """
+        # List to store processed feature maps
+        processed = []
+
+        # Get feature maps from all kernels of all the conv layers
+        outputs = self.feature_maps_of_all_kernels(image)
+
+        # Extract the n_th kernel's output from each layer and convert it to grayscale
+        for feature_map in outputs.values():
+            try:
+                feature_map = feature_map[0][kernel_number]
+            except IndexError:
+                print("Filter number should be less than the minimum number of channels in a network")
+                break
+            finally:
+                gray_scale = feature_map / feature_map.shape[0]
+                processed.append(gray_scale.data.numpy())
+
+        # Plot the Feature maps with layer and kernel number
+        x_range = len(outputs) // 5 + 4
+        fig = plt.figure(figsize=(10, 10))
+        for i in range(len(processed)):
+            a = fig.add_subplot(x_range, 5, i + 1)
+            imgplot = plt.imshow(processed[i])
+            a.axis("off")
+            title = f"{list(outputs.keys())[i].split('(')[0]}_l{i + 1}_k{kernel_number}"
+            a.set_title(title, fontsize=10)
+
+    def get_max_kernel_number(self):
+        """
+        Function to get maximum number of kernels in the network (for a layer)
+        """
+        layers = self.get_conv_layers()
+        channels = [layer.out_channels for layer in layers]
+        self.layerwise_kernels = channels
+        return max(channels)
+
+    def visualize_kernels_from_layer(self, layer_number: int):
+        """
+        Visualize Kernels from a layer
+        :param layer_number: Number of layer from which kernels are to be visualized
+        """
+        # Get the kernels number for each layer
+        self.get_max_kernel_number()
+
+        # Zero Indexing
+        layer_number = layer_number - 1
+        _kernels = self.layerwise_kernels[layer_number]
+
+        grid = math.ceil(math.sqrt(_kernels))
+
+        plt.figure(figsize=(5, 4))
+        model_weights = self.get_model_weights()
+        _layer_weights = model_weights[layer_number].cpu()
+        for i, filter in enumerate(_layer_weights):
+            plt.subplot(grid, grid, i + 1)
+            plt.imshow(filter[0, :, :].detach(), cmap='gray')
+            plt.axis('off')
+        plt.show()
+
+
+# ---------------------------- Confusion Matrix ----------------------------
+def visualize_confusion_matrix(classes: list[str], device: str, model: 'DL Model',
+                               test_loader: torch.utils.data.DataLoader):
+    """
+    Function to generate and visualize confusion matrix
+    :param classes: List of class names
+    :param device: cuda/cpu
+    :param model: Model Architecture
+    :param test_loader: DataLoader for test set
+    """
+    nb_classes = len(classes)
+    device = 'cuda'
+    cm = torch.zeros(nb_classes, nb_classes)
+
+    model.eval()
+    with torch.no_grad():
+        for inputs, labels in test_loader:
+            inputs = inputs.to(device)
+            labels = labels.to(device)
+            model = model.to(device)
+
+            preds = model(inputs)
+            preds = preds.argmax(dim=1)
+
+        for t, p in zip(labels.view(-1), preds.view(-1)):
+            cm[t, p] = cm[t, p] + 1
+
+    # Build confusion matrix
+    labels = labels.to('cpu')
+    preds = preds.to('cpu')
+    cf_matrix = confusion_matrix(labels, preds)
+    df_cm = pd.DataFrame(cf_matrix / np.sum(cf_matrix, axis=1)[:, None],
+                         index=[i for i in classes],
+                         columns=[i for i in classes])
+    plt.figure(figsize=(12, 7))
+    sn.heatmap(df_cm, annot=True)