Update app.py

app.py

@@ -1,181 +1,363 @@
-import pandas as pd
-import numpy as np
-from sklearn.model_selection import train_test_split
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.metrics import accuracy_score, classification_report
+# app.py - Fixed for 4-feature BioSentinel Model
+import gradio as gr
 import joblib
+import numpy as np
+from typing import Tuple
 
-def create_realistic_water_data():
-    """
-    Create realistic water quality dataset with clear safe/unsafe patterns
-    """
-    np.random.seed(42)
-    n_samples = 2000
-    
-    # Create 50% safe and 50% unsafe samples
-    n_safe = n_samples // 2
-    n_unsafe = n_samples - n_safe
-    
-    data = []
-    labels = []
-    
-    # Generate SAFE water samples
-    print(f"🟢 Generating {n_safe} SAFE water samples...")
-    for i in range(n_safe):
-        # Safe water characteristics
-        ph = np.random.normal(7.2, 0.5)  # Around neutral pH
-        ph = np.clip(ph, 6.5, 8.5)  # Keep in safe range
+class BioSentinelPredictor:
+    def __init__(self):
+        try:
+            self.model = joblib.load("model.joblib")
+            self.model_loaded = True
+            print(f"✅ Model loaded successfully!")
+        except Exception as e:
+            print(f"❌ Error loading model: {e}")
+            self.model_loaded = False
         
-        hardness = np.random.uniform(80, 250)  # Moderate hardness
+        # Only 4 features to match your trained model
+        self.feature_columns = [
+            "pH",
+            "Hardness", 
+            "Solids",
+            "Chloramines"
+        ]
         
-        solids = np.random.uniform(50, 400)  # Low dissolved solids
-        
-        chloramines = np.random.uniform(0.5, 3.5)  # Low chloramines
+        # Realistic ranges for water quality parameters
+        self.feature_ranges = {
+            "pH": (3.0, 9.5, 7.0),
+            "Hardness": (47.0, 323.0, 196.0),
+            "Solids": (320.0, 61227.0, 22000.0),
+            "Chloramines": (0.35, 13.13, 7.0)
+        }
+
+    def predict(self, ph, hardness, solids, chloramines) -> Tuple[str, str, str]:
+        if not self.model_loaded:
+            return "❌ Model Error", "Could not load the trained model. Please check if model.joblib exists.", ""
         
-        data.append([ph, hardness, solids, chloramines])
-        labels.append(1)  # Safe
-    
-    # Generate UNSAFE water samples
-    print(f"🔴 Generating {n_unsafe} UNSAFE water samples...")
-    for i in range(n_unsafe):
-        # Randomly choose what makes it unsafe
-        unsafe_type = np.random.choice(['acidic', 'alkaline', 'high_solids', 'high_chloramines', 'multiple'])
-        
-        if unsafe_type == 'acidic':
-            ph = np.random.uniform(3.0, 6.0)  # Too acidic
-            hardness = np.random.uniform(50, 300)
-            solids = np.random.uniform(100, 1000)
-            chloramines = np.random.uniform(1.0, 6.0)
+        try:
+            # Create input array with exactly 4 features (matching your model)
+            features = np.array([[ph, hardness, solids, chloramines]])
             
-        elif unsafe_type == 'alkaline':
-            ph = np.random.uniform(9.0, 11.0)  # Too alkaline
-            hardness = np.random.uniform(100, 350)
-            solids = np.random.uniform(200, 1500)
-            chloramines = np.random.uniform(2.0, 7.0)
+            # Debug: Print input values
+            print(f"🔍 Input values: pH={ph}, Hardness={hardness}, Solids={solids}, Chloramines={chloramines}")
             
-        elif unsafe_type == 'high_solids':
-            ph = np.random.uniform(6.0, 8.0)
-            hardness = np.random.uniform(150, 400)
-            solids = np.random.uniform(1000, 60000)  # Very high solids
-            chloramines = np.random.uniform(2.0, 8.0)
+            # Make prediction
+            prediction = self.model.predict(features)[0]
+            print(f"🎯 Model prediction: {prediction}")
             
-        elif unsafe_type == 'high_chloramines':
-            ph = np.random.uniform(6.5, 8.0)
-            hardness = np.random.uniform(100, 300)
-            solids = np.random.uniform(200, 800)
-            chloramines = np.random.uniform(8.0, 15.0)  # High chloramines
+            # Get confidence score if available
+            confidence_text = ""
+            proba_values = None
+            if hasattr(self.model, 'predict_proba'):
+                try:
+                    proba = self.model.predict_proba(features)[0]
+                    proba_values = proba
+                    confidence = max(proba)
+                    confidence_text = f"\nConfidence: {confidence:.1%}"
+                    print(f"📊 Probabilities: {proba}")
+                except Exception as e:
+                    print(f"Confidence error: {e}")
             
-        else:  # multiple issues
-            ph = np.random.uniform(4.0, 5.5)  # Acidic
-            hardness = np.random.uniform(30, 100)  # Low hardness
-            solids = np.random.uniform(2000, 50000)  # High solids
-            chloramines = np.random.uniform(8.0, 13.0)  # High chloramines
-        
-        data.append([ph, hardness, solids, chloramines])
-        labels.append(0)  # Unsafe
-    
-    # Convert to DataFrame
-    df = pd.DataFrame(data, columns=['pH', 'Hardness', 'Solids', 'Chloramines'])
-    df['Potability'] = labels
-    
-    # Shuffle the data
-    df = df.sample(frac=1, random_state=42).reset_index(drop=True)
-    
-    return df
+            # Create dynamic detailed analysis based on actual parameters
+            detailed_analysis = self._create_dynamic_analysis(ph, hardness, solids, chloramines, prediction, proba_values)
+            
+            # Interpret results with more nuanced responses
+            if prediction == 1:
+                result = "✅ SAFE TO DRINK"
+                base_description = "Water quality analysis indicates this sample is generally SAFE for consumption."
+            else:
+                result = "⚠️ NOT SAFE"
+                base_description = "Water quality analysis indicates potential safety concerns with this sample."
+            
+            # Add specific concerns based on parameters
+            concerns = self._identify_concerns(ph, hardness, solids, chloramines)
+            
+            final_description = f"{base_description}\n\n{detailed_analysis}{confidence_text}"
+            
+            # Parameter breakdown
+            feature_analysis = self._create_parameter_breakdown(ph, hardness, solids, chloramines)
+            
+            return result, final_description, feature_analysis
+            
+        except Exception as e:
+            error_msg = str(e)
+            print(f"❌ Prediction error: {error_msg}")
+            return "❌ Prediction Failed", f"Error during prediction: {error_msg}", "Please check your input values and try again."
 
-def train_improved_model():
-    """
-    Train an improved 4-feature water quality model
-    """
-    print("🧬 Training Improved BioSentinel Model")
-    print("=" * 50)
-    
-    # Create dataset
-    df = create_realistic_water_data()
-    print(f"✅ Dataset created: {len(df)} samples")
-    print(f"🎯 Safe samples: {sum(df['Potability'] == 1)}")
-    print(f"🎯 Unsafe samples: {sum(df['Potability'] == 0)}")
-    
-    # Show sample statistics
-    print("\n📊 Dataset Statistics:")
-    print(df.describe())
-    
-    # Prepare features and target
-    feature_columns = ['pH', 'Hardness', 'Solids', 'Chloramines']
-    X = df[feature_columns]
-    y = df['Potability']
-    
-    # Split data
-    X_train, X_test, y_train, y_test = train_test_split(
-        X, y, test_size=0.2, random_state=42, stratify=y
-    )
-    
-    print(f"\n🔄 Training set: {len(X_train)} samples")
-    print(f"🔄 Test set: {len(X_test)} samples")
-    
-    # Train improved model
-    print("\n🤖 Training Random Forest model...")
-    model = RandomForestClassifier(
-        n_estimators=200,  # More trees
-        random_state=42,
-        max_depth=15,
-        min_samples_split=10,
-        min_samples_leaf=5,
-        class_weight='balanced'  # Handle any class imbalance
-    )
-    
-    model.fit(X_train, y_train)
-    
-    # Evaluate model
-    print("\n🧪 Evaluating model...")
-    train_pred = model.predict(X_train)
-    test_pred = model.predict(X_test)
-    
-    train_acc = accuracy_score(y_train, train_pred)
-    test_acc = accuracy_score(y_test, test_pred)
-    
-    print(f"📈 Training Accuracy: {train_acc:.3f}")
-    print(f"📈 Test Accuracy: {test_acc:.3f}")
-    
-    # Feature importance
-    print(f"\n📊 Feature Importance:")
-    for feature, importance in zip(feature_columns, model.feature_importances_):
-        print(f"   {feature}: {importance:.3f}")
-    
-    # Test with specific examples
-    print(f"\n🧪 Testing specific examples:")
-    test_cases = [
-        ([7.0, 200, 300, 3.0], "Good water"),
-        ([4.5, 80, 45000, 11.0], "Bad water"),
-        ([8.8, 320, 800, 4.5], "Borderline water")
-    ]
-    
-    for features, description in test_cases:
-        X_test = np.array([features])
-        pred = model.predict(X_test)[0]
-        if hasattr(model, 'predict_proba'):
-            proba = model.predict_proba(X_test)[0]
-            conf = max(proba)
-            print(f"   {description}: {'SAFE' if pred==1 else 'UNSAFE'} (confidence: {conf:.2%})")
+    def _create_dynamic_analysis(self, ph, hardness, solids, chloramines, prediction, proba_values):
+        """Create dynamic analysis based on actual parameter values"""
+        
+        analysis_parts = []
+        
+        # pH Analysis
+        if ph < 6.5:
+            analysis_parts.append("🔴 **pH too acidic** - May cause corrosion and health issues")
+        elif ph > 8.5:
+            analysis_parts.append("🔴 **pH too alkaline** - May cause scaling and taste issues")
+        elif 6.5 <= ph <= 8.5:
+            analysis_parts.append("🟢 **pH within safe range** - Good for consumption")
         else:
-            print(f"   {description}: {'SAFE' if pred==1 else 'UNSAFE'}")
-    
-    # Save model
-    print(f"\n💾 Saving model...")
-    joblib.dump(model, 'model.joblib')
-    print("✅ Model saved as 'model.joblib'")
-    
-    # Verify saved model
-    print(f"\n🔄 Testing saved model...")
-    loaded_model = joblib.load('model.joblib')
-    test_input = np.array([[7.2, 180, 250, 2.5]])
-    prediction = loaded_model.predict(test_input)[0]
-    print(f"✅ Saved model test: {'SAFE' if prediction==1 else 'UNSAFE'}")
-    
-    print(f"\n🎉 Improved BioSentinel model ready!")
-    print(f"💡 This model should give varied predictions based on input parameters")
+            analysis_parts.append("🟡 **pH borderline** - Monitor closely")
+        
+        # Hardness Analysis
+        if hardness > 300:
+            analysis_parts.append("🟡 **High mineral content** - Very hard water")
+        elif hardness > 180:
+            analysis_parts.append("🟢 **Moderate mineral content** - Moderately hard water")
+        else:
+            analysis_parts.append("🟢 **Low to moderate hardness** - Acceptable levels")
+        
+        # Solids Analysis
+        if solids > 1000:
+            analysis_parts.append("🔴 **High dissolved solids** - Exceeds WHO guidelines")
+        elif solids > 500:
+            analysis_parts.append("🟡 **Elevated dissolved solids** - Above recommended levels")
+        else:
+            analysis_parts.append("🟢 **Dissolved solids acceptable** - Within safe range")
+        
+        # Chloramines Analysis
+        if chloramines > 4.0:
+            analysis_parts.append("🔴 **High chloramines** - Exceeds EPA maximum")
+        elif chloramines > 2.0:
+            analysis_parts.append("🟡 **Moderate chloramines** - Acceptable but elevated")
+        else:
+            analysis_parts.append("🟢 **Low chloramines** - Within safe limits")
+        
+        # Risk level based on prediction and confidence
+        if prediction == 1:
+            if proba_values is not None and max(proba_values) > 0.8:
+                risk_text = "🟢 **Low Risk** - High confidence in safety assessment"
+            elif proba_values is not None and max(proba_values) > 0.6:
+                risk_text = "🟡 **Moderate Confidence** - Generally safe but monitor"
+            else:
+                risk_text = "🟡 **Low Confidence** - Additional testing recommended"
+        else:
+            if proba_values is not None and max(proba_values) > 0.8:
+                risk_text = "🔴 **High Risk** - Strong indication of safety concerns"
+            elif proba_values is not None and max(proba_values) > 0.6:
+                risk_text = "🟡 **Moderate Risk** - Some safety concerns identified"
+            else:
+                risk_text = "🟡 **Uncertain Risk** - Requires professional testing"
+        
+        # Recommendations
+        if prediction == 0:
+            if ph < 6.5 or ph > 8.5:
+                recommendations = "💡 **Recommended Actions:** pH adjustment, professional water treatment"
+            elif solids > 1000:
+                recommendations = "💡 **Recommended Actions:** Filtration system, reverse osmosis treatment"
+            elif chloramines > 4.0:
+                recommendations = "💡 **Recommended Actions:** Carbon filtration, contact water utility"
+            else:
+                recommendations = "💡 **Recommended Actions:** Professional water testing, consider treatment options"
+        else:
+            recommendations = "💡 **Recommended Actions:** Regular monitoring, maintain current water source quality"
+        
+        return f"{risk_text}\n\n" + "\n".join(analysis_parts) + f"\n\n{recommendations}"
+
+    def _identify_concerns(self, ph, hardness, solids, chloramines):
+        """Identify specific parameter concerns"""
+        concerns = []
+        
+        if ph < 6.5 or ph > 8.5:
+            concerns.append("pH out of safe range")
+        if hardness > 300:
+            concerns.append("very hard water")
+        if solids > 500:
+            concerns.append("high dissolved solids")
+        if chloramines > 4.0:
+            concerns.append("excessive chloramines")
+            
+        return concerns
+
+    def _create_parameter_breakdown(self, ph, hardness, solids, chloramines) -> str:
+        """Create detailed parameter analysis"""
+        
+        analysis = "📊 **Parameter Analysis:**\n\n"
+        values = [ph, hardness, solids, chloramines]
+        units = ["", "(mg/L)", "(ppm)", "(ppm)"]
+        
+        # WHO/EPA standard ranges for reference
+        safe_ranges = {
+            "pH": (6.5, 8.5),
+            "Hardness": (0, 300),
+            "Solids": (0, 500),  # WHO guideline for TDS
+            "Chloramines": (0, 4.0)  # EPA maximum
+        }
+        
+        for i, (feature, value) in enumerate(zip(self.feature_columns, values)):
+            unit = units[i]
+            
+            # Determine status based on WHO/EPA guidelines
+            if feature in safe_ranges:
+                min_safe, max_safe = safe_ranges[feature]
+                if min_safe <= value <= max_safe:
+                    status = "✅ Within Safe Range"
+                    color = "🟢"
+                elif value < min_safe:
+                    status = "⚠️ Below Safe Range" 
+                    color = "🟡"
+                else:
+                    status = "❌ Above Safe Range"
+                    color = "🔴"
+            else:
+                status = "ℹ️ Measured"
+                color = "⚪"
+            
+            analysis += f"{color} **{feature}**: {value:.2f} {unit} - {status}\n"
+        
+        analysis += "\n📋 **Guidelines Used**: WHO & EPA Water Quality Standards"
+        return analysis
+
+# Initialize the predictor
+predictor = BioSentinelPredictor()
+
+def create_interface():
+    with gr.Blocks(
+        title="🧬 BioSentinel Water Quality Predictor",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            max-width: 1200px !important;
+        }
+        """
+    ) as interface:
+        
+        # Header
+        gr.Markdown("""
+        # 🧬 BioSentinel - Water Quality Predictor
+        
+        **AI-Powered Water Safety Assessment System**
+        
+        Enter water quality parameters below for instant safety analysis. This system uses machine learning 
+        to evaluate water potability based on critical physicochemical properties.
+        """)
+        
+        # Main interface
+        with gr.Row():
+            # Input Section
+            with gr.Column(scale=1):
+                gr.Markdown("### 🔬 Water Quality Parameters")
+                
+                ph_input = gr.Slider(
+                    minimum=3.0, maximum=9.5, value=7.0, step=0.1,
+                    label="🌊 pH Level",
+                    info="Acidity/Alkalinity measure (6.5-8.5 ideal)"
+                )
+                
+                hardness_input = gr.Slider(
+                    minimum=47.0, maximum=323.0, value=196.0, step=1.0,
+                    label="💎 Hardness (mg/L)",
+                    info="Calcium & magnesium content (0-300 acceptable)"
+                )
+                
+                solids_input = gr.Slider(
+                    minimum=320.0, maximum=61227.0, value=22000.0, step=100.0,
+                    label="⚪ Total Dissolved Solids (ppm)",
+                    info="Dissolved mineral content (<500 ideal)"
+                )
+                
+                chloramines_input = gr.Slider(
+                    minimum=0.35, maximum=13.13, value=7.0, step=0.1,
+                    label="🧪 Chloramines (ppm)",
+                    info="Disinfection byproducts (<4.0 safe)"
+                )
+                
+                # Analysis Button
+                predict_button = gr.Button(
+                    "🔍 Analyze Water Quality", 
+                    variant="primary", 
+                    size="lg",
+                    scale=1
+                )
+            
+            # Results Section  
+            with gr.Column(scale=1):
+                gr.Markdown("### 🎯 Analysis Results")
+                
+                # Main result
+                result_output = gr.Textbox(
+                    label="Safety Assessment",
+                    placeholder="Click 'Analyze Water Quality' to get results...",
+                    lines=2,
+                    max_lines=2
+                )
+                
+                # Detailed analysis
+                description_output = gr.Textbox(
+                    label="Detailed Analysis",
+                    placeholder="Detailed safety analysis will appear here...",
+                    lines=4,
+                    max_lines=6
+                )
+                
+                # Parameter breakdown
+                feature_output = gr.Textbox(
+                    label="Parameter Breakdown",
+                    placeholder="Individual parameter analysis will show here...",
+                    lines=8,
+                    max_lines=12
+                )
+        
+        # Connect prediction function
+        inputs = [ph_input, hardness_input, solids_input, chloramines_input]
+        outputs = [result_output, description_output, feature_output]
+        
+        predict_button.click(
+            fn=predictor.predict,
+            inputs=inputs,
+            outputs=outputs
+        )
+        
+        # Quick Examples Section
+        with gr.Row():
+            gr.Markdown("### 📋 Quick Test Examples")
+        
+        with gr.Row():
+            safe_btn = gr.Button("✅ Safe Water Sample", variant="secondary")
+            unsafe_btn = gr.Button("❌ Unsafe Water Sample", variant="secondary")
+            neutral_btn = gr.Button("⚖️ Borderline Sample", variant="secondary")
+        
+        # Example functions with more varied data
+        def load_safe_example():
+            return [7.2, 150.0, 250.0, 2.5]  # Really good quality water
+        
+        def load_unsafe_example():
+            return [4.5, 50.0, 45000.0, 11.0]  # Really poor quality water
+        
+        def load_borderline_example():
+            return [8.8, 320.0, 800.0, 4.5]  # Borderline case with multiple issues
+        
+        # Connect example buttons
+        safe_btn.click(load_safe_example, outputs=inputs)
+        unsafe_btn.click(load_unsafe_example, outputs=inputs)
+        neutral_btn.click(load_borderline_example, outputs=inputs)
+        
+        # Footer
+        gr.Markdown("""
+        ---
+        ### ⚠️ Important Disclaimer
+        
+        This tool provides **AI-based predictions for educational and research purposes only**. 
+        For official water quality certification and regulatory compliance, always consult:
+        - Certified water testing laboratories
+        - Local health departments  
+        - Environmental protection agencies
+        
+        ### 🔬 About This Model
+        
+        - **Technology**: Machine Learning classification model
+        - **Parameters**: pH, Hardness, Total Dissolved Solids, Chloramines
+        - **Standards**: Based on WHO and EPA water quality guidelines
+        - **Purpose**: Educational demonstration of AI in water quality assessment
+        
+        **Built with ❤️ for water quality research and education**
+        """)
     
-    return model
+    return interface
+
+# Create the interface
+demo = create_interface()
 
+# Launch the app
 if __name__ == "__main__":
-    model = train_improved_model()
+    demo.launch()