Upload app.py

app.py

@@ -0,0 +1,113 @@
+import torch
+import pandas as pd
+import numpy as np
+import gradio as gr
+from PIL import Image
+from torch.nn import functional as F
+from collections import OrderedDict
+from torchvision import transforms
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.image import show_cam_on_image
+from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
+from pytorch_lightning import LightningModule, Trainer, seed_everything
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+import torchvision.transforms as T
+from custom_resnet import LitResnet
+
+classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
+
+wrong_img = pd.read_csv('misclassified_images.csv')
+wrong_img_no = wrong_img.line()
+
+model = LitResnet()
+model.load_state_dict(torch.load("model.pth", map_location=torch.device('cpu')), strict=False)
+model.eval()
+
+transform = A.Compose(
+        [
+        A.Normalize(
+                mean=(0.485, 0.456, 0.406),
+                std=(0.229, 0.224, 0.225),
+                p=1.0,
+                max_pixel_value=255,
+            ),
+        ToTensorV2()
+        ])
+
+inv_normalize = T.Normalize(
+    mean=[-0.50/0.23, -0.50/0.23, -0.50/0.23],
+    std=[1/0.23, 1/0.23, 1/0.23])
+
+grad_cams = [GradCAM(model=model, target_layers=[model.network[i]], use_cuda=False) for i in range(4)]
+
+def get_gradcam_image(input_tensor, label, target_layer):
+    grad_cam = grad_cams[target_layer]
+    targets = [ClassifierOutputTarget(label)]
+    grayscale_cam = grad_cam(input_tensor=input_tensor, targets=targets)
+    grayscale_cam = grayscale_cam[0, :]
+    return grayscale_cam
+
+
+def image_classifier(input_image, top_classes=3, show_cam=True, target_layers=[2, 3], transparency=0.5):
+    input_image = transform(input_image).unsqueeze(0)
+
+    output = model(input_image)
+    output = F.softmax(output.flatten(), dim=-1)
+
+    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()
+
+    outputs = list()
+    if show_cam:
+        for layer in target_layers:
+            grayscale_cam = get_gradcam_image(input_image, label, layer)
+            output_image = show_cam_on_image(input_image / 255, grayscale_cam, use_rgb=True, image_weight=transparency)
+            outputs.append((output_image, f"Layer {layer - 4}"))    
+
+    return outputs, confidences
+
+
+demo1 = gr.Interface(
+    fn=image_classifier,
+    inputs=[
+        gr.Image(shape=(32, 32), label="Input Image").style(width=128, height=128),
+        gr.Slider(1, 10, value=3, step=1, label="Top Classes",
+                  info="How many top classes do you want to view?"),
+        gr.Checkbox(label="Enable GradCAM", value=True, info="Do you want to see Class Activation Maps?"),
+        gr.CheckboxGroup(["-4", "-3", "-2", "-1"], value=["-2", "-1"], label="Network Layers", type='index',
+                         info="Which layer CAMs do you want to visualize?",),
+        gr.Slider(0, 1, value=0.5, label="Transparency", step=0.1,
+                  info="Set Transparency of CAMs")
+    ],
+    outputs=[gr.Gallery(label="Output Images", columns=2, rows=2), gr.Label(label='Top Classes')],
+    examples=[[f'examples/{k}.jpg'] for k in classes.values()]
+)
+
+
+def show_incorrect(num_examples=10):
+    result = list()
+    for i in range(num_examples):
+        j = np.random.randint(0,wrong_img_no)
+        image = np.asarray(Image.open(f'misclassified-images/{j}.jpg'))
+        actual = classes(wrong_img['actual'])
+        predicted = classes(wrong_img['predicted'])
+        
+        result.append((image, f"{actual} / {predicted}"))
+        
+    return result
+
+
+demo2 = gr.Interface(
+    fn=show_incorrect,
+    inputs=[
+        gr.Number(value=10, minimum=1, maximum=50, label="No. of Misclassified Images", precision=0,
+                  info="How many misclassified examples do you want to view? (1 - 50)")
+    ],
+    outputs=[gr.Gallery(label="Missclassified Images (Truth / Predicted)", columns=5)]
+)
+
+demo = gr.TabbedInterface([demo1, demo2], ["Classifier", "Misclassified Images"])
+demo.launch()