Spaces:
Configuration error
Configuration error
| """Probability, trifecta generation, and confidence. | |
| Deterministic / statistical only — no LLM involvement. Probabilities are model | |
| estimates (softmax over scores), explicitly NOT bookmaker odds, and are labelled | |
| as such in all output. | |
| """ | |
| from __future__ import annotations | |
| import math | |
| from collections import OrderedDict | |
| from typing import Optional | |
| def softmax_probabilities(scores: list[float], temperature: float = 1.0) -> list[float]: | |
| if not scores: | |
| return [] | |
| mx = max(scores) | |
| exps = [math.exp((s - mx) / temperature) for s in scores] | |
| total = sum(exps) or 1.0 | |
| return [e / total for e in exps] | |
| def joint_prob(first: int, second: int, third: int, | |
| runner_probs: dict[int, float], order: list[int]) -> float: | |
| """Probability that `order` (a permutation of first/second/third) lands, | |
| under a simple first-order model: P(1st) * P(2nd | not 1st) * P(3rd | not 1,2).""" | |
| nums = [first, second, third] | |
| perm = list(order) | |
| p = 1.0 | |
| excluded = set() | |
| for pos, pick in enumerate(perm): | |
| avail = [n for n in nums if n not in excluded] | |
| # P(pick | available) proportional to its standalone prob among available | |
| avail_p = {n: runner_probs.get(n, 0.0) for n in avail} | |
| s = sum(avail_p.values()) or 1.0 | |
| p *= avail_p.get(pick, 0.0) / s | |
| excluded.add(pick) | |
| return p | |
| def generate_trifecta(ranked: list[dict], weights_cfg: dict) -> dict: | |
| """ranked: list of {number, score, win_est, place_est} sorted desc by score. | |
| Returns primary, top3, alternatives (savers), and probabilities.""" | |
| if len(ranked) < 3: | |
| return {"skippable": True, "reason": "fewer than 3 active runners"} | |
| # standalone per-runner win probabilities (softmax over scores) | |
| nums = [r["number"] for r in ranked] | |
| scores = [r["score"] for r in ranked] | |
| probs = softmax_probabilities(scores, temperature=12.0) | |
| runner_probs = {n: p for n, p in zip(nums, probs)} | |
| top3 = [ranked[0]["number"], ranked[1]["number"], ranked[2]["number"]] | |
| primary = list(top3) | |
| # enumerate saver permutations of the top-K (K=4) and score them | |
| k = min(4, len(ranked)) | |
| pool = [r["number"] for r in ranked[:k]] | |
| from itertools import permutations | |
| candidates = [] | |
| for order in permutations(pool): | |
| if order == tuple(primary): | |
| continue | |
| pr = joint_prob(primary[0], primary[1], primary[2], runner_probs, order) | |
| candidates.append((list(order), pr)) | |
| candidates.sort(key=lambda x: x[1], reverse=True) | |
| primary_prob = joint_prob(primary[0], primary[1], primary[2], runner_probs, tuple(primary)) | |
| max_ratio = weights_cfg.get("min_saver_prob_ratio", 0.18) | |
| max_savers = weights_cfg.get("max_savers", 6) | |
| savers = [c for c in candidates if c[1] >= primary_prob * max_ratio][:max_savers] | |
| return { | |
| "primary": primary, | |
| "top3": top3, | |
| "alternatives": [c[0] for c in savers], | |
| "primary_prob": round(primary_prob, 4), | |
| "saver_probs": [round(c[1], 4) for c in savers], | |
| "runner_probs": {str(k): round(v, 4) for k, v in runner_probs.items()}, | |
| } | |
| def compute_confidence(ranked: list[dict], race_completeness: float, | |
| pace: dict, weights_cfg: dict) -> dict: | |
| if len(ranked) < 3: | |
| return {"category": "AVOID", "score": 0, | |
| "reason": "Insufficient active runners for a trifecta."} | |
| conf = weights_cfg | |
| leader = ranked[0]["score"] | |
| if leader < weights_cfg.get("min_leader_score_for_prediction", 30.0): | |
| return {"category": "AVOID", "score": int(leader), | |
| "reason": "Leader score below threshold — data too weak to predict."} | |
| sep = ranked[0]["score"] - ranked[1]["score"] | |
| # competitive runners within `competitive_band` of leader | |
| band = conf.get("competitive_band", 8.0) | |
| competitive = sum(1 for r in ranked if leader - r["score"] <= band) | |
| if (sep >= conf.get("high_separation", 18.0) | |
| and race_completeness >= conf.get("high_min_completeness", 0.85) | |
| and competitive <= conf.get("max_competitive_runners_for_high", 3)): | |
| cat, score = "HIGH", min(100, 70 + int(sep) + int(race_completeness * 15)) | |
| elif (sep >= conf.get("medium_separation", 9.0) | |
| and race_completeness >= conf.get("medium_min_completeness", 0.6) | |
| and competitive <= conf.get("max_competitive_runners_for_medium", 6)): | |
| cat, score = "MEDIUM", min(75, 50 + int(sep) + int(race_completeness * 10)) | |
| elif sep < 4.0 or race_completeness < 0.35: | |
| cat, score = "AVOID", min(35, int(leader)) | |
| else: | |
| cat, score = "LOW", min(50, 30 + int(sep)) | |
| score = max(0, min(100, score)) | |
| return { | |
| "category": cat, | |
| "score": score, | |
| "leader_score": round(leader, 1), | |
| "separation": round(sep, 1), | |
| "competitive_runners": competitive, | |
| "data_completeness": round(race_completeness, 2), | |
| "pace": pace.get("label"), | |
| } | |