| |
| """Build a run-level WandB/profiling inventory from benchmark metadata. |
| |
| This intentionally inventories links and run summaries, not trace blobs. The |
| large profiler outputs stay in their original artifact stores; the CSV gives the |
| paper/class-grading path a compact "what exists and where" surface. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| from pathlib import Path |
| from urllib.parse import urlparse |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
|
|
| DEFAULT_BENCHMARKS = ROOT / "benchmarks" |
| DEFAULT_SCORES = ROOT / "results" / "metrics" / "scenario_scores.jsonl" |
| DEFAULT_REGISTRY = ROOT / "results" / "metrics" / "evidence_registry.csv" |
| DEFAULT_OUT = ROOT / "results" / "metrics" / "profiling_inventory.csv" |
|
|
| OUTPUT_COLUMNS = [ |
| "benchmark_run_dir", |
| "run_name", |
| "benchmark_cell_dir", |
| "experiment_cell", |
| "orchestration_mode", |
| "mcp_mode", |
| "model_id", |
| "git_sha", |
| "registry_status", |
| "include_in_paper", |
| "registry_reason", |
| "run_status", |
| "started_at", |
| "finished_at", |
| "total_runs", |
| "pass", |
| "fail", |
| "has_wandb", |
| "wandb_run_id", |
| "wandb_run_url", |
| "has_profiling", |
| "profiling_dir", |
| "profiling_artifact", |
| "has_profiling_summary", |
| "profiling_gpu_util_mean", |
| "profiling_gpu_util_max", |
| "profiling_gpu_mem_used_mib_mean", |
| "profiling_gpu_mem_used_mib_max", |
| "profiling_power_draw_w_mean", |
| "profiling_power_draw_w_max", |
| "profiling_nvidia_smi_samples", |
| "notes", |
| ] |
|
|
| CELL_DIR_FALLBACKS = { |
| "cell_A_direct": "A", |
| "cell_B_mcp_baseline": "B", |
| "cell_C_mcp_optimized": "C", |
| "cell_D": "D", |
| "cell_ZSD": "ZSD", |
| } |
|
|
|
|
| def load_json(path: Path) -> dict: |
| with path.open(encoding="utf-8") as f: |
| return json.load(f) |
|
|
|
|
| def load_score_lookup(path: Path) -> dict[str, dict]: |
| if not path.exists(): |
| return {} |
| lookup: dict[str, dict] = {} |
| with path.open(encoding="utf-8") as f: |
| for line in f: |
| if not line.strip(): |
| continue |
| row = json.loads(line) |
| run_name = row.get("run_name") |
| if run_name and run_name not in lookup: |
| lookup[run_name] = { |
| "experiment_cell": row.get("experiment_cell"), |
| "orchestration_mode": row.get("orchestration_mode"), |
| "mcp_mode": row.get("mcp_mode"), |
| "model_id": row.get("model_id"), |
| "wandb_run_url": row.get("wandb_run_url"), |
| } |
| return lookup |
|
|
|
|
| def load_registry(path: Path) -> dict[str, dict[str, str]]: |
| if not path.exists(): |
| return {} |
| with path.open(encoding="utf-8", newline="") as f: |
| return {row["run_name"]: row for row in csv.DictReader(f)} |
|
|
|
|
| def infer_cell(cell_dir: str, run_name: str) -> str: |
| if cell_dir in CELL_DIR_FALLBACKS: |
| return CELL_DIR_FALLBACKS[cell_dir] |
| if cell_dir == "cell_Y_plan_execute": |
| return "YS" if "self_ask" in run_name else "Y" |
| if cell_dir == "cell_Z_hybrid": |
| return "ZS" if "self_ask" in run_name else "Z" |
| if cell_dir.startswith("cell_"): |
| return cell_dir.removeprefix("cell_") |
| return "" |
|
|
|
|
| def infer_orchestration(cell: str, run_name: str) -> str: |
| if cell in {"A", "B", "C", "D"} or cell.endswith("70B"): |
| return "agent_as_tool" |
| if cell.startswith("Y"): |
| return "plan_execute" |
| if cell.startswith("Z"): |
| return "verified_pe" |
| if "verified_pe" in run_name: |
| return "verified_pe" |
| if "pe_" in run_name: |
| return "plan_execute" |
| if "aat" in run_name: |
| return "agent_as_tool" |
| return "" |
|
|
|
|
| def infer_mcp_mode(cell: str, run_name: str) -> str: |
| if cell == "A" or cell == "A70B" or "_aat_direct" in run_name: |
| return "direct" |
| if "optimized" in run_name or cell in {"C", "D", "ZSD"}: |
| return "optimized" |
| if "baseline" in run_name or cell in {"B", "Y", "YS", "Z", "ZS"}: |
| return "baseline" |
| return "" |
|
|
|
|
| def wandb_run_id(url: str) -> str: |
| if not url: |
| return "" |
| path = urlparse(url).path.rstrip("/") |
| return path.rsplit("/", 1)[-1] if path else "" |
|
|
|
|
| def flatten_summary(summary: dict | None, key: str) -> object: |
| if not isinstance(summary, dict): |
| return "" |
| return summary.get(key, "") |
|
|
|
|
| def bool_s(value: object) -> str: |
| return "true" if bool(value) else "false" |
|
|
|
|
| def build_rows( |
| benchmarks_dir: Path, |
| scores_path: Path, |
| registry_path: Path, |
| ) -> list[dict[str, object]]: |
| score_lookup = load_score_lookup(scores_path) |
| registry = load_registry(registry_path) |
| rows: list[dict[str, object]] = [] |
|
|
| for meta_path in sorted(benchmarks_dir.glob("*/raw/*/meta.json")): |
| meta = load_json(meta_path) |
| run_dir = meta_path.parent |
| cell_dir = run_dir.parents[1].name |
| run_name = meta.get("run_name") or run_dir.name |
| score = score_lookup.get(run_name, {}) |
| reg = registry.get(run_name, {}) |
|
|
| inferred_cell = infer_cell(cell_dir, run_name) |
| experiment_cell = ( |
| meta.get("experiment_cell") or inferred_cell or score.get("experiment_cell") |
| ) |
| orchestration_mode = ( |
| meta.get("orchestration_mode") |
| or score.get("orchestration_mode") |
| or infer_orchestration(experiment_cell, run_name) |
| ) |
| mcp_mode = ( |
| meta.get("mcp_mode") |
| or score.get("mcp_mode") |
| or infer_mcp_mode(experiment_cell, run_name) |
| ) |
| wandb_url = meta.get("wandb_run_url") or score.get("wandb_run_url") or "" |
| profiling_dir = meta.get("profiling_dir") or "" |
| profiling_artifact = meta.get("profiling_artifact") or "" |
| profiling_summary = meta.get("profiling_summary") |
| has_profiling_summary = isinstance(profiling_summary, dict) and bool( |
| profiling_summary |
| ) |
| has_profiling = bool( |
| profiling_dir or profiling_artifact or has_profiling_summary |
| ) |
|
|
| notes = "" |
| if has_profiling_summary: |
| notes = "profiling summary present in meta.json" |
| elif has_profiling: |
| notes = "profiling artifact linked; summary stats absent from meta.json" |
| elif wandb_url: |
| notes = "wandb only" |
|
|
| rows.append( |
| { |
| "benchmark_run_dir": run_dir.relative_to(ROOT).as_posix(), |
| "run_name": run_name, |
| "benchmark_cell_dir": cell_dir, |
| "experiment_cell": experiment_cell, |
| "orchestration_mode": orchestration_mode, |
| "mcp_mode": mcp_mode, |
| "model_id": meta.get("model_id") or score.get("model_id") or "", |
| "git_sha": meta.get("git_sha", ""), |
| "registry_status": reg.get("status", ""), |
| "include_in_paper": reg.get("include_in_paper", ""), |
| "registry_reason": reg.get("reason", ""), |
| "run_status": meta.get("run_status", ""), |
| "started_at": meta.get("started_at", ""), |
| "finished_at": meta.get("finished_at", ""), |
| "total_runs": meta.get("total_runs", ""), |
| "pass": meta.get("pass", ""), |
| "fail": meta.get("fail", ""), |
| "has_wandb": bool_s(wandb_url), |
| "wandb_run_id": wandb_run_id(wandb_url), |
| "wandb_run_url": wandb_url, |
| "has_profiling": bool_s(has_profiling), |
| "profiling_dir": profiling_dir, |
| "profiling_artifact": profiling_artifact, |
| "has_profiling_summary": bool_s(has_profiling_summary), |
| "profiling_gpu_util_mean": flatten_summary( |
| profiling_summary, "profiling/gpu_util_mean" |
| ), |
| "profiling_gpu_util_max": flatten_summary( |
| profiling_summary, "profiling/gpu_util_max" |
| ), |
| "profiling_gpu_mem_used_mib_mean": flatten_summary( |
| profiling_summary, "profiling/gpu_mem_used_mib_mean" |
| ), |
| "profiling_gpu_mem_used_mib_max": flatten_summary( |
| profiling_summary, "profiling/gpu_mem_used_mib_max" |
| ), |
| "profiling_power_draw_w_mean": flatten_summary( |
| profiling_summary, "profiling/power_draw_w_mean" |
| ), |
| "profiling_power_draw_w_max": flatten_summary( |
| profiling_summary, "profiling/power_draw_w_max" |
| ), |
| "profiling_nvidia_smi_samples": flatten_summary( |
| profiling_summary, "profiling/nvidia_smi_samples" |
| ), |
| "notes": notes, |
| } |
| ) |
|
|
| rows.sort( |
| key=lambda row: ( |
| row["experiment_cell"] or "", |
| row["run_name"] or "", |
| row["benchmark_run_dir"] or "", |
| ) |
| ) |
| return rows |
|
|
|
|
| def write_csv(path: Path, rows: list[dict[str, object]]) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with path.open("w", encoding="utf-8", newline="") as f: |
| writer = csv.DictWriter(f, fieldnames=OUTPUT_COLUMNS, lineterminator="\n") |
| writer.writeheader() |
| writer.writerows(rows) |
|
|
|
|
| def display_path(path: Path) -> str: |
| resolved = path.resolve() |
| try: |
| return resolved.relative_to(ROOT).as_posix() |
| except ValueError: |
| return resolved.as_posix() |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--benchmarks", type=Path, default=DEFAULT_BENCHMARKS) |
| parser.add_argument("--scores", type=Path, default=DEFAULT_SCORES) |
| parser.add_argument("--registry", type=Path, default=DEFAULT_REGISTRY) |
| parser.add_argument("--out", type=Path, default=DEFAULT_OUT) |
| args = parser.parse_args() |
|
|
| rows = build_rows(args.benchmarks, args.scores, args.registry) |
| write_csv(args.out, rows) |
| print(f"wrote {len(rows)} rows to {display_path(args.out)}") |
| print( |
| "coverage: " |
| f"{sum(r['has_wandb'] == 'true' for r in rows)} W&B-linked, " |
| f"{sum(r['has_profiling'] == 'true' for r in rows)} profiler-linked, " |
| f"{sum(r['has_profiling_summary'] == 'true' for r in rows)} with summary stats" |
| ) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
