code backup: corruption

corruption/empirical.py

@@ -16,8 +16,15 @@ corruption/chimera.py uses), which is deliberate: both modules should agree on w
 
 from __future__ import annotations
 
+import argparse
 import json
 import math
+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))
 
 
 def _center(instance):
@@ -129,3 +136,64 @@ def empirical_noise(code, residuals, rng, scale=1.0):
             kept[class_name] = survivors
     code["objects"] = kept
     return code
+
+
+def main():
+    """Measure the residual distribution over every scene with BOTH a perceived code
+    (at the given Step-2 config) and a ground-truth code, and write it to a JSON file
+    corruption.run's ``--residuals`` flag consumes."""
+    from encoder import config as encoder_config
+    from encoder.config import ground_truth_spatial_code_path
+    from harness.A.run import load_questions
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--depth", required=True, choices=("relative", "metric"))
+    parser.add_argument("--tracking", required=True, choices=("tracking", "no tracking"))
+    parser.add_argument(
+        "--input-selection", required=True, choices=("uniform", "selective"),
+        dest="input_selection",
+    )
+    parser.add_argument("--frames", type=int, required=True)
+    parser.add_argument(
+        "--output", default=str(WORKSPACE_ROOT / "analysis" / "sam3_da3_residuals.json")
+    )
+    args = parser.parse_args()
+
+    pairs = []
+    seen = set()
+    for row in load_questions():
+        scene = row["scene_name"]
+        if scene in seen:
+            continue
+        seen.add(scene)
+        perceived_path = Path(
+            encoder_config.spatial_code_path(
+                scene, args.depth, args.input_selection, args.tracking, args.frames, "compact"
+            )
+        )
+        gt_path = Path(ground_truth_spatial_code_path(scene, "compact"))
+        if not (perceived_path.is_file() and gt_path.is_file()):
+            continue
+        with perceived_path.open(encoding="utf-8") as stream:
+            perceived = json.load(stream)
+        with gt_path.open(encoding="utf-8") as stream:
+            ground_truth = json.load(stream)
+        pairs.append((perceived, ground_truth))
+    if not pairs:
+        raise SystemExit(
+            "no scenes with both perceived and ground-truth compact codes at this config"
+        )
+
+    residuals = measure_residuals(pairs)
+    with open(args.output, "w", encoding="utf-8") as stream:
+        json.dump(residuals, stream, indent=1)
+    print(f"measured residuals over {len(pairs)} scene pair(s) -> {args.output}")
+    print(
+        f"matched {residuals['matched']}, missed {residuals['missed']} "
+        f"(rate {residuals['miss_rate']:.3f}), hallucinated {residuals['hallucinated']} "
+        f"(rate {residuals['hallucination_rate']:.3f})"
+    )
+
+
+if __name__ == "__main__":
+    main()

corruption/launch.py

@@ -40,6 +40,23 @@ def main():
     )
     parser.add_argument("--scenes", default=None, help="comma-separated scenes")
     parser.add_argument("--sample", default=None, help="JSON list of question ids")
+    parser.add_argument(
+        "--depth", default=None, choices=("relative", "metric"),
+        help="chimera transforms only: the perceived codes' Step-2 config",
+    )
+    parser.add_argument(
+        "--tracking", default=None, choices=("tracking", "no tracking"),
+        help="chimera transforms only",
+    )
+    parser.add_argument(
+        "--input-selection", default=None, choices=("uniform", "selective"),
+        dest="input_selection", help="chimera transforms only",
+    )
+    parser.add_argument("--frames", type=int, default=None, help="chimera transforms only")
+    parser.add_argument(
+        "--residuals", default=None,
+        help="empirical transform only: corruption.empirical's measured-residuals JSON",
+    )
     args = parser.parse_args()
 
     transforms = [t.strip() for t in args.transforms.split(",") if t.strip()]
@@ -63,19 +80,37 @@ def main():
         with open(args.sample, encoding="utf-8") as stream:
             question_ids = set(json.load(stream))
 
+    condition_kwargs = {}
+    if any(t.startswith("chimera") for t in transforms):
+        if None in (args.depth, args.tracking, args.input_selection, args.frames):
+            parser.error(
+                "chimera transforms require --depth/--tracking/--input-selection/--frames"
+            )
+        condition_kwargs["perceived_config"] = {
+            "depth": args.depth,
+            "tracking": args.tracking,
+            "input_selection": args.input_selection,
+            "frame_count": args.frames,
+        }
+    if "empirical" in transforms:
+        if not args.residuals:
+            parser.error("the empirical transform requires --residuals")
+        with open(args.residuals, encoding="utf-8") as stream:
+            condition_kwargs["residuals"] = json.load(stream)
+
     conditions = [(t, m) for t in transforms for m in magnitudes]
     for index, (transform, magnitude) in enumerate(conditions, start=1):
         print(f"=== corruption {index}/{len(conditions)}: {transform}@{magnitude} ===", flush=True)
         if args.arm in ("solver", "both"):
             results = run_solver(
                 transform, magnitude, args.spatial_code_format,
-                scenes=scenes, question_ids=question_ids,
+                scenes=scenes, question_ids=question_ids, **condition_kwargs,
             )
             print(f"  [solver] {len(results)} questions", flush=True)
         for model in models:
             results = run_vlm(
                 model, transform, magnitude, args.spatial_code_format,
-                scenes=scenes, question_ids=question_ids,
+                scenes=scenes, question_ids=question_ids, **condition_kwargs,
             )
             print(f"  [{model}] {len(results)} questions", flush=True)
 

corruption/run.py

@@ -67,6 +67,28 @@ def load_ground_truth_compact(scene):
     return code
 
 
+def single_object_info(scene, magnitude):
+    """Reconstruct WHICH object the single-object probe perturbed for this scene --
+    fully determined by the frozen seed, so it can be recovered at any time. H6's
+    analysis needs this to select the questions that mention the perturbed object."""
+    rng = random.Random(_seed_for(scene, "single-object", magnitude))
+    _code, info = chimera_mod.perturb_single_object(load_ground_truth_compact(scene), rng)
+    return info
+
+
+def _write_perturbation_sidecars(results, transform, magnitude, root):
+    """For single-object runs, record the perturbed object's identity next to each
+    scene's result files (_perturbation.json) -- without it the H6 conflict-question
+    set cannot be constructed."""
+    if transform != "single-object":
+        return
+    for scene in {record["scene"] for record in results}:
+        scene_dir = Path(root) / scene
+        scene_dir.mkdir(parents=True, exist_ok=True)
+        with (scene_dir / "_perturbation.json").open("w", encoding="utf-8") as stream:
+            json.dump(single_object_info(scene, magnitude), stream, indent=1)
+
+
 def corrupted_compact(
     scene, transform, magnitude, perceived_config=None, residuals=None, wrong_scene=None
 ):
@@ -146,6 +168,7 @@ def run_vlm(
     )
     if question_ids is not None:
         results = [r for r in results if r["question_id"] in question_ids]
+    _write_perturbation_sidecars(results, transform, magnitude, root)
     return results
 
 
@@ -200,6 +223,8 @@ def run_solver(
         else:
             record["result_path"] = None
         results.append(record)
+    if write_results:
+        _write_perturbation_sidecars(results, transform, magnitude, root)
     return results
 
 
@@ -226,6 +251,40 @@ def certify_invariant(scene, transform, magnitude, spatial_code_format="explicit
     return True
 
 
+def _condition_kwargs(args, parser):
+    """Build the per-condition keyword arguments the special transforms need,
+    validating that the right flags were given for the requested transform."""
+    kwargs = {}
+    if args.transform in CHIMERA_CONDITIONS:
+        missing = [
+            flag for flag, value in (
+                ("--depth", args.depth), ("--tracking", args.tracking),
+                ("--input-selection", args.input_selection), ("--frames", args.frames),
+            ) if value is None
+        ]
+        if missing:
+            parser.error(f"{args.transform} requires {', '.join(missing)} (the Step-2 config)")
+        kwargs["perceived_config"] = {
+            "depth": args.depth,
+            "tracking": args.tracking,
+            "input_selection": args.input_selection,
+            "frame_count": args.frames,
+        }
+    if args.transform == "wrong-scene":
+        if not args.wrong_scene:
+            parser.error("wrong-scene requires --wrong-scene (the substitute scene id)")
+        kwargs["wrong_scene"] = args.wrong_scene
+    if args.transform == "empirical":
+        if not args.residuals:
+            parser.error(
+                "empirical requires --residuals (measure them first: "
+                "python -m corruption.empirical --help)"
+            )
+        with open(args.residuals, encoding="utf-8") as stream:
+            kwargs["residuals"] = json.load(stream)
+    return kwargs
+
+
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("--arm", required=True, choices=("vlm", "solver", "certify"))
@@ -243,7 +302,32 @@ def main():
         help="path to a JSON list of question ids (the pre-registered sample)",
     )
     parser.add_argument("--results-dir", default=None)
+    parser.add_argument(
+        "--depth", default=None, choices=("relative", "metric"),
+        help="chimera only: the perceived codes' Step-2 config",
+    )
+    parser.add_argument(
+        "--tracking", default=None, choices=("tracking", "no tracking"),
+        help="chimera only: the perceived codes' Step-2 config",
+    )
+    parser.add_argument(
+        "--input-selection", default=None, choices=("uniform", "selective"),
+        dest="input_selection", help="chimera only: the perceived codes' Step-2 config",
+    )
+    parser.add_argument(
+        "--frames", type=int, default=None,
+        help="chimera only: the perceived codes' Step-2 config",
+    )
+    parser.add_argument(
+        "--wrong-scene", default=None, dest="wrong_scene",
+        help="wrong-scene only: the substitute scene id",
+    )
+    parser.add_argument(
+        "--residuals", default=None,
+        help="empirical only: path to corruption.empirical's measured-residuals JSON",
+    )
     args = parser.parse_args()
+    condition_kwargs = _condition_kwargs(args, parser)
 
     scenes = None
     if args.scenes:
@@ -269,13 +353,13 @@ def main():
         results = run_vlm(
             args.model, args.transform, args.magnitude, args.spatial_code_format,
             scenes=scenes, limit=args.limit, question_ids=question_ids,
-            results_dir=args.results_dir,
+            results_dir=args.results_dir, **condition_kwargs,
         )
     else:
         results = run_solver(
             args.transform, args.magnitude, args.spatial_code_format,
             scenes=scenes, limit=args.limit, question_ids=question_ids,
-            results_dir=args.results_dir,
+            results_dir=args.results_dir, **condition_kwargs,
         )
     if results:
         mean_score = sum(r["score"] for r in results) / len(results)

corruption/sample.py

@@ -0,0 +1,146 @@
+"""Generate the pre-registered corruption-arm question sample.
+
+Implements EXACTLY the procedure frozen in analysis/preregistration.md: a balanced
+draw of ~600 questions over the 7 non-appearance-order categories (~85 each; the
+three object_rel_direction_* subtypes share the relative-direction budget), from
+scenes that have BOTH a perceived spatial code at the frozen Step-2 config AND a
+ground-truth code, spread over as many distinct scenes as the draw allows, sampled
+with the frozen RNG seed. Writes the realized question-id list to
+analysis/corruption_sample.json (and prints coverage stats) so it can be committed
+to the pre-registration immediately after Step 2, before any corruption run.
+
+Usage (after Step 2, with the winning config):
+    python -m corruption.sample --depth relative --tracking tracking \\
+        --input-selection selective --frames 32
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+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 corruption import SAMPLE_SEED  # noqa: E402
+from encoder import config as encoder_config  # noqa: E402
+from encoder.config import ground_truth_spatial_code_path  # noqa: E402
+from harness.A.run import load_questions  # noqa: E402
+
+# The 7 sampled categories (appearance order excluded for circularity -- see
+# analysis/preregistration.md); the direction subtypes pool into one budget.
+CATEGORY_BUDGETS = {
+    "object_counting": 85,
+    "object_abs_distance": 85,
+    "object_size_estimation": 85,
+    "room_size_estimation": 85,
+    "object_rel_distance": 85,
+    "object_rel_direction": 85,  # easy+medium+hard pooled
+    "route_planning": 85,
+}
+
+DEFAULT_OUTPUT = WORKSPACE_ROOT / "analysis" / "corruption_sample.json"
+
+
+def _budget_key(question_type):
+    if question_type.startswith("object_rel_direction"):
+        return "object_rel_direction"
+    return question_type
+
+
+def eligible_scenes(depth, input_selection, tracking, frame_count):
+    """Scenes having BOTH a perceived code at the given config AND a ground-truth
+    code on disk -- required by the empirical calibration and chimera arms."""
+    scenes = set()
+    for row in load_questions():
+        scene = row["scene_name"]
+        if scene in scenes:
+            continue
+        perceived = Path(
+            encoder_config.spatial_code_path(
+                scene, depth, input_selection, tracking, frame_count, "compact"
+            )
+        )
+        ground_truth = Path(ground_truth_spatial_code_path(scene, "compact"))
+        if perceived.is_file() and ground_truth.is_file():
+            scenes.add(scene)
+    return scenes
+
+
+def draw_sample(scenes, seed=SAMPLE_SEED, budgets=None):
+    """Draw the balanced sample: within each category budget, scenes are cycled
+    round-robin (maximizing distinct-scene spread) with per-scene question order and
+    scene order both shuffled by the frozen seed."""
+    budgets = dict(budgets or CATEGORY_BUDGETS)
+    rng = random.Random(seed)
+    by_bucket_scene = defaultdict(lambda: defaultdict(list))
+    for row in load_questions():
+        if row["scene_name"] not in scenes:
+            continue
+        bucket = _budget_key(row["question_type"])
+        if bucket in budgets:
+            by_bucket_scene[bucket][row["scene_name"]].append(row["id"])
+
+    sampled = []
+    for bucket in sorted(budgets):
+        scene_queues = {}
+        for scene, ids in by_bucket_scene[bucket].items():
+            ids = list(ids)
+            rng.shuffle(ids)
+            scene_queues[scene] = ids
+        order = sorted(scene_queues)
+        rng.shuffle(order)
+        remaining = budgets[bucket]
+        while remaining > 0 and any(scene_queues[scene] for scene in order):
+            for scene in order:
+                if remaining == 0:
+                    break
+                if scene_queues[scene]:
+                    sampled.append(scene_queues[scene].pop())
+                    remaining -= 1
+    return sorted(sampled)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--depth", required=True, choices=("relative", "metric"))
+    parser.add_argument("--tracking", required=True, choices=("tracking", "no tracking"))
+    parser.add_argument(
+        "--input-selection", required=True, choices=("uniform", "selective"),
+        dest="input_selection",
+    )
+    parser.add_argument("--frames", type=int, required=True)
+    parser.add_argument("--output", default=str(DEFAULT_OUTPUT))
+    parser.add_argument(
+        "--seed", type=int, default=SAMPLE_SEED,
+        help="frozen in analysis/preregistration.md -- do not change for real runs",
+    )
+    args = parser.parse_args()
+
+    scenes = eligible_scenes(args.depth, args.input_selection, args.tracking, args.frames)
+    if not scenes:
+        raise SystemExit(
+            "no eligible scenes: need BOTH perceived (Step 2) and ground-truth codes on disk"
+        )
+    sample = draw_sample(scenes, seed=args.seed)
+
+    scene_of = {row["id"]: row["scene_name"] for row in load_questions()}
+    distinct_scenes = {scene_of[qid] for qid in sample}
+    with open(args.output, "w", encoding="utf-8") as stream:
+        json.dump(sample, stream, indent=1)
+    print(f"wrote {len(sample)} question ids to {args.output}")
+    print(f"eligible scenes: {len(scenes)}; distinct scenes in sample: {len(distinct_scenes)}")
+    print(
+        "NOW: commit this file into the repository and re-run the code backup so the "
+        "realized sample is timestamped before any corruption run "
+        "(analysis/preregistration.md)."
+    )
+
+
+if __name__ == "__main__":
+    main()