Upload 2 files

model_training.py

@@ -0,0 +1,288 @@
+# ...existing code...
+import joblib, json
+from pathlib import Path
+from xgboost import XGBClassifier
+from lightgbm import LGBMClassifier
+# ...existing code...
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.calibration import CalibratedClassifierCV
+
+try:
+    from ingest import metrics_report  # type: ignore
+except Exception:
+    try:
+        from preprocess import metrics_report  # type: ignore
+    except Exception:
+        # Minimal fallback implementation returning a dict compatible with existing summary DataFrame usage
+        from sklearn.metrics import log_loss, accuracy_score, brier_score_loss, roc_auc_score
+
+        def metrics_report(y_true, y_proba, name="model"):
+            """
+            Minimal metrics report compatible with the rest of the script.
+            Returns a dict with at least the key "model" so it can be placed into the summary DataFrame.
+            """
+            y_true = np.asarray(y_true)
+            proba = np.asarray(y_proba)
+
+            # handle binary vs multiclass probabilities
+            try:
+                if proba.ndim == 1 or proba.shape[1] == 1:
+                    # binary
+                    proba_flat = proba.ravel()
+                    y_pred = (proba_flat >= 0.5).astype(int)
+                    ll = float(log_loss(y_true, proba_flat)) if y_true.size and proba_flat.size else float("nan")
+                    try:
+                        auc = float(roc_auc_score(y_true, proba_flat))
+                    except Exception:
+                        auc = float("nan")
+                    try:
+                        brier = float(brier_score_loss(y_true, proba_flat))
+                    except Exception:
+                        brier = float("nan")
+                else:
+                    # multiclass
+                    y_pred = proba.argmax(axis=1)
+                    try:
+                        ll = float(log_loss(y_true, proba))
+                    except Exception:
+                        ll = float("nan")
+                    try:
+                        auc = float(roc_auc_score(y_true, proba, multi_class="ovr"))
+                    except Exception:
+                        auc = float("nan")
+                    # multiclass Brier as mean squared error against one-hot
+                    try:
+                        n_classes = proba.shape[1]
+                        one_hot = np.eye(n_classes)[y_true]
+                        brier = float(np.mean(np.sum((proba - one_hot) ** 2, axis=1)))
+                    except Exception:
+                        brier = float("nan")
+            except Exception:
+                y_pred = np.zeros_like(y_true)
+                ll = auc = brier = float("nan")
+
+            acc = float(accuracy_score(y_true, y_pred)) if y_true.size else float("nan")
+
+            return {
+                "model": name,
+                "accuracy": acc,
+                "log_loss": ll,
+                "roc_auc": auc,
+                "brier": brier
+            }
+
+def load_processed_data(target_col="target", data_dir=Path("data/processed")):
+    """
+    Try multiple ways to obtain a processed dataframe:
+    1) call a load_processed_data / load_data function from local ingest or preprocess modules
+    2) look for common filenames under data/processed (parquet/csv)
+    Returns: df (pd.DataFrame)
+    """
+    # 1) try local modules
+    try:
+        from ingest import load_processed_data as _lp  # type: ignore
+        df = _lp()
+        if isinstance(df, pd.DataFrame):
+            return df
+    except Exception:
+        pass
+
+    try:
+        from preprocess import load_processed_data as _lp2  # type: ignore
+        df = _lp2()
+        if isinstance(df, pd.DataFrame):
+            return df
+    except Exception:
+        pass
+
+    # 2) look for common files
+    candidates = [
+        data_dir / "processed.parquet",
+        data_dir / "dataset.parquet",
+        data_dir / "processed.csv",
+        data_dir / "dataset.csv",
+        data_dir / "train.parquet",
+        data_dir / "train.csv",
+    ]
+    for fp in candidates:
+        if fp.exists():
+            if fp.suffix == ".parquet":
+                return pd.read_parquet(fp)
+            else:
+                return pd.read_csv(fp)
+
+    raise FileNotFoundError(
+        f"No processed data found. Checked modules ingest/preprocess and files under {data_dir}. "
+        "Add a processed dataset or expose load_processed_data() in ingest/preprocess."
+    )
+
+# Load data and build train/valid/test splits
+df = load_processed_data()
+
+# infer target column
+TARGET = None
+for candidate in ("target", "label", "y", "outcome"):
+    if candidate in df.columns:
+        TARGET = candidate
+        break
+if TARGET is None:
+    raise KeyError("No target column found. Expected one of: target,label,y,outcome")
+
+# If dataset already includes a 'split' column with values 'train'/'valid'/'test', use it
+if "split" in df.columns:
+    train_df = df[df["split"] == "train"].drop(columns=["split"])
+    valid_df = df[df["split"] == "valid"].drop(columns=["split"])
+    test_df  = df[df["split"] == "test"].drop(columns=["split"])
+else:
+    # create splits: train/valid/test = 64%/16%/20% (approx)
+    train_val, test_df = train_test_split(df, test_size=0.20, stratify=df[TARGET], random_state=42)
+    train_df, valid_df = train_test_split(train_val, test_size=0.20, stratify=train_val[TARGET], random_state=42)
+
+X_cols = [c for c in df.columns if c != TARGET]
+WINDOW = int(df.attrs.get("WINDOW", 1)) if hasattr(df, "attrs") else 1
+
+X_train = train_df[X_cols]
+y_train = train_df[TARGET]
+X_valid = valid_df[X_cols]
+y_valid = valid_df[TARGET]
+X_test  = test_df[X_cols]
+y_test  = test_df[TARGET]
+
+# ...existing code...
+xgb = XGBClassifier(
+    n_estimators=6000,
+    max_depth=50,
+    learning_rate=0.05,
+    subsample=0.9,
+    colsample_bytree=0.9,
+    objective="multi:softprob",
+    num_class=3,
+    reg_lambda=1.0,
+    random_state=42,
+    tree_method="hist"
+)
+
+
+xgb = XGBClassifier(
+    n_estimators=6000,
+    max_depth=50,
+    learning_rate=0.05,
+    subsample=0.9,
+    colsample_bytree=0.9,
+    objective="multi:softprob",
+    num_class=3,
+    reg_lambda=1.0,
+    random_state=42,
+    tree_method="hist"
+)
+xgb.fit(X_train, y_train)
+proba_xgb_valid = xgb.predict_proba(X_valid)
+proba_xgb_test  = xgb.predict_proba(X_test)
+
+m_xgb_valid = metrics_report(y_valid, proba_xgb_valid, "xgb_valid")
+m_xgb_test  = metrics_report(y_test,  proba_xgb_test,  "xgb_test")
+
+# Isotonic calibration
+cal_xgb = CalibratedClassifierCV(xgb, method="isotonic", cv="prefit")
+cal_xgb.fit(X_valid, y_valid)
+proba_xgb_cal_valid = cal_xgb.predict_proba(X_valid)
+proba_xgb_cal_test  = cal_xgb.predict_proba(X_test)
+
+m_xgb_cal_valid = metrics_report(y_valid, proba_xgb_cal_valid, "xgb_cal_valid")
+m_xgb_cal_test  = metrics_report(y_test,  proba_xgb_cal_test,  "xgb_cal_test")
+
+# Platt (optional)
+cal_xgb_platt = CalibratedClassifierCV(xgb, method="sigmoid", cv="prefit")
+cal_xgb_platt.fit(X_valid, y_valid)
+proba_xgb_platt_test = cal_xgb_platt.predict_proba(X_test)
+m_xgb_platt_test = metrics_report(y_test, proba_xgb_platt_test, "xgb_platt_test")
+
+# -----------------------------
+# 8) LightGBM + Calibration
+# -----------------------------
+lgbm = LGBMClassifier(
+    n_estimators=12000,
+    learning_rate=0.03,
+    num_leaves=63,
+    subsample=0.9,
+    colsample_bytree=0.9,
+    objective="multiclass",
+    class_weight=None,
+    random_state=42
+)
+lgbm.fit(X_train, y_train)
+proba_lgb_valid = lgbm.predict_proba(X_valid)
+proba_lgb_test  = lgbm.predict_proba(X_test)
+
+m_lgb_valid = metrics_report(y_valid, proba_lgb_valid, "lgb_valid")
+m_lgb_test  = metrics_report(y_test,  proba_lgb_test,  "lgb_test")
+
+cal_lgb = CalibratedClassifierCV(lgbm, method="isotonic", cv="prefit")
+cal_lgb.fit(X_valid, y_valid)
+proba_lgb_cal_valid = cal_lgb.predict_proba(X_valid)
+proba_lgb_cal_test  = cal_lgb.predict_proba(X_test)
+
+m_lgb_cal_valid = metrics_report(y_valid, proba_lgb_cal_valid, "lgb_cal_valid")
+m_lgb_cal_test  = metrics_report(y_test,  proba_lgb_cal_test,  "lgb_cal_test")
+
+from sklearn.base import BaseEstimator, ClassifierMixin
+
+class PriorProbaPredictor(BaseEstimator, ClassifierMixin):
+    """Predict class probabilities equal to the class distribution in training data."""
+    def fit(self, X, y):
+        y = np.asarray(y)
+        classes, counts = np.unique(y, return_counts=True)
+        self.classes_ = classes
+        self.class_proba_ = counts / counts.sum()
+        return self
+
+    def predict_proba(self, X):
+        n = len(X)
+        # return array shape (n_samples, n_classes) following classes_ order
+        return np.tile(self.class_proba_, (n, 1))
+
+    def predict(self, X):
+        proba = self.predict_proba(X)
+        return proba.argmax(axis=1)
+
+odds = PriorProbaPredictor()
+odds.fit(X_train, y_train)
+proba_odds_valid = odds.predict_proba(X_valid)
+proba_odds_test  = odds.predict_proba(X_test)
+
+m_odds_valid = metrics_report(y_valid, proba_odds_valid, "odds_valid")
+m_odds_test  = metrics_report(y_test,  proba_odds_test,  "odds_test")
+# ...existing code...
+# -----------------------------
+# 9) Summary table
+# -----------------------------
+summary = pd.DataFrame([
+    m_odds_valid, m_odds_test,
+    m_xgb_valid, m_xgb_test, m_xgb_cal_valid, m_xgb_cal_test, m_xgb_platt_test,
+    m_lgb_valid, m_lgb_test, m_lgb_cal_valid, m_lgb_cal_test
+]).sort_values("model").reset_index(drop=True)
+
+try:
+    from IPython.display import display as _display
+    _display(summary)
+except Exception:
+    print(summary.to_string(index=False))
+
+
+# Optional: save metrics
+summary.to_csv("./evaluation/baseline_metrics.csv", index=False)
+print("Saved: baseline_metrics.csv")
+
+Path(".").mkdir(exist_ok=True)
+
+# เลือกโมเดลที่ต้องการใช้ inference (แนะนำตัวที่ calibrated แล้ว)
+joblib.dump(cal_xgb, "./model/model_xgb_isotonic.joblib")
+joblib.dump(cal_lgb, "./model/model_lgb_isotonic.joblib")
+
+# เก็บคอลัมน์ฟีเจอร์ และพารามิเตอร์สำคัญ
+with open("feature_columns.json", "w", encoding="utf-8") as f:
+    json.dump({"X_cols": X_cols, "WINDOW": int(WINDOW)}, f, ensure_ascii=False, indent=2)
+
+print("Saved: model_xgb_isotonic.joblib, model_lgb_isotonic.joblib, feature_columns.json")

preprocess_data.py

@@ -0,0 +1,196 @@
+import numpy as np
+import pandas as pd
+from collections import defaultdict
+from unidecode import unidecode
+from sklearn.metrics import log_loss, accuracy_score
+
+def prepare_features(data_raw: pd.DataFrame, window: int = 7, verbose: bool = True):
+    """Prepare features from raw EPL data.
+
+    Returns (feat_df, X_cols, WINDOW, base_df)
+    - feat_df: DataFrame with features aligned to training
+    - X_cols: list of feature column names used for modeling
+    - WINDOW: the rolling window used
+    - base_df: base match DataFrame with cleaned columns (date, home, away, ftr, ...)
+    """
+    RENAME = {
+        "Date":"date","Time":"time","HomeTeam":"home","AwayTeam":"away",
+        "FTHG":"fthg","FTAG":"ftag","FTR":"ftr",
+        "HTHG":"hthg","HTAG":"htag","HTR":"htr",
+        "Referee":"ref",
+        "HS":"hs","AS":"as","HST":"hst","AST":"ast",
+        "HF":"hf","AF":"af","HC":"hc","AC":"ac",
+        "HY":"hy","AY":"ay","HR":"hr","AR":"ar",
+        # odds (Bet365, William Hill, Pinnacle(PS), VC)
+        "B365H":"b365h","B365D":"b365d","B365A":"b365a",
+        "WHH":"whh","WHD":"whd","WHA":"wha",
+        "PSH":"psh","PSD":"psd","PSA":"psa",
+        "VCH":"vch","VCD":"vcd","VCA":"vca",
+    }
+    df = data_raw.rename(columns=RENAME).copy()
+
+    # parse date
+    from datetime import datetime
+    def parse_date(x):
+        for fmt in ("%d/%m/%Y", "%d/%m/%y", "%Y-%m-%d"):
+            try:
+                return datetime.strptime(str(x), fmt)
+            except Exception:
+                pass
+        return pd.NaT
+    df["date"] = df["date"].map(parse_date)
+    df = df[~df["date"].isna()].copy()
+
+    # clean team names
+    def clean_team(s):
+        if pd.isna(s): return s
+        s = unidecode(str(s)).strip()
+        s = " ".join(s.split())
+        return s
+    df["home"] = df["home"].map(clean_team)
+    df["away"] = df["away"].map(clean_team)
+
+    # keep valid rows
+    df = df[(df["ftr"].isin(["H","D","A"])) & (~df["home"].isna()) & (~df["away"].isna())].copy()
+    df.sort_values(["date","home","away"], inplace=True, ignore_index=True)
+
+    # target
+    label_map = {"H":0, "D":1, "A":2}
+    df["y"] = df["ftr"].map(label_map)
+
+    # -----------------------------
+    # 3) Odds → implied probabilities (normalize overround)
+    # -----------------------------
+    def implied_probs(row, prefix):
+        h,d,a = row.get(prefix+"h"), row.get(prefix+"d"), row.get(prefix+"a")
+        if any(pd.isna([h,d,a])): return pd.Series([np.nan,np.nan,np.nan])
+        if min(h,d,a) <= 1.0:     return pd.Series([np.nan,np.nan,np.nan])
+        inv = np.array([1/h, 1/d, 1/a], dtype=float)
+        s = inv.sum()
+        if s <= 0: return pd.Series([np.nan,np.nan,np.nan])
+        return pd.Series(inv / s)
+
+    for bk in ["b365","wh","ps","vc"]:
+        cols_exist = all([(bk+c) in df.columns for c in ["h","d","a"]])
+        if cols_exist:
+            probs = df.apply(lambda r: implied_probs(r, bk), axis=1, result_type="expand")
+            df[[f"p_{bk}_H", f"p_{bk}_D", f"p_{bk}_A"]] = probs
+
+    prob_cols = [c for c in df.columns if c.startswith("p_") and c[-2:] in ["_H","_D","_A"]]
+    def avg_prob(suffix):
+        cols = [c for c in prob_cols if c.endswith(suffix)]
+        return df[cols].mean(axis=1)
+
+    df["p_odds_H"] = avg_prob("_H")
+    df["p_odds_D"] = avg_prob("_D")
+    df["p_odds_A"] = avg_prob("_A")
+
+    # -----------------------------
+    # 4) Leak-free features: rolling form + simple Elo
+    # -----------------------------
+    def result_points(ftr, is_home):
+        if ftr == "D": return 1
+        if ftr == "H": return 3 if is_home else 0
+        if ftr == "A": return 0 if is_home else 3
+        return 0
+
+    tm_rows = []
+    for i, r in df.iterrows():
+        # home perspective
+        tm_rows.append({
+            "match_id": i, "date": r["date"], "team": r["home"], "opp": r["away"], "is_home": 1,
+            "gf": r["fthg"], "ga": r["ftag"],
+            "shots_f": r.get("hs", np.nan), "shots_a": r.get("as", np.nan),
+            "sot_f": r.get("hst", np.nan), "sot_a": r.get("ast", np.nan),
+            "corn_f": r.get("hc", np.nan), "corn_a": r.get("ac", np.nan),
+            "y_f": r.get("hy", np.nan), "y_a": r.get("ay", np.nan),
+            "r_f": r.get("hr", np.nan), "r_a": r.get("ar", np.nan),
+            "points": result_points(r["ftr"], True),
+        })
+        # away perspective
+        tm_rows.append({
+            "match_id": i, "date": r["date"], "team": r["away"], "opp": r["home"], "is_home": 0,
+            "gf": r["ftag"], "ga": r["fthg"],
+            "shots_f": r.get("as", np.nan), "shots_a": r.get("hs", np.nan),
+            "sot_f": r.get("ast", np.nan), "sot_a": r.get("hst", np.nan),
+            "corn_f": r.get("ac", np.nan), "corn_a": r.get("hc", np.nan),
+            "y_f": r.get("ay", np.nan), "y_a": r.get("hy", np.nan),
+            "r_f": r.get("ar", np.nan), "r_a": r.get("hr", np.nan),
+            "points": result_points(r["ftr"], False),
+        })
+    tm = pd.DataFrame(tm_rows).sort_values(["team","date"]).reset_index(drop=True)
+
+    WINDOW = int(window)
+    agg_cols = ["gf","ga","shots_f","shots_a","sot_f","sot_a","corn_f","corn_a","y_f","r_f","points"]
+    for col in agg_cols:
+        tm[f"roll_{col}"] = (tm.groupby("team")[col]
+                               .rolling(WINDOW, min_periods=1).mean()
+                               .shift(1)  # ใช้ข้อมูลก่อนหน้าเท่านั้น
+                               .reset_index(level=0, drop=True))
+
+    # Elo (ง่าย)
+    BASE_ELO = 1500.0
+    K = 20.0
+    HOME_ADV = 60.0
+
+    elo = defaultdict(lambda: BASE_ELO)
+    elo_before_home, elo_before_away = [], []
+
+    df_sorted = df.sort_values("date").reset_index(drop=True)
+    for i, r in df_sorted.iterrows():
+        h, a = r["home"], r["away"]
+        eh, ea = elo[h], elo[a]
+        elo_before_home.append(eh); elo_before_away.append(ea)
+        ph = 1.0/(1.0 + 10**(-((eh+HOME_ADV)-ea)/400))
+        if r["ftr"] == "H": oh, oa = 1.0, 0.0
+        elif r["ftr"] == "D": oh, oa = 0.5, 0.5
+        else: oh, oa = 0.0, 1.0
+        elo[h] = eh + K*(oh - ph)
+        elo[a] = ea + K*((1.0-oh) - (1.0-ph))
+
+    df_sorted["elo_home"] = elo_before_home
+    df_sorted["elo_away"] = elo_before_away
+    df_sorted["elo_diff"] = df_sorted["elo_home"] - df_sorted["elo_away"]
+
+    # Merge rolling features into match rows
+    home_tm = tm[tm["is_home"]==1].copy()
+    away_tm = tm[tm["is_home"]==0].copy()
+    home_feats = home_tm.filter(regex="^roll_").columns.tolist()
+    hf = home_tm[["match_id"] + home_feats].rename(columns={c: f"home_{c}" for c in home_feats})
+    af = away_tm[["match_id"] + home_feats].rename(columns={c: f"away_{c}" for c in home_feats})
+
+    feat_df = df_sorted.merge(hf, left_index=True, right_on="match_id", how="left") \
+                       .merge(af, left_index=True, right_on="match_id", how="left")
+
+    # Fill odds missing (keep baseline)
+    for c in ["p_odds_H","p_odds_D","p_odds_A"]:
+        if c in feat_df.columns:
+            feat_df[c] = feat_df[c].astype(float).fillna(feat_df[c].mean())
+
+    role_feats = [f"home_{c}" for c in home_feats] + [f"away_{c}" for c in home_feats]
+    elo_feats  = ["elo_home","elo_away","elo_diff"]
+    odds_feats = ["p_odds_H","p_odds_D","p_odds_A"]
+    X_cols = role_feats + elo_feats + odds_feats
+
+    for c in X_cols:
+        if c not in feat_df.columns:
+            feat_df[c] = np.nan
+        feat_df[c] = feat_df[c].astype(float).fillna(feat_df[c].median())
+
+    # -----------------------------
+    # 5) Time-based split (kept for compatibility, but not returned)
+    # -----------------------------
+    n = len(feat_df)
+    idx_train = int(n*0.70)
+    idx_valid = int(n*0.85)
+    if verbose and n > 0:
+        dates_train = feat_df["date"].iloc[:idx_train].max()
+        dates_valid = (feat_df["date"].iloc[idx_train:idx_valid].min(),
+                       feat_df["date"].iloc[idx_train:idx_valid].max())
+        dates_test  = (feat_df["date"].iloc[idx_valid:].min(),
+                       feat_df["date"].iloc[idx_valid:].max())
+        print(f"Train up to: {dates_train:%Y-%m-%d}")
+        print(f"Valid: {dates_valid[0]:%Y-%m-%d} .. {dates_valid[1]:%Y-%m-%d}")
+        print(f"Test : {dates_test[0]:%Y-%m-%d} .. {dates_test[1]:%Y-%m-%d}")
+
+    return feat_df, X_cols, WINDOW, df_sorted