predictor / services /model /simulate.py
pengpeng9099's picture
Deploy World Cup 2026 Predictor (docker space)
1790bde verified
Raw History Blame Contribute Delete
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}%")