Create app.py

app.py

@@ -0,0 +1,94 @@
+import gradio as gr
+import numpy as np
+import tensorflow as tf
+import matplotlib.pyplot as plt
+import seaborn as sns
+from tensorflow.keras.models import load_model
+from tensorflow.keras.utils import to_categorical
+from sklearn.metrics import confusion_matrix
+from tensorflow.keras.datasets import mnist
+import cv2
+
+# I/O image dimensions for display
+DIMS = (100,100)
+# Load the trained model
+model = load_model('model.h5')
+
+# Load MNIST examples
+(x_train, y_train), (x_test, y_test) = mnist.load_data()
+mnist_examples = [[x_test[i]] for i in range(10)]  # Select first 10 examples and format as nested list
+# resize the examples 100 by 100
+mnist_examples = [[cv2.resize(x_test[i], DIMS)] for i in range(10)]
+
+# Function to preprocess the image
+def preprocess_image(image):
+    image = cv2.resize(image, (28, 28))  # Resize to 28x28 for model input
+    image = np.array(image) / 255.0
+    image = image.reshape(1, 28, 28, 1)
+    return image
+
+# Function to make predictions
+def predict(image):
+    image = preprocess_image(image)
+    prediction = model.predict(image)
+    predicted_label = np.argmax(prediction)
+    return predicted_label, np.max(prediction)
+
+# Function to compute gradients
+def get_gradients(image, label):
+    image = tf.convert_to_tensor(image.reshape((1, 28, 28, 1)), dtype=tf.float32)
+    with tf.GradientTape() as tape:
+        tape.watch(image)
+        prediction = model(image)
+        loss = tf.keras.losses.categorical_crossentropy([label], prediction)
+    gradients = tape.gradient(loss, image)
+    return gradients.numpy().reshape(28, 28)
+
+# Function to progressively mask image and observe changes
+def progressively_mask_image(image, steps=100, increment=5):
+    image = preprocess_image(image).reshape(28, 28)
+    label = np.argmax(model.predict(image.reshape(1, 28, 28, 1)))
+    gradients = get_gradients(image, to_categorical(label, 10))
+
+    modified_image = np.copy(image)
+    original_prediction = model.predict(image.reshape(1, 28, 28, 1))
+    original_label = np.argmax(original_prediction)
+
+    for i in range(1, steps + 1):
+        threshold = np.percentile(np.abs(gradients), 100 - i * increment)
+        mask = np.abs(gradients) > threshold
+        modified_image[mask] = 0
+        modified_prediction = model.predict(modified_image.reshape(1, 28, 28, 1))
+        predicted_label = np.argmax(modified_prediction)
+        if predicted_label != original_label:
+            break
+
+    return cv2.resize(modified_image, DIMS), original_label, predicted_label
+
+# Gradio interface functions
+def gradio_predict(image):
+    predicted_label, confidence = predict(image)
+    return f"Predicted Label: {predicted_label}, Confidence: {confidence:.4f}"
+
+def gradio_mask(image, steps, increment):
+    modified_image, original_label, predicted_label = progressively_mask_image(image, steps, increment)
+    return modified_image, f"Original Label: {original_label}, New Label: {predicted_label}"
+
+# Gradio interface
+image_input = gr.Image(image_mode='L', label="Input Image")
+steps_input = gr.Slider(minimum=1, maximum=100, label="Steps", step=1, value=100)
+increment_input = gr.Slider(minimum=1, maximum=20, label="Increment", step=1, value=5)
+
+
+gr.Interface(
+    fn=gradio_mask,
+    inputs=[image_input, steps_input, increment_input],
+    outputs=[
+        gr.Image(image_mode='L', label="Ouput Image"),
+        gr.Textbox(label="Prediction Details")
+    ],
+    title="Progressive Masking",
+    description="Upload an image of a digit and observe how masking affects the model's prediction.",
+    examples=mnist_examples,
+    allow_flagging="never"
+).launch()