Upload qwen_vl_medical_ui.py

qwen_vl_medical_ui.py

@@ -0,0 +1,472 @@
+#!/usr/bin/env python3
+"""
+Qwen-VL Medical Image Analysis - Gradio Interface for Hugging Face Spaces
+Optimized for Hugging Face deployment with efficient resource usage
+"""
+
+import gradio as gr
+import torch
+from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
+from qwen_vl_utils import process_vision_info
+from PIL import Image
+import json
+import time
+import os
+from typing import Dict, List, Optional, Tuple
+import warnings
+warnings.filterwarnings("ignore")
+
+# Global variables for model caching
+MODEL = None
+PROCESSOR = None
+DEVICE = None
+
+def get_device():
+    """Determine the best available device"""
+    if torch.cuda.is_available():
+        return "cuda"
+    else:
+        return "cpu"
+
+def load_model_cached(model_name: str = "Qwen/Qwen2.5-VL-3B-Instruct"):
+    """Load and cache model - optimized for HF Spaces"""
+    global MODEL, PROCESSOR, DEVICE
+    
+    if MODEL is None:
+        print(f"Loading {model_name}...")
+        DEVICE = get_device()
+        print(f"Using device: {DEVICE}")
+        
+        try:
+            # Load with memory optimization for HF Spaces
+            MODEL = Qwen2VLForConditionalGeneration.from_pretrained(
+                model_name,
+                torch_dtype=torch.bfloat16 if DEVICE == "cuda" else torch.float32,
+                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
+            
+        except Exception as e:
+            print(f"Error loading model: {str(e)}")
+            return False
+    
+    return True
+
+def create_medical_prompt(clinical_data: Dict, analysis_type: str, focus_areas: str) -> str:
+    """Create optimized medical analysis prompt"""
+    
+    base_prompt = """You are an expert medical AI assistant specializing in medical image analysis with training across radiology, pathology, dermatology, 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
+- Be thorough but concise
+- Always mention limitations and need for professional consultation
+"""
+    
+    # Add clinical context if provided
+    clinical_context = ""
+    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("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']}")
+        
+        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
+""",
+        "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
+""",
+        "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
+"""
+    }
+    
+    focus_instruction = ""
+    if focus_areas and focus_areas.strip():
+        focus_instruction = f"\n**SPECIAL FOCUS**: 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.
+"""
+    
+    return base_prompt + clinical_context + analysis_instructions.get(analysis_type, analysis_instructions["Comprehensive"]) + focus_instruction + disclaimer
+
+def analyze_medical_image(
+    image: Image.Image,
+    age: str,
+    gender: str,
+    symptoms: str,
+    history: str,
+    medications: str,
+    analysis_type: str,
+    focus_areas: str,
+    progress=gr.Progress()
+) -> Tuple[str, str]:
+    """Main analysis function for Gradio interface"""
+    
+    if image is None:
+        return "❌ Please upload an image first.", ""
+    
+    # Load model if needed
+    progress(0.1, desc="Loading model...")
+    if not load_model_cached():
+        return "❌ Failed to load model. Please try again.", ""
+    
+    try:
+        progress(0.3, desc="Preparing analysis...")
+        
+        # Prepare clinical data
+        clinical_data = {
+            "age": age.strip(),
+            "gender": gender,
+            "symptoms": symptoms.strip(),
+            "history": history.strip(),
+            "medications": medications.strip()
+        }
+        
+        # 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,
+            )
+        
+        generated_ids_trimmed = [
+            out_ids[len(in_ids):] 
+            for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+        ]
+        
+        response = PROCESSOR.batch_decode(
+            generated_ids_trimmed, 
+            skip_special_tokens=True, 
+            clean_up_tokenization_spaces=False
+        )[0]
+        
+        progress(1.0, desc="Analysis complete!")
+        
+        # Create download content
+        report_data = {
+            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S UTC"),
+            "model": "Qwen2.5-VL-3B-Instruct",
+            "analysis_type": analysis_type,
+            "clinical_data": clinical_data,
+            "focus_areas": focus_areas,
+            "analysis": response
+        }
+        
+        download_content = json.dumps(report_data, indent=2)
+        
+        return response, download_content
+        
+    except Exception as e:
+        return f"❌ Analysis failed: {str(e)}\n\nPlease try again or contact support.", ""
+
+def create_interface():
+    """Create the Gradio interface"""
+    
+    # Custom CSS for medical theme
+    css = """
+    .gradio-container {
+        max-width: 1200px !important;
+    }
+    .medical-header {
+        text-align: center;
+        color: #2c5aa0;
+        margin-bottom: 20px;
+    }
+    .clinical-section {
+        background-color: #f8f9fa;
+        padding: 15px;
+        border-radius: 8px;
+        margin: 10px 0;
+    }
+    """
+    
+    with gr.Blocks(css=css, theme=gr.themes.Soft(), title="Medical AI Analyzer") 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>
+        </div>
+        """)
+        
+        with gr.Row():
+            # Left column - Inputs
+            with gr.Column(scale=1):
+                gr.Markdown("## 📤 Upload Medical Image")
+                
+                image_input = gr.Image(
+                    type="pil",
+                    label="Medical Image",
+                    height=300,
+                    sources=["upload", "clipboard"]
+                )
+                
+                gr.Markdown("*Supported: X-rays, CT, MRI, photographs, microscopy, etc.*")
+                
+                gr.Markdown("## 📋 Clinical Information")
+                
+                with gr.Group():
+                    with gr.Row():
+                        age_input = gr.Textbox(
+                            label="Patient Age",
+                            placeholder="e.g., 45 years",
+                            max_lines=1
+                        )
+                        gender_input = gr.Dropdown(
+                            choices=["", "Male", "Female", "Other"],
+                            label="Gender",
+                            value=""
+                        )
+                    
+                    symptoms_input = gr.Textbox(
+                        label="Chief Complaint / Symptoms",
+                        placeholder="e.g., Chest pain, shortness of breath for 3 days",
+                        lines=2
+                    )
+                    
+                    history_input = gr.Textbox(
+                        label="Medical History",
+                        placeholder="e.g., Hypertension, diabetes, previous surgeries",
+                        lines=2
+                    )
+                    
+                    medications_input = gr.Textbox(
+                        label="Current Medications",
+                        placeholder="e.g., Metformin, Lisinopril, Aspirin",
+                        lines=2
+                    )
+                
+                gr.Markdown("## ⚙️ Analysis Settings")
+                
+                analysis_type = gr.Radio(
+                    choices=["Comprehensive", "Quick Assessment", "Educational"],
+                    label="Analysis Type",
+                    value="Comprehensive",
+                    info="Choose the depth and focus of analysis"
+                )
+                
+                focus_areas = gr.Textbox(
+                    label="Focus Areas (Optional)",
+                    placeholder="e.g., cardiac, pulmonary, neurological",
+                    info="Specific areas to emphasize in analysis"
+                )
+                
+                analyze_btn = gr.Button(
+                    "🔬 Analyze Medical Image",
+                    variant="primary",
+                    size="lg"
+                )
+            
+            # Right column - Results
+            with gr.Column(scale=1):
+                gr.Markdown("## 🤖 AI Analysis Results")
+                
+                analysis_output = gr.Textbox(
+                    label="Medical Analysis",
+                    lines=20,
+                    max_lines=30,
+                    show_copy_button=True,
+                    placeholder="Analysis results will appear here after processing..."
+                )
+                
+                download_file = gr.File(
+                    label="📥 Download Analysis Report",
+                    visible=False
+                )
+                
+                # Hidden component to store download content
+                download_content = gr.Textbox(visible=False)
+        
+        # Example section
+        with gr.Accordion("💡 Example Use Cases & Tips", open=False):
+            gr.Markdown("""
+            ### 🔍 **Supported Medical Images:**
+            - **Radiology**: X-rays, CT scans, MRI images, Ultrasound
+            - **Pathology**: Histological slides, Cytology specimens
+            - **Dermatology**: Skin lesions, Rashes, Clinical photos
+            - **Ophthalmology**: Fundus photos, OCT images
+            - **Clinical Photography**: Wound assessment, Physical findings
+            
+            ### 📝 **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
+            
+            ### ⚠️ **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
+            """)
+        
+        # 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. 
+            It should never replace professional medical diagnosis or treatment. 
+            Always consult qualified healthcare providers for medical decisions.
+        </div>
+        """)
+        
+        # Event handlers
+        def create_download_file(content):
+            if content:
+                filename = f"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)
+        
+        analyze_btn.click(
+            fn=analyze_medical_image,
+            inputs=[
+                image_input, age_input, gender_input, symptoms_input,
+                history_input, medications_input, analysis_type, focus_areas
+            ],
+            outputs=[analysis_output, download_content]
+        ).then(
+            fn=create_download_file,
+            inputs=[download_content],
+            outputs=[download_file]
+        )
+    
+    return interface
+
+if __name__ == "__main__":
+    # Pre-load model to reduce first-run latency
+    print("Initializing Medical AI Analyzer...")
+    load_model_cached()
+    
+    # Create and launch interface
+    interface = create_interface()
+    
+    # Launch with settings optimized for HF Spaces
+    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
+"""