Upload folder using huggingface_hub

app.py

@@ -1,147 +1,75 @@
 import gradio as gr
 import shap
 import xgboost as xgb
-import numpy as np
 import pandas as pd
+import numpy as np
 import matplotlib.pyplot as plt
 
-# Make sure matplotlib does not try to open any GUI backend
-plt.switch_backend("Agg")
-
-# ---------------------------
-# 1. CREATE SYNTHETIC DATA & TRAIN MODEL
-# ---------------------------
-np.random.seed(42)
-
-# Simple synthetic dataset: "health-like" features and a fake cost
-df = pd.DataFrame({
+# -----------------------------
+# 1. Load a simple demo model
+# -----------------------------
+# Create fake training data
+np.random.seed(0)
+X = pd.DataFrame({
     "age": np.random.randint(20, 80, 200),
-    "bmi": np.random.uniform(18, 35, 200),
-    "steps": np.random.randint(2000, 14000, 200),
+    "bmi": np.random.uniform(18, 40, 200),
+    "bp": np.random.uniform(80, 160, 200)
 })
+y = 0.3*X["age"] + 0.5*X["bmi"] + 0.2*X["bp"] + np.random.normal(0, 3, 200)
 
-# Fake target: cost in dollars
-df["cost"] = (
-    10 * df["age"] +
-    50 * (df["bmi"] - 25) -
-    0.001 * df["steps"] +
-    np.random.normal(0, 50, size=len(df))
-)
-
-FEATURE_COLUMNS = ["age", "bmi", "steps"]
-
-X = df[FEATURE_COLUMNS]
-y = df["cost"]
-
-# Train a tiny XGBoost regressor
-model = xgb.XGBRegressor(
-    n_estimators=40,
-    max_depth=3,
-    learning_rate=0.1,
-    subsample=0.8,
-    colsample_bytree=0.8,
-    random_state=42
-)
+model = xgb.XGBRegressor()
 model.fit(X, y)
 
-# ---------------------------
-# 2. BUILD A SHAP TREE EXPLAINER (SAFE FOR TREE MODELS)
-# ---------------------------
-# DO NOT use shap.Explainer(model, X) -> causes TypeError on some setups
+# Correct SHAP explainer for XGBoost tree models
 explainer = shap.TreeExplainer(model)
 
+# -----------------------------
+# 2. Prediction + SHAP function
+# -----------------------------
+def predict_and_explain(age, bmi, bp):
 
-# ---------------------------
-# 3. FUNCTION TO EXPLAIN A SINGLE PREDICTION
-# ---------------------------
-def explain_cost(age: float, bmi: float, steps: int):
-    """
-    Take user inputs, compute predicted cost, and generate a SHAP waterfall plot.
-    Returns:
-      - predicted cost (float)
-      - path to saved waterfall PNG (string)
-    """
-    # Build a single-row DataFrame with the same columns as training
-    input_df = pd.DataFrame([{
+    df = pd.DataFrame([{
         "age": age,
         "bmi": bmi,
-        "steps": steps
+        "bp": bp
     }])
 
-    # Model prediction
-    pred = model.predict(input_df)[0]
+    # Prediction
+    pred = model.predict(df)[0]
 
-    # Compute SHAP values for this single instance
-    shap_explanation = explainer(input_df)  # returns shap.Explanation object
+    # SHAP values
+    shap_values = explainer(df)
 
-    # Make a waterfall plot for the first (and only) instance
+    # SHAP waterfall plot
     plt.figure(figsize=(8, 5))
-    shap.plots.waterfall(shap_explanation[0], show=False)
-    plt.title("SHAP Waterfall Explanation", fontsize=12)
-
-    # Save plot to file for Gradio to show
-    output_path = "shap_waterfall.png"
+    shap.plots.waterfall(shap_values[0], show=False)
     plt.tight_layout()
-    plt.savefig(output_path, bbox_inches="tight")
+    plt.savefig("shap_plot.png")
     plt.close()
 
-    # Return prediction and image path
-    return float(pred), output_path
-
-
-# ---------------------------
-# 4. GRADIO UI
-# ---------------------------
-with gr.Blocks() as demo:
-    gr.Markdown(
-        """
-        # SHAP Explainability Demo
-        
-        This app trains a tiny XGBoost regression model on synthetic data
-        and explains each prediction using **SHAP TreeExplainer**.
-        
-        Adjust the sliders and click **Explain Prediction** to see:
-        - The model's predicted cost
-        - A SHAP waterfall plot showing how each feature pushes the prediction
-          higher or lower relative to the model's base value.
-        """
-    )
-
-    with gr.Row():
-        age = gr.Slider(
-            minimum=20,
-            maximum=80,
-            value=40,
-            step=1,
-            label="Age"
-        )
-        bmi = gr.Slider(
-            minimum=18,
-            maximum=35,
-            value=25,
-            step=0.1,
-            label="BMI"
-        )
-        steps = gr.Slider(
-            minimum=2000,
-            maximum=15000,
-            value=8000,
-            step=500,
-            label="Daily Steps"
-        )
-
-    explain_button = gr.Button("Explain Prediction")
-
-    with gr.Row():
-        pred_output = gr.Number(label="Predicted Cost ($)")
-        shap_output = gr.Image(label="SHAP Waterfall", type="filepath")
-
-    explain_button.click(
-        fn=explain_cost,
-        inputs=[age, bmi, steps],
-        outputs=[pred_output, shap_output]
-    )
+    return pred, "shap_plot.png"
+
+# -----------------------------
+# 3. Gradio Interface
+# -----------------------------
+inputs = [
+    gr.Number(label="Age"),
+    gr.Number(label="BMI"),
+    gr.Number(label="Blood Pressure")
+]
+
+outputs = [
+    gr.Number(label="Prediction"),
+    gr.Image(label="SHAP Explanation")
+]
+
+demo = gr.Interface(
+    fn=predict_and_explain,
+    inputs=inputs,
+    outputs=outputs,
+    title="XGBoost + SHAP Demo",
+    description="Working Hugging Face deployment without SHAP model errors."
+)
 
-# For local debugging; on Hugging Face this is ignored but harmless
 if __name__ == "__main__":
     demo.launch(share=True)