Upload 2 files

utils/encoders.py

@@ -0,0 +1,72 @@
+"""
+utils/encoders.py
+Label-encoding maps that mirror the sklearn LabelEncoder used during training.
+All lists are sorted alphabetically – matching the default LabelEncoder order.
+"""
+
+# ── IPL Teams (alphabetical order = encoding index) ──────────────────────────
+TEAMS = sorted([
+    "Chennai Super Kings",
+    "Delhi Capitals",
+    "Gujarat Titans",
+    "Kolkata Knight Riders",
+    "Lucknow Super Giants",
+    "Mumbai Indians",
+    "Punjab Kings",
+    "Rajasthan Royals",
+    "Royal Challengers Bangalore",
+    "Sunrisers Hyderabad",
+])
+
+TEAM_ENC: dict[str, int] = {team: idx for idx, team in enumerate(TEAMS)}
+
+# ── IPL Venues (alphabetical order = encoding index) ─────────────────────────
+VENUES = sorted([
+    "Arun Jaitley Stadium",
+    "Brabourne Stadium",
+    "DY Patil Stadium",
+    "Eden Gardens",
+    "Feroz Shah Kotla",
+    "MA Chidambaram Stadium",
+    "MCA Stadium",
+    "Maharashtra Cricket Association Stadium",
+    "Narendra Modi Stadium",
+    "Punjab Cricket Association Stadium",
+    "Rajiv Gandhi International Stadium",
+    "Sawai Mansingh Stadium",
+    "Wankhede Stadium",
+])
+
+VENUE_ENC: dict[str, int] = {venue: idx for idx, venue in enumerate(VENUES)}
+
+# ── Phase encoding ────────────────────────────────────────────────────────────
+PHASE_LABELS = {
+    0: "Powerplay (Ov 1–6)",
+    1: "Middle Overs (Ov 7–15)",
+    2: "Death Overs (Ov 16–20)",
+}
+
+
+def encode_team(name: str) -> int:
+    """Return integer encoding for a team name. Defaults to 0 if not found."""
+    return TEAM_ENC.get(name, 0)
+
+
+def encode_venue(name: str) -> int:
+    """Return integer encoding for a venue name. Defaults to 0 if not found."""
+    return VENUE_ENC.get(name, 0)
+
+
+def get_phase(over: int) -> int:
+    """
+    Returns match phase (0/1/2) based on over number.
+      0 = Powerplay   (overs 1–6)
+      1 = Middle overs(overs 7–15)
+      2 = Death overs (overs 16–20)
+    """
+    if over < 6:
+        return 0
+    elif over < 15:
+        return 1
+    else:
+        return 2

utils/predictor.py

@@ -0,0 +1,161 @@
+"""
+utils/predictor.py
+Loads the four XGBoost models and exposes a single predict() method
+that accepts a raw request dict and returns a structured result dict.
+"""
+
+import os
+import pickle
+import warnings
+import pandas as pd
+
+from utils.encoders import encode_team, encode_venue, get_phase, PHASE_LABELS
+
+warnings.filterwarnings("ignore")
+
+# ── Model file paths ──────────────────────────────────────────────────────────
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+MODELS_DIR = os.path.join(BASE_DIR, "models")
+
+
+class CricketPredictor:
+    """
+    Loads all four pre-trained XGBoost models and provides
+    ball-level and match-level predictions.
+
+    Models
+    ------
+    dot_model      : DotBall.pkl          – P(dot ball)       binary
+    boundary_model : BoundaryModel.pkl    – P(boundary 4/6)   binary
+    run_model      : RunPrediction.pkl    – P(0..5 runs)      multi-class
+    win_model      : IPLchasingTeamWin.pkl– P(chase success)  binary
+    """
+
+    def __init__(self):
+        print("Loading models...")
+        self.dot_model      = self._load("DotBall.pkl")
+        self.boundary_model = self._load("BoundaryModel.pkl")
+        self.run_model      = self._load("RunPrediction.pkl")
+        self.win_model      = self._load("IPLchasingTeamWin.pkl")
+        print("✓ All 4 models loaded successfully.\n")
+
+    # ── Public API ────────────────────────────────────────────────────────────
+
+    def predict(self, data: dict) -> dict:
+        """
+        Main prediction entry point.
+
+        Parameters
+        ----------
+        data : dict   Raw JSON body from the API request.
+
+        Returns
+        -------
+        dict with keys:
+            dot_ball_prob    float  – % probability of a dot ball
+            boundary_prob    float  – % probability of a 4 or 6
+            expected_runs    float  – weighted average expected runs
+            run_distribution list   – [P(0), P(1), P(2), P(3), P(4), P(5)]
+            win_probability  float|None – % win prob for chasing team (innings=2 only)
+            phase            str    – human-readable phase label
+        """
+        # ── 1. Parse & validate inputs ────────────────────────────────────────
+        batting_team   = str(data.get("batting_team", ""))
+        bowling_team   = str(data.get("bowling_team", ""))
+        venue          = str(data.get("venue", ""))
+        innings        = int(data.get("innings", 1))
+        over           = int(data.get("over", 1))
+        ball_in_over   = int(data.get("ball_in_over", 1))
+        current_score  = float(data.get("current_score", 0))
+        wickets_fallen = int(data.get("wickets_fallen", 0))
+
+        # Optional performance features
+        batter_sr      = float(data.get("batter_sr", 130))
+        bowler_eco     = float(data.get("bowler_eco", 7.5))
+        last_6_runs    = float(data.get("last_6_runs", 6))
+        last_12_runs   = float(data.get("last_12_runs", 12))
+        prev_runs      = float(data.get("prev_runs", 1))
+        prev_wicket    = int(data.get("prev_wicket", 0))
+        last_6_wickets = int(data.get("last_6_wickets", 0))
+        striker_enc    = int(data.get("striker_enc", 0))
+        bowler_enc     = int(data.get("bowler_enc", 0))
+
+        # ── 2. Derived features ───────────────────────────────────────────────
+        balls_bowled = over * 6 + ball_in_over
+        run_rate     = round(current_score / max(balls_bowled, 1) * 6, 3)
+        phase        = get_phase(over)
+
+        # ── 3. Build ball-level feature DataFrame ─────────────────────────────
+        ball_df = pd.DataFrame([{
+            "striker_enc"      : striker_enc,
+            "bowler_enc"       : bowler_enc,
+            "batting_team_enc" : encode_team(batting_team),
+            "bowling_team_enc" : encode_team(bowling_team),
+            "venue_enc"        : encode_venue(venue),
+            "over"             : over,
+            "ball_in_over"     : ball_in_over,
+            "phase"            : phase,
+            "current_score"    : current_score,
+            "wickets_fallen"   : wickets_fallen,
+            "run_rate"         : run_rate,
+            "prev_runs"        : prev_runs,
+            "prev_wicket"      : prev_wicket,
+            "last_6_runs"      : last_6_runs,
+            "last_12_runs"     : last_12_runs,
+            "last_6_wickets"   : last_6_wickets,
+            "batter_sr"        : batter_sr,
+            "bowler_eco"       : bowler_eco,
+        }])
+
+        # ── 4. Run the three ball-level models ────────────────────────────────
+        dot_prob      = float(self.dot_model.predict_proba(ball_df)[0][1])
+        boundary_prob = float(self.boundary_model.predict_proba(ball_df)[0][1])
+
+        run_proba     = self.run_model.predict_proba(ball_df)[0]
+        run_dist      = [round(float(p), 4) for p in run_proba]
+        expected_runs = round(sum(i * run_dist[i] for i in range(len(run_dist))), 3)
+
+        # ── 5. Win probability (2nd innings only) ─────────────────────────────
+        win_prob = None
+        if innings == 2:
+            balls_remaining = int(data.get("balls_remaining", 60))
+            balls_done_chase = max(120 - balls_remaining, 1)
+            chase_rr = round(current_score / balls_done_chase * 6, 3)
+
+            win_df = pd.DataFrame([{
+                "batting_team"   : encode_team(batting_team),
+                "bowling_team"   : encode_team(bowling_team),
+                "venue"          : encode_venue(venue),
+                "innings"        : innings,
+                "current_score"  : current_score,
+                "wickets_fallen" : wickets_fallen,
+                "balls_remaining": balls_remaining,
+                "run_rate"       : chase_rr,
+            }])
+            win_prob = round(float(self.win_model.predict_proba(win_df)[0][1]) * 100, 1)
+
+        # ── 6. Return structured result ───────────────────────────────────────
+        return {
+            "dot_ball_prob"   : round(dot_prob * 100, 1),
+            "boundary_prob"   : round(boundary_prob * 100, 1),
+            "expected_runs"   : expected_runs,
+            "run_distribution": run_dist,
+            "win_probability" : win_prob,
+            "phase"           : PHASE_LABELS[phase],
+            "run_rate"        : round(run_rate, 2),
+        }
+
+    def models_loaded(self) -> list[str]:
+        return ["DotBall", "BoundaryModel", "RunPrediction", "IPLchasingTeamWin"]
+
+    # ── Private helpers ───────────────────────────────────────────────────────
+
+    def _load(self, filename: str):
+        path = os.path.join(MODELS_DIR, filename)
+        if not os.path.exists(path):
+            raise FileNotFoundError(
+                f"Model file not found: {path}\n"
+                f"Make sure {filename} is inside the 'models/' folder."
+            )
+        with open(path, "rb") as f:
+            return pickle.load(f)