Add files using upload-large-folder tool

harness/D/launch.py

@@ -26,6 +26,7 @@ if str(WORKSPACE_ROOT) not in sys.path:
 from encoder.ground_truth import scenes as ground_truth_scenes  # noqa: E402
 from harness.A import EXTENDED_MAX_NEW_TOKENS, MAX_NEW_TOKENS  # noqa: E402
 from harness.A import models as vlm_models  # noqa: E402
+from harness.B import DEFAULT_INPUT_SELECTION, FRAMES_PER_VIDEO, INPUT_SELECTIONS  # noqa: E402
 from harness.D import DEFAULT_SPATIAL_CODE_FORMAT, SPATIAL_CODE_FORMATS  # noqa: E402
 from inference.launch import available_cpu_count, visible_gpus  # noqa: E402
 
@@ -39,7 +40,8 @@ def _load_run_module():
 
 
 def _worker(tasks, results, model, spatial_code_format, results_dir, gpu, cpu_threads,
-            extended, reasoning_budget, force_budget, strip_schema_legend):
+            extended, reasoning_budget, force_budget, strip_schema_legend,
+            frames, frame_selection, frame_count):
     if gpu is not None:
         os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
     for variable in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
@@ -70,6 +72,9 @@ def _worker(tasks, results, model, spatial_code_format, results_dir, gpu, cpu_th
                 reasoning_budget=reasoning_budget,
                 force_budget=force_budget,
                 strip_schema_legend=strip_schema_legend,
+                frames=frames,
+                frame_selection=frame_selection,
+                frame_count=frame_count,
             )
             mean_score = (
                 sum(r["score"] for r in answered) / len(answered) if answered else None
@@ -85,12 +90,18 @@ def launch(
     model, spatial_code_format, selected, results_dir=None, rebuild=False,
     extended=True, reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
     strip_schema_legend=False,
+    frames=False, frame_selection=DEFAULT_INPUT_SELECTION, frame_count=FRAMES_PER_VIDEO,
 ):
     """Answer every question for ``selected`` scenes, sharded across every visible GPU."""
     protocol = f"{reasoning_budget}" if extended else "base"
     condition = f"{model}/{protocol}/{spatial_code_format}"
+    if frames:
+        condition += f"/frames/{frame_selection}/{frame_count}"
     run = _load_run_module()
-    root = run.results_dir_for(model, protocol, spatial_code_format, results_dir)
+    root = run.results_dir_for(
+        model, protocol, spatial_code_format, results_dir,
+        frames=frames, frame_selection=frame_selection, frame_count=frame_count,
+    )
     pending = []
     completed = 0
     for scene in selected:
@@ -128,6 +139,7 @@ def launch(
             args=(
                 tasks, results, model, spatial_code_format, results_dir, gpu, cpu_threads,
                 extended, reasoning_budget, force_budget, strip_schema_legend,
+                frames, frame_selection, frame_count,
             ),
         )
         for gpu in assignments
@@ -186,6 +198,20 @@ def main():
         "--no-schema-legend", action="store_true", dest="strip_schema_legend",
         help="drop the embedded schema legend (the amended main-run design)",
     )
+    parser.add_argument(
+        "--with-frames", action="store_true", dest="frames",
+        help="frames+ground-truth-code arm: also sample and show the scene's raw video "
+        "frames alongside the ground-truth code (default sampling: uniform, 32 frames -- "
+        "the frozen Step-1 config)",
+    )
+    parser.add_argument(
+        "--frame-selection", default=DEFAULT_INPUT_SELECTION, choices=INPUT_SELECTIONS,
+        dest="frame_selection", help="only used with --with-frames",
+    )
+    parser.add_argument(
+        "--frames-per-video", type=int, default=FRAMES_PER_VIDEO, dest="frame_count",
+        help="only used with --with-frames",
+    )
     parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
     parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     args = parser.parse_args()
@@ -202,10 +228,13 @@ def main():
         parser.error("--reasoning-budget must be positive")
     if args.force_budget < 1:
         parser.error("--force-budget must be positive")
+    if args.frame_count < 1:
+        parser.error("--frames-per-video must be positive")
     launch(
         args.model, args.spatial_code_format, selected,
         results_dir=args.results_dir, rebuild=args.rebuild,
         extended=not args.base_protocol,
+        frames=args.frames, frame_selection=args.frame_selection, frame_count=args.frame_count,
         reasoning_budget=args.reasoning_budget, force_budget=args.force_budget,
         strip_schema_legend=args.strip_schema_legend,
     )

harness/D/run.py

@@ -20,36 +20,66 @@ WORKSPACE_ROOT = Path(__file__).resolve().parent.parent.parent
 if str(WORKSPACE_ROOT) not in sys.path:
     sys.path.insert(0, str(WORKSPACE_ROOT))
 
+import inference as inference_config  # noqa: E402
 from harness.A import EXTENDED_MAX_NEW_TOKENS, MAX_NEW_TOKENS  # noqa: E402
+from harness.A import frames as frame_sampling  # noqa: E402
 from harness.A import models as vlm_models  # noqa: E402
 from harness.A.run import _scalar_score, load_questions, vsi_official_eval  # noqa: E402
+from harness.B import DEFAULT_INPUT_SELECTION, FRAMES_PER_VIDEO, INPUT_SELECTIONS  # noqa: E402
+from harness.C import prompts as combined_prompts  # noqa: E402
 from harness.D import DEFAULT_SPATIAL_CODE_FORMAT, RESULTS_DIR, SPATIAL_CODE_FORMATS  # noqa: E402
 from harness.D import prompts as code_prompts  # noqa: E402
 from harness.D.prompts import NO_LEGEND_PRE_PROMPT  # noqa: E402
 from harness.D import spatial_codes  # noqa: E402
 
 
-def results_dir_for(model, protocol, spatial_code_format, results_dir=None):
+def results_dir_for(
+    model, protocol, spatial_code_format, results_dir=None,
+    frames=False, frame_selection=DEFAULT_INPUT_SELECTION, frame_count=FRAMES_PER_VIDEO,
+):
     """Return the result root isolated by model + protocol + spatial-code-format.
     ``protocol`` is "base" (16-token) or "<reasoning budget>" (e.g. "512") -- a real path segment, so records from different protocols OR
-    different reasoning budgets can never collide on disk."""
+    different reasoning budgets can never collide on disk.
+
+    ``frames=True`` (the frames+ground-truth-code arm) appends its own "frames/
+    <selection>/<count>" segment -- video frames have no bearing on which ground-truth
+    code gets loaded (ground truth has no depth/tracking/input-selection axis at all;
+    see harness/D/__init__.py), but they DO change what the model sees, so this arm's
+    records must never share a path with the text-only condition's."""
     if results_dir is not None:
         return Path(results_dir)
-    return RESULTS_DIR / model / protocol / spatial_code_format
+    root = RESULTS_DIR / model / protocol / spatial_code_format
+    if frames:
+        root = root / "frames" / frame_selection / str(frame_count)
+    return root
 
 
 def _build_record(row, prompt, answer, metric_name, score, model, model_path, code_info):
-    """Assemble one question's full, untruncated result record (nothing summarized)."""
+    """Assemble one question's full, untruncated result record (nothing summarized).
+
+    ``code_info`` carries frame provenance (``video_path``, ``frame_indices``,
+    ``frame_timestamps``) only for the frames+ground-truth-code arm; all three are None
+    on the standard text-only condition, matching how harness.A/B/D's other optional
+    fields (``reasoning_text`` etc.) are present-but-null rather than absent."""
+    condition = f"{code_info['protocol']}:{code_info['spatial_code_format']}"
+    if code_info.get("frames"):
+        condition += f":frames:{code_info['frame_selection']}:{code_info['frame_count']}"
     return {
         "model": model,
         "model_path": str(model_path),
         "device": answer["device"],
         "dtype": answer["dtype"],
         "library_versions": answer["library_versions"],
-        "condition": f"{code_info['protocol']}:{code_info['spatial_code_format']}",
+        "condition": condition,
         "protocol": code_info["protocol"],
         "spatial_code_format": code_info["spatial_code_format"],
         "spatial_code_path": code_info["spatial_code_path"],
+        "frames": code_info.get("frames", False),
+        "frame_selection": code_info.get("frame_selection"),
+        "frame_count": code_info.get("frame_count"),
+        "video_path": code_info.get("video_path"),
+        "frame_indices": code_info.get("frame_indices"),
+        "frame_timestamps_seconds": code_info.get("frame_timestamps"),
         "scene": row["scene_name"],
         "dataset": row.get("dataset"),
         "question_id": row["id"],
@@ -87,7 +117,10 @@ def write_question_result(
     """Write one question's full, untruncated result record. Return (path, record)."""
     record = _build_record(row, prompt, answer, metric_name, score, model, model_path, code_info)
     root = results_dir_for(
-        model, code_info["protocol"], code_info["spatial_code_format"], results_dir
+        model, code_info["protocol"], code_info["spatial_code_format"], results_dir,
+        frames=code_info.get("frames", False),
+        frame_selection=code_info.get("frame_selection", DEFAULT_INPUT_SELECTION),
+        frame_count=code_info.get("frame_count", FRAMES_PER_VIDEO),
     )
     scene_dir = root / record["scene"]
     scene_dir.mkdir(parents=True, exist_ok=True)
@@ -113,10 +146,26 @@ def run(
     force_budget=MAX_NEW_TOKENS,
     code_transform=None,
     strip_schema_legend=False,
+    frames=False,
+    frame_selection=DEFAULT_INPUT_SELECTION,
+    frame_count=FRAMES_PER_VIDEO,
 ):
     """Answer every matching question with one model, given its scene's GROUND-TRUTH
-    spatial code as text (no video frames). Each question's full record is written to
-    its own JSON file as soon as it is answered (unless ``write_results=False``).
+    spatial code as text. Each question's full record is written to its own JSON file
+    as soon as it is answered (unless ``write_results=False``).
+
+    ``frames=True`` runs the frames+ground-truth-code arm: the scene's raw video is
+    ALSO sampled (``frame_selection``/``frame_count``, harness.A.frames.sample_frames --
+    the same sampling every harness uses; ground truth has no depth/tracking axis for
+    frames to be sourced "from", so there is nothing for this to mismatch against) and
+    shown alongside the ground-truth code, with harness.C's frames+code context line
+    (byte-identical composition rule: harness.A's frame sentence + harness.B's code
+    sentence, the same CODE_DESCRIPTION D's own text-only line already uses). This is
+    the ground-truth counterpart of harness C -- C answers with frames + a PERCEIVED
+    code; this is frames + the PERFECT code -- which harness C itself cannot produce,
+    since its spatial-code loader is perception-only. The default ``frame_selection``/
+    ``frame_count`` match the frozen Step-1 config (uniform, 32) so a default frames=True
+    call needs no extra flags to land on the same sampling every other harness uses.
 
     Uses ``adapter.answer_extended`` as the standing default protocol, same as
     harness.B -- working through a full spatial-code JSON before answering benefits
@@ -151,18 +200,36 @@ def run(
                     code = code_transform(code, scene_id, spatial_code_format)
                 if strip_schema_legend:
                     code = {k: v for k, v in code.items() if k != "spatial code schema"}
-                code_cache[scene_id] = {"code": code, "path": path}
+                entry = {"code": code, "path": path}
+                if frames:
+                    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
+                    )
+                    entry.update(
+                        video_path=video_path, frame_images=frame_images,
+                        frame_timestamps=frame_timestamps, frame_indices=frame_indices,
+                    )
+                code_cache[scene_id] = entry
             cached = code_cache[scene_id]
+            if frames:
+                context_line = (
+                    combined_prompts.NO_LEGEND_PRE_PROMPT if strip_schema_legend
+                    else combined_prompts.PRE_PROMPT
+                )
+            else:
+                context_line = NO_LEGEND_PRE_PROMPT if strip_schema_legend else None
             prompt = code_prompts.build_prompt(
                 cached["code"], row["question_type"], row["question"], row.get("options"),
-                context_line=NO_LEGEND_PRE_PROMPT if strip_schema_legend else None,
+                context_line=context_line,
             )
             answer = (
                 adapter.answer_extended(
-                    [], prompt, reasoning_budget=reasoning_budget, force_budget=force_budget
+                    cached["frame_images"] if frames else [], prompt,
+                    reasoning_budget=reasoning_budget, force_budget=force_budget,
                 )
                 if extended
-                else adapter.answer([], prompt)
+                else adapter.answer(cached["frame_images"] if frames else [], prompt)
             )
             doc = {"question_type": row["question_type"], "ground_truth": row["ground_truth"]}
             score_doc = vsi_official_eval.vsibench_process_results(
@@ -173,6 +240,12 @@ def run(
                 "protocol": f"{reasoning_budget}" if extended else "base",
                 "spatial_code_format": spatial_code_format,
                 "spatial_code_path": cached["path"],
+                "frames": frames,
+                "frame_selection": frame_selection if frames else None,
+                "frame_count": frame_count if frames else None,
+                "video_path": cached.get("video_path"),
+                "frame_indices": cached.get("frame_indices"),
+                "frame_timestamps": cached.get("frame_timestamps"),
             }
             if write_results:
                 path, record = write_question_result(
@@ -219,6 +292,20 @@ def main():
         "--no-schema-legend", action="store_true", dest="strip_schema_legend",
         help="drop the embedded schema legend (the amended main-run design)",
     )
+    parser.add_argument(
+        "--with-frames", action="store_true", dest="frames",
+        help="frames+ground-truth-code arm: also sample and show the scene's raw video "
+        "frames alongside the ground-truth code (default sampling: uniform, 32 frames -- "
+        "the frozen Step-1 config)",
+    )
+    parser.add_argument(
+        "--frame-selection", default=DEFAULT_INPUT_SELECTION, choices=INPUT_SELECTIONS,
+        dest="frame_selection", help="only used with --with-frames",
+    )
+    parser.add_argument(
+        "--frames-per-video", type=int, default=FRAMES_PER_VIDEO, dest="frame_count",
+        help="only used with --with-frames",
+    )
     parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
     parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     args = parser.parse_args()
@@ -226,6 +313,8 @@ def main():
         parser.error("--reasoning-budget must be positive")
     if args.force_budget < 1:
         parser.error("--force-budget must be positive")
+    if args.frame_count < 1:
+        parser.error("--frames-per-video must be positive")
 
     results = run(
         args.model,
@@ -239,6 +328,9 @@ def main():
         strip_schema_legend=args.strip_schema_legend,
         reasoning_budget=args.reasoning_budget,
         force_budget=args.force_budget,
+        frames=args.frames,
+        frame_selection=args.frame_selection,
+        frame_count=args.frame_count,
     )
 
     for result in results:

harness/D/sweep.py

@@ -25,7 +25,7 @@ if str(WORKSPACE_ROOT) not in sys.path:
 from harness.A import models as vlm_models  # noqa: E402
 from harness.A import EXTENDED_MAX_NEW_TOKENS  # noqa: E402
 from harness.A.sweep import _parse_csv_choice  # noqa: E402
-from harness.B import SPATIAL_CODE_FORMATS  # noqa: E402
+from harness.B import DEFAULT_INPUT_SELECTION, FRAMES_PER_VIDEO, INPUT_SELECTIONS, SPATIAL_CODE_FORMATS  # noqa: E402
 from harness.D import launch as harness_launch  # noqa: E402
 
 
@@ -41,19 +41,22 @@ def build_plan(models, spatial_code_formats):
 def sweep(
     models, spatial_code_formats, selected_scenes, results_dir=None, rebuild=False,
     extended=True, reasoning_budget=EXTENDED_MAX_NEW_TOKENS, strip_schema_legend=False,
+    frames=False, frame_selection=DEFAULT_INPUT_SELECTION, frame_count=FRAMES_PER_VIDEO,
 ):
     """Run every (model, spatial_code_format) pair across all visible GPUs."""
     plan = build_plan(models, spatial_code_formats)
     protocol = "extended" if extended else "base"
     for index, (model, spatial_code_format) in enumerate(plan, start=1):
         print(
-            f"=== sweep {index}/{len(plan)}: {model}/{protocol}/{spatial_code_format} ===",
+            f"=== sweep {index}/{len(plan)}: {model}/{protocol}/{spatial_code_format}"
+            + (f"/frames/{frame_selection}/{frame_count}" if frames else "") + " ===",
             flush=True,
         )
         harness_launch.launch(
             model, spatial_code_format, selected_scenes,
             results_dir=results_dir, rebuild=rebuild, extended=extended,
             reasoning_budget=reasoning_budget, strip_schema_legend=strip_schema_legend,
+            frames=frames, frame_selection=frame_selection, frame_count=frame_count,
         )
 
 
@@ -88,9 +91,25 @@ def main():
         "--no-schema-legend", action="store_true", dest="strip_schema_legend",
         help="drop the embedded schema legend (the amended main-run design)",
     )
+    parser.add_argument(
+        "--with-frames", action="store_true", dest="frames",
+        help="frames+ground-truth-code arm: also sample and show the scene's raw video "
+        "frames alongside the ground-truth code (default sampling: uniform, 32 frames -- "
+        "the frozen Step-1 config)",
+    )
+    parser.add_argument(
+        "--frame-selection", default=DEFAULT_INPUT_SELECTION, choices=INPUT_SELECTIONS,
+        dest="frame_selection", help="only used with --with-frames",
+    )
+    parser.add_argument(
+        "--frames-per-video", type=int, default=FRAMES_PER_VIDEO, dest="frame_count",
+        help="only used with --with-frames",
+    )
     args = parser.parse_args()
     if args.scene and args.scenes:
         parser.error("positional scene and --scenes cannot be used together")
+    if args.frame_count < 1:
+        parser.error("--frames-per-video must be positive")
 
     try:
         models = _parse_csv_choice(args.models, vlm_models.available_models(), "--models")
@@ -114,6 +133,7 @@ def main():
         extended=not args.base_protocol,
         reasoning_budget=args.reasoning_budget,
         strip_schema_legend=args.strip_schema_legend,
+        frames=args.frames, frame_selection=args.frame_selection, frame_count=args.frame_count,
     )
 
 

tests/test_D/test_run.py

@@ -67,11 +67,18 @@ def test_build_record_preserves_every_field_untruncated():
     assert record["answer_given"] == "4"
     assert record["spatial_code_format"] == "explicit"
     assert record["spatial_code_path"] == _FAKE_CODE_INFO["spatial_code_path"]
-    # No depth/tracking/input_selection/frame_count -- ground truth has no such axis.
+    # No depth/tracking/input_selection -- ground truth has no such axis. frames/
+    # frame_selection/frame_count/video_path/frame_indices/frame_timestamps_seconds DO
+    # exist on every record (the frames+ground-truth-code arm's fields), null here since
+    # _FAKE_CODE_INFO has no "frames" key -- same present-but-null pattern as
+    # reasoning_text on a base-protocol record.
     assert record["condition"] == "extended:explicit"
     assert record["protocol"] == "extended"
+    assert record["frames"] is False
+    assert record["frame_selection"] is None
+    assert record["frame_count"] is None
+    assert record["video_path"] is None
     assert "input_selection" not in record
-    assert "frame_count" not in record
     assert "depth" not in record
     assert "tracking" not in record
     assert record["metric"] == "MRA:.5:.95:.05"