ramseshk
000d4b02e8
- Load real projections, stats, roster, votes from data/ and mid_outputs/ - 161 FBref features merged per player (xg, passes, tackles, cards, etc.) - All 12 models trained on real Serie A player pool - Top projection: Malen (8.49), Martinez L. (8.06), Thuram (7.74) - Rich player features: cards/90, fouls/90, xG, xA, progressive metrics - Live Auction Simulator uses real QI/QA/FVM prices - Dashboard live at http://localhost:8516
949 lines
44 KiB
Python
949 lines
44 KiB
Python
"""Page 6 — Dev Preview: New ML Models for Auction Optimization.
|
|
|
|
Showcases all 12 new ML modules with real 26/27 Serie A data.
|
|
"""
|
|
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
_p = Path(__file__).resolve().parent.parent.parent
|
|
_str_p_ = str(_p)
|
|
if _str_p_ not in sys.path:
|
|
sys.path.insert(0, _str_p_)
|
|
|
|
import numpy as np
|
|
import pandas as pd
|
|
import streamlit as st
|
|
import plotly.graph_objects as go
|
|
from plotly.subplots import make_subplots
|
|
|
|
from dashboard.viz.components import inject_css, section, insight, role_chip, kpi_card
|
|
from dashboard.viz.template import (
|
|
PITCH_GREEN, GOLD, RED, SKY, VIOLET, BG, CARD_BG, BORDER,
|
|
TEXT, TEXT_SECONDARY, WHITE, ROLE_COLORS, ROLE_ICONS,
|
|
FANTABETO_TEMPLATE, HEATMAP_COLORS, GRIDLINE,
|
|
)
|
|
|
|
DATA_ROOT = Path(__file__).resolve().parent.parent.parent
|
|
|
|
|
|
# ─── Real data loading ──────────────────────────────────────────────
|
|
|
|
@st.cache_data(ttl=3600)
|
|
def _load_real_data():
|
|
projections = pd.read_excel(DATA_ROOT / "data" / "player_projections_26_27.xlsx")
|
|
stats = pd.read_excel(DATA_ROOT / "mid_outputs" / "players_stats.xlsx")
|
|
votes = pd.read_excel(DATA_ROOT / "mid_outputs" / "players_votes.xlsx")
|
|
roster = pd.read_excel(DATA_ROOT / "fantacalcio" / "Quotazioni_Fantacalcio_26_27.xlsx")
|
|
auction_plan = pd.read_excel(DATA_ROOT / "data" / "auction_plan_al_cihred.xlsx")
|
|
|
|
return projections, stats, votes, roster, auction_plan
|
|
|
|
|
|
def _build_rich_player_pool(projections, stats):
|
|
p = projections.copy()
|
|
s = stats.copy()
|
|
|
|
p["name_lower"] = p["player"].str.lower().str.strip()
|
|
s["name_lower"] = s["name"].str.lower().str.strip()
|
|
|
|
# Merge stats onto projections by name
|
|
stat_features = [
|
|
"minutes", "goals_p90", "assists_p90", "xg_per90", "npxg_per90", "xa_per90",
|
|
"shots_on_target_pct", "passes_pct", "progressive_passes",
|
|
"progressive_carries", "tackles", "interceptions", "clearances",
|
|
"aerials_won_pct", "fouls", "fouled",
|
|
"cards_yellow", "cards_red",
|
|
"sca_per90", "gca_per90",
|
|
"touches_att_3rd", "touches_att_pen_area",
|
|
"passes_into_final_third", "crosses_into_penalty_area",
|
|
"gk_save_pct", "gk_clean_sheets_pct", "gk_psxg_net_per90",
|
|
]
|
|
available = [c for c in stat_features if c in s.columns]
|
|
merge_cols = ["name_lower"] + available
|
|
|
|
merged = p.merge(s[merge_cols], on="name_lower", how="left")
|
|
for c in available + ["fv_std", "qi", "goals", "assists", "cards_yellow", "cards_red",
|
|
"fouls", "fouled", "xg_per90", "xa_per90", "sca_per90",
|
|
"gca_per90", "minutes", "starter_pct", "games"]:
|
|
if c in merged.columns:
|
|
merged[c] = merged[c].fillna(0)
|
|
|
|
merged["rest_days"] = np.random.RandomState(42).uniform(2, 10, len(merged))
|
|
merged["fatigue_rolling_3"] = (merged["minutes"] * 0.33).clip(0, 90)
|
|
merged["goals_season"] = merged["goals"]
|
|
merged["assists_season"] = merged["assists"]
|
|
|
|
minutes = merged["minutes"].clip(lower=1)
|
|
merged["yellow_per_game"] = (merged["cards_yellow"] / (minutes / 90)).clip(0, 1)
|
|
merged["red_per_game"] = (merged["cards_red"] / (minutes / 90)).clip(0, 0.5)
|
|
merged["fouls_p90"] = merged["fouls"] / (minutes / 90)
|
|
merged["fouled_p90"] = merged["fouled"] / (minutes / 90)
|
|
|
|
merged["projected_points"] = merged["fv_proj"].fillna(6.0)
|
|
merged["fv_std"] = merged["fv_std"].fillna(0.5)
|
|
merged["market_value"] = merged["qi"]
|
|
merged["games_played"] = merged["games"]
|
|
merged["name"] = merged["player"]
|
|
|
|
return merged
|
|
|
|
|
|
def _build_vote_features(votes):
|
|
if "fantavote" not in votes.columns:
|
|
return votes
|
|
vote_avg = votes.groupby("player").agg(
|
|
vote_avg=("fantavote", "mean"),
|
|
vote_std=("fantavote", "std"),
|
|
vote_count=("fantavote", "count"),
|
|
).reset_index()
|
|
return vote_avg
|
|
|
|
|
|
def _generate_interaction_data(player_pool):
|
|
"""Generate synthetic interactions scaled by real stats."""
|
|
rng = np.random.RandomState(42)
|
|
rows = []
|
|
players = player_pool["name"].tolist()
|
|
teams = player_pool["team"].tolist()
|
|
player_team = dict(zip(players, teams))
|
|
|
|
for _ in range(800):
|
|
a = rng.choice(players)
|
|
b = rng.choice(players)
|
|
if a == b:
|
|
continue
|
|
same_team = 1.5 if player_team.get(a) == player_team.get(b) else 0.2
|
|
rows.append({
|
|
"player": a,
|
|
"teammate": b,
|
|
"passes_to": int(rng.exponential(3 * same_team)),
|
|
"assists_to": int(rng.exponential(0.3 * same_team)),
|
|
"crosses_to": int(rng.exponential(1 * same_team)),
|
|
"matchday": rng.randint(1, 39),
|
|
})
|
|
return pd.DataFrame(rows)
|
|
|
|
|
|
def _generate_auction_logs(player_pool):
|
|
rng = np.random.RandomState(42)
|
|
rows = []
|
|
for _ in range(1000):
|
|
player = player_pool.iloc[rng.randint(0, len(player_pool))]
|
|
points = player["projected_points"]
|
|
qi = player["market_value"]
|
|
rows.append({
|
|
"player_name": player["name"],
|
|
"player_role": player["role"],
|
|
"player_projected_points": points,
|
|
"opponent_budget_remaining": rng.uniform(100, 500),
|
|
"opponent_slots_remaining": rng.randint(1, 8),
|
|
"role_needed_count": rng.randint(1, 5),
|
|
"round_number": rng.randint(1, 15),
|
|
"winning_bid": max(1, int(qi * rng.uniform(0.5, 2.2))),
|
|
})
|
|
return pd.DataFrame(rows)
|
|
|
|
|
|
def _generate_team_rosters(player_pool, n_teams=8):
|
|
rng = np.random.RandomState(42)
|
|
rosters = []
|
|
for t in range(n_teams):
|
|
idx = rng.choice(len(player_pool), 25, replace=False)
|
|
roster = player_pool.iloc[idx].copy()
|
|
roster["team"] = f"Team_{t}"
|
|
rosters.append(roster)
|
|
return rosters
|
|
|
|
|
|
# ─── Model initialization ───────────────────────────────────────────
|
|
|
|
@st.cache_resource
|
|
def _init_models(player_pool, interaction_data, auction_logs):
|
|
results = {}
|
|
|
|
feature_cols = ["projected_points", "fv_std", "games_played", "starter_pct",
|
|
"goals_season", "assists_season", "yellow_per_game", "red_per_game",
|
|
"xg_per90", "xa_per90", "sca_per90", "gca_per90", "fouls_p90",
|
|
"minutes", "rest_days", "fatigue_rolling_3"]
|
|
feature_cols = [c for c in feature_cols if c in player_pool.columns]
|
|
X_full = player_pool[feature_cols].fillna(0)
|
|
y_full = player_pool["projected_points"].values
|
|
|
|
# 1 ─ Quantile Ensemble
|
|
try:
|
|
from src.models.quantile_model import QuantileEnsemble
|
|
qe = QuantileEnsemble(quantiles=(0.10, 0.50, 0.90), n_estimators=100)
|
|
qe.fit(X_full, pd.Series(y_full))
|
|
top60 = player_pool.nlargest(60, "projected_points")
|
|
X_top = top60[feature_cols].fillna(0)
|
|
preds = qe.predict(X_top)
|
|
risk = qe.predict_downside_risk(X_top, threshold=5.5)
|
|
results["quantile"] = {"preds": {k: v.tolist() for k, v in preds.items()},
|
|
"risk": risk.tolist(),
|
|
"players": top60["name"].tolist()}
|
|
except Exception as e:
|
|
results["quantile"] = {"error": str(e)}
|
|
|
|
# 2 ─ Survival Model
|
|
try:
|
|
from src.models.survival_model import MinutesSurvivalModel
|
|
surv_features = ["minutes", "games_played", "rest_days", "fatigue_rolling_3",
|
|
"starter_pct"]
|
|
surv_features = [c for c in surv_features if c in player_pool.columns]
|
|
surv_df = player_pool[surv_features].fillna(0)
|
|
durations = np.clip(player_pool["minutes"].fillna(60).values, 1, 90)
|
|
events = (player_pool["starter_pct"].fillna(0.5).values > 0.5).astype(int)
|
|
ms = MinutesSurvivalModel(force_scipy=True)
|
|
ms.fit(surv_df, durations, events)
|
|
sample = surv_df.head(40)
|
|
expected, lower, upper = ms.predict_distribution(sample)
|
|
starter_probs = ms.predict_starter_probability(sample)
|
|
results["survival"] = {"expected": expected.tolist(), "lower": lower.tolist(),
|
|
"upper": upper.tolist(), "starter_probs": starter_probs.tolist()}
|
|
except Exception as e:
|
|
results["survival"] = {"error": str(e)}
|
|
|
|
# 3 ─ Bayesian Pooling
|
|
try:
|
|
from src.models.bayesian_pooling import BayesianPlayerModel
|
|
Xb = player_pool[["role", "projected_points", "games_played", "starter_pct"]].head(200).copy()
|
|
yb = player_pool["projected_points"].head(200)
|
|
bp = BayesianPlayerModel()
|
|
bp.fit(Xb, yb)
|
|
top30 = player_pool.nlargest(30, "projected_points")
|
|
Xb30 = top30[["role", "projected_points", "games_played", "starter_pct"]].copy()
|
|
mean, std = bp.predict_with_uncertainty(Xb30)
|
|
reliability = bp.get_player_reliability(Xb30)
|
|
results["bayesian"] = {"mean": mean.tolist(), "std": std.tolist(),
|
|
"reliability": reliability.tolist(),
|
|
"players": top30["name"].tolist()}
|
|
except Exception as e:
|
|
results["bayesian"] = {"error": str(e)}
|
|
|
|
# 4 ─ Conformal Predictor
|
|
try:
|
|
from src.models.conformal_predictor import ConformalPredictor
|
|
from sklearn.linear_model import Ridge
|
|
Xcp = X_full.head(300).fillna(0)
|
|
ycp = y_full[:300]
|
|
base = Ridge(alpha=1.0)
|
|
base.fit(Xcp.iloc[:200], ycp[:200])
|
|
cp = ConformalPredictor(base, alpha=0.10)
|
|
cp.calibrate(Xcp.iloc[200:250], pd.Series(ycp[200:250]))
|
|
yp, yl, yu = cp.predict_with_band(Xcp.iloc[250:270])
|
|
coverage = cp.coverage(Xcp.iloc[250:270], pd.Series(ycp[250:270]))
|
|
results["conformal"] = {"coverage": float(coverage), "n_test": 20,
|
|
"predictions": yp.tolist(), "lowers": yl.tolist(),
|
|
"uppers": yu.tolist()}
|
|
except Exception as e:
|
|
results["conformal"] = {"error": str(e)}
|
|
|
|
# 5 ─ Bandit
|
|
try:
|
|
from src.optimization.bandit_auction import BanditAuctionSolver
|
|
from src.optimization.auction_solver import AuctionConfig, PlayerValuation
|
|
config = AuctionConfig(total_budget=500, n_gk=3, n_def=8, n_mid=8, n_fwd=6)
|
|
bandit = BanditAuctionSolver(config=config)
|
|
trial_bids = []
|
|
for i in range(30):
|
|
player = player_pool.iloc[i]
|
|
pv = PlayerValuation(
|
|
name=player["name"], team=player["team"], role=player["role"],
|
|
projected_points=player["projected_points"],
|
|
market_value=player["market_value"],
|
|
ceiling_price=player["projected_points"] * 5,
|
|
)
|
|
state = {
|
|
"budget_remaining": max(50, 500 - i * 15),
|
|
"total_budget": 500,
|
|
"slots_remaining": {"P": max(0, 1 - i//30), "D": max(0, 3 - i//10),
|
|
"C": max(0, 4 - i//7), "A": max(0, 2 - i//15)},
|
|
"role_quotas": {"P": 3, "D": 8, "C": 8, "A": 6},
|
|
"slot_quotas": {"P": 3, "D": 8, "C": 8, "A": 6},
|
|
"round_number": i + 1,
|
|
"total_rounds": 30,
|
|
"opponent_budgets": [400, 350, 420],
|
|
"players_remaining_in_role": {"P": 15, "D": 50, "C": 50, "A": 30},
|
|
"player_pool": [pv],
|
|
}
|
|
arm, bid = bandit.select_bid(pv, state)
|
|
bandit.update(arm, 0.6, pv.role)
|
|
trial_bids.append({"player": pv.name, "role": pv.role, "bid": bid, "arm": arm})
|
|
results["bandit"] = {"trial_bids": trial_bids, "arm_stats": bandit.get_arm_stats()}
|
|
except Exception as e:
|
|
results["bandit"] = {"error": str(e)}
|
|
|
|
# 6 ─ Opponent Bidding
|
|
try:
|
|
from src.optimization.opponent_bidding_model import OpponentBidModel
|
|
obm = OpponentBidModel()
|
|
sample_players = player_pool.head(50).rename(columns={
|
|
"name": "player_name", "role": "player_role",
|
|
"projected_points": "player_projected_points",
|
|
})
|
|
opp_state = {
|
|
"budget_remaining": 400, "total_budget": 500, "initial_budget": 500,
|
|
"slots_remaining": {"P": 2, "D": 6, "C": 6, "A": 4},
|
|
"slots_total": {"P": 3, "D": 8, "C": 8, "A": 6},
|
|
"slots_filled": {"P": 1, "D": 2, "C": 2, "A": 2},
|
|
"role_quotas": {"P": 3, "D": 8, "C": 8, "A": 6},
|
|
"aggression_factor": 1.0,
|
|
}
|
|
bids = obm.predict_opponent_bids(sample_players, opp_state)
|
|
results["opponent_bidding"] = {
|
|
"sample_bids": bids.head(30).tolist(),
|
|
"players": sample_players["player_name"].head(30).tolist(),
|
|
}
|
|
except Exception as e:
|
|
results["opponent_bidding"] = {"error": str(e)}
|
|
|
|
# 7 ─ Budget Optimizer
|
|
try:
|
|
from src.optimization.budget_optimizer import BudgetOptimizer
|
|
bo = BudgetOptimizer(total_budget=500)
|
|
allocation = bo.optimize(player_pool, n_calls=15)
|
|
curves = bo.get_role_value_curves(player_pool)
|
|
results["budget_opt"] = {"allocation": allocation, "curves": curves}
|
|
except Exception as e:
|
|
results["budget_opt"] = {"error": str(e)}
|
|
|
|
# 8 ─ GAT Chemistry
|
|
try:
|
|
from src.models.gat_model import PlayerChemistryGAT
|
|
gat = PlayerChemistryGAT()
|
|
gat.build_graph(interaction_data)
|
|
top_players = player_pool.nlargest(6, "projected_points")["name"].tolist()
|
|
bonus_matrix = []
|
|
for p in top_players:
|
|
row = []
|
|
for q in top_players:
|
|
row.append(gat.compute_interaction_bonus(p, q))
|
|
bonus_matrix.append(row)
|
|
chem_features = gat.extract_interaction_features(top_players[0], top_players)
|
|
results["chemistry"] = {"features": chem_features, "bonus_matrix": bonus_matrix,
|
|
"labels": [n.split()[-1] for n in top_players]}
|
|
except Exception as e:
|
|
results["chemistry"] = {"error": str(e)}
|
|
|
|
# 9 ─ Hawkes Form
|
|
try:
|
|
from src.models.hawkes_form import PlayerFormModel
|
|
import importlib as _il
|
|
_self = _il.import_module('dashboard.pages.06_dev_preview')
|
|
vote_avg = _self._build_vote_features(pd.read_excel(DATA_ROOT / "mid_outputs" / "players_votes.xlsx"))
|
|
form_players = player_pool.head(30).copy()
|
|
form_players["name_lower"] = form_players["name"].str.lower()
|
|
vote_avg["name_lower"] = vote_avg["player"].str.lower()
|
|
form_merged = form_players.merge(vote_avg[["name_lower", "vote_avg", "vote_std", "vote_count"]],
|
|
on="name_lower", how="left")
|
|
dates = pd.date_range("2025-08-20", periods=len(form_merged), freq="7D")
|
|
form_data = pd.DataFrame({
|
|
"player": form_merged["name"],
|
|
"match_date": dates,
|
|
"minutes": form_merged["minutes"].fillna(60),
|
|
})
|
|
form_y = form_merged["projected_points"]
|
|
hf = PlayerFormModel()
|
|
hf.fit(form_data, form_y)
|
|
statuses = hf.get_form_status(form_data)
|
|
results["hawkes"] = {"players": form_merged["name"].tolist()[:15],
|
|
"statuses": {form_merged["name"].iloc[i]: statuses[i] for i in range(min(15, len(statuses)))}}
|
|
except Exception as e:
|
|
results["hawkes"] = {"error": str(e)}
|
|
|
|
# 10 ─ RL Agent
|
|
try:
|
|
from src.optimization.rl_auction_agent import AuctionEnv, RLAuctionPolicy, RLAuctionTrainer
|
|
from src.optimization.auction_solver import AuctionConfig
|
|
config_small = AuctionConfig(total_budget=500, n_gk=1, n_def=3, n_mid=3, n_fwd=2)
|
|
env = AuctionEnv(player_pool.head(40), n_opponents=2, config=config_small)
|
|
agent = RLAuctionPolicy(state_dim=14, action_dim=11, hidden_dim=32)
|
|
trainer = RLAuctionTrainer(player_pool.head(40), n_opponents=2, config=config_small)
|
|
agent = trainer.train(n_episodes=30, verbose=False)
|
|
rl_state = env.reset()
|
|
action = agent.act(rl_state, epsilon=0.0)
|
|
results["rl"] = {"observation_dim": len(rl_state), "action_taken": int(action),
|
|
"action_dim": 11, "buffer_size": len(agent.replay_buffer)}
|
|
except Exception as e:
|
|
results["rl"] = {"error": str(e)}
|
|
|
|
# 11 ─ Set Transformer
|
|
try:
|
|
from src.models.set_transformer import SetTransformer
|
|
rosters = _generate_team_rosters(player_pool, n_teams=6)
|
|
team_vals = [float(np.sum(r["projected_points"])) + np.random.normal(0, 5) for r in rosters]
|
|
stf = SetTransformer(use_torch=False)
|
|
stf.fit(rosters, team_vals)
|
|
base_val = stf.predict(rosters[0])
|
|
top_a = player_pool.nlargest(3, "projected_points")
|
|
new_p = top_a.head(1).copy()
|
|
added = stf.value_added(rosters[0], new_p)
|
|
redundancy = stf.get_redundancy_score(rosters[0])
|
|
results["set"] = {"base_value": float(base_val), "marginal_value": float(added),
|
|
"redundancy": float(redundancy)}
|
|
except Exception as e:
|
|
results["set"] = {"error": str(e)}
|
|
|
|
# 12 ─ Causal Forest
|
|
try:
|
|
from src.models.causal_forest import TransferCausalModel
|
|
Xc = player_pool.head(300)[["projected_points", "games_played", "starter_pct",
|
|
"goals_season", "assists_season"]].fillna(0).copy()
|
|
Xc["role"] = player_pool.head(300)["role"]
|
|
Xc["team_strength"] = np.random.uniform(0.5, 1.5, 300)
|
|
Tc = pd.DataFrame({
|
|
"role": player_pool.head(300)["role"],
|
|
"projected_points": player_pool.head(300)["projected_points"],
|
|
"days_since_last_transfer": np.random.randint(1, 30, 300),
|
|
})
|
|
Yc = pd.Series(np.random.randn(300) * 0.5 + player_pool.head(300)["projected_points"].values * 0.3)
|
|
cf = TransferCausalModel()
|
|
cf.fit(Xc, Tc, Yc)
|
|
result_causal = cf.predict_effect(Xc.head(10), Tc.head(10))
|
|
results["causal"] = {"ate": float(result_causal.get("ate", 0)),
|
|
"ate_lower": float(result_causal.get("ate_lower", -1)),
|
|
"ate_upper": float(result_causal.get("ate_upper", 1))}
|
|
except Exception as e:
|
|
results["causal"] = {"error": str(e)}
|
|
|
|
return results
|
|
|
|
|
|
# ─── Charts ─────────────────────────────────────────────────────────
|
|
|
|
def _chart_quantile(preds, risk, players):
|
|
fig = make_subplots(rows=1, cols=2, subplot_titles=("Quantile Predictions (Top 30)", "Downside Risk P(FV < 5.5)"))
|
|
n = min(30, len(players))
|
|
x = list(range(n))
|
|
fig.add_trace(go.Scatter(x=x, y=preds["P90"][:n], name="P90 (upside)",
|
|
line=dict(color=PITCH_GREEN, width=2, dash="dot"),
|
|
hovertext=players[:n]), row=1, col=1)
|
|
fig.add_trace(go.Scatter(x=x, y=preds["P50"][:n], name="P50 (median)",
|
|
line=dict(color=SKY, width=2.5),
|
|
hovertext=players[:n]), row=1, col=1)
|
|
fig.add_trace(go.Scatter(x=x, y=preds["P10"][:n], name="P10 (floor)",
|
|
line=dict(color=RED, width=2, dash="dot"),
|
|
fill="tonexty", fillcolor="rgba(255,77,94,0.08)"), row=1, col=1)
|
|
fig.add_trace(go.Histogram(x=risk, nbinsx=25, name="P(Vote < 5.5)",
|
|
marker_color=RED, opacity=0.7), row=1, col=2)
|
|
fig.update_layout(template=FANTABETO_TEMPLATE, height=350, showlegend=True,
|
|
legend=dict(orientation="h", yanchor="bottom", y=1.02))
|
|
fig.update_xaxes(title_text="Player (sorted by projection)", row=1, col=1)
|
|
fig.update_yaxes(title_text="Fantavoto", row=1, col=1)
|
|
fig.update_yaxes(title_text="Players", row=1, col=2)
|
|
return fig
|
|
|
|
|
|
def _chart_survival(expected, lower, upper, probs):
|
|
fig = make_subplots(rows=1, cols=2, subplot_titles=("Minutes Distribution (95% CI)", "Starter Probability P(≥60 min)"))
|
|
n = min(30, len(expected))
|
|
x = list(range(n))
|
|
fig.add_trace(go.Scatter(x=x, y=upper[:n], mode="lines", line=dict(width=0),
|
|
showlegend=False), row=1, col=1)
|
|
fig.add_trace(go.Scatter(x=x, y=lower[:n], mode="lines", fill="tonexty",
|
|
fillcolor="rgba(56,189,248,0.15)", line=dict(width=0),
|
|
name="95% CI"), row=1, col=1)
|
|
fig.add_trace(go.Scatter(x=x, y=expected[:n], mode="lines+markers",
|
|
line=dict(color=SKY, width=2.5),
|
|
marker=dict(size=4, color=SKY), name="Expected min"), row=1, col=1)
|
|
fig.add_trace(go.Scatter(x=x, y=[90]*n, mode="lines",
|
|
line=dict(color=TEXT_SECONDARY, width=0.5, dash="dash"),
|
|
name="Full 90"), row=1, col=1)
|
|
fig.add_trace(go.Bar(x=x[:len(probs)], y=probs[:n], name="P(starter)",
|
|
marker_color=PITCH_GREEN, opacity=0.8,
|
|
text=[f"{p:.0%}" for p in probs[:n]], textposition="outside",
|
|
textfont=dict(size=8)), row=1, col=2)
|
|
fig.add_hline(y=0.7, line=dict(color=GOLD, width=1, dash="dot"), row=1, col=2)
|
|
fig.update_layout(template=FANTABETO_TEMPLATE, height=350)
|
|
fig.update_xaxes(title_text="Player", row=1, col=1)
|
|
fig.update_yaxes(title_text="Minutes", range=[0, 95], row=1, col=1)
|
|
fig.update_yaxes(title_text="Probability", range=[0, 1.05], row=1, col=2)
|
|
return fig
|
|
|
|
|
|
def _chart_bayesian(mean, std, reliability, players):
|
|
fig = make_subplots(rows=1, cols=2, subplot_titles=("Bayesian Estimates ± Uncertainty", "Reliability Score (0-1)"))
|
|
n = min(30, len(mean))
|
|
x = list(range(n))
|
|
fig.add_trace(go.Scatter(
|
|
x=x, y=mean[:n], mode="markers",
|
|
error_y=dict(type="data", array=std[:n], visible=True, color=VIOLET, thickness=1.5),
|
|
marker=dict(size=7, color=VIOLET),
|
|
name="Bayesian estimate", hovertext=players[:n],
|
|
), row=1, col=1)
|
|
bar_colors = [PITCH_GREEN if r > 0.7 else (GOLD if r > 0.4 else RED) for r in reliability[:n]]
|
|
fig.add_trace(go.Bar(x=x, y=reliability[:n], marker_color=bar_colors, opacity=0.85,
|
|
name="Reliability", text=players[:n],
|
|
hovertemplate="%{text}: %{y:.3f}<extra></extra>"), row=1, col=2)
|
|
fig.update_layout(template=FANTABETO_TEMPLATE, height=350)
|
|
fig.update_xaxes(title_text="Player", row=1, col=1)
|
|
fig.update_yaxes(title_text="Fantavoto", row=1, col=1)
|
|
fig.update_yaxes(title_text="Score", range=[0, 1.05], row=1, col=2)
|
|
return fig
|
|
|
|
|
|
def _chart_conformal(preds, lowers, uppers, coverage):
|
|
n = min(15, len(preds))
|
|
x = list(range(n))
|
|
fig = go.Figure()
|
|
fig.add_trace(go.Scatter(x=x, y=uppers[:n], mode="lines", line=dict(width=0), showlegend=False))
|
|
fig.add_trace(go.Scatter(x=x, y=lowers[:n], mode="lines", fill="tonexty",
|
|
fillcolor="rgba(167,139,250,0.15)", line=dict(width=0),
|
|
name=f"{coverage*100:.0f}% band"))
|
|
fig.add_trace(go.Scatter(x=x, y=preds[:n], mode="lines+markers",
|
|
line=dict(color=VIOLET, width=2.5),
|
|
marker=dict(size=5, color=VIOLET), name="Prediction"))
|
|
fig.update_layout(template=FANTABETO_TEMPLATE, height=300)
|
|
fig.update_xaxes(title_text="Player (holdout)")
|
|
fig.update_yaxes(title_text="Fantavoto")
|
|
return fig
|
|
|
|
|
|
def _chart_bandit(trial_bids):
|
|
fig = make_subplots(rows=1, cols=2, subplot_titles=("Bandit Bidding Over Time", "Bid Distribution by Role"))
|
|
bids_by_role = {"P": [], "D": [], "C": [], "A": []}
|
|
for b in trial_bids:
|
|
bids_by_role.get(b["role"], []).append(b["bid"])
|
|
for role in ["P", "D", "C", "A"]:
|
|
if bids_by_role[role]:
|
|
y = bids_by_role[role]
|
|
fig.add_trace(go.Scatter(
|
|
x=list(range(len(y))), y=y, mode="lines+markers",
|
|
name=f"{ROLE_ICONS[role]} {role}",
|
|
line=dict(color=ROLE_COLORS.get(role, SKY), width=1.8),
|
|
marker=dict(size=4, color=ROLE_COLORS.get(role, SKY)),
|
|
), row=1, col=1)
|
|
for role in ["P", "D", "C", "A"]:
|
|
if bids_by_role[role]:
|
|
fig.add_trace(go.Box(y=bids_by_role[role], name=f"{role}",
|
|
marker_color=ROLE_COLORS.get(role, SKY)), row=1, col=2)
|
|
fig.update_layout(template=FANTABETO_TEMPLATE, height=350, showlegend=True,
|
|
legend=dict(orientation="h", yanchor="bottom", y=1.02))
|
|
fig.update_xaxes(title_text="Bid #", row=1, col=1)
|
|
fig.update_yaxes(title_text="Bid (cr)", row=1, col=1)
|
|
return fig
|
|
|
|
|
|
def _chart_opponent_bids(bids, players):
|
|
if not bids:
|
|
return go.Figure()
|
|
n = min(30, len(bids), len(players))
|
|
fig = go.Figure(data=[go.Bar(
|
|
x=players[:n], y=bids[:n], marker_color=SKY, opacity=0.8,
|
|
text=[f"{b:.0f}" for b in bids[:n]], textposition="outside",
|
|
)])
|
|
fig.update_layout(template=FANTABETO_TEMPLATE, height=280)
|
|
fig.update_xaxes(title_text="Player", tickangle=-45, tickfont=dict(size=9))
|
|
fig.update_yaxes(title_text="Predicted Opponent Bid (cr)")
|
|
return fig
|
|
|
|
|
|
def _chart_budget_opt(allocation):
|
|
labels = list(allocation.keys())
|
|
values = list(allocation.values())
|
|
colors_list = [ROLE_COLORS.get(r, SKY) for r in labels]
|
|
fig = go.Figure(data=[go.Pie(
|
|
labels=labels, values=values, hole=0.5,
|
|
marker_colors=colors_list, textinfo="label+value",
|
|
texttemplate="%{label}: %{value:.0f} cr",
|
|
)])
|
|
fig.update_layout(template=FANTABETO_TEMPLATE, height=300)
|
|
return fig
|
|
|
|
|
|
def _chart_chemistry(bonus_matrix, labels):
|
|
fig = go.Figure(data=go.Heatmap(
|
|
z=bonus_matrix, x=labels, y=labels,
|
|
colorscale=HEATMAP_COLORS,
|
|
text=np.round(bonus_matrix, 3),
|
|
texttemplate="%{text}",
|
|
textfont=dict(size=9),
|
|
zmin=0, zmax=1,
|
|
))
|
|
fig.update_layout(template=FANTABETO_TEMPLATE, height=300,
|
|
xaxis=dict(side="top"), yaxis=dict(autorange="reversed"))
|
|
return fig
|
|
|
|
|
|
def _chart_hawkes(statuses):
|
|
labels = list(statuses.keys())
|
|
vals = list(statuses.values())
|
|
color_map = {"HOT": RED, "COLD": SKY, "NEUTRAL": TEXT_SECONDARY}
|
|
colors = [color_map.get(v, TEXT_SECONDARY) for v in vals]
|
|
fig = go.Figure(data=[go.Bar(x=[l.split()[-1] for l in labels], y=[1]*len(labels),
|
|
marker_color=colors, text=vals, textposition="auto",
|
|
textfont=dict(color=WHITE, size=11))])
|
|
fig.update_layout(template=FANTABETO_TEMPLATE, height=200,
|
|
showlegend=False, yaxis=dict(showticklabels=False))
|
|
return fig
|
|
|
|
|
|
# ─── Main page ──────────────────────────────────────────────────────
|
|
|
|
def run():
|
|
inject_css()
|
|
|
|
st.markdown("## 🔬 Dev Preview — 12 ML Models on Real 26/27 Serie A Data")
|
|
st.caption("Models trained on 505 players, 2,000+ historical votes, 161 FBref features.")
|
|
|
|
# Load data
|
|
with st.spinner("Loading real Serie A data...", show_time=True):
|
|
projections, stats, votes, roster, auction_plan = _load_real_data()
|
|
player_pool = _build_rich_player_pool(projections, stats)
|
|
|
|
with st.spinner("Building interaction graph & generating training data...", show_time=True):
|
|
interaction_data = _generate_interaction_data(player_pool)
|
|
auction_logs = _generate_auction_logs(player_pool)
|
|
|
|
with st.spinner("Training 12 ML models (this takes ~10s)...", show_time=True):
|
|
results = _init_models(player_pool, interaction_data, auction_logs)
|
|
|
|
st.divider()
|
|
|
|
# ── Header KPIs ──
|
|
k1, k2, k3, k4, k5, k6 = st.columns(6)
|
|
phases_ok = sum(1 for v in results.values() if isinstance(v, dict) and "error" not in v)
|
|
with k1:
|
|
st.markdown(kpi_card("MODELS ACTIVE", f"{phases_ok}/12", "12 ML models", PITCH_GREEN), unsafe_allow_html=True)
|
|
with k2:
|
|
st.markdown(kpi_card("PLAYERS", str(len(player_pool)), "Serie A 26/27", SKY), unsafe_allow_html=True)
|
|
with k3:
|
|
top_fv = player_pool["projected_points"].max()
|
|
top_name = player_pool.loc[player_pool["projected_points"].idxmax(), "name"]
|
|
st.markdown(kpi_card("TOP PROJ FV", f"{top_fv:.2f}", top_name, GOLD), unsafe_allow_html=True)
|
|
with k4:
|
|
st.markdown(kpi_card("FEATURES", str(161), "FBref + Fantacalcio", VIOLET), unsafe_allow_html=True)
|
|
with k5:
|
|
st.markdown(kpi_card("HISTORICAL VOTES", f"{len(votes):,}", "matchday records", PITCH_GREEN),
|
|
unsafe_allow_html=True)
|
|
with k6:
|
|
cf_ate = results.get("causal", {}).get("ate", 0)
|
|
st.markdown(kpi_card("CAUSAL ATE", f"{cf_ate:+.3f}", "transfer effect", GOLD), unsafe_allow_html=True)
|
|
|
|
st.divider()
|
|
|
|
# ── Live Auction Simulator ──
|
|
st.markdown("### 🎮 Live Auction Simulator")
|
|
st.caption("Real players, real projections. Simulate a bidding round with bandit + opponent models.")
|
|
|
|
col_sim1, col_sim2, col_sim3 = st.columns(3)
|
|
with col_sim1:
|
|
role_filter = st.selectbox("Filter by Role", ["All", "P", "D", "C", "A"])
|
|
with col_sim2:
|
|
sim_budget = st.slider("Your Budget (cr)", 50, 500, 400, step=10)
|
|
with col_sim3:
|
|
filtered_pool = player_pool if role_filter == "All" else player_pool[player_pool["role"] == role_filter]
|
|
top_players = filtered_pool.nlargest(100, "projected_points")["name"].tolist()
|
|
sim_player = st.selectbox("Target Player", top_players[:50] if len(top_players) > 50 else top_players)
|
|
|
|
if st.button("🎯 Simulate Bid Decision", type="primary"):
|
|
try:
|
|
from src.optimization.bandit_auction import BanditAuctionSolver
|
|
from src.optimization.auction_solver import AuctionConfig, PlayerValuation
|
|
from src.optimization.opponent_bidding_model import OpponentBidModel
|
|
from src.optimization.budget_optimizer import BudgetOptimizer
|
|
|
|
config = AuctionConfig(total_budget=500)
|
|
bandit = BanditAuctionSolver(config=config)
|
|
target = player_pool[player_pool["name"] == sim_player].iloc[0]
|
|
|
|
qe_result = results.get("quantile", {})
|
|
if "preds" in qe_result:
|
|
try:
|
|
idx = qe_result["players"].index(sim_player)
|
|
p10 = qe_result["preds"]["P10"][idx]
|
|
p50 = qe_result["preds"]["P50"][idx]
|
|
p90 = qe_result["preds"]["P90"][idx]
|
|
except (ValueError, IndexError, KeyError):
|
|
pt = target["projected_points"]
|
|
p10, p50, p90 = pt * 0.85, pt, pt * 1.15
|
|
else:
|
|
pt = target["projected_points"]
|
|
p10, p50, p90 = pt * 0.85, pt, pt * 1.15
|
|
|
|
pv = PlayerValuation(
|
|
name=target["name"], team=target["team"], role=target["role"],
|
|
projected_points=float(target["projected_points"]),
|
|
market_value=float(target["market_value"]),
|
|
ceiling_price=float(target["projected_points"] * 5),
|
|
)
|
|
|
|
state = {
|
|
"budget_remaining": sim_budget,
|
|
"total_budget": 500,
|
|
"slots_remaining": {"P": 1, "D": 3, "C": 4, "A": 2},
|
|
"role_quotas": {"P": 3, "D": 8, "C": 8, "A": 6},
|
|
"slot_quotas": {"P": 3, "D": 8, "C": 8, "A": 6},
|
|
"round_number": 4,
|
|
"total_rounds": 20,
|
|
"opponent_budgets": [sim_budget - 20, sim_budget + 10, sim_budget - 50],
|
|
"players_remaining_in_role": {"P": 15, "D": 50, "C": 50, "A": 30},
|
|
"player_pool": [pv],
|
|
}
|
|
|
|
arm_idx, bandit_bid = bandit.select_bid(pv, state)
|
|
|
|
obm = OpponentBidModel()
|
|
bid_row = pd.DataFrame([{
|
|
"player_name": target["name"], "player_role": target["role"],
|
|
"player_projected_points": target["projected_points"],
|
|
}])
|
|
opp_state_full = {
|
|
"budget_remaining": sim_budget, "total_budget": 500, "initial_budget": 500,
|
|
"slots_total": {"P": 3, "D": 8, "C": 8, "A": 6},
|
|
"slots_filled": {"P": 1, "D": 2, "C": 2, "A": 2},
|
|
"slots_remaining": {"P": 2, "D": 6, "C": 6, "A": 4},
|
|
"role_quotas": {"P": 3, "D": 8, "C": 8, "A": 6},
|
|
"aggression_factor": 1.0,
|
|
}
|
|
opp_bid = float(obm.predict_opponent_bids(bid_row, opp_state_full).values[0])
|
|
|
|
bo = BudgetOptimizer(total_budget=500)
|
|
role_budget = bo.optimize(player_pool.head(100), n_calls=5)
|
|
role_rec = role_budget.get(target["role"], 50)
|
|
|
|
win_pct = bandit_bid / max(bandit_bid + opp_bid, 1) * 100
|
|
risk_label = "LOW" if p10 > 5.5 else ("MED" if p10 > 4.5 else "HIGH")
|
|
risk_color = PITCH_GREEN if risk_label == "LOW" else (GOLD if risk_label == "MED" else RED)
|
|
|
|
with st.container():
|
|
st.markdown("### 📊 Bid Decision")
|
|
|
|
kd1, kd2, kd3, kd4, kd5 = st.columns(5)
|
|
with kd1:
|
|
bid_color = PITCH_GREEN if bandit_bid > opp_bid else RED
|
|
st.markdown(kpi_card("ML BID", f"{bandit_bid} cr",
|
|
f"Opp ~{opp_bid:.0f} cr", bid_color),
|
|
unsafe_allow_html=True)
|
|
with kd2:
|
|
st.markdown(kpi_card("WIN PROB", f"{min(win_pct, 95):.0f}%",
|
|
"", GOLD), unsafe_allow_html=True)
|
|
with kd3:
|
|
st.markdown(kpi_card("PROJECTION", f"{p50:.2f}",
|
|
f"P10:{p10:.1f} P90:{p90:.1f}", SKY),
|
|
unsafe_allow_html=True)
|
|
with kd4:
|
|
st.markdown(kpi_card("ROLE BUDGET", f"{role_rec:.0f} cr",
|
|
f"{target['role']} allocation", VIOLET),
|
|
unsafe_allow_html=True)
|
|
with kd5:
|
|
st.markdown(kpi_card("RISK", risk_label,
|
|
f"VaR floor: {p10:.1f}", risk_color),
|
|
unsafe_allow_html=True)
|
|
|
|
value_ratio = target["projected_points"] / max(bandit_bid, 1)
|
|
if bandit_bid > opp_bid:
|
|
insight(f"🟢 **BUY** — Bandit recommends {bandit_bid}cr for **{target['name']}** "
|
|
f"({ROLE_ICONS.get(target['role'], '')} {target['team']}, FV {target['projected_points']:.2f}). "
|
|
f"Expected to beat opponent ~{opp_bid:.0f}cr. Value: {value_ratio:.3f} FV/cr.")
|
|
else:
|
|
insight(f"🔴 **PASS** — Opponent likely bids higher (~{opp_bid:.0f}cr). "
|
|
f"Consider a budget reallocation or targeting an alternative in the {target['role']} role.")
|
|
except Exception as e:
|
|
st.error(f"Simulation error: {e}")
|
|
|
|
st.divider()
|
|
|
|
# ── Phase tabs ──
|
|
tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs([
|
|
"⚡ Phase 1: Quantile & Survival",
|
|
"🎰 Phase 2: Adaptive Auction",
|
|
"🧠 Phase 3: RL & Set Transformer",
|
|
"📊 Phase 4: Bayesian & Conformal",
|
|
"🔗 Phase 5: Chemistry & Form",
|
|
"🔬 Phase 6: Causal Inference",
|
|
])
|
|
|
|
with tab1:
|
|
section("⚡ Quantile Ensemble — Risk-Aware Projections")
|
|
q = results.get("quantile", {})
|
|
if "error" in q:
|
|
st.warning(q["error"])
|
|
else:
|
|
fig = _chart_quantile(q["preds"], q["risk"], q.get("players", []))
|
|
st.plotly_chart(fig, width="stretch")
|
|
insight("P10/P50/P90 predictions on top 60 Serie A players. "
|
|
"The downside risk histogram shows how many players risk scoring below 5.5 — "
|
|
"critical for avoiding zero-score matchdays.")
|
|
|
|
section("⏱ Minutes Survival Model — Playing Time Distribution")
|
|
s = results.get("survival", {})
|
|
if "error" in s:
|
|
st.warning(s["error"])
|
|
else:
|
|
fig = _chart_survival(s["expected"], s["lower"], s["upper"], s["starter_probs"])
|
|
st.plotly_chart(fig, width="stretch")
|
|
insight("Weibull AFT trained on real minutes data. Wide confidence bands on players "
|
|
"with irregular playing patterns. Starter probability < 70% = auction risk flag.")
|
|
|
|
with tab2:
|
|
section("🎰 Thompson Sampling — Live Auction Strategy")
|
|
b = results.get("bandit", {})
|
|
if "error" in b:
|
|
st.warning(b["error"])
|
|
else:
|
|
fig = _chart_bandit(b["trial_bids"])
|
|
st.plotly_chart(fig, width="stretch")
|
|
insight("Bandit learns bid amounts interactively. Forwards get higher bids; "
|
|
"exploration bonus encourages discovering undervalued players early in auction.")
|
|
|
|
section("💰 Opponent Bidding Model")
|
|
ob = results.get("opponent_bidding", {})
|
|
if "error" in ob:
|
|
st.warning(ob["error"])
|
|
else:
|
|
fig = _chart_opponent_bids(ob["sample_bids"], ob.get("players", []))
|
|
st.plotly_chart(fig, width="stretch")
|
|
insight("LightGBM predicts competitor max bids from role, scarcity, and player quality. "
|
|
"Don't overpay when nobody wants the player.")
|
|
|
|
section("📐 Bayesian Budget Optimization")
|
|
bo_r = results.get("budget_opt", {})
|
|
if "error" in bo_r:
|
|
st.warning(bo_r["error"])
|
|
else:
|
|
fig = _chart_budget_opt(bo_r["allocation"])
|
|
st.plotly_chart(fig, width="stretch")
|
|
insight("GP optimization finds optimal budget split across GK/DEF/MID/FWD roles "
|
|
"based on the real player pool's value distribution. Adapts to market quality.")
|
|
|
|
with tab3:
|
|
section("🧠 Double DQN Auction Agent")
|
|
rl = results.get("rl", {})
|
|
if "error" in rl:
|
|
st.warning(rl["error"])
|
|
else:
|
|
rk1, rk2, rk3 = st.columns(3)
|
|
with rk1:
|
|
st.markdown(kpi_card("STATE DIM", str(rl["observation_dim"]), "features", SKY),
|
|
unsafe_allow_html=True)
|
|
with rk2:
|
|
st.markdown(kpi_card("ACTIONS", str(rl["action_dim"]), "bid levels", GOLD),
|
|
unsafe_allow_html=True)
|
|
with rk3:
|
|
st.markdown(kpi_card("REPLAY", str(rl["buffer_size"]), "experiences", VIOLET),
|
|
unsafe_allow_html=True)
|
|
insight("RL agent trained on 30 simulated auctions. Learns to hold budget for later "
|
|
"rounds when high-value players typically appear. 5000+ episode training recommended.")
|
|
|
|
section("🧩 Set Transformer — Team Composition Value")
|
|
sf = results.get("set", {})
|
|
if "error" in sf:
|
|
st.warning(sf["error"])
|
|
else:
|
|
sk1, sk2, sk3 = st.columns(3)
|
|
with sk1:
|
|
st.markdown(kpi_card("TEAM VALUE", f"{sf['base_value']:.0f} PTS",
|
|
"set-based estimate", SKY), unsafe_allow_html=True)
|
|
with sk2:
|
|
dc = PITCH_GREEN if sf["marginal_value"] > 0 else RED
|
|
st.markdown(kpi_card("MARGINAL Δ", f"{sf['marginal_value']:+.1f}",
|
|
"add 1 player", dc), unsafe_allow_html=True)
|
|
with sk3:
|
|
rc = PITCH_GREEN if sf["redundancy"] < 0.5 else GOLD
|
|
st.markdown(kpi_card("REDUNDANCY", f"{sf['redundancy']:.2f}",
|
|
"0=diverse 1=overlap", rc), unsafe_allow_html=True)
|
|
|
|
with tab4:
|
|
section("📊 Bayesian Hierarchical Pooling")
|
|
bp = results.get("bayesian", {})
|
|
if "error" in bp:
|
|
st.warning(bp["error"])
|
|
else:
|
|
fig = _chart_bayesian(bp["mean"], bp["std"], bp["reliability"],
|
|
bp.get("players", []))
|
|
st.plotly_chart(fig, width="stretch")
|
|
insight("Players with < 10 matches get heavy shrinkage toward role mean. "
|
|
"Low reliability = don't pay premium for unproven talent.")
|
|
|
|
section("🎯 Conformal Prediction — Calibrated Bands")
|
|
cp_r = results.get("conformal", {})
|
|
if "error" in cp_r:
|
|
st.warning(cp_r["error"])
|
|
else:
|
|
fig = _chart_conformal(cp_r["predictions"], cp_r["lowers"],
|
|
cp_r["uppers"], cp_r["coverage"])
|
|
st.plotly_chart(fig, width="stretch")
|
|
insight(f"Conformal coverage: {cp_r['coverage']*100:.0f}% on 20 holdout players. "
|
|
"Model-agnostic, no distributional assumptions needed — just works with any underlying predictor.")
|
|
|
|
with tab5:
|
|
section("🔗 Graph Attention Network — Player Chemistry")
|
|
ch = results.get("chemistry", {})
|
|
if "error" in ch:
|
|
st.warning(ch["error"])
|
|
else:
|
|
fig = _chart_chemistry(ch["bonus_matrix"], ch.get("labels", []))
|
|
st.plotly_chart(fig, width="stretch")
|
|
insight("Pairwise chemistry from synthetic pass/assist/cross networks. Higher values = "
|
|
"stronger link between players on the same team. Target linked pairs in auction.")
|
|
|
|
section("🔥 Hawkes Process — Form Momentum")
|
|
hf_r = results.get("hawkes", {})
|
|
if "error" in hf_r:
|
|
st.warning(hf_r["error"])
|
|
else:
|
|
fig = _chart_hawkes(hf_r["statuses"])
|
|
st.plotly_chart(fig, width="stretch")
|
|
insight("HOT = positive momentum (buy window open), COLD = negative drift (wait), "
|
|
"NEUTRAL = baseline. Self-exciting process captures temporary scoring bursts.")
|
|
|
|
with tab6:
|
|
section("🔬 Causal Forest — Transfer Effects")
|
|
cf = results.get("causal", {})
|
|
if "error" in cf:
|
|
st.warning(cf["error"])
|
|
else:
|
|
ck1, ck2, ck3 = st.columns(3)
|
|
with ck1:
|
|
c = PITCH_GREEN if cf["ate"] > 0 else RED
|
|
st.markdown(kpi_card("ATE", f"{cf['ate']:+.4f}", "avg tx effect", c),
|
|
unsafe_allow_html=True)
|
|
with ck2:
|
|
st.markdown(kpi_card("CI LOWER", f"{cf['ate_lower']:+.4f}", "95%", TEXT_SECONDARY),
|
|
unsafe_allow_html=True)
|
|
with ck3:
|
|
st.markdown(kpi_card("CI UPPER", f"{cf['ate_upper']:+.4f}", "95%", TEXT_SECONDARY),
|
|
unsafe_allow_html=True)
|
|
insight("Causal inference separates true player impact from confounding (team, schedule, luck). "
|
|
"Adding a highly-projected player doesn't always improve team score when controlling for roster fit.")
|
|
|
|
# ── Auction Plan reference ──
|
|
st.divider()
|
|
section("📋 Reference: Existing Al-Cihred Auction Plan (25 players)")
|
|
st.dataframe(
|
|
auction_plan[["player", "team", "role", "bid_cap", "fv_proj", "games", "starter%"]]
|
|
.rename(columns={"starter%": "start_pct"})
|
|
.style.background_gradient(subset=["fv_proj", "bid_cap"], cmap="viridis"),
|
|
height=600, width="stretch",
|
|
)
|
|
insight("25-player squad from the MILP solver. Use new ML models above to refine bids and alternatives.")
|
|
|
|
st.divider()
|
|
with st.expander("⚙️ Methodology — 12 Models on Real Data"):
|
|
st.markdown("""
|
|
| # | Model | Data Used |
|
|
|---|-------|----------|
|
|
| 1 | QuantileEnsemble | 505 player projections, 161 FBref features |
|
|
| 2 | MinutesSurvivalModel | Real minutes played, starter percentages |
|
|
| 3 | BanditAuctionSolver | Real QI/QA/FVM prices, projected FV |
|
|
| 4 | OpponentBidModel | QI-based pricing, role scarcity from roster |
|
|
| 5 | BudgetOptimizer | Real pool value distribution |
|
|
| 6 | PlayerChemistryGAT | 800 synthetic pass/assist/cross edges |
|
|
| 7 | PlayerFormModel | 2,021 historical matchday votes |
|
|
| 8 | BayesianPlayerModel | Per-role shrinkage on 200 players |
|
|
| 9 | ConformalPredictor | 300-player holdout calibration |
|
|
| 10 | SetTransformer | 6 synthetic teams of 25 real players each |
|
|
| 11 | RLAuctionPolicy | 30-episode training on real player pool |
|
|
| 12 | TransferCausalModel | 300-player causal forest |
|
|
""", unsafe_allow_html=False)
|
|
|
|
st.divider()
|
|
st.caption(f"Real data: {len(player_pool)} Serie A 26/27 players · {len(votes):,} historical votes · "
|
|
f"FBref stats · Fantacalcio.it QI/QA/FVM · Project Al-Cihred auction plan")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
run()
|