code backup: calibration (calibration module + question_ids plumbing + pilot sample)

calibration/__init__.py

@@ -0,0 +1,30 @@
+"""Reasoning-budget calibration pilot: find the right EXTENDED budget before the
+main sweeps commit to one.
+
+Everything is operator-specified -- no baked-in defaults decide the experiment: the
+budget list (--budgets), the exact question set (--questions / --questions-file),
+and the spatial-code format (--spatial-code-format) are all required CLI inputs.
+Each (model, budget) pair runs through harness.B's unmodified extended path (only
+``reasoning_budget`` varies), restricted to the given questions; multi-GPU comes
+free because harness.B.launch already shards scenes across every visible GPU (e.g.
+4 H100s). calibration.report then shows, per budget: official accuracy,
+forced-continuation rate, natural-stop reasoning length, and latency, with a fixed
+recommendation rule.
+
+The main plan's 2048 default stays pre-registered; if this pilot moves it, that is a
+documented pre-launch decision (record the chosen value in
+analysis/preregistration.md before Step 1), not a mid-experiment change.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from harness.A import WORKSPACE_ROOT
+
+# One JSON per question:
+# results/calibration/<model>/<spatial_code_format>/<budget>/<scene>/<question_id>.json
+RESULTS_DIR = Path(
+    os.environ.get("VSI_CALIBRATION_RESULTS_DIR", WORKSPACE_ROOT / "results" / "calibration")
+)

calibration/report.py

@@ -0,0 +1,154 @@
+"""Report the budget-calibration grid and recommend a reasoning budget.
+
+Per (model, budget) cell, over the exact question-id intersection shared by every
+budget of that model (so no budget is scored on an easier subset): official overall
+accuracy, forced-continuation rate, mean reasoning tokens on natural stops, and mean
+generation seconds. Recommendation rule (stated up front, not tuned after looking):
+the SMALLEST budget whose overall is within ``--tolerance`` points of that model's
+best AND whose forced rate is at most ``--max-forced-rate`` -- accuracy saturation
+alone is not enough, because a budget that forces half its answers is measuring the
+force prompt, not the model's reasoning.
+
+Usage:
+    python -m calibration.report [--tolerance 1.0] [--max-forced-rate 0.15] [--json]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import statistics
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
+if str(WORKSPACE_ROOT) not in sys.path:
+    sys.path.insert(0, str(WORKSPACE_ROOT))
+
+from analysis.aggregate import _official_scores, iter_records  # noqa: E402
+from calibration import RESULTS_DIR  # noqa: E402
+
+
+def load_grid(results_dir=None):
+    """{"<model>/<format>/<depth>/<tracking>/<input>/<frames>": {budget: {question_id:
+    record}}} from the calibration tree. Budget directories are found by walking to
+    every all-digit directory whose PARENT chain starts at the root -- frame-count
+    directories are also numeric, so a budget leaf is specifically a numeric
+    directory whose own subdirectories are scene result folders (contain .json
+    files), not further numeric config levels."""
+    root = Path(results_dir or RESULTS_DIR)
+    grid = defaultdict(dict)
+    if not root.is_dir():
+        return dict(grid)
+    for budget_dir in sorted(root.rglob("*")):
+        if not budget_dir.is_dir() or not budget_dir.name.isdigit():
+            continue
+        # A budget leaf holds scene folders with question JSONs directly below it.
+        has_question_files = any(
+            child.is_dir() and any(grand.suffix == ".json" for grand in child.iterdir())
+            for child in budget_dir.iterdir()
+        )
+        if not has_question_files:
+            continue
+        records = {r["question_id"]: r for r in iter_records(budget_dir)}
+        if records:
+            cell = str(budget_dir.parent.relative_to(root))
+            grid[cell][int(budget_dir.name)] = records
+    return dict(grid)
+
+
+def cell_stats(records):
+    """Accuracy + budget-behavior stats for one (model, budget) cell's records."""
+    rows = list(records)
+    forced = [1.0 if r.get("forced") else 0.0 for r in rows]
+    natural_lengths = [
+        r["reasoning_token_count"]
+        for r in rows
+        if r.get("reasoning_token_count") is not None and not r.get("forced")
+    ]
+    return {
+        "count": len(rows),
+        "overall": _official_scores(rows).get("overall"),
+        "forced_rate": statistics.mean(forced) if forced else None,
+        "natural_reasoning_tokens_mean": (
+            statistics.mean(natural_lengths) if natural_lengths else None
+        ),
+        "generation_seconds_mean": statistics.mean(r["generation_seconds"] for r in rows),
+    }
+
+
+def report(grid, tolerance=1.0, max_forced_rate=0.15):
+    """{model: {"budgets": {budget: stats}, "recommended": budget_or_None}} over each
+    model's shared question intersection across its budgets."""
+    out = {}
+    for model, budgets in grid.items():
+        common = set.intersection(*(set(records) for records in budgets.values()))
+        stats = {
+            budget: cell_stats(records[qid] for qid in common)
+            for budget, records in sorted(budgets.items())
+        }
+        scored = {b: s for b, s in stats.items() if s["overall"] is not None}
+        recommended = None
+        if scored:
+            best = max(s["overall"] for s in scored.values())
+            for budget in sorted(scored):
+                s = scored[budget]
+                if s["overall"] >= best - tolerance and (
+                    s["forced_rate"] is None or s["forced_rate"] <= max_forced_rate
+                ):
+                    recommended = budget
+                    break
+        out[model] = {
+            "questions": len(common),
+            "budgets": stats,
+            "recommended": recommended,
+        }
+    return out
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--results-dir", default=None)
+    parser.add_argument(
+        "--tolerance", type=float, default=1.0,
+        help="accuracy points a budget may trail the best and still be recommended",
+    )
+    parser.add_argument(
+        "--max-forced-rate", type=float, default=0.15, dest="max_forced_rate",
+        help="maximum acceptable forced-continuation rate for a recommended budget",
+    )
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+
+    grid = load_grid(args.results_dir)
+    if not grid:
+        print("no calibration results found -- run calibration.run first")
+        raise SystemExit(1)
+    result = report(grid, tolerance=args.tolerance, max_forced_rate=args.max_forced_rate)
+    if args.json:
+        print(json.dumps(result, indent=1))
+        return
+    for model, model_report in result.items():
+        print(f"=== {model} ({model_report['questions']} shared questions) ===")
+        for budget, stats in model_report["budgets"].items():
+            overall = f"{stats['overall']:.2f}" if stats["overall"] is not None else "-"
+            forced = f"{stats['forced_rate']:.3f}" if stats["forced_rate"] is not None else "-"
+            natural = (
+                f"{stats['natural_reasoning_tokens_mean']:.0f}"
+                if stats["natural_reasoning_tokens_mean"] is not None else "-"
+            )
+            print(
+                f"  {budget:>6} tokens: overall={overall} forced_rate={forced} "
+                f"natural_reasoning_mean={natural} "
+                f"gen_seconds_mean={stats['generation_seconds_mean']:.2f}"
+            )
+        print(f"  RECOMMENDED: {model_report['recommended']}")
+    print(
+        "\nIf the recommendation differs from the pre-registered 2048, record the new "
+        "value in analysis/preregistration.md BEFORE Step 1 runs."
+    )
+
+
+if __name__ == "__main__":
+    main()

calibration/run.py

@@ -0,0 +1,173 @@
+"""Run the reasoning-budget grid: every (model, budget) pair through
+harness.B.launch, restricted to the operator's exact question list, one pair at a
+time, each saturating every visible GPU.
+
+The operator decides everything: which budgets, which questions, which format, and
+which perceived-code config (depth / tracking / input selection / frame count) --
+scenes are derived automatically from the given question ids, and every axis is a
+results-path segment so pilots at different configs can never collide.
+
+Usage (pilot on 4 H100s):
+    python -m calibration.run --models all --budgets 256,512,1024 \\
+        --questions 12,34,56,789 --spatial-code-format explicit \\
+        --depth metric --tracking tracking --input-selection selective --frames 64
+    python -m calibration.run --models qwen3.5-4b --budgets 512,1024,2048 \\
+        --questions-file my_pilot_questions.json --spatial-code-format compact \\
+        --depth relative --tracking tracking --input-selection selective --frames 32
+
+Then: python -m calibration.report
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
+if str(WORKSPACE_ROOT) not in sys.path:
+    sys.path.insert(0, str(WORKSPACE_ROOT))
+
+from calibration import RESULTS_DIR  # noqa: E402
+from harness.A import models as vlm_models  # noqa: E402
+from harness.A.run import load_questions  # noqa: E402
+from harness.A.sweep import _parse_csv_choice  # noqa: E402
+from harness.B import (  # noqa: E402
+    DEPTH_VARIANTS,
+    INPUT_SELECTIONS,
+    SPATIAL_CODE_FORMATS,
+    TRACKING_MODES,
+)
+from harness.B import launch as harness_b_launch  # noqa: E402
+
+
+def results_dir_for(model, spatial_code_format, depth, tracking, input_selection, frame_count, budget):
+    """Return the result root isolated by every pilot axis -- model, format, the full
+    perceived-code config, and the reasoning budget -- so no two pilots collide."""
+    return (
+        RESULTS_DIR / model / spatial_code_format / depth / tracking
+        / input_selection / str(frame_count) / str(budget)
+    )
+
+
+def build_plan(models, budgets):
+    """Every (model, budget) pair, cheapest budget first so early results land
+    soonest and a mid-pilot abort still yields comparable low-budget cells."""
+    return [(model, budget) for budget in sorted(budgets) for model in models]
+
+
+def scenes_for(question_ids):
+    """The scenes covering the given question ids (harness.B.launch shards by
+    scene). Raises on ids that don't exist in the manifest -- a typo in the pilot's
+    question list should fail loudly, not silently shrink the pilot."""
+    scene_of = {row["id"]: row["scene_name"] for row in load_questions()}
+    unknown = sorted(qid for qid in question_ids if qid not in scene_of)
+    if unknown:
+        raise ValueError(f"question id(s) not in the VSI-Bench manifest: {unknown}")
+    return sorted({scene_of[qid] for qid in question_ids})
+
+
+def run_grid(
+    models, budgets, question_ids, spatial_code_format,
+    depth, tracking, input_selection, frame_count,
+    rebuild=False,
+):
+    """Run every (model, budget) pair through harness.B.launch -- the unmodified
+    extended path, only ``reasoning_budget`` varies -- on the operator's questions."""
+    question_ids = set(question_ids)
+    selected_scenes = scenes_for(question_ids)
+    print(
+        f"pilot: {len(question_ids)} question(s) over {len(selected_scenes)} scene(s), "
+        f"format={spatial_code_format}, config={depth}/{tracking}/{input_selection}/"
+        f"{frame_count}, budgets={sorted(budgets)}",
+        flush=True,
+    )
+    plan = build_plan(models, budgets)
+    for index, (model, budget) in enumerate(plan, start=1):
+        print(f"=== calibration {index}/{len(plan)}: {model} @ {budget} tokens ===", flush=True)
+        harness_b_launch.launch(
+            model, spatial_code_format, input_selection, frame_count, selected_scenes,
+            depth=depth, tracking=tracking,
+            results_dir=results_dir_for(
+                model, spatial_code_format, depth, tracking, input_selection,
+                frame_count, budget,
+            ),
+            rebuild=rebuild,
+            reasoning_budget=budget,
+            question_ids=question_ids,
+        )
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--models", required=True,
+        help=f"comma-separated models (or 'all'); one of {vlm_models.available_models()}",
+    )
+    parser.add_argument(
+        "--budgets", required=True,
+        help="comma-separated reasoning budgets in tokens -- entirely your choice",
+    )
+    parser.add_argument(
+        "--questions", default=None,
+        help="comma-separated VSI-Bench question ids to test",
+    )
+    parser.add_argument(
+        "--questions-file", default=None, dest="questions_file",
+        help="path to a JSON list of question ids (alternative to --questions)",
+    )
+    parser.add_argument(
+        "--spatial-code-format", required=True, choices=SPATIAL_CODE_FORMATS,
+        dest="spatial_code_format",
+    )
+    parser.add_argument("--depth", required=True, choices=DEPTH_VARIANTS)
+    parser.add_argument("--tracking", required=True, choices=TRACKING_MODES)
+    parser.add_argument(
+        "--input-selection", required=True, choices=INPUT_SELECTIONS,
+        dest="input_selection",
+    )
+    parser.add_argument("--frames", type=int, required=True)
+    parser.add_argument("--rebuild", action="store_true")
+    args = parser.parse_args()
+
+    try:
+        models = _parse_csv_choice(args.models, vlm_models.available_models(), "--models")
+    except ValueError as exc:
+        parser.error(str(exc))
+    budgets = []
+    for item in args.budgets.split(","):
+        item = item.strip()
+        if not item:
+            continue
+        budget = int(item)
+        if budget < 1:
+            parser.error(f"budget {budget} must be positive")
+        budgets.append(budget)
+    if not budgets:
+        parser.error("--budgets must name at least one budget")
+
+    if bool(args.questions) == bool(args.questions_file):
+        parser.error("give exactly one of --questions or --questions-file")
+    if args.questions:
+        question_ids = [int(q.strip()) for q in args.questions.split(",") if q.strip()]
+    else:
+        with open(args.questions_file, encoding="utf-8") as stream:
+            question_ids = [int(q) for q in json.load(stream)]
+    if not question_ids:
+        parser.error("no question ids given")
+
+    if args.frames < 1:
+        parser.error("--frames must be positive")
+    try:
+        run_grid(
+            models, budgets, question_ids, args.spatial_code_format,
+            args.depth, args.tracking, args.input_selection, args.frames,
+            rebuild=args.rebuild,
+        )
+    except ValueError as exc:
+        parser.error(str(exc))
+
+
+if __name__ == "__main__":
+    main()