refactor

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,14 +1,30 @@
----
-title: Cifar10
-emoji: 👁
-colorFrom: pink
-colorTo: blue
-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
+# CIFAR10 demo with GradCAM
+## How to Use the App
+1. The app has two tabs:
+   - **Examples**: In this tab, you can upload your own 32x32 pixel image or choose an example image provided to classify and visualize the class activation maps using GradCAM. You can adjust the number of top predicted classes, show/hide the GradCAM overlay, select a target layer, and control the transparency of the overlay.
+   - **Misclassified Examples**: In this tab, the app displays a gallery of misclassified images from CIFAR10 test dataset. You can control the number of examples shown, show/hide the GradCAM overlay, select a target layer, and control the transparency of the overlay.
 
+2. **Examples Tab**:
+   - **Input Image**: Upload your own 32x32 pixel image or select one of the example images from the dropdown list.
+   - **Number of Top Classes**: Choose the number of top predicted classes to display along with their respective confidence scores.
+   - **Show GradCAM?**: Check this box to display the GradCAM overlay on the input image. Uncheck it to view only the original image.
+   - **Which Layer?**: Adjust the target layer for GradCAM visualization. The default value is -2.
+   - **Transparency**: Control the transparency of the GradCAM overlay. The default value is 0.7.
+
+3. **Misclassified Examples Tab**:
+   - **No. of Missclassified Examples**: Control the number of misclassified examples displayed in the gallery. The default value is 20.
+   - **Show GradCAM?**: Check this box to display the GradCAM overlay on the misclassified images. Uncheck it to view only the original images.
+   - **Which Layer?**: Adjust the target layer for GradCAM visualization. The default value is -2.
+   - **Transparency**: Control the transparency of the GradCAM overlay. The default value is 0.7.
+
+4. After adjusting the settings, click the "Submit" button to see the results.
+
+## Credits
+
+- This app is built using the Gradio library ([https://www.gradio.app/](https://www.gradio.app/)) for interactive model interfaces.
+- The PyTorch library ([https://pytorch.org/](https://pytorch.org/)) is used for the deep learning model and GradCAM visualization.
+- The CIFAR-10 dataset ([https://www.cs.toronto.edu/~kriz/cifar.html](https://www.cs.toronto.edu/~kriz/cifar.html)) is used for training and evaluation.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

app.py

@@ -11,18 +11,29 @@ from pytorch_grad_cam.utils.image import show_cam_on_image
 from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
 
 from models.custom_resnet import Model
-from datasets import CIFAR10
 
-cifar10 = CIFAR10(normalize=False, shuffle=False, augment=False)
-_ = cifar10.test_data
+from utils import get_device
+
+DEVICE = get_device()
+
+classes = {0: 'airplane',
+           1: 'automobile',
+           2: 'bird',
+           3: 'cat',
+           4: 'deer',
+           5: 'dog',
+           6: 'frog',
+           7: 'horse',
+           8: 'ship',
+           9: 'truck'}
 
 missed_df = pd.read_csv('S12_incorrect.csv')
-missed_df['ground_truths'] = missed_df['ground_truths'].map(cifar10.classes)
-missed_df['predicted_vals'] = missed_df['predicted_vals'].map(cifar10.classes)
+missed_df['ground_truths'] = missed_df['ground_truths'].map(classes)
+missed_df['predicted_vals'] = missed_df['predicted_vals'].map(classes)
 missed_df = missed_df.sample(frac=1)
 
-model = Model(cifar10)
-model.load_state_dict(torch.load('S12_model.pth', map_location='cpu'))
+model = Model()
+model.load_state_dict(torch.load('S12_model.pth', map_location=DEVICE), strict=False)
 model.eval()
 
 transform = transforms.Compose([
@@ -34,20 +45,20 @@ inv_transform = transforms.Normalize(mean=[-2, -2, -2], std=[4, 4, 4])
 
 
 def image_classifier(input_image, top_classes=3, show_cam=True, target_layer=-2, transparency=0.7):
-    input = transform(input_image).unsqueeze(0)
+    input_ = transform(input_image).unsqueeze(0)
 
-    output = model(input)
+    output = model(input_)
     output = F.softmax(output.flatten(), dim=-1)
 
-    confidences = [(cifar10.classes[i], float(output[i])) for i in range(10)]
+    confidences = [(classes[i], float(output[i])) for i in range(10)]
     confidences.sort(key=lambda x: x[1], reverse=True)
     confidences = OrderedDict(confidences[:top_classes])
 
     label = torch.argmax(output).item()
     target_layer = [model.network[4 + target_layer]]
-    grad_cam = GradCAM(model=model, target_layers=target_layer, use_cuda=False)
+    grad_cam = GradCAM(model=model, target_layers=target_layer, use_cuda=(DEVICE == 'cuda'))
     targets = [ClassifierOutputTarget(label)]
-    grayscale_cam = grad_cam(input_tensor=input, targets=targets)
+    grayscale_cam = grad_cam(input_tensor=input_, targets=targets)
     grayscale_cam = grayscale_cam[0, :]
     output_image = show_cam_on_image(input_image / 255, grayscale_cam, use_rgb=True, image_weight=transparency)
 
@@ -63,9 +74,9 @@ demo1 = gr.Interface(
         gr.Slider(-4, -1, value=-2, step=1, label="Which Layer?"),
         gr.Slider(0, 1, value=0.7, label="Transparency", step=0.1)
     ],
-    outputs=[gr.Image(shape=(32, 32), label="Output Image"),
+    outputs=[gr.Image(shape=(32, 32), label="Output Image", height=256, width=256),
              gr.Label(label='Top Classes')],
-    examples=[[f'examples/{k}.jpg'] for k in cifar10.classes.values()]
+    examples=[[f'examples/{k}.jpg'] for k in classes.values()]
 )
 
 

datasets/__init__.py

@@ -1 +0,0 @@
-from .cifar10 import CIFAR10

datasets/cifar10.py

@@ -1,32 +0,0 @@
-import numpy as np
-import cv2
-from torchvision import datasets
-import albumentations as A
-
-from .generic import MyDataSet
-
-
-class AlbCIFAR10(datasets.CIFAR10):
-    def __init__(self, root, alb_transform=None, **kwargs):
-        super(AlbCIFAR10, self).__init__(root, **kwargs)
-        self.alb_transform = alb_transform
-
-    def __getitem__(self, index):
-        image, label = super(AlbCIFAR10, self).__getitem__(index)
-        if self.alb_transform is not None:
-            image = self.alb_transform(image=np.array(image))['image']
-        return image, label
-
-
-class CIFAR10(MyDataSet):
-    DataSet = AlbCIFAR10
-    mean = (0.49139968, 0.48215827, 0.44653124)
-    std = (0.24703233, 0.24348505, 0.26158768)
-    default_alb_transforms = [
-        A.ToGray(p=0.2),
-        A.PadIfNeeded(40, 40, p=1),
-        A.RandomCrop(32, 32, p=1),
-        A.HorizontalFlip(p=0.5),
-        # Since normalisation was the first step, mean is already 0, so cutout fill_value = 0
-        A.CoarseDropout(max_holes=1, max_height=8, max_width=8, fill_value=0, p=1)
-    ]

datasets/generic.py

@@ -1,111 +0,0 @@
-import os
-from abc import ABC
-from functools import cached_property
-
-import torch
-import albumentations as A
-from albumentations.pytorch import ToTensorV2
-
-try:
-    from epoch.utils import plot_examples
-except ModuleNotFoundError:
-    from utils import plot_examples
-
-
-class MyDataSet(ABC):
-    DataSet = None
-    mean = None
-    std = None
-    classes = None
-    default_alb_transforms = None
-
-    def __init__(self, batch_size=1, normalize=True, shuffle=True, augment=True, alb_transforms=None):
-        self.batch_size = batch_size
-        self.normalize = normalize
-        self.shuffle = shuffle
-        self.augment = augment
-        self.alb_transforms = alb_transforms or self.default_alb_transforms
-
-        self.loader_kwargs = {'batch_size': batch_size, 'num_workers': os.cpu_count(), 'pin_memory': True}
-
-    @classmethod
-    def set_classes(cls, data):
-        if cls.classes is None:
-            cls.classes = {i: c for i, c in enumerate(data.classes)}
-
-    @cached_property
-    def train_data(self):
-        res = self.DataSet('../data', train=True, download=True, alb_transform=self.get_train_transforms())
-        self.set_classes(res)
-        return res
-
-    @cached_property
-    def test_data(self):
-        res = self.DataSet('../data', train=False, download=True, alb_transform=self.get_test_transforms())
-        self.set_classes(res)
-        return res
-
-    @cached_property
-    def train_loader(self):
-        return torch.utils.data.DataLoader(self.train_data, shuffle=self.shuffle, **self.loader_kwargs)
-
-    @cached_property
-    def test_loader(self):
-        return torch.utils.data.DataLoader(self.test_data, shuffle=False, **self.loader_kwargs)
-
-    @cached_property
-    def example_iter(self):
-        return iter(self.train_loader)
-
-    def get_train_transforms(self):
-        all_transforms = list()
-        if self.normalize:
-            all_transforms.append(A.Normalize(self.mean, self.std))
-        if self.augment and self.alb_transforms is not None:
-            all_transforms.extend(self.alb_transforms)
-        all_transforms.append(ToTensorV2())
-        return A.Compose(all_transforms)
-
-    def get_test_transforms(self):
-        all_transforms = list()
-        if self.normalize:
-            all_transforms.append(A.Normalize(self.mean, self.std))
-        all_transforms.append(ToTensorV2())
-        return A.Compose(all_transforms)
-
-    def download(self):
-        self.DataSet('../data', train=True, download=True)
-        self.DataSet('../data', train=False, download=True)
-
-    def denormalise(self, tensor):
-        result = tensor.clone().detach().requires_grad_(False)
-        if self.normalize:
-            for t, m, s in zip(result, self.mean, self.std):
-                t.mul_(s).add_(m)
-        return result
-
-    def show_transform(self, img):
-        if self.normalize:
-            img = self.denormalise(img)
-        if len(self.mean) == 3:
-            return img.permute(1, 2, 0)
-        else:
-            return img.squeeze(0)
-
-    def show_examples(self, figsize=(8, 6)):
-        batch_data, batch_label = next(self.example_iter)
-        images = list()
-        labels = list()
-
-        for i in range(len(batch_data)):
-            image = batch_data[i]
-            image = self.show_transform(image)
-
-            label = batch_label[i].item()
-            if self.classes is not None:
-                label = f'{label}:{self.classes[label]}'
-
-            images.append(image)
-            labels.append(label)
-
-        plot_examples(images, labels, figsize=figsize)

models/custom_resnet.py

@@ -1,10 +1,4 @@
 from torch import nn
-from torch import optim
-from pytorch_lightning import LightningModule
-from torchmetrics import MeanMetric
-from torch_lr_finder import LRFinder
-
-from utils.metrics import RunningAccuracy
 
 
 class ConvLayer(nn.Module):
@@ -51,12 +45,10 @@ class CustomLayer(nn.Module):
         return x
 
 
-class Model(LightningModule):
-    def __init__(self, dataset, dropout=0.05, max_epochs=24):
+class Model(nn.Module):
+    def __init__(self, dropout=0.05):
         super(Model, self).__init__()
 
-        self.dataset = dataset
-
         self.network = nn.Sequential(
             CustomLayer(3, 64, pool=False, residue=0, dropout=dropout),
             CustomLayer(64, 128, pool=True, residue=2, dropout=dropout),
@@ -67,93 +59,5 @@ class Model(LightningModule):
             nn.Linear(512, 10)
         )
 
-        self.criterion = nn.CrossEntropyLoss()
-        self.train_accuracy = RunningAccuracy()
-        self.val_accuracy = RunningAccuracy()
-        self.train_loss = MeanMetric()
-        self.val_loss = MeanMetric()
-
-        self.max_epochs = max_epochs
-        self.epoch_counter = 1
-
     def forward(self, x):
         return self.network(x)
-
-    def common_step(self, batch, loss_metric, acc_metric):
-        x, y = batch
-        batch_len = y.numel()
-        logits = self.forward(x)
-        loss = self.criterion(logits, y)
-        loss_metric.update(loss, batch_len)
-        acc_metric.update(logits, y)
-        return loss
-
-    def training_step(self, batch, batch_idx):
-        return self.common_step(batch, self.train_loss, self.train_accuracy)
-
-    def on_train_epoch_end(self):
-        print(f"Epoch: {self.epoch_counter}, Train: Loss: {self.train_loss.compute():0.4f}, Accuracy: "
-              f"{self.train_accuracy.compute():0.2f}")
-        self.train_loss.reset()
-        self.train_accuracy.reset()
-        self.epoch_counter += 1
-
-    def validation_step(self, batch, batch_idx):
-        loss = self.common_step(batch, self.val_loss, self.val_accuracy)
-        self.log("val_step_loss", self.val_loss, prog_bar=True, logger=True)
-        self.log("val_step_acc", self.val_accuracy, prog_bar=True, logger=True)
-        return loss
-
-    def on_validation_epoch_end(self):
-        print(f"Epoch: {self.epoch_counter}, Valid: Loss: {self.val_loss.compute():0.4f}, Accuracy: "
-              f"{self.val_accuracy.compute():0.2f}")
-        self.val_loss.reset()
-        self.val_accuracy.reset()
-
-    def predict_step(self, batch, batch_idx, dataloader_idx=0):
-        if isinstance(batch, list):
-            x, _ = batch
-        else:
-            x = batch
-        return self.forward(x)
-
-    def find_lr(self, optimizer):
-        lr_finder = LRFinder(self, optimizer, self.criterion)
-        lr_finder.range_test(self.dataset.train_loader, end_lr=0.1, num_iter=100, step_mode='exp')
-        _, best_lr = lr_finder.plot()
-        lr_finder.reset()
-        return best_lr
-
-    def configure_optimizers(self):
-        optimizer = optim.Adam(self.parameters(), lr=1e-7, weight_decay=1e-2)
-        best_lr = self.find_lr(optimizer)
-        scheduler = optim.lr_scheduler.OneCycleLR(
-            optimizer,
-            max_lr=best_lr,
-            steps_per_epoch=len(self.dataset.train_loader),
-            epochs=self.max_epochs,
-            pct_start=5/self.max_epochs,
-            div_factor=100,
-            three_phase=False,
-            final_div_factor=100,
-            anneal_strategy='linear'
-        )
-        return {
-            'optimizer': optimizer,
-            'lr_scheduler': {
-                "scheduler": scheduler,
-                "interval": "step",
-            }
-        }
-
-    def prepare_data(self):
-        self.dataset.download()
-
-    def train_dataloader(self):
-        return self.dataset.train_loader
-
-    def val_dataloader(self):
-        return self.dataset.test_loader
-
-    def predict_dataloader(self):
-        return self.val_dataloader()

utils/metrics.py

@@ -1,19 +0,0 @@
-import torch
-from torch import Tensor
-from torchmetrics import Metric
-
-
-class RunningAccuracy(Metric):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.add_state("correct", default=torch.tensor(0), dist_reduce_fx="sum")
-        self.add_state("total", default=torch.tensor(0), dist_reduce_fx="sum")
-
-    def update(self, preds: Tensor, target: Tensor):
-        preds = preds.argmax(dim=1)
-        total = target.numel()
-        self.correct += preds.eq(target).sum()
-        self.total += total
-
-    def compute(self):
-        return 100 * self.correct.float() / self.total