Made Modifications and added requirements.txt

app.py

@@ -1,7 +1,94 @@
 import gradio as gr
+import tensorflow as tf
+import numpy as np
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image
+from PIL import Image
 
-def greet(name):
-    return "Hello " + name + "!!"
+# --- CONFIGURATION (MUST MATCH YOUR TRAINING) ---
+# The model file is automatically available in the Space's file system
+MODEL_PATH = 'weapon_classifier_final_tuned.keras'
+IMG_SIZE = (224, 224) 
+# The names of your classes, corresponding to the order they were generated (0=Not_Weapon, 1=Weapon)
+CLASS_NAMES = ['Not a Weapon', 'Weapon'] 
+# --- END CONFIGURATION ---
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+# 1. LOAD MODEL GLOBALLY
+# Loading the model here ensures it only happens once when the app starts.
+try:
+    classifier_model = load_model(MODEL_PATH)
+    print("Model loaded successfully for Gradio interface.")
+except Exception as e:
+    print(f"Error loading model: {e}")
+    # Fallback in case of model load failure
+    classifier_model = None
+
+
+# 2. DEFINE THE PREDICTION FUNCTION
+# Gradio automatically passes the uploaded image as a NumPy array (or PIL Image, depending on 'type').
+def classify_weapon(input_img_array):
+    """
+    Takes a NumPy image array, preprocesses it, and returns the classification.
+    """
+    if classifier_model is None:
+        return "Error: Model failed to load."
+
+    # Gradio passes the image as a NumPy array with shape (H, W, 3) and values 0-255.
+    
+    # a) Resize: Must resize to the model's required input size (224x224 for VGG16).
+    # We use PIL/Image.fromarray and resize before conversion to prevent distortion
+    img = Image.fromarray(input_img_array.astype('uint8'))
+    img = img.resize(IMG_SIZE)
+    
+    # b) Convert to array and add batch dimension (1, 224, 224, 3)
+    img_array = np.array(img).astype('float32')
+    img_array = np.expand_dims(img_array, axis=0)
+    
+    # c) Normalize (Rescale): Must match the 1./255 scaling used during training
+    processed_image = img_array / 255.0
+
+    # d) Make Prediction
+    # Prediction returns a 1x1 array, e.g., [[0.95]]
+    prediction = classifier_model.predict(processed_image)
+    
+    # e) Interpret Output for Gradio Label Component
+    probability = prediction[0][0] 
+
+    # Gradio's Label component expects a dictionary mapping labels to probabilities.
+    # We calculate the confidence for both classes based on the Sigmoid output.
+    confidences = {
+        CLASS_NAMES[1]: float(probability),         # Weapon confidence
+        CLASS_NAMES[0]: float(1 - probability)      # Not a Weapon confidence
+    }
+    
+    return confidences
+
+
+# 3. CREATE THE GRADIO INTERFACE
+# Gradio will handle the 'Submit' button click automatically.
+gr_interface = gr.Interface(
+    # The function to run when the user submits an image
+    fn=classify_weapon, 
+    
+    # Input component: Image component set to resize input to 224x224 for display
+    # Gradio automatically converts the image to a NumPy array for the function.
+    inputs=gr.Image(
+        shape=IMG_SIZE, 
+        label="Upload Image for Classification",
+        type="numpy" # Pass NumPy array to the function
+    ),
+    
+    # Output component: Label displays the class names and confidence scores.
+    outputs=gr.Label(
+        num_top_classes=2, 
+        label="Classification Result"
+    ),
+    
+    title="🔫 VGG16 Weapon Detector",
+    description="Upload an image to classify it as 'Weapon' or 'Not a Weapon'."
+)
+
+# 4. LAUNCH THE INTERFACE
+# In a Hugging Face Space, the launch() call is automatically handled by the environment.
+# If running locally, you would use: demo.launch()
+gr_interface.launch()