Deploy MediPredict AI Gradio app

.gitignore

@@ -0,0 +1,32 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Environment and credentials
+.env
+.env.*
+kaggle.json
+
+# Local notebooks and editor files
+.ipynb_checkpoints/
+.vscode/
+.idea/
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Generated dataset and model artifacts
+data/*
+!data/.gitkeep
+model/*
+!model/.gitkeep
+
+# Logs
+*.log

README.md

@@ -1,12 +1,192 @@
 ---
 title: MediPredict AI
-emoji: 🐢
-colorFrom: indigo
+emoji: 🏥
+colorFrom: blue
 colorTo: green
 sdk: gradio
-sdk_version: 6.13.0
-app_file: app.py
-pinned: false
+sdk_version: "4.0.0"
+python_version: "3.10"
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# MediPredict AI - Disease Prediction System
+
+MediPredict AI is an end-to-end machine learning project that predicts diabetes risk using the Pima Indians Diabetes Database. It trains Logistic Regression, Random Forest, and XGBoost classifiers, evaluates them with standard classification metrics, saves the best model, and serves predictions through a Gradio web interface.
+
+This project is built for Python 3.10, VS Code, and Hugging Face Spaces.
+
+## Project Structure
+
+```text
+disease-prediction-app/
+├── data/
+│   └── diabetes.csv
+├── model/
+│   ├── model.pkl
+│   └── scaler.pkl
+├── app.py
+├── train.py
+├── requirements.txt
+└── README.md
+```
+
+`diabetes.csv`, `model.pkl`, and `scaler.pkl` are generated after running `train.py`.
+
+## Dataset
+
+Dataset: Pima Indians Diabetes Database  
+Kaggle slug: `uciml/pima-indians-diabetes-database`
+
+The training script downloads the dataset automatically with the Kaggle API.
+
+## Kaggle API Setup
+
+1. Install the Kaggle package:
+
+```bash
+pip install kaggle
+```
+
+2. Go to your Kaggle account settings:
+
+```text
+https://www.kaggle.com/settings
+```
+
+3. Create a new API token. Kaggle downloads a file named `kaggle.json`.
+
+4. Place `kaggle.json` in the correct folder.
+
+On Windows:
+
+```text
+C:\Users\<your-username>\.kaggle\kaggle.json
+```
+
+On macOS or Linux:
+
+```text
+~/.kaggle/kaggle.json
+```
+
+5. On macOS or Linux, set file permissions:
+
+```bash
+chmod 600 ~/.kaggle/kaggle.json
+```
+
+## Local Setup in VS Code
+
+Open the project folder in VS Code:
+
+```bash
+cd disease-prediction-app
+```
+
+Create a virtual environment:
+
+```bash
+python -m venv .venv
+```
+
+Activate the virtual environment on Windows PowerShell:
+
+```bash
+.\.venv\Scripts\Activate.ps1
+```
+
+Activate the virtual environment on macOS or Linux:
+
+```bash
+source .venv/bin/activate
+```
+
+Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+Train the model:
+
+```bash
+python train.py
+```
+
+Run the Gradio app:
+
+```bash
+python app.py
+```
+
+Open the local URL shown in the terminal, usually:
+
+```text
+http://127.0.0.1:7860
+```
+
+## Model Training
+
+`train.py` performs the full ML workflow:
+
+- Downloads `diabetes.csv` from Kaggle.
+- Loads the data into a pandas DataFrame.
+- Replaces zero values in `Glucose`, `BloodPressure`, `SkinThickness`, `Insulin`, and `BMI` with `NaN`.
+- Fills missing values with column means.
+- Scales features with `StandardScaler`.
+- Trains Logistic Regression, Random Forest, and XGBoost.
+- Evaluates models using accuracy, precision, recall, F1-score, and ROC-AUC.
+- Saves the best model to `model/model.pkl`.
+- Saves the scaler to `model/scaler.pkl`.
+
+## Gradio App
+
+`app.py` loads the saved model and scaler, accepts patient health inputs, scales the input, predicts diabetes risk, and displays:
+
+- Prediction: `Low Risk` or `High Risk`
+- Probability score
+
+The app uses Gradio only. It does not use Streamlit.
+
+## Hugging Face Spaces Deployment
+
+1. Train the model locally first:
+
+```bash
+python train.py
+```
+
+2. Confirm these files exist:
+
+```text
+data/diabetes.csv
+model/model.pkl
+model/scaler.pkl
+```
+
+3. Create a new Hugging Face Space:
+
+- Go to `https://huggingface.co/spaces`
+- Click **Create new Space**
+- Select **Gradio** as the SDK
+- Use Python 3.10
+
+4. Upload or push these files to the Space repository:
+
+```text
+app.py
+train.py
+requirements.txt
+README.md
+data/diabetes.csv
+model/model.pkl
+model/scaler.pkl
+```
+
+5. Hugging Face Spaces will install dependencies from `requirements.txt` and run `app.py` automatically.
+
+## Important Notes
+
+- This app is for educational use only.
+- It is not a medical diagnosis tool.
+- The Gradio app uses a default Diabetes Pedigree Function value of `0.47` because the requested UI inputs do not include that dataset feature.
+- For production medical use, consult clinical experts, validate the model rigorously, and follow healthcare compliance requirements.

app.py

@@ -0,0 +1,182 @@
+import pickle
+from pathlib import Path
+
+import gradio as gr
+import pandas as pd
+
+
+BASE_DIR = Path(__file__).resolve().parent
+MODEL_FILE = BASE_DIR / "model" / "model.pkl"
+SCALER_FILE = BASE_DIR / "model" / "scaler.pkl"
+
+DEFAULT_DPF = 0.47
+FEATURE_COLUMNS = [
+    "Pregnancies",
+    "Glucose",
+    "BloodPressure",
+    "SkinThickness",
+    "Insulin",
+    "BMI",
+    "DiabetesPedigreeFunction",
+    "Age",
+]
+
+
+def load_pickle(path: Path):
+    if not path.exists():
+        raise FileNotFoundError(
+            f"{path.name} was not found in {path.parent}. Run `python train.py` first."
+        )
+
+    with path.open("rb") as file:
+        return pickle.load(file)
+
+
+model = load_pickle(MODEL_FILE)
+scaler = load_pickle(SCALER_FILE)
+
+
+def validate_inputs(values: list[float]) -> str | None:
+    labels = [
+        "Pregnancies",
+        "Glucose",
+        "Blood Pressure",
+        "Skin Thickness",
+        "Insulin",
+        "BMI",
+        "Age",
+    ]
+
+    for label, value in zip(labels, values):
+        if value is None:
+            return f"Please enter a value for {label}."
+        if value < 0:
+            return f"{label} cannot be negative."
+
+    if values[5] == 0:
+        return "BMI must be greater than 0."
+
+    return None
+
+
+def predict_diabetes(
+    pregnancies: float,
+    glucose: float,
+    blood_pressure: float,
+    skin_thickness: float,
+    insulin: float,
+    bmi: float,
+    age: float,
+) -> tuple[str, str]:
+    values = [
+        pregnancies,
+        glucose,
+        blood_pressure,
+        skin_thickness,
+        insulin,
+        bmi,
+        age,
+    ]
+
+    error = validate_inputs(values)
+    if error:
+        return "Invalid Input", error
+
+    input_data = pd.DataFrame(
+        [
+            {
+                "Pregnancies": pregnancies,
+                "Glucose": glucose,
+                "BloodPressure": blood_pressure,
+                "SkinThickness": skin_thickness,
+                "Insulin": insulin,
+                "BMI": bmi,
+                "DiabetesPedigreeFunction": DEFAULT_DPF,
+                "Age": age,
+            }
+        ],
+        columns=FEATURE_COLUMNS,
+    )
+
+    scaled_input = scaler.transform(input_data)
+    prediction = int(model.predict(scaled_input)[0])
+    probability = float(model.predict_proba(scaled_input)[0][1])
+
+    risk_label = "High Risk" if prediction == 1 else "Low Risk"
+    risk_message = (
+        "The model predicts a higher likelihood of diabetes."
+        if prediction == 1
+        else "The model predicts a lower likelihood of diabetes."
+    )
+
+    return risk_label, f"{probability * 100:.2f}% probability. {risk_message}"
+
+
+custom_css = """
+.gradio-container {
+    max-width: 960px !important;
+    margin: auto !important;
+}
+.risk-box {
+    border-radius: 8px;
+}
+"""
+
+
+with gr.Blocks(theme=gr.themes.Soft(), css=custom_css, title="MediPredict AI") as demo:
+    gr.Markdown(
+        """
+        # 🏥 MediPredict AI
+        A disease prediction system that estimates diabetes risk using a trained machine learning classifier.
+        Enter patient health values below to get a risk category and probability score.
+        """
+    )
+
+    with gr.Row():
+        with gr.Column():
+            pregnancies = gr.Slider(
+                minimum=0,
+                maximum=20,
+                value=1,
+                step=1,
+                label="Pregnancies",
+            )
+            glucose = gr.Number(value=120, label="Glucose")
+            blood_pressure = gr.Number(value=70, label="Blood Pressure")
+            skin_thickness = gr.Number(value=20, label="Skin Thickness")
+
+        with gr.Column():
+            insulin = gr.Number(value=80, label="Insulin")
+            bmi = gr.Number(value=25.0, label="BMI")
+            age = gr.Number(value=30, label="Age")
+
+    predict_button = gr.Button("Predict Diabetes Risk", variant="primary")
+
+    with gr.Row():
+        prediction_output = gr.Textbox(label="Prediction", interactive=False)
+        probability_output = gr.Textbox(label="Probability Score", interactive=False)
+
+    predict_button.click(
+        fn=predict_diabetes,
+        inputs=[
+            pregnancies,
+            glucose,
+            blood_pressure,
+            skin_thickness,
+            insulin,
+            bmi,
+            age,
+        ],
+        outputs=[prediction_output, probability_output],
+    )
+
+    gr.Markdown(
+        """
+        **Note:** This app is for educational purposes only and is not a medical diagnosis tool.
+        Please consult a qualified healthcare professional for medical advice.
+        """
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

data/.gitkeep

@@ -0,0 +1 @@
+

model/.gitkeep

@@ -0,0 +1 @@
+

requirements.txt

@@ -0,0 +1,6 @@
+pandas
+numpy
+scikit-learn
+xgboost
+gradio
+kaggle

train.py

@@ -0,0 +1,185 @@
+import os
+import pickle
+import zipfile
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from kaggle.api.kaggle_api_extended import KaggleApi
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import (
+    accuracy_score,
+    f1_score,
+    precision_score,
+    recall_score,
+    roc_auc_score,
+)
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from xgboost import XGBClassifier
+
+
+BASE_DIR = Path(__file__).resolve().parent
+DATA_DIR = BASE_DIR / "data"
+MODEL_DIR = BASE_DIR / "model"
+DATASET_SLUG = "uciml/pima-indians-diabetes-database"
+DATA_FILE = DATA_DIR / "diabetes.csv"
+MODEL_FILE = MODEL_DIR / "model.pkl"
+SCALER_FILE = MODEL_DIR / "scaler.pkl"
+
+FEATURE_COLUMNS = [
+    "Pregnancies",
+    "Glucose",
+    "BloodPressure",
+    "SkinThickness",
+    "Insulin",
+    "BMI",
+    "DiabetesPedigreeFunction",
+    "Age",
+]
+
+ZERO_AS_MISSING_COLUMNS = [
+    "Glucose",
+    "BloodPressure",
+    "SkinThickness",
+    "Insulin",
+    "BMI",
+]
+
+
+def download_dataset() -> None:
+    """Download the Pima Indians Diabetes dataset using Kaggle API."""
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+    if DATA_FILE.exists():
+        print(f"Dataset already exists: {DATA_FILE}")
+        return
+
+    print("Downloading dataset from Kaggle...")
+    api = KaggleApi()
+    api.authenticate()
+    api.dataset_download_files(DATASET_SLUG, path=str(DATA_DIR), unzip=False)
+
+    zip_path = DATA_DIR / "pima-indians-diabetes-database.zip"
+    if not zip_path.exists():
+        raise FileNotFoundError(
+            "Kaggle download finished, but the expected zip file was not found."
+        )
+
+    with zipfile.ZipFile(zip_path, "r") as zip_ref:
+        zip_ref.extractall(DATA_DIR)
+
+    zip_path.unlink(missing_ok=True)
+
+    if not DATA_FILE.exists():
+        raise FileNotFoundError("diabetes.csv was not found after extracting the dataset.")
+
+    print(f"Dataset saved to: {DATA_FILE}")
+
+
+def load_and_preprocess_data() -> tuple[np.ndarray, np.ndarray, StandardScaler]:
+    """Load data, clean missing medical values, split features, and scale."""
+    df = pd.read_csv(DATA_FILE)
+
+    missing_columns = [col for col in FEATURE_COLUMNS + ["Outcome"] if col not in df.columns]
+    if missing_columns:
+        raise ValueError(f"Dataset is missing required columns: {missing_columns}")
+
+    df[ZERO_AS_MISSING_COLUMNS] = df[ZERO_AS_MISSING_COLUMNS].replace(0, np.nan)
+    df[ZERO_AS_MISSING_COLUMNS] = df[ZERO_AS_MISSING_COLUMNS].fillna(
+        df[ZERO_AS_MISSING_COLUMNS].mean()
+    )
+
+    x = df[FEATURE_COLUMNS]
+    y = df["Outcome"]
+
+    scaler = StandardScaler()
+    x_scaled = scaler.fit_transform(x)
+
+    return x_scaled, y.to_numpy(), scaler
+
+
+def evaluate_model(name: str, model, x_test: np.ndarray, y_test: np.ndarray) -> dict:
+    """Calculate common classification metrics for a trained model."""
+    predictions = model.predict(x_test)
+
+    if hasattr(model, "predict_proba"):
+        probabilities = model.predict_proba(x_test)[:, 1]
+    else:
+        probabilities = predictions
+
+    metrics = {
+        "model": name,
+        "accuracy": accuracy_score(y_test, predictions),
+        "precision": precision_score(y_test, predictions, zero_division=0),
+        "recall": recall_score(y_test, predictions, zero_division=0),
+        "f1_score": f1_score(y_test, predictions, zero_division=0),
+        "roc_auc": roc_auc_score(y_test, probabilities),
+    }
+    return metrics
+
+
+def train_models() -> None:
+    """Train candidate models and save the best model by ROC-AUC."""
+    MODEL_DIR.mkdir(parents=True, exist_ok=True)
+    download_dataset()
+
+    x, y, scaler = load_and_preprocess_data()
+    x_train, x_test, y_train, y_test = train_test_split(
+        x,
+        y,
+        test_size=0.2,
+        random_state=42,
+        stratify=y,
+    )
+
+    models = {
+        "Logistic Regression": LogisticRegression(max_iter=1000, random_state=42),
+        "Random Forest": RandomForestClassifier(
+            n_estimators=200,
+            random_state=42,
+            class_weight="balanced",
+        ),
+        "XGBoost": XGBClassifier(
+            n_estimators=200,
+            learning_rate=0.05,
+            max_depth=3,
+            subsample=0.9,
+            colsample_bytree=0.9,
+            eval_metric="logloss",
+            random_state=42,
+        ),
+    }
+
+    results = []
+    trained_models = {}
+
+    for name, model in models.items():
+        print(f"\nTraining {name}...")
+        model.fit(x_train, y_train)
+        trained_models[name] = model
+        metrics = evaluate_model(name, model, x_test, y_test)
+        results.append(metrics)
+
+    results_df = pd.DataFrame(results).sort_values(by="roc_auc", ascending=False)
+    print("\nModel Evaluation Results")
+    print(results_df.to_string(index=False))
+
+    best_model_name = results_df.iloc[0]["model"]
+    best_model = trained_models[best_model_name]
+
+    with MODEL_FILE.open("wb") as model_file:
+        pickle.dump(best_model, model_file)
+
+    with SCALER_FILE.open("wb") as scaler_file:
+        pickle.dump(scaler, scaler_file)
+
+    print(f"\nBest model: {best_model_name}")
+    print(f"Model saved to: {MODEL_FILE}")
+    print(f"Scaler saved to: {SCALER_FILE}")
+
+
+if __name__ == "__main__":
+    os.environ.setdefault("KAGGLE_CONFIG_DIR", str(Path.home() / ".kaggle"))
+    train_models()