app.py

# app.py - Fixed for 4-feature BioSentinel Model
import gradio as gr
import joblib
import numpy as np
from typing import Tuple

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
        
        # Only 4 features to match your trained model
        self.feature_columns = [
            "pH",
            "Hardness", 
            "Solids",
            "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.", ""
        
        try:
            # Create input array with exactly 4 features (matching your model)
            features = np.array([[ph, hardness, solids, chloramines]])
            
            # Debug: Print input values
            print(f"🔍 Input values: pH={ph}, Hardness={hardness}, Solids={solids}, Chloramines={chloramines}")
            
            # Make prediction
            prediction = self.model.predict(features)[0]
            print(f"🎯 Model prediction: {prediction}")
            
            # 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}")
            
            # 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 _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:
            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 interface

# Create the interface
demo = create_interface()

# Launch the app
if __name__ == "__main__":
    demo.launch()