import pandas as pd import numpy as np import matplotlib.pyplot as plt from scipy.stats import poisson, nbinom, gamma, lognorm, kstest import gradio as gr # ========================= # Stat mapping & milestones # ========================= STAT_MAP = { "pass_att": "att", "pass_yds": "pass_yds", "pass_td": "pass_td", "rush_att": "rush_att", "rush_yds": "rush_yds", "rush_td": "rush_td", "targets": "targets", "receptions": "receptions", "rec_yds": "rec_yds", "rec_td": "rec_td", "fg_made": "fg_made", } STAT_LABELS = { "pass_att": "Pass Attempts", "pass_yds": "Passing Yards", "pass_td": "Passing TDs", "rush_att": "Rush Attempts", "rush_yds": "Rushing Yards", "rush_td": "Rushing TDs", "targets": "Targets", "receptions": "Receptions", "rec_yds": "Receiving Yards", "rec_td": "Receiving TDs", "fg_made": "Field Goals Made", } STAT_OPTIONS = [ "pass_att", "pass_yds", "pass_td", "rush_att", "rush_yds", "rush_td", "targets", "receptions", "rec_yds", "rec_td", "fg_made", ] TIMEFRAMES = {"Game": "", "1H": "_1h", "1Q": "_1q"} # Timeframe-specific milestones NFL_MILESTONES = { "Game": { "pass_att": [15, 20, 25, 30, 35, 40, 45, 50], "pass_yds": [150, 200, 225, 250, 275, 300, 325, 350, 400], "pass_td": [1, 2, 3, 4, 5], "rush_att": [8, 10, 12, 14, 16, 18, 20, 22], "rush_yds": [25, 40, 50, 60, 75, 80, 90, 100, 110, 125, 150], "rush_td": [1, 2, 3], "targets": [4, 6, 8, 10, 12], "receptions":[3, 4, 5, 6, 7, 8, 9, 10], "rec_yds": [25, 40, 50, 60, 75, 80, 90, 100, 110, 125, 150], "rec_td": [1, 2, 3], "fg_made": [1, 2, 3, 4, 5], }, "1H": { "pass_att": [8, 10, 12, 15, 18, 20, 22, 25], "pass_yds": [100, 125, 150, 175, 200, 225, 250, 275, 300], "pass_td": [1, 2, 3], "rush_att": [5, 7, 9, 11, 13, 15], "rush_yds": [20, 30, 40, 50, 60, 70, 80, 90, 100], "rush_td": [1, 2], "targets": [3, 4, 5, 6, 7, 8], "receptions":[2, 3, 4, 5, 6, 7, 8], "rec_yds": [20, 30, 40, 50, 60, 70, 80, 90, 100], "rec_td": [1, 2], "fg_made": [1, 2, 3], }, "1Q": { "pass_att": [4, 6, 8, 10, 12, 14, 16, 18], "pass_yds": [50, 75, 100, 125, 150, 175, 200], "pass_td": [1, 2], "rush_att": [3, 4, 5, 6, 7, 8, 9], "rush_yds": [10, 20, 30, 40, 50, 60, 70], "rush_td": [1, 2], "targets": [1, 2, 3, 4, 5, 6], "receptions":[1, 2, 3, 4, 5, 6], "rec_yds": [10, 20, 30, 40, 50, 60, 70], "rec_td": [1, 2], "fg_made": [1, 2], }, } def milestones_for(stat_key: str, timeframe: str): tf = NFL_MILESTONES.get(timeframe, NFL_MILESTONES["Game"]) return tf.get(stat_key, NFL_MILESTONES["Game"].get(stat_key, [])) # ============ # Market columns (exact, full-game only) # ============ MARKET_LINE_MAP = { "pass_att": "prop_pass_att_line", "pass_yds": "prop_pass_yds_line", "pass_td": "prop_pass_td_line", "rush_att": "prop_rush_att_line", "rush_yds": "prop_rush_yds_line", "rush_td": "prop_rush_td_line", "receptions": "prop_rec_line", "rec_yds": "prop_rec_yds_line", "rec_td": "prop_rec_td_line", # fg_made not included here (we model K-ball separately) } # ============ # Odds helpers # ============ def to_american_odds(prob: float) -> str: prob = max(min(float(prob), 0.9999), 0.0001) if prob >= 0.5: return str(int(-100 * prob / (1 - prob))) else: return f"+{int(100 * (1 - prob) / prob)}" def apply_vig(prob: float, vig_pct: float) -> float: return max(min(float(prob) + float(vig_pct) / 100.0, 0.9999), 0.0001) # ====================== # Modeling helpers (NBA-style blend kept for non-FG if needed later) # ====================== def bayesian_model_weights(poisson_ll, nb_ll, gamma_ll, lognorm_ll): log_likelihoods = np.array([poisson_ll, nb_ll, gamma_ll, lognorm_ll]) log_likelihoods = np.nan_to_num(log_likelihoods, nan=-np.inf) max_log_likelihood = np.max(log_likelihoods) exp_likelihoods = np.exp(log_likelihoods - max_log_likelihood) s = np.sum(exp_likelihoods) if s == 0: return {"Poisson": 0.25, "Negative Binomial": 0.25, "Gamma-Poisson": 0.25, "Log-Normal": 0.25} w = exp_likelihoods / s return {"Poisson": w[0], "Negative Binomial": w[1], "Gamma-Poisson": w[2], "Log-Normal": w[3]} def determine_best_fit(data): data = data.dropna() mean = np.mean(data) variance = np.var(data) if len(data) < 5 or mean <= 0 or variance <= 0: return bayesian_model_weights(-np.inf, -np.inf, -np.inf, -np.inf) poisson_ll = np.sum(poisson.logpmf(data, mean)) if mean > 0 else -np.inf nb_r = mean ** 2 / (variance - mean) if variance > mean else 10 nb_p = mean / variance if variance > mean else 0.5 nb_ll = np.sum(nbinom.logpmf(data, nb_r, nb_p)) if nb_r > 0 and nb_p > 0 else -np.inf gamma_ll = np.sum(gamma.logpdf(data, a=nb_r, scale=nb_p)) if nb_r > 0 and nb_p > 0 else -np.inf log_data = np.log1p(data[data > 0]) ks_stat, ks_p = kstest(log_data, 'norm', args=(np.mean(log_data), np.std(log_data))) if len(log_data) > 1 else (0, 0) lognorm_ll = np.sum(lognorm.logpdf(data[data > 0], s=(np.std(log_data) if len(log_data) > 1 else 1), scale=np.exp(np.mean(log_data) if len(log_data) > 1 else 0))) if ks_p > 0.01 else -np.inf return bayesian_model_weights(poisson_ll, nb_ll, gamma_ll, lognorm_ll) def calculate_probability(mean, variance, weights, milestones, raw_data): probabilities = {} if mean <= 0: return {f"{m}+": 0.001 for m in milestones} for m in milestones: poisson_prob = 1 - poisson.cdf(m - 1, mean) probabilities[f"{m}+"] = round(max(poisson_prob, 0.001), 4) return probabilities def generate_pie(weights, player, stat): fig, ax = plt.subplots() labels = list(weights.keys()) sizes = list(weights.values()) nz_idx = [i for i, s in enumerate(sizes) if s > 0] sizes_nz = [sizes[i] for i in nz_idx] or [1.0] labels_nz = [labels[i] for i in nz_idx] or ["Poisson"] wedges, _ = ax.pie(sizes_nz, startangle=140, radius=1.0) for i, w in enumerate(wedges): angle = (w.theta2 + w.theta1) / 2. rad = np.deg2rad(angle) ax.annotate(f"{labels_nz[i]} ({sizes_nz[i]*100:.1f}%)", xy=(np.cos(rad), np.sin(rad)), xytext=(1.2*np.cos(rad), 1.2*np.sin(rad)), ha="center", va="center", arrowprops=dict(arrowstyle='-', lw=0.8)) ax.set_title(f"Distribution Blend – {player} ({STAT_LABELS.get(stat, stat)})") ax.axis('equal') return fig def generate_histogram(raw_data, weights, mean, variance): x = np.linspace(0, max(raw_data.max() if len(raw_data) else 1, 10) + 10, 500) poisson_pdf = poisson.pmf(np.floor(x), mean) if mean > 0 else np.zeros_like(x) nb_r = mean ** 2 / (variance - mean) if variance > mean else 10 nb_p = mean / variance if variance > mean else 0.5 nb_pdf = nbinom.pmf(np.floor(x), nb_r, nb_p) if nb_r > 0 and nb_p > 0 else np.zeros_like(x) gamma_pdf = gamma.pdf(x, a=mean, scale=variance / mean) if mean > 0 and variance > 0 else np.zeros_like(x) lognorm_pdf = np.zeros_like(x) log_data = np.log1p(raw_data[raw_data > 0]) if len(log_data) > 1: lognorm_pdf = lognorm.pdf(x, s=np.std(log_data), scale=np.exp(np.mean(log_data))) blended_pdf = (weights["Poisson"] * poisson_pdf + weights["Negative Binomial"] * nb_pdf + weights["Gamma-Poisson"] * gamma_pdf + weights["Log-Normal"] * lognorm_pdf) fig, ax = plt.subplots() bins = range(int(raw_data.min()) if len(raw_data) > 0 else 0, int(raw_data.max()) + 2 if len(raw_data) > 0 else 2) ax.hist(raw_data, bins=bins, density=True, alpha=0.6) ax.plot(x, blended_pdf, 'k-', label="Blended Model", linewidth=2) ax.set_title("Histogram vs. Blended Model PDF") ax.legend() return fig # ==================== # Recency weighting helpers # ==================== def _order_key(df_slice: pd.DataFrame): if "gameday" in df_slice.columns: return pd.to_datetime(df_slice["gameday"], errors="coerce") if {"season", "week"}.issubset(df_slice.columns): # coerce tuples; older first return df_slice["season"].astype(float) * 100 + df_slice["week"].astype(float) # fallback to row order return pd.Series(np.arange(len(df_slice)), index=df_slice.index) def recency_weights(df_slice: pd.DataFrame, half_life_games: float) -> pd.Series: """ Exponential decay by 'games ago' (0 = most recent). weight = 0.5 ** (age / half_life_games) """ if half_life_games is None or half_life_games <= 0: # equal weights return pd.Series(1.0, index=df_slice.index) # sort by time key = _order_key(df_slice) ord_idx = key.sort_values(na_position="first").index # ages: oldest -> largest age; we want most recent = age 0 # create rank so that the last in sorted order is most recent ranks = pd.Series(np.arange(len(ord_idx)), index=ord_idx) # oldest=0 ... most recent= n-1 ages = (ranks.max() - ranks).reindex(df_slice.index).fillna(0).astype(float) w = 0.5 ** (ages / float(half_life_games)) return w.clip(lower=1e-6) # ==================== # FG K-ball model helpers (used ONLY for fg_made and kickers) # ==================== FG_BINS = [ ("lt40", 35), ("40_49", 45), ("50_54", 52), ("55_59", 57), ("60_plus", 62), ] def _beta_smooth_rate(makes, atts, alpha=8.0, beta=2.0): return (makes + alpha) / (atts + alpha + beta) if (atts + alpha + beta) > 0 else (alpha / (alpha + beta)) def _fit_logistic_from_bins(dists, rates): def logit(p): p = np.clip(p, 1e-6, 1-1e-6) return np.log(p/(1-p)) R = 50.0 x = (R - np.array(dists)) y = np.array([logit(p) for p in rates]) X = np.vstack([np.ones_like(x), x]).T try: coef, _, _, _ = np.linalg.lstsq(X, y, rcond=None) a, b = coef[0], coef[1] except Exception: a, b = 0.0, -0.15 return a, b, R def _p_make(a, b, R, d): z = a + b*(R - d) return 1.0 / (1.0 + np.exp(-z)) def _fg_lambda_p_from_slice(pdata: pd.DataFrame, timeframe: str, hist_weights: pd.Series = None): """ Return per-game attempt rates per bin and smoothed accuracy per bin, with optional per-row recency weights applied to attempts/makes. """ suf = {"Game":"", "1H":"_1h", "1Q":"_1q"}[timeframe] att_cols = [f"fg_att_{k}{suf}" for k,_ in FG_BINS] made_cols = [f"fg_made_{k}{suf}" for k,_ in FG_BINS] if hist_weights is None: hist_weights = pd.Series(1.0, index=pdata.index) atts = [] made = [] for c in att_cols: s = pd.to_numeric(pdata.get(c, pd.Series(dtype=float)), errors="coerce").fillna(0.0) atts.append((s * hist_weights.reindex(pdata.index).fillna(0)).sum()) for c in made_cols: s = pd.to_numeric(pdata.get(c, pd.Series(dtype=float)), errors="coerce").fillna(0.0) made.append((s * hist_weights.reindex(pdata.index).fillna(0)).sum()) atts = np.array(atts, dtype=float) made = np.array(made, dtype=float) # "weighted games" is sum of weights (each row ~ one game) games_w = float(hist_weights.sum()) games_w = max(games_w, 1e-9) lam_bins = atts / games_w dist_mid = np.array([mid for _, mid in FG_BINS]) p_hat = np.array([_beta_smooth_rate(m, a) for m, a in zip(made, atts)]) a, b, R = _fit_logistic_from_bins(dist_mid, p_hat) return lam_bins, (a, b, R), dist_mid def fg_kball_mean_var_for_slice(pdata: pd.DataFrame, timeframe: str, range_gain_yds=7.0, acc_bump_abs=0.02, long_propensity=0.10, hist_weights: pd.Series = None): lam_bins, (a, b, R), dist_mid = _fg_lambda_p_from_slice(pdata, timeframe, hist_weights) # Tilt long attempts tilt = np.ones_like(lam_bins) long_idx = np.array([i for i,(k,_) in enumerate(FG_BINS) if k in ("55_59","60_plus")]) tilt[long_idx] = 1.0 + float(long_propensity) lam_bins = lam_bins * tilt # Keep total attempts per game constant after tilting total = lam_bins.sum() if total > 1e-12: lam_bins = lam_bins * (total / lam_bins.sum()) # Range + accuracy bump def p_range(d): return _p_make(a, b, R + float(range_gain_yds), d) p_vec = np.array([np.clip(p_range(d) + float(acc_bump_abs), 0.0, 1.0) for d in dist_mid]) mu = float(np.sum(lam_bins * p_vec)) var = float(np.sum(lam_bins * p_vec * (1.0 - p_vec))) return mu, var # ==================== # Market + Historical (recency) helpers # ==================== def weighted_mean(series: pd.Series, weights: pd.Series): s = pd.to_numeric(series, errors="coerce").replace([np.inf, -np.inf], np.nan) mask = s.notna() & weights.reindex(s.index).notna() if not mask.any(): return float("nan"), 0 s = s[mask] w = weights.reindex(s.index).astype(float) denom = w.sum() if denom <= 0: return float("nan"), 0 return float((s * w).sum() / denom), int(s.shape[0]) def market_mean_for_player(pdata: pd.DataFrame, stat_key: str, market_half_life_games: float): col = MARKET_LINE_MAP.get(stat_key, None) if not col or col not in pdata.columns: return float("nan"), 0 w = recency_weights(pdata, market_half_life_games) return weighted_mean(pdata[col], w) def historical_mean_for_player(pdata: pd.DataFrame, stat_col: str, hist_half_life_games: float): w = recency_weights(pdata, hist_half_life_games) return weighted_mean(pdata[stat_col], w) # ==================== # Globals # ==================== df = None model_weights_df = None temp_df = None # ========================= # Loading + preprocessing # ========================= def csv_col_for(stat_key: str, timeframe_key: str) -> str: return f"{STAT_MAP.get(stat_key, stat_key)}{TIMEFRAMES.get(timeframe_key, '')}" def load_and_prepare_data(file): """Populate globals and return UI choices.""" global df, model_weights_df, temp_df if file is None: return (gr.update(choices=[], value=None), # team_dd gr.update(choices=[], value=[]), # players_ms gr.update(choices=[], value=None), # position_dd gr.update(choices=[], value=None), # league_pos "Upload the CSV to begin.") raw = pd.read_csv(file.name) raw.columns = [c.strip() for c in raw.columns] df = raw.copy() temp_df = raw.copy() teams = sorted(df.get("player_team", pd.Series(dtype=str)).dropna().astype(str).str.strip().replace("", np.nan).dropna().unique().tolist()) players = sorted(df.get("player", pd.Series(dtype=str)).dropna().astype(str).str.strip().replace("", np.nan).dropna().unique().tolist()) positions = sorted(df.get("position", pd.Series(dtype=str)).dropna().astype(str).str.strip().replace("", np.nan).dropna().unique().tolist()) # Precompute per-player model weights (non-FG stats; kept as before) rows = [] for player in players: pdata = df[df["player"] == player] row = {"player": player, "games_played": pdata["game_id"].nunique() if "game_id" in pdata.columns else len(pdata)} for stat_key in STAT_OPTIONS: stat_col = csv_col_for(stat_key, "Game") if stat_col not in pdata.columns: weights = {"Poisson":0.25, "Negative Binomial":0.25, "Gamma-Poisson":0.25, "Log-Normal":0.25} else: raw_data = pd.to_numeric(pdata.get(stat_col, pd.Series(dtype=float)), errors="coerce").dropna() weights = determine_best_fit(raw_data) row[f"Poisson_Weight_{stat_key}"] = round(weights["Poisson"], 4) row[f"Negative_Binomial_Weight_{stat_key}"] = round(weights["Negative Binomial"], 4) row[f"Gamma_Poisson_Weight_{stat_key}"] = round(weights["Gamma-Poisson"], 4) row[f"Log_Normal_Weight_{stat_key}"] = round(weights["Log-Normal"], 4) rows.append(row) model_weights_df = pd.DataFrame(rows) msg = "✅ File loaded." if "player_team" not in df.columns: msg = "⚠️ 'player_team' not found. Team tab will not filter correctly until your exporter adds it." return (gr.update(choices=teams, value=(teams[0] if teams else None)), gr.update(choices=players, value=[]), gr.update(choices=positions, value=None), gr.update(choices=positions, value=None), msg) # ========================= # Player tab (position filter + league average + K-ball + Market/Hist blend + Recency + Small-sample prior) # ========================= def estimate(player, stat_key, timeframe, mean_sel, custom_mean, vig, show_extremes, range_gain_yds, acc_bump_abs, long_propensity, market_hist_blend, hist_half_life, market_half_life, prior_strength_games): if df is None or model_weights_df is None: return "⚠️ Upload the CSV.", pd.DataFrame(), {"Poisson":1,"Negative Binomial":0,"Gamma-Poisson":0,"Log-Normal":0}, pd.Series(dtype=float) if player not in df['player'].values: return f"⚠️ Player '{player}' not found.", pd.DataFrame(), {"Poisson":1,"Negative Binomial":0,"Gamma-Poisson":0,"Log-Normal":0}, pd.Series(dtype=float) stat_col = csv_col_for(stat_key, timeframe) pdata = df[df['player'] == player] # RAW (for hit rates & charts) raw_data = pd.to_numeric(pdata.get(stat_col, pd.Series(dtype=float)), errors="coerce").dropna() n_hist_rows = int(raw_data.shape[0]) # ===== Historical mean (recency-weighted) ===== hist_mean, _hist_used = historical_mean_for_player(pdata, stat_col, hist_half_life) # ===== K-ball for FG (kickers only) overrides hist_mean/variance ===== is_kicker = (pdata.get("position") == "K").any() variance = raw_data.var() if len(raw_data) else 0.0 if stat_key == "fg_made" and is_kicker: w_hist = recency_weights(pdata, hist_half_life) mu, var = fg_kball_mean_var_for_slice( pdata, timeframe, range_gain_yds, acc_bump_abs, long_propensity, hist_weights=w_hist ) hist_mean, variance = mu, var # ===== Market mean (recency-weighted; partial rows OK) ===== market_mean, market_rows = market_mean_for_player(pdata, stat_key, market_half_life) # ===== Market ↔ Historical Blend (unless custom) ===== if mean_sel == "Use Custom Projection" and custom_mean is not None: mean_after_market = float(custom_mean) mean_src = "Custom" else: if np.isfinite(market_mean): w = float(market_hist_blend) # 0..1 (1 = all market) mean_after_market = w * market_mean + (1.0 - w) * hist_mean mean_src = f"Blend ({w:.2f} market / {1-w:.2f} hist)" else: mean_after_market = hist_mean mean_src = "Historical" # ===== Small-sample league-average prior (position-based) ===== # Compute league avg for same position (same stat/timeframe) position_vals = pdata.get("position").dropna().astype(str).unique().tolist() player_pos = position_vals[0] if position_vals else None league_mean_for_prior = None if player_pos: pos_slice = df[df.get("position") == player_pos].copy() if stat_key == "fg_made" and player_pos == "K": # use K-ball mean across position (no recency here to keep fast) mu_pos, _ = fg_kball_mean_var_for_slice(pos_slice, timeframe) league_mean_for_prior = mu_pos else: series_pos = pd.to_numeric(pos_slice.get(stat_col, pd.Series(dtype=float)), errors="coerce").dropna() league_mean_for_prior = float(series_pos.mean()) if len(series_pos) else None n_games = n_hist_rows # rows with non-null stat for the player if league_mean_for_prior is not None and prior_strength_games > 0: # shrink towards league avg when sample is small; continuous shrinkage w_player = n_games / (n_games + float(prior_strength_games)) mean_to_use = w_player * mean_after_market + (1.0 - w_player) * league_mean_for_prior prior_note = f" (shrunken with {player_pos} league avg, w={w_player:.2f})" else: mean_to_use = mean_after_market prior_note = "" # ===== Probabilities and table ===== ms = milestones_for(stat_key, timeframe) probs_all = calculate_probability(mean_to_use, variance, {"Poisson":1,"Negative Binomial":0,"Gamma-Poisson":0,"Log-Normal":0}, ms, raw_data) if show_extremes == "Hide Extreme Probabilities": probs = {k: v for k, v in probs_all.items() if 0.005 <= v <= 0.99} if len(probs) == 0: probs = probs_all.copy() else: probs = probs_all games = pdata['game_id'].nunique() if "game_id" in pdata.columns else len(pdata) hit_rates = [] for m in ms: hits = (raw_data >= m).sum() if len(raw_data) else 0 hit_rates.append(round((hits / games) * 100, 2) if games > 0 else 0.0) filtered = list(probs.keys()) filt_hr = [hr for m, hr in zip(ms, hit_rates) if f"{m}+" in filtered] table = pd.DataFrame({ "Milestone": filtered, "Probability": [f"{v * 100:.2f}%" for v in probs.values()], "True Odds": [to_american_odds(v) for v in probs.values()], "Odds w/Vig": [to_american_odds(apply_vig(v, vig)) for v in probs.values()], "Hit Rate": [f"{x:.2f}%" for x in filt_hr], }) mm_text = f"{market_mean:.2f}" if np.isfinite(market_mean) else "n/a" summary_md = f""" ### 📊 {player} — {STAT_LABELS.get(stat_key, stat_key)} ({timeframe}) - Games in sample (non-null {stat_col}): **{n_games}** - Historical mean (recency HL={hist_half_life:.1f} games): **{(hist_mean if np.isfinite(hist_mean) else 0.0):.2f}** - Market mean (rows used, HL={market_half_life:.1f}): **{mm_text}** (rows: **{market_rows}**) - Projection used: **{mean_to_use:.2f}** — {mean_src}{prior_note} - Variance (hist/K-ball): **{variance:.2f}** - Vig: **{vig:.2f}%** — Extremes: **{'Shown' if show_extremes == 'Show All' else 'Hidden (fallback if empty)'}** """ return summary_md, table, {"Poisson":1,"Negative Binomial":0,"Gamma-Poisson":0,"Log-Normal":0}, raw_data def league_avg_by_position(position, stat_key, timeframe, vig, range_gain_yds, acc_bump_abs, long_propensity): if df is None: return pd.DataFrame(), "Upload a CSV first." if not position: return pd.DataFrame(), "Pick a position." slice_df = df[df.get("position") == position].copy() if slice_df.empty: return pd.DataFrame(), f"No rows for position {position}." stat_col = csv_col_for(stat_key, timeframe) ms = milestones_for(stat_key, timeframe) # FG uses K-ball mean ONLY if position is K and stat is fg_made if stat_key == "fg_made" and position == "K": mu, _ = fg_kball_mean_var_for_slice(slice_df, timeframe, range_gain_yds, acc_bump_abs, long_propensity) mean_to_use = mu else: series = pd.to_numeric(slice_df.get(stat_col, pd.Series(dtype=float)), errors="coerce").dropna() mean_to_use = series.mean() if len(series) else 0.0 probs = {f"{m}+": round(1 - poisson.cdf(m-1, mean_to_use), 4) for m in ms} table = pd.DataFrame({ "Milestone": list(probs.keys()), "Probability": [f"{p*100:.2f}%" for p in probs.values()], "True Odds": [to_american_odds(p) for p in probs.values()], "Odds w/Vig": [to_american_odds(apply_vig(p, vig)) for p in probs.values()], }) title = f"{position} League Avg — {STAT_LABELS.get(stat_key, stat_key)} ({timeframe})" return table, title # ========================= # Team tab # ========================= def team_table(team, stat_key, timeframe, vig, subset_players): if df is None: return pd.DataFrame(), "Upload a CSV first." if not team: return pd.DataFrame(), "Pick a team." stat_col = csv_col_for(stat_key, timeframe) milestones = milestones_for(stat_key, timeframe) work = df[df.get("player_team") == team].copy() if subset_players: work = work[work.get("player").isin(subset_players)] if work.empty: return pd.DataFrame(), f"No rows for {team}." rows = [] for player, pdata in work.groupby("player", dropna=True): series = pd.to_numeric(pdata.get(stat_col, pd.Series(dtype=float)), errors="coerce").dropna() games = pdata['game_id'].nunique() if "game_id" in pdata.columns else len(pdata) mean = series.mean() if len(series) else 0.0 for m in milestones: prob_hist = float((series >= m).sum()) / float(games) if (games > 0 and len(series)) else (1 - poisson.cdf(m-1, mean)) rows.append({ "Player": player, "Games": games, "Milestone": f"{m}+", "Prob": round(prob_hist, 4), "True Odds": to_american_odds(prob_hist), "Odds w/ Vig": to_american_odds(apply_vig(prob_hist, vig)), "Mean": round(mean, 2), }) out = pd.DataFrame(rows) def m_to_int(s): try: return int(str(s).replace("+", "")) except: return 0 out["_m"] = out["Milestone"].apply(m_to_int) out = out.sort_values(["Prob","Player","_m"], ascending=[False,True,True]).drop(columns=["_m"]) return out, f"{team} • {STAT_LABELS.get(stat_key, stat_key)} • {timeframe}" # ============== # UI (Gradio) # ============== with gr.Blocks(title="🏈 NFL Milestone Explorer", css=".green-button {background-color: #28a745 !important; color: white !important; font-weight: bold;}") as demo: gr.Markdown("## 🏈 NFL Milestone Explorer") gr.Markdown("Upload the `nfl_milestone_logs.csv` from your exporter. Team tab uses the **player_team** column.") file_in = gr.File(label="Upload nfl_milestone_logs.csv", file_types=[".csv"]) status = gr.Markdown("") # Populate choices on upload def on_file(f): team_upd, players_upd, pos_upd, league_pos_upd, msg = load_and_prepare_data(f) return team_upd, players_upd, pos_upd, league_pos_upd, msg with gr.Tabs(): # ===== Team Tab ===== with gr.Tab("Team"): with gr.Row(): team_dd = gr.Dropdown(label="Team (player_team)", choices=[]) team_stat = gr.Dropdown(label="Stat", choices=STAT_OPTIONS, value="rec_yds") team_time = gr.Radio(list(TIMEFRAMES.keys()), value="Game", label="Timeframe") team_vig = gr.Number(label="Vig (%)", value=4.92, precision=2) team_players = gr.Dropdown(choices=[], multiselect=True, label="Filter to Players (optional)") team_btn = gr.Button("Compute Team Table", elem_classes=["green-button"]) team_title = gr.Markdown(visible=False) team_table_out = gr.Dataframe(visible=False, label="Team Milestones") # ===== Player Tab ===== with gr.Tab("Player"): gr.Markdown("### Filters") with gr.Row(): position_dd = gr.Dropdown(choices=[], label="Position (optional, filters player list)") players_ms = gr.Dropdown(choices=[], multiselect=True, label="Players (select none to use all in position)") with gr.Row(): p_stat = gr.Dropdown(label="Stat", choices=STAT_OPTIONS, value="rec_yds") p_time = gr.Radio(list(TIMEFRAMES.keys()), value="Game", label="Timeframe") gr.Markdown("### Projection Controls") with gr.Row(): mean_sel = gr.Radio(["Use Per-Game Average", "Use Custom Projection"], label="Projection Source", value="Use Per-Game Average") custom_proj = gr.Number(label="Custom Mean (if selected)", precision=2) market_hist_blend = gr.Slider(0, 1, value=0.5, step=0.05, label="Projection Blend: Market ↔ Historical") gr.Markdown("### Recency Weighting (Half-life in games)") with gr.Row(): hist_half_life = gr.Slider(0, 20, value=6, step=1, label="Historical Half-life") market_half_life = gr.Slider(0, 20, value=6, step=1, label="Market Half-life") gr.Markdown("### Small-Sample League Average Prior") with gr.Row(): prior_strength = gr.Slider(0, 20, value=7, step=1, label="Prior Strength (games)") gr.Markdown("### (Optional) K-ball Adjustments (used only when Stat = FG Made & Position = K)") with gr.Row(): range_gain = gr.Slider(0, 10, value=7, step=1, label="K-ball: Range gain (yds)") acc_bump = gr.Slider(0, 0.10, value=0.02, step=0.01, label="K-ball: Accuracy bump (abs prob)") long_prop = gr.Slider(0, 0.5, value=0.10, step=0.05, label="K-ball: Long-attempt propensity") gr.Markdown("### Odds Settings") with gr.Row(): p_vig = gr.Number(label="Vig (%)", value=4.92, precision=2) extreme_toggle = gr.Radio(["Hide Extreme Probabilities", "Show All"], label="Extreme Probabilities", value="Hide Extreme Probabilities") player_btn = gr.Button("Compute Selected Players", elem_classes=["green-button"]) p_summary = gr.Markdown(visible=False) p_table = gr.Dataframe(visible=False, label="Milestones") p_pie = gr.Plot(visible=False) p_hist = gr.Plot(visible=False) recent_games = gr.Dataframe(visible=False, label="Recent Games") gr.Markdown("### League Average Pricing (by Position)") with gr.Row(): league_pos = gr.Dropdown(choices=[], label="Position for League Avg") league_stat = gr.Dropdown(label="Stat", choices=STAT_OPTIONS, value="fg_made") league_time = gr.Radio(list(TIMEFRAMES.keys()), value="Game", label="Timeframe") league_vig = gr.Number(label="Vig (%)", value=4.92, precision=2) with gr.Row(): league_range_gain = gr.Slider(0, 10, value=7, step=1, label="K-ball: Range gain (yds)") league_acc_bump = gr.Slider(0, 0.10, value=0.02, step=0.01, label="K-ball: Accuracy bump (abs prob)") league_long_prop = gr.Slider(0, 0.5, value=0.10, step=0.05, label="K-ball: Long-attempt propensity") league_btn = gr.Button("Compute League Avg", elem_classes=["green-button"]) league_title = gr.Markdown(visible=False) league_table = gr.Dataframe(visible=False, label="League Avg Milestones") # Hook file load (also fills league_pos) file_in.change(on_file, inputs=[file_in], outputs=[team_dd, players_ms, position_dd, league_pos, status]) # Team roster subset choices def on_team_change(team): if df is None or not team: return gr.update(choices=[], value=[]) team_players_list = ( df.loc[df.get("player_team") == team, "player"] .dropna().astype(str).str.strip().replace("", np.nan).dropna().unique().tolist() ) return gr.update(choices=sorted(team_players_list), value=[]) team_dd.change(on_team_change, inputs=[team_dd], outputs=[team_players]) # Player list filtered by position (or all) def on_position_change(pos): if df is None: return gr.update(choices=[], value=[]) if not pos: plist = df["player"].dropna().astype(str).str.strip().unique().tolist() else: plist = (df.loc[df.get("position") == pos, "player"] .dropna().astype(str).str.strip().unique().tolist()) plist = sorted(plist) return gr.update(choices=plist, value=[]) position_dd.change(on_position_change, inputs=[position_dd], outputs=[players_ms]) # Team run def run_team(team, stat, timeframe, vig, subset): table, title = team_table(team, stat, timeframe, vig, subset) return gr.update(value=title, visible=True), gr.update(value=table, visible=True) team_btn.click(run_team, inputs=[team_dd, team_stat, team_time, team_vig, team_players], outputs=[team_title, team_table_out]) # Player run (multi-player; charts only when a single player is selected) def run_players(pos, players, stat, timeframe, mean_sel_v, custom_mean, vig, extreme_v, rg, acc, lp, blend, hist_hl, market_hl, prior_g): if df is None: return (gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)) # If no players selected but position chosen -> use all players of that position if (not players) and pos: players = sorted(df.loc[df.get("position") == pos, "player"].dropna().astype(str).str.strip().unique().tolist()) if not players: return (gr.update(value="⚠️ Select a position or at least one player.", visible=True), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)) all_rows = [] first_summary = None first_weights = None first_raw = None for i, player in enumerate(players): summary_md, table, weights, raw = estimate( player, stat, timeframe, mean_sel_v, custom_mean, vig, extreme_v, rg, acc, lp, blend, hist_hl, market_hl, prior_g ) t = table.copy() t.insert(0, "Player", player) all_rows.append(t) if i == 0: first_summary, first_weights, first_raw = summary_md, weights, raw stacked = pd.concat(all_rows, ignore_index=True) if all_rows else pd.DataFrame() # Charts & recent games only when exactly one player is selected if len(players) == 1 and first_weights is not None: pie = generate_pie(first_weights, players[0], stat) raw = first_raw if first_raw is not None else pd.Series(dtype=float) hist = generate_histogram( raw, first_weights, custom_mean if mean_sel_v == "Use Custom Projection" and custom_mean is not None else (raw.mean() if len(raw)>0 else 0.0), raw.var() if len(raw)>0 else 0.0 ) recent = temp_df[temp_df['player'] == players[0]].copy() if "game_id" in recent.columns and "gameday" in recent.columns: recent = recent.sort_values(by=['season','week','game_id'] if {'season','week','game_id'}.issubset(recent.columns) else 'gameday', ascending=False) recent = recent.head(10) keep_cols = [c for c in ["gameday","season","week","home_team","away_team", csv_col_for(stat, timeframe)] if c in recent.columns] recent_disp = recent[keep_cols] if keep_cols else recent return (gr.update(value=first_summary, visible=True), gr.update(value=stacked, visible=True), gr.update(value=pie, visible=True), gr.update(value=hist, visible=True), gr.update(value=recent_disp, visible=True)) else: title = f"{', '.join(players[:6])}{' …' if len(players) > 6 else ''} — {STAT_LABELS.get(stat, stat)} ({timeframe})" return (gr.update(value=title, visible=True), gr.update(value=stacked, visible=True), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)) player_btn.click( run_players, inputs=[ position_dd, players_ms, p_stat, p_time, mean_sel, custom_proj, p_vig, extreme_toggle, range_gain, acc_bump, long_prop, market_hist_blend, hist_half_life, market_half_life, prior_strength ], outputs=[p_summary, p_table, p_pie, p_hist, recent_games] ) # League average run (by position) def run_league_avg(pos, stat, timeframe, vig, rg, acc, lp): table, title = league_avg_by_position(pos, stat, timeframe, vig, rg, acc, lp) return gr.update(value=title, visible=True), gr.update(value=table, visible=True) league_btn.click(run_league_avg, inputs=[league_pos, league_stat, league_time, league_vig, league_range_gain, league_acc_bump, league_long_prop], outputs=[league_title, league_table]) demo.launch()