Create app.py

app.py

@@ -0,0 +1,235 @@
+import gradio as gr
+import torch
+from huggingface_hub import hf_hub_download
+from PIL import Image
+import numpy as np
+import traceback
+
+# Your model configuration
+MODEL_REPO = "AssanaliAidarkhan/Biomedclip"  # Your uploaded model
+MODEL_FILENAME = "pytorch_model.bin"  # The .pt file you uploaded
+
+# Global variables
+model = None
+
+def load_model():
+    """Load the BiodemCLIP model from your uploaded .pt file"""
+    global model
+    
+    try:
+        print(f"Downloading model from: {MODEL_REPO}")
+        
+        # Download your model file
+        model_path = hf_hub_download(
+            repo_id=MODEL_REPO,
+            filename=MODEL_FILENAME,
+            cache_dir="./model_cache"
+        )
+        
+        print(f"Model downloaded to: {model_path}")
+        
+        # Load the model
+        # Note: Adjust this based on how your model was saved
+        model = torch.load(model_path, map_location='cpu')
+        
+        # If your model was saved as a state dict, you might need:
+        # model = YourModelClass()  # Initialize your model architecture
+        # model.load_state_dict(torch.load(model_path, map_location='cpu'))
+        
+        # Set to evaluation mode
+        if hasattr(model, 'eval'):
+            model.eval()
+            
+        print("✓ Model loaded successfully!")
+        return True
+        
+    except Exception as e:
+        print(f"Error loading model: {e}")
+        print(traceback.format_exc())
+        return False
+
+def predict(image, text_query):
+    """Make prediction with your model"""
+    global model
+    
+    if model is None:
+        return "❌ Model not loaded! Please wait for initialization."
+    
+    if image is None:
+        return "❌ Please upload an image."
+    
+    if not text_query or text_query.strip() == "":
+        return "❌ Please enter a text query."
+    
+    try:
+        # Convert PIL image to tensor
+        if isinstance(image, Image.Image):
+            # Convert to RGB if not already
+            image = image.convert('RGB')
+            
+            # Convert to numpy array and then tensor
+            image_array = np.array(image)
+            
+            # Normalize pixel values to [0, 1]
+            image_tensor = torch.from_numpy(image_array).float() / 255.0
+            
+            # Rearrange dimensions from HWC to CHW
+            image_tensor = image_tensor.permute(2, 0, 1).unsqueeze(0)  # Add batch dimension
+        
+        # Process text (this is a basic tokenization - adjust based on your model)
+        # You might need to use a specific tokenizer here
+        text_tokens = text_query.lower().split()  # Basic tokenization
+        
+        # Run inference
+        with torch.no_grad():
+            try:
+                # This depends on your model's forward method
+                # You'll need to adjust this based on how your model expects inputs
+                
+                # Example approaches (try these and see which works):
+                
+                # Option 1: If your model has a forward method that takes image and text
+                if hasattr(model, 'forward'):
+                    output = model(image_tensor, text_query)
+                
+                # Option 2: If your model has separate encode methods
+                elif hasattr(model, 'encode_image') and hasattr(model, 'encode_text'):
+                    image_features = model.encode_image(image_tensor)
+                    text_features = model.encode_text(text_query)
+                    
+                    # Calculate similarity
+                    similarity = torch.cosine_similarity(image_features, text_features, dim=-1)
+                    output = similarity
+                
+                # Option 3: If it's a different architecture
+                else:
+                    # You might need to call your model differently
+                    # For example: output = model.predict(image_tensor, text_query)
+                    output = model(image_tensor)  # Adjust this line based on your model
+                
+                # Process the output
+                if torch.is_tensor(output):
+                    if output.numel() == 1:  # Single value (like similarity score)
+                        score = output.item()
+                    else:  # Multiple values
+                        score = torch.mean(output).item()  # Take mean as similarity
+                else:
+                    score = float(output) if isinstance(output, (int, float)) else 0.5
+                
+                result = f"""
+🎯 **Similarity Score:** {score:.4f}
+
+📝 **Query:** {text_query}
+
+🖼️ **Image Shape:** {image_array.shape}
+
+💡 **Interpretation:**
+{interpret_similarity(score)}
+
+🔧 **Model Info:** Loaded from {MODEL_REPO}
+                """
+                
+                return result
+                
+            except Exception as model_error:
+                return f"""
+❌ **Model Inference Error:**
+{str(model_error)}
+
+🔧 **Debug Info:**
+- Image shape: {image_array.shape}
+- Text query: "{text_query}"
+- Model type: {type(model)}
+
+💡 **Note:** You may need to adjust the inference code based on your specific model architecture.
+                """
+        
+    except Exception as e:
+        error_msg = f"❌ Error during prediction: {str(e)}"
+        print(traceback.format_exc())
+        return error_msg
+
+def interpret_similarity(score):
+    """Interpret the similarity score"""
+    if score >= 0.8:
+        return "🟢 Very high similarity - Strong match!"
+    elif score >= 0.6:
+        return "🟡 Good similarity - Reasonable match"
+    elif score >= 0.4:
+        return "🟠 Moderate similarity - Some relevance"
+    elif score >= 0.2:
+        return "🔴 Low similarity - Limited relevance"
+    else:
+        return "⚫ Very low similarity - Poor match"
+
+# Load model on startup
+print("Initializing BiodemCLIP model...")
+model_loaded = load_model()
+
+# Create Gradio interface
+with gr.Blocks(title="BiodemCLIP Demo", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🧬 BiodemCLIP Model Demo
+    
+    Upload a biomedical image and enter a text description to see how well they match!
+    
+    **Model:** AssanaliAidarkhan/Biomedclip
+    """)
+    
+    if not model_loaded:
+        gr.Markdown("⚠️ **Warning: Model failed to load. Check the logs for details.**")
+    else:
+        gr.Markdown("✅ **Model loaded successfully!**")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            image_input = gr.Image(
+                type="pil", 
+                label="📸 Upload Biomedical Image",
+                height=400
+            )
+            
+            text_input = gr.Textbox(
+                label="📝 Enter Text Query",
+                placeholder="e.g., 'chest X-ray showing pneumonia', 'normal tissue sample', etc.",
+                lines=3
+            )
+            
+            submit_btn = gr.Button("🔍 Analyze", variant="primary", size="lg")
+            clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+        
+        with gr.Column(scale=1):
+            output = gr.Markdown(label="📊 Results")
+    
+    # Event handlers
+    submit_btn.click(
+        fn=predict,
+        inputs=[image_input, text_input],
+        outputs=output
+    )
+    
+    clear_btn.click(
+        fn=lambda: [None, "", ""],
+        inputs=[],
+        outputs=[image_input, text_input, output]
+    )
+    
+    gr.Markdown("""
+    ### 📋 Instructions:
+    1. Upload a biomedical image (X-ray, MRI, microscopy, etc.)
+    2. Enter a descriptive text query
+    3. Click "Analyze" to get the similarity score
+    
+    ### ℹ️ About:
+    This model analyzes the similarity between biomedical images and text descriptions.
+    Higher scores indicate better matches between the image and text.
+    
+    ### 🔧 Technical Notes:
+    - Model loaded from Hugging Face Hub
+    - Runs on CPU (may be slower for large images)
+    - Custom .pt model loading
+    """)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()