"""Paper figure generator. Produces four PDF figures for the MacroLens NeurIPS 2026 D&B paper. Source of truth: aggregated long-DataFrame from :mod:`experiments.aggregate_results` (or load directly from a results JSON glob via the CLI below). Figures (all panel-driven; method ordering follows the registry's ``family -> name`` sort): * ``fig_panel_overview`` - Figure 1 (page-1 schematic): grid of 7 tasks x 7 families with counts where the family covers the task. Plus the benchmark headline numbers (4,416 tickers, 131 features, 1,130 events). * ``fig_primary_metric_per_task`` - One subplot per task; horizontal bar chart of method primary-metric values with bootstrap-CI error bars; methods ordered by primary metric (best at top). * ``fig_per_family_box`` - One subplot per task; box-and-whisker of primary metric grouped by family (n=members in that family that cover the task). Shows family-level distribution. * ``fig_zs_vs_ft`` - Bar chart: ZS vs FT for the LLM family (the 3 frontier models), only on T1. (Single-horizon experiment design — no horizon-curve figure; horizon is fixed to the longest configured value per granularity, e.g. 252 daily.) CLI:: python -m projects.agent_builder.scripts.whatif_bench.experiments.gen_figures \ --results-glob 'experiments/results/canon_*.json' \ --output-dir 'experiments/paper_artifacts/figures/' \ --granularity daily Headless: matplotlib is forced to the ``Agg`` backend so the script runs on a GPU box / CI without an X server. Each figure is saved as both ``.pdf`` (vector, for LaTeX) and ``.png`` (raster, for previews / quicklook). """ from __future__ import annotations import argparse import glob import logging from pathlib import Path from typing import Iterable import matplotlib matplotlib.use("Agg") # headless import matplotlib.pyplot as plt # noqa: E402 import numpy as np # noqa: E402 import pandas as pd # noqa: E402 from .. import config # noqa: E402 from . import panel # noqa: E402 from .aggregate_results import ( # noqa: E402 _PRIMARY_METRIC_KEY, _PRIMARY_METRIC_LOWER_IS_BETTER, _load_records, _records_to_long_df, aggregate, ) logger = logging.getLogger(__name__) # Friendly family display name + plot colour. Stable across all figures so # the same family always reads as the same hue. _FAMILY_ORDER: tuple[str, ...] = ( "naive", "classical", "sequence", "tsfm", "llm_ts", "llm", ) _FAMILY_DISPLAY: dict[str, str] = { "naive": "Naive", "classical": "Classical", "sequence": "Deep Seq", "tsfm": "TSFM", "llm_ts": "LLM-TS", "llm": "LLM", } _FAMILY_COLOR: dict[str, str] = { "naive": "tab:gray", "classical": "tab:olive", "sequence": "tab:blue", "tsfm": "tab:cyan", "llm_ts": "tab:purple", "llm": "tab:orange", } # Registry-family aliases used by the runner inside the long DataFrame's # ``method_family`` column. Panel and registry now use the same canonical # family names ("tsfm", "llm", "llm_ts"); the alias map is a no-op kept # only so adding a new family later is a one-line change. _FAMILY_ALIASES: dict[str, str] = {} def _canonical_family(family: str) -> str: return _FAMILY_ALIASES.get(family, family) def _save_fig(fig: plt.Figure, output_path: Path) -> tuple[Path, Path]: """Save *fig* as both ``output_path.pdf`` and ``output_path.png``.""" output_path = Path(output_path) output_path.parent.mkdir(parents=True, exist_ok=True) pdf = output_path.with_suffix(".pdf") png = output_path.with_suffix(".png") fig.savefig(pdf, bbox_inches="tight", dpi=300) fig.savefig(png, bbox_inches="tight", dpi=200) plt.close(fig) return pdf, png def _method_display(method_id: str) -> str: """Display name for *method_id* (panel-aware, registry-fallback).""" for m in panel.ALL_METHODS: if m.id == method_id: return m.name return method_id def _primary_view(df: pd.DataFrame, task: str) -> pd.DataFrame: """Per-method mean-over-seeds view of the task's primary metric.""" metric = _PRIMARY_METRIC_KEY.get(task) if metric is None or df.empty: return pd.DataFrame() sub = df[(df["task"] == task) & (df["metric_name"] == metric)].copy() if sub.empty: return sub grouped = ( sub.groupby(["method_id", "method_family"], as_index=False) .agg(value=("value", "mean"), ci_lo=("ci_lo", "mean"), ci_hi=("ci_hi", "mean"), std=("std", "mean")) ) grouped["family"] = grouped["method_family"].map(_canonical_family) grouped["display"] = grouped["method_id"].map(_method_display) grouped = grouped.dropna(subset=["value"]) return grouped # --------------------------------------------------------------------------- # Figure 1: panel overview (task x family coverage matrix) # --------------------------------------------------------------------------- def fig_panel_overview(df: pd.DataFrame, output_path: Path) -> tuple[Path, Path]: """Page-1 schematic: 7 tasks x 7 families coverage grid + headline numbers. *df* is unused for the static schematic; accepted to keep the figure-API uniform across the five generators. """ tasks = list(panel.ALL_TASKS) families = list(_FAMILY_ORDER) # Build coverage matrix from panel.ALL_METHODS (canonical 18-method panel). coverage = np.zeros((len(families), len(tasks)), dtype=int) for m in panel.ALL_METHODS: if m.family not in _FAMILY_DISPLAY: continue # unknown family – skip i = families.index(m.family) for t in m.tasks: if t in tasks: j = tasks.index(t) coverage[i, j] += 1 fig, ax = plt.subplots(figsize=(8.5, 4.0)) # Heatmap with a reversed grayscale palette so 0 = white, n>0 = darker. im = ax.imshow(coverage, aspect="auto", cmap="Blues", vmin=0, vmax=max(1, int(coverage.max()))) ax.set_xticks(range(len(tasks))) ax.set_xticklabels(tasks, fontsize=10) ax.set_yticks(range(len(families))) ax.set_yticklabels([_FAMILY_DISPLAY[f] for f in families], fontsize=10) for i in range(len(families)): for j in range(len(tasks)): n = coverage[i, j] if n > 0: ax.text(j, i, str(n), ha="center", va="center", color="white" if n >= 2 else "black", fontsize=10) ax.set_title("MacroLens method-x-task coverage " "(4,416 tickers; 131 features; 1,130 events)", fontsize=11) fig.colorbar(im, ax=ax, label="# methods") fig.tight_layout() return _save_fig(fig, output_path) # --------------------------------------------------------------------------- # Figure 2: primary metric per task # --------------------------------------------------------------------------- def fig_primary_metric_per_task(df: pd.DataFrame, output_path: Path) -> tuple[Path, Path]: """One horizontal-bar subplot per task; bars sorted best-on-top.""" tasks = list(panel.ALL_TASKS) n_tasks = len(tasks) ncols = 2 nrows = (n_tasks + ncols - 1) // ncols fig, axes = plt.subplots(nrows, ncols, figsize=(11, 2.4 * nrows + 1.0), squeeze=False) axes_flat = axes.flatten() any_data = False for k, t in enumerate(tasks): ax = axes_flat[k] view = _primary_view(df, t) primary = _PRIMARY_METRIC_KEY[t] ascending = _PRIMARY_METRIC_LOWER_IS_BETTER[t] if view.empty: ax.set_axis_off() ax.set_title(f"{t} — no records") continue any_data = True view = view.sort_values("value", ascending=ascending).reset_index(drop=True) # Reverse so best-on-top after barh paints bottom-up. view = view.iloc[::-1].reset_index(drop=True) y = np.arange(len(view)) # Symmetric error length from CI; fall back to std if CI absent. lo = view["value"].to_numpy() - view["ci_lo"].to_numpy() hi = view["ci_hi"].to_numpy() - view["value"].to_numpy() lo = np.where(np.isnan(lo), view["std"].fillna(0).to_numpy(), lo) hi = np.where(np.isnan(hi), view["std"].fillna(0).to_numpy(), hi) lo = np.clip(lo, 0, None) hi = np.clip(hi, 0, None) colors = [_FAMILY_COLOR.get(f, "tab:gray") for f in view["family"]] ax.barh(y, view["value"], xerr=[lo, hi], color=colors, edgecolor="black", linewidth=0.4, capsize=2) ax.set_yticks(y) ax.set_yticklabels(view["display"], fontsize=8) ax.set_title(f"{t} ({primary})", fontsize=10) ax.tick_params(axis="x", labelsize=8) # Hide unused axes for k in range(len(tasks), len(axes_flat)): axes_flat[k].set_axis_off() # Family legend – only families that actually appear. seen_fams = sorted({_canonical_family(f) for f in df["method_family"].unique() if isinstance(f, str)}) if not df.empty else [] handles = [plt.Rectangle((0, 0), 1, 1, color=_FAMILY_COLOR[f]) for f in seen_fams if f in _FAMILY_COLOR] labels = [_FAMILY_DISPLAY[f] for f in seen_fams if f in _FAMILY_COLOR] if handles: fig.legend(handles, labels, ncol=min(len(handles), 4), loc="lower center", bbox_to_anchor=(0.5, -0.01), fontsize=8, frameon=False) fig.suptitle( "Per-task primary-metric leaderboard (mean across seeds; " "error bars = bootstrap 95% CI)" if any_data else "Per-task primary-metric leaderboard (no data)", fontsize=11, ) fig.tight_layout(rect=[0, 0.03, 1, 0.97]) return _save_fig(fig, output_path) # --------------------------------------------------------------------------- # Figure 3: T1 horizon curves # --------------------------------------------------------------------------- # --------------------------------------------------------------------------- # Figure 4: per-family box plot # --------------------------------------------------------------------------- def fig_per_family_box(df: pd.DataFrame, output_path: Path) -> tuple[Path, Path]: """One box-plot subplot per task; primary metric grouped by family.""" tasks = list(panel.ALL_TASKS) n_tasks = len(tasks) ncols = 2 nrows = (n_tasks + ncols - 1) // ncols fig, axes = plt.subplots(nrows, ncols, figsize=(11, 2.4 * nrows + 1.0), squeeze=False) axes_flat = axes.flatten() for k, t in enumerate(tasks): ax = axes_flat[k] view = _primary_view(df, t) primary = _PRIMARY_METRIC_KEY[t] if view.empty: ax.set_axis_off() ax.set_title(f"{t} — no records") continue # Group values by family, drop empties, preserve canonical order. groups: list[tuple[str, np.ndarray]] = [] for fam in _FAMILY_ORDER: arr = view.loc[view["family"] == fam, "value"].to_numpy() arr = arr[~np.isnan(arr)] if arr.size: groups.append((fam, arr)) if not groups: ax.set_axis_off() ax.set_title(f"{t} — no data") continue positions = np.arange(len(groups)) bp = ax.boxplot([g[1] for g in groups], positions=positions, widths=0.55, patch_artist=True) for box, (fam, _) in zip(bp["boxes"], groups): box.set_facecolor(_FAMILY_COLOR.get(fam, "tab:gray")) box.set_alpha(0.7) for med in bp["medians"]: med.set_color("black") ax.set_xticks(positions) ax.set_xticklabels([_FAMILY_DISPLAY[g[0]] for g in groups], rotation=30, ha="right", fontsize=8) ax.set_title(f"{t} ({primary})", fontsize=10) ax.tick_params(axis="y", labelsize=8) for k in range(len(tasks), len(axes_flat)): axes_flat[k].set_axis_off() fig.suptitle("Per-family primary-metric distribution by task", fontsize=11) fig.tight_layout(rect=[0, 0.0, 1, 0.97]) return _save_fig(fig, output_path) # --------------------------------------------------------------------------- # Figure 5: ZS vs FT (T1) # --------------------------------------------------------------------------- def fig_zs_vs_ft(df: pd.DataFrame, output_path: Path) -> tuple[Path, Path]: """Single-panel bar chart comparing ZS vs FT on T1 for the LLM family.""" fig, ax = plt.subplots(1, 1, figsize=(6.5, 4.0)) if df.empty: ax.text(0.5, 0.5, "no records", ha="center", va="center", transform=ax.transAxes); ax.set_axis_off() return _save_fig(fig, output_path) sub = df[(df["task"] == "T1") & (df["metric_name"] == "mse")].copy() sub["family"] = sub["method_family"].map(_canonical_family) sub["display"] = sub["method_id"].map(_method_display) sub["base_id"] = sub["method_id"].str.replace(r"_(zs|ft)$", "", regex=True) # ZS-vs-FT pair: zero-shot LLMs ("llm") vs fine-tuned LLMs ("llm_ft"). # The current panel reports zero-shot only, so the FT side stays empty # and the deferred-placeholder branch below handles the no-data case. title, fam_pair = "LLM", ["llm", "llm_ft"] zs = sub[sub["family"] == fam_pair[0]] ft = sub[sub["family"] == fam_pair[1]] if zs.empty and ft.empty: ax.text(0.5, 0.5, f"{title}: no data", ha="center", va="center", transform=ax.transAxes); ax.set_axis_off() fig.suptitle("Zero-shot vs fine-tuned, T1 only", fontsize=11) fig.tight_layout(rect=[0, 0, 1, 0.97]) return _save_fig(fig, output_path) zs_avg = (zs.groupby("base_id", as_index=False)["value"].mean() .rename(columns={"value": "zs"})) ft_avg = (ft.groupby("base_id", as_index=False)["value"].mean() .rename(columns={"value": "ft"})) merged = zs_avg.merge(ft_avg, on="base_id", how="outer") if merged.empty: ax.text(0.5, 0.5, f"{title}: no data", ha="center", va="center", transform=ax.transAxes); ax.set_axis_off() fig.suptitle("Zero-shot vs fine-tuned, T1 only", fontsize=11) fig.tight_layout(rect=[0, 0, 1, 0.97]) return _save_fig(fig, output_path) merged = merged.sort_values("base_id").reset_index(drop=True) x = np.arange(len(merged)) w = 0.36 ax.bar(x - w/2, merged["zs"].fillna(np.nan), width=w, color=_FAMILY_COLOR[fam_pair[0]], label="ZS", edgecolor="black", linewidth=0.4) ax.bar(x + w/2, merged["ft"].fillna(np.nan), width=w, color=_FAMILY_COLOR[fam_pair[1]], label="FT", edgecolor="black", linewidth=0.4) ax.set_xticks(x) ax.set_xticklabels(merged["base_id"], rotation=30, ha="right", fontsize=8) ax.set_title(f"{title} family — T1 MSE (lower = better)", fontsize=10) ax.set_ylabel("MSE", fontsize=9) ax.legend(fontsize=8, frameon=False) fig.suptitle("Zero-shot vs fine-tuned, T1 only", fontsize=11) fig.tight_layout(rect=[0, 0, 1, 0.97]) return _save_fig(fig, output_path) # --------------------------------------------------------------------------- # Driver # --------------------------------------------------------------------------- ALL_FIGURES: tuple[str, ...] = ( "panel_overview", "primary_metric_per_task", "per_family_box", "zs_vs_ft", ) def render_all( df: pd.DataFrame, output_dir: Path, *, granularity: str = "daily", quick: bool = False, ) -> dict[str, tuple[Path, Path]]: """Render every paper figure from the long-form aggregator output. *quick* downsamples the long-form input to the first 32 rows of each (task, method) group to keep CI runs fast. """ output_dir = Path(output_dir) output_dir.mkdir(parents=True, exist_ok=True) out: dict[str, tuple[Path, Path]] = {} if quick and not df.empty: df = ( df.groupby(["task", "method_id"], as_index=False, group_keys=False) .head(32) ) out["panel_overview"] = fig_panel_overview(df, output_dir / "fig_panel_overview") out["primary_metric_per_task"] = fig_primary_metric_per_task( df, output_dir / "fig_primary_metric_per_task") out["per_family_box"] = fig_per_family_box(df, output_dir / "fig_per_family_box") out["zs_vs_ft"] = fig_zs_vs_ft(df, output_dir / "fig_zs_vs_ft") return out def _df_from_glob(input_glob: str) -> pd.DataFrame: paths = [Path(p) for p in sorted(glob.glob(input_glob))] records, n_skip, n_mig = _load_records(paths) logger.info("loaded %d records (%d non-ok, %d migrated v1->v2)", len(records), n_skip, n_mig) return _records_to_long_df(records) def main(argv: list[str] | None = None) -> int: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument( "--results-glob", type=str, default=str(Path(__file__).resolve().parent / "results" / "canon_*.json"), help="Glob pointing to RunRecord JSON files.", ) parser.add_argument( "--output-dir", type=Path, default=Path(__file__).resolve().parent / "paper_artifacts" / "figures", help="Directory to write fig_*.pdf / fig_*.png pairs.", ) parser.add_argument( "--granularity", default="daily", choices=["daily", "weekly", "monthly"], ) parser.add_argument( "--quick", action="store_true", help="Downsample long-form input for faster CI runs.", ) args = parser.parse_args(argv) logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s") df = _df_from_glob(args.results_glob) out = render_all(df, args.output_dir, granularity=args.granularity, quick=args.quick) for name, (pdf, png) in out.items(): logger.info("wrote %s -> %s", name, pdf) return 0 if __name__ == "__main__": # pragma: no cover import sys sys.exit(main())