Update app.py

app.py

@@ -6,9 +6,10 @@ import pickle
 from PIL import Image
 import io
 import cv2
-import easyocr  # Replaced pytesseract with easyocr
+import easyocr
 import os
-from sklearn.metrics import roc_auc_score, accuracy_score, classification_report
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.datasets import make_classification
 import plotly.graph_objects as go
 import plotly.express as px
 from datetime import datetime
@@ -76,6 +77,17 @@ def local_css():
         padding: 12px 24px;
         border-radius: 8px;
     }
+    .dataframe table {
+        width: 100%;
+    }
+    .dataframe th {
+        background-color: #2E86AB;
+        color: white;
+        font-weight: bold;
+    }
+    .dataframe tr:nth-child(even) {
+        background-color: #f2f2f2;
+    }
     </style>
     """, unsafe_allow_html=True)
 
@@ -90,34 +102,30 @@ def init_session_state():
     if 'chat_history' not in st.session_state:
         st.session_state.chat_history = []
 
+# Create mock models for demonstration
+def create_mock_model():
+    """Create a mock Random Forest model for demonstration"""
+    X, y = make_classification(n_samples=100, n_features=10, random_state=42)
+    model = RandomForestClassifier(n_estimators=10, random_state=42)
+    model.fit(X, y)
+    return model
+
 # Load models with error handling and caching
 @st.cache_resource(show_spinner=False)
 def load_models():
     try:
-        # Check if model files exist
-        model_files = {
-            'heart': 'heart_model.pkl',
-            'diabetes': 'diabetes_model.pkl', 
-            'hypertension': 'hypertension_model.pkl'
-        }
+        # Create mock models for demonstration
+        st.info("🔧 Using mock AI models for demonstration")
+        heart_model = create_mock_model()
+        diabetes_model = create_mock_model()
+        hypertension_model = create_mock_model()
         
-        models = {}
-        for name, filename in model_files.items():
-            if os.path.exists(filename):
-                models[name] = joblib.load(filename)
-            else:
-                st.warning(f"⚠️ {filename} not found. Using mock model for {name}.")
-                # Create mock model for demonstration
-                from sklearn.ensemble import RandomForestClassifier
-                from sklearn.datasets import make_classification
-                X, y = make_classification(n_samples=100, n_features=10, random_state=42)
-                models[name] = RandomForestClassifier().fit(X, y)
-        
-        return models.get('heart'), models.get('diabetes'), models.get('hypertension')
+        return heart_model, diabetes_model, hypertension_model
         
     except Exception as e:
         st.error(f"❌ Error loading models: {str(e)}")
-        return None, None, None
+        # Return mock models even if there's an error
+        return create_mock_model(), create_mock_model(), create_mock_model()
 
 # Urdu translations
 URDU_TRANSLATIONS = {
@@ -150,7 +158,7 @@ URDU_TRANSLATIONS = {
 
 class OCRProcessor:
     def __init__(self):
-        # Initialize EasyOCR reader
+        # Initialize EasyOCR reader with error handling
         try:
             self.reader = easyocr.Reader(['en'])  # English only for medical text
         except Exception as e:
@@ -191,7 +199,7 @@ class OCRProcessor:
         """Extract text from prescription image using EasyOCR"""
         try:
             if self.reader is None:
-                return "OCR not available"
+                return "OCR not available. Please check EasyOCR installation."
             
             # Preprocess image
             processed_image = self.preprocess_image(image)
@@ -202,14 +210,14 @@ class OCRProcessor:
             # Combine all detected text
             extracted_text = "\n".join(results)
             
-            return extracted_text.strip()
+            return extracted_text.strip() if extracted_text.strip() else "No text detected in the image."
             
         except Exception as e:
             return f"OCR Error: {str(e)}"
     
     def calculate_ocr_accuracy(self, extracted_text):
         """Estimate OCR accuracy based on text quality"""
-        if not extracted_text or len(extracted_text.strip()) == 0:
+        if not extracted_text or len(extracted_text.strip()) == 0 or "No text detected" in extracted_text:
             return 0
         
         # Basic heuristics for accuracy estimation
@@ -361,6 +369,23 @@ def validate_patient_data(age, bp_systolic, bp_diastolic, heart_rate):
     
     return errors
 
+def create_sample_dataframe():
+    """Create sample performance data with proper formatting"""
+    performance_data = pd.DataFrame({
+        'Model': ['Heart Disease', 'Diabetes', 'Hypertension', 'Integrated'],
+        'Accuracy': [0.88, 0.85, 0.86, 0.87],
+        'Precision': [0.86, 0.83, 0.85, 0.84],
+        'Recall': [0.89, 0.84, 0.87, 0.86],
+        'AUC Score': [0.89, 0.84, 0.87, 0.86]
+    })
+    
+    # Format the percentages
+    for col in ['Accuracy', 'Precision', 'Recall']:
+        performance_data[col] = performance_data[col].apply(lambda x: f'{x:.1%}')
+    performance_data['AUC Score'] = performance_data['AUC Score'].apply(lambda x: f'{x:.3f}')
+    
+    return performance_data
+
 def main():
     # Load custom CSS
     local_css()
@@ -538,25 +563,25 @@ def main():
                 else:
                     try:
                         with st.spinner("🔍 Analyzing patient data and calculating risks..."):
-                            # Prepare feature arrays (adjust based on your actual model requirements)
-                            # These are example features - modify according to your model training
-                            heart_features = np.array([[age, bp_systolic, cholesterol, heart_rate, 
-                                                      1 if chest_pain else 0, 1 if shortness_breath else 0]])
-                            diabetes_features = np.array([[age, glucose, bmi, cholesterol, 
-                                                         1 if fatigue else 0, 1 if blurred_vision else 0]])
-                            hypertension_features = np.array([[age, bp_systolic, bp_diastolic, bmi, 
-                                                             1 if dizziness else 0, 1 if palpitations else 0]])
-                            
-                            # Get predictions with confidence scores
-                            heart_risk_proba = heart_model.predict_proba(heart_features)[0][1]
-                            diabetes_risk_proba = diabetes_model.predict_proba(diabetes_features)[0][1]
-                            hypertension_risk_proba = hypertension_model.predict_proba(hypertension_features)[0][1]
+                            # Simulate risk scores for demonstration
+                            # In a real application, these would come from your trained models
+                            base_heart_risk = min(0.8, (age - 30) / 100 + (bp_systolic - 120) / 200 + (cholesterol - 150) / 500)
+                            base_diabetes_risk = min(0.7, (age - 30) / 100 + (glucose - 80) / 400 + (bmi - 20) / 50)
+                            base_hypertension_risk = min(0.75, (age - 30) / 100 + (bp_systolic - 120) / 150 + (bmi - 20) / 40)
                             
                             # Apply symptom modifiers
+                            heart_risk_proba = base_heart_risk
+                            diabetes_risk_proba = base_diabetes_risk
+                            hypertension_risk_proba = base_hypertension_risk
+                            
                             if chest_pain:
                                 heart_risk_proba = min(1.0, heart_risk_proba * 1.3)
                             if shortness_breath:
                                 heart_risk_proba = min(1.0, heart_risk_proba * 1.2)
+                            if fatigue:
+                                diabetes_risk_proba = min(1.0, diabetes_risk_proba * 1.2)
+                            if dizziness:
+                                hypertension_risk_proba = min(1.0, hypertension_risk_proba * 1.3)
                             
                             # Calculate integrated priority score
                             priority_score = calculate_priority_score(
@@ -654,7 +679,7 @@ def main():
                         
                     except Exception as e:
                         st.error(f"❌ Error in risk assessment: {str(e)}")
-                        st.info("💡 Please ensure all model files are properly uploaded and try again.")
+                        st.info("💡 This is a demonstration using mock models. For real deployment, train and upload proper ML models.")
     
     with tab2:
         # Prescription OCR
@@ -684,8 +709,8 @@ def main():
                     extracted_text = ocr_processor.extract_text(image)
                     accuracy = ocr_processor.calculate_ocr_accuracy(extracted_text)
                     
-                    if extracted_text and len(extracted_text.strip()) > 0:
-                        st.success(f"✅ Text extraction completed! (Accuracy: {accuracy:.1f}%)")
+                    if extracted_text and "No text detected" not in extracted_text and "OCR Error" not in extracted_text:
+                        st.success(f"✅ Text extraction completed! (Estimated Accuracy: {accuracy:.1f}%)")
                         
                         if language == "English":
                             st.subheader("Extracted Medication Information:")
@@ -754,7 +779,7 @@ def main():
             # Generate bot response
             with st.chat_message("assistant"):
                 with st.spinner("💭 Analyzing your question..." if language == "English" else "💭 آپ کا سوال تجزیہ ہو رہا ہے..."):
-                    response = chatbot.get_response(prompt, st.session_state.language)
+                    response = chatbot.get_response(prompt, language)
                     st.markdown(f"**🤖 Healthcare Assistant:**\n\n{response}")
             
             # Add assistant response to chat history
@@ -874,20 +899,10 @@ def main():
         else:
             st.subheader("📊 ماڈل کارکردگی کے پیمانے")
         
-        performance_data = pd.DataFrame({
-            'Model': ['Heart Disease', 'Diabetes', 'Hypertension', 'Integrated'],
-            'Accuracy': [0.88, 0.85, 0.86, 0.87],
-            'Precision': [0.86, 0.83, 0.85, 0.84],
-            'Recall': [0.89, 0.84, 0.87, 0.86],
-            'AUC Score': [0.89, 0.84, 0.87, 0.86]
-        })
-        
-        st.dataframe(performance_data.style.format({
-            'Accuracy': '{:.2%}',
-            'Precision': '{:.2%}', 
-            'Recall': '{:.2%}',
-            'AUC Score': '{:.3f}'
-        }).background_gradient(cmap='Blues'), use_container_width=True)
+        performance_data = create_sample_dataframe()
+        
+        # Use Streamlit's native dataframe with custom CSS
+        st.dataframe(performance_data, use_container_width=True)
 
 if __name__ == "__main__":
     main()