DiaRisk Elite: Final LFS Production Build

.gitattributes

@@ -0,0 +1,3 @@
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,26 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+.tox/
+.venv
+venv/
+ENV/
+env/
+
+# Streamlit
+.streamlit/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Large Project Folders (Now optimized to <15MB each - INCLUDED)
+# models/
+data/
+
+# IDEs
+.vscode/
+.idea/
+.ipynb_checkpoints/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Divyanshi Singh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,59 @@
+---
+title: DiaRisk-Advanced Detection Engine
+emoji: 🩺
+colorFrom: blue
+colorTo: teal
+sdk: streamlit
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 🛡️ DiaRisk-Advanced Detection Engine
+
+**DiaRisk** is a professional-grade clinical diagnostic system designed to identify Type 2 Diabetes risk patterns by transforming 253k+ CDC real-world health records into actionable medical insights.
+
+[![Streamlit App](https://static.streamlit.io/badges/streamlit_badge_svg?color=blue)](https://huggingface.co/spaces/YOUR_USERNAME/diarisk-detection-engine)
+[![License: MIT](https://img.shields.io/badge/License-MIT-teal.svg)](https://opensource.org/licenses/MIT)
+
+## 🩺 Project Intelligence & Mission
+The core challenge in diabetes screening is balancing **Sensitivity (Recall)** vs. **Accuracy**. Missing a high-risk patient is clinically dangerous. DiaRisk addresses this by providing two optimized model tiers:
+1.  **Recall-Optimized XGBoost**: Designed for clinical safety, ensuring 79% of potential cases are flagged for screening.
+2.  **Elite Stacked Ensemble**: An advanced booster blending XGBoost, LightGBM, and CatBoost for a peak **86.4% Accuracy**.
+
+## 📊 Key Clinical Insights
+Our exploratory analysis of the CDC BRFSS dataset revealed critical risk drivers:
+*   **Obesity Impact**: Patients with BMI ≥ 30 show a **3x higher risk** of diabetes compared to those at a healthy weight.
+*   **Age Progression**: Risk doubles for every two age categories above 40, with a sharp spike after age 45.
+*   **General Health**: Self-assessed "Poor" or "Fair" health status is the strongest non-clinical predictor of current diabetic status.
+
+## 🏆 Model Performance
+| Model Tier | Accuracy | AUC-ROC | Recall (Sensitivity) | Focus |
+|:---|:---|:---|:---|:---|
+| **Elite Ensemble** | **86.4%** | **0.83** | 21% | Technical Precision |
+| **XGBoost (Recall)** | 72.2% | **0.83** | **79.3%** | Clinical Safety |
+
+## 🛠️ Technology Stack
+- **Languages**: Python 3.10+
+- **Boosters**: XGBoost, LightGBM, CatBoost
+- **Ensemble**: Scikit-learn StackingClassifier
+- **Dashboard**: Streamlit (Navy/Dark Clinical UI)
+- **Visuals**: Plotly, Seaborn, Matplotlib
+
+## 📂 Repository Structure
+```text
+├── data/               # Raw & Processed CDC Datasets
+├── models/             # Serialized (.pkl) Elite Model Checkpoints
+├── pipeline/           # End-to-end ML Scripts (EDA, Prep, Train, Eval)
+├── outputs/            # Diagnostic Visualizations & Metrics
+├── app.py              # Main Dashboard Entry Point
+└── path_utils.py       # Global Path Management Utility
+```
+
+## 🏗️ Installation & Usage
+1. Clone the repository: `git clone https://github.com/Divyanshi018572/diarisk-detection-engine.git`
+2. Install dependencies: `pip install -r requirements.txt`
+3. Launch Dashboard: `streamlit run app.py`
+
+---
+**Build by Divyanshi Singh** | [GitHub](https://github.com/Divyanshi018572) | [LinkedIn](https://www.linkedin.com/in/divyanshi-singh-ds/)

app.py

@@ -0,0 +1,427 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import joblib
+import os
+import plotly.graph_objects as go
+import matplotlib.pyplot as plt
+import seaborn as sns
+from PIL import Image
+
+# Path management
+import path_utils
+
+# --- PAGE CONFIG ---
+st.set_page_config(
+    page_title="DiaRisk-Advanced Detection Engine",
+    page_icon="🩺",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# --- CUSTOM NAVY DARK THEME CSS ---
+st.markdown("""
+<style>
+    /* Main Background & Text */
+    .main {
+        background-color: #0c121c;
+        color: #ffffff;
+    }
+    
+    /* Global Text Color */
+    html, body, [class*="st-"] {
+        color: #e0e0e0 !important;
+    }
+    
+    /* Sidebar styling */
+    [data-testid="stSidebar"] {
+        background-color: #16213e;
+        border-right: 1px solid #1f4068;
+    }
+    
+    /* Headers */
+    h1, h2, h3, h4, h5, h6 {
+        color: #2ec4b6 !important;
+        font-family: 'Inter', sans-serif;
+    }
+    
+    /* Input Fields Border & Background */
+    div[data-baseweb="input"], div[data-baseweb="select"], div[data-baseweb="textarea"] {
+        background-color: #1b263b !important;
+        border: 1px solid #334e68 !important;
+        border-radius: 8px !important;
+    }
+    
+    /* Checkbox & Radio Labels */
+    .stCheckbox label, .stRadio label {
+        color: #ffffff !important;
+        font-weight: 500 !important;
+    }
+    
+    /* Button Styling */
+    .stButton>button {
+        width: 100%;
+        border-radius: 12px;
+        height: 3.5em;
+        background: linear-gradient(135deg, #4361ee 0%, #3a0ca3 100%);
+        color: white;
+        font-weight: bold;
+        border: none;
+        transition: all 0.3s ease;
+        box-shadow: 0 4px 15px rgba(67, 97, 238, 0.3);
+    }
+    
+    .stButton>button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 6px 20px rgba(67, 97, 238, 0.5);
+        color: #ffffff;
+    }
+    
+    /* Custom Risk Cards */
+    .risk-card {
+        padding: 25px;
+        border-radius: 15px;
+        background: rgba(22, 33, 62, 0.8);
+        border: 1px solid #334e68;
+        box-shadow: 0 8px 32px 0 rgba(0, 0, 0, 0.3);
+        backdrop-filter: blur(10px);
+    }
+    
+    .driver-item {
+        font-size: 1.05em;
+        padding: 10px;
+        margin-bottom: 5px;
+        background: rgba(27, 38, 59, 0.6);
+        border-radius: 8px;
+        border-left: 4px solid #4361ee;
+    }
+    
+    /* Tabs styling */
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 10px;
+        background-color: #0c121c;
+    }
+    
+    .stTabs [data-baseweb="tab"] {
+        height: 50px;
+        white-space: pre-wrap;
+        background-color: #16213e;
+        border-radius: 8px 8px 0 0;
+        gap: 1px;
+        padding-top: 10px;
+        padding-bottom: 10px;
+        color: #ffffff !important;
+    }
+    
+    .stTabs [data-baseweb="tab"]:hover {
+        background-color: #1f4068;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# --- LOAD MODELS ---
+@st.cache_resource
+def load_assets():
+    models = {
+        '⭐ Elite Ensemble (Max Accuracy)': joblib.load(path_utils.get_models_path("elite_ensemble.pkl")),
+        'XGBoost (Recall Optimized)': joblib.load(path_utils.get_models_path("xgboost_model.pkl")),
+        'Logistic Regression': joblib.load(path_utils.get_models_path("logistic_regression.pkl")),
+        'Random Forest': joblib.load(path_utils.get_models_path("random_forest.pkl")),
+        'Naive Bayes': joblib.load(path_utils.get_models_path("naive_bayes.pkl"))
+    }
+    scaler = joblib.load(path_utils.get_models_path("scaler.pkl"))
+    return models, scaler
+
+models, scaler = load_assets()
+
+# --- SIDEBAR ---
+st.sidebar.image("https://img.icons8.com/color/96/diabetes.png", width=100)
+st.sidebar.title("App Intelligence")
+selected_model_name = st.sidebar.selectbox("Predictive Engine", list(models.keys()))
+threshold = st.sidebar.slider("Risk Cutoff Threshold", 0.3, 0.7, 0.5, 0.05)
+st.sidebar.info("Adjust threshold to balance medical sensitivity vs precision.")
+
+st.sidebar.divider()
+st.sidebar.markdown("### 📊 Project Insights")
+st.sidebar.write("""
+This tool analyzes 22 health indicators from the CDC BRFSS dataset (253k rows) to quantify Diabetes risk.
+""")
+
+# --- TABS ---
+tab0, tab1, tab2, tab3, tab4 = st.tabs([
+    "📄 Project Overview",
+    "🏥 Patient Risk Portal", 
+    "📊 Population Explorer", 
+    "📈 Model Calibration", 
+    "⚖️ Disclaimer"
+])
+
+# --- TAB 0: PROJECT OVERVIEW ---
+with tab0:
+    st.title("🛡️ DiaRisk-Advanced Detection Engine")
+    st.markdown("""
+    **DiaRisk** is a professional-grade clinical detection engine that transforms 253k+ CDC records into actionable health insights. 
+    By leveraging a high-recall XGBoost and an Elite Stacked Ensemble, it identifies Type 2 Diabetes risk patterns with **86.4% accuracy**. 
+    Designed for clinical pre-screening, it empowers early intervention through expert analytics and real-time risk stratification.
+    """)
+    
+    col_ov1, col_ov2 = st.columns([1, 1])
+    with col_ov1:
+        st.subheader("The Problem Statement")
+        st.info("""
+        **Mission:** Identify high-risk individuals for Type 2 Diabetes using lifestyle and demographic indicators.
+        
+        **Challenge:** How do we balance 'False Alarms' (Precision) vs. 'Missing Patients' (Recall)? 
+        In clinical environments, **Missing a diabetic case is 10x more costly than a false alarm.**
+        """)
+        
+    with col_ov2:
+        st.subheader("Performance Strategy")
+        st.write("""
+        We implemented two distinct model philosophies:
+        1. **Precision Elite (Stacked Ensemble):** Maximizes global Accuracy (86.4%).
+        2. **Clinical Heavyweight (Recall Opt XGB):** Maximizes detection of patients (79% Recall).
+        """)
+
+    st.divider()
+    
+    st.subheader("🏆 The 'Best Overall' Model Analysis")
+    st.markdown("""
+    According to the clinical problem statement, the **XGBoost (Recall Optimized)** is the best overall performer.
+    
+    | Model Tier | Metric Focus | Clinical Value |
+    |:---|:---|:---|
+    | **XGBoost (Recall Opt)** | **79% Sensitivity** | **High Utility** - Highest safety net for patient screening. |
+    | **Elite Ensemble** | **86.4% Accuracy** | **Technical Excellence** - Best for population-wide statistics. |
+    
+    ### **Why Recall Opt XGB Wins?**
+    In medical screening, our goal is to capture as many 'True Positive' risk profiles as possible. While the Elite Ensemble is more accurate overall, the Recall-Optimized model ensures more people are flagged for clinical HbA1c testing, directly supporting early intervention.
+    """)
+    st.caption("Intelligence Analysis built with 5Base Models + Stacked Ensemble Classifiers.")
+
+# --- TAB 1: ASSESSMENT ---
+with tab1:
+    st.title("🩺 Clinical Risk Assessment")
+    st.write("Complete the profile below for a real-time risk evaluation.")
+    
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.subheader("Demographics")
+        age_map = {
+            "18-24": 1, "25-29": 2, "30-34": 3, "35-39": 4, "40-44": 5,
+            "45-49": 6, "50-54": 7, "55-59": 8, "60-64": 9, "65-69": 10,
+            "70-74": 11, "75-79": 12, "80+": 13
+        }
+        age = st.selectbox("Current Age Range", list(age_map.keys()))
+        sex = st.radio("Biological Gender", ["Female", "Male"], horizontal=True)
+        
+        st.subheader("Primary Metrics")
+        bmi = st.number_input("Body Mass Index (BMI)", 10.0, 100.0, 25.0)
+        # WHO Category feedback
+        if bmi < 18.5: st.warning(f"Classification: Underweight")
+        elif bmi < 25: st.success(f"Classification: Healthy Weight")
+        elif bmi < 30: st.info(f"Classification: Overweight")
+        else: st.error(f"Classification: Clinically Obese")
+        
+        gen_hlth_map = {"Excellent": 1, "Very Good": 2, "Good": 3, "Fair": 4, "Poor": 5}
+        gen_hlth = st.radio("Self-Assessed General Health", list(gen_hlth_map.keys()), horizontal=True)
+
+    with col2:
+        st.subheader("Clinical History")
+        high_bp = st.checkbox("Diagnosed Hypertension (High BP)")
+        high_chol = st.checkbox("Diagnosed Dyslipidemia (High Chol)")
+        chol_check = st.checkbox("Cholesterol Screening (Past 5 Years)", value=True)
+        heart_disease = st.checkbox("History of Cardiac Events (Heart Disease)")
+        stroke = st.checkbox("History of Cerebrovascular Events (Stroke)")
+        
+        st.subheader("Lifestyle Factors")
+        smoker = st.checkbox("Smoked 100+ Cigarettes in Lifetime")
+        phys_active = st.checkbox("Regular Physical Activity", value=True)
+        fruits = st.checkbox("Consume Fruits Daily", value=True)
+        veggies = st.checkbox("Consume Veggies Daily", value=True)
+        hvy_alcohol = st.checkbox("Heavy Alcohol Intake")
+        
+        diff_walk = st.checkbox("Difficulty with Mobility (Climbing/Walking)")
+        ment_hlth = st.slider("Days of Poor Mental Health (Monthly)", 0, 30, 0)
+        phys_hlth = st.slider("Days of Poor Physical Health (Monthly)", 0, 30, 0)
+        
+        # Required for features but less prominent
+        income_map = {"<$10k": 1, "$10k-15k": 2, "$15k-20k": 3, "$20k-25k": 4, "$25k-35k": 5, "$35k-50k": 6, "$50k-75k": 7, "$75k+": 8}
+        income = 5 # Defaulting
+        edu_map = {"No HS": 1, "Elem": 2, "Some HS": 3, "HS Grad": 4, "Some College": 5, "Coll Grad": 6}
+        edu = 4 # Defaulting
+        healthcare = 1 # Defaulting
+        doc_cost = 0 # Defaulting
+
+    # Prepare Data
+    input_data = {
+        'HighBP': int(high_bp), 'HighChol': int(high_chol), 'CholCheck': int(chol_check),
+        'BMI': bmi, 'Smoker': int(smoker), 'Stroke': int(stroke),
+        'HeartDiseaseorAttack': int(heart_disease), 'PhysActivity': int(phys_active),
+        'Fruits': int(fruits), 'Veggies': int(veggies), 'HvyAlcoholConsump': int(hvy_alcohol),
+        'AnyHealthcare': healthcare, 'NoDocbcCost': doc_cost, 
+        'GenHlth': gen_hlth_map[gen_hlth], 'MentHlth': float(ment_hlth), 'PhysHlth': float(phys_hlth),
+        'DiffWalk': int(diff_walk), 'Sex': 1 if sex == "Male" else 0, 'Age': age_map[age],
+        'Education': edu, 'Income': income
+    }
+    input_data['BMI_OBESE'] = 1 if bmi >= 30 else 0
+    input_data['HIGH_RISK_COMBO'] = 1 if (high_bp and high_chol) else 0
+    phys_hlth_flag = 1 if phys_hlth > 14 else 0
+    input_data['POOR_HEALTH_SCORE'] = input_data['GenHlth'] + input_data['DiffWalk'] + phys_hlth_flag
+    
+    feature_cols = ['HighBP', 'HighChol', 'CholCheck', 'BMI', 'Smoker', 'Stroke', 'HeartDiseaseorAttack', 'PhysActivity', 'Fruits', 'Veggies', 'HvyAlcoholConsump', 'AnyHealthcare', 'NoDocbcCost', 'GenHlth', 'MentHlth', 'PhysHlth', 'DiffWalk', 'Sex', 'Age', 'Education', 'Income', 'BMI_OBESE', 'HIGH_RISK_COMBO', 'POOR_HEALTH_SCORE']
+    input_df = pd.DataFrame([input_data])[feature_cols]
+    input_scaled = scaler.transform(input_df)
+    
+    st.divider()
+    
+    if st.button("RUN CLINICAL RISK ANALYSIS"):
+        model = models[selected_model_name]
+        prob = model.predict_proba(input_scaled)[0][1]
+        
+        res_col1, res_col2 = st.columns([1, 1.3])
+        
+        with res_col1:
+            fig = go.Figure(go.Indicator(
+                mode = "gauge+number",
+                value = prob * 100,
+                domain = {'x': [0, 1], 'y': [0, 1]},
+                title = {'text': "Risk Probability", 'font': {'size': 24, 'color': '#ffffff'}},
+                number = {'font': {'color': '#4cc9f0', 'size': 50}},
+                gauge = {
+                    'axis': {'range': [None, 100], 'tickcolor': "#ffffff"},
+                    'bar': {'color': "#4361ee"},
+                    'bgcolor': "rgba(0,0,0,0)",
+                    'steps': [
+                        {'range': [0, 20], 'color': 'rgba(76, 201, 240, 0.2)'},
+                        {'range': [20, 60], 'color': 'rgba(67, 97, 238, 0.2)'},
+                        {'range': [60, 100], 'color': 'rgba(247, 37, 133, 0.2)'}],
+                }))
+            fig.update_layout(paper_bgcolor='rgba(0,0,0,0)', font={'color': "white"}, height=350, margin=dict(l=20, r=20, t=50, b=20))
+            st.plotly_chart(fig, use_column_width=True)
+            
+        with res_col2:
+            st.markdown("### Risk Interpretation")
+            if prob < (threshold if selected_model_name == '⭐ Elite Ensemble (Max Accuracy)' else threshold): # Dynamic threshold logic if needed
+                st.success("#### PASS: LOW CLINICAL RISK")
+                message = "Your profile suggests low immediate risk. Continue regular checkups."
+            elif prob < 0.6:
+                st.warning("#### WARNING: ELEVATED RISK")
+                message = "Moderate markers detected. We recommend clinical consultation for blood glucose testing."
+            else:
+                st.error("#### ALERT: HIGH CLINICAL RISK")
+                message = "Significant risk factors identified. Consult a physician immediately for diagnostic screenings."
+            
+            st.write(message)
+            
+            st.markdown("#### Primary Stressors")
+            drivers = []
+            if high_bp: drivers.append("🔹 Hypertension (Strong clinical link)")
+            if bmi >= 30: drivers.append("🔹 Class 1+ Obesity (Metabolic driver)")
+            if gen_hlth_map[gen_hlth] >= 4: drivers.append("🔹 Self-Identified Poor General Health")
+            if age_map[age] >= 8: drivers.append("🔹 Age Interaction (Slowing metabolism)")
+            if not phys_active: drivers.append("🔹 Physical Inactivity")
+            
+            for d in drivers[:4]:
+                st.markdown(f"<div class='driver-item'>{d}</div>", unsafe_allow_html=True)
+
+# --- TAB 2: EXPLORER ---
+with tab2:
+    st.title("📊 Population Risk Insights")
+    st.write("Visualizing the relationship between lifestyle and disease across 253k patient records.")
+    
+    col_e1, col_e2 = st.columns(2)
+    with col_e1:
+        st.markdown("#### Risk by BMI Category")
+        img_bmi = path_utils.get_outputs_path("diabetes_rate_by_bmi.png")
+        if os.path.exists(img_bmi): 
+            st.image(img_bmi, use_column_width=True)
+            st.info("""
+            **Clinical Insight:** Obesity (BMI ≥ 30) is the single most significant modifiable driver. 
+            Data shows a **3x increase** in risk compared to the 'Healthy Weight' category.
+            """)
+    with col_e2:
+        st.markdown("#### Risk by Age Progression")
+        img_age = path_utils.get_outputs_path("diabetes_rate_by_age.png")
+        if os.path.exists(img_age): 
+            st.image(img_age, use_column_width=True)
+            st.info("""
+            **Clinical Insight:** Vulnerability increases sharply after Age Category 7 (45+ years). 
+            Risk doubles for every two age categories above 40.
+            """)
+
+    st.divider()
+    col_e3, col_e4 = st.columns(2)
+    with col_e3:
+        st.markdown("#### Feature Correlation Matrix")
+        img_corr = path_utils.get_outputs_path("correlation_heatmap.png")
+        if os.path.exists(img_corr): 
+            st.image(img_corr, use_column_width=True)
+            st.info("**Key Drivers:** GenHlth, HighBP, BMI, and Age show the strongest positive correlation with current and pre-diabetic status.")
+    with col_e4:
+        st.markdown("#### Diabetic Clinical Median")
+        img_means = path_utils.get_outputs_path("feature_means_comparison.png")
+        if os.path.exists(img_means): 
+            st.image(img_means, use_column_width=True)
+            st.info("**Pattern:** Patients with diabetes significantly exhibit co-occurring Hypertension and High Cholesterol ('High Risk Combo').")
+
+# --- TAB 3: CALIBRATION ---
+with tab3:
+    st.title("📈 Model Intelligence & Metrics")
+    st.write("Evaluating the predictive validity of the selected clinical model.")
+    
+    st.subheader("Area Under Curve (AUC-ROC) Comparison")
+    img_roc = path_utils.get_outputs_path("roc_curves_elite_comparison.png") # Updated for Elite comparison
+    if os.path.exists(img_roc):
+        st.image(img_roc, use_column_width=True)
+        st.success("**Model Evolution:** The Elite Stacked Ensemble achieves over 86% Accuracy, outperforming baseline models by effectively blending XGB, LGBM, and CatBoost.")
+    
+    col_m1, col_m2 = st.columns([1.5, 1])
+    with col_m1:
+        st.subheader("Global Feature Importance (XGBoost)")
+        img_imp = path_utils.get_outputs_path("feature_importance.png")
+        if os.path.exists(img_imp): st.image(img_imp, use_column_width=True)
+            
+    with col_m2:
+        st.subheader("Comparative Metrics (Elite Stack)")
+        metrics_file = path_utils.get_outputs_path("performance_metrics_elite.csv") # Updated for Elite metrics
+        if os.path.exists(metrics_file):
+            metrics_df = pd.read_csv(metrics_file)
+            st.dataframe(metrics_df.style.background_gradient(cmap='Blues', subset=['Accuracy']))
+        
+        st.subheader("Confusion Matrix (Elite Champion)")
+        img_cm = path_utils.get_outputs_path("confusion_matrix_elite.png") # Updated for Elite CM
+        if os.path.exists(img_cm): 
+            st.image(img_cm, use_column_width=True)
+            st.info("**Clinical Utility:** The Elite Model focuses on overall predictive accuracy, identifying the majority of non-diabetic cases with higher precision than the Recall-tuned XGBoost.")
+
+# --- TAB 4: DISCLAIMER ---
+with tab4:
+    st.title("⚖️ Legal & Clinical Disclaimer")
+    st.warning("PLEASE READ CAREFULLY")
+    st.markdown("""
+    ### 1. EDUCATIONAL PURPOSE
+    This application is designed as a **technical showcase** of machine learning capabilities in the healthcare domain. It is **NOT** a medical diagnostic tool and should not be used as a substitute for professional medical advice.
+    
+    ### 2. PREDICTIVE NATURE
+    Machine Learning models predict based on patterns found in historical population data (CDC BRFSS 2015). A predicted probability is a statistical estimate, not a clinical diagnosis.
+    
+    ### 3. ACTIONABLE ADVICE
+    If this tool flags you as "High Risk," it serves as a prompt for you to **consult a licensed physician** for blood tests such as HbA1c or Fasting Plasma Glucose.
+    
+    ### 4. DATA PRIVACY
+    All data processed in this session is volatile and cleared upon page refresh. No clinical data is stored in any database.
+    """)
+    st.info("Dataset: CDC Diabetes Health Indicators | Model: Elite Stacked Ensemble")
+
+# --- FOOTER ---
+st.markdown("""
+<br><hr>
+<center>
+    <p style='color: #a0a0a0;'>Diabetes Risk Prediction System | Built by <b>Divyanshi Singh</b></p>
+    <a href='https://github.com/Divyanshi018572' target='_blank'><img src='https://img.icons8.com/fluent/32/000000/github.png' width='25'/></a> &nbsp;
+    <a href='https://www.linkedin.com/in/divyanshi-singh-ds/' target='_blank'><img src='https://img.icons8.com/fluent/32/000000/linkedin.png' width='25'/></a>
+    <p style='color: #606060; font-size: 0.8em;'>© 2026 Professional Risk Engine | Data Science Portfolio</p>
+</center>
+""", unsafe_allow_html=True)

models/elite_ensemble.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:faff1e121de704459e255cd351a32fb1acbae867c827e0e375bae0b94cd54389
+size 3803481

models/logistic_regression.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f8a31415ecef2987564624e915550d6cb8b486357add292135f281da6c15c0e0
+size 1228

models/naive_bayes.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ddf65a38aaf1732c794ad501f088429f28bed657a9fcbfe0bbfff54ddc59b8df
+size 1766

models/random_forest.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3437abcc72d34da4d06c8a716b5c7c6b623847ccc53b642100cc62933bf24818
+size 3940691

models/scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d19c14a0a476bc8917bccdb4dd5bc919b6419198b58aade784e7b7e7276c5550
+size 1863

models/xgboost_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:08fc16cd817332f6b392d24944dfb9b9321e112cf07c898fd05e0f0d30deb915
+size 155909

models/xgboost_model_accuracy.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f3d55301aba0f6976f493a85dadb39c5a6da2c7bc9b29c0968af20b61394a7c
+size 538670

outputs/performance_metrics.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:359ddafbe7c108e040f53f6c1571d23ad51ca24114af8cb8a5aab1d699beeade
+size 482

outputs/performance_metrics_elite.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dca93920962c552b8f00947c7bcf6231fd3c94011a1dce433a3f4992d6db707b
+size 520

path_utils.py

@@ -0,0 +1,33 @@
+import os
+
+def get_project_root():
+    """Returns the root path of the project."""
+    return os.path.dirname(os.path.abspath(__file__))
+
+def get_data_path(subdir="raw", filename=None):
+    """Returns the path to the data directory."""
+    path = os.path.join(get_project_root(), "data", subdir)
+    if filename:
+        path = os.path.join(path, filename)
+    return path
+
+def get_models_path(filename=None):
+    """Returns the path to the models directory."""
+    path = os.path.join(get_project_root(), "models")
+    if filename:
+        path = os.path.join(path, filename)
+    return path
+
+def get_outputs_path(filename=None):
+    """Returns the path to the outputs directory."""
+    path = os.path.join(get_project_root(), "outputs")
+    if filename:
+        path = os.path.join(path, filename)
+    return path
+
+def get_pipeline_path(filename=None):
+    """Returns the path to the pipeline directory."""
+    path = os.path.join(get_project_root(), "pipeline")
+    if filename:
+        path = os.path.join(path, filename)
+    return path

pipeline/01_eda.py

@@ -0,0 +1,87 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import os
+import sys
+
+# Add project root to sys.path
+# This assumes the script is run from the project root or pipeline directory
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import path_utils
+
+def run_eda():
+    """Runs data exploration and saves plots to outputs folder."""
+    # 1. Load Data
+    csv_file = path_utils.get_data_path("raw", "diabetes_binary_health_indicators_BRFSS2015.csv")
+    df = pd.read_csv(csv_file)
+    print(f"Dataset Loaded: {df.shape[0]} rows, {df.shape[1]} columns")
+    print(f"Null Values: {df.isnull().sum().sum()}")
+    
+    # Ensure outputs directory exists
+    os.makedirs(path_utils.get_outputs_path(), exist_ok=True)
+    
+    # 2. Target Distribution
+    plt.figure(figsize=(8, 6))
+    sns.countplot(x='Diabetes_binary', data=df, palette='viridis')
+    plt.title('Diabetes Distribution (0=No, 1=Yes/Pre)')
+    plt.savefig(path_utils.get_outputs_path("diabetes_distribution.png"))
+    plt.close()
+    
+    # 3. Diabetes Rate by Age Category
+    plt.figure(figsize=(10, 6))
+    sns.lineplot(x='Age', y='Diabetes_binary', data=df, marker='o', color='blue')
+    plt.title('Diabetes Rate by Age category (1=18-24, 13=80+)')
+    plt.ylabel('Risk Probability')
+    plt.grid(True)
+    plt.savefig(path_utils.get_outputs_path("diabetes_rate_by_age.png"))
+    plt.close()
+    
+    # 4. Diabetes Rate by BMI Bins
+    # (Underweight <18.5, Normal 18.5–25, Overweight 25–30, Obese 30+)
+    df['BMI_Bins'] = pd.cut(df['BMI'], bins=[0, 18.5, 25, 30, 100], 
+                            labels=['Underweight', 'Normal', 'Overweight', 'Obese'])
+    plt.figure(figsize=(10, 6))
+    sns.barplot(x='BMI_Bins', y='Diabetes_binary', data=df, palette='coolwarm')
+    plt.title('Diabetes Rate by BMI Category')
+    plt.ylabel('Risk Probability')
+    plt.savefig(path_utils.get_outputs_path("diabetes_rate_by_bmi.png"))
+    plt.close()
+    
+    # 5. Diabetes Rate by GenHlth (General Health Rating 1-5)
+    plt.figure(figsize=(10, 6))
+    sns.barplot(x='GenHlth', y='Diabetes_binary', data=df, palette='OrRd')
+    plt.title('Diabetes Rate by General Health Rating (1=Excellent, 5=Poor)')
+    plt.ylabel('Risk Probability')
+    plt.savefig(path_utils.get_outputs_path("diabetes_rate_by_genhlth.png"))
+    plt.close()
+    
+    # 6. Correlation Heatmap (Top 10 features correlate with Diabetes)
+    plt.figure(figsize=(12, 10))
+    # Filter only numeric columns for correlation
+    numeric_df = df.select_dtypes(include=[np.number])
+    corr_matrix = numeric_df.corr()
+    # Pull Top Correlations with Target
+    top_corr = corr_matrix['Diabetes_binary'].sort_values(ascending=False).head(10).index
+    sns.heatmap(df[top_corr].corr(), annot=True, cmap='RdBu_r', center=0)
+    plt.title('Top 10 Feature Correlation Heatmap')
+    plt.savefig(path_utils.get_outputs_path("correlation_heatmap.png"))
+    plt.close()
+    
+    # 7. Comparison: Mean values for Diabetic vs Non-Diabetic
+    comp_features = ['HighBP', 'HighChol', 'BMI', 'Age', 'Smoker', 'HeartDiseaseorAttack', 'PhysActivity']
+    comp_df = df.groupby('Diabetes_binary')[comp_features].mean().reset_index()
+    # Melt for plotting
+    comp_melted = comp_df.melt(id_vars='Diabetes_binary', var_name='Feature', value_name='Mean Value')
+    
+    plt.figure(figsize=(12, 6))
+    sns.barplot(x='Feature', y='Mean Value', hue='Diabetes_binary', data=comp_melted, palette='muted')
+    plt.title('Mean Feature Values: Diabetic (1) vs Non-Diabetic (0)')
+    plt.xticks(rotation=45)
+    plt.savefig(path_utils.get_outputs_path("feature_means_comparison.png"))
+    plt.close()
+    
+    print("EDA Visualizations saved to 'outputs/'")
+
+if __name__ == "__main__":
+    run_eda()

pipeline/02_preprocessing.py

@@ -0,0 +1,73 @@
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+import os
+import sys
+import joblib
+
+# Add project root to sys.path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import path_utils
+
+def run_preprocessing():
+    """Performs feature engineering, scaling, and splitting."""
+    # 1. Load Data
+    csv_file = path_utils.get_data_path("raw", "diabetes_binary_health_indicators_BRFSS2015.csv")
+    df = pd.read_csv(csv_file)
+    print(f"Initial Dataset: {df.shape[0]} rows, {df.shape[1]} columns")
+    
+    # 2. Clinical Feature Engineering
+    print("Engineering Clinical Features...")
+    # BMI_OBESE = 1 if BMI >= 30 else 0
+    df['BMI_OBESE'] = (df['BMI'] >= 30).astype(int)
+    
+    # HIGH_RISK_COMBO = 1 if HighBP == 1 AND HighChol == 1 else 0
+    df['HIGH_RISK_COMBO'] = ((df['HighBP'] == 1) & (df['HighChol'] == 1)).astype(int)
+    
+    # POOR_HEALTH_SCORE = GenHlth + DiffWalk + PhysHlth_flag
+    # where PhysHlth_flag = 1 if PhysHlth > 14
+    df['PhysHlth_flag'] = (df['PhysHlth'] > 14).astype(int)
+    df['POOR_HEALTH_SCORE'] = df['GenHlth'] + df['DiffWalk'] + df['PhysHlth_flag']
+    
+    # Drop intermediate flag
+    df.drop(columns=['PhysHlth_flag'], inplace=True)
+    
+    print(f"Features Engineered. Total columns: {df.shape[1]}")
+    
+    # 3. Features and Target
+    X = df.drop(columns=['Diabetes_binary'])
+    y = df['Diabetes_binary']
+    
+    # 4. Train-Test Split (80/20, stratified)
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42, stratify=y
+    )
+    print(f"Splits Created: Train={X_train.shape[0]}, Test={X_test.shape[0]}")
+    
+    # 5. Scaling
+    print("Scaling Features...")
+    scaler = StandardScaler()
+    X_train_scaled = scaler.fit_transform(X_train)
+    X_test_scaled = scaler.transform(X_test)
+    
+    # Save Scaler for later use in app.py
+    os.makedirs(path_utils.get_models_path(), exist_ok=True)
+    joblib.dump(scaler, path_utils.get_models_path("scaler.pkl"))
+    
+    # 6. Save Processed Data
+    os.makedirs(path_utils.get_data_path("processed"), exist_ok=True)
+    
+    # Convert scaled back to DataFrame to preserve feature names for training script
+    X_train_final = pd.DataFrame(X_train_scaled, columns=X.columns)
+    X_test_final = pd.DataFrame(X_test_scaled, columns=X.columns)
+    
+    X_train_final.to_csv(path_utils.get_data_path("processed", "X_train.csv"), index=False)
+    X_test_final.to_csv(path_utils.get_data_path("processed", "X_test.csv"), index=False)
+    y_train.to_csv(path_utils.get_data_path("processed", "y_train.csv"), index=False)
+    y_test.to_csv(path_utils.get_data_path("processed", "y_test.csv"), index=False)
+    
+    print("Preprocessing Complete. Data and Scaler saved.")
+
+if __name__ == "__main__":
+    run_preprocessing()

pipeline/03_train.py

@@ -0,0 +1,99 @@
+import pandas as pd
+import numpy as np
+import os
+import sys
+import joblib
+from sklearn.linear_model import LogisticRegression
+from sklearn.naive_bayes import GaussianNB
+from sklearn.ensemble import RandomForestClassifier, StackingClassifier
+from xgboost import XGBClassifier
+from lightgbm import LGBMClassifier
+from catboost import CatBoostClassifier
+from sklearn.model_selection import train_test_split
+
+# Add project root to sys.path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import path_utils
+
+def run_training():
+    """Trains baseline models and a champion Elite Stacked Ensemble for maximum accuracy."""
+    # 1. Load Processed Data
+    X_train = pd.read_csv(path_utils.get_data_path("processed", "X_train.csv"))
+    y_train = pd.read_csv(path_utils.get_data_path("processed", "y_train.csv")).values.ravel()
+    
+    print(f"HF-Optimized Training on {X_train.shape[0]} samples with {X_train.shape[1]} features.")
+    
+    # 2. Train Optimized Baselines
+    print("Training Optimized Baselines (Pruned to <10MB)...")
+    
+    # Logistic Regression (Tiny)
+    lr = LogisticRegression(class_weight='balanced', max_iter=1000, random_state=42).fit(X_train, y_train)
+    joblib.dump(lr, path_utils.get_models_path("logistic_regression.pkl"), compress=3)
+    
+    # Naive Bayes (Tiny)
+    nb = GaussianNB(priors=[0.86, 0.14], var_smoothing=1e-8).fit(X_train, y_train)
+    joblib.dump(nb, path_utils.get_models_path("naive_bayes.pkl"), compress=3)
+    
+    # 🛑 KNN Removed: Too large for standard HF push (>60MB)
+    if os.path.exists(path_utils.get_models_path("knn.pkl")):
+        os.remove(path_utils.get_models_path("knn.pkl"))
+    
+    # Pruning Random Forest to < 10MB (max_depth=10, n_estimators=75)
+    rf = RandomForestClassifier(
+        n_estimators=75, max_depth=10, class_weight='balanced', 
+        random_state=42, n_jobs=-1
+    ).fit(X_train, y_train)
+    joblib.dump(rf, path_utils.get_models_path("random_forest.pkl"), compress=3)
+    
+    # 3. Define "Elite" Base Learners (Pruned for 10MB threshold)
+    print("Initializing Elite Ensemble Base Learners (Pruned for Deploy)...")
+    
+    xgb_elite = XGBClassifier(
+        n_estimators=100, max_depth=6, learning_rate=0.1, 
+        random_state=42, use_label_encoder=False, eval_metric='logloss'
+    )
+    
+    lgb_elite = LGBMClassifier(
+        n_estimators=100, num_leaves=31, learning_rate=0.1, 
+        random_state=42, verbose=-1
+    )
+    
+    cat_elite = CatBoostClassifier(
+        iterations=100, depth=6, learning_rate=0.1, 
+        random_seed=42, verbose=0, allow_writing_files=False
+    )
+    
+    rf_elite = RandomForestClassifier(
+        n_estimators=80, max_depth=10, random_state=42, n_jobs=-1
+    )
+
+    # 4. Create Stacked Ensemble
+    print("Training Elite Stacked Ensemble (XGB + LGBM + Cat + RF)...")
+    base_learners = [
+        ('xgb', xgb_elite),
+        ('lgbm', lgb_elite),
+        ('cat', cat_elite),
+        ('rf', rf_elite)
+    ]
+    
+    stack = StackingClassifier(
+        estimators=base_learners,
+        final_estimator=LogisticRegression(),
+        n_jobs=-1
+    )
+    
+    stack.fit(X_train, y_train)
+    # Save with Level 3 Compression (Ensuring < 10MB)
+    joblib.dump(stack, path_utils.get_models_path("elite_ensemble.pkl"), compress=3)
+    
+    # 5. XGBoost (Recall Optimized) - Tiny
+    xgb_recall = XGBClassifier(
+        n_estimators=100, max_depth=6, learning_rate=0.1, 
+        scale_pos_weight=6.14, random_state=42, eval_metric='logloss'
+    ).fit(X_train, y_train)
+    joblib.dump(xgb_recall, path_utils.get_models_path("xgboost_model.pkl"), compress=3)
+    
+    print("10MB Threshold Training Complete. All models saved successfully.")
+
+if __name__ == "__main__":
+    run_training()

pipeline/04_evaluate.py

@@ -0,0 +1,104 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import os
+import sys
+import joblib
+from sklearn.metrics import accuracy_score, roc_auc_score, recall_score, f1_score, roc_curve, confusion_matrix
+
+# Add project root to sys.path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import path_utils
+
+def run_evaluation():
+    """Evaluates all models including the Elite Stacked Ensemble."""
+    # 1. Load Data
+    X_test = pd.read_csv(path_utils.get_data_path("processed", "X_test.csv"))
+    y_test = pd.read_csv(path_utils.get_data_path("processed", "y_test.csv")).values.ravel()
+    
+    # 2. Identify Models and Load Them
+    # Add 'Elite Ensemble' and 'XGBoost (Accuracy Opt)' to comparison
+    model_paths = {
+        'Logistic Regression': "logistic_regression.pkl",
+        'Naive Bayes': "naive_bayes.pkl",
+        'Random Forest': "random_forest.pkl",
+        'Elite Ensemble (Max Accuracy)': "elite_ensemble.pkl",
+        'XGBoost (Recall Opt)': "xgboost_model.pkl"
+    }
+    
+    models = {}
+    for name, filename in model_paths.items():
+        path = path_utils.get_models_path(filename)
+        if os.path.exists(path):
+            models[name] = joblib.load(path)
+        else:
+            print(f"Warning: {filename} not found.")
+            
+    # 3. Store Results
+    results = []
+    plt.figure(figsize=(12, 10))
+    
+    for name, model in models.items():
+        print(f"Evaluating {name}...")
+        y_pred = model.predict(X_test)
+        
+        # Get Probabilities for ROC curve
+        if hasattr(model, "predict_proba"):
+            y_prob = model.predict_proba(X_test)[:, 1]
+        else:
+            # Stacking classifier has predict_proba
+            y_prob = model.decision_function(X_test)
+        
+        # Metrics
+        acc = accuracy_score(y_test, y_pred)
+        auc = roc_auc_score(y_test, y_prob)
+        rec = recall_score(y_test, y_pred)
+        f1 = f1_score(y_test, y_pred)
+        
+        results.append({
+            'Model': name,
+            'Accuracy': acc,
+            'AUC-ROC': auc,
+            'Recall': rec,
+            'F1-Score': f1
+        })
+        
+        # ROC Plotting
+        fpr, tpr, _ = roc_curve(y_test, y_prob)
+        plt.plot(fpr, tpr, label=f"{name} (AUC={auc:.2f})")
+    
+    # Finalize ROC Plot
+    plt.plot([0, 1], [0, 1], 'k--', alpha=0.5)
+    plt.xlabel('False Positive Rate')
+    plt.ylabel('True Positive Rate')
+    plt.title('ROC Curves: Comparing Baseline vs Elite Ensemble')
+    plt.legend(loc='lower right')
+    plt.grid(alpha=0.3)
+    plt.savefig(path_utils.get_outputs_path("roc_curves_elite_comparison.png"))
+    plt.close()
+    
+    # 4. Save Performance Table
+    results_df = pd.DataFrame(results).sort_values(by='Accuracy', ascending=False)
+    print("\nElite Model Performance Comparison:")
+    print(results_df)
+    results_df.to_csv(path_utils.get_outputs_path("performance_metrics_elite.csv"), index=False)
+    
+    # 5. Elite Confusion Matrix
+    if 'Elite Ensemble (Max Accuracy)' in models:
+        best_model = models['Elite Ensemble (Max Accuracy)']
+        y_pred_elite = best_model.predict(X_test)
+        cm = confusion_matrix(y_test, y_pred_elite)
+        
+        plt.figure(figsize=(8, 6))
+        sns.heatmap(cm, annot=True, fmt='d', cmap='Greens')
+        plt.title('Confusion Matrix: Elite Stacked Ensemble')
+        plt.xlabel('Predicted Label')
+        plt.ylabel('True Label')
+        plt.savefig(path_utils.get_outputs_path("confusion_matrix_elite.png"))
+        plt.close()
+    
+    print("Elite Evaluation Complete.")
+
+if __name__ == "__main__":
+    run_evaluation()

requirements.txt

@@ -0,0 +1,12 @@
+pandas
+numpy
+streamlit
+joblib
+plotly
+xgboost
+lightgbm
+catboost
+scikit-learn
+matplotlib
+seaborn
+imbalanced-learn

runtime.txt

@@ -0,0 +1 @@
+python-3.10.12