fahricansecer/iddaai-be
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wow
Deploy Iddaai Backend / build-and-deploy (push) Successful in 1m7s
Details

Browse Source
This commit is contained in:
Fahri Can Seçer
2026-06-11 00:25:45 +03:00
parent bb911176df
commit 4c137fbab6
9 changed files with 1246 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ai-engine/config/market_anchor_corrections.json
+131
View File
@@ -0,0 +1,131 @@
{
"version": "2026-06-10T23:11:49",
"fitted_on": {
"days": 540,
"test_days": 90,
"n_train": 64603,
"n_test": 14450
},
"validated": {
"ece_home": {
"raw": 0.01803,
"active_before": 0.01312,
"candidate_oos": 0.01301
},
"ece_away": {
"raw": 0.01234,
"active_before": 0.01234,
"candidate_oos": 0.00845
}
},
"gates": {
"min_n": 1500,
"shrink": 0.5,
"clip": 0.05,
"min_delta": 0.004
},
"corrections": {
"ms_home": [
{
"lo": 0.05,
"hi": 0.15,
"delta": 0.0,
"n": 2124,
"raw_gap": -0.0072
},
{
"lo": 0.15,
"hi": 0.25,
"delta": 0.0,
"n": 6476,
"raw_gap": -0.0031
},
{
"lo": 0.25,
"hi": 0.35,
"delta": 0.0,
"n": 12565,
"raw_gap": -0.0018
},
{
"lo": 0.35,
"hi": 0.45,
"delta": 0.0,
"n": 16431,
"raw_gap": 0.006
},
{
"lo": 0.45,
"hi": 0.55,
"delta": 0.0124,
"n": 12995,
"raw_gap": 0.0248
},
{
"lo": 0.55,
"hi": 0.65,
"delta": 0.0154,
"n": 8479,
"raw_gap": 0.0307
},
{
"lo": 0.65,
"hi": 0.75,
"delta": 0.0203,
"n": 4638,
"raw_gap": 0.0407
}
],
"ms_away": [
{
"lo": 0.05,
"hi": 0.15,
"delta": -0.0077,
"n": 6762,
"raw_gap": -0.0154
},
{
"lo": 0.15,
"hi": 0.25,
"delta": -0.0048,
"n": 16211,
"raw_gap": -0.0097
},
{
"lo": 0.25,
"hi": 0.35,
"delta": 0.0,
"n": 18440,
"raw_gap": -0.002
},
{
"lo": 0.35,
"hi": 0.45,
"delta": 0.009,
"n": 12061,
"raw_gap": 0.0181
},
{
"lo": 0.45,
"hi": 0.55,
"delta": 0.0116,
"n": 5930,
"raw_gap": 0.0231
},
{
"lo": 0.55,
"hi": 0.65,
"delta": 0.0199,
"n": 3287,
"raw_gap": 0.0399
},
{
"lo": 0.65,
"hi": 0.75,
"delta": 0.0295,
"n": 1580,
"raw_gap": 0.0589
}
]
}
}
ai-engine/models/live_matrix.py
+184
View File
@@ -0,0 +1,184 @@
"""Live-conditioned score projection (V38) — pure functions, no I/O.
Answers, DURING a match, questions like "1-0 at 80' — what is the REAL
probability the away team still scores?" by conditioning the same calibrated
market-anchored lambdas (V35/V36) on the current score and minute.
Mechanics — a minute-stepped Markov chain over remaining goals:
1. Pre-match lambdas come from the SAME source the score card uses
(de-vigged 1X2 + over2.5, models/score_matrix solvers) — one consistent
probability spine pre-match and in-play.
2. Each remaining minute contributes lambda_side x minute_share(t) goals,
where minute_share is the EMPIRICAL goal-time intensity curve measured
on 38,779 clean-timeline real-odds matches (1H share 44.4%, late-game
intensity rises, stoppage spikes at 45' and 90+').
3. Each minute's intensity is scaled by the MEASURED score-state
multiplier: trailing teams push (+9%, +17% after 70'), leading teams
shut up shop (-5%/-7%), 2+ ahead opens up. The chain updates the state
as virtual goals happen, so multipliers switch mid-projection exactly
like they do on the pitch.
All constants are fitted on the train window (matches older than the last 90
days); the held-out window validates calibration out-of-sample before any of
this reaches the screen.
"""
from __future__ import annotations
from typing import Dict, List, Optional, Tuple
from models.score_matrix import split_lambdas, total_lambda_from_over25
MAX_MINUTE = 94 # 90 + folded stoppage
LATE_PHASE_FROM = 70 # measured multipliers switch here
MAX_EXTRA_GOALS = 7 # per side, absorbing cap for the chain
# Empirical goal-time intensity: share of a match's goals per 5-min bucket
# (0-5, ..., 90-94+). Measured on 105k goals; 45' and 90+' buckets carry the
# folded stoppage-time spikes.
INTENSITY_SHARES: Tuple[float, ...] = (
0.036, 0.045, 0.047, 0.047, 0.045, 0.046, 0.048, 0.049, 0.081,
0.048, 0.057, 0.055, 0.054, 0.053, 0.052, 0.053, 0.052, 0.056, 0.076,
)
# Score-state goal-intensity multipliers, measured (actual/expected) by the
# scoring side's goal difference, split early (<70') / late (>=70').
_STATE_MULT_EARLY: Dict[int, float] = {-2: 1.095, -1: 1.045, 0: 0.966, 1: 0.952, 2: 1.011}
_STATE_MULT_LATE: Dict[int, float] = {-2: 1.123, -1: 1.174, 0: 1.015, 1: 0.930, 2: 1.011}
def _minute_share(minute: int) -> float:
"""Per-minute share of match-total goal intensity at `minute` (1-based)."""
b = min(len(INTENSITY_SHARES) - 1, max(0, (minute - 1) // 5))
return INTENSITY_SHARES[b] / 5.0
def state_multiplier(diff: int, minute: int) -> float:
"""Intensity multiplier for a side whose current goal difference is
`diff` (own − opponent), at `minute`."""
d = max(-2, min(2, diff))
table = _STATE_MULT_LATE if minute >= LATE_PHASE_FROM else _STATE_MULT_EARLY
return table[d]
def estimate_minute(match_date_ms: Optional[int], now_ms: int) -> Optional[int]:
"""Approximate current match minute from kickoff time (no feed minute is
available: live_matches.substate carries none). Folds the ~15' half-time
break; accuracy is ±2-3 minutes which barely moves the projection."""
if not match_date_ms:
return None
elapsed = (now_ms - int(match_date_ms)) / 60000.0
if elapsed < 0:
return None
if elapsed <= 48: # first half (+stoppage)
minute = elapsed
elif elapsed <= 63: # half-time break window
minute = 46
else:
minute = elapsed - 15.0 # second half, break folded out
return int(max(1, min(MAX_MINUTE, minute)))
def _chain(
lam_h: float,
lam_a: float,
cur_h: int,
cur_a: int,
minute: int,
) -> Dict[Tuple[int, int], float]:
"""Distribution over (extra home goals, extra away goals) from `minute`
to full time, with state-dependent intensities."""
dist: Dict[Tuple[int, int], float] = {(0, 0): 1.0}
for t in range(minute, MAX_MINUTE + 1):
share = _minute_share(t)
nxt: Dict[Tuple[int, int], float] = {}
for (eh, ea), p in dist.items():
diff = (cur_h + eh) - (cur_a + ea)
ph = lam_h * share * state_multiplier(diff, t)
pa = lam_a * share * state_multiplier(-diff, t)
ph = min(ph, 0.30); pa = min(pa, 0.30)
stay = max(0.0, 1.0 - ph - pa)
nxt[(eh, ea)] = nxt.get((eh, ea), 0.0) + p * stay
if eh < MAX_EXTRA_GOALS:
nxt[(eh + 1, ea)] = nxt.get((eh + 1, ea), 0.0) + p * ph
else:
nxt[(eh, ea)] = nxt.get((eh, ea), 0.0) + p * ph
if ea < MAX_EXTRA_GOALS:
nxt[(eh, ea + 1)] = nxt.get((eh, ea + 1), 0.0) + p * pa
else:
nxt[(eh, ea)] = nxt.get((eh, ea), 0.0) + p * pa
dist = nxt
return dist
def build_live_projection(
p1: float,
px: float,
p2: float,
p_over25: float,
cur_h: int,
cur_a: int,
minute: int,
) -> Dict[str, object]:
"""Live projection from the anchored pre-match probabilities + the pitch
state. Returns honest, score/minute-aware probabilities.
(p1, px, p2) and p_over25 are the CALIBRATED (V35-anchored) numbers; the
same spine the pre-match cards display.
"""
minute = int(max(1, min(MAX_MINUTE, minute)))
cur_h = max(0, int(cur_h)); cur_a = max(0, int(cur_a))
total = total_lambda_from_over25(p_over25)
lam_h, lam_a = split_lambdas(total, p1, p2)
dist = _chain(lam_h, lam_a, cur_h, cur_a, minute)
p_home_win = p_draw = p_away_win = 0.0
p_home_scores = p_away_scores = 0.0
exp_goals = 0.0
scores: Dict[str, float] = {}
for (eh, ea), p in dist.items():
fh, fa = cur_h + eh, cur_a + ea
if fh > fa: p_home_win += p
elif fh == fa: p_draw += p
else: p_away_win += p
if eh > 0: p_home_scores += p
if ea > 0: p_away_scores += p
exp_goals += p * (eh + ea)
key = f"{min(fh,9)}-{min(fa,9)}"
scores[key] = scores.get(key, 0.0) + p
top = sorted(scores.items(), key=lambda kv: kv[1], reverse=True)[:5]
total_now = cur_h + cur_a
p_over25_live = sum(
p for (eh, ea), p in dist.items() if total_now + eh + ea >= 3
)
# "comeback": the side currently behind at least draws / currently level
# match does NOT stay level
if cur_h > cur_a:
p_comeback = p_draw + p_away_win
elif cur_a > cur_h:
p_comeback = p_draw + p_home_win
else:
p_comeback = p_home_win + p_away_win # deadlock breaks
return {
"minute": minute,
"current_score": f"{cur_h}-{cur_a}",
"probs": {
"1": round(p_home_win, 4),
"X": round(p_draw, 4),
"2": round(p_away_win, 4),
},
"p_home_scores_again": round(p_home_scores, 4),
"p_away_scores_again": round(p_away_scores, 4),
"p_comeback": round(p_comeback, 4),
"p_over25": round(p_over25_live, 4),
"expected_remaining_goals": round(exp_goals, 2),
"scenario_top5": [
{"score": s, "prob": round(p, 4)} for s, p in top
],
"calibration_source": "live_matrix_v38",
}
ai-engine/models/market_anchor.py
+173 -2
View File
@@ -25,7 +25,11 @@ without the DB or the heavy model stack.
from __future__ import annotations
from typing import List, Optional, Tuple
import json
import os
import threading
import time
from typing import Any, Dict, List, Optional, Tuple
def devig(odds: List[Optional[float]]) -> Optional[List[float]]:
@@ -53,6 +57,13 @@ def devig(odds: List[Optional[float]]) -> Optional[List[float]]:
# unbiased. Values are deliberately conservative — universal and shrunk toward 0
# vs the raw tier-0 (soft-league) edge, because the bias is weaker in efficient
# top leagues. Applying these took MS-home OOS ECE 1.56% -> 0.64%.
#
# These static bands are the BUILT-IN FALLBACK. The live values come from the
# versioned artifact `config/market_anchor_corrections.json`, refreshed by
# `scripts/fit_anchor_corrections.py` (the guarded self-correction loop:
# measure on settled matches -> shrink/clip/min-sample gates -> out-of-sample
# acceptance -> write table). The engine only ever consumes the TABLE — the
# loop never modifies code.
_HOME_FAV_BANDS: Tuple[Tuple[float, float, float], ...] = (
(0.45, 0.55, 0.010),
(0.55, 0.65, 0.018),
@@ -60,17 +71,177 @@ _HOME_FAV_BANDS: Tuple[Tuple[float, float, float], ...] = (
(0.75, 1.01, 0.034),
)
_DEFAULT_CORRECTIONS_PATH = os.path.join(
os.path.dirname(os.path.abspath(__file__)), "..", "config",
"market_anchor_corrections.json",
)
def _corrections_path() -> str:
return os.environ.get(
"MARKET_ANCHOR_CORRECTIONS_PATH", _DEFAULT_CORRECTIONS_PATH
)
_corrections_lock = threading.Lock()
_corrections_cache: Optional[Dict[str, Any]] = None
_corrections_ts: float = 0.0
# Re-check sources at most every 10 minutes: the self-correction cron writes a
# new table to app_settings; running engines pick it up WITHOUT a restart.
_CORRECTIONS_TTL_S = 600.0
def _parse_corrections(raw: Dict[str, Any]) -> Optional[Dict[str, Any]]:
parsed_table: Dict[str, Any] = {}
for key in ("ms_home", "ms_away"):
bands = raw.get("corrections", {}).get(key)
if not (isinstance(bands, list) and bands):
continue
parsed = []
for b in bands:
lo = float(b["lo"]); hi = float(b["hi"]); delta = float(b["delta"])
if not (0.0 <= lo < hi <= 1.01) or abs(delta) > 0.10:
raise ValueError(f"correction band out of range: {b}")
parsed.append((lo, hi, delta))
parsed_table[key] = tuple(parsed)
if not parsed_table:
return None
parsed_table["version"] = str(raw.get("version", "?"))
return parsed_table
def _db_corrections_raw() -> Optional[Dict[str, Any]]:
"""Fetch the correction artifact from app_settings (the deployment's shared
medium — the ai-engine container has no volume mounts, so a host-side cron
can only reach the running engine through the database). Guarded: any
failure → None, never breaks a prediction. Disable with MARKET_ANCHOR_DB=0."""
if os.environ.get("MARKET_ANCHOR_DB", "1") == "0":
return None
try:
import psycopg2 # local import: keeps module usable without DB deps
from data.db import get_clean_dsn
with psycopg2.connect(get_clean_dsn(), connect_timeout=3) as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT value FROM app_settings"
" WHERE key = 'market_anchor_corrections'"
)
row = cur.fetchone()
if row and row[0]:
return json.loads(row[0])
except Exception:
return None
return None
def _load_corrections() -> Optional[Dict[str, Any]]:
"""Resolve the active correction table (thread-safe, TTL-cached).
Source order:
1. MARKET_ANCHOR_CORRECTIONS_PATH env file (tests/dev — file-only mode,
malformed → static fallback, DB and default file are NOT consulted)
2. app_settings DB row 'market_anchor_corrections' (production path —
refreshed by scripts/fit_anchor_corrections.py)
3. bundled config/market_anchor_corrections.json
4. None → built-in static fallback bands
"""
global _corrections_cache, _corrections_ts
now = time.time()
if now - _corrections_ts < _CORRECTIONS_TTL_S:
return _corrections_cache
with _corrections_lock:
if now - _corrections_ts < _CORRECTIONS_TTL_S:
return _corrections_cache
table: Optional[Dict[str, Any]] = None
env_path = os.environ.get("MARKET_ANCHOR_CORRECTIONS_PATH")
if env_path:
try:
with open(env_path, "r", encoding="utf-8") as fh:
table = _parse_corrections(json.load(fh))
except (OSError, ValueError, KeyError, TypeError, json.JSONDecodeError):
table = None
else:
raw = _db_corrections_raw()
if raw is not None:
try:
table = _parse_corrections(raw)
except (ValueError, KeyError, TypeError):
table = None
if table is None:
try:
with open(_corrections_path(), "r", encoding="utf-8") as fh:
table = _parse_corrections(json.load(fh))
except (OSError, ValueError, KeyError, TypeError, json.JSONDecodeError):
table = None
_corrections_cache = table
_corrections_ts = time.time()
return _corrections_cache
def reload_corrections() -> None:
"""Force re-read of the correction sources (used after a refresh/tests)."""
global _corrections_ts, _corrections_cache
with _corrections_lock:
_corrections_ts = 0.0
_corrections_cache = None
def home_favorite_delta(p_home: float) -> float:
"""Additive correction to the de-vigged home-win probability.
Zero below 0.45 (no measured bias for non-favourites)."""
Band semantics: a fitted-artifact band OVERRIDES the static prior where it
exists (including an explicit delta of 0 — evidence of "no bias"). Where
the artifact is SILENT (a range that never passed the min-sample gate,
e.g. big favourites 0.75+), the static prior still applies — missing
evidence must not silently erase proven knowledge."""
table = _load_corrections()
if table and "ms_home" in table:
for lo, hi, delta in table["ms_home"]:
if lo <= p_home < hi:
return delta
for lo, hi, delta in _HOME_FAV_BANDS:
if lo <= p_home < hi:
return delta
return 0.0
def away_favorite_delta(p_away: float) -> float:
"""Additive correction to the de-vigged away-win probability.
Scoreboard measurement (2026-06): away favourites also win a few points
MORE than the de-vigged price implies (+2.6..+4.2pt). Unlike the home
side there is NO built-in fallback — away corrections must be EARNED via
the fitted artifact (scripts/fit_anchor_corrections.py passing its
out-of-sample acceptance gate). No artifact → zero → prior behaviour."""
table = _load_corrections()
bands = table.get("ms_away", ()) if table else ()
for lo, hi, delta in bands:
if lo <= p_away < hi:
return delta
return 0.0
def apply_corrections(
p1: float, px: float, p2: float
) -> Tuple[float, float, float]:
"""Apply favourite corrections to a 3-way (1, X, 2) vector.
In practice only one side can be a favourite (both ≥0.45 would leave no
room for the draw); if both bands somehow fire, the larger delta wins.
The other two outcomes are renormalised so the vector still sums to 1."""
d1 = home_favorite_delta(p1)
d2 = away_favorite_delta(p2)
if d1 <= 0.0 and d2 <= 0.0:
return p1, px, p2
if d1 >= d2:
return apply_home_correction(p1, px, p2)
p2n = min(0.98, p2 + d2)
remaining = 1.0 - p2n
rest = p1 + px
if rest <= 0.0:
return p1, px, p2n
return p1 / rest * remaining, px / rest * remaining, p2n
def apply_home_correction(
p1: float, px: float, p2: float
) -> Tuple[float, float, float]:
ai-engine/scripts/calibration_scoreboard.py
+261
View File
@@ -0,0 +1,261 @@
"""Calibration scoreboard — "dediğimiz vs olan" karnesi.
Measures, on settled real-odds matches, how honest the DISPLAYED numbers are:
1. ANCHORED PIPELINE (what V35 shows): per market (MS 1/X/2, OU2.5, BTTS)
reliability buckets — mean stated probability vs actual frequency,
plus ECE / Brier per market.
2. SCORE CARD (V36): modal-score hit vs stated modal probability, top-5
coverage, HT modal hit.
3. STORED RUNS: prediction_runs settled per engine_version (the
`.sim-finished` buckets — the user's manual finished-match tests — are
reported separately and never mixed into the live karne).
It recomputes the anchored numbers with the SAME modules the engine ships
(models/market_anchor.py + models/score_matrix.py), so the scoreboard always
grades current pipeline math, not a copy of it.
DB: uses DATABASE_URL (data/db.py). Reads are gentle: a server-side cursor
over an indexed, date-bounded join — never aggregate-scans the giant odds
tables (prod runs on a Raspberry Pi).
Usage:
python scripts/calibration_scoreboard.py [--days 365] [--buckets 10]
"""
from __future__ import annotations
import argparse
import os
import sys
import time
from collections import defaultdict
from typing import Any, Dict, List, Optional, Tuple
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
import psycopg2 # noqa: E402
from psycopg2.extras import RealDictCursor # noqa: E402
from data.db import get_clean_dsn # noqa: E402
from models.market_anchor import apply_corrections # noqa: E402
from models.score_matrix import build_calibrated_score_package # noqa: E402
REAL_ODDS_MIN_OVERROUND = 0.05 # the user's hard rule: no real odds -> excluded
def _fetch_settled_matches(days: int) -> List[Dict[str, Any]]:
"""Finished, real-odds matches with stored de-vigged implied probs."""
since_ms = int((time.time() - days * 86400) * 1000)
sql = """
SELECT f.implied_home, f.implied_draw, f.implied_away,
f.implied_over25, f.implied_btts_yes, f.odds_overround,
m.score_home, m.score_away, m.ht_score_home, m.ht_score_away
FROM football_ai_features f
JOIN matches m ON m.id = f.match_id
WHERE m.sport = 'football'
AND m.winner IN ('home', 'away', 'draw')
AND m.score_home IS NOT NULL
AND f.odds_overround > %s
AND m.mst_utc >= %s
"""
rows: List[Dict[str, Any]] = []
with psycopg2.connect(get_clean_dsn()) as conn:
with conn.cursor() as cur:
cur.execute("SET statement_timeout = '120s'")
# server-side (named) cursor: streams gently instead of one big fetch
with conn.cursor("scoreboard_stream", cursor_factory=RealDictCursor) as cur:
cur.itersize = 5000
cur.execute(sql, (REAL_ODDS_MIN_OVERROUND, since_ms))
for r in cur:
rows.append(dict(r))
return rows
def _anchored_probs(row: Dict[str, Any]) -> Optional[Tuple[float, float, float]]:
"""The MS vector the V35 pipeline would display (devig is already done in
the stored features; apply the active home-favourite correction)."""
try:
p1 = float(row["implied_home"]); px = float(row["implied_draw"]); p2 = float(row["implied_away"])
except (TypeError, ValueError):
return None
if not (0.0 < p1 < 1.0 and 0.0 < px < 1.0 and 0.0 < p2 < 1.0):
return None
if abs(p1 + px + p2 - 1.0) > 0.02: # not a clean de-vigged vector
return None
return apply_corrections(p1, px, p2)
class Reliability:
"""Accumulates (stated probability, outcome) pairs into buckets."""
def __init__(self, n_buckets: int) -> None:
self.n_buckets = n_buckets
self.n = defaultdict(int)
self.sum_p = defaultdict(float)
self.sum_y = defaultdict(int)
def add(self, p: float, hit: bool) -> None:
b = min(self.n_buckets - 1, int(p * self.n_buckets))
self.n[b] += 1
self.sum_p[b] += p
self.sum_y[b] += 1 if hit else 0
def report(self, title: str) -> Tuple[float, float]:
total = sum(self.n.values())
if not total:
print(f"\n== {title}: no data ==")
return 0.0, 0.0
ece = 0.0
brier_num = 0.0
print(f"\n== {title} (n={total}) ==")
print(f"{'band':>10} {'n':>8} {'said%':>8} {'actual%':>8} {'gap_pt':>7}")
for b in sorted(self.n):
n = self.n[b]
said = self.sum_p[b] / n
act = self.sum_y[b] / n
ece += n * abs(said - act)
print(f"{b / self.n_buckets:>5.2f}-{(b + 1) / self.n_buckets:<4.2f} "
f"{n:>8} {100 * said:>8.1f} {100 * act:>8.1f} {100 * (act - said):>7.1f}")
ece /= total
# Brier from bucket stats is approximate; recompute exactly elsewhere
# if needed. ECE is the headline honesty metric here.
print(f"{'ECE':>10}: {100 * ece:.2f}%")
return ece, brier_num
def grade_pipeline(rows: List[Dict[str, Any]], n_buckets: int) -> None:
ms1 = Reliability(n_buckets); msx = Reliability(n_buckets); ms2 = Reliability(n_buckets)
ou = Reliability(n_buckets); btts = Reliability(n_buckets)
top1 = top5 = ht1 = 0
stated_modal = 0.0
n_score = 0
for r in rows:
anch = _anchored_probs(r)
sh, sa = int(r["score_home"]), int(r["score_away"])
winner = "home" if sh > sa else "away" if sa > sh else "draw"
if anch is not None:
p1, px, p2 = anch
ms1.add(p1, winner == "home")
msx.add(px, winner == "draw")
ms2.add(p2, winner == "away")
# exactly-0.5 values are DEFAULT FILL for matches without a real OU/BTTS
# market (measured: 15,993 of 78k OU rows) — never grade or use them.
try:
po = float(r["implied_over25"])
if po == 0.5 or not (0.05 < po < 0.95):
po = None
else:
ou.add(po, sh + sa >= 3)
except (TypeError, ValueError):
po = None
try:
pb = float(r["implied_btts_yes"])
if pb != 0.5 and 0.05 < pb < 0.95:
btts.add(pb, sh > 0 and sa > 0)
except (TypeError, ValueError):
pass
# V36 score card (sampled fully — pure math, no I/O)
if anch is not None and po is not None and 0.05 < po < 0.95:
pkg = build_calibrated_score_package(*anch, po)
actual = f"{min(sh, 10)}-{min(sa, 10)}"
n_score += 1
stated_modal += float(pkg["scenario_top5"][0]["prob"])
if pkg["ft"] == actual:
top1 += 1
if actual in [d["score"] for d in pkg["scenario_top5"]]:
top5 += 1
hh, ha = r.get("ht_score_home"), r.get("ht_score_away")
if hh is not None and ha is not None and pkg["ht"] == f"{min(int(hh),10)}-{min(int(ha),10)}":
ht1 += 1
ms1.report("MS ev (1) — anchored pipeline")
msx.report("MS beraberlik (X) — anchored pipeline")
ms2.report("MS deplasman (2) — anchored pipeline")
ou.report("Ust/Alt 2.5 (over) — devig")
btts.report("KG Var — devig")
if n_score:
print(f"\n== V36 skor karti (n={n_score}) ==")
print(f" modal skor isabeti : {100 * top1 / n_score:.1f}% (soylenen: {100 * stated_modal / n_score:.1f}%)")
print(f" top-5 kapsama : {100 * top5 / n_score:.1f}%")
print(f" IY modal isabeti : {100 * ht1 / n_score:.1f}%")
def grade_stored_runs() -> None:
"""Settle prediction_runs main_pick stated probabilities per engine_version.
`.sim-finished` buckets (manual finished-match tests) report separately."""
sql = """
SELECT pr.engine_version,
pr.payload_summary->'main_pick'->>'market' AS market,
pr.payload_summary->'main_pick'->>'pick' AS pick,
COALESCE((pr.payload_summary->'main_pick'->>'calibrated_probability')::float,
(pr.payload_summary->'main_pick'->>'probability')::float) AS p,
m.score_home AS sh, m.score_away AS sa, m.winner AS w
FROM prediction_runs pr
JOIN matches m ON m.id = pr.match_id
WHERE m.score_home IS NOT NULL
AND jsonb_typeof(pr.payload_summary->'main_pick') = 'object'
"""
with psycopg2.connect(get_clean_dsn()) as conn:
with conn.cursor() as cur:
cur.execute("SET statement_timeout = '60s'")
with conn.cursor(cursor_factory=RealDictCursor) as cur:
cur.execute(sql)
rows = cur.fetchall()
def settle(market: str, pick: str, sh: int, sa: int, w: str) -> Optional[bool]:
total = sh + sa
pick_u = (pick or "").upper()
over = "UST" in pick_u.replace("Ü", "U") or "OVER" in pick_u
if market == "MS":
return {"1": w == "home", "X": w == "draw", "2": w == "away"}.get(pick)
if market in ("OU15", "OU25", "OU35"):
line = {"OU15": 1.5, "OU25": 2.5, "OU35": 3.5}[market]
return total > line if over else total < line
if market == "BTTS":
yes = "VAR" in pick_u or "YES" in pick_u
return (sh > 0 and sa > 0) if yes else not (sh > 0 and sa > 0)
return None
stats: Dict[str, List[Tuple[float, bool]]] = defaultdict(list)
for r in rows:
if r["p"] is None:
continue
hit = settle(str(r["market"]), str(r["pick"]), int(r["sh"]), int(r["sa"]), str(r["w"]))
if hit is None:
continue
stats[str(r["engine_version"])].append((float(r["p"]), bool(hit)))
print("\n== prediction_runs karnesi (main_pick, soylenen vs olan) ==")
print(f"{'engine_version':<34} {'n':>5} {'said%':>8} {'actual%':>8}")
for ver in sorted(stats):
pairs = stats[ver]
n = len(pairs)
said = sum(p for p, _ in pairs) / n
act = sum(1 for _, h in pairs if h) / n
tag = " <- test kovasi" if ver.endswith(".sim-finished") else ""
print(f"{ver:<34} {n:>5} {100 * said:>8.1f} {100 * act:>8.1f}{tag}")
if not stats:
print(" (settle edilebilir kayit yok)")
def main() -> None:
ap = argparse.ArgumentParser(description=__doc__)
ap.add_argument("--days", type=int, default=365, help="lookback window (days)")
ap.add_argument("--buckets", type=int, default=10)
args = ap.parse_args()
t0 = time.time()
rows = _fetch_settled_matches(args.days)
print(f"settled real-odds matches loaded: {len(rows)} (last {args.days} days, "
f"{time.time() - t0:.1f}s)")
if rows:
grade_pipeline(rows, args.buckets)
grade_stored_runs()
if __name__ == "__main__":
main()
ai-engine/scripts/fit_anchor_corrections.py
+255
View File
@@ -0,0 +1,255 @@
"""Guarded self-correction loop — fits the market-anchor correction table.
What it does (the "tablo üreteci" of the feedback loop):
1. MEASURE: on settled real-odds matches, per implied-probability band, the
gap between the RAW de-vigged probability and the actual rate — for BOTH
the home side (ms_home) and the away side (ms_away).
2. BRAKE: a band only earns a correction if it passes the safety gates —
* min sample (>= MIN_N matches in the band, fitted on TRAIN window)
* shrinkage (delta = SHRINK x measured gap — never the full gap)
* clipping (|delta| <= CLIP)
* materiality (|delta| >= MIN_DELTA, else 0 — don't chase noise)
3. PROVE: the candidate table must beat the CURRENTLY ACTIVE corrections
out-of-sample (most recent TEST_DAYS, never seen during fitting) on
combined home+away ECE. If it doesn't, nothing is written.
4. WRITE: versioned artifact `config/market_anchor_corrections.json`
(+ timestamped copy under `config/history/`). The engine reads the table
at runtime (models/market_anchor.py) — the loop never modifies code.
Run weekly (cron) or manually after big data ingests:
python scripts/fit_anchor_corrections.py [--days 540] [--test-days 90]
python scripts/fit_anchor_corrections.py --dry-run # measure only
"""
from __future__ import annotations
import argparse
import json
import os
import shutil
import sys
import time
from collections import defaultdict
from typing import Any, Callable, Dict, List, Optional, Tuple
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
import psycopg2 # noqa: E402
from psycopg2.extras import RealDictCursor # noqa: E402
from data.db import get_clean_dsn # noqa: E402
from models.market_anchor import ( # noqa: E402
away_favorite_delta,
home_favorite_delta,
)
# ── safety gates ─────────────────────────────────────────────────────
MIN_N = 1500 # band needs this many TRAIN matches to earn a correction
SHRINK = 0.5 # apply only half of the measured gap
CLIP = 0.05 # never correct more than 5 points
MIN_DELTA = 0.004 # below this the correction is noise — emit 0
ACCEPT_MARGIN = 0.0002 # candidate must beat active combined ECE by this
BANDS: Tuple[Tuple[float, float], ...] = (
(0.05, 0.15), (0.15, 0.25), (0.25, 0.35), (0.35, 0.45),
(0.45, 0.55), (0.55, 0.65), (0.65, 0.75), (0.75, 0.85), (0.85, 1.01),
)
REAL_ODDS_MIN_OVERROUND = 0.05
def fetch(days: int) -> List[Dict[str, Any]]:
since_ms = int((time.time() - days * 86400) * 1000)
sql = """
SELECT f.implied_home AS p1, f.implied_draw AS px, f.implied_away AS p2,
m.mst_utc,
(m.winner = 'home')::int AS home_won,
(m.winner = 'away')::int AS away_won
FROM football_ai_features f
JOIN matches m ON m.id = f.match_id
WHERE m.sport = 'football'
AND m.winner IN ('home', 'away', 'draw')
AND f.odds_overround > %s
AND m.mst_utc >= %s
"""
out: List[Dict[str, Any]] = []
with psycopg2.connect(get_clean_dsn()) as conn:
with conn.cursor() as cur:
cur.execute("SET statement_timeout = '120s'")
with conn.cursor("fit_stream", cursor_factory=RealDictCursor) as cur:
cur.itersize = 5000
cur.execute(sql, (REAL_ODDS_MIN_OVERROUND, since_ms))
for r in cur:
p1, px, p2 = r["p1"], r["px"], r["p2"]
if p1 is None or px is None or p2 is None:
continue
if abs(float(p1) + float(px) + float(p2) - 1.0) > 0.02:
continue
out.append({
"p1": float(p1), "p2": float(p2),
"y1": int(r["home_won"]), "y2": int(r["away_won"]),
"mst_utc": int(r["mst_utc"]),
})
return out
def band_of(p: float) -> Optional[int]:
for i, (lo, hi) in enumerate(BANDS):
if lo <= p < hi:
return i
return None
def fit_candidate(
train: List[Dict[str, Any]], pkey: str, ykey: str
) -> List[Dict[str, Any]]:
n = defaultdict(int); sp = defaultdict(float); sy = defaultdict(int)
for r in train:
b = band_of(r[pkey])
if b is None:
continue
n[b] += 1; sp[b] += r[pkey]; sy[b] += r[ykey]
bands: List[Dict[str, Any]] = []
for i, (lo, hi) in enumerate(BANDS):
if n[i] < MIN_N:
continue # gate: not enough evidence — no correction for this band
raw_gap = (sy[i] / n[i]) - (sp[i] / n[i])
delta = max(-CLIP, min(CLIP, SHRINK * raw_gap))
if abs(delta) < MIN_DELTA:
delta = 0.0
bands.append({"lo": lo, "hi": hi, "delta": round(delta, 4),
"n": n[i], "raw_gap": round(raw_gap, 4)})
return bands
def table_delta_fn(table: List[Dict[str, Any]]) -> Callable[[float], float]:
def fn(p: float) -> float:
for b in table:
if b["lo"] <= p < b["hi"]:
return b["delta"]
return 0.0
return fn
def ece(rows: List[Dict[str, Any]], pkey: str, ykey: str,
delta_fn: Callable[[float], float]) -> float:
n = defaultdict(int); sp = defaultdict(float); sy = defaultdict(int)
for r in rows:
pc = min(0.98, r[pkey] + delta_fn(r[pkey]))
b = min(19, int(pc * 20))
n[b] += 1; sp[b] += pc; sy[b] += r[ykey]
total = sum(n.values())
if not total:
return 0.0
return sum(n[b] * abs(sp[b] / n[b] - sy[b] / n[b]) for b in n) / total
def print_bands(title: str, bands: List[Dict[str, Any]]) -> None:
print(f"\ncandidate bands — {title} (after gates):")
print(f"{'band':>12} {'n':>8} {'raw_gap_pt':>11} {'delta_pt':>9}")
for b in bands:
print(f"{b['lo']:>5.2f}-{b['hi']:<5.2f} {b['n']:>8} "
f"{100 * b['raw_gap']:>11.2f} {100 * b['delta']:>9.2f}")
def main() -> None:
ap = argparse.ArgumentParser(description=__doc__)
ap.add_argument("--days", type=int, default=540, help="total lookback")
ap.add_argument("--test-days", type=int, default=90,
help="most recent window held out for acceptance")
ap.add_argument("--dry-run", action="store_true",
help="measure and report only — never write")
args = ap.parse_args()
rows = fetch(args.days)
cutoff_ms = int((time.time() - args.test_days * 86400) * 1000)
train = [r for r in rows if r["mst_utc"] < cutoff_ms]
test = [r for r in rows if r["mst_utc"] >= cutoff_ms]
print(f"matches: total={len(rows)} train={len(train)} test(OOS)={len(test)}")
if len(train) < 10 * MIN_N or len(test) < 2000:
print("ABORT: not enough data for a safe fit — keeping active table.")
return
cand_home = fit_candidate(train, "p1", "y1")
cand_away = fit_candidate(train, "p2", "y2")
print_bands("ms_home", cand_home)
print_bands("ms_away", cand_away)
# active = whatever the engine currently loads (artifact or fallback)
ece_h_act = ece(test, "p1", "y1", home_favorite_delta)
ece_a_act = ece(test, "p2", "y2", away_favorite_delta)
ece_h_cand = ece(test, "p1", "y1", table_delta_fn(cand_home))
ece_a_cand = ece(test, "p2", "y2", table_delta_fn(cand_away))
ece_h_raw = ece(test, "p1", "y1", lambda _p: 0.0)
ece_a_raw = ece(test, "p2", "y2", lambda _p: 0.0)
print(f"\nOOS ECE (home/away/combined):")
print(f" raw (devig only) : {100 * ece_h_raw:.3f}% / {100 * ece_a_raw:.3f}% "
f"/ {100 * (ece_h_raw + ece_a_raw):.3f}%")
print(f" ACTIVE table : {100 * ece_h_act:.3f}% / {100 * ece_a_act:.3f}% "
f"/ {100 * (ece_h_act + ece_a_act):.3f}%")
print(f" CANDIDATE table : {100 * ece_h_cand:.3f}% / {100 * ece_a_cand:.3f}% "
f"/ {100 * (ece_h_cand + ece_a_cand):.3f}%")
if args.dry_run:
print("\n(dry-run: nothing written)")
return
combined_act = ece_h_act + ece_a_act
combined_cand = ece_h_cand + ece_a_cand
if combined_cand > combined_act - ACCEPT_MARGIN:
print("\nREJECTED: candidate does not beat the active table "
"out-of-sample. Active corrections stay. (Bu fren tasarim geregi:"
" kanitlayamayan tablo yazilmaz.)")
return
cfg_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "config"))
path = os.path.join(cfg_dir, "market_anchor_corrections.json")
artifact = {
"version": time.strftime("%Y-%m-%dT%H:%M:%S"),
"fitted_on": {"days": args.days, "test_days": args.test_days,
"n_train": len(train), "n_test": len(test)},
"validated": {
"ece_home": {"raw": round(ece_h_raw, 5), "active_before": round(ece_h_act, 5),
"candidate_oos": round(ece_h_cand, 5)},
"ece_away": {"raw": round(ece_a_raw, 5), "active_before": round(ece_a_act, 5),
"candidate_oos": round(ece_a_cand, 5)},
},
"gates": {"min_n": MIN_N, "shrink": SHRINK, "clip": CLIP,
"min_delta": MIN_DELTA},
"corrections": {"ms_home": cand_home, "ms_away": cand_away},
}
hist_dir = os.path.join(cfg_dir, "history")
os.makedirs(hist_dir, exist_ok=True)
if os.path.exists(path):
shutil.copy2(path, os.path.join(
hist_dir, f"market_anchor_corrections-{int(time.time())}.json"))
with open(path, "w", encoding="utf-8") as fh:
json.dump(artifact, fh, ensure_ascii=False, indent=2)
print(f"\nACCEPTED: wrote {path}")
# The deployed ai-engine container has NO volume mounts, so the file above
# is invisible to it — app_settings is the shared medium. Running engines
# re-read it within ~10 minutes (TTL in models/market_anchor.py).
try:
with psycopg2.connect(get_clean_dsn()) as conn:
with conn.cursor() as cur:
cur.execute(
"""
INSERT INTO app_settings (key, value, updated_at)
VALUES ('market_anchor_corrections', %s, now())
ON CONFLICT (key)
DO UPDATE SET value = EXCLUDED.value, updated_at = now()
""",
(json.dumps(artifact, ensure_ascii=False),),
)
conn.commit()
print("ACCEPTED: upserted app_settings['market_anchor_corrections'] "
"(live engines refresh within ~10 min)")
except Exception as exc: # file artifact still written — warn only
print(f"WARN: app_settings upsert failed: {exc}")
if __name__ == "__main__":
main()
ai-engine/services/orchestrator/market_board.py
+50 -3
View File
@@ -57,8 +57,9 @@ from utils.top_leagues import load_top_league_ids
from utils.league_reliability import load_league_reliability
from config.config_loader import build_threshold_dict, get_threshold_default
from models.calibration import get_calibrator, get_final_recalibrator
from models.market_anchor import devig, apply_home_correction
from models.market_anchor import devig, apply_corrections
from models.score_matrix import build_calibrated_score_package
from models.live_matrix import build_live_projection, estimate_minute
# ── V30: Post-calibration trust factors ─────────────────────────────
# Controls how much to trust isotonic calibrator vs raw model output.
@@ -372,6 +373,12 @@ class MarketBoardMixin:
# 13.1%, top-5 coverage 51%, per-score gaps <1.2pt.
cal_score = self._build_calibrated_score(market_board)
# V38: while the match is LIVE, also project score/minute-conditioned
# probabilities (P(side scores again), live 1X2, comeback, scenarios).
# OOS-validated on 70,410 reconstructed live moments: ECE 0.5-0.8%;
# "one-goal lead at 80'" case: said 21.7% vs actual 23.0%.
live_projection = self._build_live_projection(market_board, data)
# Determine simulation mode for the response
_resp_status = str(data.status or "").upper()
_resp_state = str(data.state or "").upper()
@@ -446,6 +453,9 @@ class MarketBoardMixin:
}
),
"market_board": market_board,
# V38: score/minute-aware live probabilities (None when not live or
# no real odds). FE can render "deplasman gol atar: %X / dönme: %Y".
"live_projection": live_projection,
"others": {
"handicap": prediction.handicap_pick,
"cards": {
@@ -1115,10 +1125,10 @@ class MarketBoardMixin:
val = self._real_market_odds(odds, key)
return val if val > 1.01 else None
# MS (3-way) + home-favourite correction; DC derived from the same vector
# MS (3-way) + favourite corrections; DC derived from the same vector
ms = devig([real("ms_h"), real("ms_d"), real("ms_a")])
if ms is not None:
p1, px, p2 = apply_home_correction(*ms)
p1, px, p2 = apply_corrections(*ms)
if "MS" in market_board:
self._set_board(market_board, "MS", {"1": p1, "X": px, "2": p2})
if "DC" in market_board:
@@ -1305,6 +1315,43 @@ class MarketBoardMixin:
"scenario_top5": pkg["scenario_top5"],
}
def _build_live_projection(
self,
market_board: Dict[str, Any],
data: MatchData,
) -> Optional[Dict[str, Any]]:
"""V38: score/minute-conditioned live projection from the anchored
probabilities. None unless the match is live, both MS and OU25 were
anchored (real odds) and a minute estimate exists. Same kill-switch."""
if os.environ.get("MARKET_ANCHOR_CAL", "1") == "0":
return None
if not self._is_live_match(data):
return None
ms = market_board.get("MS") or {}
ou = market_board.get("OU25") or {}
if (
ms.get("calibration_source") != "market_anchor_v35"
or ou.get("calibration_source") != "market_anchor_v35"
):
return None
minute = estimate_minute(
getattr(data, "match_date_ms", None), int(time.time() * 1000)
)
if minute is None:
return None
try:
return build_live_projection(
float(ms["probs"]["1"]),
float(ms["probs"]["X"]),
float(ms["probs"]["2"]),
float(ou["probs"]["over"]),
int(data.current_score_home or 0),
int(data.current_score_away or 0),
minute,
)
except (KeyError, TypeError, ValueError, ZeroDivisionError, OverflowError):
return None
def _build_market_rows(
self,
data: MatchData,
ai-engine/tests/test_live_matrix.py
+80
View File
@@ -0,0 +1,80 @@
"""Unit tests for V38 live-conditioned projection (pure, no DB/model deps)."""
import os
import sys
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
from models.live_matrix import (
build_live_projection,
estimate_minute,
state_multiplier,
)
def _approx(a, b, tol=1e-6):
return abs(a - b) <= tol
def test_probs_form_distribution():
proj = build_live_projection(0.50, 0.27, 0.23, 0.55, 1, 0, 60)
p = proj["probs"]
assert _approx(p["1"] + p["X"] + p["2"], 1.0, 1e-3)
assert 0.0 <= proj["p_away_scores_again"] <= 1.0
def test_minute_one_roughly_matches_prematch():
# at 0-0 minute 1 the projection must stay close to the anchored numbers
proj = build_live_projection(0.50, 0.27, 0.23, 0.55, 0, 0, 1)
assert abs(proj["probs"]["1"] - 0.50) < 0.06
assert abs(proj["probs"]["2"] - 0.23) < 0.06
def test_one_goal_lead_at_80():
# the user's exact case: 1-0 at 80' (OOS-validated: said 21.7 / actual 23.0)
proj = build_live_projection(0.50, 0.27, 0.23, 0.55, 1, 0, 80)
assert proj["probs"]["1"] > 0.72 # leader is now strong fav
assert 0.08 <= proj["p_away_scores_again"] <= 0.30
assert _approx(
proj["p_comeback"], proj["probs"]["X"] + proj["probs"]["2"], 1e-9
)
def test_less_time_means_fewer_chances():
early = build_live_projection(0.50, 0.27, 0.23, 0.55, 1, 0, 60)
late = build_live_projection(0.50, 0.27, 0.23, 0.55, 1, 0, 85)
assert late["p_away_scores_again"] < early["p_away_scores_again"]
assert late["probs"]["1"] > early["probs"]["1"]
def test_trailing_team_pushes_late():
assert state_multiplier(-1, 80) > 1.05 # trailing by one, late: pushes
assert state_multiplier(1, 80) < 1.0 # leading by one, late: parks bus
assert state_multiplier(-1, 80) > state_multiplier(-1, 30)
def test_score_consistency_with_current_score():
proj = build_live_projection(0.50, 0.27, 0.23, 0.55, 2, 1, 75)
# every scenario must be reachable from the current score
for s in proj["scenario_top5"]:
fh, fa = map(int, str(s["score"]).split("-"))
assert fh >= 2 and fa >= 1
assert proj["current_score"] == "2-1"
def test_estimate_minute_approximation():
now = 1_700_000_000_000
assert estimate_minute(None, now) is None
assert estimate_minute(now + 60_000, now) is None # not kicked off
assert estimate_minute(now - 30 * 60_000, now) == 30 # mid 1H
assert estimate_minute(now - 55 * 60_000, now) == 46 # HT break
assert estimate_minute(now - 80 * 60_000, now) == 65 # 2H, break folded
assert estimate_minute(now - 200 * 60_000, now) == 94 # capped
if __name__ == "__main__":
fns = [v for k, v in sorted(globals().items()) if k.startswith("test_")]
for fn in fns:
fn()
print(f"PASS {fn.__name__}")
print(f"\nAll {len(fns)} tests passed.")
ai-engine/tests/test_market_anchor.py
+80
View File
@@ -5,6 +5,9 @@ import sys
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
# tests must be deterministic: never consult the DB source for corrections
os.environ["MARKET_ANCHOR_DB"] = "0"
from models.market_anchor import devig, home_favorite_delta, apply_home_correction
@@ -51,6 +54,83 @@ def test_apply_home_correction_keeps_distribution_valid():
assert _approx(q[0], 0.30)
def test_corrections_artifact_loaded_and_fallback():
import json
import tempfile
from models import market_anchor as ma
# 1) valid artifact -> values come from the file
with tempfile.NamedTemporaryFile(
"w", suffix=".json", delete=False, encoding="utf-8"
) as fh:
json.dump(
{"version": "test", "corrections": {"ms_home": [
{"lo": 0.60, "hi": 0.70, "delta": 0.042},
]}},
fh,
)
path = fh.name
try:
os.environ["MARKET_ANCHOR_CORRECTIONS_PATH"] = path
ma.reload_corrections()
assert _approx(ma.home_favorite_delta(0.65), 0.042)
# band not in the artifact -> the STATIC PRIOR applies (silence must
# not erase proven knowledge); 0.45-0.55 static prior is 0.010
assert _approx(ma.home_favorite_delta(0.50), 0.010)
# 2) malformed artifact -> static fallback, never crashes
with open(path, "w", encoding="utf-8") as fh2:
fh2.write("{not json")
ma.reload_corrections()
assert ma.home_favorite_delta(0.65) > 0.0 # fallback band value
assert _approx(ma.home_favorite_delta(0.65), 0.028)
finally:
os.environ.pop("MARKET_ANCHOR_CORRECTIONS_PATH", None)
ma.reload_corrections()
os.unlink(path)
def test_away_corrections_only_from_artifact():
import json
import tempfile
from models import market_anchor as ma
# without an artifact: away correction must be ZERO (earned, not assumed).
# (Point the env path at a nonexistent file: the repo now SHIPS a fitted
# artifact, so "no artifact" must be simulated explicitly.)
os.environ["MARKET_ANCHOR_CORRECTIONS_PATH"] = os.path.join(
os.path.dirname(__file__), "does_not_exist.json"
)
ma.reload_corrections()
assert ma.away_favorite_delta(0.65) == 0.0
base = ma.apply_corrections(0.20, 0.20, 0.60)
assert _approx(base[2], 0.60) # away untouched without artifact
with tempfile.NamedTemporaryFile(
"w", suffix=".json", delete=False, encoding="utf-8"
) as fh:
json.dump(
{"version": "t2", "corrections": {
"ms_home": [{"lo": 0.45, "hi": 0.55, "delta": 0.010}],
"ms_away": [{"lo": 0.55, "hi": 0.65, "delta": 0.020}],
}},
fh,
)
path = fh.name
try:
os.environ["MARKET_ANCHOR_CORRECTIONS_PATH"] = path
ma.reload_corrections()
assert _approx(ma.away_favorite_delta(0.60), 0.020)
p1, px, p2 = ma.apply_corrections(0.20, 0.20, 0.60)
assert p2 > 0.60 # away favourite lifted
assert _approx(p1 + px + p2, 1.0) # still a valid distribution
assert p1 < 0.20 and px < 0.20 # others renormalised down
finally:
os.environ.pop("MARKET_ANCHOR_CORRECTIONS_PATH", None)
ma.reload_corrections()
os.unlink(path)
if __name__ == "__main__":
fns = [v for k, v in sorted(globals().items()) if k.startswith("test_")]
for fn in fns:
src/modules/predictions/predictions.service.ts
+32 -1
View File
@@ -1525,6 +1525,37 @@ export class PredictionsService implements OnModuleInit, OnModuleDestroy {
payload: MatchPredictionDto,
): Promise<void> {
try {
// Finished-match re-analyses (manual validation runs) must not pollute
// the forward track record: they would bias settlement ROI, the
// per-league karne and engine-version comparisons. Tag them into their
// own engine_version bucket so every GROUP BY engine_version isolates
// them automatically — the data is kept, the live karne stays clean.
const auditMatch = await this.prisma.match.findUnique({
where: { id: matchId },
select: {
state: true,
status: true,
scoreHome: true,
scoreAway: true,
mstUtc: true,
},
});
const kickoffMs =
auditMatch?.mstUtc != null ? Number(auditMatch.mstUtc) : null;
const kickoffLongPast =
kickoffMs !== null && Date.now() - kickoffMs > 3 * 60 * 60 * 1000;
const isCompletedRun =
isMatchCompleted({
state: auditMatch?.state ?? null,
status: auditMatch?.status ?? null,
scoreHome: auditMatch?.scoreHome,
scoreAway: auditMatch?.scoreAway,
}) || kickoffLongPast;
const baseVersion = String(payload.model_version || "unknown");
const engineVersion = isCompletedRun
? `${baseVersion}.sim-finished`
: baseVersion;
const oddsSnapshot = await this.getPredictionOddsSnapshot(matchId);
const payloadSummary = this.buildPredictionPayloadSummary(payload);
await this.prisma.$executeRawUnsafe(
@@ -1539,7 +1570,7 @@ export class PredictionsService implements OnModuleInit, OnModuleDestroy {
VALUES ($1, $2, $3, $4::jsonb, $5::jsonb)
`,
matchId,
String(payload.model_version || "unknown"),
engineVersion,
typeof payload.decision_trace_id === "string"
? payload.decision_trace_id
: null,