tylerdevos's picture
Update app.py
7798619 verified
Raw History Blame Contribute Delete
37.2 kB
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()