Create app.py

app.py

@@ -0,0 +1,106 @@
+import gradio as gr
+import numpy as np
+import joblib
+import pickle
+import os
+
+# Expected filename (place your trained model here)
+MODEL_PATH = "cancer_forest.pkl"
+
+# Try to load the model robustly (joblib first, then pickle)
+model = None
+_load_error = None
+if os.path.exists(MODEL_PATH):
+    try:
+        model = joblib.load(MODEL_PATH)
+    except Exception as e1:
+        try:
+            with open(MODEL_PATH, "rb") as f:
+                model = pickle.load(f)
+        except Exception as e2:
+            _load_error = f"Failed to load model with joblib ({e1}) and pickle ({e2})"
+else:
+    _load_error = f"Model file not found at '{MODEL_PATH}'. Please upload the trained model."
+
+# Define target names in the same order as sklearn's breast cancer dataset:
+# 0 -> malignant, 1 -> benign
+TARGET_NAMES = ["malignant", "benign"]
+
+def predict_breast(mean_concave_points: float, worst_concave_points: float, worst_area: float):
+    """
+    Predict breast cancer (malignant/benign) using the trained RandomForest model
+    that expects the top 3 features in this order:
+      1. mean concave points
+      2. worst concave points
+      3. worst area
+
+    Returns:
+      - predicted label (string)
+      - dict of probabilities {label: probability}
+    """
+    if _load_error is not None:
+        return "MODEL LOAD ERROR", {"error": _load_error}
+
+    # Ensure model exists and supports predict/predict_proba
+    if model is None:
+        return "MODEL NOT LOADED", {"error": "Model is None after attempted load."}
+
+    arr = np.array([[mean_concave_points, worst_concave_points, worst_area]], dtype=float)
+
+    try:
+        pred_idx = int(model.predict(arr)[0])
+    except Exception as e:
+        return "PREDICTION ERROR", {"error": f"model.predict failed: {e}"}
+
+    proba = None
+    try:
+        proba_arr = model.predict_proba(arr)[0]
+        # Some classifiers put classes_ in different order; map by model.classes_
+        if hasattr(model, "classes_"):
+            # build mapping from class label (0/1) to probability
+            class_prob_map = {int(cls): float(proba_arr[i]) for i, cls in enumerate(model.classes_)}
+            proba = {
+                TARGET_NAMES[0]: float(class_prob_map.get(0, 0.0)),
+                TARGET_NAMES[1]: float(class_prob_map.get(1, 0.0)),
+            }
+        else:
+            # fallback: assume order is [0,1]
+            proba = {
+                TARGET_NAMES[0]: float(proba_arr[0]),
+                TARGET_NAMES[1]: float(proba_arr[1]) if len(proba_arr) > 1 else 0.0,
+            }
+    except Exception:
+        # If predict_proba not available, return deterministic prediction with probability 1.0
+        proba = {TARGET_NAMES[i]: (1.0 if i == pred_idx else 0.0) for i in range(len(TARGET_NAMES))}
+
+    predicted_label = TARGET_NAMES[pred_idx] if 0 <= pred_idx < len(TARGET_NAMES) else str(pred_idx)
+    return predicted_label, proba
+
+with gr.Blocks() as demo:
+    gr.Markdown("# 🩺 Breast Cancer Detector — Random Forest (Top 3 Features)")
+    gr.Markdown("This app predicts whether a tumor is malignant or benign using a RandomForest model trained on the top 3 features from the sklearn breast cancer dataset.\n\n"
+                "**Expected input order**: mean concave points, worst concave points, worst area")
+
+    with gr.Row():
+        with gr.Column():
+            mean_concave_points = gr.Number(label="Mean Concave Points", value=0.0)
+            worst_concave_points = gr.Number(label="Worst Concave Points", value=0.0)
+            worst_area = gr.Number(label="Worst Area", value=0.0)
+
+            predict_btn = gr.Button("Predict")
+            output_class = gr.Label(label="Predicted Class")
+            output_proba = gr.JSON(label="Probabilities")
+
+            predict_btn.click(
+                fn=predict_breast,
+                inputs=[mean_concave_points, worst_concave_points, worst_area],
+                outputs=[output_class, output_proba]
+            )
+
+        with gr.Column():
+            gr.Markdown(
+"""
+## 📖 API Usage (example for Hugging Face Spaces)
+When deployed to a Hugging Face Space, the Gradio app provides a POST /predict endpoint.
+
+### **API Endpoint (example)**