Upload 10 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+proto_core_with_proba_0904_0717.xlsx filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,20 +1,13 @@
+
 ---
-title: Mustrategy V2
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
+title: Similar Match Filter App
+emoji: ⚽️
+colorFrom: green
+colorTo: blue
+sdk: streamlit
+sdk_version: "1.31.1"
+app_file: app.py
 pinned: false
-short_description: Football match outcome predictor using odds and ML models
-license: mit
 ---
 
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+유사 배당 구조를 기반으로 정배 방향, 무 위치, 배당대 등을 필터링하여 유사 경기를 분석하고 분포 및 예측 결과를 제공합니다.

app.py

@@ -0,0 +1,808 @@
+import numpy as np
+from sklearn.isotonic import IsotonicRegression
+from sklearn.preprocessing import StandardScaler   # ← NEW
+from sklearn.metrics.pairwise import euclidean_distances
+
+from decimal import Decimal, getcontext
+getcontext().prec = 12
+
+def decimal_places(x):
+    """소수 자릿수 정확 계산(부동소수 오차 방지)"""
+    s = f"{float(x):.6f}".rstrip("0").rstrip(".")
+    return 0 if "." not in s else len(s.split(".")[1])
+
+# ===== (NEW) 무/핸무 순위 마스크 =====
+def _rank12_app26(value, trio):
+    vals = [float(x) for x in trio]
+    uniq = sorted(set(vals), reverse=True)
+    v = float(value)
+    if len(uniq) == 0:
+        return 0
+    if v == uniq[0]:
+        return 1
+    if len(uniq) > 1 and v == uniq[1]:
+        return 2
+    return 0
+    
+class AverageProbaEstimator:
+    def __init__(self, models):
+        self.models = models
+    def fit(self, X, y=None):
+        for model in self.models:
+            model.fit(X, y)
+        return self
+    def predict_proba(self, X):
+        probas = [model.predict_proba(X) for model in self.models]
+        return np.mean(probas, axis=0)
+    def predict(self, X):
+        return np.argmax(self.predict_proba(X), axis=1)    
+
+class SoftVotingIsotonicWrapper:
+    def __init__(self, models, class_idx=1):
+        self.avg_model = AverageProbaEstimator(models)
+        self.iso = IsotonicRegression(out_of_bounds="clip")
+        self.class_idx = class_idx
+    def fit(self, X, y):
+        self.avg_model.fit(X, y)
+        probs = self.avg_model.predict_proba(X)
+        self.iso.fit(probs[:, self.class_idx], y)
+        return self
+    def predict_proba(self, X):
+        probs = self.avg_model.predict_proba(X)
+        calibrated = self.iso.predict(probs[:, self.class_idx])
+        result = np.zeros_like(probs)
+        result[:, self.class_idx] = calibrated
+        other = (1 - calibrated) / (probs.shape[1] - 1)
+        for i in range(probs.shape[1]):
+            if i != self.class_idx:
+                result[:, i] = other
+        return result
+    def predict(self, X):
+        return np.argmax(self.predict_proba(X), axis=1)    
+
+
+# ✅ 여기에 기존 import문 추가
+import streamlit as st
+import pandas as pd
+import numpy as np
+import joblib
+from xgboost import XGBClassifier
+
+expected_cols = [
+        'norm_win', 'norm_draw', 'norm_lose', 'mean_odds', 'std_odds', 'cv_odds',
+        'p_win', 'p_draw', 'p_lose', 'overround', 'entropy', 'spread', 'spread_draw',
+        'odds_ratio_wd', 'odds_ratio_wl', 'odds_ratio_dl',
+        'draw_prob_ratio', 'draw_ratio', 'draw_prob_gap',
+        'fav_gap', 'fav_draw_gap', 'fav_diff', 'draw_gap_mean',
+        'rank_win', 'rank_draw', 'rank_lose',
+        'p_win_norm', 'p_draw_norm', 'p_lose_norm',
+        'ev_win', 'ev_draw', 'ev_lose',
+        'draw_vs_avg', 'draw_vs_max',
+        'cv_spread', 'cv_draw_gap',
+        'draw_margin','fav_ratio','draw_skew','log_spread','draw_entropy_component','dominance_score'
+    ]        
+
+def generate_features_from_input(win, draw, lose):
+    import numpy as np
+    import pandas as pd
+
+    d = {}
+    d['norm_win'] = win / (win + draw + lose)
+    d['norm_draw'] = draw / (win + draw + lose)
+    d['norm_lose'] = lose / (win + draw + lose)
+    d['mean_odds'] = np.mean([win, draw, lose])
+    d['std_odds'] = np.std([win, draw, lose])
+    d['cv_odds'] = d['std_odds'] / d['mean_odds']
+    d['p_win'] = 1 / win
+    d['p_draw'] = 1 / draw
+    d['p_lose'] = 1 / lose
+    p_total = d['p_win'] + d['p_draw'] + d['p_lose']
+    d['p_win_norm'] = d['p_win'] / p_total
+    d['p_draw_norm'] = d['p_draw'] / p_total
+    d['p_lose_norm'] = d['p_lose'] / p_total
+    d['overround'] = p_total
+    d['entropy'] = -sum([d[k] * np.log(d[k]) for k in ['p_win_norm', 'p_draw_norm', 'p_lose_norm']])
+    d['spread'] = max(win, draw, lose) - min(win, draw, lose)
+    d['spread_draw'] = abs(draw - (win + lose)/2)
+    d['odds_ratio_wd'] = win / draw
+    d['odds_ratio_wl'] = win / lose
+    d['odds_ratio_dl'] = draw / lose
+    d['draw_prob_ratio'] = d['p_draw'] / max(d['p_win'], d['p_lose'])
+    d['draw_ratio'] = draw / min(win, lose)
+    d['draw_prob_gap'] = abs(d['p_draw'] - (d['p_win'] + d['p_lose']) / 2)
+    d['fav_gap'] = abs(win - lose)
+    d['fav_draw_gap'] = abs(draw - min(win, lose))
+    d['fav_diff'] = abs(win - lose)
+    d['draw_gap_mean'] = abs(draw - d['mean_odds'])
+    d['rank_win'] = sorted([win, draw, lose]).index(win) + 1
+    d['rank_draw'] = sorted([win, draw, lose]).index(draw) + 1
+    d['rank_lose'] = sorted([win, draw, lose]).index(lose) + 1
+    d['ev_win'] = win * d['p_win_norm']
+    d['ev_draw'] = draw * d['p_draw_norm']
+    d['ev_lose'] = lose * d['p_lose_norm']
+    d['draw_vs_avg'] = draw / d['mean_odds']
+    d['draw_vs_max'] = draw / max(win, draw, lose)
+    d['cv_spread'] = d['spread'] / d['mean_odds']
+    d['cv_draw_gap'] = d['fav_draw_gap'] / d['mean_odds']
+    d['draw_margin'] = abs(draw - (win + lose)/2)
+    d['fav_ratio'] = min(win, lose) / max(win, lose)
+    d['draw_skew'] = (draw - win) - (lose - draw)
+    d['log_spread'] = np.log(max(win, draw, lose)) - np.log(min(win, draw, lose))
+    d['draw_entropy_component'] = -d['p_draw_norm'] * np.log(d['p_draw_norm'])
+    d['dominance_score'] = max(d['p_win_norm'], d['p_lose_norm']) - d['p_draw_norm']
+    return pd.DataFrame([d])[expected_cols]
+
+expected_cols_handicap = [
+    'log_win', 'log_draw', 'log_lose',
+    'log_hwin', 'log_hdraw', 'log_hlose',
+    'pn_win', 'pn_draw', 'pn_lose',
+    'pn_hwin', 'pn_hdraw', 'pn_hlose',
+    'spread_base', 'spread_hand',
+    'mean_odds_h', 'std_odds_h', 'cv_odds_h', 'entropy_h',
+    'ratio_draw_win_h', 'ratio_draw_lose_h',
+    'log_ratio_base_hand', 'gap_hdraw_base_draw',
+    'overround_base', 'overround_hand',
+    'ev_hwin', 'ev_hdraw', 'ev_hlose',
+    'rank_win', 'rank_draw', 'rank_lose'
+]  
+
+def generate_similarity_features_for_input(win, draw, lose, hwin, hdraw, hlose):
+    p_base = to_probs_from_odds(win, draw, lose)              # [pW, pD, pL]
+    p_hand = to_probs_from_handicap(hwin, hdraw, hlose)       # [pHW, pHD, pHL]
+
+    # 기존 피처 계산
+    spread = max(win, draw, lose) - min(win, draw, lose)
+    draw_prob_ratio = (1.0/draw) / max(1.0/win, 1.0/lose)
+    entropy_base = entropy_of_probs(p_base)
+    entropy_h = entropy_of_probs(p_hand)
+    entropy_delta = entropy_h - entropy_base
+    overround = (1.0/win + 1.0/draw + 1.0/lose)
+    overround_h = (1.0/hwin + 1.0/hdraw + 1.0/hlose)
+    overround_diff = overround_h - overround
+    prob_entropy_ratio = entropy_h / max(entropy_base, 1e-12)
+
+    fav_gap = abs(win - lose)
+    mean_odds = (win + draw + lose) / 3.0
+    cv_spread = spread / mean_odds
+    cv_draw_gap = abs(draw - min(win, lose)) / mean_odds
+    draw_prob_gap = abs(p_base[1] - (p_base[0] + p_base[2]) / 2.0)
+    delta_base_handicap_prob = abs(p_base[0] - p_hand[0]) + abs(p_base[1] - p_hand[1]) + abs(p_base[2] - p_hand[2])
+
+    p_one_goal = p_hand[1]
+    p_large_margin = p_hand[0]
+    p_upset = min(p_base[0], p_base[2])
+    fav_dog_win_ratio = max(p_base[0], p_base[2]) / max(p_upset, 1e-12)
+    herfindahl_base = herfindahl(p_base)
+    draw_dev = p_base[1] - (p_base[0] + p_base[2]) / 2.0
+
+    # 추가: dominance_score
+    sorted_probs = sorted(p_base)
+    dominance_score = sorted_probs[-1] - sorted_probs[-2]
+
+    shin_bias = 0.0
+    p_draw_shin_delta = 0.0
+    if USE_SHIN:
+        p_shin, shin_bias = shin_adjusted_probs((win, draw, lose))
+        p_draw_shin_delta = p_shin[1] - p_base[1]
+
+    feats = {
+        "spread": spread,
+        "draw_prob_ratio": draw_prob_ratio,
+        "entropy": entropy_base,
+        "overround": overround,
+        "fav_gap": fav_gap,
+        "cv_spread": cv_spread,
+        "cv_draw_gap": cv_draw_gap,
+        "draw_prob_gap": draw_prob_gap,
+        "p_one_goal": p_one_goal,
+        "p_large_margin": p_large_margin,
+        "p_upset": p_upset,
+        "fav_dog_win_ratio": fav_dog_win_ratio,
+        "entropy_h": entropy_h,
+        "entropy_delta": entropy_delta,
+        "herfindahl_base": herfindahl_base,
+        "draw_dev": draw_dev,
+        "dominance_score": dominance_score,
+        "delta_base_handicap_prob": delta_base_handicap_prob,
+        "overround_diff": overround_diff,
+        "prob_entropy_ratio": prob_entropy_ratio
+    }
+    if USE_SHIN:
+        feats["shin_bias"] = shin_bias
+        feats["p_draw_shin_delta"] = p_draw_shin_delta
+
+    return feats
+
+
+# ===== Similarity Features Config =====
+USE_SHIN = False  # 처음엔 False로 시작. 느려도 괜찮으면 True로 바꿔 사용.
+
+# 유사 경기 거리 전용 피처 셋 (기존 8개 + 신규들)
+KEY_FEATS = [
+    # 기존 8개
+    "spread", "draw_prob_ratio", "entropy", "overround",
+    "fav_gap", "cv_spread", "cv_draw_gap", "draw_prob_gap",
+    "delta_base_handicap_prob", "overround_diff", "dominance_score", "prob_entropy_ratio",
+
+    # 신규 (10개 제안 중 앱에서 바로 계산 가능한 것들)
+    "p_one_goal",            # 핸디 무 확률 (한 골차 승부)
+    "p_large_margin",        # 핸디 승 확률 (여유 승)
+    "p_upset",               # 언더독 승 확률
+    "fav_dog_win_ratio",     # 강팀 승확률 / 약팀 승확률
+    "entropy_h",             # 핸디 엔트로피
+    "entropy_delta",         # (핸디 - 기본) 엔트로피 차이
+    "herfindahl_base",       # 1X2 확률 집중도(제곱합)
+    "draw_dev",              # 무확률의 편차 (vs 비무 평균)
+    # Shin 관련 (옵션)
+    *([ "shin_bias", "p_draw_shin_delta" ] if USE_SHIN else [])
+]
+
+def generate_handicap_features_from_input(win, draw, lose,
+                                          hwin, hdraw, hlose):
+    import numpy as np, pandas as pd
+
+    # --- 로그 배당 ---
+    log_win, log_draw, log_lose   = np.log([win, draw, lose])
+    log_hwin, log_hdraw, log_hlose = np.log([hwin, hdraw, hlose])
+
+    # --- 역배당 확률 & 정규화 ---
+    p_base = 1 / np.array([win, draw, lose])
+    pn_win, pn_draw, pn_lose = p_base / p_base.sum()
+
+    p_hand = 1 / np.array([hwin, hdraw, hlose])
+    pn_hwin, pn_hdraw, pn_hlose = p_hand / p_hand.sum()
+
+    # --- 스프레드·통계 ---
+    spread_base  = win - lose
+    spread_hand  = hwin - hlose
+    mean_h       = np.mean([hwin, hdraw, hlose])
+    std_h        = np.std([hwin, hdraw, hlose])
+    cv_h         = std_h / mean_h
+    entropy_h    = -np.sum([pn_hwin, pn_hdraw, pn_hlose] *
+                           np.log([pn_hwin, pn_hdraw, pn_hlose]))
+
+    # --- 비율·차이 ---
+    ratio_draw_win_h   = hdraw / hwin
+    ratio_draw_lose_h  = hdraw / hlose
+    log_ratio_base_hand = np.log((hdraw + 1e-6) / (draw + 1e-6))
+    gap_hdraw_base_draw = hdraw - draw
+    overround_base  = (1/win + 1/draw + 1/lose) - 1
+    overround_hand  = (1/hwin + 1/hdraw + 1/hlose) - 1
+
+    # --- EV ---
+    ev_hwin  = hwin  * pn_hwin
+    ev_hdraw = hdraw * pn_hdraw
+    ev_hlose = hlose * pn_hlose
+
+    # --- 순위 ---
+    rank_win, rank_draw, rank_lose = pd.Series([win, draw, lose]).rank().tolist()
+
+    feat = {
+        # 6 로그
+        'log_win':log_win, 'log_draw':log_draw, 'log_lose':log_lose,
+        'log_hwin':log_hwin,'log_hdraw':log_hdraw,'log_hlose':log_hlose,
+        # 6 확률
+        'pn_win':pn_win,'pn_draw':pn_draw,'pn_lose':pn_lose,
+        'pn_hwin':pn_hwin,'pn_hdraw':pn_hdraw,'pn_hlose':pn_hlose,
+        # 6 스프레드·통계
+        'spread_base':spread_base,'spread_hand':spread_hand,
+        'mean_odds_h':mean_h,'std_odds_h':std_h,'cv_odds_h':cv_h,'entropy_h':entropy_h,
+        # 6 비율·차이
+        'ratio_draw_win_h':ratio_draw_win_h,'ratio_draw_lose_h':ratio_draw_lose_h,
+        'log_ratio_base_hand':log_ratio_base_hand,'gap_hdraw_base_draw':gap_hdraw_base_draw,
+        'overround_base':overround_base,'overround_hand':overround_hand,
+        # 6 EV·순위
+        'ev_hwin':ev_hwin,'ev_hdraw':ev_hdraw,'ev_hlose':ev_hlose,
+        'rank_win':rank_win,'rank_draw':rank_draw,'rank_lose':rank_lose
+    }
+
+    return pd.DataFrame([feat])[expected_cols_handicap]   
+
+def dec_group(x: float) -> int:
+    """
+    2 → 소수 둘째 자리까지 있음
+    1 → 소수 첫째 자리만 있거나 정수
+    """
+    s = str(x)
+    if "." not in s:
+        return 1
+    return 2 if len(s.split(".")[1]) == 2 else 1
+
+def first_decimal_floor(x: float) -> float:
+    x = float(x)
+    return np.floor(x * 10) / 10.0
+
+def decimal_class_by_value(x: float) -> int:
+    x = float(x)
+    if abs(x*10 - round(x*10)) < 1e-8:
+        return 1  # 소수 1자리(또는 정수)
+    elif abs(x*100 - round(x*100)) < 1e-6:
+        return 2  # 소수 2자리
+    else:
+        return 2  # 안전하게 2로 취급(표현상 3자리라도 배당은 보통 2자리)
+
+def to_probs_from_odds(win, draw, lose):
+    p = np.array([1.0/win, 1.0/draw, 1.0/lose], dtype=float)
+    return p / p.sum()
+
+def to_probs_from_handicap(hwin, hdraw, hlose):
+    p = np.array([1.0/hwin, 1.0/hdraw, 1.0/hlose], dtype=float)
+    return p / p.sum()
+
+def entropy_of_probs(p):
+    p = np.clip(p, 1e-12, 1.0)
+    return -np.sum(p * np.log(p))
+
+def herfindahl(p):
+    return np.sum(np.square(p))
+
+def shin_adjusted_probs(odds, max_iter=40, tol=1e-9):
+    # 간단화한 Shin 추정. USE_SHIN=True일 때만 호출 권장.
+    w, d, l = odds
+    q = np.array([1.0/w, 1.0/d, 1.0/l], dtype=float)
+    lo, hi = 0.0, 0.66
+    for _ in range(max_iter):
+        z = (lo + hi) / 2.0
+        denom = (1 - z)
+        p = (np.sqrt(z*z + 4*denom*q) - z) / (2*denom)
+        s = p.sum()
+        if abs(s - 1.0) < tol:
+            break
+        if s > 1.0:
+            lo = z
+        else:
+            hi = z
+    shin_bias = z
+    p = p / p.sum()
+    return p, shin_bias
+
+def ensure_similarity_features_df(df):
+    # base probs
+    pW = 1.0 / df["승"].to_numpy()
+    pD = 1.0 / df["무"].to_numpy()
+    pL = 1.0 / df["패"].to_numpy()
+    pt = pW + pD + pL
+    pWn, pDn, pLn = pW/pt, pD/pt, pL/pt
+
+    # hand probs
+    pHW = 1.0 / df["핸디 승"].to_numpy()
+    pHD = 1.0 / df["핸디 무"].to_numpy()
+    pHL = 1.0 / df["핸디 패"].to_numpy()
+    pht = pHW + pHD + pHL
+    pHWn, pHDn, pHLn = pHW/pht, pHD/pht, pHL/pht
+
+    mean_odds = (df["승"] + df["무"] + df["패"]) / 3.0
+    trio = np.stack([df["승"], df["무"], df["패"]], axis=1)
+    spread = trio.max(axis=1) - trio.min(axis=1)
+
+    # 기존 8개
+    df["spread"] = spread
+    df["draw_prob_ratio"] = (pD / np.maximum(pW, pL))
+
+    # 🔒 엔트로피(기본)
+    P_base = np.stack([pWn, pDn, pLn], axis=1)
+    df["entropy"] = entropy_of_probs(P_base)
+
+    df["overround"] = pt
+    df["fav_gap"] = np.abs(df["승"] - df["패"])
+    df["cv_spread"] = spread / mean_odds
+    df["cv_draw_gap"] = np.abs(df["무"] - np.minimum(df["승"], df["패"])) / mean_odds
+    df["draw_prob_gap"] = np.abs(pDn - (pWn + pLn)/2.0)
+
+    # 신규 유사도용 피처
+    df["p_one_goal"] = pHDn
+    df["p_large_margin"] = pHWn
+    df["p_upset"] = np.minimum(pWn, pLn)
+    df["fav_dog_win_ratio"] = np.maximum(pWn, pLn) / np.maximum(df["p_upset"], 1e-12)
+
+    # 🔒 엔트로피(핸디)
+    P_hand = np.stack([pHWn, pHDn, pHLn], axis=1)
+    df["entropy_h"] = entropy_of_probs(P_hand)
+
+    df["entropy_delta"] = df["entropy_h"] - df["entropy"]
+    df["herfindahl_base"] = pWn*pWn + pDn*pDn + pLn*pLn
+    df["draw_dev"] = pDn - (pWn + pLn)/2.0
+
+    # ▶ NEW: 확률 기반 피처 4종
+    df["delta_base_handicap_prob"] = (
+        np.abs(pWn - pHWn) + np.abs(pDn - pHDn) + np.abs(pLn - pHLn)
+    )
+    df["overround_diff"] = (pW + pD + pL) - (pHW + pHD + pHL)
+
+    # ✅ dominance_score 고정
+    sorted_probs = np.sort(np.stack([pWn, pDn, pLn], axis=1), axis=1)
+    df["dominance_score"] = sorted_probs[:, -1] - sorted_probs[:, -2]
+
+    df["prob_entropy_ratio"] = df["entropy_h"] / np.maximum(df["entropy"], 1e-6)
+
+    # ✅ Shin 피처 추가 (선택)
+    if USE_SHIN:
+        shin_biases = []
+        p_draw_shin_deltas = []
+        for w, d, l in zip(df["승"], df["무"], df["패"]):
+            p_shin, shin_bias = shin_adjusted_probs((w, d, l))
+            p_base = to_probs_from_odds(w, d, l)
+            shin_biases.append(shin_bias)
+            p_draw_shin_deltas.append(p_shin[1] - p_base[1])
+        df["shin_bias"] = shin_biases
+        df["p_draw_shin_delta"] = p_draw_shin_deltas
+
+    return df
+    
+def entropy_of_probs(p):
+    """
+    p: shape (3,) or (n,3) 확률 벡터(정규화된 값)
+    log(0) 방지를 위해 아주 작은 값으로 클리핑 후 엔트로피 계산
+    """
+    p = np.clip(p, 1e-12, 1.0)
+    # 벡터/행렬 모두 처리
+    if p.ndim == 1:
+        return -np.sum(p * np.log(p))
+    else:
+        return -np.sum(p * np.log(p), axis=1)
+    
+    
+from catboost import CatBoostClassifier
+
+@st.cache_resource
+def load_softmax_model():
+    return joblib.load("xgb_model_wdl_softmax.pkl")
+
+softmax_model = load_softmax_model()
+
+# 2) 핸디캡 3‑클래스 새 모델 + 인코더
+import xgboost as xgb
+import joblib
+
+@st.cache_resource
+def load_handicap_model():
+    # Colab에서 joblib.dump(model_hand, ...) 로 저장한 pkl
+    return joblib.load("xgb_model_handicap_30f_fast.pkl")
+
+@st.cache_resource
+def load_handicap_encoder():
+    """라벨 인코더(pkl) 로드 ─ classes_: ['핸디 승','핸디 무','핸디 패']"""
+    return joblib.load("label_encoder_handicap.pkl")
+
+handicap_model   = load_handicap_model()
+handicap_encoder = load_handicap_encoder()
+
+
+@st.cache_data
+def load_match_data():
+    return pd.read_parquet("proto_core_with_proba_0904_0717.parquet")
+
+@st.cache_resource
+def load_keyfeat_scaler(df_for_fit=None):
+    from sklearn.preprocessing import StandardScaler
+    try:
+        sc = joblib.load("keyfeat_scaler.pkl")
+        # KEY_FEATS 개수가 바뀌면 자동 재적합
+        if hasattr(sc, "n_features_in_") and sc.n_features_in_ != len(KEY_FEATS):
+            raise ValueError("KEY_FEATS dimension changed")
+        return sc
+    except Exception:
+        sc = StandardScaler()
+        if df_for_fit is None:
+            df_for_fit = load_match_data()
+            # 유사도용 피처 생성 보장
+            df_for_fit = ensure_similarity_features_df(df_for_fit)
+        sc.fit(df_for_fit[KEY_FEATS].values)
+        # (선택) 다음 실행 속도 향상을 위해 저장
+        try:
+            joblib.dump(sc, "keyfeat_scaler.pkl")
+        except Exception:
+            pass
+        return sc
+
+@st.cache_data
+def get_scaled_matrix(df):
+    # 유사도용 피처 생성 보장
+    df = ensure_similarity_features_df(df)
+    sc = load_keyfeat_scaler(df_for_fit=df)
+    return sc, sc.transform(df[KEY_FEATS].values)
+# ================================================    
+
+def extract_booster(model):
+    """
+    XGBClassifier  혹은  CalibratedClassifierCV  어디서든
+    fit 완료된 booster 를 안전하게 꺼낸다.
+    순서: ① 이미 get_booster() 있으면 → ② calibrated_classifiers_ →
+          ③ estimator (prefit일 때) → 오류.
+    """
+    # ① 순수 XGBClassifier
+    if hasattr(model, "get_booster"):
+        return model.get_booster()
+
+    # ② CalibratedClassifierCV(cv>1) ─ fit 된 clone 보유
+    if hasattr(model, "calibrated_classifiers_") and model.calibrated_classifiers_:
+        est = model.calibrated_classifiers_[0].estimator
+        if hasattr(est, "get_booster"):
+            return est.get_booster()
+
+    # ③ CalibratedClassifierCV(cv='prefit')
+    if hasattr(model, "estimator") and hasattr(model.estimator, "get_booster"):
+        return model.estimator.get_booster()
+
+    raise AttributeError("Booster를 찾을 수 없습니다 (extract_booster)")   
+
+# === 예측 함수 ===
+def predict_all(inputs):
+    win, draw, lose = inputs["승"], inputs["무"], inputs["패"]
+    hwin, hdraw, hlose = inputs["핸디 승"], inputs["핸디 무"], inputs["핸디 패"]
+    
+    # 1. 기본 승무패
+    df_input_base = generate_features_from_input(win, draw, lose)
+    df_input_base = df_input_base[expected_cols]
+    probs_base = softmax_model.predict_proba(df_input_base)[0]
+    labels_base = ["승", "무", "패"]
+    pred_idx_base = np.argmax(probs_base)
+    fav_dir_base = labels_base[pred_idx_base]
+    fav_odds_base = [win, draw, lose][pred_idx_base]
+    prob_hit_base = probs_base[pred_idx_base]
+    ev_base = fav_odds_base * prob_hit_base
+
+    # 2. 핸디캡 softmax
+    # ------------------------------------------------------------------
+    # ① 30개 피처 생성 → 컬럼 순서 고정
+    # 1) 30 개 피처 DataFrame 1행 생성  ← 이 줄이 다시 필요
+    features_h = generate_handicap_features_from_input(win, draw, lose, hwin, hdraw, hlose)
+
+    # 2) 컬럼 순서 고정
+    df_input_handicap = features_h[expected_cols_handicap]
+
+    # ⬅︎ 새 줄
+    probs_handicap = handicap_model.predict_proba(df_input_handicap)[0]
+
+    # ③ 라벨은 인코더 순서 사용
+    labels_handicap = handicap_encoder.classes_                             # ★
+    # ------------------------------------------------------------------
+
+    # 라벨‑배당 딕셔너리
+    odds_dict = {"핸디 승": hwin, "핸디 무": hdraw, "핸디 패": hlose}
+
+    # 확률 딕셔너리
+    prob_dict = dict(zip(labels_handicap, probs_handicap))
+    
+    # 최고 확률 라벨과 EV
+    fav_dir_handicap  = max(prob_dict, key=prob_dict.get)
+    prob_hit_handicap = prob_dict[fav_dir_handicap]
+    fav_odds_handicap = odds_dict[fav_dir_handicap]
+    ev_handicap       = fav_odds_handicap * prob_hit_handicap
+
+    return {
+        "정배 Softmax": {
+            "예측": fav_dir_base,
+            "확률": round(prob_hit_base, 4),
+            "배당": fav_odds_base,
+            "EV": round(ev_base, 4)
+        },
+        "핸디 Softmax": {
+            "예측": fav_dir_handicap,
+            "확률": round(prob_hit_handicap, 4),
+            "배당": fav_odds_handicap,
+            "EV": round(ev_handicap, 4)
+        },
+        "wdl_probs": probs_base.tolist(),
+        "handicap_probs": probs_handicap.tolist()
+    }
+
+
+# === UI ===
+st.title("🎯 통합 예측기 + 유사 경기")
+user_input = st.text_input("배당 입력 (승 무 패 핸디승 핸디무 핸디패):", "1.85/3.2/4.1/2.9/3.2/1.55")
+
+if user_input:
+    try:
+        odds = list(map(float, user_input.replace("/", " ").split()))
+        if len(odds) != 6:
+            st.error("❌ 정확히 6개의 숫자를 입력해주세요.")
+        else:
+            inputs = {"승": odds[0], "무": odds[1], "패": odds[2], "핸디 승": odds[3], "핸디 무": odds[4], "핸디 패": odds[5]}
+            result = predict_all(inputs)
+
+            입력_무_class   = decimal_class_by_value(odds[1])
+            입력_핸무_class = decimal_class_by_value(odds[4])
+
+
+            # 🔹 예측 결과 출력
+            st.subheader("✅ 예측 결과")
+            st.markdown("**🔹 기본 승/무/패 Softmax 확률**")
+            labels_base = ["승", "무", "패"]
+            for label, prob in zip(labels_base, result.get("wdl_probs", [0, 0, 0])):
+                st.write(f" - {label}: {prob * 100:.2f}%")
+
+            pred = result["정배 Softmax"]
+            st.markdown("**🔹 정배 방향 예측 결과**")
+            st.write(f" - 예측: **{pred['예측']}**")
+            st.write(f" - 확률: **{pred['확률'] * 100:.2f}%**")
+            st.write(f" - EV: **{pred['EV']:.3f}**")
+
+            st.markdown("**🔹 핸디캡 승/무/패 Softmax 확률**")
+
+            # ⬇️ 1) 하드코드 → 인코더 순서로 변경
+            labels_handicap = handicap_encoder.classes_          # 모델·인코더 순서
+            probs_handicap  = result["handicap_probs"]           # 동일 길이 확률 배열
+
+            # 👇 ① 라벨‑확률 매핑 딕셔너리로 만든 뒤
+            prob_map = dict(zip(labels_handicap, probs_handicap))
+    
+            for lbl in ["핸디 승", "핸디 무", "핸디 패"]:
+                st.write(f" - {lbl}: {prob_map[lbl] * 100:.2f}%")
+
+            pred_h = result["핸디 Softmax"]
+            st.markdown("**🔹 핸디 정배 방향 예측 결과**")
+            st.write(f" - 예측: **{pred_h['예측']}**")
+            st.write(f" - 확률: **{pred_h['확률'] * 100:.2f}%**")
+            st.write(f" - EV: **{pred_h['EV']:.3f}**")
+        
+            # ================= 유사 경기 (특징 거리 기반 k-NN) =================
+            df_all = load_match_data().copy()
+            df_all = ensure_similarity_features_df(df_all)
+
+            # (안전) 숫자형 강제 변환
+            for c in ["승","무","패","핸디 승","핸디 무","핸디 패"]:
+                df_all[c] = pd.to_numeric(df_all[c], errors="coerce")
+
+            # 입력 요약
+            base_odds = np.array([inputs["승"], inputs["무"], inputs["패"]], dtype=float)
+            hand_odds = np.array([inputs["핸디 승"], inputs["핸디 무"], inputs["핸디 패"]], dtype=float)
+            base_dir_in = ["승","무","패"][np.argmin(base_odds)]
+            hand_dir_in = ["핸디 승","핸디 무","핸디 패"][np.argmin(hand_odds)]
+            정배당, 핸디정배당 = base_odds.min(), hand_odds.min()
+            # (NEW) app26 규칙과 같은 무/핸무 순위 라벨
+            draw_rank_in  = 1 if base_odds[1] == base_odds.max() else 2
+            hdraw_rank_in = 1 if hand_odds[1] == hand_odds.max() else 2
+
+            # ===== (NEW) 무/핸무 순위 라벨 =====
+            # base_odds = np.array([inputs["승"], inputs["무"], inputs["패"]], dtype=float)
+            # hand_odds = np.array([inputs["핸디 승"], inputs["핸디 무"], inputs["핸디 패"]], dtype=float)
+            draw_rank_in   = _rank12_app26(base_odds[1], base_odds)      # 무의 rank(1 or 2)
+            hdraw_rank_in  = _rank12_app26(hand_odds[1], hand_odds)      # 핸무의 rank(1 or 2)
+
+            # ===== (NEW) 6개 배당 정수부 =====
+            base_ints = {
+                "승": int(inputs["승"]),
+                "무": int(inputs["무"]),
+                "패": int(inputs["패"]),
+                "핸디 승": int(inputs["핸디 승"]),
+                "핸디 무": int(inputs["핸디 무"]),
+                "핸디 패": int(inputs["핸디 패"]),
+            }
+
+            # 1) 특징 스케일/쿼리
+            scaler, M_scaled = get_scaled_matrix(df_all)
+            qf = generate_similarity_features_for_input(inputs["승"], inputs["무"], inputs["패"],
+                                                        inputs["핸디 승"], inputs["핸디 무"], inputs["핸디 패"])
+            q_vec = np.array([qf[k] for k in KEY_FEATS], dtype=float).reshape(1, -1)
+            q_scaled = scaler.transform(q_vec)[0]
+
+            # 2) 거리(유클리드) + k 후보 + 거리 상한
+            df_all["feat_dist"] = euclidean_distances(M_scaled, q_scaled[None]).ravel()
+            N = len(df_all)
+            k = min(100, N)
+            if k < N:
+                top_idx = np.argpartition(df_all["feat_dist"].values, k)[:k]
+                mask_knn = pd.Series(False, index=df_all.index); mask_knn.iloc[top_idx] = True
+            else:
+                mask_knn = pd.Series(True, index=df_all.index)
+            # 상위 1.5% 거리만 허용(이상치 컷)
+            dist_cut = df_all["feat_dist"].quantile(0.015) if N > 1000 else df_all["feat_dist"].quantile(0.05)
+            mask_knn = mask_knn & (df_all["feat_dist"] <= dist_cut)
+
+            # 3) 1자리 버킷(반올림) 일치
+            row_base_min = df_all[["승","무","패"]].min(axis=1)
+            row_hand_min = df_all[["핸디 승","핸디 무","핸디 패"]].min(axis=1)
+
+            # 버킷 경계(내림) 계산
+            b_lo = first_decimal_floor(정배당);     b_hi = b_lo + 0.1
+            h_lo = first_decimal_floor(핸디정배당); h_hi = h_lo + 0.1
+
+            # “같은 1.x대”를 확실히: [버킷 하한, 하한+0.1) 구간 매칭
+            mask_1d = (row_base_min >= b_lo) & (row_base_min < b_hi) & \
+                      (row_hand_min >= h_lo) & (row_hand_min < h_hi)
+
+            # 4) 무/핸무 자릿수 정확 일치
+            mu_dp_in  = decimal_places(inputs["무"])
+            hmu_dp_in = decimal_places(inputs["핸디 무"])
+            mask_decimals_strict = (df_all["무"].apply(decimal_places) == mu_dp_in) & \
+                                   (df_all["핸디 무"].apply(decimal_places) == hmu_dp_in)
+
+
+            # 6) 방향 일치(+동률 제거)
+            df_base_dir = df_all[["승","무","패"]].idxmin(axis=1).str.replace(" ", "", regex=False)
+            df_hand_dir = df_all[["핸디 승","핸디 무","핸디 패"]].idxmin(axis=1).str.replace(" ", "", regex=False)
+            mask_dir = (df_base_dir == base_dir_in.replace(" ","")) & (df_hand_dir == hand_dir_in.replace(" ",""))
+            # 최솟값-2위값 차이가 너무 작은 동률/근접 케이스 제외
+            base_sorted = np.sort(df_all[["승","무","패"]].values, axis=1)
+            hand_sorted = np.sort(df_all[["핸디 승","핸디 무","핸디 패"]].values, axis=1)
+            GAP_TOL = 0.01
+            # (옵션) app(26)과 결과 맞추려면 동률 제외를 끕니다.
+            # mask_dir = mask_dir & ((base_sorted[:,1]-base_sorted[:,0] >= GAP_TOL) &
+            #                        (hand_sorted[:,1]-hand_sorted[:,0] >= GAP_TOL))
+
+            # ===== (NEW) 무/핸무 순위 마스크 =====
+
+            def _row_rank_mask(row):
+                try:
+                    r_base = _rank12_app26(row["무"],      [row["승"], row["무"], row["패"]])
+                    r_hand = _rank12_app26(row["핸디 무"], [row["핸디 승"], row["핸디 무"], row["핸디 패"]])
+                    return (r_base == draw_rank_in) and (r_hand == hdraw_rank_in)
+                except Exception:
+                    return False
+
+            mask_rank = df_all.apply(_row_rank_mask, axis=1)
+
+            # ===== (NEW) 6개 배당 정수부 일치 마스크 =====
+            mask_intparts = (
+                (df_all["승"].fillna(0).astype(float).astype(int)      == base_ints["승"]) &
+                (df_all["무"].fillna(0).astype(float).astype(int)      == base_ints["무"]) &
+                (df_all["패"].fillna(0).astype(float).astype(int)      == base_ints["패"]) &
+                (df_all["핸디 승"].fillna(0).astype(float).astype(int) == base_ints["핸디 승"]) &
+                (df_all["핸디 무"].fillna(0).astype(float).astype(int) == base_ints["핸디 무"]) &
+                (df_all["핸디 패"].fillna(0).astype(float).astype(int) == base_ints["핸디 패"])
+            )  # ← 여기 닫는 괄호 추가!
+
+            # 8) 최종 마스크
+            final_mask = (
+                # mask_knn &
+                mask_1d &
+                mask_decimals_strict &
+                mask_dir &
+                mask_rank &       # (NEW)
+                mask_intparts     # (NEW)
+            )
+
+            df_sim = (df_all.loc[final_mask]
+                            .copy()
+                            .sort_values("feat_dist")
+                            .reset_index(drop=True))
+
+
+            # 9) 사후 검증(안전망): 조건 위반행이 남아있으면 마지막으로 드롭
+            def _dir_ok(row):
+                return (row[["승","무","패"]].idxmin().replace(" ","") == base_dir_in.replace(" ","")) and \
+                       (row[["핸디 승","핸디 무","핸디 패"]].idxmin().replace(" ","") == hand_dir_in.replace(" ",""))
+
+            if not df_sim.empty:
+                q_row = {
+                    "mu_dp":  decimal_places(inputs["무"]),
+                    "hmu_dp": decimal_places(inputs["핸디 무"]),
+                }
+                s_base_min = df_sim[["승","무","패"]].min(axis=1)
+                s_hand_min = df_sim[["핸디 승","핸디 무","핸디 패"]].min(axis=1)
+
+                b_lo = first_decimal_floor(정배당);     b_hi = b_lo + 0.1
+                h_lo = first_decimal_floor(핸디정배당); h_hi = h_lo + 0.1
+
+                ok_post  = (s_base_min >= b_lo) & (s_base_min <  b_hi)
+                ok_post &= (s_hand_min >= h_lo) & (s_hand_min <  h_hi)
+                ok_post &= (df_sim["무"].apply(decimal_places) == q_row["mu_dp"])
+                ok_post &= (df_sim["핸디 무"].apply(decimal_places) == q_row["hmu_dp"])
+                ok_post &= df_sim.apply(_dir_ok, axis=1)
+                df_sim = df_sim.loc[ok_post].reset_index(drop=True)
+
+
+
+    
+
+            if "일자" in df_sim.columns:
+                df_sim["일자"] = pd.to_datetime(df_sim["일자"], errors="coerce").dt.strftime("%Y-%m-%d")
+
+            st.subheader(f"✅ 유사 경기 목록 ({len(df_sim)})")
+            cols = ["일자","리그","홈팀","원정팀","승","무","패",
+                    "핸디 승","핸디 무","핸디 패",
+                    "feat_dist","softmax_dist",
+                    "결과","핸디결과"]
+            cols = [c for c in cols if c in df_sim.columns]
+            st.dataframe(df_sim[cols])
+
+            st.subheader("📊 결과 분포")
+            if "결과" in df_sim.columns:
+                st.write(df_sim["결과"].value_counts())
+            if "핸디결과" in df_sim.columns:
+                st.write(df_sim["핸디결과"].value_counts())
+                
+    except Exception as e:
+        st.error("❌ 예측 또는 유사 경기 분석 중 오류 발생")
+        st.exception(e)

keyfeat_scaler.pkl

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

label_encoder_handicap.pkl

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

meta.json

@@ -0,0 +1,103 @@
+{
+  "train_time": "0904_0717",
+  "model_base_path": "/content/models_full_0904_0717/xgb_model_wdl_softmax.pkl",
+  "model_hand_path": "/content/models_full_0904_0717/xgb_model_handicap_30f_fast.pkl",
+  "encoder_hand_path": "/content/models_full_0904_0717/label_encoder_handicap.pkl",
+  "scaler_keyfeat_path": "/content/models_full_0904_0717/keyfeat_scaler.pkl",
+  "features_base": [
+    "norm_win",
+    "norm_draw",
+    "norm_lose",
+    "mean_odds",
+    "std_odds",
+    "cv_odds",
+    "p_win",
+    "p_draw",
+    "p_lose",
+    "overround",
+    "entropy",
+    "spread",
+    "spread_draw",
+    "odds_ratio_wd",
+    "odds_ratio_wl",
+    "odds_ratio_dl",
+    "draw_prob_ratio",
+    "draw_ratio",
+    "draw_prob_gap",
+    "fav_gap",
+    "fav_draw_gap",
+    "fav_diff",
+    "draw_gap_mean",
+    "rank_win",
+    "rank_draw",
+    "rank_lose",
+    "p_win_norm",
+    "p_draw_norm",
+    "p_lose_norm",
+    "ev_win",
+    "ev_draw",
+    "ev_lose",
+    "draw_vs_avg",
+    "draw_vs_max",
+    "cv_spread",
+    "cv_draw_gap",
+    "draw_margin",
+    "fav_ratio",
+    "draw_skew",
+    "log_spread",
+    "draw_entropy_component",
+    "dominance_score"
+  ],
+  "features_hand": [
+    "log_win",
+    "log_draw",
+    "log_lose",
+    "log_hwin",
+    "log_hdraw",
+    "log_hlose",
+    "pn_win",
+    "pn_draw",
+    "pn_lose",
+    "pn_hwin",
+    "pn_hdraw",
+    "pn_hlose",
+    "spread_base",
+    "spread_hand",
+    "mean_odds_h",
+    "std_odds_h",
+    "cv_odds_h",
+    "entropy_h",
+    "ratio_draw_win_h",
+    "ratio_draw_lose_h",
+    "log_ratio_base_hand",
+    "gap_hdraw_base_draw",
+    "overround_base",
+    "overround_hand",
+    "ev_hwin",
+    "ev_hdraw",
+    "ev_hlose",
+    "rank_win",
+    "rank_draw",
+    "rank_lose"
+  ],
+  "key_feats": [
+    "spread",
+    "draw_prob_ratio",
+    "entropy",
+    "overround",
+    "fav_gap",
+    "cv_spread",
+    "cv_draw_gap",
+    "draw_prob_gap"
+  ],
+  "label_map_base": {
+    "승": 0,
+    "무": 1,
+    "패": 2
+  },
+  "label_order_hand": [
+    "핸디 승",
+    "핸디 무",
+    "핸디 패"
+  ]
+}

proto_core_with_proba_0904_0717.parquet

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

proto_core_with_proba_0904_0717.xlsx

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

requirements.txt

@@ -1,3 +1,7 @@
-altair
+catboost
+scikit-learn==1.3.2  # 훈련 당시 버전과 일치시키는 것이 가장 안전
+xgboost
+numpy
 pandas
+openpyxl
 streamlit

xgb_model_handicap_30f_fast.pkl

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

xgb_model_wdl_softmax.pkl

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