Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,171 @@
+import os
+import shutil
+import zipfile
+import pathlib
+import pandas
+import gradio
+import huggingface_hub
+import autogluon.tabular
+
+# Settings
+MODEL_REPO_ID = "jennifee/classical_automl_model"
+ZIP_FILENAME  = "autogluon_predictor_dir.zip"
+CACHE_DIR = pathlib.Path("hf_assets")
+EXTRACT_DIR = CACHE_DIR / "predictor_native"
+
+# Feature column names and target column names (these should match the model's expected input)
+FEATURE_COLS_MODEL = [
+    "phone_hours",
+    "computer_hours",
+    "device_count",
+    "sleep_quality",
+    "sleep_time",
+    "sleep_hours",
+]
+TARGET_COL = "use_before_bed"
+
+# Encoding for categorical features - these mappings are for the Gradio interface,
+# the model expects the original string/numeric values based on the training data.
+SLEEP_QUALITY_LABELS = ["good", "medium", "bad"]
+
+# Encoding for the target outcome (for displaying the prediction and probability)
+USE_BEFORE_BED_LABELS = {
+    0: "No",
+    1: "Yes",
+}
+
+
+# Download & load the native predictor
+def _prepare_predictor_dir() -> str:
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    local_zip = huggingface_hub.hf_hub_download(
+        repo_id=MODEL_REPO_ID,
+        filename=ZIP_FILENAME,
+        repo_type="model",
+        local_dir=str(CACHE_DIR),
+        local_dir_use_symlinks=False,
+    )
+    if EXTRACT_DIR.exists():
+        shutil.rmtree(EXTRACT_DIR)
+    EXTRACT_DIR.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(local_zip, "r") as zf:
+        zf.extractall(str(EXTRACT_DIR))
+    contents = list(EXTRACT_DIR.iterdir())
+    predictor_root = contents[0] if (len(contents) == 1 and contents[0].is_dir()) else EXTRACT_DIR
+    return str(predictor_root)
+
+PREDICTOR_DIR = _prepare_predictor_dir()
+PREDICTOR = autogluon.tabular.TabularPredictor.load(PREDICTOR_DIR, require_py_version_match=False)
+
+# A mapping utility to make it easier to encode the variables for display
+def _human_label(c):
+    # Updated to map 0/1 to "No"/"Yes" for the target
+    try:
+        ci = int(c)
+        if ci in USE_BEFORE_BED_LABELS:
+            return USE_BEFORE_BED_LABELS[ci]
+    except Exception:
+        pass
+    return str(c)
+
+# This functions takes all of our features, encodes this accordingly, and performs a prediction
+def do_predict(phone_hours, computer_hours, device_count, sleep_quality_label, sleep_time, sleep_hours):
+    # Create the input row using the original column names and appropriate data types
+    row = {
+        "phone_hours": float(phone_hours),
+        "computer_hours": float(computer_hours),
+        "device_count": int(device_count),
+        "sleep_quality": sleep_quality_label,
+        "sleep_time": int(sleep_time),
+        "sleep_hours": float(sleep_hours),
+    }
+    X = pandas.DataFrame([row], columns=FEATURE_COLS_MODEL)
+
+
+    pred_series = PREDICTOR.predict(X)
+    raw_pred = pred_series.iloc[0]
+
+    try:
+        # Re-added probability prediction
+        proba = PREDICTOR.predict_proba(X)
+        if isinstance(proba, pandas.Series):
+            proba = proba.to_frame().T
+    except Exception as e:
+        print(f"Error calculating probabilities: {e}")
+        proba = None
+
+    pred_label = _human_label(raw_pred)
+
+    proba_dict = None
+    if proba is not None:
+        row0 = proba.iloc[0]
+        tmp = {}
+        # Assuming the probability columns are the class labels (0 and 1)
+        for cls in [0, 1]:
+             if cls in row0:
+                 key = _human_label(cls)
+                 tmp[key] = float(row0[cls]) + float(tmp.get(key, 0.0))
+        proba_dict = dict(sorted(tmp.items(), key=lambda kv: kv[1], reverse=True))
+
+
+    # Updated output format to include confidence
+    md = f"**Prediction:** {pred_label}"
+    if proba_dict:
+        md += f"  
+**Confidence:** {round(proba_dict.get(pred_label, 0.0) * 100, 2)}%"
+
+    # Always return two values, even if proba_dict is None
+    return proba_dict, md
+
+
+# Representative examples - Updated examples based on the new dataset
+EXAMPLES = [
+    [3.5, 5.0, 3, "good", 23, 7.0],
+    [4.2, 6.5, 3, "medium", 0, 6.5],
+    [5.0, 4.0, 4, "bad", 1, 6.0],
+    [2.0, 7.5, 3, "good", 22, 7.5],
+    [3.8, 6.0, 3, "medium", 0, 6.0],
+    [4.5, 5.5, 3, "good", 1, 7.0],
+]
+
+# Gradio UI
+with gradio.Blocks() as demo:
+    # Provide an introduction
+    gradio.Markdown("# Predict Phone Use Before Bed")
+    gradio.Markdown("""
+This app predicts whether a student uses their phone before bed based on their sleeping habits.
+Enter the student's sleeping habits below to get a prediction.
+""")
+
+    with gradio.Row():
+        phone_hours = gradio.Number(value=3.5, precision=1, label=FEATURE_COLS_MODEL[0])
+        computer_hours = gradio.Number(value=5.0, precision=1, label=FEATURE_COLS_MODEL[1])
+        device_count = gradio.Number(value=3, precision=0, label=FEATURE_COLS_MODEL[2])
+
+    with gradio.Row():
+        sleep_quality_label = gradio.Radio(choices=SLEEP_QUALITY_LABELS, value="good", label=FEATURE_COLS_MODEL[3])
+        sleep_time = gradio.Number(value=23, precision=0, label=FEATURE_COLS_MODEL[4])
+        sleep_hours = gradio.Number(value=7.0, precision=1, label=FEATURE_COLS_MODEL[5])
+
+
+    # Re-added Label for probability output and kept Markdown for prediction text
+    proba_pretty = gradio.Label(num_top_classes=2, label="Probability of Using Phone Before Bed")
+    prediction_output = gradio.Markdown(label="Prediction")
+
+    # Updated inputs list and outputs list to match the do_predict function
+    inputs = [phone_hours, computer_hours, device_count, sleep_quality_label, sleep_time, sleep_hours]
+    # The do_predict function now returns either a dict or a string, update outputs accordingly
+    outputs = [proba_pretty, prediction_output]
+    for comp in inputs:
+        comp.change(fn=do_predict, inputs=inputs, outputs=outputs)
+
+    gradio.Examples(
+        examples=EXAMPLES,
+        inputs=inputs,
+        label="Representative examples",
+        examples_per_page=5,
+        cache_examples=False,
+    )
+
+if __name__ == "__main__":
+    demo.launch(debug=False)