Deploy: 5-model ensemble predictor with Gradio API

README.md

@@ -1,12 +1,45 @@
 ---
-title: Dota2 Edge Ensemble
-emoji: 👀
-colorFrom: purple
-colorTo: red
+title: Dota 2 Edge Ensemble
+emoji: 🎮
+colorFrom: red
+colorTo: green
 sdk: gradio
-sdk_version: 6.9.0
+sdk_version: 4.44.1
 app_file: app.py
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Dota 2 Edge — Multi-Model Ensemble Predictor
+
+Predict professional Dota 2 match outcomes using a 5-model ensemble
+(XGBoost, LightGBM, CatBoost, LogReg, MLP) with Stacking meta-learner.
+
+## Prediction Moments
+
+| Moment | Description | Stacking AUC |
+|--------|-------------|-------------|
+| m0 | Draft (pre-game) | 0.587 |
+| m1 | @10 minutes | 0.735 |
+| m15 | @15 minutes | 0.807 |
+| m2 | @20 minutes | 0.838 |
+| m3 | @30 minutes | 0.963 |
+
+## Dataset
+
+Trained on 1,645 professional Dota 2 matches from OpenDota API.
+Dataset available at [Finish-him/dota2-pro-matches](https://huggingface.co/datasets/Finish-him/dota2-pro-matches).
+
+## API Usage
+
+```python
+from gradio_client import Client
+
+client = Client("Finish-him/dota2-edge-ensemble")
+result = client.predict(
+    moment="m1",
+    features_text='{"gold_delta_10": 2500, "xp_delta_10": 1800}',
+    api_name="/predict"
+)
+print(result)
+```

app.py

@@ -0,0 +1,214 @@
+"""
+Dota 2 Edge — Multi-Model Ensemble Prediction API
+==================================================
+HuggingFace Space serving XGBoost, LightGBM, CatBoost, LogReg, MLP
+with Stacking meta-learner for 5 prediction moments.
+"""
+
+import gradio as gr
+import pickle
+import numpy as np
+import json
+import os
+from pathlib import Path
+
+MODEL_DIR = Path("models")
+MOMENTS = {
+    'm0':  'Draft (pre-game)',
+    'm1':  '@10 minutes',
+    'm15': '@15 minutes',
+    'm2':  '@20 minutes',
+    'm3':  '@30 minutes',
+}
+
+# Load all ensemble bundles
+bundles = {}
+for mk in MOMENTS:
+    path = MODEL_DIR / f"ensemble_{mk}.pkl"
+    if path.exists():
+        with open(path, 'rb') as f:
+            bundles[mk] = pickle.load(f)
+
+# Load ensemble summary
+summary_path = MODEL_DIR / "ensemble_summary.json"
+if summary_path.exists():
+    with open(summary_path) as f:
+        ensemble_summary = json.load(f)
+else:
+    ensemble_summary = {}
+
+
+def predict(moment: str, features_json: str) -> dict:
+    """
+    Run ensemble prediction for a given moment.
+
+    Args:
+        moment: One of 'm0', 'm1', 'm15', 'm2', 'm3'
+        features_json: JSON object with feature values
+
+    Returns:
+        Dict with individual model probabilities + stacking ensemble
+    """
+    if moment not in bundles:
+        return {"error": f"Moment '{moment}' not loaded. Available: {list(bundles.keys())}"}
+
+    bundle = bundles[moment]
+    feature_cols = bundle['feature_cols']
+
+    # Parse features
+    try:
+        if isinstance(features_json, str):
+            features = json.loads(features_json)
+        else:
+            features = features_json
+    except json.JSONDecodeError as e:
+        return {"error": f"Invalid JSON: {e}"}
+
+    # Build feature vector
+    X = np.array([[features.get(col, 0.0) for col in feature_cols]])
+    X_scaled = bundle['scaler'].transform(X)
+
+    # Individual predictions
+    probs = {}
+    for name in bundle['base_model_names']:
+        model = bundle['models'][name]
+        if name in ('logreg', 'mlp'):
+            p = model.predict_proba(X_scaled)[:, 1][0]
+        else:
+            p = model.predict_proba(X)[:, 1][0]
+        probs[name] = round(float(p), 4)
+
+    # Average ensemble
+    avg = round(float(np.mean(list(probs.values()))), 4)
+
+    # Stacking meta-learner
+    stack_input = np.array([[probs[n] for n in bundle['base_model_names']]])
+    stacking = round(float(bundle['meta_learner'].predict_proba(stack_input)[:, 1][0]), 4)
+
+    return {
+        "moment": moment,
+        "moment_name": MOMENTS[moment],
+        "n_features_used": len(feature_cols),
+        "individual_models": probs,
+        "avg_ensemble": avg,
+        "stacking_ensemble": stacking,
+        "prediction": "Radiant" if stacking > 0.5 else "Dire",
+        "confidence": round(abs(stacking - 0.5) * 2, 4),
+    }
+
+
+def predict_all_moments(features_json: str) -> dict:
+    """Run prediction for all available moments."""
+    results = {}
+    for mk in bundles:
+        results[mk] = predict(mk, features_json)
+    return results
+
+
+def get_model_info() -> dict:
+    """Get info about loaded models."""
+    info = {
+        "available_moments": {},
+        "ensemble_summary": ensemble_summary,
+    }
+    for mk, bundle in bundles.items():
+        info["available_moments"][mk] = {
+            "name": MOMENTS[mk],
+            "n_features": bundle['n_features'],
+            "n_samples_trained": bundle['n_samples'],
+            "feature_columns": bundle['feature_cols'],
+            "base_models": bundle['base_model_names'],
+            "meta_weights": bundle['meta_weights'],
+            "results": bundle['results'],
+        }
+    return info
+
+
+# ================================================================
+# GRADIO INTERFACE
+# ================================================================
+
+def gradio_predict(moment, features_text):
+    try:
+        result = predict(moment, features_text)
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)}, indent=2)
+
+
+def gradio_info():
+    return json.dumps(get_model_info(), indent=2, default=str)
+
+
+# Example features for @10min
+example_features = {
+    "gold_delta_10": 2500,
+    "xp_delta_10": 1800,
+    "gold_growth_5_10": 450,
+    "deny_delta_10": 3,
+    "lh_delta_10": 25,
+    "kill_delta_10": 2,
+}
+
+with gr.Blocks(
+    title="Dota 2 Edge — Ensemble Predictor",
+    theme=gr.themes.Base(primary_hue="red", secondary_hue="green"),
+) as demo:
+    gr.Markdown("""
+    # Dota 2 Edge — Multi-Model Ensemble Predictor
+
+    Predict professional Dota 2 match outcomes using a 5-model ensemble
+    (XGBoost, LightGBM, CatBoost, LogReg, MLP) with Stacking meta-learner.
+
+    **Moments:** Draft | @10min | @15min | @20min | @30min
+
+    **Best AUC:** 0.963 (@30min stacking) | 0.807 (@15min) | 0.735 (@10min)
+    """)
+
+    with gr.Tab("Predict"):
+        with gr.Row():
+            moment_dropdown = gr.Dropdown(
+                choices=list(MOMENTS.keys()),
+                value="m1",
+                label="Prediction Moment",
+            )
+        features_input = gr.Textbox(
+            label="Features (JSON)",
+            value=json.dumps(example_features, indent=2),
+            lines=10,
+        )
+        predict_btn = gr.Button("Predict", variant="primary")
+        output = gr.Textbox(label="Result", lines=15)
+        predict_btn.click(gradio_predict, inputs=[moment_dropdown, features_input], outputs=output)
+
+    with gr.Tab("Model Info"):
+        info_btn = gr.Button("Load Model Info")
+        info_output = gr.Textbox(label="Model Details", lines=30)
+        info_btn.click(gradio_info, outputs=info_output)
+
+    with gr.Tab("API"):
+        gr.Markdown("""
+        ## API Usage
+
+        This Space exposes a Gradio API. You can call it programmatically:
+
+        ```python
+        from gradio_client import Client
+
+        client = Client("Finish-him/dota2-edge-ensemble")
+        result = client.predict(
+            moment="m1",
+            features_text='{"gold_delta_10": 2500, "xp_delta_10": 1800}',
+            api_name="/predict"
+        )
+        print(result)
+        ```
+
+        ### Endpoints
+        - `/predict` — Single moment prediction
+        - `/info` — Model details and feature lists
+        """)
+
+
+if __name__ == "__main__":
+    demo.launch()

models/ensemble_m0.pkl

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

models/ensemble_m1.pkl

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

models/ensemble_m15.pkl

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

models/ensemble_m2.pkl

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

models/ensemble_m3.pkl

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

models/ensemble_summary.json

@@ -0,0 +1,244 @@
+{
+  "trained_at_brt": "2026-03-24T04:18:04.226896-03:00",
+  "moments": {
+    "m0": {
+      "results": {
+        "xgboost": {
+          "auc": 0.5726,
+          "logloss": 0.7188,
+          "brier": 0.2588
+        },
+        "lightgbm": {
+          "auc": 0.5722,
+          "logloss": 0.7174,
+          "brier": 0.2582
+        },
+        "catboost": {
+          "auc": 0.581,
+          "logloss": 0.6801,
+          "brier": 0.2436
+        },
+        "logreg": {
+          "auc": 0.5652,
+          "logloss": 0.6886,
+          "brier": 0.2476
+        },
+        "mlp": {
+          "auc": 0.5615,
+          "logloss": 0.6884,
+          "brier": 0.2475
+        },
+        "avg_ensemble": {
+          "auc": 0.5847,
+          "logloss": 0.6809,
+          "brier": 0.244
+        },
+        "stacking": {
+          "auc": 0.5872,
+          "logloss": 0.6783,
+          "brier": 0.2427
+        }
+      },
+      "meta_weights": {
+        "xgboost": 9.4379,
+        "lightgbm": 4.8757,
+        "catboost": 1.686,
+        "logreg": -3.8813,
+        "mlp": -1.0309
+      }
+    },
+    "m1": {
+      "results": {
+        "xgboost": {
+          "auc": 0.7153,
+          "logloss": 0.6409,
+          "brier": 0.2208
+        },
+        "lightgbm": {
+          "auc": 0.7156,
+          "logloss": 0.6408,
+          "brier": 0.2201
+        },
+        "catboost": {
+          "auc": 0.7243,
+          "logloss": 0.6091,
+          "brier": 0.211
+        },
+        "logreg": {
+          "auc": 0.7252,
+          "logloss": 0.6147,
+          "brier": 0.2131
+        },
+        "mlp": {
+          "auc": 0.6925,
+          "logloss": 0.6789,
+          "brier": 0.2333
+        },
+        "avg_ensemble": {
+          "auc": 0.7314,
+          "logloss": 0.6062,
+          "brier": 0.2095
+        },
+        "stacking": {
+          "auc": 0.7349,
+          "logloss": 0.6025,
+          "brier": 0.208
+        }
+      },
+      "meta_weights": {
+        "xgboost": 8.4541,
+        "lightgbm": 6.2371,
+        "catboost": 1.4335,
+        "logreg": -3.4229,
+        "mlp": -0.2915
+      }
+    },
+    "m15": {
+      "results": {
+        "xgboost": {
+          "auc": 0.7928,
+          "logloss": 0.5738,
+          "brier": 0.1907
+        },
+        "lightgbm": {
+          "auc": 0.7842,
+          "logloss": 0.5818,
+          "brier": 0.1946
+        },
+        "catboost": {
+          "auc": 0.8005,
+          "logloss": 0.5376,
+          "brier": 0.1818
+        },
+        "logreg": {
+          "auc": 0.7925,
+          "logloss": 0.5556,
+          "brier": 0.1883
+        },
+        "mlp": {
+          "auc": 0.7781,
+          "logloss": 0.5628,
+          "brier": 0.1917
+        },
+        "avg_ensemble": {
+          "auc": 0.8036,
+          "logloss": 0.5352,
+          "brier": 0.1808
+        },
+        "stacking": {
+          "auc": 0.8068,
+          "logloss": 0.5355,
+          "brier": 0.1797
+        }
+      },
+      "meta_weights": {
+        "xgboost": 7.6935,
+        "lightgbm": 5.5758,
+        "catboost": 1.3063,
+        "logreg": -2.9682,
+        "mlp": 0.4831
+      }
+    },
+    "m2": {
+      "results": {
+        "xgboost": {
+          "auc": 0.8245,
+          "logloss": 0.5345,
+          "brier": 0.1757
+        },
+        "lightgbm": {
+          "auc": 0.821,
+          "logloss": 0.5391,
+          "brier": 0.1766
+        },
+        "catboost": {
+          "auc": 0.832,
+          "logloss": 0.5013,
+          "brier": 0.1669
+        },
+        "logreg": {
+          "auc": 0.8301,
+          "logloss": 0.509,
+          "brier": 0.1699
+        },
+        "mlp": {
+          "auc": 0.804,
+          "logloss": 0.542,
+          "brier": 0.182
+        },
+        "avg_ensemble": {
+          "auc": 0.8352,
+          "logloss": 0.4976,
+          "brier": 0.1658
+        },
+        "stacking": {
+          "auc": 0.8375,
+          "logloss": 0.5002,
+          "brier": 0.1654
+        }
+      },
+      "meta_weights": {
+        "xgboost": 6.8754,
+        "lightgbm": 6.2505,
+        "catboost": 1.2161,
+        "logreg": -2.691,
+        "mlp": 0.151
+      }
+    },
+    "m3": {
+      "results": {
+        "xgboost": {
+          "auc": 0.9612,
+          "logloss": 0.2771,
+          "brier": 0.0795
+        },
+        "lightgbm": {
+          "auc": 0.9617,
+          "logloss": 0.2798,
+          "brier": 0.0805
+        },
+        "catboost": {
+          "auc": 0.964,
+          "logloss": 0.2449,
+          "brier": 0.0736
+        },
+        "logreg": {
+          "auc": 0.9564,
+          "logloss": 0.2782,
+          "brier": 0.0828
+        },
+        "mlp": {
+          "auc": 0.9489,
+          "logloss": 0.2883,
+          "brier": 0.0891
+        },
+        "avg_ensemble": {
+          "auc": 0.9626,
+          "logloss": 0.2477,
+          "brier": 0.0746
+        },
+        "stacking": {
+          "auc": 0.9633,
+          "logloss": 0.258,
+          "brier": 0.0746
+        }
+      },
+      "meta_weights": {
+        "xgboost": 4.8879,
+        "lightgbm": 4.9469,
+        "catboost": 1.7448,
+        "logreg": 0.0635,
+        "mlp": 0.1361
+      }
+    }
+  },
+  "models": [
+    "xgboost",
+    "lightgbm",
+    "catboost",
+    "logreg",
+    "mlp"
+  ],
+  "meta_learner": "logistic_regression_stacking",
+  "total_time_s": 457.2
+}

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=4.0.0
+numpy
+scikit-learn
+xgboost
+lightgbm
+catboost