| |
| """Backtest Riak's predictions against historical scenarios with known outcomes. |
| |
| Each case in backtests/*.json describes a real historical episode and the kind of |
| outcome that actually materialised (as keyword alternatives). The engine runs |
| fully offline (deterministic rule-based mode) and we score: |
| |
| - hit@6 : does any of the top-6 predicted outcomes match an expected keyword? |
| - Brier : (1 - p)^2 where p = probability of the best-matching predicted node |
| (0 = perfect; lower is better) |
| |
| Usage: |
| python3 backtest.py # run all cases, print a report table |
| python3 backtest.py -v # also print the matching node per case |
| |
| This is a reporting tool, not a gate: it always exits 0 unless something crashes. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import json |
| import os |
| import re |
| import sys |
|
|
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
|
|
| |
| for var in ("LLM_BASE_URL", "LLM_MODEL_NAME", "LLM_API_KEY"): |
| os.environ.pop(var, None) |
|
|
| from engine import causal |
|
|
| CASES_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "backtests") |
|
|
|
|
| def _match_prob(web: dict, patterns: list[str]) -> tuple[float, str]: |
| """Highest-probability node whose text matches any expected pattern.""" |
| best_p, best_t = 0.0, "" |
| for n in web["nodes"]: |
| if any(re.search(pat, n["text"], re.I) for pat in patterns): |
| if n.get("probability", 0.0) > best_p: |
| best_p, best_t = n["probability"], n["text"] |
| return best_p, best_t |
|
|
|
|
| def run_case(case: dict, verbose: bool = False) -> dict: |
| lang = case.get("lang", "en") |
| web = causal.build_web(case["seed_text"], int(case.get("seed", 42)), |
| case.get("config") or {"branching": 5, "depth": 3, "max_nodes": 300}, |
| lang=lang) |
| pred = causal.predict(web, lang=lang) |
| patterns = case["expect_any"] |
| p_exp, match_text = _match_prob(web, patterns) |
| top_texts = [o["text"] for o in pred.get("top_outcomes", [])] |
| hit = any(re.search(pat, t, re.I) for t in top_texts for pat in patterns) |
| brier = (1.0 - p_exp) ** 2 |
| row = {"name": case["name"], "p_expected": round(p_exp, 3), |
| "hit_at_6": hit, "brier": round(brier, 3), "match": match_text} |
| if verbose: |
| row["top_outcomes"] = top_texts |
| return row |
|
|
|
|
| def main() -> int: |
| verbose = "-v" in sys.argv or "--verbose" in sys.argv |
| cases = [] |
| for fn in sorted(os.listdir(CASES_DIR)): |
| if fn.endswith(".json"): |
| with open(os.path.join(CASES_DIR, fn), encoding="utf-8") as f: |
| cases.append(json.load(f)) |
| if not cases: |
| print("no backtest cases found in", CASES_DIR) |
| return 0 |
|
|
| rows = [] |
| for case in cases: |
| try: |
| rows.append(run_case(case, verbose=verbose)) |
| except Exception as exc: |
| rows.append({"name": case.get("name", "?"), "p_expected": 0.0, |
| "hit_at_6": False, "brier": 1.0, "match": f"ERROR: {exc}"}) |
|
|
| print(f"\nRiak backtest — {len(rows)} historical scenario(s), offline rule-based mode\n") |
| print(f"{'scenario':<42} {'P(expected)':>11} {'hit@6':>6} {'Brier':>7}") |
| print("-" * 70) |
| for r in rows: |
| print(f"{r['name'][:42]:<42} {r['p_expected']:>11.3f} " |
| f"{('yes' if r['hit_at_6'] else 'no'):>6} {r['brier']:>7.3f}") |
| if verbose and r.get("match"): |
| print(f"{'':<42} └─ {r['match'][:60]}") |
| print("-" * 70) |
| hits = sum(1 for r in rows if r["hit_at_6"]) |
| mean_brier = sum(r["brier"] for r in rows) / len(rows) |
| print(f"hit@6: {hits}/{len(rows)} ({round(100 * hits / len(rows))}%) " |
| f"mean Brier: {mean_brier:.3f} (0.0 = perfect, 0.25 = coin flip)\n") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
