Create app.py

app.py

@@ -0,0 +1,441 @@
+import streamlit as st
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+import plotly.express as px
+import numpy as np
+import xgboost as xgb
+import os
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
+
+# Set page configuration at the very top
+st.set_page_config(page_title="Healthcare Dashboard", layout="wide", page_icon="💡")
+
+# Define human-readable labels for prediction outcomes 
+OUTCOME_MAP = {
+    0: "Patient recovered and went home",
+    1: "Transferred to another hospital or care center",
+    2: "Transferred to a rehab center",
+    3: "Left the hospital early without approval",
+    4: "Passed away or had a very serious event",
+}
+
+# Function to load the model
+def load_model():
+    try:
+        model = xgb.XGBClassifier()
+        model.load_model("xgboost_patient_model.json")
+        return model
+    except Exception as e:
+        st.error(f"Error loading model: {e}")
+        return None
+
+# Ensure data matches model's feature requirements
+def preprocess_data(data, model_features):
+    try:
+        data = data.apply(pd.to_numeric, errors='coerce')
+        missing_features = [f for f in model_features if f not in data.columns]
+        extra_features = [f for f in data.columns if f not in model_features]
+        
+        if missing_features:
+            st.error(f"❌ Missing required features: {missing_features}")
+            return None
+        if extra_features:
+            st.warning(f"⚠️ Extra features in uploaded data: {extra_features}")
+        
+        return data[model_features]
+    except Exception as e:
+        st.error(f"Data preprocessing error: {e}")
+        return None
+
+# Predict patient outcomes
+def predict_outcome(model, data):
+    if model is None:
+        return None, None, None, None
+    
+    actual_target = data.pop("target") if "target" in data.columns else None
+    
+    try:
+        model_features = model.get_booster().feature_names
+        data = preprocess_data(data, model_features)
+        if data is None:
+            return None, None, None, None
+            
+        predictions = model.predict(data)
+        
+        # Convert numerical predictions to human-readable labels
+        mapped_predictions = [OUTCOME_MAP[pred] for pred in predictions]
+        actual_labels = [OUTCOME_MAP[actual] for actual in actual_target] if actual_target is not None else ["N/A"] * len(predictions)
+        
+        # Debugging information
+        if actual_target is not None:
+            correct_predictions = (predictions == actual_target).sum()
+            total_predictions = len(actual_target)
+            accuracy = (correct_predictions / total_predictions) * 100
+            st.write(f"✅ Correct Predictions: {correct_predictions}/{total_predictions}")
+            st.write(f"📊 Model Accuracy: **{accuracy:.2f}%**")
+        
+        return actual_target, predictions, mapped_predictions, actual_labels
+    except Exception as e:
+        st.error(f"Prediction error: {e}")
+        return None, None, None, None
+
+# Load the data
+file_path = 'final_cleaned_patient_data.csv'
+try:
+    df = pd.read_csv(file_path)
+except Exception as e:
+    st.error(f"Error loading data: {e}")
+    df = pd.DataFrame()  # Create empty DataFrame if file doesn't exist
+
+# Sidebar navigation
+st.sidebar.title('Healthcare Data Dashboard')
+
+# Team Members Section
+st.sidebar.markdown("### 🏆 Team Members:")
+team_members = [
+    "1. R. Sai Somnath",
+    "2. S. Sreevardhan", 
+    "3. S. Mohammad Basha", 
+    "4. V. Hussain Basha", 
+    "5. P. Charles"
+]
+for member in team_members:
+    st.sidebar.text(member)
+
+# Add a divider
+st.sidebar.markdown("---")
+
+# Section navigation - Added two new sections
+option = st.sidebar.selectbox('Choose a section', [
+    'Data Overview', 
+    'Data Visualization', 
+    'Interactive Reports', 
+    'Correlation Analysis', 
+    'Data Insights', 
+    'Patient Outcome Prediction', 
+    'Batch Prediction', 
+    'Model Performance'
+])
+
+# Apply a Streamlit theme with a dark background for a modern look
+st.markdown("""
+    <style>
+        h1 { color: #00FFAA; }
+        .stApp { background-color: #121212; color: #FFFFFF; }
+        .sidebar .sidebar-content { background-color: #333333; color: #FFFFFF; }
+        .css-1d391kg { color: #FFFFFF; }
+        .css-18e3th9 { background-color: #1E1E1E; }
+    </style>
+""", unsafe_allow_html=True)
+
+# Data Overview Section
+if option == 'Data Overview':
+    st.title('📊 Data Overview')
+    st.write(df.head())
+    st.write(f"Dataset Shape: {df.shape}")
+    st.write(f"Column Names: {df.columns.tolist()}")
+    st.write("Basic Statistical Overview:")
+    st.write(df.describe())
+
+    if st.checkbox('Show Missing Values'): 
+        st.write(df.isnull().sum())
+
+# Data Visualization Section
+elif option == 'Data Visualization':
+    st.title('📈 Data Visualization')
+    column = st.selectbox('Select Column for Visualization', df.columns)
+    plot_type = st.radio('Choose plot type', ['Histogram', 'Boxplot', 'Violin Plot', 'Scatter Plot', 'Line Plot', 'Animated Plot'])
+
+    if plot_type == 'Animated Plot':
+        time_col = st.selectbox('Select Time Column (if applicable)', df.columns)
+        fig = px.scatter(df, x=column, y=column, animation_frame=time_col, size_max=60)
+    elif plot_type == 'Histogram':
+        fig = px.histogram(df, x=column, marginal='box', nbins=30)
+    elif plot_type == 'Boxplot':
+        fig = px.box(df, y=column)
+    elif plot_type == 'Violin Plot':
+        fig = px.violin(df, y=column, box=True, points='all')
+    elif plot_type == 'Scatter Plot':
+        x_col = st.selectbox('Select X axis', df.columns)
+        fig = px.scatter(df, x=x_col, y=column, color=column)
+    elif plot_type == 'Line Plot':
+        x_col = st.selectbox('Select X axis for Line Plot', df.columns)
+        fig = px.line(df, x=x_col, y=column)
+    
+    st.plotly_chart(fig)
+
+# Correlation Analysis Section
+elif option == 'Correlation Analysis':
+    st.title('🔎 Correlation Analysis')
+    corr_matrix = df.corr()
+    fig, ax = plt.subplots(figsize=(12, 8))
+    sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', fmt='.2f', ax=ax)
+    st.pyplot(fig)
+
+# Interactive Reports Section
+elif option == 'Interactive Reports':
+    st.title('📂 Interactive Reports')
+    st.write("Filter and explore the data.")
+    selected_columns = st.multiselect('Select columns to display', df.columns)
+    st.dataframe(df[selected_columns] if selected_columns else df)
+
+    st.write("Filter the Data:")
+    filter_column = st.selectbox('Select column to filter by', df.columns)
+    filter_value = st.text_input('Enter filter value')
+    if filter_value:
+        filtered_data = df[df[filter_column].astype(str).str.contains(filter_value, case=False)]
+        st.write(filtered_data)
+        
+        # Download option
+        csv_data = filtered_data.to_csv(index=False).encode('utf-8')
+        st.download_button(label='Download Filtered Data as CSV', data=csv_data, file_name='filtered_data.csv', mime='text/csv')
+
+# Data Insights Section
+elif option == 'Data Insights':
+    st.title('🧠 Data Insights')
+    st.write("Gain insights into the data using various metrics.")
+    st.write("Total Unique Values per Column:")
+    st.write(df.nunique())
+    
+    st.write("Top 5 Frequent Values for Each Column:")
+    for col in df.columns:
+        st.write(f"{col}: {df[col].value_counts().head(5)}")
+
+# Patient Outcome Prediction Section
+elif option == 'Patient Outcome Prediction':
+    st.title('🤖 Patient Outcome Prediction')
+    
+    # Load the pre-trained model
+    model = load_model()
+    
+    if model is not None:
+        st.success("✅ Pre-trained model loaded successfully!")
+        
+        # Define class descriptions
+        class_descriptions = {
+            0: "Patient recovered and went home",
+            1: "Patient transferred to another hospital",
+            2: "Patient moved to rehab facility",
+            3: "Patient left against medical advice",
+            4: "Patient deceased or serious outcome"
+        }
+        
+        # Display target class distribution if target column exists
+        target_column = 'target'
+        if target_column in df.columns:
+            st.subheader("Target Class Distribution")
+            target_counts = df[target_column].value_counts().reset_index()
+            target_counts.columns = ['Class', 'Count']
+            target_counts['Description'] = target_counts['Class'].map(class_descriptions)
+            st.write(target_counts)
+            
+            fig = px.pie(target_counts, values='Count', names='Description', title='Target Class Distribution')
+            st.plotly_chart(fig)
+        
+        # Prediction interface
+        st.subheader("Make Predictions")
+        st.write("Enter values for the features to predict the patient outcome:")
+        
+        # Create a more interactive UI for prediction with all input values
+        col1, col2, col3 = st.columns(3)
+        
+        # Create input fields for all required features
+        input_values = {}
+        
+        with col1:
+            input_values['age'] = st.number_input("Age", min_value=0, max_value=120, value=51)
+            input_values['gender'] = st.selectbox("Gender", [0, 1], index=1, format_func=lambda x: "Male" if x == 0 else "Female")
+            input_values['previous_hospitalizations'] = st.number_input("Previous Hospitalizations", min_value=0, value=4)
+            input_values['heart_rate'] = st.number_input("Heart Rate", min_value=30, max_value=200, value=63)
+            input_values['respiratory_rate'] = st.number_input("Respiratory Rate", min_value=5, max_value=60, value=16)
+            input_values['blood_pressure_sys'] = st.number_input("Blood Pressure (Systolic)", min_value=50, max_value=250, value=86)
+            input_values['blood_pressure_dia'] = st.number_input("Blood Pressure (Diastolic)", min_value=30, max_value=150, value=58)
+            input_values['temperature'] = st.number_input("Temperature (°C)", min_value=35.0, max_value=42.0, value=35.86, step=0.1)
+            input_values['wbc_count'] = st.number_input("WBC Count", min_value=0.0, max_value=50.0, value=7.15, step=0.1)
+            input_values['creatinine'] = st.number_input("Creatinine", min_value=0.1, max_value=10.0, value=2.93, step=0.1)
+
+        with col2:
+            input_values['bilirubin'] = st.number_input("Bilirubin", min_value=0.1, max_value=30.0, value=1.72, step=0.1)
+            input_values['glucose'] = st.number_input("Glucose", min_value=40, max_value=500, value=137)
+            input_values['bun'] = st.number_input("BUN", min_value=5, max_value=150, value=36)
+            input_values['pH'] = st.number_input("pH", min_value=6.8, max_value=7.8, value=7.34, step=0.01)
+            input_values['pao2'] = st.number_input("PaO2", min_value=40, max_value=300, value=72)
+            input_values['pco2'] = st.number_input("PCO2", min_value=20, max_value=100, value=58)
+            input_values['fio2'] = st.number_input("FiO2", min_value=0.21, max_value=1.0, value=0.88, step=0.01)
+            input_values['gcs'] = st.slider("GCS Score", 3, 15, 5)
+            input_values['comorbidity_index'] = st.slider("Comorbidity Index", 0, 10, 1)
+            input_values['admission_source'] = st.selectbox("Admission Source", [0, 1, 2, 3], index=1, format_func=lambda x: ["Emergency", "OPD", "Transfer", "Other"][x])
+
+        with col3:
+            input_values['elective_surgery'] = st.selectbox("Elective Surgery", [0, 1], index=1, format_func=lambda x: "No" if x == 0 else "Yes")
+            input_values['num_medications'] = st.number_input("Number of Medications", min_value=0, value=18)
+            input_values['charlson_comorbidity_index'] = st.slider("Charlson Comorbidity Index", 0, 15, 1)
+            input_values['ews_score'] = st.slider("EWS Score", 0, 20, 7)
+            input_values['severity_score'] = st.slider("Severity Score", 0, 10, 4)
+            input_values['bed_occupancy_rate'] = st.slider("Bed Occupancy Rate (%)", 50, 100, int(68.67))
+            input_values['staff_to_patient_ratio'] = st.slider("Staff to Patient Ratio", 0.1, 2.0, 0.99, step=0.1)
+            input_values['past_icu_admissions'] = st.number_input("Past ICU Admissions", min_value=0, value=2)
+            input_values['previous_surgery'] = st.selectbox("Previous Surgery", [0, 1], index=1, format_func=lambda x: "No" if x == 0 else "Yes")
+            input_values['high_risk_treatment'] = st.selectbox("High Risk Treatment", [0, 1], index=1, format_func=lambda x: "No" if x == 0 else "Yes")
+            input_values['discharge_support'] = st.selectbox("Discharge Support", [0, 1], index=0, format_func=lambda x: "No" if x == 0 else "Yes")
+
+        
+        if st.button("Predict Outcome"):
+            # Define input columns (must match your model's expected input features)
+            input_columns = [
+                'age', 'gender', 'previous_hospitalizations', 'heart_rate',
+                'respiratory_rate', 'blood_pressure_sys', 'blood_pressure_dia',
+                'temperature', 'wbc_count', 'creatinine', 'bilirubin', 'glucose', 'bun',
+                'pH', 'pao2', 'pco2', 'fio2', 'gcs', 'comorbidity_index',
+                'admission_source', 'elective_surgery', 'num_medications',
+                'charlson_comorbidity_index', 'ews_score', 'severity_score',
+                'bed_occupancy_rate', 'staff_to_patient_ratio', 'past_icu_admissions',
+                'previous_surgery', 'high_risk_treatment', 'discharge_support'
+            ]
+            
+            # Create a sample input for prediction (using a template from your dataset)
+            if len(df) > 0:
+                sample_input = pd.DataFrame([{col: 0 for col in input_columns}])
+                
+                # Update with user inputs
+                for feature, value in input_values.items():
+                    if feature in sample_input.columns:
+                        sample_input[feature] = value
+                
+                # Make prediction
+                try:
+                    prediction = model.predict(sample_input)[0]
+                    prediction_proba = model.predict_proba(sample_input)[0]
+                    
+                    # Display prediction
+                    st.subheader("Prediction Result")
+                    st.write(f"Predicted Class: {prediction} - {class_descriptions.get(prediction, 'Unknown')}")
+                    
+                    # Display probability for each class
+                    st.write("Prediction Probabilities:")
+                    proba_df = pd.DataFrame({
+                        'Class': [class_descriptions.get(i, f"Class {i}") for i in range(len(prediction_proba))],
+                        'Probability': prediction_proba
+                    })
+                    fig = px.bar(proba_df, x='Class', y='Probability', title='Prediction Probabilities')
+                    st.plotly_chart(fig)
+                except Exception as e:
+                    st.error(f"Error making prediction: {e}")
+            else:
+                st.error("Dataset is empty, cannot create input template.")
+    else:
+        st.error("Failed to load model. Please check if 'xgboost_patient_model.json' exists in the current directory.")
+
+# NEW SECTION 1: Batch Prediction
+elif option == 'Batch Prediction':
+    st.title("🏥 Batch Patient Outcome Prediction")
+    st.write("Upload a CSV file with patient data to predict outcomes for multiple patients at once.")
+  
+    uploaded_file = st.file_uploader("📂 Upload CSV file", type=["csv"])
+  
+    if uploaded_file is not None:
+        batch_df = pd.read_csv(uploaded_file)
+        batch_df = batch_df.dropna().reset_index(drop=True)
+        
+        st.write("## Preview of Uploaded Data")
+        st.dataframe(batch_df.head(), use_container_width=True)
+        
+        model = load_model()
+        actual_target, predicted_classes, predicted_outcomes, actual_outcomes = predict_outcome(model, batch_df.copy())
+        
+        if predicted_classes is not None:
+            st.write("## 🏥 Prediction Results")
+            result_df = pd.DataFrame({
+                "Patient ID": range(1, len(predicted_classes) + 1),
+                "Actual Class": actual_target if actual_target is not None else ["N/A"] * len(predicted_classes),
+                "Predicted Class": predicted_classes,
+                "Predicted Outcome": predicted_outcomes
+            })
+            st.dataframe(result_df, use_container_width=True)
+            
+            # Add visualization of batch prediction results
+            st.write("## Prediction Distribution")
+            results_count = pd.Series(predicted_outcomes).value_counts().reset_index()
+            results_count.columns = ['Predicted Outcome', 'Count']
+            fig = px.pie(results_count, values='Count', names='Predicted Outcome', 
+                         title='Distribution of Predicted Outcomes')
+            st.plotly_chart(fig)
+            
+            # Offer download of results
+            csv_results = result_df.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="Download Prediction Results",
+                data=csv_results,
+                file_name="patient_predictions.csv",
+                mime="text/csv"
+            )
+
+# NEW SECTION 2: Model Performance
+elif option == 'Model Performance':
+    st.title("📊 Model Performance Analysis")
+    
+    # Check if data exists and contains target variable
+    if len(df) > 0 and 'target' in df.columns:
+        st.write("Analyze the model's performance on the dataset.")
+        
+        # Split data into features and target
+        X = df.drop(columns=["target"])  # Features
+        y = df["target"]  # Target
+        
+        # Split data for testing
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=0.2, random_state=42, stratify=y
+        )
+        
+       
+        
+        # Load the model
+        model = load_model()
+        
+        if model is not None:
+            # Make predictions
+            try:
+                y_pred = model.predict(X_test)
+                y_prob = model.predict_proba(X_test)
+                
+                # Calculate metrics
+                accuracy = accuracy_score(y_test, y_pred)
+                conf_matrix = confusion_matrix(y_test, y_pred)
+                class_report = classification_report(y_test, y_pred, output_dict=True)
+                
+                # Display metrics
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.metric("Model Accuracy", f"{accuracy:.2%}")
+                    
+                    # Plot confusion matrix
+                    st.write("### Confusion Matrix")
+                    fig, ax = plt.subplots(figsize=(10, 8))
+                    sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', ax=ax)
+                    ax.set_xlabel('Predicted Labels')
+                    ax.set_ylabel('True Labels')
+                    st.pyplot(fig)
+                
+                with col2:
+                    # Plot classification report
+                    st.write("### Classification Report")
+                    report_df = pd.DataFrame(class_report).transpose()
+                    st.dataframe(report_df.style.format({
+                        'precision': '{:.2f}',
+                        'recall': '{:.2f}',
+                        'f1-score': '{:.2f}',
+                        'support': '{:.0f}'
+                    }))
+                
+                
+            except Exception as e:
+                st.error(f"Error performing analysis: {e}")
+        else:
+            st.error("Model could not be loaded. Please check if the model file exists.")
+    else:
+        st.error("Cannot perform model analysis. Dataset is empty or missing target variable.")
+
+st.sidebar.write("Forecasting discharge outcomes for critically ILL patients using machine learning")