update app

README.md

@@ -15,21 +15,21 @@ Check out the configuration reference at https://huggingface.co/docs/hub/spaces-
 # 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.
+   - **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 multiple target layers, 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.
+   - **Input Image**: Upload your own 32x32 pixel image or select one of the example images from the given list.
+   - **Top Classes**: Choose the number of top predicted classes to display along with their respective confidence scores.
+   - **Enable GradCAM**: Check this box to display the GradCAM overlay on the input image. Uncheck it to view only the original image.
+   - **Network Layers**: Select the target layers for GradCAM visualization. The default values are -2 and -1.
+   - **Transparency**: Control the transparency of the GradCAM overlay. The default value is 0.5.
 
 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.
+   - **No. of Examples**: Control the number of misclassified examples displayed in the gallery. The default value is 20.
+   - **Enable GradCAM**: Check this box to display the GradCAM overlay on the misclassified images. Uncheck it to view only the original images.
+   - **Network 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.5.
 
 4. After adjusting the settings, click the "Submit" button to see the results.
 

app.py

@@ -10,8 +10,19 @@ 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 models.custom_resnet import Model
-from utils import get_device
+from custom_resnet import Model
+
+
+def get_device():
+    if torch.cuda.is_available():
+        device = "cuda"
+    elif torch.backends.mps.is_available():
+        device = "mps"
+    else:
+        device = "cpu"
+    print("Device Selected:", device)
+    return device
+
 
 DEVICE = get_device()
 
@@ -42,8 +53,18 @@ transform = transforms.Compose([
 
 inv_transform = transforms.Normalize(mean=[-2, -2, -2], std=[4, 4, 4])
 
+grad_cams = [GradCAM(model=model, target_layers=[model.network[i]], use_cuda=(DEVICE == 'cuda')) 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_layer=-2, transparency=0.7):
+def image_classifier(input_image, top_classes=3, show_cam=True, target_layers=[2, 3], transparency=0.5):
     input_ = transform(input_image).unsqueeze(0)
 
     output = model(input_)
@@ -52,43 +73,47 @@ def image_classifier(input_image, top_classes=3, show_cam=True, target_layer=-2,
     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=(DEVICE == 'cuda'))
-    targets = [ClassifierOutputTarget(label)]
-    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)
 
-    return output_image if show_cam else input_image, confidences
+    outputs = list()
+    if show_cam:
+        for layer in target_layers:
+            grayscale_cam = get_gradcam_image(input_, 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}"))
+    else:
+        outputs.append((input_image, "Input"))
+
+    return outputs, confidences
 
 
 demo1 = gr.Interface(
     fn=image_classifier,
     inputs=[
         gr.Image(shape=(32, 32), label="Input Image", value='examples/cat.jpg'),
-        gr.Slider(1, 10, value=3, step=1, label="Number of Top Classes"),
-        gr.Checkbox(label="Show GradCAM?", value=True),
-        gr.Slider(-4, -1, value=-2, step=1, label="Which Layer?"),
-        gr.Slider(0, 1, value=0.7, label="Transparency", step=0.1)
+        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.Image(shape=(32, 32), label="Output Image", height=256, width=256),
-             gr.Label(label='Top Classes')],
+    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=20, show_cam=True, target_layer=-1, transparency=0.5):
+def show_incorrect(num_examples=20, show_cam=True, target_layer=-2, transparency=0.5):
     result = list()
     for index, row in missed_df.iterrows():
         image = np.asarray(Image.open(f'missed_examples/{index}.jpg'))
-        output_image, confidence = image_classifier(image, show_cam=show_cam, target_layer=target_layer,
-                                                    transparency=transparency)
+        output_images, confidences = image_classifier(image, top_classes=1, show_cam=show_cam,
+                                                      target_layers=[4 + target_layer], transparency=transparency)
         truth = row['ground_truths']
-        predicted = list(confidence)[0]
+        predicted = list(confidences)[0]
         if truth != predicted:
-            result.append((output_image, f"{row['ground_truths']} / {predicted}"))
+            result.append((output_images[0][0], f"{row['ground_truths']} / {predicted}"))
         if len(result) >= num_examples:
             break
     return result
@@ -97,12 +122,13 @@ def show_incorrect(num_examples=20, show_cam=True, target_layer=-1, transparency
 demo2 = gr.Interface(
     fn=show_incorrect,
     inputs=[
-        gr.Number(value=20, minimum=1, maximum=len(missed_df), label="No. of missclassified Examples", precision=0),
-        gr.Checkbox(label="Show GradCAM?", value=True),
-        gr.Slider(-4, -1, value=-2, step=1, label="Which Layer?"),
-        gr.Slider(0, 1, value=0.7, label="Transparency", step=0.1),
+        gr.Number(value=20, minimum=1, maximum=100, label="No. of Examples", precision=0,
+                  info="How many misclassified examples do you want to view? (1 - 100)"),
+        gr.Checkbox(label="Enable GradCAM", value=True, info="Do you want to see Class Activation Maps?"),
+        gr.Slider(-4, -1, value=-2, step=1, label="Network Layer", info="Which layer CAM 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="Missclassified Images (Truth / Predicted)", columns=4)]
+    outputs=[gr.Gallery(label="Missclassified Images (Truth / Predicted)", columns=5)]
 )
 
 demo = gr.TabbedInterface([demo1, demo2], ["Examples", "Misclassified Examples"])

utils/__init__.py

@@ -1 +0,0 @@
-from .misc import *

utils/misc.py

@@ -1,19 +0,0 @@
-import torch
-
-SEED = 42
-DEVICE = None
-
-
-def get_device():
-    global DEVICE
-    if DEVICE is not None:
-        return DEVICE
-
-    if torch.cuda.is_available():
-        DEVICE = "cuda"
-    elif torch.backends.mps.is_available():
-        DEVICE = "mps"
-    else:
-        DEVICE = "cpu"
-    print("Device Selected:", DEVICE)
-    return DEVICE