app gradio file with all required fields

.gitignore

@@ -1,2 +1,3 @@
-__pycache__/app.cpython-310.pyc
+__pycache__
 data
+flagged

app-2.py

@@ -1,65 +0,0 @@
-# Importing necessary libraries
-import gradio as gr
-import torch
-import torchvision.transforms as transforms
-from torchvision.models import resnet18
-from torchvision.datasets import CIFAR10
-from torch.nn import functional as F
-import numpy as np
-import matplotlib.pyplot as plt
-from PIL import Image
-
-# Load CIFAR10 pretrained model
-model = resnet18(pretrained=True)
-model.eval()
-
-# Define transformation for CIFAR10
-transform = transforms.Compose([
-    transforms.Resize((224, 224)),
-    transforms.ToTensor(),
-    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
-])
-
-# Load CIFAR10 dataset for example images
-cifar10_dataset = CIFAR10(root='./data', train=False, download=True, transform=transform)
-example_images = [cifar10_dataset[i][0] for i in range(10)]
-
-# Define class names for CIFAR10
-class_names = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
-
-def predict(img, gradcam, num_gradcam, layer, opacity, misclassified, num_misclassified, top_classes):
-    # Transform and predict
-    img_tensor = transform(img).unsqueeze(0)
-    outputs = model(img_tensor)
-    _, predicted = outputs.max(1)
-    probs = F.softmax(outputs, dim=1)[0] * 100
-
-    # Get top classes
-    top_probs, top_labels = torch.topk(probs, min(top_classes, 10))
-    top_classes = [class_names[label] for label in top_labels]
-
-    # GradCAM
-    gradcam_images = []
-    if gradcam:
-        # TODO: Implement GradCAM
-        pass
-
-    # Misclassified images
-    misclassified_images = []
-    if misclassified:
-        # TODO: Get misclassified images
-        pass
-
-    return {'Prediction': top_classes, 'Probabilities': top_probs.tolist(), 'GradCAM': gradcam_images, 'Misclassified': misclassified_images}
-
-# Gradio Interface
-image = gr.inputs.Image()
-gradcam = gr.inputs.Checkbox(label='Show GradCAM Images')
-num_gradcam = gr.inputs.Number(label='Number of GradCAM Images', default=1, minimum=1, maximum=10)
-layer = gr.inputs.Dropdown(choices=['layer1', 'layer2', 'layer3', 'layer4'], label='GradCAM Layer')
-opacity = gr.inputs.Slider(minimum=0, maximum=1, default=0.5, label='Opacity')
-misclassified = gr.inputs.Checkbox(label='Show Misclassified Images')
-num_misclassified = gr.inputs.Number(label='Number of Misclassified Images', default=1, minimum=1, maximum=10)
-top_classes = gr.inputs.Number(label='Number of Top Classes to Show', default=1, minimum=1, maximum=10)
-
-gr.Interface(fn=predict, inputs=[image, gradcam, num_gradcam, layer, opacity, misclassified, num_misclassified, top_classes], outputs='json').launch()

app.py

@@ -1,51 +1,100 @@
 import gradio as gr
 import numpy as np
+import torch
+from torchvision import models, transforms
+from PIL import Image
 
-# Stub function for model inference
-def cifar10_inference(image, gradcam, num_gradcam, layer, opacity, view_misclassified, num_misclassified, top_classes):
-    # Placeholder for model inference
-    # You would replace this with your actual model inference code
-    predictions = {"class_1": 0.1, "class_2": 0.2}  # Example prediction dictionary
-
-    # Placeholder for GradCAM images
-    gradcam_images = []
-    if gradcam:
-        # Generate GradCAM images for the specified layer and number
-        for i in range(num_gradcam):
-            gradcam_images.append(np.random.rand(32, 32, 3))  # Example random image
-
-    # Placeholder for misclassified images
-    misclassified_images = []
-    if view_misclassified:
-        # Get misclassified images
-        for i in range(num_misclassified):
-            misclassified_images.append(np.random.rand(32, 32, 3))  # Example random image
-
-    return predictions, gradcam_images, misclassified_images
-
-# Gradio interface
-iface = gr.Interface(
-    fn=cifar10_inference,
+
+# Run Interface
+def run_inference(input_image, gradcam=False, gradcam_layer=3, gradcam_num = 3, gradcam_opacity=0.5, misclassified_num=5, top_classes=10):
+  """Run inference on a CIFAR-10 image.
+
+  Args:
+    image: The image to be classified.
+    gradcam: Whether to show GradCAM images.
+    gradcam_layer: The layer from which to generate GradCAM images.
+    gradcam_opacity: The opacity of the GradCAM images.
+    misclassified: Whether to show misclassified images.
+    misclassified_num: The number of misclassified images to show.
+    top_classes: The number of top classes to show.
+
+  Returns:
+    The classification results, including the predicted class, the top classes, and the GradCAM images (if requested).
+  """
+#   # Load the CIFAR-10 model
+
+#   # Classify the image
+#   prediction = model.predict(image)
+#   predicted_class = np.argmax(prediction)
+
+#   # Get the top classes
+#   top_classes = prediction.argsort()[-top_classes:][::-1]
+
+#   # Generate GradCAM images, if requested
+#   if gradcam:
+#     gradcam_images = []
+#     for layer in range(model.layers.shape[0]):
+#       gradcam_image = gradcam(model, image, layer, gradcam_opacity)
+#       gradcam_images.append(gradcam_image)
+
+#   # Get the misclassified images, if requested
+#   misclassified_images = []
+#   for i in range(len(prediction)):
+#     if prediction[i] != y_test[i]:
+#       misclassified_images.append(image[i])
+
+  # Placeholder for top classes
+  top_classes = {"dog" : 0.90, "cat": 0.10}
+
+  # Placeholder for GradCAM images
+  gradcam_images = []
+  if gradcam:
+      # Generate GradCAM images for the specified layer and number
+      for i in range(gradcam_num):
+          gradcam_images.append(np.random.rand(32, 32, 3))  # Example random image
+
+  # Placeholder for misclassified images
+  misclassified_images = []
+  if misclassified_num > 0:
+      # Get misclassified images
+      for i in range(misclassified_num):
+          misclassified_images.append((np.random.rand(32, 32, 3), 'caption'))  # Example random image
+
+
+  # Return the classification results
+  return top_classes, gradcam_images if gradcam else [], misclassified_images
+
+
+# Gradio Interface
+input_image = gr.Image(shape=(32, 32), label="Upload Image", info="Upload a CIFAR-10 image to be classified.")
+gradcam= gr.Checkbox(label="View GradCAM images?", info="Whether to show GradCAM images.")
+gradcam_layer = gr.Dropdown(["1", "2", "3"], value="2", label="GradCAM Layer", info="The layer from which to generate GradCAM images.")
+gradcam_num = gr.Slider(label="Number of GradCAM images", minimum=1, maximum=10, step=1, info="The number of GradCAM images to show.")
+gradcam_opacity = gr.Slider(label="GradCAM opacity", minimum=0.0, maximum=1.0, step=0.01, info="The opacity of the GradCAM images.")
+misclassified_num = gr.Slider(label="Number of Misclassified images", minimum=0, maximum=10, step=1, info="The number of misclassified images to show.")
+top_classes = gr.Slider(label="Number of top classes to show", minimum=1, maximum=10, step=1, info="The number of top classes to show.")
+
+output_label = gr.Label(num_top_classes=3, label="Top Classes")
+output_gradcam_gallery = gr.Gallery(object_fit="fit", columns=4, height=280, label="GradCam Galery")
+output_misclassified_gallery = gr.Gallery(object_fit="fit", columns=4, height=280, label="Misclassified Images")
+
+interface = gr.Interface(
+    fn=run_inference,
     inputs=[
-            gr.inputs.Image(shape=(32, 32), label="Upload Image"),
-            gr.inputs.Checkbox(label="View GradCAM images?"),
-            gr.inputs.Number(default=1, label="Number of GradCAM images", min=1, max=10),
-            gr.inputs.Dropdown(choices=["layer_1", "layer_2"], label="Choose a layer for GradCAM"),  # Replace with your layer names
-            gr.inputs.Slider(minimum=0, maximum=1, default=0.5, label="Opacity"),
-            gr.inputs.Checkbox(label="View misclassified images?"),
-            gr.inputs.Number(default=1, label="Number of misclassified images", min=1, max=10),
-            gr.inputs.Number(default=1, label="Number of top classes to show", min=1, max=10),
-        ],
-    outputs=[
-        gr.outputs.Label(num_top_classes=10, label="Predictions"),
-        gr.outputs.Image(type="numpy", label="GradCAM Images"),
-        gr.outputs.Image(type="numpy", label="Misclassified Images"),
+        input_image,
+        gradcam,
+        gradcam_layer,
+        gradcam_num,
+        gradcam_opacity,
+        misclassified_num,
+        top_classes
     ],
+    outputs=[output_label, output_gradcam_gallery, output_misclassified_gallery],
     examples=[
-        # Add paths to your 10 example images
-        ["example1.jpg", False, 1, "layer_1", 0.5, False, 1, 3],
-        ["example2.jpg", False, 1, "layer_1", 0.5, False, 1, 3],
-    ]
-)
-
-iface.launch()
+        ['assets/0001.jpg', True,"3", 4, 0.5, 3, 3, 2],
+        ['assets/0002.jpg', False, "2", 1, 0.3, 1, 2, 2],
+        ['assets/0003.jpg', True, "2", 1, 0.3, 1, 2, 2],
+    ],
+    title="Cifar-10 Inference with GradCAM",
+    description="This is a CIFAR-10 image classifier using custom resnet. Upload a CIFAR-10 image and it will be classified into one of 10 categories.",)
+interface.launch(share=False)