Add files using upload-large-folder tool

encoder/__pycache__/geometric.cpython-311.pyc

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ff9d4daf608e6587f64975e802212265367f41192958b1d0d996b4ae70e90fe7
-size 131345
+oid sha256:3ac64db9babd5e880fa52f32cd0d05bb460afaef9f1568463f9cee478650ec66
+size 134984

encoder/config.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import os
 from pathlib import Path
 
-
 MODEL = "sam3+depth-anything-3"
 FRAMES_PER_VIDEO = int(os.environ.get("VSI_FRAMES_PER_VIDEO", "32"))
 FPS = float(os.environ.get("VSI_FPS", "6"))
@@ -36,7 +35,9 @@ def _validate_dimensions(depth, input_selection, tracking, frame_count):
             f"unknown input selection {input_selection!r}; expected {INPUT_SELECTIONS}"
         )
     if tracking not in TRACKING_MODES:
-        raise ValueError(f"unknown tracking mode {tracking!r}; expected {TRACKING_MODES}")
+        raise ValueError(
+            f"unknown tracking mode {tracking!r}; expected {TRACKING_MODES}"
+        )
     if frame_count < 1:
         raise ValueError("frame count must be positive")
 
@@ -85,9 +86,7 @@ def da3_cache_file(scene, depth, input_selection, frame_count=FRAMES_PER_VIDEO):
     return str(directory / str(frame_count) / f"{scene}.pkl")
 
 
-def sam3_cache_file(
-    scene, input_selection, tracking, frame_count=FRAMES_PER_VIDEO
-):
+def sam3_cache_file(scene, input_selection, tracking, frame_count=FRAMES_PER_VIDEO):
     """Return one native SAM3 cache path for a specific set of input dimensions."""
     _validate_dimensions("relative", input_selection, tracking, frame_count)
     directory = CACHE_ROOT / "sam3" / tracking / input_selection

encoder/geometric.py

@@ -31,7 +31,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -125,7 +124,8 @@ def room_gravity(
 ):
     """Robust UP vector = normal of the RANSAC floor plane (a real physical plane), oriented toward
     the cameras. Works when the reconstruction is tilted/drifted (ScanNet++) where argmin-extent fails.
-    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -218,7 +218,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -274,8 +275,10 @@ def _find_cls(name, classes):
     name_tokens = set(name.split())
     for c in classes:
         class_tokens = set(c.split())
-        if name_tokens and class_tokens and (
-            name_tokens <= class_tokens or class_tokens <= name_tokens
+        if (
+            name_tokens
+            and class_tokens
+            and (name_tokens <= class_tokens or class_tokens <= name_tokens)
         ):
             return c
     return None
@@ -397,7 +400,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -412,7 +416,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -448,7 +453,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -474,7 +480,8 @@ def answer_closest_distance(instances_a, instances_b, k=4000):
     """Closest distance between the two objects' point clouds ('closest point of each object'). Points are
     cleaned by _clean (self-calibrated per-object confidence + density) then exact nearest-neighbor min via
     KD-tree, so mask-bleed/speckle can't collapse the answer. NOTE: VSI's GT is box-to-box on CLEAN annotation
-    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -521,7 +528,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -576,7 +584,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1043,7 +1052,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1344,15 +1354,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1387,7 +1393,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1417,7 +1425,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     # the short-axis ship's one 32f caveat).
     core_centers, core_weights = centers, weights
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1443,7 +1453,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
             full_dimensions = full_dimensions[consistent]
             weights = weights[consistent]
     box_center_local = np.array(
-        [_weighted_quantile(core_centers[:, axis], core_weights, 0.5) for axis in range(3)]
+        [
+            _weighted_quantile(core_centers[:, axis], core_weights, 0.5)
+            for axis in range(3)
+        ]
     )
     # Size each axis by a HIGH percentile (0.90) of the mutually-consistent observed extents,
     # not the 75th. A partial/occluded/foreshortened view of an object can only measure a
@@ -1488,7 +1501,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1587,13 +1603,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1757,9 +1777,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -1792,9 +1810,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)
@@ -1822,7 +1838,10 @@ def instance_source_track_ids(scene):
             "cache carries only canonical points (no SAM3 track ids to recover)"
         )
     up_vec, up_ax = room_gravity(
-        raw_inputs["depth"], raw_inputs["intr"], raw_inputs["c2w"], raw_inputs.get("conf")
+        raw_inputs["depth"],
+        raw_inputs["intr"],
+        raw_inputs["c2w"],
+        raw_inputs.get("conf"),
     )
     instances, _stats = _compact_instances(scene, up_ax)
     out = {}
@@ -2005,13 +2024,17 @@ def _compact_box_distance(box_a, box_b):
     """
     from scipy.optimize import lsq_linear
 
-    center_a = np.asarray(box_a["3D oriented bounding box center coordinates"], np.float64)
+    center_a = np.asarray(
+        box_a["3D oriented bounding box center coordinates"], np.float64
+    )
     dimensions_a = np.asarray(box_a["3D oriented bounding box dimensions"], np.float64)
     orientation_a = np.asarray(
         box_a["3D oriented bounding box orientation unit vectors"], np.float64
     )
     orientation_a = orientation_a / np.linalg.norm(orientation_a, axis=1, keepdims=True)
-    center_b = np.asarray(box_b["3D oriented bounding box center coordinates"], np.float64)
+    center_b = np.asarray(
+        box_b["3D oriented bounding box center coordinates"], np.float64
+    )
     dimensions_b = np.asarray(box_b["3D oriented bounding box dimensions"], np.float64)
     orientation_b = np.asarray(
         box_b["3D oriented bounding box orientation unit vectors"], np.float64
@@ -2033,7 +2056,9 @@ def _compact_box_distance(box_a, box_b):
         max_iter=200,
     )
     if not result.success:
-        raise RuntimeError(f"oriented-box distance optimization failed: {result.message}")
+        raise RuntimeError(
+            f"oriented-box distance optimization failed: {result.message}"
+        )
     distance = float(np.linalg.norm(matrix @ result.x + center_a - center_b))
     return 0.0 if distance < 1e-10 else distance
 
@@ -2041,7 +2066,9 @@ def _compact_box_distance(box_a, box_b):
 def _compact_class_distance(instances_a, instances_b):
     """Return the minimum compact oriented-box distance across every cross-class instance pair."""
     return min(
-        _compact_box_distance(a["3D oriented bounding box"], b["3D oriented bounding box"])
+        _compact_box_distance(
+            a["3D oriented bounding box"], b["3D oriented bounding box"]
+        )
         for a in instances_a
         for b in instances_b
     )
@@ -2167,7 +2194,9 @@ def _explicit_from_compact(compact_code):
     printed_distances = {class_name: {} for class_name in classes}
     for index, class_name in enumerate(classes):
         for other in classes[index + 1 :]:
-            raw = _compact_class_distance(compact_objects[class_name], compact_objects[other])
+            raw = _compact_class_distance(
+                compact_objects[class_name], compact_objects[other]
+            )
             printed = _corrected_class_distance(
                 compact_objects[class_name], compact_objects[other]
             )
@@ -2187,7 +2216,10 @@ def _explicit_from_compact(compact_code):
         }
 
     floor_area = round(
-        _compact_room_floor_area(compact_code["room"].get("floor boundary polygons", [])), 1
+        _compact_room_floor_area(
+            compact_code["room"].get("floor boundary polygons", [])
+        ),
+        1,
     )
 
     return {
@@ -2206,7 +2238,8 @@ def build_explicit_spatial_code(scene):
     compact schema (see the section header above): every object position/dimension/count and
     the appearance order are direct subsets of the compact spatial code's own values; the
     distance table is computed purely from compact's 3D oriented boxes. Nothing here
-    independently re-measures geometry -- build_compact_spatial_code() already did that once."""
+    independently re-measures geometry -- build_compact_spatial_code() already did that once.
+    """
     compact_code, instances, stats, up_ax, up_vec, _ = build_compact_spatial_code(scene)
     code, floor_area = _explicit_from_compact(compact_code)
     return code, instances, stats, up_ax, up_vec, floor_area

encoder/ground_truth.py

@@ -51,9 +51,7 @@ from encoder.geometric import (
     dump_spatial_code,
 )
 
-META_INFO_DIR = Path(
-    config.DATA_ROOT
-) / "thinking-in-space" / "data" / "meta_info"
+META_INFO_DIR = Path(config.DATA_ROOT) / "thinking-in-space" / "data" / "meta_info"
 META_INFO_DATASETS = ("scannet", "arkitscenes", "scannetpp")
 
 
@@ -97,7 +95,9 @@ def _appearance_order_ranks_by_scene():
 
     ranks_by_scene = {}
     for scene, edges in edges_by_scene.items():
-        nodes = set(edges) | {node for successors in edges.values() for node in successors}
+        nodes = set(edges) | {
+            node for successors in edges.values() for node in successors
+        }
         order = []
         visited, in_progress = set(), set()
 
@@ -243,7 +243,8 @@ def build_and_write(scene, spatial_code_format="explicit"):
 
 def scenes():
     """Every scene meta_info has ground truth for (a superset of every scene any
-    perception-built spatial code could ever cover, since this needs no SAM3/DA3 cache)."""
+    perception-built spatial code could ever cover, since this needs no SAM3/DA3 cache).
+    """
     return sorted(load_meta_info())
 
 
@@ -261,9 +262,13 @@ if __name__ == "__main__":
     import argparse
 
     parser = argparse.ArgumentParser()
-    parser.add_argument("--scenes", help="comma-separated scenes (default: every scene)")
     parser.add_argument(
-        "--formats", default="explicit,compact", help="comma-separated spatial-code formats"
+        "--scenes", help="comma-separated scenes (default: every scene)"
+    )
+    parser.add_argument(
+        "--formats",
+        default="explicit,compact",
+        help="comma-separated spatial-code formats",
     )
     args = parser.parse_args()
     scene_list = (

encoder/launch.py

@@ -33,26 +33,18 @@ def _has_required_caches(scene, depth, input_selection, tracking, frame_count):
     return all(
         os.path.isfile(path)
         for path in (
-            config.sam3_cache_file(
-                scene, input_selection, tracking, frame_count
-            ),
-            config.da3_cache_file(
-                scene, depth, input_selection, frame_count
-            ),
+            config.sam3_cache_file(scene, input_selection, tracking, frame_count),
+            config.da3_cache_file(scene, depth, input_selection, frame_count),
         )
     )
 
 
-def _scenes_with_required_caches(
-    depth, input_selection, tracking, frame_count
-):
+def _scenes_with_required_caches(depth, input_selection, tracking, frame_count):
     """Return manifest scenes having every cache required by this encoder run."""
     return [
         scene
         for scene in _scenes()
-        if _has_required_caches(
-            scene, depth, input_selection, tracking, frame_count
-        )
+        if _has_required_caches(scene, depth, input_selection, tracking, frame_count)
     ]
 
 
@@ -226,8 +218,7 @@ def _launch(args, selected):
         process.join()
     succeeded = len(selected) - len(failed) - skipped
     print(
-        f"[{label}] DONE: {succeeded} ok, {skipped} skipped, "
-        f"{len(failed)} failed"
+        f"[{label}] DONE: {succeeded} ok, {skipped} skipped, " f"{len(failed)} failed"
     )
     if failed:
         raise SystemExit(1)

harness/A/__init__.py

@@ -20,9 +20,7 @@ JSONL = Path(os.environ.get("VSI_JSONL", VSI_ROOT / "test.jsonl"))
 WORKSPACE_ROOT = Path(__file__).resolve().parent.parent.parent
 # One JSON per question, matching the layout results/symbolic/... already uses:
 # results/A/<model>/<frame_selection>/<frame_count>/<scene>/<question_id>.json
-RESULTS_DIR = Path(
-    os.environ.get("VSI_HARNESS_RESULTS_DIR", "/root/results/A")
-)
+RESULTS_DIR = Path(os.environ.get("VSI_HARNESS_RESULTS_DIR", "/root/results/A"))
 
 # Same two selection strategies and vocabulary as inference.SAM3_FRAME_SELECTIONS:
 # "uniform" (evenly spaced indices) or "selective" (the quality/redundancy/motion-

harness/A/run.py

@@ -79,7 +79,9 @@ def load_questions(jsonl_path=None, scene=None, scenes=None, limit=None):
     """Return VSI-Bench question rows, optionally filtered to one/many scenes / capped."""
     if scene is not None and scenes is not None:
         raise ValueError("scene and scenes cannot both be given")
-    allowed = {scene} if scene is not None else (set(scenes) if scenes is not None else None)
+    allowed = (
+        {scene} if scene is not None else (set(scenes) if scenes is not None else None)
+    )
     jsonl_path = jsonl_path or JSONL
     rows = []
     with open(jsonl_path) as stream:
@@ -103,7 +105,9 @@ def results_dir_for(model, protocol, frame_selection, frame_count, results_dir=N
     return RESULTS_DIR / model / protocol / frame_selection / str(frame_count)
 
 
-def _build_record(row, prompt, answer, metric_name, score, model, model_path, frame_info):
+def _build_record(
+    row, prompt, answer, metric_name, score, model, model_path, frame_info
+):
     """Assemble one question's full, untruncated result record (nothing summarized)."""
     return {
         "model": model,
@@ -153,15 +157,26 @@ def _build_record(row, prompt, answer, metric_name, score, model, model_path, fr
 
 
 def write_question_result(
-    row, prompt, answer, metric_name, score, model, model_path, frame_info, results_dir=None
+    row,
+    prompt,
+    answer,
+    metric_name,
+    score,
+    model,
+    model_path,
+    frame_info,
+    results_dir=None,
 ):
     """Write one question's full, untruncated result record. Return (path, record)."""
     record = _build_record(
         row, prompt, answer, metric_name, score, model, model_path, frame_info
     )
     root = results_dir_for(
-        model, frame_info["protocol"], frame_info["frame_selection"],
-        frame_info["frame_count"], results_dir,
+        model,
+        frame_info["protocol"],
+        frame_info["frame_selection"],
+        frame_info["frame_count"],
+        results_dir,
     )
     scene_dir = root / record["scene"]
     scene_dir.mkdir(parents=True, exist_ok=True)
@@ -227,8 +242,10 @@ def run(
             scene_id = row["scene_name"]
             if scene_id not in frame_cache:
                 video_path = inference_config.video_path(scene_id, row.get("dataset"))
-                frame_images, frame_timestamps, frame_indices = frame_sampling.sample_frames(
-                    video_path, frame_count, frame_selection
+                frame_images, frame_timestamps, frame_indices = (
+                    frame_sampling.sample_frames(
+                        video_path, frame_count, frame_selection
+                    )
                 )
                 frame_cache[scene_id] = {
                     "video_path": video_path,
@@ -244,22 +261,29 @@ def run(
             )
             answer = (
                 adapter.answer_extended(
-                    cached["frame_images"], prompt,
-                    reasoning_budget=reasoning_budget, force_budget=force_budget,
+                    cached["frame_images"],
+                    prompt,
+                    reasoning_budget=reasoning_budget,
+                    force_budget=force_budget,
                 )
                 if extended
-                else adapter.answer(cached["frame_images"], prompt, max_new_tokens=raw_budget)
+                else adapter.answer(
+                    cached["frame_images"], prompt, max_new_tokens=raw_budget
+                )
             )
-            doc = {"question_type": row["question_type"], "ground_truth": row["ground_truth"]}
+            doc = {
+                "question_type": row["question_type"],
+                "ground_truth": row["ground_truth"],
+            }
             score_doc = vsi_official_eval.vsibench_process_results(
                 doc, [answer["answer_text"]]
             )["vsibench_score"]
             metric_name, score = _scalar_score(row["question_type"], score_doc)
             frame_info = {
                 "protocol": (
-                    f"{reasoning_budget}" if extended
-                    else f"truncated/{raw_budget}" if raw_budget is not None
-                    else "base"
+                    f"{reasoning_budget}"
+                    if extended
+                    else f"truncated/{raw_budget}" if raw_budget is not None else "base"
                 ),
                 "video_path": cached["video_path"],
                 "frame_timestamps": cached["frame_timestamps"],
@@ -269,13 +293,27 @@ def run(
             }
             if write_results:
                 path, record = write_question_result(
-                    row, prompt, answer, metric_name, score, model, adapter.model_path,
-                    frame_info, results_dir,
+                    row,
+                    prompt,
+                    answer,
+                    metric_name,
+                    score,
+                    model,
+                    adapter.model_path,
+                    frame_info,
+                    results_dir,
                 )
             else:
                 path = None
                 record = _build_record(
-                    row, prompt, answer, metric_name, score, model, adapter.model_path, frame_info
+                    row,
+                    prompt,
+                    answer,
+                    metric_name,
+                    score,
+                    model,
+                    adapter.model_path,
+                    frame_info,
                 )
             record["result_path"] = str(path) if path else None
             results.append(record)
@@ -296,7 +334,9 @@ def main():
         dest="frame_selection",
     )
     parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
-    parser.add_argument("--limit", type=int, default=None, help="cap the number of questions")
+    parser.add_argument(
+        "--limit", type=int, default=None, help="cap the number of questions"
+    )
     parser.add_argument("--device", default="cuda")
     parser.add_argument(
         "--results-dir",
@@ -320,7 +360,9 @@ def main():
     parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
     parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     parser.add_argument(
-        "--raw-budget", type=int, default=None,
+        "--raw-budget",
+        type=int,
+        default=None,
         help="raw-budget arm: run the base protocol's exact single-generation, "
         "no-rescue mechanism at this token cap instead of the hardcoded 16 "
         "(mutually exclusive with --extended)",

harness/B/launch.py

@@ -54,10 +54,28 @@ def _load_run_module():
 
 
 def _worker(
-    tasks, results, model, spatial_code_format, input_selection, frame_count, depth, tracking,
-    results_dir, gpu, cpu_threads, extended, reasoning_budget, force_budget,
-    serialization, context_line, question_ids, strip_schema_legend, reasoning_note,
-    thinking, raw_budget, flat_distance_table,
+    tasks,
+    results,
+    model,
+    spatial_code_format,
+    input_selection,
+    frame_count,
+    depth,
+    tracking,
+    results_dir,
+    gpu,
+    cpu_threads,
+    extended,
+    reasoning_budget,
+    force_budget,
+    serialization,
+    context_line,
+    question_ids,
+    strip_schema_legend,
+    reasoning_note,
+    thinking,
+    raw_budget,
+    flat_distance_table,
 ):
     if gpu is not None:
         os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
@@ -115,11 +133,25 @@ def _worker(
 
 
 def launch(
-    model, spatial_code_format, input_selection, frame_count, selected,
-    depth=DEFAULT_DEPTH, tracking=DEFAULT_TRACKING, results_dir=None, rebuild=False,
-    extended=True, reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
-    serialization="json", context_line=None, question_ids=None,
-    strip_schema_legend=False, reasoning_note=False, thinking=False, raw_budget=None,
+    model,
+    spatial_code_format,
+    input_selection,
+    frame_count,
+    selected,
+    depth=DEFAULT_DEPTH,
+    tracking=DEFAULT_TRACKING,
+    results_dir=None,
+    rebuild=False,
+    extended=True,
+    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
+    force_budget=MAX_NEW_TOKENS,
+    serialization="json",
+    context_line=None,
+    question_ids=None,
+    strip_schema_legend=False,
+    reasoning_note=False,
+    thinking=False,
+    raw_budget=None,
     flat_distance_table=False,
 ):
     """Answer every question for ``selected`` scenes, sharded across every visible GPU.
@@ -132,9 +164,9 @@ def launch(
     if extended and raw_budget is not None:
         raise ValueError("extended and raw_budget are mutually exclusive")
     protocol = (
-        f"{reasoning_budget}" if extended
-        else f"truncated/{raw_budget}" if raw_budget is not None
-        else "base"
+        f"{reasoning_budget}"
+        if extended
+        else f"truncated/{raw_budget}" if raw_budget is not None else "base"
     )
     condition = (
         f"{model}/{protocol}/{spatial_code_format}/{depth}/{tracking}"
@@ -142,7 +174,13 @@ def launch(
     )
     run = _load_run_module()
     root = run.results_dir_for(
-        model, protocol, spatial_code_format, depth, tracking, input_selection, frame_count,
+        model,
+        protocol,
+        spatial_code_format,
+        depth,
+        tracking,
+        input_selection,
+        frame_count,
         results_dir,
     )
     pending = []
@@ -152,12 +190,16 @@ def launch(
         if question_ids is not None:
             rows = [row for row in rows if row["id"] in question_ids]
         if not rows:
-            completed += 1
-            continue
+            raise ValueError(
+                f"no questions found for scene {scene!r}; check the manifest, scene selection, or question_ids"
+            )
         answered = all((root / scene / f"{row['id']}.json").is_file() for row in rows)
         if answered and not rebuild:
             completed += 1
-            print(f"[{condition} {completed}/{len(selected)}] {scene}: skipped", flush=True)
+            print(
+                f"[{condition} {completed}/{len(selected)}] {scene}: skipped",
+                flush=True,
+            )
         else:
             pending.append(scene)
     if not pending:
@@ -185,10 +227,28 @@ def launch(
         context.Process(
             target=_worker,
             args=(
-                tasks, results, model, spatial_code_format, input_selection, frame_count,
-                depth, tracking, results_dir, gpu, cpu_threads, extended, reasoning_budget,
-                force_budget, serialization, context_line, question_ids, strip_schema_legend,
-                reasoning_note, thinking, raw_budget, flat_distance_table,
+                tasks,
+                results,
+                model,
+                spatial_code_format,
+                input_selection,
+                frame_count,
+                depth,
+                tracking,
+                results_dir,
+                gpu,
+                cpu_threads,
+                extended,
+                reasoning_budget,
+                force_budget,
+                serialization,
+                context_line,
+                question_ids,
+                strip_schema_legend,
+                reasoning_note,
+                thinking,
+                raw_budget,
+                flat_distance_table,
             ),
         )
         for gpu in assignments
@@ -219,16 +279,21 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("scene", nargs="?")
     parser.add_argument(
-        "--scenes", help="comma-separated scenes (cannot be combined with positional scene)"
+        "--scenes",
+        help="comma-separated scenes (cannot be combined with positional scene)",
     )
     parser.add_argument("--model", required=True, choices=vlm_models.available_models())
     parser.add_argument(
-        "--spatial-code-format", default=DEFAULT_SPATIAL_CODE_FORMAT,
-        choices=SPATIAL_CODE_FORMATS, dest="spatial_code_format",
+        "--spatial-code-format",
+        default=DEFAULT_SPATIAL_CODE_FORMAT,
+        choices=SPATIAL_CODE_FORMATS,
+        dest="spatial_code_format",
     )
     parser.add_argument(
-        "--input-selection", default=DEFAULT_INPUT_SELECTION,
-        choices=INPUT_SELECTIONS, dest="input_selection",
+        "--input-selection",
+        default=DEFAULT_INPUT_SELECTION,
+        choices=INPUT_SELECTIONS,
+        dest="input_selection",
     )
     parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
     parser.add_argument("--depth", default=DEFAULT_DEPTH, choices=DEPTH_VARIANTS)
@@ -236,49 +301,64 @@ def main():
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
     parser.add_argument(
-        "--base-protocol", action="store_true",
+        "--base-protocol",
+        action="store_true",
         help="run harness.A's exact fixed 16-token protocol instead of the extended default",
     )
     parser.add_argument(
-        "--serialization", default="json",
+        "--serialization",
+        default="json",
         help="robustness arm only: 'yaml' renders the identical code dict as YAML "
         "(pair with an explicit --results-dir)",
     )
     parser.add_argument(
-        "--paraphrase-context", action="store_true", dest="paraphrase_context",
+        "--paraphrase-context",
+        action="store_true",
+        dest="paraphrase_context",
         help="robustness arm only: the pre-registered paraphrased context line "
         "(pair with an explicit --results-dir)",
     )
     parser.add_argument(
-        "--no-schema-legend", action="store_true", dest="strip_schema_legend",
+        "--no-schema-legend",
+        action="store_true",
+        dest="strip_schema_legend",
         help="legend-ablation arm: drop the embedded schema legend before prompting "
         "(pair with an explicit --results-dir)",
     )
     parser.add_argument(
-        "--prose-legend", action="store_true", dest="prose_legend",
+        "--prose-legend",
+        action="store_true",
+        dest="prose_legend",
         help="legacy-legend arm: drop the embedded schema block AND use the legacy "
         "prose legend as the context block (pair with an explicit --results-dir)",
     )
     parser.add_argument(
-        "--reasoning-note", action="store_true", dest="reasoning_note",
+        "--reasoning-note",
+        action="store_true",
+        dest="reasoning_note",
         help="prefix the Thinking-with-Spatial-Code step-by-step note to the "
         "post-prompt (pair with an explicit --results-dir)",
     )
     parser.add_argument(
-        "--thinking", action="store_true",
+        "--thinking",
+        action="store_true",
         help="enable native thinking mode (Qwen only; pair with an explicit "
         "--results-dir)",
     )
     parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
     parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     parser.add_argument(
-        "--truncated-budget", type=int, default=None,
+        "--truncated-budget",
+        type=int,
+        default=None,
         help="raw-budget arm: base-protocol mechanics (single generation, no forced "
         "rescue) at this token cap instead of the hardcoded 16 (mutually exclusive "
         "with --base-protocol)",
     )
     parser.add_argument(
-        "--flat-distance-table", action="store_true", dest="flat_distance_table",
+        "--flat-distance-table",
+        action="store_true",
+        dest="flat_distance_table",
         help="flat-table arm: flatten the distance table's two-level nesting into "
         "single-level '<class> to <other>' keys, identical information (pair with "
         "an explicit --results-dir)",
@@ -304,17 +384,28 @@ def main():
     if args.base_protocol and args.truncated_budget is not None:
         parser.error("--base-protocol and --truncated-budget are mutually exclusive")
     launch(
-        args.model, args.spatial_code_format, args.input_selection, args.frames, selected,
-        depth=args.depth, tracking=args.tracking, results_dir=args.results_dir, rebuild=args.rebuild,
+        args.model,
+        args.spatial_code_format,
+        args.input_selection,
+        args.frames,
+        selected,
+        depth=args.depth,
+        tracking=args.tracking,
+        results_dir=args.results_dir,
+        rebuild=args.rebuild,
         extended=not args.base_protocol and args.truncated_budget is None,
         raw_budget=args.truncated_budget,
-        reasoning_budget=args.reasoning_budget, force_budget=args.force_budget,
+        reasoning_budget=args.reasoning_budget,
+        force_budget=args.force_budget,
         serialization=args.serialization,
         context_line=(
-            PROSE_LEGEND if args.prose_legend
-            else PARAPHRASE_PRE_PROMPT if args.paraphrase_context
-            else NO_LEGEND_PRE_PROMPT if args.strip_schema_legend
-            else None
+            PROSE_LEGEND
+            if args.prose_legend
+            else (
+                PARAPHRASE_PRE_PROMPT
+                if args.paraphrase_context
+                else NO_LEGEND_PRE_PROMPT if args.strip_schema_legend else None
+            )
         ),
         strip_schema_legend=args.strip_schema_legend or args.prose_legend,
         reasoning_note=args.reasoning_note,

harness/B/spatial_codes.py

@@ -15,7 +15,9 @@ from encoder.config import spatial_code_path
 from harness.B import SPATIAL_CODE_FORMATS
 
 
-def load_spatial_code(scene, depth, input_selection, tracking, frame_count, spatial_code_format):
+def load_spatial_code(
+    scene, depth, input_selection, tracking, frame_count, spatial_code_format
+):
     """Return (spatial code dict, path it was loaded from)."""
     if spatial_code_format not in SPATIAL_CODE_FORMATS:
         raise ValueError(

harness/B/sweep.py

@@ -35,7 +35,9 @@ from harness.B import (  # noqa: E402
 from harness.B import launch as harness_launch  # noqa: E402
 
 
-def build_plan(models, spatial_code_formats, input_selections, frame_counts, depths, trackings):
+def build_plan(
+    models, spatial_code_formats, input_selections, frame_counts, depths, trackings
+):
     """Return every (model, spatial_code_format, depth, tracking, input_selection,
     frame_count) 6-tuple in the sweep, in a stable, cheapest-first-ish order (frame
     count sorted first)."""
@@ -51,31 +53,57 @@ def build_plan(models, spatial_code_formats, input_selections, frame_counts, dep
 
 
 def sweep(
-    models, spatial_code_formats, input_selections, frame_counts, selected_scenes,
-    depths=(DEFAULT_DEPTH,), trackings=(DEFAULT_TRACKING,), results_dir=None, rebuild=False,
-    extended=True, reasoning_budget=EXTENDED_MAX_NEW_TOKENS, strip_schema_legend=False,
-    raw_budget=None, flat_distance_table=False,
+    models,
+    spatial_code_formats,
+    input_selections,
+    frame_counts,
+    selected_scenes,
+    depths=(DEFAULT_DEPTH,),
+    trackings=(DEFAULT_TRACKING,),
+    results_dir=None,
+    rebuild=False,
+    extended=True,
+    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
+    strip_schema_legend=False,
+    raw_budget=None,
+    flat_distance_table=False,
 ):
     """Run every sweep combination across all visible GPUs."""
-    plan = build_plan(models, spatial_code_formats, input_selections, frame_counts, depths, trackings)
+    plan = build_plan(
+        models, spatial_code_formats, input_selections, frame_counts, depths, trackings
+    )
     protocol = (
-        f"{reasoning_budget}" if extended
-        else f"truncated/{raw_budget}" if raw_budget is not None
-        else "base"
+        f"{reasoning_budget}"
+        if extended
+        else f"truncated/{raw_budget}" if raw_budget is not None else "base"
     )
-    for index, (model, spatial_code_format, depth, tracking, input_selection, frame_count) in enumerate(
-        plan, start=1
-    ):
+    for index, (
+        model,
+        spatial_code_format,
+        depth,
+        tracking,
+        input_selection,
+        frame_count,
+    ) in enumerate(plan, start=1):
         print(
             f"=== sweep {index}/{len(plan)}: {model}/{protocol}/"
             f"{spatial_code_format}/{depth}/{tracking}/{input_selection}/{frame_count} ===",
             flush=True,
         )
         harness_launch.launch(
-            model, spatial_code_format, input_selection, frame_count, selected_scenes,
-            depth=depth, tracking=tracking, results_dir=results_dir, rebuild=rebuild,
-            extended=extended, reasoning_budget=reasoning_budget,
-            strip_schema_legend=strip_schema_legend, raw_budget=raw_budget,
+            model,
+            spatial_code_format,
+            input_selection,
+            frame_count,
+            selected_scenes,
+            depth=depth,
+            tracking=tracking,
+            results_dir=results_dir,
+            rebuild=rebuild,
+            extended=extended,
+            reasoning_budget=reasoning_budget,
+            strip_schema_legend=strip_schema_legend,
+            raw_budget=raw_budget,
             flat_distance_table=flat_distance_table,
         )
 
@@ -84,56 +112,73 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("scene", nargs="?")
     parser.add_argument(
-        "--scenes", help="comma-separated scenes (cannot be combined with positional scene)"
+        "--scenes",
+        help="comma-separated scenes (cannot be combined with positional scene)",
     )
     parser.add_argument(
-        "--models", required=True,
+        "--models",
+        required=True,
         help=f"comma-separated models (or 'all'); one of {vlm_models.available_models()}",
     )
     parser.add_argument(
-        "--spatial-code-formats", required=True, dest="spatial_code_formats",
+        "--spatial-code-formats",
+        required=True,
+        dest="spatial_code_formats",
         help=f"comma-separated formats (or 'all'); one of {SPATIAL_CODE_FORMATS}",
     )
     parser.add_argument(
-        "--input-selections", required=True, dest="input_selections",
+        "--input-selections",
+        required=True,
+        dest="input_selections",
         help=f"comma-separated selections (or 'all'); one of {INPUT_SELECTIONS}",
     )
     parser.add_argument(
         "--frames", required=True, help="comma-separated frame counts, e.g. 16,32,64"
     )
     parser.add_argument(
-        "--depths", default=DEFAULT_DEPTH,
+        "--depths",
+        default=DEFAULT_DEPTH,
         help=f"comma-separated depths (or 'all'); one of {DEPTH_VARIANTS}",
     )
     parser.add_argument(
-        "--trackings", default=DEFAULT_TRACKING,
+        "--trackings",
+        default=DEFAULT_TRACKING,
         help=f"comma-separated tracking modes (or 'all'); one of {TRACKING_MODES}",
     )
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
     parser.add_argument(
-        "--base-protocol", action="store_true",
+        "--base-protocol",
+        action="store_true",
         help="run the whole sweep under harness.A's exact fixed 16-token protocol "
         "instead of the extended default",
     )
     parser.add_argument(
-        "--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS,
+        "--reasoning-budget",
+        type=int,
+        default=EXTENDED_MAX_NEW_TOKENS,
         dest="reasoning_budget",
         help="extended-protocol first-pass budget (the calibrated value from "
         "analysis/preregistration.md, e.g. 512)",
     )
     parser.add_argument(
-        "--no-schema-legend", action="store_true", dest="strip_schema_legend",
+        "--no-schema-legend",
+        action="store_true",
+        dest="strip_schema_legend",
         help="drop the embedded schema legend from every prompt (the amended main-run "
         "design; see analysis/preregistration.md)",
     )
     parser.add_argument(
-        "--truncated-budget", type=int, default=None,
+        "--truncated-budget",
+        type=int,
+        default=None,
         help="raw-budget arm: base-protocol mechanics (single generation, no forced "
         "rescue) at this token cap (mutually exclusive with --base-protocol)",
     )
     parser.add_argument(
-        "--flat-distance-table", action="store_true", dest="flat_distance_table",
+        "--flat-distance-table",
+        action="store_true",
+        dest="flat_distance_table",
         help="flat-table arm: flatten the distance table's two-level nesting into "
         "single-level '<class> to <other>' keys, identical information",
     )
@@ -144,7 +189,9 @@ def main():
         parser.error("--base-protocol and --truncated-budget are mutually exclusive")
 
     try:
-        models = _parse_csv_choice(args.models, vlm_models.available_models(), "--models")
+        models = _parse_csv_choice(
+            args.models, vlm_models.available_models(), "--models"
+        )
         spatial_code_formats = _parse_csv_choice(
             args.spatial_code_formats, SPATIAL_CODE_FORMATS, "--spatial-code-formats"
         )
@@ -168,9 +215,15 @@ def main():
         selected = [args.scene] if args.scene else scenes()
 
     sweep(
-        models, spatial_code_formats, input_selections, frame_counts, selected,
-        depths=depths, trackings=trackings,
-        results_dir=args.results_dir, rebuild=args.rebuild,
+        models,
+        spatial_code_formats,
+        input_selections,
+        frame_counts,
+        selected,
+        depths=depths,
+        trackings=trackings,
+        results_dir=args.results_dir,
+        rebuild=args.rebuild,
         extended=not args.base_protocol and args.truncated_budget is None,
         reasoning_budget=args.reasoning_budget,
         strip_schema_legend=args.strip_schema_legend,