MLB Game Prediction
MLOps Pipeline

import pandas as pd
import numpy as np
from feast import FeatureStore

def compute_sabermetrics(df: pd.DataFrame) -> pd.DataFrame:
    # Weighted On-Base Average (wOBA) — 2025 weights
    df["woba"] = (
        0.69 * df["bb"] + 0.72 * df["hbp"] +
        0.89 * df["singles"] + 1.27 * df["doubles"] +
        1.62 * df["triples"] + 2.10 * df["hr"]
    ) / (df["ab"] + df["bb"] + df["sf"] + df["hbp"])

    # ERA+ (park-adjusted pitcher quality)
    df["era_plus"] = 100 * (df["lg_era"] / df["era"].replace(0, np.nan))

    # Bullpen fatigue — rolling 5-day pitch count
    df["bullpen_fatigue"] = (
        df.groupby("team_id")["pitches"]
          .transform(lambda x: x.rolling(5, min_periods=1).mean())
    )

    # Park factor (run environment adjustment)
    df["park_factor"] = df["home_park_factor"].fillna(1.0)

    # Left/Right platoon advantage
    df["platoon_adv"] = (df["starter_hand"] != df["opp_lineup_side"]).astype(float)

    return df

# Serve features from Feast for zero training-serving skew
def get_online_features(team_id: int, store: FeatureStore) -> dict:
    return store.get_online_features(
        features=["mlb_teams:woba","mlb_teams:era_plus",
                  "mlb_teams:bullpen_fatigue","mlb_teams:park_factor"],
        entity_rows=[{"team_id": team_id}]
    ).to_dict()

import xgboost as xgb
import optuna
from sklearn.model_selection import TimeSeriesSplit
from sklearn.metrics import brier_score_loss, roc_auc_score
import mlflow

def train_with_time_cv(X: pd.DataFrame, y: pd.Series) -> xgb.XGBClassifier:
    tscv = TimeSeriesSplit(n_splits=5)  # chronological — no future leakage

    def objective(trial):
        params = {
            "n_estimators":     trial.suggest_int("n_estimators", 100, 500),
            "max_depth":        trial.suggest_int("max_depth", 3, 8),
            "learning_rate":    trial.suggest_float("lr", 0.01, 0.3, log=True),
            "subsample":        trial.suggest_float("subsample", 0.6, 1.0),
            "colsample_bytree": trial.suggest_float("colsample", 0.6, 1.0),
        }
        scores = []
        for train_idx, val_idx in tscv.split(X):
            model = xgb.XGBClassifier(**params, eval_metric="logloss")
            model.fit(X.iloc[train_idx], y.iloc[train_idx], verbose=False)
            preds = model.predict_proba(X.iloc[val_idx])[:, 1]
            scores.append(roc_auc_score(y.iloc[val_idx], preds))
        return float(np.mean(scores))

    study = optuna.create_study(direction="maximize")
    study.optimize(objective, n_trials=200, show_progress_bar=True)

    with mlflow.start_run(run_name="xgb_final"):
        best = xgb.XGBClassifier(**study.best_params)
        best.fit(X, y)
        mlflow.log_params(study.best_params)
        mlflow.log_metric("best_cv_auc", study.best_value)
        mlflow.xgboost.log_model(best, "model")
    return best

from evidently.report import Report
from evidently.metric_preset import DataDriftPreset
import pandas as pd
import mlflow

def check_and_retrain_if_drifted(
    reference: pd.DataFrame,
    current: pd.DataFrame,
    psi_threshold: float = 0.20
) -> dict:
    report = Report(metrics=[DataDriftPreset()])
    report.run(reference_data=reference, current_data=current)
    result = report.as_dict()

    drift_info = {
        "dataset_drift":       result["metrics"][0]["result"]["dataset_drift"],
        "n_drifted_features":  result["metrics"][0]["result"]["n_drifted_features"],
        "share_drifted":       result["metrics"][0]["result"]["share_drifted_features"],
    }

    with mlflow.start_run(run_name="drift_monitor"):
        for k, v in drift_info.items():
            mlflow.log_metric(k, float(v))

    if drift_info["share_drifted"] > psi_threshold:
        # Auto-trigger retrain via Azure ML pipeline
        trigger_azure_ml_retrain(
            reason="feature_drift_detected",
            psi=drift_info["share_drifted"]
        )

    return drift_info