Spaces:
Running
Running
Download services/model/simulate.py from 2026worldcup/predictor: direct link, hf CLI and curl.
- Browser
- Download file 8.91 kB
-
https://huggingface.co/spaces/2026worldcup/predictor/resolve/main/services/model/simulate.py
- Command line
-
hf download hf://spaces/2026worldcup/predictor/services/model/simulate.py
-
curl -L -o simulate.py https://huggingface.co/spaces/2026worldcup/predictor/resolve/main/services/model/simulate.py
8.91 kB
| """Monte-Carlo simulation of the 2026 World Cup under the real 48-team format. | |
| Group stage scorelines are sampled from the Dixon-Coles joint grid; group | |
| standings use FIFA tiebreakers (points, GD, GF). The 8 best third-placed teams | |
| are selected and allocated to bracket slots via Annex-C cluster matching; the | |
| fixed single-elimination bracket is then played out, with draws in knockout | |
| matches resolved in proportion to regulation win strength (ET/penalties).""" | |
| from __future__ import annotations | |
| import json | |
| import time | |
| import networkx as nx | |
| import numpy as np | |
| import config | |
| from db import connect | |
| import bracket as B | |
| from wcmodel import WorldCupModel, load_training_frame | |
| # ---------------------------------------------------------------- caches | |
| def build_caches(model: WorldCupModel, groups: dict[str, list[str]]): | |
| """Precompute group-stage scoreline samplers and a knockout win matrix.""" | |
| teams = sorted({t for ts in groups.values() for t in ts}) | |
| idx = {t: i for i, t in enumerate(teams)} | |
| n = len(teams) | |
| with connect() as conn: | |
| fixtures = conn.execute( | |
| "SELECT home_team,away_team,neutral FROM matches " | |
| "WHERE stage='group' ORDER BY date,id" | |
| ).fetchall() | |
| # group-stage fixtures -> flattened cumulative distribution over scorelines | |
| gs = [] | |
| for f in fixtures: | |
| g = model.predict_grid(f["home_team"], f["away_team"], neutral=bool(f["neutral"])) | |
| grid = np.asarray(g.grid) | |
| flat = grid.ravel() | |
| flat = flat / flat.sum() | |
| gs.append((f["home_team"], f["away_team"], np.cumsum(flat), grid.shape[1])) | |
| # knockout: advance-probability matrix (neutral venue), team i beats team j | |
| adv = np.zeros((n, n)) | |
| for a in teams: | |
| for b in teams: | |
| if a == b: | |
| continue | |
| g = model.predict_grid(a, b, neutral=True) | |
| ph, pdr, pa = (float(x) for x in g.home_draw_away) | |
| denom = ph + pa | |
| adv[idx[a], idx[b]] = ph + (pdr * ph / denom if denom > 0 else 0.5 * pdr) | |
| return teams, idx, gs, adv | |
| # ---------------------------------------------------------------- one sim | |
| def _rank(table: dict) -> list[str]: | |
| """Sort teams by points, goal difference, goals for, then random jitter.""" | |
| return sorted( | |
| table, | |
| key=lambda t: (table[t]["pts"], table[t]["gd"], table[t]["gf"], table[t]["r"]), | |
| reverse=True, | |
| ) | |
| def _assign_thirds(third_groups: list[str], rng) -> dict[int, str]: | |
| """Match the 8 qualified third-place groups to the 8 bracket slots so each | |
| lands in an Annex-C-permitted cluster (bipartite maximum matching).""" | |
| G = nx.Graph() | |
| slots = list(B.THIRD_SLOTS) | |
| for mid in slots: | |
| G.add_node(("slot", mid)) | |
| for grp in third_groups: | |
| G.add_node(("grp", grp)) | |
| for mid in slots: | |
| if grp in B.THIRD_SLOTS[mid]: | |
| G.add_edge(("grp", grp), ("slot", mid)) | |
| m = nx.bipartite.maximum_matching(G, top_nodes={("grp", g) for g in third_groups}) | |
| return {mid: m[("slot", mid)][1] for mid in slots if ("slot", mid) in m} | |
| def simulate_once(groups, idx, gs, adv, rng) -> tuple[dict, str]: | |
| # ---- group stage ---- | |
| tables = {g: {t: {"pts": 0, "gf": 0, "ga": 0, "gd": 0, "r": rng.random()} | |
| for t in ts} for g, ts in groups.items()} | |
| team_group = {t: g for g, ts in groups.items() for t in ts} | |
| ncol = gs[0][3] | |
| for home, away, cum, _nc in gs: | |
| k = int(np.searchsorted(cum, rng.random())) | |
| hs, as_ = divmod(k, ncol) | |
| g = team_group[home] | |
| th, ta = tables[g][home], tables[g][away] | |
| th["gf"] += hs; th["ga"] += as_; ta["gf"] += as_; ta["ga"] += hs | |
| if hs > as_: | |
| th["pts"] += 3 | |
| elif hs < as_: | |
| ta["pts"] += 3 | |
| else: | |
| th["pts"] += 1; ta["pts"] += 1 | |
| for g in tables: | |
| for t in tables[g]: | |
| tables[g][t]["gd"] = tables[g][t]["gf"] - tables[g][t]["ga"] | |
| winners, runners, thirds = {}, {}, [] | |
| reached = {} # team -> furthest stage code | |
| for g, tbl in tables.items(): | |
| order = _rank(tbl) | |
| winners[g], runners[g] = order[0], order[1] | |
| thirds.append((g, order[2], tbl[order[2]])) | |
| for t in order: | |
| reached[t] = "group" | |
| # best 8 third-placed teams | |
| thirds.sort(key=lambda x: (x[2]["pts"], x[2]["gd"], x[2]["gf"], x[2]["r"]), reverse=True) | |
| best8 = thirds[:8] | |
| third_team_of_group = {g: t for g, t, _ in best8} | |
| slot_group = _assign_thirds([g for g, _, _ in best8], rng) | |
| third_for_slot = {mid: third_team_of_group[slot_group[mid]] for mid in slot_group} | |
| # ---- resolve R32 entrants ---- | |
| def resolve(slot): | |
| kind, val = slot | |
| if kind == "W": | |
| return winners[val] | |
| if kind == "RU": | |
| return runners[val] | |
| return None # third slots filled below | |
| qualified = set() | |
| match_team = {} | |
| for mid, (sa, sb) in B.R32.items(): | |
| ta = resolve(sa) | |
| tb = resolve(sb) if sb[0] != "3" else third_for_slot[mid] | |
| match_team[mid] = [ta, tb] | |
| qualified.update([ta, tb]) | |
| for t in qualified: | |
| reached[t] = "R32" | |
| # ---- play knockout bracket ---- | |
| def play(mid): | |
| ta, tb = match_team[mid] | |
| pa = adv[idx[ta], idx[tb]] | |
| winner = ta if rng.random() < pa else tb | |
| return winner | |
| # R32 | |
| r32_winners = {mid: play(mid) for mid in B.R32} | |
| for w in r32_winners.values(): | |
| reached[w] = "R16" | |
| # subsequent rounds use FEED | |
| winners_by_match = dict(r32_winners) | |
| next_stage_code = {"R16": "QF", "QF": "SF", "SF": "F", "F": "champion"} | |
| for mid in (89, 90, 91, 92, 93, 94, 95, 96, | |
| 97, 98, 99, 100, 101, 102, 104): | |
| a, b = B.FEED[mid] | |
| match_team[mid] = [winners_by_match[a], winners_by_match[b]] | |
| w = play(mid) | |
| winners_by_match[mid] = w | |
| reached[w] = next_stage_code[B.STAGE_OF[mid]] | |
| champion = winners_by_match[104] | |
| return reached, champion, winners | |
| # ---------------------------------------------------------------- aggregate | |
| STAGES = ["group", "R32", "R16", "QF", "SF", "F", "champion"] | |
| # cumulative "reached at least" mapping | |
| REACH_AT_LEAST = { | |
| "p_advance": ["R32", "R16", "QF", "SF", "F", "champion"], | |
| "p_r16": ["R16", "QF", "SF", "F", "champion"], | |
| "p_qf": ["QF", "SF", "F", "champion"], | |
| "p_sf": ["SF", "F", "champion"], | |
| "p_final": ["F", "champion"], | |
| "p_win": ["champion"], | |
| } | |
| def run(n_sims: int = 20000, seed: int = 12345) -> dict: | |
| groups = json.loads((config.PROCESSED / "groups.json").read_text(encoding="utf-8")) | |
| model = WorldCupModel.load() | |
| teams, idx, gs, adv = build_caches(model, groups) | |
| rng = np.random.default_rng(seed) | |
| counts = {t: {k: 0 for k in REACH_AT_LEAST} for t in teams} | |
| group_win = {t: 0 for t in teams} | |
| t0 = time.time() | |
| for _ in range(n_sims): | |
| reached, champ, winners = simulate_once(groups, idx, gs, adv, rng) | |
| for w in winners.values(): | |
| group_win[w] += 1 | |
| for t, st in reached.items(): | |
| for key, ok in REACH_AT_LEAST.items(): | |
| if st in ok: | |
| counts[t][key] += 1 | |
| dt = time.time() - t0 | |
| team_group = {t: g for g, ts in groups.items() for t in ts} | |
| results = [] | |
| for t in teams: | |
| c = counts[t] | |
| results.append({ | |
| "team": t, "group": team_group[t], | |
| "p_group_win": round(group_win[t] / n_sims, 4), | |
| "p_advance": round(c["p_advance"] / n_sims, 4), | |
| "p_r16": round(c["p_r16"] / n_sims, 4), | |
| "p_qf": round(c["p_qf"] / n_sims, 4), | |
| "p_sf": round(c["p_sf"] / n_sims, 4), | |
| "p_final": round(c["p_final"] / n_sims, 4), | |
| "p_win": round(c["p_win"] / n_sims, 4), | |
| }) | |
| results.sort(key=lambda r: r["p_win"], reverse=True) | |
| print(f"{n_sims} sims in {dt:.1f}s ({n_sims/dt:.0f}/s)") | |
| return {"n_sims": n_sims, "results": results} | |
| def store(sim: dict, run_id: int) -> None: | |
| with connect() as conn: | |
| conn.execute("DELETE FROM simulations WHERE run_id=?", (run_id,)) | |
| conn.executemany( | |
| """INSERT INTO simulations(run_id,team,group_label,p_group_win, | |
| p_advance,p_r16,p_qf,p_sf,p_final,p_win,exp_points) | |
| VALUES(?,?,?,?,?,?,?,?,?,?,?)""", | |
| [(run_id, r["team"], r["group"], r["p_group_win"], r["p_advance"], | |
| r["p_r16"], r["p_qf"], r["p_sf"], r["p_final"], r["p_win"], 0.0) | |
| for r in sim["results"]], | |
| ) | |
| if __name__ == "__main__": | |
| import sys | |
| n = int(sys.argv[1]) if len(sys.argv) > 1 else 20000 | |
| out = run(n) | |
| print("\nTitle odds (top 12):") | |
| for r in out["results"][:12]: | |
| print(f" {r['team']:<16} {r['group']} win={r['p_win']*100:5.2f}% " | |
| f"final={r['p_final']*100:5.1f}% adv={r['p_advance']*100:5.1f}%") | |