Upload 5 files

app.py

@@ -0,0 +1,81 @@
+import sys
+import gradio as gr
+from classifier import MedSigLIPClassifier
+from logger import logging
+from exception import CustomExceptionHandling
+
+# Initialize the classifier
+# This might take a moment to download/load the model
+classifier = MedSigLIPClassifier()
+
+
+def infer(image, candidate_labels):
+    """Infer function to predict the probability of the given image and candidate labels."""
+    try:
+        if not image:
+            raise gr.Error("No image uploaded")
+
+        # Split labels by comma and strip whitespace
+        labels = [l.strip() for l in candidate_labels.split(",") if l.strip()]
+
+        if not labels:
+            raise gr.Error("No labels provided")
+
+        # Call the classifier
+        logging.info("Calling the classifier")
+        return classifier.predict(image, labels)
+
+    except Exception as e:
+        # Custom exception handling
+        raise CustomExceptionHandling(e, sys) from e
+
+
+# Gradio interface
+with gr.Blocks() as demo:
+    with gr.Column():
+
+        gr.Markdown("# **MedSigLIP Zero-Shot Classification**")
+        gr.Markdown(
+            "This is a demo of MedSigLIP (448) for zero-shot classification trained on medical images."
+        )
+
+        with gr.Row():
+            # Add image input, text input and run button
+            with gr.Column():
+                image_input = gr.Image(
+                    type="pil", label="Image", placeholder="Upload an image", height=310
+                )
+                text_input = gr.Textbox(
+                    label="Labels",
+                    placeholder="Enter your input labels here (comma separated)",
+                )
+                run_button = gr.Button("Run")
+            with gr.Column():
+                output_label = gr.Label(label="Output", num_top_classes=3)
+
+                # Add examples
+                gr.Examples(
+                    examples=[
+                        [
+                            "./images/sample1.png",
+                            "a photo of a leg with no rash, a photo of a leg with a rash",
+                        ],
+                        [
+                            "./images/sample2.png",
+                            "a photo of an arm with no rash, a photo of an arm with a rash",
+                        ],
+                    ],
+                    inputs=[image_input, text_input],
+                    outputs=[output_label],
+                    fn=infer,
+                    cache_examples=True,
+                    cache_mode="lazy",
+                )
+
+        # Add run button click event
+        run_button.click(
+            fn=infer, inputs=[image_input, text_input], outputs=[output_label]
+        )
+
+# Launch the app
+demo.launch(debug=False, theme=gr.themes.Soft())

classifier.py

@@ -0,0 +1,53 @@
+import numpy as np
+from PIL import Image
+import torch
+from transformers import AutoProcessor, AutoModel
+import tensorflow as tf
+
+
+class MedSigLIPClassifier:
+    """MedSigLIPClassifier class for zero-shot classification of medical images."""
+
+    def __init__(self, model_id="google/medsiglip-448"):
+        """Initialize the classifier with the given model ID."""
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model = AutoModel.from_pretrained(model_id).to(self.device)
+        self.processor = AutoProcessor.from_pretrained(model_id)
+
+    def _resize(self, image):
+        """Resizes the image using TensorFlow's resize method to match MedSigLIP training preprocessing."""
+        return Image.fromarray(
+            tf.image.resize(
+                images=image, size=[448, 448], method="bilinear", antialias=False
+            )
+            .numpy()
+            .astype(np.uint8)
+        )
+
+    def predict(self, image: Image.Image, candidate_labels: list[str]):
+        """Predicts the probabilities for the given image and candidate labels."""
+        # Ensure image is RGB
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+
+        # Resize image
+        resized_image = self._resize(image)
+
+        # Prepare inputs
+        inputs = self.processor(
+            text=candidate_labels,
+            images=resized_image,
+            padding="max_length",
+            return_tensors="pt",
+        ).to(self.device)
+
+        # Inference
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+
+        logits_per_image = outputs.logits_per_image
+        probs = torch.softmax(logits_per_image, dim=1)
+
+        # Format results
+        probs_list = probs[0].tolist()
+        return {label: prob for label, prob in zip(candidate_labels, probs_list)}

exception.py

@@ -0,0 +1,50 @@
+"""
+This module defines a custom exception handling class and a function to get error message with details of the error.
+"""
+
+# Standard Library
+import sys
+
+# Local imports
+from logger import logging
+
+
+# Function Definition to get error message with details of the error (file name and line number) when an error occurs in the program
+def get_error_message(error, error_detail: sys):
+    """
+    Get error message with details of the error.
+
+    Args:
+        - error (Exception): The error that occurred.
+        - error_detail (sys): The details of the error.
+
+    Returns:
+        str: A string containing the error message along with the file name and line number where the error occurred.
+    """
+    _, _, exc_tb = error_detail.exc_info()
+
+    # Get error details
+    file_name = exc_tb.tb_frame.f_code.co_filename
+    return "Error occured in python script name [{0}] line number [{1}] error message[{2}]".format(
+        file_name, exc_tb.tb_lineno, str(error)
+    )
+
+
+# Custom Exception Handling Class Definition
+class CustomExceptionHandling(Exception):
+    """
+    Custom Exception Handling:
+        This class defines a custom exception that can be raised when an error occurs in the program.
+        It takes an error message and an error detail as input and returns a formatted error message when the exception is raised.
+    """
+
+    # Constructor
+    def __init__(self, error_message, error_detail: sys):
+        """Initialize the exception"""
+        super().__init__(error_message)
+
+        self.error_message = get_error_message(error_message, error_detail=error_detail)
+
+    def __str__(self):
+        """String representation of the exception"""
+        return self.error_message

logger.py

@@ -0,0 +1,21 @@
+# Importing the required modules
+import os
+import logging
+from datetime import datetime
+
+# Creating a log file with the current date and time as the name of the file
+LOG_FILE = f"{datetime.now().strftime('%m_%d_%Y_%H_%M_%S')}.log"
+
+# Creating a logs folder if it does not exist
+logs_path = os.path.join(os.getcwd(), "logs")
+os.makedirs(logs_path, exist_ok=True)
+
+# Setting the log file path and the log level
+LOG_FILE_PATH = os.path.join(logs_path, LOG_FILE)
+
+# Configuring the logger
+logging.basicConfig(
+    filename=LOG_FILE_PATH,
+    format="[ %(asctime)s ] %(lineno)d %(name)s - %(levelname)s - %(message)s",
+    level=logging.INFO,
+)

requirements.txt

@@ -0,0 +1,9 @@
+torch
+transformers
+pillow
+numpy
+requests
+tensorflow
+gradio
+sentencepiece
+protobuf