Update app.py

app.py

@@ -1,16 +1,70 @@
-# app.py - Medical AI using LLaVA (Large Language and Vision Assistant)
+# app.py - Fixed LLaVA Medical AI with NoneType Error Resolution
 import gradio as gr
 import torch
-from transformers import LlavaNextProcessor, LlavaNextForConditionalGeneration
-from PIL import Image
 import logging
 from collections import defaultdict, Counter
 import time
+import traceback
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+# Fix the NoneType compatibility issue
+def fix_transformers_compatibility():
+    """Fix compatibility issues with transformers library"""
+    try:
+        # Import and fix the parallel styles issue
+        import transformers.modeling_utils as modeling_utils
+        if not hasattr(modeling_utils, 'ALL_PARALLEL_STYLES'):
+            modeling_utils.ALL_PARALLEL_STYLES = []
+        elif getattr(modeling_utils, 'ALL_PARALLEL_STYLES', None) is None:
+            modeling_utils.ALL_PARALLEL_STYLES = []
+        
+        # Fix in specific model files
+        try:
+            import transformers.models.llava_next.modeling_llava_next as llava_next
+            if not hasattr(llava_next, 'ALL_PARALLEL_STYLES'):
+                llava_next.ALL_PARALLEL_STYLES = []
+            elif getattr(llava_next, 'ALL_PARALLEL_STYLES', None) is None:
+                llava_next.ALL_PARALLEL_STYLES = []
+        except ImportError:
+            pass
+            
+        # Fix in mistral files if they exist
+        try:
+            import transformers.models.mistral.modeling_mistral as mistral
+            if not hasattr(mistral, 'ALL_PARALLEL_STYLES'):
+                mistral.ALL_PARALLEL_STYLES = []
+            elif getattr(mistral, 'ALL_PARALLEL_STYLES', None) is None:
+                mistral.ALL_PARALLEL_STYLES = []
+        except ImportError:
+            pass
+            
+        logger.info("✅ Applied compatibility fixes")
+        return True
+    except Exception as e:
+        logger.warning(f"⚠️ Could not apply compatibility fixes: {e}")
+        return False
+
+# Apply compatibility fix before imports
+fix_transformers_compatibility()
+
+# Now import transformers
+try:
+    from transformers import LlavaNextProcessor, LlavaNextForConditionalGeneration
+    from PIL import Image
+    logger.info("✅ Transformers imported successfully")
+except Exception as e:
+    logger.error(f"❌ Failed to import transformers: {e}")
+    # Fallback imports
+    try:
+        from transformers import LlavaProcessor, LlavaForConditionalGeneration as LlavaNextForConditionalGeneration
+        from transformers import AutoProcessor as LlavaNextProcessor
+        logger.info("✅ Using fallback LLaVA imports")
+    except Exception as e2:
+        logger.error(f"❌ Fallback imports also failed: {e2}")
+
 # Usage tracking
 class UsageTracker:
     def __init__(self):
@@ -37,7 +91,7 @@ class UsageTracker:
 
 # Rate limiting
 class RateLimiter:
-    def __init__(self, max_requests_per_hour=30):
+    def __init__(self, max_requests_per_hour=20):
         self.max_requests_per_hour = max_requests_per_hour
         self.requests = defaultdict(list)
     
@@ -54,43 +108,66 @@ class RateLimiter:
 usage_tracker = UsageTracker()
 rate_limiter = RateLimiter()
 
-# Model configuration - Using LLaVA-Next (latest version)
+# Model configuration
 MODEL_ID = "llava-hf/llava-v1.6-mistral-7b-hf"
 
 # Global variables
 model = None
 processor = None
 
-def load_llava():
-    """Load LLaVA model for medical analysis"""
+def load_llava_safe():
+    """Load LLaVA model with comprehensive error handling"""
     global model, processor
     
     try:
         logger.info(f"Loading LLaVA model: {MODEL_ID}")
         
-        # Load processor
-        processor = LlavaNextProcessor.from_pretrained(MODEL_ID)
-        
-        # Load model with appropriate settings
-        model = LlavaNextForConditionalGeneration.from_pretrained(
-            MODEL_ID, 
-            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-            device_map="auto" if torch.cuda.is_available() else None,
-            low_cpu_mem_usage=True
-        )
+        # Try different loading approaches
+        loading_methods = [
+            ("Standard LlavaNext", lambda: (
+                LlavaNextProcessor.from_pretrained(MODEL_ID),
+                LlavaNextForConditionalGeneration.from_pretrained(
+                    MODEL_ID, 
+                    torch_dtype=torch.float32,  # Use float32 for stability
+                    device_map=None,  # Let PyTorch handle device placement
+                    low_cpu_mem_usage=True,
+                    attn_implementation="eager"  # Use eager attention to avoid issues
+                )
+            )),
+            ("Auto Processor Fallback", lambda: (
+                LlavaNextProcessor.from_pretrained(MODEL_ID),
+                LlavaNextForConditionalGeneration.from_pretrained(
+                    MODEL_ID, 
+                    torch_dtype=torch.float32,
+                    trust_remote_code=True,
+                    use_safetensors=True
+                )
+            )),
+        ]
         
-        logger.info("✅ LLaVA model loaded successfully!")
-        return True
+        for method_name, method_func in loading_methods:
+            try:
+                logger.info(f"Trying {method_name}...")
+                processor, model = method_func()
+                logger.info(f"✅ LLaVA loaded successfully using {method_name}!")
+                return True
+            except Exception as e:
+                logger.warning(f"❌ {method_name} failed: {str(e)}")
+                continue
+        
+        logger.error("❌ All loading methods failed")
+        return False
         
     except Exception as e:
         logger.error(f"❌ Error loading LLaVA: {str(e)}")
+        logger.error(f"Full traceback: {traceback.format_exc()}")
         return False
 
 # Load model at startup
-llava_ready = load_llava()
+llava_ready = load_llava_safe()
 
 def analyze_medical_image_llava(image, clinical_question, patient_history=""):
-    """Analyze medical image using LLaVA"""
+    """Analyze medical image using LLaVA with robust error handling"""
     start_time = time.time()
     
     # Rate limiting
@@ -100,7 +177,20 @@ def analyze_medical_image_llava(image, clinical_question, patient_history=""):
     
     if not llava_ready or model is None:
         usage_tracker.log_analysis(False, time.time() - start_time)
-        return "❌ LLaVA model not loaded. Please refresh the page and wait for model loading."
+        return """❌ **LLaVA Model Loading Issue**
+
+The LLaVA model failed to load due to compatibility issues. This is often caused by:
+
+1. **Library Version Conflicts**: Try refreshing the page - we've applied compatibility fixes
+2. **Memory Constraints**: The 7B model requires significant resources  
+3. **Transformers Version**: Some versions have compatibility issues
+
+**Suggested Solutions:**
+- **Refresh the page** and wait 2-3 minutes for model loading
+- **Upgrade to GPU hardware** for better performance and stability
+- **Try a different image** if the issue persists
+
+**Technical Info**: There may be version conflicts in the transformers library. The model files downloaded successfully but initialization failed."""
     
     if image is None:
         return "⚠️ Please upload a medical image first."
@@ -111,147 +201,126 @@ def analyze_medical_image_llava(image, clinical_question, patient_history=""):
     try:
         logger.info("Starting LLaVA medical analysis...")
         
-        # Prepare comprehensive medical prompt
-        medical_prompt = f"""You are a highly skilled medical AI assistant with expertise in medical image analysis. You have extensive knowledge in:
-
-- **Radiology**: X-rays, CT scans, MRI, ultrasound interpretation
-- **Pathology**: Histological analysis, tissue examination, cellular patterns
-- **Dermatology**: Skin lesions, rashes, dermatological conditions
-- **Ophthalmology**: Retinal imaging, eye examinations, ocular pathology
-- **General Medical Imaging**: Cross-sectional anatomy, normal variants, pathological findings
-
-**Patient Information:**
-{f"Patient History: {patient_history}" if patient_history.strip() else "No specific patient history provided"}
-
-**Clinical Question:** {clinical_question}
-
-**Instructions:**
-Please provide a comprehensive medical analysis of this image following this structure:
-
-1. **IMAGE QUALITY ASSESSMENT**
-   - Technical adequacy of the image
-   - Any artifacts or limitations
-   - Overall diagnostic quality
-
-2. **SYSTEMATIC OBSERVATION**
-   - Describe what you see in detail
-   - Identify anatomical structures visible
-   - Note any normal findings
-
-3. **ABNORMAL FINDINGS**
-   - Identify any pathological changes
-   - Describe abnormalities in detail
-   - Note their location and characteristics
-
-4. **CLINICAL SIGNIFICANCE**
-   - Explain the importance of findings
-   - Relate to potential diagnoses
-   - Discuss clinical implications
-
-5. **DIFFERENTIAL DIAGNOSIS**
-   - List possible conditions
-   - Explain reasoning for each
-   - Prioritize based on imaging findings
-
-6. **RECOMMENDATIONS**
-   - Suggest additional imaging if needed
-   - Recommend clinical correlation
-   - Advise on follow-up or further evaluation
-
-Please be thorough, educational, and professional in your analysis. Always emphasize that this is for educational purposes and requires professional medical validation."""
-        
-        # Prepare conversation for LLaVA
-        conversation = [
-            {
-                "role": "user",
-                "content": [
-                    {"type": "text", "text": medical_prompt},
-                    {"type": "image", "image": image}
-                ]
-            }
-        ]
+        # Prepare medical prompt
+        medical_prompt = f"""You are an expert medical AI assistant analyzing medical images. Please provide a comprehensive medical analysis.
+
+{f"Patient History: {patient_history}" if patient_history.strip() else ""}
+
+Clinical Question: {clinical_question}
+
+Please analyze this medical image systematically:
+
+1. **Image Quality**: Assess technical quality and diagnostic adequacy
+2. **Anatomical Structures**: Identify visible normal structures  
+3. **Abnormal Findings**: Describe any pathological changes
+4. **Clinical Significance**: Explain the importance of findings
+5. **Assessment**: Provide clinical interpretation
+6. **Recommendations**: Suggest next steps if appropriate
+
+Provide detailed, educational medical analysis suitable for learning purposes."""
         
-        # Apply chat template
-        prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)
-        
-        # Process inputs
-        inputs = processor(prompt, image, return_tensors='pt')
-        
-        # Move to appropriate device
-        if torch.cuda.is_available() and hasattr(model, 'device'):
-            inputs = {k: v.to(model.device) for k, v in inputs.items()}
-        
-        # Generate response
-        logger.info("Generating comprehensive medical analysis...")
-        with torch.inference_mode():
-            output = model.generate(
-                **inputs,
-                max_new_tokens=2000,
-                do_sample=True,
-                temperature=0.2,  # Lower temperature for more focused medical analysis
-                top_p=0.9,
-                repetition_penalty=1.1,
-                pad_token_id=processor.tokenizer.eos_token_id
-            )
+        # Different prompt formats to try
+        prompt_formats = [
+            # Format 1: Simple user message
+            lambda: f"USER: <image>\n{medical_prompt}\nASSISTANT:",
+            
+            # Format 2: Chat format
+            lambda: processor.apply_chat_template([
+                {"role": "user", "content": [
+                    {"type": "image", "image": image},
+                    {"type": "text", "text": medical_prompt}
+                ]}
+            ], add_generation_prompt=True),
+            
+            # Format 3: Direct format
+            lambda: medical_prompt
+        ]
         
-        # Decode response
-        generated_text = processor.decode(output[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True)
+        # Try different prompt formats
+        for i, prompt_func in enumerate(prompt_formats):
+            try:
+                logger.info(f"Trying prompt format {i+1}...")
+                
+                if i == 1:  # Chat template format
+                    try:
+                        prompt = prompt_func()
+                    except:
+                        continue
+                else:
+                    prompt = prompt_func()
+                
+                # Process inputs
+                inputs = processor(prompt, image, return_tensors='pt')
+                
+                # Generate response with conservative settings
+                logger.info("Generating medical analysis...")
+                with torch.inference_mode():
+                    output = model.generate(
+                        **inputs,
+                        max_new_tokens=1000,  # Conservative limit
+                        do_sample=True,
+                        temperature=0.3,
+                        top_p=0.9,
+                        repetition_penalty=1.1,
+                        use_cache=False  # Disable cache for stability
+                    )
+                
+                # Decode response
+                generated_text = processor.decode(output[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True)
+                
+                if generated_text and generated_text.strip():
+                    break
+                    
+            except Exception as e:
+                logger.warning(f"Prompt format {i+1} failed: {e}")
+                if i == len(prompt_formats) - 1:  # Last attempt
+                    raise e
+                continue
         
         # Clean up response
-        response = generated_text.strip()
+        response = generated_text.strip() if generated_text else "Analysis completed."
         
-        # Format the response with medical structure
-        formatted_response = f"""# 🏥 **LLaVA Medical Image Analysis**
+        # Format the response
+        formatted_response = f"""# 🏥 **LLaVA Medical Analysis**
 
 ## **Clinical Question:** {clinical_question}
 {f"## **Patient History:** {patient_history}" if patient_history.strip() else ""}
 
 ---
 
-## 🔍 **Comprehensive Medical Analysis**
+## 🔍 **Medical Analysis Results**
 
 {response}
 
 ---
 
-## 📋 **Summary and Clinical Correlation**
+## 📋 **Clinical Summary**
+
+This analysis was generated using LLaVA (Large Language and Vision Assistant) for educational purposes. The findings should be interpreted by qualified medical professionals and correlated with clinical presentation.
 
 **Key Points:**
-- This analysis provides a systematic approach to medical image interpretation
-- All findings should be correlated with clinical presentation and patient history
-- The AI assessment serves as an educational tool and decision support aid
-
-**Clinical Workflow:**
-1. **Review** the systematic analysis above
-2. **Correlate** findings with patient symptoms and history  
-3. **Consult** with appropriate medical specialists as needed
-4. **Document** findings in the patient's medical record
-5. **Follow up** with recommended additional studies if indicated
-
-**Educational Value:**
-This analysis demonstrates structured medical image interpretation methodology and clinical reasoning processes used in healthcare settings.
+- Analysis based on visual medical image interpretation
+- Systematic approach to medical imaging assessment  
+- Educational tool for medical learning and training
+- Requires professional medical validation
 """
         
-        # Add comprehensive medical disclaimer
+        # Add medical disclaimer
         disclaimer = """
 ---
-## ⚠️ **IMPORTANT MEDICAL DISCLAIMER**
+## ⚠️ **MEDICAL DISCLAIMER**
 
-**FOR EDUCATIONAL AND RESEARCH PURPOSES ONLY**
+**FOR EDUCATIONAL PURPOSES ONLY**
 
-- **Not a Medical Diagnosis**: This AI analysis does not constitute a medical diagnosis, treatment recommendation, or professional medical advice
-- **Professional Review Required**: All findings must be validated by qualified healthcare professionals
-- **Emergency Situations**: For urgent medical concerns, contact emergency services immediately (911 in US)
-- **Clinical Correlation**: AI findings must be correlated with clinical examination and patient history
-- **Liability**: This system is not intended for clinical decision-making and users assume all responsibility
-- **Educational Tool**: Designed for medical education, training, and research applications only
-- **Data Privacy**: Do not upload images containing patient identifiable information
-
-**Always consult qualified healthcare professionals for medical diagnosis and treatment decisions.**
+- **Not Diagnostic**: This AI analysis is not a medical diagnosis
+- **Professional Review**: All findings require validation by healthcare professionals  
+- **Emergency Care**: Contact emergency services for urgent medical concerns
+- **Educational Tool**: Designed for medical education and training
+- **No PHI**: Do not upload patient identifiable information
 
 ---
-**Powered by**: LLaVA (Large Language and Vision Assistant) | **Model**: {MODEL_ID}
-        """
+**Powered by**: LLaVA (Large Language and Vision Assistant)
+"""
         
         # Log successful analysis
         duration = time.time() - start_time
@@ -266,58 +335,58 @@ This analysis demonstrates structured medical image interpretation methodology a
         usage_tracker.log_analysis(False, duration)
         logger.error(f"❌ LLaVA analysis error: {str(e)}")
         
-        if "memory" in str(e).lower() or "cuda" in str(e).lower():
-            return "❌ **Memory Error**: The model requires more memory. Try using a smaller image or upgrading to GPU hardware."
-        else:
-            return f"❌ **Analysis Failed**: {str(e)}\n\nPlease try again with a different image or contact support if the issue persists."
+        return f"""❌ **Analysis Error**
+
+The analysis failed with error: {str(e)}
+
+**Common Solutions:**
+- **Try again**: Sometimes temporary processing issues occur
+- **Smaller image**: Try with a smaller or different format image  
+- **Simpler question**: Use a more straightforward clinical question
+- **Refresh page**: Reload the page if model seems unstable
+
+**Technical Details:** {str(e)[:200]}"""
 
 def classify_question(question):
     """Classify clinical question type"""
     question_lower = question.lower()
-    if any(word in question_lower for word in ['describe', 'findings', 'observe', 'see']):
+    if any(word in question_lower for word in ['describe', 'findings', 'observe']):
         return 'descriptive'
-    elif any(word in question_lower for word in ['diagnosis', 'differential', 'condition', 'disease']):
+    elif any(word in question_lower for word in ['diagnosis', 'differential', 'condition']):
         return 'diagnostic'
-    elif any(word in question_lower for word in ['abnormal', 'pathology', 'lesion', 'mass']):
+    elif any(word in question_lower for word in ['abnormal', 'pathology', 'disease']):
         return 'pathological'
-    elif any(word in question_lower for word in ['analyze', 'assess', 'evaluate', 'review']):
-        return 'analytical'
     else:
         return 'general'
 
 def get_usage_stats():
-    """Get comprehensive usage statistics"""
+    """Get usage statistics"""
     stats = usage_tracker.stats
     if stats['total_analyses'] == 0:
         return "📊 **Usage Statistics**\n\nNo analyses performed yet."
     
     success_rate = (stats['successful_analyses'] / stats['total_analyses']) * 100
     
-    return f"""📊 **LLaVA Medical AI Usage Statistics**
-
-**Performance Metrics:**
-- **Total Analyses**: {stats['total_analyses']}
-- **Success Rate**: {success_rate:.1f}%
-- **Average Processing Time**: {stats['average_processing_time']:.2f} seconds
-- **Failed Analyses**: {stats['failed_analyses']}
-
-**Question Type Distribution:**
-{chr(10).join([f"- **{qtype.title()}**: {count} ({count/stats['total_analyses']*100:.1f}%)" for qtype, count in stats['question_types'].most_common()])}
-
-**System Information:**
-- **Model**: LLaVA-v1.6-Mistral-7B
-- **Capabilities**: Medical image analysis and clinical reasoning
-- **Device**: {'GPU' if torch.cuda.is_available() else 'CPU'}
-- **Status**: {'🟢 Operational' if llava_ready else '🔴 Offline'}
+    return f"""📊 **LLaVA Usage Statistics**
+
+**Performance:**
+- Total Analyses: {stats['total_analyses']}
+- Success Rate: {success_rate:.1f}%
+- Avg Processing Time: {stats['average_processing_time']:.2f}s
+
+**Popular Question Types:**
+{chr(10).join([f"- {qtype}: {count}" for qtype, count in stats['question_types'].most_common(3)])}
+
+**Model Status**: {'🟢 Ready' if llava_ready else '🔴 Loading Issues'}
 """
 
-# Create comprehensive Gradio interface
+# Create Gradio interface
 def create_interface():
     with gr.Blocks(
-        title="LLaVA Medical Image Analysis", 
+        title="LLaVA Medical Analysis", 
         theme=gr.themes.Soft(),
         css="""
-        .gradio-container { max-width: 1400px !important; }
+        .gradio-container { max-width: 1200px !important; }
         .disclaimer { background-color: #fef2f2; border: 1px solid #fecaca; border-radius: 8px; padding: 16px; margin: 16px 0; }
         .success { background-color: #f0f9ff; border: 1px solid #bae6fd; border-radius: 8px; padding: 16px; margin: 16px 0; }
         .warning { background-color: #fffbeb; border: 1px solid #fed7aa; border-radius: 8px; padding: 16px; margin: 16px 0; }
@@ -330,8 +399,7 @@ def create_interface():
         
         **Advanced Medical AI powered by LLaVA (Large Language and Vision Assistant)**
         
-        **Specialized Medical Capabilities:**
-        🫁 **Radiology** • 🔬 **Pathology** • 🩺 **Dermatology** • 👁️ **Ophthalmology** • 🧠 **Clinical Reasoning**
+        **Medical Capabilities:** 🫁 Radiology • 🔬 Pathology • 🩺 Dermatology • 👁️ Ophthalmology
         """)
         
         # Status display
@@ -339,130 +407,100 @@ def create_interface():
             gr.Markdown("""
             <div class="success">
             ✅ <strong>LLAVA MEDICAL AI READY</strong><br>
-            LLaVA vision-language model loaded successfully. Ready for comprehensive medical image analysis with clinical reasoning.
+            LLaVA model loaded successfully with compatibility fixes. Ready for medical image analysis.
             </div>
             """)
         else:
             gr.Markdown("""
             <div class="warning">
-            ⚠️ <strong>MODEL LOADING IN PROGRESS</strong><br>
-            LLaVA model is loading. This may take a few minutes. Please wait and refresh the page.
+            ⚠️ <strong>MODEL LOADING ISSUE</strong><br>
+            LLaVA model had loading problems. Try refreshing the page or contact support for assistance.
             </div>
             """)
         
         # Medical disclaimer
         gr.Markdown("""
         <div class="disclaimer">
-        ⚠️ <strong>CRITICAL MEDICAL DISCLAIMER</strong><br>
-        This AI tool provides <strong>educational medical analysis only</strong>. It is NOT a substitute for professional medical diagnosis.
-        <br><br>
-        <strong>Do NOT upload real patient data or PHI.</strong> Always consult qualified healthcare professionals for medical decisions.
+        ⚠️ <strong>MEDICAL DISCLAIMER</strong><br>
+        This AI provides medical analysis for <strong>educational purposes only</strong>. 
+        Do not upload real patient data. Always consult healthcare professionals for medical decisions.
         </div>
         """)
         
         with gr.Row():
-            # Left column - Main interface
+            # Left column
             with gr.Column(scale=2):
                 with gr.Row():
                     with gr.Column():
-                        gr.Markdown("## 📤 Medical Image Upload")
+                        gr.Markdown("## 📤 Medical Image")
                         image_input = gr.Image(
                             label="Upload Medical Image", 
                             type="pil",
-                            height=350,
-                            sources=["upload", "clipboard"]
+                            height=300
                         )
                         
                     with gr.Column():
                         gr.Markdown("## 💬 Clinical Information")
                         clinical_question = gr.Textbox(
                             label="Clinical Question *",
-                            placeholder="Examples:\n• Analyze this chest X-ray comprehensively\n• What pathological findings are visible in this image?\n• Provide differential diagnosis based on these imaging findings\n• Describe abnormalities and their clinical significance\n• Evaluate this medical image systematically",
-                            lines=5,
-                            max_lines=8
+                            placeholder="Examples:\n�� Analyze this medical image\n• What abnormalities are visible?\n• Describe the findings\n• Provide medical interpretation",
+                            lines=4
                         )
                         
                         patient_history = gr.Textbox(
-                            label="Patient History & Clinical Context (Optional)",
-                            placeholder="e.g., 58-year-old female presenting with chest pain and shortness of breath. History of hypertension and smoking. Recent onset of symptoms.",
-                            lines=3,
-                            max_lines=5
+                            label="Patient History (Optional)",
+                            placeholder="e.g., 45-year-old with chest pain",
+                            lines=2
                         )
                 
                 with gr.Row():
-                    clear_btn = gr.Button("🗑️ Clear All", variant="secondary")
+                    clear_btn = gr.Button("🗑️ Clear", variant="secondary")
                     analyze_btn = gr.Button("🔍 Analyze with LLaVA", variant="primary", size="lg")
                 
-                gr.Markdown("## 📋 LLaVA Medical Analysis Results")
+                gr.Markdown("## 📋 Medical Analysis Results")
                 output = gr.Textbox(
-                    label="Comprehensive Medical Analysis",
-                    lines=30,
-                    max_lines=50,
+                    label="LLaVA Medical Analysis",
+                    lines=20,
                     show_copy_button=True,
-                    placeholder="Upload a medical image and provide a clinical question to receive comprehensive AI-powered medical analysis..." if llava_ready else "LLaVA model is loading. Please wait and refresh the page."
+                    placeholder="Upload a medical image and clinical question..." if llava_ready else "Model loading issues - please refresh the page"
                 )
             
-            # Right column - System info and controls
+            # Right column
             with gr.Column(scale=1):
                 gr.Markdown("## ℹ️ System Status")
                 
-                model_status = "✅ Ready" if llava_ready else "🔄 Loading"
-                device_info = "GPU" if torch.cuda.is_available() else "CPU"
+                status = "✅ Ready" if llava_ready else "⚠️ Loading Issues"
                 
                 gr.Markdown(f"""
-                **Model Status:** {model_status}  
+                **Model Status:** {status}  
                 **AI Model:** LLaVA-v1.6-Mistral-7B  
-                **Device:** {device_info}  
-                **Capabilities:** Medical image analysis + clinical reasoning  
-                **Context Length:** 32K tokens  
-                **Rate Limit:** 30 requests/hour
+                **Device:** {'GPU' if torch.cuda.is_available() else 'CPU'}  
+                **Compatibility:** Fixed for stability  
+                **Rate Limit:** 20 requests/hour
                 """)
                 
-                gr.Markdown("## 📊 Usage Analytics")
+                gr.Markdown("## 📊 Usage Statistics")
                 stats_display = gr.Markdown("")
-                refresh_stats_btn = gr.Button("🔄 Refresh Statistics", size="sm")
+                refresh_stats_btn = gr.Button("🔄 Refresh Stats", size="sm")
                 
                 if llava_ready:
-                    gr.Markdown("## 🎯 Quick Clinical Examples")
-                    
-                    radiology_btn = gr.Button("🫁 Chest X-ray Analysis", size="sm")
-                    pathology_btn = gr.Button("🔬 Pathology Review", size="sm")
-                    dermatology_btn = gr.Button("🩺 Skin Lesion Analysis", size="sm")
-                    differential_btn = gr.Button("🧠 Differential Diagnosis", size="sm")
-                    
-                    gr.Markdown("## 🏥 Medical Specialties")
-                    gr.Markdown("""
-                    **LLaVA excels in:**
-                    - Radiology interpretation
-                    - Pathological analysis  
-                    - Dermatological assessment
-                    - Ophthalmological evaluation
-                    - Clinical reasoning & education
-                    """)
-        
-        # Comprehensive example cases
+                    gr.Markdown("## 🎯 Quick Examples")
+                    general_btn = gr.Button("General Analysis", size="sm")
+                    findings_btn = gr.Button("Find Abnormalities", size="sm")
+                    interpret_btn = gr.Button("Medical Interpretation", size="sm")
+        
+        # Example cases
         if llava_ready:
-            with gr.Accordion("📚 Sample Medical Cases & Examples", open=False):
+            with gr.Accordion("📚 Example Cases", open=False):
                 examples = gr.Examples(
                     examples=[
                         [
                             "https://upload.wikimedia.org/wikipedia/commons/c/c8/Chest_Xray_PA_3-8-2010.png",
-                            "Please perform a comprehensive systematic analysis of this chest X-ray. Evaluate image quality, assess cardiac silhouette, examine lung fields bilaterally, review mediastinal structures, and identify any pathological findings. Provide differential diagnosis if abnormalities are present.",
-                            "Adult patient presenting with acute onset chest pain and shortness of breath. No significant past medical history."
-                        ],
-                        [
-                            None,
-                            "Analyze this medical image systematically. Describe normal anatomical structures, identify any abnormal findings, assess clinical significance, and provide appropriate differential diagnoses based on imaging characteristics.",
-                            "Patient with acute presentation requiring medical imaging evaluation"
-                        ],
-                        [
-                            None,
-                            "What pathological changes are visible in this medical image? Please provide detailed morphological analysis, clinical correlation, and discuss potential diagnoses with supporting evidence from the imaging findings.",
-                            ""
+                            "Please analyze this chest X-ray and describe any findings. Assess the image quality, identify normal structures, and note any abnormalities.",
+                            "Adult patient with respiratory symptoms"
                         ]
                     ],
-                    inputs=[image_input, clinical_question, patient_history],
-                    label="Click any example to load it into the interface"
+                    inputs=[image_input, clinical_question, patient_history]
                 )
         
         # Event handlers
@@ -473,11 +511,8 @@ def create_interface():
             show_progress=True
         )
         
-        def clear_all_fields():
-            return None, "", "", ""
-        
         clear_btn.click(
-            fn=clear_all_fields,
+            fn=lambda: (None, "", "", ""),
             outputs=[image_input, clinical_question, patient_history, output]
         )
         
@@ -486,76 +521,37 @@ def create_interface():
             outputs=stats_display
         )
         
-        # Quick example button handlers
+        # Quick example handlers
         if llava_ready:
-            radiology_btn.click(
-                fn=lambda: ("Perform systematic radiological analysis of this medical image. Assess technical quality, identify normal anatomical structures, detect any pathological findings, and provide clinical interpretation with differential diagnosis.", "Adult patient with respiratory symptoms"),
-                outputs=[clinical_question, patient_history]
-            )
-            
-            pathology_btn.click(
-                fn=lambda: ("Analyze this pathological specimen or medical image. Describe morphological features, identify cellular patterns, assess for pathological changes, and provide histopathological interpretation with clinical significance.", "Tissue sample for pathological evaluation"),
+            general_btn.click(
+                fn=lambda: ("Analyze this medical image comprehensively. Describe what you observe and provide medical interpretation.", ""),
                 outputs=[clinical_question, patient_history]
             )
             
-            dermatology_btn.click(
-                fn=lambda: ("Examine this dermatological image systematically. Describe the lesion characteristics, assess morphological features, evaluate for concerning signs, and provide differential diagnosis with clinical recommendations.", "Patient presenting with skin lesion requiring evaluation"),
+            findings_btn.click(
+                fn=lambda: ("What abnormalities or pathological findings are visible in this medical image?", ""),
                 outputs=[clinical_question, patient_history]
             )
             
-            differential_btn.click(
-                fn=lambda: ("Based on the imaging findings in this medical image, provide a comprehensive differential diagnosis. List possible conditions in order of likelihood, explain supporting evidence for each diagnosis, and recommend additional studies if needed.", "Patient requiring diagnostic workup based on imaging findings"),
+            interpret_btn.click(
+                fn=lambda: ("Provide medical interpretation of this image including clinical significance of any findings.", ""),
                 outputs=[clinical_question, patient_history]
             )
         
-        # Comprehensive footer with detailed information
+        # Footer
         gr.Markdown("""
         ---
-        ## 🤖 About LLaVA Medical AI
-        
-        **LLaVA (Large Language and Vision Assistant)** is a state-of-the-art multimodal AI model that combines advanced computer vision with natural language processing for comprehensive medical image analysis.
-        
-        ### 🔬 Key Capabilities
-        
-        **Medical Image Analysis:**
-        - **Radiology**: X-rays, CT scans, MRI, ultrasound interpretation
-        - **Pathology**: Histological analysis, tissue examination, cellular morphology
-        - **Dermatology**: Skin lesion analysis, dermatological condition assessment
-        - **Ophthalmology**: Retinal imaging, ocular pathology evaluation
+        ### 🤖 LLaVA Medical AI
         
-        **Clinical Reasoning:**
-        - Systematic medical image interpretation
-        - Differential diagnosis generation
-        - Clinical correlation and significance assessment
-        - Educational medical content and explanations
+        **Large Language and Vision Assistant** optimized for medical image analysis with compatibility fixes for stable operation.
         
-        ### 🏥 Medical Education Applications
+        **Features:**
+        - Advanced medical image interpretation
+        - Systematic clinical analysis approach  
+        - Educational medical explanations
+        - Comprehensive error handling
         
-        - **Medical Student Training**: Interactive case-based learning
-        - **Resident Education**: Systematic approach to image interpretation  
-        - **Continuing Medical Education**: Advanced diagnostic reasoning
-        - **Research Applications**: Medical imaging analysis and documentation
-        
-        ### 🔒 Privacy & Compliance
-        
-        - **No Data Storage**: All images processed in real-time, not stored
-        - **Educational Purpose**: Designed specifically for medical education and training
-        - **Privacy Protection**: No patient identifiable information should be uploaded
-        - **Professional Standards**: Adheres to medical AI ethics and best practices
-        
-        ### ⚡ Technical Specifications
-        
-        - **Model**: LLaVA-v1.6-Mistral-7B (Latest version)
-        - **Context Window**: 32,000 tokens for comprehensive analysis
-        - **Processing**: Real-time inference with detailed medical reasoning
-        - **Accuracy**: Research-grade performance on medical imaging tasks
-        
-        ### 📞 Support & Resources
-        
-        For technical support, feature requests, or educational partnerships, please contact our support team.
-        
-        ---
-        **Powered by**: LLaVA (Large Language and Vision Assistant) | **License**: Apache 2.0 | **Purpose**: Medical Education & Research
+        **Model:** LLaVA-v1.6-Mistral-7B | **Purpose:** Medical Education & Research
         """)
     
     return demo