Update app.py

app.py

@@ -1,84 +1,68 @@
 #!/usr/bin/env python3
 """
-Qwen-VL Medical Image Analysis - Gradio Interface for Hugging Face Spaces
-Optimized for Hugging Face deployment with efficient resource usage
+Gemini Vision Pro Medical Image Analysis - Gradio Interface
+Lightweight alternative using Google's Gemini Vision Pro API
 """
 
 import gradio as gr
-import torch
-from transformers import Qwen2_5_VLForConditionalGeneration, AutoTokenizer, AutoProcessor
-from qwen_vl_utils import process_vision_info
+import google.generativeai as genai
 from PIL import Image
 import json
 import time
 import os
 from typing import Dict, List, Optional, Tuple
+import base64
+import io
 import warnings
 warnings.filterwarnings("ignore")
 
-# Global variables for model caching
-MODEL = None
-PROCESSOR = None
-DEVICE = None
+# Global configuration
+GEMINI_MODEL = None
+API_KEY = None
 
-os.environ['TOKENIZERS_PARALLELISM'] = 'false'
-os.environ['TRANSFORMERS_CACHE'] = '/tmp/transformers_cache'
-
-def get_device():
-    """Determine the best available device"""
-    if torch.cuda.is_available():
-        return "cuda"
+def setup_gemini(api_key: str = None):
+    """Setup Gemini Vision Pro with API key"""
+    global GEMINI_MODEL, API_KEY
+    
+    # Try to get API key from environment or parameter
+    if api_key:
+        API_KEY = api_key
     else:
-        return "cpu"
-
-def load_model_cached(model_name: str = "Qwen/Qwen2-VL-2B-Instruct"):
-    """Load and cache model - optimized for HF Spaces"""
-    global MODEL, PROCESSOR, DEVICE
+        API_KEY = os.getenv('GOOGLE_API_KEY') or os.getenv('GEMINI_API_KEY')
+    
+    if not API_KEY:
+        return False, "❌ No API key provided. Please set GOOGLE_API_KEY environment variable or enter it in the interface."
     
-    if MODEL is None:
-        print(f"Loading {model_name}...")
-        DEVICE = get_device()
-        print(f"Using device: {DEVICE}")
+    try:
+        # Configure the API
+        genai.configure(api_key=API_KEY)
         
-        try:
-            # Load with memory optimization for HF Spaces
-            MODEL = Qwen2_5_VLForConditionalGeneration.from_pretrained(
-                model_name,
-                torch_dtype='auto',
-                device_map="auto" if DEVICE == "cuda" else None,
-                trust_remote_code=True,
-                attn_implementation="eager",  # More stable for HF Spaces
-                low_cpu_mem_usage=True
-            )
-            
-            PROCESSOR = AutoProcessor.from_pretrained(
-                model_name,
-                trust_remote_code=True
-            )
-            
-            if DEVICE == "cpu":
-                MODEL = MODEL.to(DEVICE)
-                
-            print("Model loaded successfully!")
-            return True
+        # Initialize the model
+        GEMINI_MODEL = genai.GenerativeModel('gemini-1.5-pro')
+        
+        # Test the connection
+        test_response = GEMINI_MODEL.generate_content("Hello, can you help with medical image analysis?")
+        
+        if test_response and test_response.text:
+            return True, "✅ Gemini Vision Pro connected successfully!"
+        else:
+            return False, "❌ Failed to connect to Gemini API"
             
-        except Exception as e:
-            print(f"Error loading model: {str(e)}")
-            return False
-    
-    return True
+    except Exception as e:
+        return False, f"❌ Gemini setup failed: {str(e)}"
 
 def create_medical_prompt(clinical_data: Dict, analysis_type: str, focus_areas: str) -> str:
-    """Create optimized medical analysis prompt"""
+    """Create optimized medical analysis prompt for Gemini"""
     
-    base_prompt = """You are an expert medical AI assistant specializing in medical image analysis with training across radiology, pathology, dermatology, and clinical medicine.
+    base_prompt = """You are an expert medical AI assistant specializing in medical image analysis. You have extensive training across radiology, pathology, dermatology, ophthalmology, and clinical medicine.
 
 **ANALYSIS INSTRUCTIONS:**
-Provide a systematic, professional medical image analysis following these guidelines:
-- Use clear medical terminology with explanations
-- Structure your response with clear sections
+Analyze this medical image systematically and professionally:
+- Use clear medical terminology with explanations for complex terms
+- Structure your response with clear sections and headers
 - Be thorough but concise
-- Always mention limitations and need for professional consultation
+- Always mention limitations and emphasize the need for professional medical consultation
+- Focus on observable findings rather than definitive diagnoses
 """
     
     # Add clinical context if provided
@@ -86,51 +70,94 @@ Provide a systematic, professional medical image analysis following these guidel
     if clinical_data and any(v.strip() for v in clinical_data.values() if v):
         clinical_context = "\n**CLINICAL CONTEXT:**\n"
         context_items = []
-        if clinical_data.get("age"): context_items.append(f"Age: {clinical_data['age']}")
+        if clinical_data.get("age"): context_items.append(f"Patient Age: {clinical_data['age']}")
         if clinical_data.get("gender"): context_items.append(f"Gender: {clinical_data['gender']}")
-        if clinical_data.get("symptoms"): context_items.append(f"Symptoms: {clinical_data['symptoms']}")
-        if clinical_data.get("history"): context_items.append(f"History: {clinical_data['history']}")
-        if clinical_data.get("medications"): context_items.append(f"Medications: {clinical_data['medications']}")
+        if clinical_data.get("symptoms"): context_items.append(f"Presenting Symptoms: {clinical_data['symptoms']}")
+        if clinical_data.get("history"): context_items.append(f"Medical History: {clinical_data['history']}")
+        if clinical_data.get("medications"): context_items.append(f"Current Medications: {clinical_data['medications']}")
         
         clinical_context += "\n".join(f"• {item}" for item in context_items) + "\n"
     
     # Analysis type specific instructions
     analysis_instructions = {
         "Comprehensive": """
-**PROVIDE COMPREHENSIVE ANALYSIS:**
-1. **Image Description**: Type, quality, anatomical structures visible
-2. **Clinical Findings**: Normal and abnormal observations
-3. **Interpretation**: Clinical significance and differential diagnosis
-4. **Recommendations**: Next steps and follow-up suggestions
-5. **Limitations**: What cannot be determined from this image alone
+**PROVIDE COMPREHENSIVE ANALYSIS WITH THESE SECTIONS:**
+
+## 1. IMAGE ASSESSMENT
+- Image type, quality, and technical adequacy
+- Anatomical structures and regions visible
+- Any artifacts or limitations
+
+## 2. CLINICAL FINDINGS
+- Normal anatomical structures observed
+- Abnormal findings or variations from normal
+- Specific measurements or quantitative observations if applicable
+
+## 3. CLINICAL INTERPRETATION
+- Significance of the findings
+- Differential diagnostic considerations
+- Correlation with provided clinical history
+
+## 4. RECOMMENDATIONS
+- Suggested next steps or additional imaging
+- Clinical correlation recommendations
+- Follow-up suggestions
+
+## 5. LIMITATIONS & DISCLAIMERS
+- What cannot be determined from this image alone
+- Need for clinical correlation and professional evaluation
 """,
         "Quick Assessment": """
-**PROVIDE QUICK ASSESSMENT:**
-1. **Key Findings**: Most important observations
-2. **Clinical Impression**: Primary diagnostic considerations
-3. **Urgent Concerns**: Any findings requiring immediate attention
-4. **Next Steps**: Essential recommendations
+**PROVIDE FOCUSED QUICK ASSESSMENT:**
+
+## KEY FINDINGS
+- Most significant observations
+- Normal vs abnormal structures
+
+## CLINICAL IMPRESSION
+- Primary considerations based on image
+- Any urgent findings that require immediate attention
+
+## IMMEDIATE RECOMMENDATIONS
+- Essential next steps
+- Urgency level assessment
+
+## LIMITATIONS
+- Important caveats about this assessment
 """,
         "Educational": """
 **PROVIDE EDUCATIONAL ANALYSIS:**
-1. **Learning Points**: Key educational aspects of this case
-2. **Normal vs Abnormal**: Clear explanation of findings
-3. **Clinical Correlation**: How image relates to symptoms/history
-4. **Teaching Insights**: Important concepts demonstrated
+
+## LEARNING OBJECTIVES
+- Key educational points from this case
+- Important anatomical or pathological concepts
+
+## NORMAL vs ABNORMAL
+- Clear explanation of what's normal in this image
+- Detailed description of any abnormal findings
+
+## CLINICAL CORRELATION
+- How image findings relate to symptoms/history
+- Real-world clinical significance
+
+## TEACHING PEARLS
+- Important concepts this case demonstrates
+- Common pitfalls or considerations
 """
     }
     
     focus_instruction = ""
     if focus_areas and focus_areas.strip():
-        focus_instruction = f"\n**SPECIAL FOCUS**: Pay particular attention to: {focus_areas}\n"
+        focus_instruction = f"\n**SPECIAL FOCUS AREAS**: Pay particular attention to: {focus_areas}\n"
     
     disclaimer = """
-**MEDICAL DISCLAIMER**: This AI analysis is for educational purposes only. Always consult qualified healthcare professionals for medical diagnosis and treatment decisions.
+**IMPORTANT MEDICAL DISCLAIMER**: 
+This AI-powered analysis is for educational and research purposes only. It should never replace professional medical diagnosis, treatment, or consultation with qualified healthcare providers. Always seek professional medical advice for any health concerns or medical decisions.
 """
     
     return base_prompt + clinical_context + analysis_instructions.get(analysis_type, analysis_instructions["Comprehensive"]) + focus_instruction + disclaimer
 
-def analyze_medical_image(
+def analyze_medical_image_gemini(
     image: Image.Image,
     age: str,
     gender: str,
@@ -139,17 +166,19 @@ def analyze_medical_image(
     medications: str,
     analysis_type: str,
     focus_areas: str,
+    api_key: str,
     progress=gr.Progress()
-) -> Tuple[str, str]:
-    """Main analysis function for Gradio interface"""
+) -> Tuple[str, str, str]:
+    """Main analysis function using Gemini Vision Pro"""
     
     if image is None:
-        return "❌ Please upload an image first.", ""
+        return "❌ Please upload an image first.", "", "❌ No image provided"
     
-    # Load model if needed
-    progress(0.1, desc="Loading model...")
-    if not load_model_cached():
-        return "❌ Failed to load model. Please try again.", ""
+    # Setup Gemini if needed
+    progress(0.1, desc="Connecting to Gemini...")
+    success, status = setup_gemini(api_key)
+    if not success:
+        return status, "", status
     
     try:
         progress(0.3, desc="Preparing analysis...")
@@ -166,110 +195,104 @@ def analyze_medical_image(
         # Create prompt
         prompt = create_medical_prompt(clinical_data, analysis_type, focus_areas)
         
-        progress(0.5, desc="Processing image...")
-        
-        # Prepare messages for model
-        messages = [
-            {
-                "role": "user",
-                "content": [
-                    {"type": "image", "image": image},
-                    {"type": "text", "text": prompt}
-                ]
-            }
-        ]
-        
-        # Process inputs
-        text = PROCESSOR.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-        image_inputs, video_inputs = process_vision_info(messages)
-        
-        inputs = PROCESSOR(
-            text=[text],
-            images=image_inputs,
-            videos=video_inputs,
-            padding=True,
-            return_tensors="pt",
-        )
-        
-        inputs = inputs.to(DEVICE)
-        
-        progress(0.7, desc="Generating analysis...")
-        
-        # Generate response with optimized parameters for HF Spaces
-        with torch.no_grad():
-            generated_ids = MODEL.generate(
-                **inputs,
-                max_new_tokens=1024,  # Reduced for faster processing
-                do_sample=True,
-                temperature=0.3,
-                top_p=0.8,
-                repetition_penalty=1.1,
-                pad_token_id=PROCESSOR.tokenizer.eos_token_id,
-                eos_token_id=PROCESSOR.tokenizer.eos_token_id,
-            )
+        progress(0.5, desc="Analyzing image with Gemini...")
         
-        generated_ids_trimmed = [
-            out_ids[len(in_ids):] 
-            for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
-        ]
+        # Generate analysis using Gemini Vision Pro
+        response = GEMINI_MODEL.generate_content([prompt, image])
         
-        response = PROCESSOR.batch_decode(
-            generated_ids_trimmed, 
-            skip_special_tokens=True, 
-            clean_up_tokenization_spaces=False
-        )[0]
+        if not response or not response.text:
+            return "❌ No response received from Gemini API", "", "❌ Analysis failed"
         
-        progress(1.0, desc="Analysis complete!")
+        progress(0.9, desc="Preparing results...")
         
         # Create download content
         report_data = {
             "timestamp": time.strftime("%Y-%m-%d %H:%M:%S UTC"),
-            "model": "Qwen2.5-VL-3B-Instruct",
+            "model": "Google Gemini-1.5-Pro Vision",
             "analysis_type": analysis_type,
             "clinical_data": clinical_data,
             "focus_areas": focus_areas,
-            "analysis": response
+            "analysis": response.text
         }
         
         download_content = json.dumps(report_data, indent=2)
         
-        return response, download_content
+        progress(1.0, desc="Analysis complete!")
+        
+        return response.text, download_content, "✅ Analysis completed successfully"
         
     except Exception as e:
-        return f"❌ Analysis failed: {str(e)}\n\nPlease try again or contact support.", ""
+        error_msg = f"❌ Analysis failed: {str(e)}"
+        if "API_KEY" in str(e):
+            error_msg += "\n\n💡 Tip: Make sure your Google API key is valid and has access to Gemini API"
+        elif "quota" in str(e).lower():
+            error_msg += "\n\n💡 Tip: You may have exceeded your API quota. Check your Google Cloud Console"
+        elif "safety" in str(e).lower():
+            error_msg += "\n\n💡 Tip: The image may have been blocked by safety filters. Try a different medical image"
+        
+        return error_msg, "", error_msg
 
 def create_interface():
-    """Create the Gradio interface"""
+    """Create the Gradio interface for Gemini Vision Pro"""
     
     # Custom CSS for medical theme
     css = """
     .gradio-container {
-        max-width: 1200px !important;
+        max-width: 1400px !important;
     }
     .medical-header {
         text-align: center;
-        color: #2c5aa0;
+        color: #1a73e8;
         margin-bottom: 20px;
     }
-    .clinical-section {
-        background-color: #f8f9fa;
+    .api-section {
+        background-color: #e8f0fe;
         padding: 15px;
         border-radius: 8px;
         margin: 10px 0;
+        border-left: 4px solid #1a73e8;
+    }
+    .status-success {
+        color: #137333;
+        font-weight: 500;
+    }
+    .status-error {
+        color: #d93025;
+        font-weight: 500;
     }
     """
     
-    with gr.Blocks(css=css, theme=gr.themes.Soft(), title="Medical AI Analyzer") as interface:
+    with gr.Blocks(css=css, theme=gr.themes.Soft(), title="Gemini Medical AI") as interface:
         
         # Header
         gr.HTML("""
         <div class="medical-header">
             <h1>🏥 Medical Image AI Analyzer</h1>
-            <h3>Advanced Medical Image Analysis using Qwen-VL</h3>
-            <p><em>Upload medical images and provide clinical context for AI-powered analysis</em></p>
+            <h2>🤖 Powered by Google Gemini Vision Pro</h2>
+            <p><em>Fast, efficient medical image analysis using Google's latest AI</em></p>
         </div>
         """)
         
+        # API Configuration Section
+        with gr.Accordion("🔑 API Configuration", open=True):
+            gr.Markdown("""
+            ### Google Gemini API Setup
+            You need a Google API key to use Gemini Vision Pro. Get one from [Google AI Studio](https://makersuite.google.com/app/apikey).
+            """)
+            
+            api_key_input = gr.Textbox(
+                label="Google API Key",
+                type="password",
+                placeholder="Enter your Google API key here...",
+                info="Your API key is not stored and only used for this session"
+            )
+            
+            status_display = gr.Textbox(
+                label="Connection Status",
+                value="⏳ Enter API key to connect",
+                interactive=False
+            )
+        
         with gr.Row():
             # Left column - Inputs
             with gr.Column(scale=1):
@@ -279,10 +302,10 @@ def create_interface():
                     type="pil",
                     label="Medical Image",
                     height=300,
-                    sources=["upload", "clipboard"]
+                    sources=["upload", "clipboard", "webcam"]
                 )
                 
-                gr.Markdown("*Supported: X-rays, CT, MRI, photographs, microscopy, etc.*")
+                gr.Markdown("*Supported: X-rays, CT, MRI, photographs, microscopy, dermatology images, etc.*")
                 
                 gr.Markdown("## 📋 Clinical Information")
                 
@@ -328,12 +351,12 @@ def create_interface():
                 
                 focus_areas = gr.Textbox(
                     label="Focus Areas (Optional)",
-                    placeholder="e.g., cardiac, pulmonary, neurological",
+                    placeholder="e.g., cardiac silhouette, lung fields, bone density",
                     info="Specific areas to emphasize in analysis"
                 )
                 
                 analyze_btn = gr.Button(
-                    "🔬 Analyze Medical Image",
+                    "🔬 Analyze with Gemini",
                     variant="primary",
                     size="lg"
                 )
@@ -344,8 +367,8 @@ def create_interface():
                 
                 analysis_output = gr.Textbox(
                     label="Medical Analysis",
-                    lines=20,
-                    max_lines=30,
+                    lines=25,
+                    max_lines=35,
                     show_copy_button=True,
                     placeholder="Analysis results will appear here after processing..."
                 )
@@ -358,33 +381,49 @@ def create_interface():
                 # Hidden component to store download content
                 download_content = gr.Textbox(visible=False)
         
-        # Example section
-        with gr.Accordion("💡 Example Use Cases & Tips", open=False):
+        # Information sections
+        with gr.Accordion("💡 About Gemini Vision Pro", open=False):
             gr.Markdown("""
+            ### 🚀 **Advantages of Gemini Vision Pro:**
+            - **Fast Processing**: No local model loading - results in seconds
+            - **Low Resource Usage**: Runs via API calls, minimal local computing needed
+            - **High Quality**: Google's latest multimodal AI model
+            - **Always Updated**: Access to the latest model improvements
+            - **Reliable**: Enterprise-grade infrastructure
+            
             ### 🔍 **Supported Medical Images:**
             - **Radiology**: X-rays, CT scans, MRI images, Ultrasound
-            - **Pathology**: Histological slides, Cytology specimens
+            - **Pathology**: Histological slides, Cytology specimens  
             - **Dermatology**: Skin lesions, Rashes, Clinical photos
             - **Ophthalmology**: Fundus photos, OCT images
             - **Clinical Photography**: Wound assessment, Physical findings
+            - **Microscopy**: Cellular and tissue analysis
             
-            ### 📝 **Tips for Better Analysis:**
-            - **Provide clinical context**: Age, symptoms, and history improve accuracy
-            - **Use specific focus areas**: "cardiac silhouette, lung fields" vs just "chest"
-            - **Choose appropriate analysis type**: Comprehensive for complex cases, Quick for screening
-            - **High-quality images**: Clear, well-lit images produce better results
+            ### 💰 **Cost Information:**
+            - Gemini Vision Pro uses pay-per-use pricing
+            - Typically very affordable for individual analyses
+            - Check [Google AI Pricing](https://ai.google.dev/pricing) for current rates
+            """)
+        
+        with gr.Accordion("📝 Tips for Better Results", open=False):
+            gr.Markdown("""
+            ### 🎯 **Optimization Tips:**
+            - **Provide clinical context**: Age, symptoms, and history significantly improve accuracy
+            - **Use specific focus areas**: "cardiac silhouette, pulmonary vessels" vs just "chest"
+            - **High-quality images**: Clear, well-lit, properly oriented images work best
+            - **Appropriate image size**: Gemini works well with various image sizes
+            - **Choose right analysis type**: Comprehensive for complex cases, Quick for screening
             
-            ### ⚠️ **Important Limitations:**
-            - This AI tool is for educational and research purposes only
-            - Always consult qualified healthcare professionals for medical decisions
-            - AI cannot replace clinical expertise and physical examination
-            - Results should be validated by medical professionals
+            ### 🔐 **API Key Security:**
+            - Your API key is only used for this session and not stored
+            - Consider using environment variables for production deployments
+            - Monitor your API usage in Google Cloud Console
             """)
         
         # Footer
         gr.HTML("""
         <div style="text-align: center; margin-top: 20px; padding: 15px; background-color: #fff3cd; border-radius: 8px;">
-            <strong>⚠️ Medical Disclaimer:</strong> This AI tool is for educational purposes only. 
+            <strong>⚠️ Medical Disclaimer:</strong> This AI tool is for educational and research purposes only. 
             It should never replace professional medical diagnosis or treatment. 
             Always consult qualified healthcare providers for medical decisions.
         </div>
@@ -393,19 +432,33 @@ def create_interface():
         # Event handlers
         def create_download_file(content):
             if content:
-                filename = f"medical_analysis_{int(time.time())}.json"
+                filename = f"gemini_medical_analysis_{int(time.time())}.json"
                 with open(filename, "w") as f:
                     f.write(content)
                 return gr.File(value=filename, visible=True)
             return gr.File(visible=False)
         
+        def test_api_connection(api_key):
+            if not api_key:
+                return "⏳ Enter API key to connect"
+            success, status = setup_gemini(api_key)
+            return status
+        
+        # API key testing
+        api_key_input.change(
+            fn=test_api_connection,
+            inputs=[api_key_input],
+            outputs=[status_display]
+        )
+        
+        # Main analysis
         analyze_btn.click(
-            fn=analyze_medical_image,
+            fn=analyze_medical_image_gemini,
             inputs=[
                 image_input, age_input, gender_input, symptoms_input,
-                history_input, medications_input, analysis_type, focus_areas
+                history_input, medications_input, analysis_type, focus_areas, api_key_input
             ],
-            outputs=[analysis_output, download_content]
+            outputs=[analysis_output, download_content, status_display]
         ).then(
             fn=create_download_file,
             inputs=[download_content],
@@ -415,61 +468,17 @@ def create_interface():
     return interface
 
 if __name__ == "__main__":
-    # Pre-load model to reduce first-run latency
-    print("Initializing Medical AI Analyzer...")
-    load_model_cached()
+    print("🏥 Initializing Gemini Medical AI Analyzer...")
+    print("🚀 No local model loading required - using Google Gemini Vision Pro API")
     
     # Create and launch interface
     interface = create_interface()
     
-    # Launch with settings optimized for HF Spaces
+    # Launch with optimized settings
     interface.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
         show_error=True,
         quiet=False
-    )
-
-"""
-HUGGING FACE SPACE CONFIGURATION:
-
-1. Create requirements.txt:
-torch
-torchvision
-transformers>=4.37.0
-accelerate
-pillow
-gradio
-qwen-vl-utils
-spaces
-
-2. Create app.py (this file)
-
-3. Create README.md:
----
-title: Medical Image AI Analyzer
-emoji: 🏥
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 4.44.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-4. Optional - Create .gitattributes:
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-
-DEPLOYMENT FEATURES:
-✅ Optimized for Hugging Face Spaces
-✅ Efficient memory usage
-✅ Progress indicators
-✅ Professional medical interface
-✅ Download analysis reports
-✅ Mobile-responsive design
-✅ Error handling and validation
-✅ Medical disclaimer compliance
-"""
+    )