| """Post-hoc analyses + paper artifacts for MacroLens (NeurIPS 2026 E&D track). |
| |
| One pass over the reeval JSON + saved pkls produces every table + figure |
| referenced by §6 and the appendix. |
| |
| Outputs (in --output-dir): |
| Main-text artifacts: |
| tab_t1_leaderboard.tex -- T1 leaderboard |
| tab_t2_t5_gap.tex -- T2 vs T5 valuation gap |
| fig_ablation_4panel.pdf -- 4-panel ablation figure (4 tasks x 2 models x A-E) |
| fig_cross_task_corr.pdf -- cross-task ranking heatmap |
| tab_cross_task_corr.tex -- same as table |
| Evaluation-research tables: |
| tab_baseline_floor.tex -- saturation: methods failing to beat naive |
| tab_failure_modes.tex -- per-cell mode (ok/parser_fail/saturation/scale_blowup) |
| Appendix per-task tables: |
| tab_per_task_T1.tex .. tab_per_task_T7.tex |
| Stratifications: |
| stratify_T1_sector.csv -- §App.C |
| stratify_T2_quartile.csv |
| stratify_T5_quartile.csv |
| stratify_T4_event_type.csv |
| stratify_T7_state.csv |
| Raw CSVs (backing every table): |
| panel_metrics.csv, ablation_metrics.csv, failure_modes.csv |
| |
| Usage: |
| python -m whatif_bench.experiments.analyses.post_hoc \\ |
| --predictions-dir whatif_bench/experiments/predictions \\ |
| --reeval whatif_bench/experiments/results/canon_reeval_<TS>.json \\ |
| --output-dir whatif_bench/experiments/analyses_out |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import pickle |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| PANEL = [ |
| "persistence", "historical_analogue", "sector_median", "metro_median", |
| "lightgbm", "random_forest", |
| "dlinear", "itransformer", "moderntcn", |
| "chronos2", "moirai2", "timesfm", |
| "chattime", "time_mqa", |
| "gpt_oss_120b", "gpt51", "gemini3_flash", "qwen35", |
| ] |
| NAIVE = {"persistence", "historical_analogue", "sector_median", "metro_median"} |
| TASKS = ["T1", "T2", "T3", "T4", "T5", "T6", "T7"] |
| ABL_TASKS = ["T1", "T2", "T4", "T5"] |
| ABL_MODELS = ["gpt51", "gemini3_flash"] |
| PRIMARY = { |
| "T1": "mse", "T2": "median_ape", "T3": "overall_mape", |
| "T4": "return_mae_pct", "T5": "median_ape", "T6": "overall_mape", |
| "T7": "rent_MAPE", |
| } |
| LABEL = { |
| "mse": "MSE", "median_ape": "medAPE\\%", "overall_mape": "MAPE\\%", |
| "return_mae_pct": "MAE\\%", "rent_MAPE": "MAPE\\%", |
| } |
| SETTINGS = ["A", "B", "C", "D", "E"] |
|
|
|
|
| |
|
|
| def load_metrics(reeval_path: Path) -> tuple[pd.DataFrame, pd.DataFrame]: |
| """Return (panel_df, abl_df) with primary metric per row.""" |
| recs = json.loads(reeval_path.read_text()) |
| if isinstance(recs, dict): |
| recs = recs.get("records", recs) |
| rows = [] |
| for r in recs: |
| if r.get("status") != "ok": |
| continue |
| m, t = r.get("method_id"), r.get("task") |
| if m not in PANEL or t not in TASKS: |
| continue |
| key = PRIMARY[t] |
| v = (r.get("metrics") or {}).get(key, {}).get("value") |
| if v is None: |
| continue |
| rows.append({ |
| "method": m, "task": t, |
| "setting": r.get("ablation_setting") or "", |
| "metric_key": key, "value": float(v), |
| }) |
| df = pd.DataFrame(rows) |
| panel = df[df["setting"] == ""].drop(columns=["setting"]).copy() |
| abl = df[df["setting"] != ""].copy() |
| return panel, abl |
|
|
|
|
| def load_pkls(pred_dir: Path) -> list[dict]: |
| out = [] |
| for p in sorted(pred_dir.glob("*.pkl")): |
| try: |
| with p.open("rb") as f: |
| d = pickle.load(f) |
| out.append(d) |
| except Exception: |
| continue |
| return out |
|
|
|
|
| |
|
|
| def cross_task_correlation(panel: pd.DataFrame) -> pd.DataFrame: |
| from scipy.stats import spearmanr |
| pv = panel.pivot(index="method", columns="task", values="value") |
| rho = pd.DataFrame(index=TASKS, columns=TASKS, dtype=float) |
| for ta in TASKS: |
| for tb in TASKS: |
| common = pv[[ta, tb]].dropna() if ta in pv.columns and tb in pv.columns else pd.DataFrame() |
| if len(common) >= 4 and ta != tb: |
| rho.loc[ta, tb] = spearmanr(common[ta], common[tb])[0] |
| elif ta == tb: |
| rho.loc[ta, tb] = 1.0 |
| return rho |
|
|
|
|
| def baseline_floor(panel: pd.DataFrame) -> pd.DataFrame: |
| """Per-task: naive floor + count of methods beating / failing it.""" |
| rows = [] |
| for t in TASKS: |
| sub = panel[panel["task"] == t] |
| floor = sub[sub["method"].isin(NAIVE)]["value"].min() |
| if pd.isna(floor): |
| continue |
| non_naive = sub[~sub["method"].isin(NAIVE)] |
| beat = (non_naive["value"] < floor * 0.99).sum() |
| fail = (~(non_naive["value"] < floor * 0.99)).sum() |
| rows.append({"task": t, "naive_floor": floor, |
| "n_beat": int(beat), "n_fail": int(fail)}) |
| return pd.DataFrame(rows) |
|
|
|
|
| def t2_t5_gap(panel: pd.DataFrame) -> pd.DataFrame: |
| from scipy.stats import spearmanr |
| pv = panel.pivot(index="method", columns="task", values="value") |
| common = pv[["T2", "T5"]].dropna() |
| common = common.assign( |
| delta=common["T5"] - common["T2"], |
| T2_rank=common["T2"].rank().astype(int), |
| T5_rank=common["T5"].rank().astype(int), |
| ).sort_values("T2").reset_index() |
| rho = spearmanr(common["T2"], common["T5"])[0] if len(common) >= 3 else float("nan") |
| common.attrs["spearman_rho"] = rho |
| common.attrs["mean_delta"] = common["delta"].mean() |
| return common |
|
|
|
|
| def classify_mode(d: dict) -> str: |
| yp = d.get("y_pred") |
| if yp is None: |
| return "no_pkl" |
| if hasattr(yp, "columns"): |
| col = next((c for c in ("pred", "value", "predicted_equity_value", |
| "predicted_return_pct", "pred_rent", "pred_price") |
| if c in yp.columns), None) |
| vals = pd.to_numeric(yp[col], errors="coerce").to_numpy() if col else np.array([]) |
| else: |
| vals = np.asarray(yp, dtype=np.float64).ravel() |
| if vals.size == 0: |
| return "no_pkl" |
| finite = vals[np.isfinite(vals)] |
| if finite.size / vals.size < 0.5: |
| return "parser_fail" |
| if finite.size and np.max(np.abs(finite)) > 1e8: |
| return "scale_blowup" |
| if finite.size and np.std(finite) < 1e-3: |
| return "saturation" |
| return "ok" |
|
|
|
|
| def failure_modes(pkls: list[dict]) -> pd.DataFrame: |
| rows = [] |
| for d in pkls: |
| m, t = d.get("method_id"), d.get("task") |
| s = d.get("ablation_setting") or "" |
| if m in PANEL and t in TASKS and not s: |
| rows.append({"method": m, "task": t, "mode": classify_mode(d)}) |
| return pd.DataFrame(rows) |
|
|
|
|
| def stratify(pkls: list[dict], task: str, key_col: str, metric: str) -> pd.DataFrame: |
| """Per-(method, stratum) primary metric for one task.""" |
| rows = [] |
| for d in pkls: |
| if d.get("task") != task or d.get("method_id") not in PANEL: |
| continue |
| if (d.get("ablation_setting") or ""): |
| continue |
| meta, yt, yp = d.get("meta_test"), d.get("y_test"), d.get("y_pred") |
| if meta is None or key_col not in meta.columns: |
| continue |
| m = d["method_id"] |
| if metric == "mse": |
| yt_a = np.asarray(yt, dtype=np.float64) |
| yp_a = np.asarray(yp, dtype=np.float64).copy() |
| if yt_a.ndim == 1: yt_a = yt_a.reshape(-1, 1) |
| if yp_a.ndim == 1: yp_a = yp_a.reshape(-1, 1) |
| yp_a[~np.isfinite(yp_a).all(axis=1)] = 0.0 |
| n = min(len(meta), len(yp_a)) |
| per_inst = ((yp_a[:n] - yt_a[:n]) ** 2).mean(axis=1) |
| df = pd.DataFrame({key_col: meta[key_col].astype(str).values[:n], |
| "v": per_inst}) |
| agg = df.groupby(key_col)["v"].mean() |
| elif metric == "median_ape": |
| yt_a = np.asarray(yt, dtype=np.float64).ravel() |
| yp_a = np.where(np.isfinite(np.asarray(yp, dtype=np.float64).ravel()), |
| np.asarray(yp, dtype=np.float64).ravel(), 0.0) |
| n = min(len(meta), len(yt_a), len(yp_a)) |
| keep = np.isfinite(yt_a[:n]) & (np.abs(yt_a[:n]) >= 1.0) |
| ape = np.minimum(np.abs(yp_a[:n][keep] - yt_a[:n][keep]) / np.abs(yt_a[:n][keep]), |
| 10.0) * 100.0 |
| df = pd.DataFrame({key_col: meta[key_col].astype(str).values[:n][keep], |
| "v": ape}) |
| agg = df.groupby(key_col)["v"].median() |
| elif metric == "return_mae_pct": |
| if hasattr(yp, "columns"): |
| yp_a = pd.to_numeric(yp.iloc[:, -1], errors="coerce").to_numpy() |
| else: |
| yp_a = np.asarray(yp, dtype=np.float64).ravel() |
| yt_a = np.asarray(yt, dtype=np.float64).ravel() |
| yp_a = np.where(np.isfinite(yp_a), yp_a, 0.0) |
| n = min(len(meta), len(yt_a), len(yp_a)) |
| df = pd.DataFrame({key_col: meta[key_col].astype(str).values[:n], |
| "v": np.abs(yt_a[:n] - yp_a[:n])}) |
| agg = df.groupby(key_col)["v"].mean() |
| else: |
| continue |
| for k, v in agg.items(): |
| rows.append({"method": m, key_col: k, "value": float(v)}) |
| return pd.DataFrame(rows) |
|
|
|
|
| |
|
|
| def fmt(v) -> str: |
| if pd.isna(v): |
| return "--" |
| if isinstance(v, str): |
| return v |
| if abs(v) >= 1e6: return f"{v:.2e}" |
| if abs(v) >= 100: return f"{v:.0f}" |
| if abs(v) >= 1: return f"{v:.2f}" |
| return f"{v:.4f}" |
|
|
|
|
| def tex_safe(s: str) -> str: |
| return str(s).replace("_", r"\_") |
|
|
|
|
| def latex_table(df: pd.DataFrame, caption: str, label: str, |
| escape: bool = False) -> str: |
| """Wrap pd.to_latex with NeurIPS-friendly defaults.""" |
| body = df.to_latex( |
| index=False, escape=escape, na_rep="--", |
| column_format="l" + "c" * (len(df.columns) - 1), |
| ) |
| |
| return ( |
| "\\begin{table}[h]\n\\centering\n" |
| f"\\caption{{{caption}}}\n\\label{{{label}}}\n\\small\n" |
| + body.replace("\\begin{tabular}", "\\begin{tabular}").rstrip() |
| + "\n\\end{table}\n" |
| ) |
|
|
|
|
| def render_t1_leaderboard(panel: pd.DataFrame, out: Path) -> None: |
| family_map = { |
| "persistence": "Naive", "historical_analogue": "Naive", |
| "sector_median": "Naive", "metro_median": "Naive", |
| "lightgbm": "Classical", "random_forest": "Classical", |
| "dlinear": "Sequence", "itransformer": "Sequence", "moderntcn": "Sequence", |
| "chronos2": "TSFM", "moirai2": "TSFM", "timesfm": "TSFM", |
| "chattime": "TS-LLM", "time_mqa": "TS-LLM", |
| "gpt_oss_120b": "LLM-ZS", "gpt51": "LLM-ZS", |
| "gemini3_flash": "LLM-ZS", "qwen35": "LLM-ZS", |
| } |
| t1 = panel[panel["task"] == "T1"].copy() |
| t1["family"] = t1["method"].map(family_map) |
| t1["method"] = t1["method"].map(tex_safe) |
| t1["mse"] = t1["value"].map(fmt) |
| t1 = t1[["family", "method", "mse"]] |
| t1.columns = ["Family", "Method", "MSE"] |
| out.write_text(latex_table( |
| t1, caption="T1 contextual time-series forecasting (close-trajectory MSE, " |
| "single seed with cluster-bootstrap 95\\% CIs in App.~A).", |
| label="tab:t1", |
| )) |
|
|
|
|
| def render_t2_t5_gap(gap: pd.DataFrame, out: Path) -> None: |
| df = gap[["method", "T2", "T5", "delta", "T2_rank", "T5_rank"]].copy() |
| df["method"] = df["method"].map(tex_safe) |
| for c in ("T2", "T5", "delta"): |
| df[c] = df[c].map(fmt) |
| df.columns = ["Method", "T2 medAPE", "T5 medAPE", "$\\Delta$(T5--T2)", |
| "rank T2", "rank T5"] |
| rho = gap.attrs.get("spearman_rho") |
| md = gap.attrs.get("mean_delta") |
| out.write_text(latex_table( |
| df, |
| caption=( |
| "T2 vs T5 valuation gap. $\\Delta$ is medAPE delta when " |
| "market-price features are removed (T5). " |
| f"Spearman $\\rho$(T2 ranking, T5 ranking) $= {rho:.3f}$; " |
| f"mean $\\Delta = {md:+.2f}$ medAPE pts." |
| ), |
| label="tab:t2-t5-gap", |
| )) |
|
|
|
|
| def render_correlation(rho: pd.DataFrame, out_tex: Path, out_pdf: Path) -> None: |
| df = rho.round(2).copy() |
| df.insert(0, "", df.index) |
| out_tex.write_text(latex_table( |
| df, caption="Cross-task ranking correlation (Spearman $\\rho$). " |
| "Negative cells (boxed) are the multi-task non-redundancy " |
| "evidence: methods that win T1 lose T3 and T6.", |
| label="tab:cross-task-corr", |
| )) |
| import matplotlib |
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
| fig, ax = plt.subplots(figsize=(5.5, 4.5)) |
| arr = rho.to_numpy(dtype=float) |
| im = ax.imshow(arr, cmap="RdBu_r", vmin=-1.0, vmax=1.0, aspect="equal") |
| ax.set_xticks(range(len(TASKS))); ax.set_xticklabels(TASKS) |
| ax.set_yticks(range(len(TASKS))); ax.set_yticklabels(TASKS) |
| for i in range(len(TASKS)): |
| for j in range(len(TASKS)): |
| v = arr[i, j] |
| if not np.isnan(v): |
| ax.text(j, i, f"{v:.2f}", ha="center", va="center", |
| color="white" if abs(v) > 0.5 else "black", fontsize=9) |
| fig.colorbar(im, ax=ax, fraction=0.046, pad=0.04) |
| fig.tight_layout() |
| fig.savefig(out_pdf, bbox_inches="tight") |
| plt.close(fig) |
|
|
|
|
| def render_baseline_floor(bf: pd.DataFrame, out: Path) -> None: |
| df = bf.copy() |
| df["naive_floor"] = df["naive_floor"].map(fmt) |
| df.columns = ["Task", "Naive floor", "\\# beating", "\\# failing"] |
| out.write_text(latex_table( |
| df, caption="Saturation analysis: per-task best-naive baseline value " |
| "and counts of non-naive methods beating / failing it.", |
| label="tab:baseline-floor", |
| )) |
|
|
|
|
| def render_failure_modes(fm: pd.DataFrame, out: Path) -> None: |
| pv = fm.pivot(index="method", columns="task", values="mode") |
| pv = pv.reindex(index=PANEL, columns=TASKS) |
| pv = pv.reset_index() |
| pv["method"] = pv["method"].map(tex_safe) |
| pv.columns = ["Method"] + TASKS |
| out.write_text(latex_table( |
| pv, |
| caption="Per-cell failure-mode taxonomy. ok = reasonable predictions; " |
| "parser\\_fail = $>$50\\% NaN after parser; " |
| "saturation = constant predictions near zero; " |
| "scale\\_blowup = parser-induced extreme values.", |
| label="tab:failure-modes", |
| )) |
|
|
|
|
| def render_per_task_table(panel: pd.DataFrame, task: str, out: Path) -> None: |
| df = panel[panel["task"] == task].sort_values("value")[["method", "value"]].copy() |
| df["method"] = df["method"].map(tex_safe) |
| df["value"] = df["value"].map(fmt) |
| metric_label = LABEL.get(PRIMARY[task], PRIMARY[task]) |
| df.columns = ["Method", metric_label] |
| out.write_text(latex_table( |
| df, caption=f"{task} per-method primary metric ({metric_label}).", |
| label=f"tab:per-task-{task}", |
| )) |
|
|
|
|
| def render_ablation_4panel(abl: pd.DataFrame, out: Path) -> None: |
| """4 panels (T1, T2, T4, T5); two lines per panel (gpt51, gemini3_flash).""" |
| import matplotlib |
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
| fig, axes = plt.subplots(1, 4, figsize=(13, 3.0)) |
| colors = {"gpt51": "#1f77b4", "gemini3_flash": "#d62728"} |
| nice = {"gpt51": "GPT-5.1", "gemini3_flash": "Gemini-3-Flash"} |
| for ax, t in zip(axes, ABL_TASKS): |
| for m in ABL_MODELS: |
| sub = abl[(abl["method"] == m) & (abl["task"] == t)] |
| sub = sub.set_index("setting").reindex(SETTINGS)["value"] |
| ax.plot(SETTINGS, sub.values, marker="o", color=colors[m], |
| label=nice[m], linewidth=1.6, markersize=5) |
| ax.set_title(f"{t} ({LABEL[PRIMARY[t]].replace(chr(92)+'%', '%')})", fontsize=10) |
| ax.set_xlabel("Context setting (A→E)", fontsize=9) |
| ax.tick_params(axis="both", labelsize=8) |
| ax.grid(True, alpha=0.3, linewidth=0.4) |
| if t == "T1": |
| ax.set_yscale("log") |
| ax.set_ylabel("MSE (log)", fontsize=9) |
| else: |
| ax.set_ylabel(LABEL[PRIMARY[t]].replace("\\%", "%"), fontsize=9) |
| axes[0].legend(loc="best", fontsize=8, frameon=True) |
| fig.tight_layout() |
| fig.savefig(out, bbox_inches="tight") |
| plt.close(fig) |
|
|
|
|
| |
|
|
| def main() -> int: |
| p = argparse.ArgumentParser() |
| p.add_argument("--predictions-dir", required=True, type=Path) |
| p.add_argument("--reeval", required=True, type=Path) |
| p.add_argument("--output-dir", required=True, type=Path) |
| args = p.parse_args() |
| args.output_dir.mkdir(parents=True, exist_ok=True) |
| O = args.output_dir |
|
|
| panel, abl = load_metrics(args.reeval) |
| pkls = load_pkls(args.predictions_dir) |
|
|
| panel.to_csv(O / "panel_metrics.csv", index=False) |
| abl.to_csv(O / "ablation_metrics.csv", index=False) |
|
|
| |
| render_t1_leaderboard(panel, O / "tab_t1_leaderboard.tex") |
| gap = t2_t5_gap(panel); gap.to_csv(O / "t2_t5_gap.csv", index=False) |
| render_t2_t5_gap(gap, O / "tab_t2_t5_gap.tex") |
| rho = cross_task_correlation(panel); rho.to_csv(O / "cross_task_correlation.csv") |
| render_correlation(rho, O / "tab_cross_task_corr.tex", O / "fig_cross_task_corr.pdf") |
| render_ablation_4panel(abl, O / "fig_ablation_4panel.pdf") |
|
|
| |
| bf = baseline_floor(panel); bf.to_csv(O / "baseline_floor.csv", index=False) |
| render_baseline_floor(bf, O / "tab_baseline_floor.tex") |
| fm = failure_modes(pkls); fm.to_csv(O / "failure_modes.csv", index=False) |
| render_failure_modes(fm, O / "tab_failure_modes.tex") |
|
|
| |
| for t in TASKS: |
| render_per_task_table(panel, t, O / f"tab_per_task_{t}.tex") |
|
|
| |
| |
| |
| |
| for task, key, metric, name in [ |
| ("T1", "sector", "mse", "T1_sector"), |
| ("T2", "mcap_q", "median_ape", "T2_mcap_q"), |
| ("T5", "mcap_q", "median_ape", "T5_mcap_q"), |
| ("T4", "event_type", "return_mae_pct", "T4_event_type"), |
| ]: |
| s = stratify(pkls, task, key, metric) |
| if not s.empty: |
| s.to_csv(O / f"stratify_{name}.csv", index=False) |
|
|
| print(f"\nOK — wrote {len(list(O.iterdir()))} artifacts to {O}") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
