init commit

README.md

@@ -10,4 +10,6 @@ pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+This application classifies the given images into one of the ten classes in the cifar 10 dataset. It provides the sample misclasification images done by the model in the test dataset.
+
+The app also provides the option of visualizing the GradCAM (Gradient based Class activation mapping) output for model explainability. The user has the option  to choose the layer

app.py

@@ -0,0 +1,130 @@
+import operator
+import torch
+from torchvision import transforms
+import gradio as gr
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.image import show_cam_on_image
+import gradio as gr
+import model
+from data_loader import CIFAR_CLASS_LABELS, TEST_TRANSFORM
+import matplotlib
+matplotlib.use('agg')
+from matplotlib import pyplot as plt
+
+resnet_18 = model.LitResnet()
+state_dict = torch.load("saved_model.pth", map_location=torch.device('cpu'))
+resnet_18.load_state_dict(state_dict)
+resnet_18_model = resnet_18.model
+
+classes = ('plane', 'car', 'bird', 'cat', 'deer',
+           'dog', 'frog', 'horse', 'ship', 'truck')
+
+
+def inference(input_img, n_top_classes, 
+              apply_gradcam, transparency=0.5,
+              target_layer_number = -1):
+    org_img = input_img
+    input_img = TEST_TRANSFORM(image=input_img)['image']
+    input_img = input_img.unsqueeze(0)
+    outputs = resnet_18_model(input_img)
+    softmax = torch.nn.Softmax(dim=0)
+    o = softmax(outputs.flatten())
+    y = {classes[i]: float(o[i]) for i in range(10)}
+    sorted_pred = sorted(y.items(), key=operator.itemgetter(1), reverse=True)
+    sorted_pred = sorted_pred[: n_top_classes]
+    confidences = {klass: prob for klass, prob in sorted_pred}
+    if apply_gradcam:
+        target_layers = [resnet_18_model.layer3[target_layer_number]]
+        cam = GradCAM(model=resnet_18_model, target_layers=target_layers, use_cuda=False)
+        grayscale_cam = cam(input_tensor=input_img, targets=None)
+        grayscale_cam = grayscale_cam[0, :]
+        visualization = show_cam_on_image(
+            org_img/255, grayscale_cam, use_rgb=True, image_weight=transparency)
+        return (gr.update(value= confidences),
+            gr.update(value=visualization, visible=True))
+    return (gr.update(value=confidences),
+            gr.update(visible=False))
+
+def show_misclasif(see_misclassif, n_images):
+    if see_misclassif:
+        subset = torch.load('misclassified_images.pt')
+        images, actuals, preds = torch.tensor(subset[0])[:20], subset[1], subset[2]
+        figsize=(n_images, 4)
+        nrows=2
+        ncols=n_images//2
+        fig, axes = plt.subplots(nrows, ncols, figsize=figsize)
+        fig.suptitle('misclassified images', weight='bold', size=10)
+        axes = axes.ravel()
+        for img, actual, pred, ax in zip(images, actuals, preds, axes):
+            ax.imshow(img)
+            ax.set_title(
+                f'Prediction={CIFAR_CLASS_LABELS[pred]}\n Actual={CIFAR_CLASS_LABELS[actual]}',
+                fontsize=8)
+            ax.set(xticks=[], yticks=[], xticklabels=[], yticklabels=[])
+            ax.axis('off')
+        image_path = "plot.png"
+        fig.savefig(image_path)
+        plt.close()
+        return gr.update(value=image_path, visible=True)
+
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(shape=(32, 32), label="Input Image")
+            n_top_classes = gr.Slider(maximum=10, minimum=1, value=3, step=1,
+                                label="Top n classes to show", interactive=True)
+            require_gradcam = gr.Checkbox(label="Apply GradCAM",
+                        info="Do you want see the GRAD-CAM visualization")
+            opacity_gradcam = gr.Slider(0, 1, value=0.5, 
+                                label="Opacity of GradCAM")
+            layer_gradcam = gr.Slider(-2, -1, value=-2, step=1, 
+                                label="Which Layer?")
+            submit = gr.Button("Submit")
+        with gr.Column():
+            pred_classes = gr.Label()          
+            grad_cam = gr.Image(shape=(32, 32), 
+                                label="Output",visible=False)\
+                           .style(width=128, height=128)
+    with gr.Row():
+        with gr.Column():
+            see_misclassif = gr.Checkbox(label="View misclassified images",
+                        info="Do you want see the miscassified images in the test dataset")
+            n_misclasif = gr.Slider(maximum=20, minimum=2, value=10, step=2,
+                                      label="Number of misclassified images to show",
+                                      interactive=True, visible=False)
+            render = gr.Button("Render", visible=False)
+            misclasif_display = gr.Image(visible=False)
+
+    n_top_classes.postprocess(n_top_classes.value)
+    submit.click(inference, 
+                 inputs=[input_image, n_top_classes, require_gradcam, 
+                          opacity_gradcam, layer_gradcam],
+                 outputs=[pred_classes, grad_cam]
+                )
+    def turn_on_misclasif(see_misclassif):
+        if see_misclassif:
+            return gr.update(visible=True), gr.update(visible=True), gr.update(visible=False)
+        return gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+        
+    see_misclassif.change(turn_on_misclasif, see_misclassif, [n_misclasif, render, misclasif_display])
+    render.click(show_misclasif, [see_misclassif, n_misclasif], misclasif_display)
+    
+    gr.Examples(
+        examples=[
+            ["examples/truck.jpg", 3, True],
+            ["examples/ship.jpg", 3, True],
+            ["examples/dog.jpg", 3, True],
+            ["examples/cat.jpg", 3, True],
+            ["examples/horse.jpg", 3, True],
+            ["examples/airplane.jpg", 3, True],
+            ["examples/parrot.jpg", 3, True],
+            ["examples/automobile.jpg", 3, True],
+            ["examples/deer.jpg", 3, True],
+            ["examples/frog.jpg", 3, True],
+        ],
+        inputs=[input_image, n_top_classes, require_gradcam],
+        outputs=[pred_classes, grad_cam],
+        fn=inference,
+    )
+demo.launch()

data_loader.py

@@ -0,0 +1,48 @@
+from torchvision import datasets
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+
+
+NORM_DATA_MEAN = (0.49139968, 0.48215841, 0.44653091)
+NORM_DATA_STD = (0.24703223, 0.24348513, 0.26158784)
+
+CIFAR_CLASS_LABELS = [
+    'airplane', 'automobile', 'bird', 'cat', 'deer',
+    'dog', 'frog', 'horse', 'ship', 'truck'
+    ]
+
+TRAIN_TRANSFORM = A.Compose([
+    A.Normalize(
+        mean=NORM_DATA_MEAN,
+        std=NORM_DATA_STD,
+    ),
+    A.HorizontalFlip(),
+    A.Compose([
+        A.PadIfNeeded(min_height=40, min_width=40, p=1.0),
+        A.CoarseDropout(max_holes=1, max_height=16, max_width=16,
+            min_holes=1, min_height=16, min_width=16, 
+            fill_value=NORM_DATA_MEAN, mask_fill_value=None, p=1.0),
+        A.RandomCrop(p=1.0, height=32, width=32)
+    ]),
+    ToTensorV2(),
+])
+
+TEST_TRANSFORM = A.Compose([
+    A.Normalize(
+        mean=NORM_DATA_MEAN,
+        std=NORM_DATA_STD,
+    ),
+    ToTensorV2(),
+])
+
+class CifarAlbumentationsDataset(datasets.CIFAR10):
+    def __init__(self, *args,  **kwargs):
+        super().__init__(*args, **kwargs)
+    def __getitem__(self, idx):
+        img, target = self.data[idx], self.targets[idx]
+        if self.transform:
+            augmented = self.transform(image=img)
+            image = augmented['image']
+        return image, target
+
+

model.py

@@ -0,0 +1,199 @@
+'''
+https://github.com/kuangliu/pytorch-cifar
+
+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
+from torch import nn
+from torch.nn import functional as F
+from torch_lr_finder import LRFinder
+
+
+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])
+
+import torch.nn as nn
+from torch.optim.lr_scheduler import OneCycleLR
+from torch.utils.data import DataLoader
+import matplotlib.pyplot as plt
+
+from data_loader import CifarAlbumentationsDataset,\
+    CIFAR_CLASS_LABELS, TRAIN_TRANSFORM, TEST_TRANSFORM
+import model
+from torch_lr_finder import LRFinder
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from pytorch_lightning import LightningModule
+from torch.optim.lr_scheduler import OneCycleLR
+from torchmetrics.functional import accuracy
+
+class LitResnet(LightningModule):
+    def __init__(self, lr=0.03, batch_size=512):
+        super().__init__()
+
+        self.save_hyperparameters()
+        self.criterion = nn.CrossEntropyLoss()
+        self.model = ResNet18()
+
+    def forward(self, x):
+        return self.model(x)
+
+    def training_step(self, batch, batch_idx):
+        x, y = batch
+        output = self.forward(x)
+        loss = self.criterion(output, y)
+        self.log("train_loss", loss)
+        acc = accuracy(torch.argmax(output, dim=1), 
+                       y, 'multiclass', num_classes=10)
+        self.log(f"train_acc", acc, prog_bar=True)
+        return loss
+
+    def evaluate(self, batch, stage=None):
+        x, y = batch
+        output = self.forward(x)
+        loss = self.criterion(output, y)
+        preds = torch.argmax(output, dim=1)
+        acc = accuracy(preds, y, '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")
+
+    # todo
+    # change the default for num_iter
+    def lr_finder(self, optimizer,  num_iter=200,):
+        lr_finder = LRFinder(self, optimizer, self.criterion,
+            device=self.device)
+        lr_finder.range_test(
+            self.train_dataloader(), end_lr=1,
+            num_iter=num_iter, step_mode='exp',
+            )
+        ax, suggested_lr = lr_finder.plot(suggest_lr=True)
+        # todo
+        # how to log maplotlib images
+        # self.logger.experiment.add_image('lr_finder', plt.gcf(), 0)
+        lr_finder.reset() 
+        return suggested_lr
+    def configure_optimizers(self):
+        optimizer = torch.optim.SGD(
+            self.parameters(),
+            lr=self.hparams.lr,
+            momentum=0.9,
+            weight_decay=5e-4,
+        )
+        suggested_lr = self.lr_finder(optimizer)
+        steps_per_epoch = len(self.train_dataloader())
+        scheduler_dict = {
+            "scheduler":  OneCycleLR(
+                optimizer, max_lr=suggested_lr,
+                steps_per_epoch=steps_per_epoch,
+                epochs=self.trainer.max_epochs, 
+                pct_start=5/self.trainer.max_epochs,
+                three_phase=False,
+                div_factor=100,
+                final_div_factor=100,
+                anneal_strategy='linear',
+            ),
+            "interval": "step",
+        }
+        return {"optimizer": optimizer, "lr_scheduler": scheduler_dict}
+    ####################
+    # DATA RELATED HOOKS
+    ####################
+
+    def prepare_data(self, data_path='../data'):
+        CifarAlbumentationsDataset(
+                data_path, train=True, download=True)
+        CifarAlbumentationsDataset(
+                data_path, train=False, download=True)
+
+    def setup(self, stage=None, data_dir='../data'):
+
+        if stage == "fit" or stage is None:
+            self.train_dataset = CifarAlbumentationsDataset(data_dir, train=True, transform=TRAIN_TRANSFORM)
+            self.test_dataset = CifarAlbumentationsDataset(data_dir, train=False, transform=TEST_TRANSFORM)
+
+
+    def train_dataloader(self):
+        return DataLoader(self.train_dataset, batch_size=self.hparams.batch_size,
+        shuffle=True, pin_memory=True) #num_workers=4, 
+
+    def val_dataloader(self):
+        return DataLoader(self.test_dataset, batch_size=self.hparams.batch_size,
+        shuffle=False, pin_memory=True)
+