Upload 4 files

README.md

@@ -1,14 +1,82 @@
----
-title: LorAI
-emoji: 🚀
-colorFrom: gray
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.49.0
-app_file: app.py
-pinned: false
-license: cc-by-nc-4.0
-short_description: Larynx Granuloma Detection
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🏥 Medical Image Analysis Tool
+
+An AI-powered medical image analysis application using advanced detection models and large language models for medical image interpretation.
+
+## Features
+
+- **Advanced Object Detection**: Uses RF-DETR (Real-time Fine-grained Detection Transformer) for precise object detection
+- **Medical AI Analysis**: Integrates MedGemma, a specialized medical vision-language model
+- **Interactive Interface**: Built with Gradio for easy web-based interaction
+- **Configurable Thresholds**: Adjustable confidence thresholds for detection sensitivity
+- **GPU Acceleration**: Optimized for GPU usage when available
+
+## Models Used
+
+- **RF-DETR Medium**: State-of-the-art object detection model
+- **MedGemma 4B**: Medical-specialized vision-language model for analysis and descriptions
+
+## Usage
+
+1. **Upload Image**: Click on the image upload area or drag and drop a medical image
+2. **Adjust Settings**: Use the confidence threshold slider to control detection sensitivity
+3. **Analyze**: Click "Analyze Image" to run the AI analysis
+4. **View Results**: See the annotated image with detected objects and AI-generated descriptions
+
+## Installation & Setup
+
+This application is designed to run on Hugging Face Spaces. The following files are required:
+
+- `app.py` - Main application file
+- `requirements.txt` - Python dependencies
+- `packages.txt` - System packages
+- Model files in the `models/` directory
+
+## Model Files Structure
+
+The application expects the following model files:
+
+```
+models/
+├── medgemma-4b-it/           # MedGemma model files
+│   ├── config.json
+│   ├── tokenizer.json
+│   ├── model-00001-of-00002.safetensors
+│   └── model-00002-of-00002.safetensors
+└── rf-detr-medium.pth        # RF-DETR model weights
+```
+
+## Technical Details
+
+- **Framework**: PyTorch + Transformers
+- **Interface**: Gradio
+- **Computer Vision**: OpenCV, PIL, Supervision
+- **Hardware**: Optimized for both CPU and GPU inference
+
+## Performance Tips
+
+- Higher confidence thresholds reduce false positives but may miss subtle findings
+- The application automatically uses GPU acceleration when available
+- Model loading happens on first use and is cached for subsequent analyses
+
+## Limitations
+
+- Requires significant computational resources for optimal performance
+- Best suited for medical imaging applications
+- Results should be verified by qualified medical professionals
+
+## Development
+
+To run locally:
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+## License
+
+This project is for research and educational purposes. Medical applications should be developed and validated according to appropriate regulatory standards.
+
+## Support
+
+For issues or questions, please refer to the Hugging Face Space documentation or create an issue in the project repository.

app.py

@@ -0,0 +1,185 @@
+import os
+import gc
+import json
+import time
+import warnings
+from typing import Dict, List, Optional, Tuple, Any
+import traceback
+
+import torch
+import cv2
+import numpy as np
+from PIL import Image
+import gradio as gr
+
+# Import ML libraries
+try:
+    import supervision as sv
+    from transformers import AutoModelForImageTextToText, AutoProcessor
+except ImportError as e:
+    print(f"Warning: Missing dependencies: {e}")
+
+# Suppress warnings
+warnings.filterwarnings("ignore")
+
+# Model paths - adjust these for your Space
+MODEL_DIR = "models"
+RESULTS_DIR = "results"
+CACHE_DIR = os.path.join(MODEL_DIR, "hf_cache")
+
+class ModelManager:
+    def __init__(self):
+        self.detector = None
+        self.processor = None
+        self.llm_model = None
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    def load_models(self):
+        """Load the detection and LLM models"""
+        try:
+            print(f"Loading models on device: {self.device}")
+
+            # Load RF-DETR detector
+            print("Loading RF-DETR detector...")
+            self.detector = torch.load("rf-detr-medium.pth", map_location=self.device)
+            self.detector.eval()
+
+            # Load MedGemma processor and model
+            print("Loading MedGemma model...")
+            processor_path = os.path.join(MODEL_DIR, "medgemma-4b-it")
+            if os.path.exists(processor_path):
+                self.processor = AutoProcessor.from_pretrained(processor_path)
+                self.llm_model = AutoModelForImageTextToText.from_pretrained(
+                    processor_path,
+                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                    device_map="auto" if self.device == "cuda" else None
+                )
+            else:
+                print("Warning: MedGemma model not found locally, using basic detection only")
+
+        except Exception as e:
+            print(f"Error loading models: {e}")
+            self.detector = None
+            self.processor = None
+            self.llm_model = None
+
+    def detect_objects(self, image: Image.Image, threshold: float = 0.7) -> Tuple[Image.Image, str]:
+        """Run object detection on the image"""
+        if self.detector is None:
+            return image, "Error: Detector not loaded"
+
+        try:
+            # Convert PIL to numpy
+            image_np = np.array(image)
+
+            # Run detection (simplified - adjust based on your RF-DETR implementation)
+            with torch.no_grad():
+                # This is a placeholder - you'll need to adapt based on your RF-DETR usage
+                detections = self.detector(image_np, threshold=threshold)
+
+            # Annotate image
+            annotated_image = self._annotate_image(image_np, detections)
+
+            # Generate description
+            description = self._generate_description(annotated_image, detections)
+
+            return Image.fromarray(annotated_image), description
+
+        except Exception as e:
+            return image, f"Error during detection: {str(e)}"
+
+    def _annotate_image(self, image: np.ndarray, detections) -> np.ndarray:
+        """Annotate image with detections"""
+        # Placeholder annotation - adapt based on your detection format
+        annotated = image.copy()
+
+        # Add detection boxes (adjust based on your detection format)
+        if hasattr(detections, 'boxes') and len(detections.boxes) > 0:
+            for box in detections.boxes:
+                x1, y1, x2, y2 = box.cpu().numpy().astype(int)
+                cv2.rectangle(annotated, (x1, y1), (x2, y2), (0, 255, 0), 2)
+
+        return annotated
+
+    def _generate_description(self, image: np.ndarray, detections) -> str:
+        """Generate text description using LLM"""
+        if self.processor is None or self.llm_model is None:
+            return "Basic detection completed (LLM not available)"
+
+        try:
+            # Prepare image for LLM
+            pil_image = Image.fromarray(image)
+
+            # Create prompt for medical analysis
+            prompt = "Analyze this medical image and describe any findings related to larynx granuloma or other abnormalities."
+
+            # Process image and text
+            inputs = self.processor(text=prompt, images=pil_image, return_tensors="pt")
+
+            if self.device == "cuda":
+                inputs = {k: v.to(self.device) for k, v in inputs.items()}
+
+            # Generate response
+            with torch.no_grad():
+                outputs = self.llm_model.generate(
+                    **inputs,
+                    max_new_tokens=200,
+                    temperature=0.2,
+                    do_sample=True
+                )
+
+            # Decode response
+            response = self.processor.batch_decode(outputs, skip_special_tokens=True)[0]
+            return response.strip()
+
+        except Exception as e:
+            return f"LLM analysis failed: {str(e)}"
+
+# Global model manager
+model_manager = ModelManager()
+
+def analyze_image(image: Image.Image, threshold: float = 0.7, use_llm: bool = True) -> Tuple[Image.Image, str]:
+    """Main function to analyze uploaded image"""
+    if model_manager.detector is None:
+        model_manager.load_models()
+
+    if model_manager.detector is None:
+        return image, "Error: Could not load models. Please check the model files."
+
+    return model_manager.detect_objects(image, threshold)
+
+# Create Gradio interface
+with gr.Blocks(title="Medical Image Analysis") as demo:
+    gr.Markdown(
+        "# 🏥 Medical Image Analysis Tool\n\n"
+        "Upload a medical image for AI-powered analysis using advanced detection models."
+    )
+
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(type="pil", label="Upload Medical Image")
+            threshold_slider = gr.Slider(
+                0.1, 1.0, value=0.7, step=0.05,
+                label="Detection Threshold",
+                info="Higher values = fewer but more confident detections"
+            )
+            analyze_btn = gr.Button("Analyze Image", variant="primary")
+
+        with gr.Column():
+            output_image = gr.Image(type="pil", label="Analysis Results")
+            description = gr.Markdown(label="AI Analysis", value="Upload an image to begin analysis")
+
+    analyze_btn.click(
+        analyze_image,
+        inputs=[input_image, threshold_slider],
+        outputs=[output_image, description]
+    )
+
+    input_image.change(
+        analyze_image,
+        inputs=[input_image, threshold_slider],
+        outputs=[output_image, description]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

packages.txt

@@ -0,0 +1,8 @@
+libgl1-mesa-glx
+libglib2.0-0
+libsm6
+libxext6
+libxrender-dev
+libgomp1
+ffmpeg
+build-essential

requirements.txt

@@ -0,0 +1,11 @@
+torch>=2.0.0
+transformers>=4.30.0
+gradio>=4.0.0
+pillow>=10.0.0
+opencv-python>=4.8.0
+supervision>=0.18.0
+psutil>=5.9.0
+numpy>=1.24.0
+imageio>=2.31.0
+imageio-ffmpeg>=0.4.8
+requests>=2.31.0