Create app.py

app.py

@@ -0,0 +1,580 @@
+import gradio as gr
+import torch
+from transformers import (
+    AutoProcessor, 
+    AutoModelForCausalLM, 
+    pipeline,
+    BitsAndBytesConfig
+)
+from PIL import Image
+import numpy as np
+import warnings
+import gc
+import os
+from typing import Optional, Tuple
+
+warnings.filterwarnings("ignore")
+
+class OptimizedAIDoctor:
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model_loaded = False
+        
+        # Configuration for model loading
+        self.config = {
+            "vision_model": "microsoft/git-base-coco",  # Lighter model for HF Spaces
+            "stt_model": "openai/whisper-tiny.en",     # Smaller Whisper model
+            "max_memory": "6GB" if torch.cuda.is_available() else "2GB"
+        }
+        
+        print(f"🚀 Initializing AI Doctor on {self.device}")
+        print(f"💾 Available memory config: {self.config['max_memory']}")
+        
+        self.load_models()
+    
+    def load_models(self):
+        """Load models with optimizations for Hugging Face Spaces"""
+        try:
+            print("📦 Loading Vision Model...")
+            
+            # Quantization config for memory efficiency
+            if self.device == "cuda":
+                quantization_config = BitsAndBytesConfig(
+                    load_in_4bit=True,
+                    bnb_4bit_compute_dtype=torch.float16,
+                    bnb_4bit_use_double_quant=True,
+                    bnb_4bit_quant_type="nf4"
+                )
+            else:
+                quantization_config = None
+            
+            # Load vision model
+            self.vision_processor = AutoProcessor.from_pretrained(
+                self.config["vision_model"],
+                trust_remote_code=True
+            )
+            
+            self.vision_model = AutoModelForCausalLM.from_pretrained(
+                self.config["vision_model"],
+                quantization_config=quantization_config,
+                device_map="auto" if self.device == "cuda" else None,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                trust_remote_code=True,
+                low_cpu_mem_usage=True
+            )
+            
+            print("🎤 Loading Speech-to-Text Model...")
+            # Load STT pipeline with smaller model
+            self.stt_pipeline = pipeline(
+                "automatic-speech-recognition",
+                model=self.config["stt_model"],
+                device=0 if self.device == "cuda" else -1,
+                return_timestamps=False,
+                chunk_length_s=10,
+                stride_length_s=2
+            )
+            
+            self.model_loaded = True
+            print("✅ All models loaded successfully!")
+            
+            # Clear cache
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            gc.collect()
+            
+        except Exception as e:
+            print(f"❌ Error loading models: {e}")
+            print("🔄 Trying fallback configuration...")
+            self.load_minimal_models()
+    
+    def load_minimal_models(self):
+        """Load minimal models as fallback"""
+        try:
+            # Use even lighter models
+            self.config["vision_model"] = "nlpconnect/vit-gpt2-image-captioning"
+            self.config["stt_model"] = "openai/whisper-tiny"
+            
+            self.vision_processor = AutoProcessor.from_pretrained(self.config["vision_model"])
+            self.vision_model = AutoModelForCausalLM.from_pretrained(
+                self.config["vision_model"],
+                torch_dtype=torch.float32
+            )
+            
+            self.stt_pipeline = pipeline(
+                "automatic-speech-recognition",
+                model=self.config["stt_model"],
+                device=-1  # Force CPU
+            )
+            
+            self.model_loaded = True
+            print("✅ Fallback models loaded!")
+            
+        except Exception as e:
+            print(f"❌ Critical error: {e}")
+            self.model_loaded = False
+    
+    def analyze_medical_image(self, image: Image.Image, question: str = "") -> str:
+        """Analyze medical image with AI"""
+        if not self.model_loaded:
+            return "❌ Models not loaded. Please try again later."
+        
+        if image is None:
+            return "📸 Please upload an image for analysis."
+        
+        try:
+            # Resize image for efficiency
+            image = image.convert("RGB")
+            if image.size[0] > 512 or image.size[1] > 512:
+                image.thumbnail((512, 512), Image.Resampling.LANCZOS)
+            
+            # Create medical analysis prompt
+            if not question:
+                question = "Analyze this medical image and describe what you observe."
+            
+            prompt = f"""Medical Image Analysis:
+
+{question}
+
+Please provide:
+1. Visual observations
+2. Possible medical conditions
+3. General care recommendations
+4. When to seek professional help
+
+Response:"""
+            
+            # Process inputs
+            inputs = self.vision_processor(
+                text=prompt,
+                images=image,
+                return_tensors="pt",
+                padding=True,
+                truncation=True
+            ).to(self.device)
+            
+            # Generate response with memory management
+            with torch.no_grad():
+                outputs = self.vision_model.generate(
+                    **inputs,
+                    max_new_tokens=300,
+                    do_sample=True,
+                    temperature=0.7,
+                    top_p=0.9,
+                    pad_token_id=self.vision_processor.tokenizer.eos_token_id
+                )
+            
+            # Decode response
+            response = self.vision_processor.decode(outputs[0], skip_special_tokens=True)
+            
+            # Clean response
+            if prompt in response:
+                response = response.replace(prompt, "").strip()
+            
+            # Add medical disclaimer
+            medical_response = self.format_medical_response(response)
+            
+            # Memory cleanup
+            del inputs, outputs
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            
+            return medical_response
+            
+        except Exception as e:
+            return f"❌ Error analyzing image: {str(e)}\n\nPlease try with a different image or contact support."
+    
+    def transcribe_audio(self, audio_path: Optional[str]) -> str:
+        """Convert speech to text"""
+        if not self.model_loaded or audio_path is None:
+            return "No audio to transcribe."
+        
+        try:
+            result = self.stt_pipeline(audio_path)
+            
+            if isinstance(result, dict):
+                return result.get("text", "").strip()
+            elif isinstance(result, list) and len(result) > 0:
+                return result[0].get("text", "").strip()
+            else:
+                return str(result).strip()
+                
+        except Exception as e:
+            return f"Error transcribing audio: {str(e)}"
+    
+    def format_medical_response(self, response: str) -> str:
+        """Format the AI response with proper medical disclaimers"""
+        
+        # Clean and structure the response
+        formatted_response = f"""
+🔍 **AI Medical Image Analysis**
+
+{response}
+
+---
+
+⚠️ **IMPORTANT MEDICAL DISCLAIMER**
+
+This AI analysis is for informational purposes only and should NOT replace professional medical advice. 
+
+🏥 **Please consult a qualified healthcare provider for:**
+- Proper medical diagnosis
+- Treatment recommendations  
+- Emergency medical situations
+- Any health concerns
+
+📞 **Seek immediate medical attention if you experience:**
+- Severe pain or discomfort
+- Signs of infection (fever, swelling, pus)
+- Rapid changes in condition
+- Any emergency symptoms
+
+This tool is designed to provide general health information and encourage appropriate medical care.
+"""
+        
+        return formatted_response.strip()
+    
+    def process_medical_consultation(
+        self, 
+        image: Optional[Image.Image], 
+        audio: Optional[str], 
+        text_question: str
+    ) -> Tuple[str, str]:
+        """Main function to handle medical consultation"""
+        
+        if not self.model_loaded:
+            return "❌ AI models are not loaded. Please refresh and try again.", ""
+        
+        # Handle input prioritization
+        question = text_question.strip() if text_question else ""
+        transcribed_audio = ""
+        
+        # Process audio if provided
+        if audio is not None:
+            transcribed_audio = self.transcribe_audio(audio)
+            if transcribed_audio and len(transcribed_audio.strip()) > 0:
+                question = transcribed_audio
+        
+        # Validate inputs
+        if image is None:
+            return "📸 Please upload a medical image to analyze.", transcribed_audio
+        
+        if not question:
+            question = "What medical condition or issue do you see in this image?"
+        
+        # Perform medical analysis
+        try:
+            analysis = self.analyze_medical_image(image, question)
+            return analysis, f"Question processed: {question}"
+            
+        except Exception as e:
+            error_response = f"""
+❌ **Error Processing Request**
+
+Unable to analyze the medical image due to: {str(e)}
+
+🔄 **Please try:**
+- Uploading a clearer image
+- Asking a simpler question
+- Refreshing the page
+
+If the problem persists, the AI service may be temporarily unavailable.
+
+⚠️ **For urgent medical needs, please contact a healthcare provider immediately.**
+"""
+            return error_response, transcribed_audio
+
+# Initialize AI Doctor
+print("🏥 Starting AI Doctor initialization...")
+ai_doctor = OptimizedAIDoctor()
+
+# Create enhanced Gradio interface
+def create_medical_interface():
+    """Create the main Gradio interface"""
+    
+    # Custom CSS for medical theme
+    custom_css = """
+    .gradio-container { 
+        max-width: 1400px !important; 
+        margin: auto;
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    }
+    .medical-header {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 30px;
+        border-radius: 15px;
+        text-align: center;
+        margin-bottom: 30px;
+        box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+    }
+    .disclaimer-box {
+        background-color: #fff3cd;
+        border-left: 4px solid #ffc107;
+        border-radius: 5px;
+        padding: 20px;
+        margin: 20px 0;
+        box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+    }
+    .feature-box {
+        background: white;
+        border-radius: 10px;
+        padding: 20px;
+        box-shadow: 0 2px 10px rgba(0,0,0,0.05);
+        margin: 10px 0;
+    }
+    .status-indicator {
+        display: inline-block;
+        width: 10px;
+        height: 10px;
+        border-radius: 50%;
+        margin-right: 8px;
+    }
+    .status-online { background-color: #28a745; }
+    .status-offline { background-color: #dc3545; }
+    """
+    
+    with gr.Blocks(
+        title="🏥 AI Doctor - Medical Assistant",
+        theme=gr.themes.Soft(
+            primary_hue="blue",
+            secondary_hue="indigo",
+            neutral_hue="slate"
+        ),
+        css=custom_css
+    ) as interface:
+        
+        # Header
+        gr.HTML(f"""
+        <div class="medical-header">
+            <h1>🏥 AI Medical Assistant</h1>
+            <p style="font-size: 18px; margin: 10px 0;">
+                Advanced AI-powered medical image analysis with voice and text support
+            </p>
+            <p style="font-size: 14px; opacity: 0.9;">
+                <span class="status-indicator {'status-online' if ai_doctor.model_loaded else 'status-offline'}"></span>
+                AI Status: {'Online' if ai_doctor.model_loaded else 'Offline - Please refresh'}
+            </p>
+        </div>
+        """)
+        
+        # Main disclaimer
+        gr.HTML("""
+        <div class="disclaimer-box">
+            <h3>⚠️ Critical Medical Disclaimer</h3>
+            <p><strong>This AI tool is for educational purposes only and cannot replace professional medical advice.</strong></p>
+            <ul>
+                <li>Always consult qualified healthcare professionals for medical concerns</li>
+                <li>Do not use for emergency medical situations - call emergency services</li>
+                <li>AI analysis may have limitations and should not be solely relied upon</li>
+                <li>Your privacy is important - images are processed temporarily and not stored</li>
+            </ul>
+        </div>
+        """)
+        
+        # Main interface
+        with gr.Row(equal_height=True):
+            # Input column
+            with gr.Column(scale=1, variant="panel"):
+                gr.Markdown("## 📋 Medical Consultation Input")
+                
+                # Image upload
+                with gr.Group():
+                    gr.Markdown("### 📸 Upload Medical Image")
+                    image_input = gr.Image(
+                        label="Medical Image (Required)",
+                        type="pil",
+                        height=300,
+                        interactive=True
+                    )
+                    gr.Markdown("*Upload a clear image of the medical condition or area of concern*")
+                
+                # Audio input
+                with gr.Group():
+                    gr.Markdown("### 🎤 Voice Question (Optional)")
+                    audio_input = gr.Audio(
+                        label="Record your medical question",
+                        source="microphone",
+                        type="filepath",
+                        interactive=True
+                    )
+                    gr.Markdown("*Click to record your question about the medical image*")
+                
+                # Text input
+                with gr.Group():
+                    gr.Markdown("### ✍️ Text Question (Optional)")
+                    text_input = gr.Textbox(
+                        label="Type your medical question",
+                        placeholder="Example: What type of rash is this? How should I treat it?",
+                        lines=3,
+                        interactive=True
+                    )
+                    gr.Markdown("*Describe your symptoms or ask specific questions about the image*")
+                
+                # Analysis button
+                analyze_button = gr.Button(
+                    "🔍 Analyze Medical Condition",
+                    variant="primary",
+                    size="lg",
+                    scale=1
+                )
+                
+                # Clear button
+                clear_button = gr.Button(
+                    "🗑️ Clear All",
+                    variant="secondary",
+                    size="sm"
+                )
+            
+            # Output column
+            with gr.Column(scale=1, variant="panel"):
+                gr.Markdown("## 📋 AI Medical Analysis")
+                
+                # Main analysis output
+                analysis_output = gr.Textbox(
+                    label="Medical Analysis Report",
+                    lines=20,
+                    max_lines=25,
+                    interactive=False,
+                    placeholder="Upload an image and click 'Analyze Medical Condition' to get started..."
+                )
+                
+                # Transcription output
+                transcription_output = gr.Textbox(
+                    label="Voice Input Transcription",
+                    lines=2,
+                    interactive=False,
+                    placeholder="Voice transcription will appear here..."
+                )
+                
+                # Quick actions
+                with gr.Row():
+                    gr.Button("📋 Copy Analysis", size="sm", variant="secondary")
+                    gr.Button("📧 Email Report", size="sm", variant="secondary")
+        
+        # Examples section
+        gr.Markdown("## 📚 Example Medical Cases")
+        gr.Markdown("*Click on any example to see how the AI analyzes different medical conditions*")
+        
+        with gr.Row():
+            with gr.Column():
+                gr.Examples(
+                    examples=[
+                        [None, None, "What does this skin condition look like?"],
+                        [None, None, "Is this a normal mole or should I be concerned?"],
+                        [None, None, "How should I care for this wound?"],
+                        [None, None, "What type of rash is this?"],
+                        [None, None, "Are these symptoms of an infection?"],
+                    ],
+                    inputs=[image_input, audio_input, text_input],
+                    label="Common Questions"
+                )
+        
+        # Feature information
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("""
+                ### 🎯 What Can AI Doctor Analyze?
+                
+                **✅ Skin Conditions**
+                - Acne and pimples
+                - Rashes and dermatitis  
+                - Moles and skin spots
+                - Cuts and wounds
+                - Eczema and psoriasis
+                
+                **✅ General Health**
+                - Visible infections
+                - Swelling and inflammation
+                - Hair and scalp issues
+                - Eye conditions (external)
+                - Oral health concerns
+                """)
+            
+            with gr.Column(scale=1):
+                gr.Markdown("""
+                ### ⚠️ Important Limitations
+                
+                **❌ Cannot Diagnose**
+                - Internal medical conditions
+                - Serious diseases requiring tests
+                - Emergency medical situations
+                - Conditions needing lab work
+                
+                **❌ Not Suitable For**
+                - Chest pain or heart issues
+                - Severe allergic reactions
+                - Mental health crises
+                - Medication dosing questions
+                - Pregnancy-related concerns
+                """)
+        
+        # Technical information
+        with gr.Accordion("🛠️ Technical Details", open=False):
+            gr.Markdown(f"""
+            ### AI Models Used
+            - **Vision Analysis**: {ai_doctor.config['vision_model']}
+            - **Speech Recognition**: {ai_doctor.config['stt_model']}  
+            - **Processing Device**: {ai_doctor.device.upper()}
+            - **Memory Configuration**: {ai_doctor.config['max_memory']}
+            
+            ### Privacy & Security
+            - Images are processed in real-time and not permanently stored
+            - Voice recordings are transcribed locally and deleted
+            - No personal health information is saved
+            - All processing follows HIPAA-like privacy principles
+            
+            ### Open Source
+            This application is built entirely with open-source models and can be run locally or deployed on your own infrastructure.
+            """)
+        
+        # Event handlers
+        def analyze_condition(image, audio, text):
+            if not ai_doctor.model_loaded:
+                return "❌ AI models are not available. Please refresh the page and try again.", ""
+            return ai_doctor.process_medical_consultation(image, audio, text)
+        
+        def clear_all():
+            return None, None, "", "", ""
+        
+        # Button events
+        analyze_button.click(
+            fn=analyze_condition,
+            inputs=[image_input, audio_input, text_input],
+            outputs=[analysis_output, transcription_output],
+            show_progress=True
+        )
+        
+        clear_button.click(
+            fn=clear_all,
+            outputs=[image_input, audio_input, text_input, analysis_output, transcription_output]
+        )
+        
+        # Footer
+        gr.HTML("""
+        <div style="text-align: center; margin-top: 40px; padding: 20px; background-color: #f8f9fa; border-radius: 10px;">
+            <p><strong>🏥 AI Medical Assistant</strong> - Powered by Open Source AI</p>
+            <p style="font-size: 12px; color: #666;">
+                Built with LLaVA, Whisper, and Gradio • Not for emergency use • Always consult healthcare professionals
+            </p>
+        </div>
+        """)
+    
+    return interface
+
+# Launch application
+if __name__ == "__main__":
+    print("🚀 Launching AI Doctor Medical Assistant...")
+    
+    # Create and launch interface
+    demo = create_medical_interface()
+    
+    # Launch configuration for Hugging Face Spaces
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True,
+        show_tips=True,
+        enable_queue=True,
+        max_threads=10
+    )