Create app.py

app.py

@@ -0,0 +1,121 @@
+import gradio as gr
+import numpy as np
+import cv2
+import pickle
+from PIL import Image
+
+# --- Parameters ---
+# Threshold for minimum probability to classify an image
+threshold = 0.65 
+
+# --- Load the Trained Model ---
+# This block loads the pre-trained model from a pickle file.
+# Ensure 'model_trained.p' is in the same directory as this script.
+try:
+    with open("model_trained.p", "rb") as pickle_in:
+        model = pickle.load(pickle_in)
+    print("Model loaded successfully.")
+except FileNotFoundError:
+    print("Error: 'model_trained.p' not found. Please ensure the model file is in the correct directory.")
+    model = None
+except Exception as e:
+    print(f"An error occurred while loading the model: {e}")
+    model = None
+
+# --- Preprocessing Function ---
+def preProcessing(img):
+    """
+    Converts an image to grayscale, applies histogram equalization,
+    and normalizes the pixel values.
+    
+    Args:
+        img (numpy.ndarray): The input image in BGR format.
+        
+    Returns:
+        numpy.ndarray: The preprocessed image.
+    """
+    # Convert image to grayscale
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    # Equalize the histogram of the grayscale image to improve contrast
+    img = cv2.equalizeHist(img)
+    # Normalize pixel values to be between 0 and 1
+    img = img / 255.0
+    return img
+
+# --- Prediction Function for Live Feed ---
+def predict(img):
+    """
+    Takes a single frame from the webcam feed, preprocesses it, 
+    and predicts the class using the loaded model. It then annotates 
+    the frame with the prediction and probability.
+    
+    Args:
+        img (numpy.ndarray): The input frame from the Gradio webcam component (in RGB format).
+        
+    Returns:
+        numpy.ndarray: The frame annotated with the prediction details (in RGB format).
+    """
+    if model is None:
+        # If the model isn't loaded, return the frame without any text
+        # and add an error message.
+        cv2.putText(img, "MODEL NOT LOADED", (20, 40), cv2.FONT_HERSHEY_COMPLEX, 
+                    1, (0, 0, 255), 2)
+        return img 
+
+    # Gradio provides the image as an RGB numpy array.
+    # OpenCV uses BGR, so we need to convert the color space.
+    img_original = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+    
+    # Prepare the image for the model
+    img_resized = cv2.resize(img_original, (32, 32))
+    img_processed = preProcessing(img_resized)
+    
+    # Reshape the image to match the model's expected input shape
+    img_reshaped = img_processed.reshape(1, 32, 32, 1)
+    
+    # --- Make Predictions ---
+    # Get the raw prediction probabilities for each class
+    predictions = model.predict(img_reshaped)
+    # Find the class index with the highest probability
+    class_index = np.argmax(predictions)
+    # Get the highest probability value
+    prob_val = np.amax(predictions)
+    
+    # --- Display the Result on the Image ---
+    # If the probability is higher than the set threshold, annotate the image
+    if prob_val > threshold:
+        # Prepare the text to be displayed
+        prediction_text = f"Class: {class_index}"
+        probability_text = f"Prob: {prob_val:.2f}"
+        
+        # Add the text to the original image frame
+        cv2.putText(img_original, prediction_text, (20, 40), cv2.FONT_HERSHEY_COMPLEX, 
+                    1, (0, 255, 0), 2)
+        cv2.putText(img_original, probability_text, (20, 80), cv2.FONT_HERSHEY_COMPLEX, 
+                    1, (0, 255, 0), 2)
+    else:
+        # If probability is below threshold, indicate that
+        cv2.putText(img_original, "No certain prediction", (20, 40), cv2.FONT_HERSHEY_COMPLEX, 
+                    1, (0, 0, 255), 2)
+
+    # Convert the annotated BGR frame back to RGB for display in Gradio
+    img_display = cv2.cvtColor(img_original, cv2.COLOR_BGR2RGB)
+    
+    return img_display
+
+# --- Create and Launch the Gradio Interface ---
+iface = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(sources="webcam", streaming=True, label="Live Webcam Feed"),
+    outputs=gr.Image(label="Result"),
+    live=True,
+    title="Live Webcam Image Classifier",
+    description="This application uses your webcam for real-time image classification. The model's prediction will be overlaid on the video feed.",
+)
+
+# Launch the web interface
+if __name__ == "__main__":
+    if model is not None:
+        iface.launch()
+    else:
+        print("Cannot launch the application because the model failed to load.")