Upload 18 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+deer.jpg filter=lfs diff=lfs merge=lfs -text
+ship.jpg filter=lfs diff=lfs merge=lfs -text

Custom_Resnet_v1.py

@@ -0,0 +1,72 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class ConvBNBlock(nn.Module):
+    def __init__(self, in_planes, planes, stride=1, p=0.0):
+        super(ConvBNBlock, self).__init__()
+        self.dropout_prob = p
+        self.conv_bn_block = nn.Sequential(
+            nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False),
+            nn.BatchNorm2d(planes)
+        )
+        self.drop_out = nn.Dropout2d(p=self.dropout_prob)
+
+    def forward(self, x):
+        out =F.relu(self.drop_out(self.conv_bn_block(x)) )
+        return out
+
+class TransitionBlock(nn.Module):
+    def __init__(self, in_planes, planes, stride=1, p=0.0):
+        super(TransitionBlock, self).__init__()
+        self.p = p
+        self.transition_block = nn.Sequential(
+            nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False),
+            nn.BatchNorm2d(planes),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout2d(p=self.p)
+        )
+
+    def forward(self, x):
+        x = self.transition_block(x)
+        return x
+
+class ResBlock(nn.Module):
+    def __init__(self, in_planes, planes, stride=1, p=0.0):
+        super(ResBlock, self).__init__()
+        self.p = p
+        self.transition_block = TransitionBlock(in_planes, planes, stride, p)
+        self.conv_block1 = ConvBNBlock(planes, planes, stride, p)
+        self.conv_block2 = ConvBNBlock(planes, planes, stride, p)
+       
+
+    def forward(self, x):
+        x = self.transition_block(x)
+        r = self.conv_block2(self.conv_block1(x))
+        out = x + r
+        return out
+
+class CustomResNet(nn.Module):
+    def __init__(self, p=0.0, num_classes=10):
+        super(CustomResNet, self).__init__()
+        self.in_planes = 64
+        self.p = p
+
+        self.conv = ConvBNBlock(3, 64, 1, p)
+        self.layer1 = ResBlock(64, 128, 1, p)
+        self.layer2 = TransitionBlock(128, 256, 1, p)
+        self.layer3 = ResBlock(256, 512, 1, p)
+        self.max_pool = nn.MaxPool2d(4, 4)
+        self.linear = nn.Linear(512, num_classes)
+
+    def forward(self, x):
+        out = self.conv(x)
+        out = self.layer1(out)
+        out = self.layer2(out)
+        out = self.layer3(out)
+        out = self.max_pool(out)
+        out = out.view(out.size(0), -1)
+        out = self.linear(out)
+        return F.log_softmax(out, dim=1)

README.MD

@@ -0,0 +1,38 @@
+
+# CIFAR10 Trained on Custom ResNet Model with GradCAM
+
+This is a simple Gradio interface that allows you to perform inference on a CIFAR10 dataset trained on a Custom ResNet model and visualize the GradCAM results. GradCAM (Gradient-weighted Class Activation Mapping) is a technique that highlights the regions in an image that are important for the model's prediction.
+
+## How to Use the Interface
+
+1. Upload an image by clicking on the "Choose File" button. The image should have dimensions of 32x32 pixels.
+
+2. **Show GradCAM Images**: Select this checkbox to visualize the GradCAM results on the uploaded image. GradCAM highlights the regions of the image that are important for the model's prediction.
+
+3. **Number of GradCAM Images**: Enter the number of GradCAM images you want to visualize. This option is only effective when "Show GradCAM Images" is selected.
+
+4. **Which Layer?**: Use the slider to choose the layer from which GradCAM will be computed. You can select from layers -3, -2, or -1. This option is only effective when "Show GradCAM Images" is selected.
+
+5. **Opacity of GradCAM**: Use the slider to adjust the opacity of the GradCAM overlay on the image. This option is only effective when "Show GradCAM Images" is selected.
+
+6. **Show Misclassified Images**: Select this checkbox to visualize a gallery of misclassified images. These images are randomly chosen from a folder of misclassified images.
+
+7. **Number of Misclassified Images (max 10)**: Enter the number of misclassified images you want to visualize. This option is only effective when "Show Misclassified Images" is selected.
+
+8. **Number of Top Classes (max 10)**: Enter the number of top classes to display along with their confidence scores.
+
+9. Click the "Submit" button to perform inference and visualize the results.
+
+## Output
+
+1. **Top Classes**: The interface will display the top classes along with their confidence scores for the uploaded image.
+
+2. **Output Image**: The interface will show the GradCAM result overlayed on the uploaded image. This image highlights the important regions that the model used for its prediction. If "Show GradCAM Images" is not selected, the original uploaded image will be shown.
+
+3. **Misclassified Images**: If "Show Misclassified Images" is selected, the interface will display a gallery of misclassified images. These images are randomly chosen from a folder of misclassified images.
+
+## Examples
+
+The interface provides some example images along with pre-selected settings. Feel free to modify the settings or upload your own images to visualize the GradCAM results on different images.
+
+Please note that the provided model is pre-trained and loaded from a checkpoint file. You can adjust the model and GradCAM settings in the code to experiment with different configurations.

app.py

@@ -0,0 +1,90 @@
+import torch, torchvision
+from torchvision import transforms
+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
+from custom_resnet import  Assignment12Resnet
+import random
+import os
+pl_model = Assignment12Resnet().load_from_checkpoint("epoch=22-step=4140.ckpt",map_location=torch.device("cpu"))
+
+inv_normalize = transforms.Normalize(
+    mean=[-0.50/0.23, -0.50/0.23, -0.50/0.23],
+    std=[1/0.23, 1/0.23, 1/0.23]
+)
+classes = ('plane', 'car', 'bird', 'cat', 'deer',
+           'dog', 'frog', 'horse', 'ship', 'truck')
+model = pl_model.model
+model_dict = dict(zip([-3,-2,-1],[pl_model.model.layer3.transition_block.transition_block,pl_model.model.layer3.conv_block1.conv_bn_block,pl_model.model.layer3.conv_block2.conv_bn_block]))
+# Function to load images from a folder
+def load_images_from_folder(num_misclassified,folder=None):
+    print(type(num_misclassified))
+    images = []
+    for filename in os.listdir(folder):
+        if filename.endswith(".jpg") or filename.endswith(".png"):
+            img = Image.open(os.path.join(folder, filename))
+            images.append(img)
+    return random.choices(images, k=int(num_misclassified))
+def inference(input_img, show_gradcam = True ,num_gradcam_images=1, target_layer_number =-1,opacity= 0.5,show_misclassified = True,num_misclassified_images =10,num_top_classes=3):
+    #transform = pl_model.test_transform()
+    org_img = input_img
+    input_img = pl_model.test_transform(input_img)
+    input_img = input_img.unsqueeze(0)
+    model.eval()
+    outputs = model(input_img)
+    softmax = torch.nn.Softmax(dim=0)
+    o = softmax(outputs.flatten())
+    confidences = {classes[i]: float(o[i]) for i in range(10)}
+    _, prediction = torch.max(outputs, 1)
+    if show_gradcam:
+      target_layers = model_dict[target_layer_number]
+      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 = rgb_img.numpy()
+      visualization = show_cam_on_image(org_img/255, grayscale_cam, use_rgb=True, image_weight=opacity)
+    else:
+      visualization = org_img
+
+    misclassified_images = None
+    if show_misclassified:
+      misclassified_images = load_images_from_folder(num_misclassified_images,folder = './misclassified_images')
+  
+    return confidences, visualization, misclassified_images
+
+title = "CIFAR10 trained on Custom ResNet Model with GradCAM"
+description = "A simple Gradio interface to infer on Custom ResNet model and get GradCAM results"
+examples = [["cat.jpg",True,1,-2, 0.5, True,5,3], ["dog.jpg",True,1,-2, 0.5, True,5,3 ],["bird.jpg",True,1,-2, 0.5, True,5,3],["ship.jpg",True,1,-2, 0.5, True,5,3],["truck.jpg",True,1,-2, 0.5, True,5,3],["deer.jpg",True,1,-2, 0.5, True,5,3],["frog.jpg",True,1,-2, 0.5, True,5,3],["horse.jpg",True,1,-2, 0.5, True,5,3],["plane.jpg",True,1,-2, 0.5, True,5,3]]
+
+demo = gr.Interface(inference,inputs=[ gr.Image(shape=(32, 32)),
+                                      gr.Checkbox(value=True,label="Show GradCAM Images",show_label=True),
+                                      gr.Number(value=1, label="Number of GradCAM Images", minimum=1, maximum=1),
+                                      gr.Slider(minimum = -3,maximum=-1, value=-1, step=1, label="Which Layer?"),
+                                      gr.Slider(minimum =0, maximum = 1.0, value=0.5, label="Opacity of GradCAM"),
+                                      gr.Checkbox(label="Show Misclassified Images", value=True,show_label=True),
+                                      gr.Number(value=5, label="Number of Misclassified Images (max 10)", minimum=1, maximum=10),
+                                      gr.Number(value=3, label="Number of Top Classes (max 10)", minimum=1, maximum=10)
+                                    ],
+    outputs=[
+        gr.Label(num_top_classes=3),
+        gr.Image(shape=(32, 32), label="Output").style(width=128, height=128),
+        gr.Gallery(label="Misclassified Images")
+    ],
+    title=title,
+    description=description,
+    examples=examples,
+)
+
+# Launch the Gradio interface
+demo.launch()
+
+
+
+
+
+

custom_resnet.py

@@ -0,0 +1,98 @@
+#myaddition
+import os
+import torch
+from torch.optim.lr_scheduler import LambdaLR
+import torch.optim as optim
+from pytorch_lightning import LightningModule
+from Custom_Resnet_v1 import CustomResNet
+from torch import nn
+from torch.nn import functional as F
+from torch.utils.data import DataLoader, random_split
+import torchvision
+from torchmetrics.functional import accuracy
+from torchvision.datasets import CIFAR10
+from data_transform_cifar10_custom_resnet import get_train_transform, get_test_transform
+PATH_DATASETS = os.environ.get("PATH_DATASETS", ".")
+AVAIL_GPUS = min(1, torch.cuda.device_count())
+BATCH_SIZE = 256 if AVAIL_GPUS else 64
+from cyclic_lr_util import custom_one_cycle_lr
+one_cyle_lr = custom_one_cycle_lr(no_of_images=50176, batch_size=2, base_lr=0.04, max_lr=0.4, final_lr=0.004, epoch_stage1=5, epoch_stage2=18, total_epochs=24)
+class Assignment12Resnet(LightningModule):
+    def __init__(self,lr=0.05,data_dir=PATH_DATASETS):
+        super().__init__()
+        # Set our init args as class attributes
+        self.data_dir = data_dir
+        self.learning_rate = lr
+
+        # Hardcode some dataset specific attributes
+        self.num_classes = 10
+        self.train_transform = get_train_transform()
+        self.test_transform = get_test_transform()
+        self.cifar10_trainset  = None
+        self.cifar10_testset = None
+        self.save_hyperparameters()
+        self.model = CustomResNet()
+
+    def forward(self, x):
+        out = self.model(x)
+        return out
+
+    def training_step(self, batch, batch_idx):
+        x, y = batch
+        logits = self(x)
+        loss = F.nll_loss(logits, y)
+        self.log("train_loss", loss)
+        return loss
+
+    def evaluate(self, batch, stage=None):
+        x, y = batch
+        logits = self(x)
+        loss = F.nll_loss(logits, y)
+        preds = torch.argmax(logits, dim=1)
+        acc = accuracy(preds, y,task="multiclass", num_classes=10)
+
+        if stage:
+            self.log(f"{stage}_loss", loss, prog_bar=True)
+            self.log(f"{stage}_acc", acc, prog_bar=True)
+
+    def validation_step(self, batch, batch_idx):
+        self.evaluate(batch, "val")
+
+    def test_step(self, batch, batch_idx):
+        self.evaluate(batch, "test")
+
+    def configure_optimizers(self):
+        optimizer = optim.SGD(self.model.parameters(), lr=0.04, momentum=0.9)
+        steps_per_epoch = 45000 // BATCH_SIZE
+        scheduler_dict = {
+            "scheduler": torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=[one_cyle_lr]),
+            "interval": "step",
+        }
+        return {"optimizer": optimizer, "lr_scheduler": scheduler_dict}
+    ####################
+    # 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:
+            cifar10_trainset = torchvision.datasets.CIFAR10(root=self.data_dir, train=True, download=True, transform=self.train_transform)
+            self.cifar_train, self.cifar_val = random_split(cifar10_trainset, [46000, 4000])
+        # Assign test dataset for use in dataloader(s)
+        if stage == "test" or stage is None:
+            self.cifar10_testset= torchvision.datasets.CIFAR10(root=self.data_dir, train=False,  download=True, transform=self.test_transform)
+
+    def train_dataloader(self):
+        return torch.utils.data.DataLoader(self.cifar_train, batch_size=BATCH_SIZE, shuffle=True, num_workers=os.cpu_count())
+
+    def val_dataloader(self):
+        return torch.utils.data.DataLoader(self.cifar_val, batch_size=BATCH_SIZE,shuffle=False, num_workers=os.cpu_count())
+
+    def test_dataloader(self):
+        return torch.utils.data.DataLoader(self.cifar10_testset, batch_size=BATCH_SIZE, shuffle=False,num_workers=os.cpu_count())

cyclic_lr_util.py

@@ -0,0 +1,33 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import numpy as np
+import matplotlib.pyplot as plt
+def triangle_lr_plot(lr_min, lr_max, step_size, iterations):
+    lr_list = []
+    it_list = [j for j in range(iterations + 1)]
+    for i in range(iterations + 1):
+        half_cycle_count = np.floor(i/step_size)
+        x = i - half_cycle_count * step_size
+        if half_cycle_count % 2 == 0:
+            lr = lr_min + x*(lr_max-lr_min)/step_size
+        else:
+            lr = lr_max - x*(lr_max-lr_min)/step_size
+        lr_list.append(lr)
+    fig, axs = plt.subplots(figsize=(5,5))
+    axs.plot(it_list, lr_list)
+    plt.title("CLR - 'triangular' Policy")
+    plt.xlabel("Iteration")
+    plt.ylabel("Learning Rate")
+    plt.show()
+
+def custom_one_cycle_lr(no_of_images, batch_size, base_lr, max_lr, final_lr, epoch_stage1=5, epoch_stage2=18, total_epochs=24):
+    lr_schedule = lambda t: np.interp([t], [0, epoch_stage1, epoch_stage2, total_epochs], [base_lr,  max_lr, base_lr, final_lr])[0]
+    lr_lambda = lambda it: lr_schedule(it * batch_size/no_of_images)
+    
+    return lr_lambda
+	
+def max_lr_finder_schedule(no_of_images, batch_size, base_lr, max_lr, total_epochs=5):
+    lr_finder_schedule = lambda t: np.interp([t], [0, total_epochs], [base_lr,  max_lr])[0]
+    lr_finder_lambda = lambda it: lr_finder_schedule(it * batch_size/no_of_images)
+    
+    return lr_finder_lambda

data_transform_cifar10_custom_resnet.py

@@ -0,0 +1,45 @@
+#from PIL import Image
+import cv2
+import numpy as np
+from albumentations import Compose, RandomCrop, Normalize, HorizontalFlip, Resize,GaussNoise, PadIfNeeded,ShiftScaleRotate, CoarseDropout,ToGray
+from albumentations.augmentations.dropout import Cutout
+from albumentations.pytorch import ToTensorV2
+
+
+class album_Compose_train:
+    def __init__(self):
+        self.transform = Compose(
+        [
+         PadIfNeeded(min_height=48, min_width=48, border_mode=cv2.BORDER_CONSTANT, value=[0.4914*255, 0.4822*255, 0.4465*255], p=1.0),
+         RandomCrop(32,32, p=1.0),
+         Cutout(num_holes=1, max_h_size=8, max_w_size=8,  fill_value=[0.4914*255, 0.4822*255, 0.4465*255]),
+         HorizontalFlip(p=0.2),
+         #GaussNoise(p=0.15),
+         #ElasticTransform(p=0.15),
+        Normalize((0.4914, 0.4822, 0.4465), ((0.2023, 0.1994, 0.2010))),
+        ToTensorV2(),
+        ])
+    def __call__(self, img):
+        img = np.array(img)
+        img = self.transform(image=img)['image']
+        return img
+
+class album_Compose_test:
+    def __init__(self):
+        self.transform = Compose(
+        [
+        Normalize((0.4914, 0.4822, 0.4465), ((0.2023, 0.1994, 0.2010))),
+        ToTensorV2(),
+        ])
+    def __call__(self, img):
+        img = np.array(img)
+        img = self.transform(image=img)['image']
+        return img
+			
+def get_train_transform():
+    transform = album_Compose_train()
+    return transform
+
+def get_test_transform():
+    transform = album_Compose_test()
+    return transform

epoch=22-step=4140.ckpt

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

requirements.txt

@@ -0,0 +1,10 @@
+torch
+torchvision
+torch-lr-finder
+grad-cam
+pillow
+numpy
+pytorch_lightning
+albumentations
+pytorch-gradcam
+gradio