Create app.py

app.py

@@ -0,0 +1,239 @@
+# We import gradio which is the library we use to build the web interface
+import gradio as gr
+
+# numpy is used for numerical operations and array manipulation
+import numpy as np
+
+# tensorflow is used to load and run the tflite model
+import tensorflow as tf
+
+# PIL (Pillow) is used to handle image loading and resizing
+from PIL import Image
+
+# os is used to set environment variables
+import os
+
+# This line tells TensorFlow to suppress unnecessary log messages
+# 3 means only show critical errors
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+
+
+# ------------------------------------
+# LOAD THE MODEL
+# ------------------------------------
+
+# This loads the tflite model file from the current directory
+# The Interpreter class is what TensorFlow Lite uses to run models
+interpreter = tf.lite.Interpreter(model_path="gatekeeper_model.tflite")
+
+# This allocates memory for the model's input and output tensors
+# You must always call this before running inference
+interpreter.allocate_tensors()
+
+# This gets the details of the input tensor
+# It tells us the expected shape, data type, and index of the input
+input_details = interpreter.get_input_details()
+
+# This gets the details of the output tensor
+# It tells us the shape and index of the output so we can read predictions
+output_details = interpreter.get_output_details()
+
+# This is the image size the model expects
+# ResNet50 was trained on 224x224 images so we keep this the same
+INPUT_SIZE = (224, 224)
+
+
+# ------------------------------------
+# IMAGE PREPROCESSING FUNCTION
+# ------------------------------------
+
+def preprocess_image(image):
+    # image comes in as a numpy array from gradio
+    # we convert it to a PIL Image object so we can resize it easily
+    # we also make sure it is in RGB format (3 channels: red, green, blue)
+    img = Image.fromarray(image).convert("RGB")
+
+    # we resize the image to match what the model expects
+    # if the image is not 224x224 the model will throw a shape error
+    img = img.resize(INPUT_SIZE)
+
+    # we convert the PIL image back to a numpy array
+    # dtype=np.float32 is important because the model expects 32-bit floats
+    img = np.array(img, dtype=np.float32)
+
+    # we divide all pixel values by 255
+    # this converts pixel values from the range [0, 255] to [0, 1]
+    # this is called normalization and it helps the model perform correctly
+    img = img / 255.0
+
+    # the model expects a batch of images, not a single image
+    # so we add an extra dimension at position 0
+    # this changes the shape from (224, 224, 3) to (1, 224, 224, 3)
+    # the 1 represents a batch size of 1 (one image at a time)
+    img = np.expand_dims(img, axis=0)
+
+    # we return the fully preprocessed image ready for inference
+    return img
+
+
+# ------------------------------------
+# CLASSIFICATION FUNCTION
+# ------------------------------------
+
+def classify_image(image):
+    # if the user clicks the button without uploading an image
+    # we return None for the scores and a warning message
+    if image is None:
+        return None, "Please upload an image first"
+
+    # we send the image through our preprocessing function
+    processed = preprocess_image(image)
+
+    # we load the preprocessed image into the model's input tensor
+    # input_details[0]['index'] gives us the correct tensor index to write to
+    interpreter.set_tensor(input_details[0]['index'], processed)
+
+    # this actually runs the model on the input we just loaded
+    interpreter.invoke()
+
+    # this reads the output from the model after inference is complete
+    # output_details[0]['index'] gives us the correct tensor index to read from
+    output = interpreter.get_tensor(output_details[0]['index'])
+
+    # we print the raw output to the console for debugging purposes
+    # this is useful to confirm the model is producing expected values
+    print(f"Raw model output: {output}")
+
+    # index 0 of the output corresponds to Non-Cervix probability
+    # we convert it to a plain Python float for easier handling
+    prob_non_cervix = float(output[0][0])
+
+    # index 1 of the output corresponds to Cervix probability
+    prob_cervix = float(output[0][1])
+
+    # we compare the two probabilities to determine the final prediction
+    # whichever class has the higher probability is our prediction
+    if prob_cervix > prob_non_cervix:
+        prediction_text = "Cervix Detected"
+    else:
+        prediction_text = "Non-Cervix"
+
+    # we build a dictionary of class names mapped to their confidence scores
+    # gradio's Label component accepts this format and displays it as a bar chart
+    # we round to 4 decimal places to keep the display clean
+    scores = {
+        "Cervix":     round(prob_cervix, 4),
+        "Non-Cervix": round(prob_non_cervix, 4)
+    }
+
+    # we return both the scores dictionary and the prediction text
+    # these map to the two output components in the gradio interface
+    return scores, prediction_text
+
+
+# ------------------------------------
+# GRADIO USER INTERFACE
+# ------------------------------------
+
+# gr.Blocks gives us full control over the layout of the interface
+# theme=gr.themes.Soft() gives it a clean and soft visual style
+with gr.Blocks(theme=gr.themes.Soft()) as app:
+
+    # gr.Markdown renders formatted text at the top of the page
+    gr.Markdown("""
+    # Gatekeeper Model
+    ### Cervix Image Binary Classifier
+    Upload an image to classify it as Cervix or Non-Cervix
+    ---
+    """)
+
+    # gr.Row arranges the components inside it horizontally side by side
+    with gr.Row():
+
+        # the first column holds the input components on the left side
+        with gr.Column():
+
+            # gr.Image creates an image upload box
+            # type="numpy" means the image will be passed to our function
+            # as a numpy array which is what we need for preprocessing
+            input_image = gr.Image(
+                label="Upload Image",
+                type="numpy"
+            )
+
+            # this is the main button the user clicks to run the model
+            # variant="primary" makes it stand out visually as the main action
+            # size="lg" makes it large and easy to click
+            classify_btn = gr.Button(
+                "Run Classification",
+                variant="primary",
+                size="lg"
+            )
+
+            # this is a secondary button to reset the interface
+            # variant="secondary" gives it a less prominent visual style
+            clear_btn = gr.Button(
+                "Clear",
+                variant="secondary",
+                size="sm"
+            )
+
+        # the second column holds the output components on the right side
+        with gr.Column():
+
+            # gr.Label displays the confidence scores as a visual bar chart
+            # num_top_classes=2 tells it to show both classes
+            output_scores = gr.Label(
+                label="Confidence Scores",
+                num_top_classes=2
+            )
+
+            # gr.Textbox displays the final prediction as plain text
+            # interactive=False means the user cannot edit it
+            # it is read-only output only
+            output_text = gr.Textbox(
+                label="Prediction",
+                interactive=False,
+                text_align="center"
+            )
+
+    # this adds a reference table at the bottom so users understand
+    # what the two class indices mean
+    gr.Markdown("""
+    ---
+    | Index | Label       | Meaning                          |
+    |-------|-------------|----------------------------------|
+    | 0     | Non-Cervix  | Image does NOT contain cervix    |
+    | 1     | Cervix      | Image contains cervix            |
+
+    ---
+    Disclaimer: This tool is for research purposes only.
+    It is not intended for clinical diagnosis or medical use.
+    """)
+
+    # ------------------------------------
+    # BUTTON ACTIONS
+    # ------------------------------------
+
+    # this connects the classify button to the classify_image function
+    # inputs tells gradio which component to read from
+    # outputs tells gradio which components to write the results to
+    classify_btn.click(
+        fn=classify_image,
+        inputs=input_image,
+        outputs=[output_scores, output_text]
+    )
+
+    # this connects the clear button to a simple lambda function
+    # a lambda is a small anonymous function defined in one line
+    # it returns None for the image, None for scores, and empty string for text
+    # this effectively resets all three components back to their empty state
+    clear_btn.click(
+        fn=lambda: (None, None, ""),
+        inputs=None,
+        outputs=[input_image, output_scores, output_text]
+    )
+
+# this starts the gradio web server and launches the interface
+# on hugging face spaces this is called automatically
+app.launch()