img classification

.gitignore

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

app-2.py

@@ -0,0 +1,65 @@
+# 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,15 +1,51 @@
-import numpy as np
 import gradio as gr
+import numpy as np
+
+# 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,
+    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"),
+    ],
+    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],
+    ]
+)
 
-def sepia(input_img):
-    sepia_filter = np.array([
-        [0.393, 0.769, 0.189], 
-        [0.349, 0.686, 0.168], 
-        [0.272, 0.534, 0.131]
-    ])
-    sepia_img = input_img.dot(sepia_filter.T)
-    sepia_img /= sepia_img.max()
-    return sepia_img
-
-iface = gr.Interface(sepia, gr.Image(shape=(200, 200)), "image")
-iface.launch()
+iface.launch()