Restructure benchmark release

Move split files to splits/*.json, keep video archives on the Hub, and move evaluation code/docs to GitHub.

.gitattributes

@@ -73,3 +73,8 @@ benchmark_splits/test_expert_seen/video_progress_benchmark_file.json filter=lfs
 benchmark_splits/test_expert_unseen/video_progress_benchmark_file.json filter=lfs diff=lfs merge=lfs -text
 benchmark_splits/test_nonexpert_seen/video_progress_benchmark_file.json filter=lfs diff=lfs merge=lfs -text
 benchmark_splits/test_nonexpert_unseen/video_progress_benchmark_file.json filter=lfs diff=lfs merge=lfs -text
+splits/train.json filter=lfs diff=lfs merge=lfs -text
+splits/test_expert_seen.json filter=lfs diff=lfs merge=lfs -text
+splits/test_expert_unseen.json filter=lfs diff=lfs merge=lfs -text
+splits/test_nonexpert_seen.json filter=lfs diff=lfs merge=lfs -text
+splits/test_nonexpert_unseen.json filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,3 @@
+TODO: replace this file with the final Video Progress Benchmark dataset license before public release.
+
+Do not publish this dataset repository until the license text and usage restrictions have been finalized.

README.md

@@ -14,11 +14,11 @@ license: other
 
 **A video-language benchmark for process-level robot task progress estimation.**
 
-[Code](https://github.com/InternRobotics/VLAC-cut) · [Paper](<PAPER_URL>) · [VLAC-Cut Model](https://huggingface.co/InternRobotics/VLAC-Cut)
+[Code](https://github.com/InternRobotics/VLAC-Cut) · [Paper](<PAPER_URL>) · [VLAC-Cut Model](https://huggingface.co/InternRobotics/VLAC-Cut)
 
-The **Video Progress Benchmark (VPB)** evaluates whether a model can estimate how a robot task evolves throughout a video—not only whether the final frame looks successful. VPB is built from the held-out portion of the **Progress Annotation Dataset** and explicitly tests advancement, stagnation, regression, and recovery.
+The **Video Progress Benchmark (VPB)** evaluates whether a model can estimate how a robot task evolves throughout a video, not only whether the final frame looks successful. VPB is built from the held-out portion of the **Progress Annotation Dataset** and explicitly tests advancement, stagnation, regression, and recovery.
 
-This release provides the official split files, the raw-video subset required by the benchmark protocol, frame-extraction utilities, and scripts for reproducible VLAC-Cut inference and metric computation.
+This release provides the official split files and the raw-video subset required by the benchmark. Frame extraction, VLAC-Cut inference, and metric computation scripts are maintained in the GitHub repository.
 
 ## Why VPB?
 
@@ -59,148 +59,69 @@ VPB is organized along two axes:
 
 All views from the same physical execution are assigned to the same split. Held-out progress annotations are excluded from prompt construction, augmentation, in-context demonstration selection, fine-tuning, and checkpoint selection.
 
-## Evaluation Protocol
+## Evaluation Setup
 
 Annotated semantic keyframes are converted into a canonical reference trajectory by piecewise-linear interpolation. This interpolation is an evaluation convention; it does not assume that physical progress changes linearly between events.
 
 - global and terminal metrics are computed on the official `1 Hz` evaluation grid;
 - local direction metrics are computed directly on adjacent annotated semantic anchors;
 - global metrics are first computed per record and then averaged over metric-valid records, preventing long videos from dominating the result;
-- prediction coverage is strict by default: missing curve points, terminal predictions, or local-direction anchor predictions stop evaluation unless `--allow-missing` is explicitly used for diagnostics.
+- prediction coverage is strict by default in the public evaluator.
 
 ### Metrics
 
 | Scope | Metrics | What they measure |
 |---|---|---|
 | Global trajectory | MAE, PRC, VOC | Absolute calibration and ordering of progress states; VOC is reported only for expert trajectories |
-| Terminal state | TSA, successful F1, failed/incomplete F1, Macro-F1 | Whether the final state is complete using the common `≥ 90` threshold |
-| Local direction | AP+, AP−, MacroAP | Whether adjacent semantic events are correctly ranked as improvement or regression |
+| Terminal state | TSA, successful F1, failed/incomplete F1, Macro-F1 | Whether the final state is complete using the common `>= 90` threshold |
+| Local direction | AP+, AP-, MacroAP | Whether adjacent semantic events are correctly ranked as improvement or regression |
 
 ## Repository Contents
 
 ```text
-benchmark_splits/
-  train/video_progress_benchmark_file.json
-  test_expert_seen/video_progress_benchmark_file.json
-  test_expert_unseen/video_progress_benchmark_file.json
-  test_nonexpert_seen/video_progress_benchmark_file.json
-  test_nonexpert_unseen/video_progress_benchmark_file.json
-
-scripts/
-  unpack_data.sh
-  extract_vlac2_release_frames.py
-  build_vlac_cut_eval_manifest.py
-  run_vlac_cut_batch.py
-  evaluate_vpb_predictions.py
-  vlac2_release_common.py
-  vpb_public_eval_utils.py
-
-docs/
-  evaluate_vlac_cut_on_vpb.md
+splits/
+  train.json
+  test_expert_seen.json
+  test_expert_unseen.json
+  test_nonexpert_seen.json
+  test_nonexpert_unseen.json
 
 data/
   train_videos.tar
   test_videos.tar
-```
-
-## Quick Start
-
-### 1. Unpack the video archives
 
-```bash
-bash scripts/unpack_data.sh
+checksums.sha256
+LICENSE
+THIRD_PARTY_LICENSES.md
 ```
 
-By default, the archives are extracted under `data/`. To use another location:
-
-```bash
-bash scripts/unpack_data.sh /path/to/data
-```
-
-### 2. Extract benchmark frames
-
-```bash
-python scripts/extract_vlac2_release_frames.py \
-  --data-root /path/to/data \
-  --frames-root /path/to/data_extracted_frames
-```
+## Data Format
 
-The script extracts the benchmark main-view frames. If `--frames-root` is omitted, frames are written to `_extracted_frames/` under the release directory.
+Each split file is a JSON list. Each record includes the trajectory id, task metadata, frame index, dense progress values, semantic anchors, and optional reference context.
 
-The canonical split JSON files use the path prefix:
+The split files use the portable frame prefix:
 
 ```text
 __VLAC2_FRAMES_ROOT__/
 ```
 
-Resolve this prefix to the absolute extracted-frame directory. For example:
+Resolve this prefix to the absolute extracted-frame directory when running the GitHub tools.
 
-```text
-__VLAC2_FRAMES_ROOT__/episode/frame.jpg
-```
+## Evaluation Code
 
-becomes:
-
-```text
-/path/to/data_extracted_frames/episode/frame.jpg
-```
-
-### 3. Build the VLAC-Cut evaluation manifest
+Detailed running commands and the complete metric implementation are provided in the GitHub repository:
 
 ```bash
-python scripts/build_vlac_cut_eval_manifest.py \
-  --benchmark-root benchmark_splits \
-  --frames-root /path/to/data_extracted_frames \
-  --out manifests/vlac_cut_vpb_eval.jsonl
-```
+git clone https://github.com/InternRobotics/VLAC-Cut
+cd VLAC-Cut
 
-For the reported VLAC-Cut evaluation, the manifest samples model-input frames at `2 Hz`, stores the public `1 Hz` evaluation frames, and materializes the exact `chunk_all` prompt in `vlac_cut_prompt`.
-
-The `2 Hz` input rate is a VLAC-Cut inference choice, not a benchmark-wide requirement. Official metrics are computed on the released `1 Hz` evaluation grid.
-
-### 4. Run VLAC-Cut batch inference
-
-Download or clone the model release from `InternRobotics/VLAC-Cut`, then run:
-
-```bash
-python scripts/run_vlac_cut_batch.py \
-  --model-path /path/to/VLAC-Cut \
-  --manifest manifests/vlac_cut_vpb_eval.jsonl \
-  --out predictions/vlac_cut_predictions.jsonl
-```
-
-Each prediction row uses the following schema:
-
-```json
-{
-  "global_episode_id": "...",
-  "frames": [65, 80, 95],
-  "response": "时间: 0.0s, 进度: 0%\n时间: 1.0s, 进度: 50%"
-}
-```
-
-Keep the manifest's original `frames` list in each trajectory-level prediction. The evaluator maps predictions by original frame ID and scores only the official `eval_frames`.
-
-### 5. Evaluate predictions
-
-```bash
 python scripts/evaluate_vpb_predictions.py \
-  --benchmark-root benchmark_splits \
+  --benchmark-root /path/to/VLAC-Cut-Benchmark/splits \
   --predictions predictions/vlac_cut_predictions.jsonl \
   --out-json reports/vlac_cut_vpb_eval.json \
   --out-md reports/vlac_cut_vpb_eval.md
 ```
 
-The evaluator reports:
-
-- global progress metrics for the four-bucket overall split and each individual bucket;
-- terminal metrics for four-bucket overall, seen merged, and unseen merged;
-- local direction AP for four-bucket overall, seen merged, and unseen merged.
-
-By default, the evaluator requires complete predictions for all selected benchmark records. Use `--allow-missing` only when you intentionally want a diagnostic report with coverage and missing-count fields.
-
-See `docs/evaluate_vlac_cut_on_vpb.md` for accepted prediction formats and complete metric definitions.
-
 ## Citation
 
 Please replace the placeholder below with the final paper BibTeX before public release.

THIRD_PARTY_LICENSES.md

@@ -0,0 +1,3 @@
+# Third-Party Licenses
+
+TODO: list all third-party source datasets, video sources, base annotations, and their required notices before public release.

checksums.sha256

@@ -0,0 +1,7 @@
+43c916c9b0c6003b454602743801dd5bbc8e1ebe041d55bcb72373b589ae4951  splits/test_expert_seen.json
+0a8c7de51a3acaceecfaf14abaf7c97d981c37c8088db54f8ecebeb83afe94d5  splits/test_expert_unseen.json
+1599d10d8d9b144151aaea1675824dcf58100153a0478576c32b825c10c98c3c  splits/test_nonexpert_seen.json
+73797d1b2869177b10f004ad44b2da14273b7d75ee42cbd1c65e4c000d1965ea  splits/test_nonexpert_unseen.json
+ae2ac3b1966872bac2a372335e0465b2b3ac7f14ec07ac33c4583a0e48537f95  splits/train.json
+318f5eef73d9d6786494ced97be1999973fafbb75306e56fbbc5176f8c3b4670  data/test_videos.tar
+5cb8ba8a6886678c41a7b3345388448c5a279171b0f09cf16d07802d74d2a4a3  data/train_videos.tar

docs/evaluate_vlac_cut_on_vpb.md

@@ -1,203 +0,0 @@
-# Evaluating VLAC-Cut on Video-Progress Benchmark
-
-This document describes the public VLAC-Cut evaluation workflow for
-Video-Progress Benchmark. It uses only this benchmark release plus the separate
-VLAC-Cut model release at <https://huggingface.co/InternRobotics/VLAC-Cut>.
-
-## Evaluation Scope
-
-The benchmark metrics are computed on the released 1Hz evaluation frames
-reconstructed from each dense video timeline:
-
-- split scope: `test_expert_seen`, `test_expert_unseen`,
-  `test_nonexpert_seen`, `test_nonexpert_unseen`
-- view scope: the `metadata.main_path` view only
-- evaluation points: `--eval-points time_hz --sample-hz 1.0`
-- global progress metrics: `MAE`, `PRC`, and `VOC` for expert bucket rows
-- terminal metrics: final progress threshold `90%`
-- local direction metrics: `AP+`, `AP-`, and `MacroAP_D` on adjacent
-  `semantic_anchors` with `tau=0`
-- coverage requirement: complete predictions are required by default; use
-  `--allow-missing` only to produce a diagnostic report for incomplete runs
-
-For VLAC-Cut evaluation we feed the model frames sampled at 2Hz. This 2Hz input
-rate is a VLAC-Cut evaluation setting, not a benchmark-wide protocol
-requirement. The evaluator maps VLAC-Cut outputs back to original frame ids and
-computes metrics on the public 1Hz evaluation frames.
-
-## Workflow
-
-VLAC-Cut inference requires the model release environment: `torch`,
-`transformers` with `Qwen3VLMoeForConditionalGeneration` support, and enough GPU
-memory for the 30B checkpoint. The benchmark-side frame extraction, manifest
-building, and evaluation scripts are included in this release.
-
-Unpack videos:
-
-```bash
-bash scripts/unpack_data.sh /path/to/data
-```
-
-Extract benchmark frames:
-
-```bash
-python scripts/extract_vlac2_release_frames.py \
-  --data-root /path/to/data \
-  --frames-root /path/to/frames
-```
-
-Build the VLAC-Cut evaluation manifest:
-
-```bash
-python scripts/build_vlac_cut_eval_manifest.py \
-  --benchmark-root benchmark_splits \
-  --frames-root /path/to/frames \
-  --out manifests/vlac_cut_vpb_eval.jsonl
-```
-
-Run VLAC-Cut batch inference:
-
-```bash
-python scripts/run_vlac_cut_batch.py \
-  --model-path /path/to/VLAC-Cut \
-  --manifest manifests/vlac_cut_vpb_eval.jsonl \
-  --out predictions/vlac_cut_predictions.jsonl
-```
-
-Evaluate the batch predictions:
-
-```bash
-python scripts/evaluate_vpb_predictions.py \
-  --benchmark-root benchmark_splits \
-  --predictions predictions/vlac_cut_predictions.jsonl \
-  --out-json reports/vlac_cut_vpb_eval.json \
-  --out-md reports/vlac_cut_vpb_eval.md
-```
-
-## Manifest Fields
-
-Each trajectory-level manifest row contains the fields needed by the batch
-inference script:
-
-- `global_episode_id`: episode key used to match predictions with GT.
-- `frames` / `image_paths`: the 2Hz frame ids and frame images passed to
-  VLAC-Cut.
-- `eval_frames`: the public 1Hz frame ids used for global progress and terminal
-  metrics.
-- `vlac_cut_prompt`: the exact text prompt passed to the Qwen/VLAC-Cut model.
-- `prompt_variant`: fixed to `chunk_all`.
-- `prompt_source`: fixed to `task_description`.
-
-The prompt is materialized by the manifest builder as:
-
-```text
-任务描述和具体规划: {task_description}
-
-请根据任务描述和具体规划，找到并逐点生成视频中的关键动作点和相应的进度标注。输出格式要求：每个关键点一行，格式为：
-时间: X.Xs, 进度: Y%
-
-请严格按照上述格式输出，不要输出额外说明。
-```
-
-`task_description` already contains the task and progress plan, so it is not
-prefixed again with `task_instruction`.
-
-## Prediction Schema
-
-`run_vlac_cut_batch.py` writes one JSON object per trajectory:
-
-```json
-{
-  "global_episode_id": "ARX-data/.../episode_000000",
-  "frames": [0, 15, 30, 45, 60],
-  "response": "时间: 0.5s, 进度: 0%\n时间: 2.0s, 进度: 30%"
-}
-```
-
-This is the public evaluator schema. The evaluator parses `response`, aligns the
-parsed keypoints to the provided 2Hz `frames` list using index-normalized curve
-alignment, and then evaluates the aligned curve on the benchmark points.
-
-## Metrics
-
-### Global Progress
-
-For each trajectory, the evaluator compares predictions against the released
-`dense_kinematic_progress` values at the selected 1Hz frames.
-
-- `MAE`: mean absolute error over valid points in one trajectory, then averaged
-  equally over trajectories with at least one valid evaluated point.
-- `PRC`: Spearman correlation between GT progress and predicted progress in one
-  trajectory, then averaged equally over valid trajectories.
-- `VOC`: Spearman correlation between predicted progress and chronological
-  frame order in one trajectory, then averaged equally over valid expert-bucket
-  trajectories.
-
-The report shows 4-bucket overall and four per-bucket rows. VOC is omitted for
-the 4-bucket overall and non-expert bucket rows.
-
-### Terminal Success
-
-Terminal success uses the last selected 1Hz evaluation frame:
-
-- GT success: final GT progress `>= 90`
-- predicted success: final predicted progress `>= 90`
-- reported metrics: `TSA`, `F1_S`, `F1_F`, `MacroF1_T`, and `TP/FN/FP/TN`
-
-The report shows 4-bucket overall, seen merged, and unseen merged rows.
-
-### Local Direction AP
-
-Local direction is computed on adjacent released `semantic_anchors`. For each
-transition:
-
-```text
-Delta_gt   = gt_anchor_progress_end - gt_anchor_progress_start
-Delta_pred = pred_progress_end - pred_progress_start
-```
-
-Prediction values at anchor frames are obtained by linear interpolation over the
-model's valid predicted curve. The public report uses `tau=0`:
-
-```text
-AP+       = AP(y = 1[Delta_gt > 0], score = Delta_pred)
-AP-       = AP(y = 1[Delta_gt < 0], score = -Delta_pred)
-MacroAP_D = (AP+ + AP-) / 2
-```
-
-Stagnation transitions are negatives inside each AP ranking, but are not
-averaged as a separate third AP class. The report shows 4-bucket overall, seen
-merged, and unseen merged rows.
-
-## Diagnostics
-
-Missing or unparsable prediction rows are not silently filled. The report
-includes coverage, missing final counts, duplicate prediction counts, unknown
-episode ids, prediction frames outside the selected 1Hz evaluation points, and
-counts for predictions outside the nominal `[0, 100]` range. The nominal range
-counts are diagnostics only; predictions are not clipped unless `--clip-pred` is
-set.
-
-The evaluator is strict by default: if any selected trajectory lacks required
-curve points, terminal predictions, or local-direction anchor predictions, the
-command exits with an error before writing outputs. Add `--allow-missing` only
-when debugging incomplete prediction files and intentionally writing a
-diagnostic report.
-
-## Quick Checks
-
-Run the evaluator self-test:
-
-```bash
-python scripts/evaluate_vpb_predictions.py --self-test
-```
-
-Build a small smoke-test manifest:
-
-```bash
-python scripts/build_vlac_cut_eval_manifest.py \
-  --benchmark-root benchmark_splits \
-  --frames-root /path/to/frames \
-  --out /tmp/vlac_cut_vpb_manifest_smoke.jsonl \
-  --limit-trajectories 2
-```

scripts/build_vlac_cut_eval_manifest.py

@@ -1,325 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import json
-import math
-import sys
-from collections import Counter
-from pathlib import Path
-from typing import Any
-
-SCRIPT_DIR = Path(__file__).resolve().parent
-if str(SCRIPT_DIR) not in sys.path:
-    sys.path.insert(0, str(SCRIPT_DIR))
-
-from vlac2_release_common import absolute_frame_path_from_any
-from vpb_public_eval_utils import (
-    TEST_BUCKETS,
-    iter_benchmark_rows,
-    main_view_for_row,
-    selected_frames_for_row,
-)
-
-PROMPT_VARIANT = "chunk_all"
-PROMPT_SOURCE = "task_description"
-
-
-def build_vlac_cut_prompt(task_description: str) -> str:
-    task_and_plan = str(task_description or "").strip()
-    return (
-        f"任务描述和具体规划: {task_and_plan}\n\n"
-        "请根据任务描述和具体规划，找到并逐点生成视频中的关键动作点和相应的进度标注。"
-        "输出格式要求：每个关键点一行，格式为：\n"
-        "时间: X.Xs, 进度: Y%\n\n"
-        "请严格按照上述格式输出，不要输出额外说明。"
-    )
-
-
-def parse_args() -> argparse.Namespace:
-    release_root = SCRIPT_DIR.parent
-    parser = argparse.ArgumentParser(
-        description="Build a VLAC-Cut evaluation manifest for the public Video-Progress Benchmark."
-    )
-    parser.add_argument(
-        "--benchmark-root",
-        type=Path,
-        default=release_root / "benchmark_splits",
-        help="Directory containing the benchmark split folders.",
-    )
-    parser.add_argument(
-        "--frames-root",
-        type=Path,
-        default=release_root / "_extracted_frames",
-        help="Root directory produced by extract_vlac2_release_frames.py.",
-    )
-    parser.add_argument("--out", type=Path, required=True, help="Output JSONL manifest path.")
-    parser.add_argument(
-        "--record-format",
-        choices=["trajectory", "point"],
-        default="trajectory",
-        help="Manifest row format. Use trajectory for video models and point for frame-level models.",
-    )
-    parser.add_argument(
-        "--buckets",
-        nargs="+",
-        default=list(TEST_BUCKETS),
-        choices=list(TEST_BUCKETS),
-        help="Benchmark buckets to include.",
-    )
-    parser.add_argument(
-        "--eval-points",
-        choices=["time_hz", "dense", "semantic_anchors"],
-        default="time_hz",
-        help="Evaluation frame points. Default time_hz with --sample-hz 1.0 matches the public 1Hz evaluation protocol.",
-    )
-    parser.add_argument(
-        "--sample-hz",
-        type=float,
-        default=1.0,
-        help="Evaluation sampling rate used when --eval-points=time_hz.",
-    )
-    parser.add_argument(
-        "--input-sample-hz",
-        type=float,
-        default=2.0,
-        help="Trajectory-level video input sampling rate. The default is the 2Hz input setting used in our VLAC-Cut evaluation.",
-    )
-    parser.add_argument(
-        "--view",
-        default=None,
-        help="Override the view for all rows. By default, the view is inferred from metadata.main_path.",
-    )
-    parser.add_argument(
-        "--limit-trajectories",
-        type=int,
-        default=None,
-        help="Optional smoke-test limit per full manifest, applied after bucket filtering.",
-    )
-    parser.add_argument(
-        "--check-files",
-        action="store_true",
-        help="Check whether resolved frame files exist and report missing paths.",
-    )
-    return parser.parse_args()
-
-
-def build_record(
-    *,
-    bucket: str,
-    row_idx: int,
-    row: dict[str, Any],
-    frame: int,
-    timestamp_sec: float | None,
-    image_path: Path,
-    view: str,
-    is_terminal_point: bool,
-    selected_count: int,
-    eval_points: str,
-    sample_hz: float,
-) -> dict[str, Any]:
-    meta = dict(row.get("metadata") or {})
-    task_description = str(meta.get("task_description") or "")
-    record: dict[str, Any] = {
-        "bucket": bucket,
-        "row_index": row_idx,
-        "global_episode_id": str(row.get("global_episode_id") or ""),
-        "frame": int(frame),
-        "timestamp_sec": timestamp_sec,
-        "image_path": str(image_path),
-        "view": view,
-        "task_instruction": str(meta.get("task_instruction") or ""),
-        "task_description": task_description,
-        "vlac_cut_prompt": build_vlac_cut_prompt(task_description),
-        "prompt_variant": PROMPT_VARIANT,
-        "prompt_source": PROMPT_SOURCE,
-        "is_terminal_point": bool(is_terminal_point),
-        "selected_frame_count": int(selected_count),
-        "eval_points": eval_points,
-    }
-    if eval_points == "time_hz":
-        record["sample_hz"] = float(sample_hz)
-    if eval_points != "time_hz" or not math.isclose(float(sample_hz), 1.0):
-        record["non_strict_eval_input"] = True
-    return record
-
-
-def build_trajectory_record(
-    *,
-    bucket: str,
-    row_idx: int,
-    row: dict[str, Any],
-    input_frames: list[int],
-    input_timestamps_sec: list[float | None],
-    input_image_paths: list[Path],
-    eval_frames: list[int],
-    eval_timestamps_sec: list[float | None],
-    view: str,
-    eval_points: str,
-    eval_sample_hz: float,
-    input_sample_hz: float,
-) -> dict[str, Any]:
-    meta = dict(row.get("metadata") or {})
-    task_description = str(meta.get("task_description") or "")
-    record: dict[str, Any] = {
-        "bucket": bucket,
-        "row_index": row_idx,
-        "global_episode_id": str(row.get("global_episode_id") or ""),
-        "frames": [int(frame) for frame in input_frames],
-        "timestamps_sec": input_timestamps_sec,
-        "image_paths": [str(path) for path in input_image_paths],
-        "input_frames": [int(frame) for frame in input_frames],
-        "input_timestamps_sec": input_timestamps_sec,
-        "input_image_paths": [str(path) for path in input_image_paths],
-        "eval_frames": [int(frame) for frame in eval_frames],
-        "eval_timestamps_sec": eval_timestamps_sec,
-        "view": view,
-        "task_instruction": str(meta.get("task_instruction") or ""),
-        "task_description": task_description,
-        "vlac_cut_prompt": build_vlac_cut_prompt(task_description),
-        "prompt_variant": PROMPT_VARIANT,
-        "prompt_source": PROMPT_SOURCE,
-        "terminal_frame": int(eval_frames[-1]) if eval_frames else None,
-        "selected_frame_count": len(input_frames),
-        "input_frame_count": len(input_frames),
-        "eval_frame_count": len(eval_frames),
-        "eval_points": eval_points,
-        "input_sample_hz": float(input_sample_hz),
-    }
-    if eval_points == "time_hz":
-        record["sample_hz"] = float(eval_sample_hz)
-        record["eval_sample_hz"] = float(eval_sample_hz)
-    if eval_points != "time_hz" or not math.isclose(float(eval_sample_hz), 1.0):
-        record["non_strict_eval_input"] = True
-    return record
-
-
-def main() -> None:
-    args = parse_args()
-    if args.sample_hz <= 0:
-        raise SystemExit("--sample-hz must be positive")
-    if args.input_sample_hz <= 0:
-        raise SystemExit("--input-sample-hz must be positive")
-
-    args.out.parent.mkdir(parents=True, exist_ok=True)
-    stats: Counter[str] = Counter()
-    emitted_trajectories = 0
-
-    with args.out.open("w", encoding="utf-8") as f:
-        for bucket, row_idx, row in iter_benchmark_rows(args.benchmark_root, args.buckets):
-            if args.limit_trajectories is not None and emitted_trajectories >= args.limit_trajectories:
-                break
-
-            eval_selected = selected_frames_for_row(
-                row,
-                eval_points=args.eval_points,
-                sample_hz=float(args.sample_hz),
-            )
-            if not eval_selected.frames:
-                stats["skipped_empty_selection"] += 1
-                continue
-            input_selected = selected_frames_for_row(
-                row,
-                eval_points="time_hz",
-                sample_hz=float(args.input_sample_hz),
-            )
-            if args.record_format == "trajectory" and not input_selected.frames:
-                stats["skipped_empty_input_selection"] += 1
-                continue
-
-            selected_view = str(args.view or main_view_for_row(row) or "").strip()
-            if not selected_view:
-                stats["skipped_missing_view"] += 1
-                continue
-
-            frame_index = dict(row.get("frame_index") or {})
-            full_eval_frames = eval_selected.frames
-            terminal_frame = full_eval_frames[-1]
-            source_selection = input_selected if args.record_format == "trajectory" else eval_selected
-            resolved_frames: list[int] = []
-            resolved_timestamps: list[float | None] = []
-            resolved_paths: list[Path] = []
-            missing_view = False
-            for frame, timestamp_sec in zip(source_selection.frames, source_selection.timestamps_sec):
-                image_map = frame_index.get(str(frame))
-                if not isinstance(image_map, dict) or selected_view not in image_map:
-                    stats["missing_view_points"] += 1
-                    missing_view = True
-                    continue
-                image_path = absolute_frame_path_from_any(str(image_map[selected_view]), args.frames_root)
-                if args.check_files and not image_path.exists():
-                    stats["missing_frame_files"] += 1
-                resolved_frames.append(frame)
-                resolved_timestamps.append(timestamp_sec)
-                resolved_paths.append(image_path)
-
-            if not resolved_frames:
-                stats["skipped_no_resolved_frames"] += 1
-                continue
-            if args.record_format == "trajectory" and missing_view:
-                stats["skipped_incomplete_trajectory"] += 1
-                continue
-
-            emitted_for_traj = 0
-            if args.record_format == "trajectory":
-                record = build_trajectory_record(
-                    bucket=bucket,
-                    row_idx=row_idx,
-                    row=row,
-                    input_frames=resolved_frames,
-                    input_timestamps_sec=resolved_timestamps,
-                    input_image_paths=resolved_paths,
-                    eval_frames=eval_selected.frames,
-                    eval_timestamps_sec=eval_selected.timestamps_sec,
-                    view=selected_view,
-                    eval_points=args.eval_points,
-                    eval_sample_hz=float(args.sample_hz),
-                    input_sample_hz=float(args.input_sample_hz),
-                )
-                f.write(json.dumps(record, ensure_ascii=False) + "\n")
-                stats["records"] += 1
-                stats["trajectory_records"] += 1
-                emitted_for_traj = 1
-            else:
-                for frame, timestamp_sec, image_path in zip(
-                    resolved_frames,
-                    resolved_timestamps,
-                    resolved_paths,
-                ):
-                    record = build_record(
-                        bucket=bucket,
-                        row_idx=row_idx,
-                        row=row,
-                        frame=frame,
-                        timestamp_sec=timestamp_sec,
-                        image_path=image_path,
-                        view=selected_view,
-                        is_terminal_point=(frame == terminal_frame),
-                        selected_count=len(eval_selected.frames),
-                        eval_points=args.eval_points,
-                        sample_hz=float(args.sample_hz),
-                    )
-                    f.write(json.dumps(record, ensure_ascii=False) + "\n")
-                    emitted_for_traj += 1
-                    stats["records"] += 1
-                    stats["point_records"] += 1
-            if emitted_for_traj:
-                emitted_trajectories += 1
-                stats["trajectories"] += 1
-
-    summary = {
-        "out": str(args.out),
-        "benchmark_root": str(args.benchmark_root),
-        "frames_root": str(args.frames_root),
-        "buckets": list(args.buckets),
-        "eval_points": args.eval_points,
-        "sample_hz": float(args.sample_hz) if args.eval_points == "time_hz" else None,
-        "input_sample_hz": float(args.input_sample_hz),
-        "record_format": args.record_format,
-        "stats": dict(stats),
-    }
-    print(json.dumps(summary, ensure_ascii=False, indent=2))
-
-
-if __name__ == "__main__":
-    main()

scripts/evaluate_vpb_predictions.py

@@ -1,1138 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import json
-import math
-import re
-import sys
-import tempfile
-from collections import Counter
-from pathlib import Path
-from typing import Any
-
-SCRIPT_DIR = Path(__file__).resolve().parent
-if str(SCRIPT_DIR) not in sys.path:
-    sys.path.insert(0, str(SCRIPT_DIR))
-
-from vpb_public_eval_utils import (
-    EXPERT_BUCKETS,
-    TEST_BUCKETS,
-    Trajectory,
-    build_trajectories,
-    dump_json,
-    finite_float,
-    format_metric,
-    format_percent,
-    markdown_table,
-    mean_or_none,
-    spearman_corr,
-)
-
-
-PredMap = dict[str, dict[int, float]]
-SIGNED_NUM = r"([+-]?[0-9]+(?:\.[0-9]+)?)"
-POINT_TIME_RE = re.compile(r"(?:Time|时间)[:：]?\s*([0-9]+(?:\.[0-9]+)?)\s*s?", re.IGNORECASE)
-POINT_PROGRESS_LINE_RE = re.compile(rf"(?im)^\s*(?:Progress|进度)[:：]?\s*{SIGNED_NUM}\s*%")
-INLINE_POINT_RE = re.compile(
-    rf"(?:Time|时间)[:：]?\s*([0-9]+(?:\.[0-9]+)?)\s*s?\s*[,，]?\s*(?:Progress|进度)[:：]?\s*{SIGNED_NUM}\s*%",
-    re.IGNORECASE,
-)
-SEEN_BUCKETS = ("test_expert_seen", "test_nonexpert_seen")
-UNSEEN_BUCKETS = ("test_expert_unseen", "test_nonexpert_unseen")
-LOCAL_DIRECTION_TAU_PERCENT = 0.0
-
-
-def parse_args() -> argparse.Namespace:
-    release_root = SCRIPT_DIR.parent
-    parser = argparse.ArgumentParser(
-        description="Evaluate public Video-Progress Benchmark predictions."
-    )
-    parser.add_argument(
-        "--benchmark-root",
-        type=Path,
-        default=release_root / "benchmark_splits",
-        help="Directory containing the benchmark split folders.",
-    )
-    parser.add_argument(
-        "--predictions",
-        type=Path,
-        help="VLAC-Cut batch prediction JSONL with global_episode_id, frames, and response.",
-    )
-    parser.add_argument("--out-json", type=Path, help="Output JSON report.")
-    parser.add_argument("--out-md", type=Path, help="Output Markdown report.")
-    parser.add_argument(
-        "--buckets",
-        nargs="+",
-        default=list(TEST_BUCKETS),
-        choices=list(TEST_BUCKETS),
-        help="Benchmark buckets to evaluate.",
-    )
-    parser.add_argument(
-        "--eval-points",
-        choices=["time_hz", "dense", "semantic_anchors"],
-        default="time_hz",
-        help="Evaluation frame points. Default time_hz with --sample-hz 1.0 reconstructs the public 1Hz protocol.",
-    )
-    parser.add_argument(
-        "--sample-hz",
-        type=float,
-        default=1.0,
-        help="Sampling rate used when --eval-points=time_hz.",
-    )
-    parser.add_argument(
-        "--success-threshold",
-        type=float,
-        default=90.0,
-        help="Terminal success threshold in progress percent.",
-    )
-    parser.add_argument(
-        "--clip-pred",
-        nargs=2,
-        type=float,
-        metavar=("MIN", "MAX"),
-        default=None,
-        help="Optionally clip predictions before evaluation.",
-    )
-    parser.add_argument(
-        "--interpolate-missing",
-        action="store_true",
-        help="Linearly interpolate missing prediction frames within each trajectory. This is not the strict default.",
-    )
-    parser.add_argument(
-        "--allow-missing",
-        action="store_true",
-        help="Write a diagnostic report even when predictions do not cover every required evaluation point.",
-    )
-    parser.add_argument(
-        "--self-test",
-        action="store_true",
-        help="Run a small synthetic self-test and exit.",
-    )
-    return parser.parse_args()
-
-
-def load_prediction_rows(path: Path) -> list[dict[str, Any]]:
-    text = path.read_text(encoding="utf-8").strip()
-    if not text:
-        return []
-    try:
-        payload = json.loads(text)
-    except json.JSONDecodeError:
-        rows = []
-        for line_no, line in enumerate(text.splitlines(), start=1):
-            raw = line.strip()
-            if not raw:
-                continue
-            item = json.loads(raw)
-            if not isinstance(item, dict):
-                raise ValueError(f"Prediction line {line_no} is not an object")
-            rows.append(item)
-        return rows
-
-    if isinstance(payload, list):
-        if not all(isinstance(item, dict) for item in payload):
-            raise ValueError("Prediction JSON list must contain objects")
-        return list(payload)
-    if isinstance(payload, dict):
-        for key in ("predictions", "results", "rows"):
-            value = payload.get(key)
-            if isinstance(value, list):
-                if not all(isinstance(item, dict) for item in value):
-                    raise ValueError(f"Prediction JSON field {key!r} must contain objects")
-                return list(value)
-        return [payload]
-    raise ValueError("Prediction file must be JSONL, a JSON object, or a JSON list")
-
-
-def strip_code_fence(text: str) -> str:
-    cleaned = str(text or "").strip()
-    if cleaned.startswith("```") and cleaned.endswith("```"):
-        lines = cleaned.splitlines()
-        if len(lines) >= 3:
-            return "\n".join(lines[1:-1]).strip()
-    return cleaned
-
-
-def dedupe_sorted_points(times: list[float], values: list[float]) -> tuple[list[float], list[float]]:
-    if not times:
-        return [], []
-    pairs = sorted(zip(times, values), key=lambda item: (item[0], item[1]))
-    out_times: list[float] = []
-    out_values: list[float] = []
-    cur_time = pairs[0][0]
-    bucket: list[float] = []
-    for time_val, progress_val in pairs:
-        if time_val != cur_time:
-            out_times.append(float(cur_time))
-            out_values.append(float(sum(bucket) / len(bucket)))
-            cur_time = time_val
-            bucket = [float(progress_val)]
-        else:
-            bucket.append(float(progress_val))
-    out_times.append(float(cur_time))
-    out_values.append(float(sum(bucket) / len(bucket)))
-    return out_times, out_values
-
-
-def parse_point_blocks(text: str) -> tuple[list[float], list[float]]:
-    cleaned = strip_code_fence(text)
-    if not cleaned:
-        return [], []
-    inline_matches = INLINE_POINT_RE.findall(cleaned)
-    if inline_matches:
-        return dedupe_sorted_points(
-            [float(time_val) for time_val, _ in inline_matches],
-            [float(progress_val) for _, progress_val in inline_matches],
-        )
-    blocks = re.split(r"(?=(?:Time|时间)[:：]?\s*[0-9])", cleaned, flags=re.IGNORECASE)
-    times: list[float] = []
-    values: list[float] = []
-    for block in blocks:
-        block = block.strip()
-        if not block:
-            continue
-        time_match = POINT_TIME_RE.search(block)
-        progress_match = POINT_PROGRESS_LINE_RE.search(block)
-        if time_match and progress_match:
-            times.append(float(time_match.group(1)))
-            values.append(float(progress_match.group(1)))
-    return dedupe_sorted_points(times, values)
-
-
-def align_curve_to_length(raw_times: list[float], raw_values: list[float], target_len: int) -> list[float]:
-    """Match the formal VLAC evaluator's index-normalized curve alignment."""
-    if target_len <= 0 or not raw_values:
-        return []
-    if len(raw_values) == 1:
-        return [float(raw_values[0])] * target_len
-    times, values = dedupe_sorted_points(raw_times, raw_values)
-    if len(values) == 1:
-        return [float(values[0])] * target_len
-    start = float(times[0])
-    end = float(times[-1])
-    if math.isclose(start, end):
-        if len(values) == 1:
-            positions = [0.0]
-        else:
-            positions = [idx * float(target_len - 1) / float(len(values) - 1) for idx in range(len(values))]
-    else:
-        positions = [(time_val - start) / (end - start) * float(target_len - 1) for time_val in times]
-
-    aligned: list[float] = []
-    for target in range(target_len):
-        target_f = float(target)
-        if target_f <= positions[0]:
-            aligned.append(float(values[0]))
-            continue
-        if target_f >= positions[-1]:
-            aligned.append(float(values[-1]))
-            continue
-        for idx in range(len(positions) - 1):
-            if positions[idx] <= target_f <= positions[idx + 1]:
-                if math.isclose(positions[idx], positions[idx + 1]):
-                    value = float(values[idx])
-                else:
-                    alpha = (target_f - positions[idx]) / (positions[idx + 1] - positions[idx])
-                    value = float(values[idx]) + alpha * (float(values[idx + 1]) - float(values[idx]))
-                aligned.append(float(value))
-                break
-    return aligned
-
-
-def maybe_clip(value: float, clip_range: tuple[float, float] | None, stats: Counter[str]) -> float:
-    if clip_range is None:
-        if value < 0.0 or value > 100.0:
-            stats["outside_nominal_0_100_predictions"] += 1
-        return value
-    lo, hi = clip_range
-    clipped = min(max(value, lo), hi)
-    if clipped != value:
-        stats["clipped_predictions"] += 1
-    return clipped
-
-
-def add_prediction(
-    pred_map: PredMap,
-    *,
-    gid: str,
-    frame: int,
-    value: Any,
-    clip_range: tuple[float, float] | None,
-    stats: Counter[str],
-) -> None:
-    pred_value = finite_float(value)
-    if pred_value is None:
-        stats["invalid_prediction_values"] += 1
-        return
-    pred_value = maybe_clip(float(pred_value), clip_range, stats)
-    frame_map = pred_map.setdefault(gid, {})
-    if int(frame) in frame_map:
-        stats["duplicate_frame_predictions"] += 1
-    frame_map[int(frame)] = pred_value
-    stats["valid_prediction_values"] += 1
-
-
-def add_canonical_vlac_response_predictions(
-    pred_map: PredMap,
-    *,
-    gid: str,
-    row: dict[str, Any],
-    clip_range: tuple[float, float] | None,
-    stats: Counter[str],
-) -> None:
-    frame_sequence = row.get("frames")
-    if not isinstance(frame_sequence, list) or not frame_sequence:
-        stats["canonical_rows_missing_frames"] += 1
-        return
-    valid_frames: list[int] = []
-    for raw_frame in frame_sequence:
-        frame = finite_float(raw_frame)
-        if frame is None:
-            stats["canonical_rows_invalid_frames"] += 1
-            return
-        valid_frames.append(int(frame))
-
-    response = row.get("response")
-    if not isinstance(response, str) or not response.strip():
-        stats["canonical_rows_missing_response"] += 1
-        return
-
-    raw_times, raw_values = parse_point_blocks(response)
-
-    if not raw_values:
-        stats["canonical_response_parse_failed"] += 1
-        return
-
-    aligned = align_curve_to_length(raw_times, raw_values, len(valid_frames))
-    if not aligned:
-        stats["canonical_response_align_failed"] += 1
-        return
-
-    for frame, value in zip(valid_frames, aligned):
-        add_prediction(
-            pred_map,
-            gid=gid,
-            frame=frame,
-            value=value,
-            clip_range=clip_range,
-            stats=stats,
-        )
-    stats["canonical_response_rows_aligned_by_index"] += 1
-
-
-def load_predictions(
-    path: Path,
-    *,
-    trajectories: list[Trajectory],
-    clip_range: tuple[float, float] | None,
-) -> tuple[PredMap, dict[str, Any]]:
-    traj_by_gid = {traj.global_episode_id: traj for traj in trajectories}
-    pred_map: PredMap = {}
-    stats: Counter[str] = Counter()
-    unknown_examples: list[str] = []
-
-    rows = load_prediction_rows(path)
-    stats["rows"] = len(rows)
-    for row in rows:
-        gid = str(row.get("global_episode_id") or "").strip()
-        if not gid:
-            stats["rows_missing_global_episode_id"] += 1
-            continue
-        traj = traj_by_gid.get(gid)
-        if traj is None:
-            stats["unknown_global_episode_id"] += 1
-            if len(unknown_examples) < 10:
-                unknown_examples.append(gid)
-            continue
-
-        add_canonical_vlac_response_predictions(
-            pred_map,
-            gid=gid,
-            row=row,
-            clip_range=clip_range,
-            stats=stats,
-        )
-
-    known_frames = {traj.global_episode_id: set(traj.frames) for traj in trajectories}
-    extra_frame_count = 0
-    for gid, frame_map in pred_map.items():
-        eval_frames = known_frames.get(gid, set())
-        for frame in frame_map:
-            if frame not in eval_frames:
-                extra_frame_count += 1
-    stats["prediction_frames_outside_eval_points"] = extra_frame_count
-
-    return pred_map, {"stats": dict(stats), "unknown_global_episode_id_examples": unknown_examples}
-
-
-def interpolated_value(frame_map: dict[int, float], frame: int) -> float | None:
-    if frame in frame_map:
-        return frame_map[frame]
-    if not frame_map:
-        return None
-    points = sorted(frame_map.items())
-    if frame <= points[0][0]:
-        return points[0][1]
-    if frame >= points[-1][0]:
-        return points[-1][1]
-    for (left_frame, left_value), (right_frame, right_value) in zip(points, points[1:]):
-        if left_frame <= frame <= right_frame:
-            if right_frame == left_frame:
-                return left_value
-            alpha = (frame - left_frame) / float(right_frame - left_frame)
-            return left_value + alpha * (right_value - left_value)
-    return None
-
-
-def interpolated_prediction_for_frame(pred_map: PredMap, gid: str, frame: int) -> float | None:
-    frame_map = pred_map.get(gid)
-    if not frame_map:
-        return None
-    return interpolated_value(frame_map, int(frame))
-
-
-def prediction_at(
-    pred_map: PredMap,
-    gid: str,
-    frame: int,
-    *,
-    interpolate_missing: bool,
-) -> float | None:
-    frame_map = pred_map.get(gid)
-    if not frame_map:
-        return None
-    if frame in frame_map:
-        return frame_map[frame]
-    if interpolate_missing:
-        return interpolated_value(frame_map, frame)
-    return None
-
-
-def summarize_curve(
-    trajectories: list[Trajectory],
-    pred_map: PredMap,
-    *,
-    interpolate_missing: bool,
-    include_voc: bool,
-) -> dict[str, Any]:
-    base_points = sum(len(traj.frames) for traj in trajectories)
-    matched_trajs = 0
-    matched_points = 0
-    valid_points = 0
-    traj_with_valid_pred = 0
-    mae_values: list[float] = []
-    prc_values: list[float] = []
-    voc_values: list[float] = []
-
-    for traj in trajectories:
-        has_predictions = traj.global_episode_id in pred_map
-        if has_predictions:
-            matched_trajs += 1
-            matched_points += len(traj.frames)
-
-        gt_curve: list[float] = []
-        pred_curve: list[float] = []
-        for frame, gt in zip(traj.frames, traj.gt_progress):
-            pred = prediction_at(
-                pred_map,
-                traj.global_episode_id,
-                frame,
-                interpolate_missing=interpolate_missing,
-            )
-            if pred is None or not math.isfinite(float(pred)):
-                continue
-            valid_points += 1
-            gt_curve.append(float(gt))
-            pred_curve.append(float(pred))
-
-        if gt_curve:
-            traj_with_valid_pred += 1
-            mae_values.append(
-                sum(abs(gt - pred) for gt, pred in zip(gt_curve, pred_curve))
-                / len(gt_curve)
-            )
-
-        prc = spearman_corr(gt_curve, pred_curve)
-        if prc is not None:
-            prc_values.append(prc)
-        if include_voc:
-            voc = spearman_corr(pred_curve, [float(i) for i in range(1, len(pred_curve) + 1)])
-            if voc is not None:
-                voc_values.append(voc)
-
-    return {
-        "traj_base_total": len(trajectories),
-        "traj_matched": matched_trajs,
-        "traj_with_valid_pred": traj_with_valid_pred,
-        "point_base_total": base_points,
-        "point_total_on_matched": matched_points,
-        "point_valid": valid_points,
-        "point_coverage_to_base": (valid_points / base_points) if base_points else None,
-        "point_coverage_on_matched": (valid_points / matched_points) if matched_points else None,
-        "mae": mean_or_none(mae_values),
-        "mae_valid_traj": len(mae_values),
-        "prc": mean_or_none(prc_values),
-        "prc_valid_traj": len(prc_values),
-        "voc": mean_or_none(voc_values) if include_voc else None,
-        "voc_valid_traj": len(voc_values) if include_voc else 0,
-    }
-
-
-def average_precision_ranked(items: list[tuple[int, float]]) -> float | None:
-    positive_total = int(sum(label for label, _ in items))
-    if not items or positive_total == 0:
-        return None
-    ranked = sorted(enumerate(items), key=lambda item: (-float(item[1][1]), item[0]))
-    hits = 0
-    precision_sum = 0.0
-    for rank, (_, (label, _score)) in enumerate(ranked, start=1):
-        if int(label) == 1:
-            hits += 1
-            precision_sum += hits / rank
-    return precision_sum / positive_total
-
-
-def classify_delta(delta: float, tau_percent: float) -> str:
-    if delta > tau_percent:
-        return "positive"
-    if delta < -tau_percent:
-        return "negative"
-    return "neutral"
-
-
-def summarize_local_direction_ap(
-    trajectories: list[Trajectory],
-    pred_map: PredMap,
-    *,
-    tau_percent: float,
-) -> dict[str, Any]:
-    transition_total = 0
-    valid = 0
-    missing = 0
-    gt_counts: Counter[str] = Counter()
-    valid_gt_counts: Counter[str] = Counter()
-    positive_items: list[tuple[int, float]] = []
-    negative_items: list[tuple[int, float]] = []
-
-    for traj in trajectories:
-        frames = traj.semantic_anchor_frames
-        progress = traj.semantic_anchor_progress
-        for idx in range(max(0, len(frames) - 1)):
-            transition_total += 1
-            gt_delta = float(progress[idx + 1]) - float(progress[idx])
-            gt_class = classify_delta(gt_delta, tau_percent)
-            gt_counts[gt_class] += 1
-
-            left = interpolated_prediction_for_frame(pred_map, traj.global_episode_id, frames[idx])
-            right = interpolated_prediction_for_frame(pred_map, traj.global_episode_id, frames[idx + 1])
-            if left is None or right is None or not math.isfinite(float(left)) or not math.isfinite(float(right)):
-                missing += 1
-                continue
-
-            valid += 1
-            valid_gt_counts[gt_class] += 1
-            pred_delta = float(right) - float(left)
-            positive_items.append((1 if gt_delta > tau_percent else 0, pred_delta))
-            negative_items.append((1 if gt_delta < -tau_percent else 0, -pred_delta))
-
-    ap_positive = average_precision_ranked(positive_items)
-    ap_negative = average_precision_ranked(negative_items)
-    macro_ap = (
-        0.5 * (ap_positive + ap_negative)
-        if ap_positive is not None and ap_negative is not None
-        else None
-    )
-    return {
-        "tau_percent": float(tau_percent),
-        "transition_total": int(transition_total),
-        "valid": int(valid),
-        "missing": int(missing),
-        "gt_counts": {key: int(gt_counts.get(key, 0)) for key in ("positive", "neutral", "negative")},
-        "valid_gt_counts": {key: int(valid_gt_counts.get(key, 0)) for key in ("positive", "neutral", "negative")},
-        "ap_positive_support": int(sum(label for label, _ in positive_items)),
-        "ap_negative_support": int(sum(label for label, _ in negative_items)),
-        "ap_positive": ap_positive,
-        "ap_negative": ap_negative,
-        "macro_ap_d": macro_ap,
-    }
-
-
-def finalize_terminal_counter(counter: Counter[str]) -> dict[str, Any]:
-    support = int(counter.get("support", 0))
-    valid_final = int(counter.get("valid_final", 0))
-    tp = int(counter.get("tp", 0))
-    fn = int(counter.get("fn", 0))
-    fp = int(counter.get("fp", 0))
-    tn = int(counter.get("tn", 0))
-    gt_success = int(counter.get("gt_success", 0))
-    gt_failure = int(counter.get("gt_failure", 0))
-    pred_success = int(counter.get("pred_success", 0))
-    pred_failure = int(counter.get("pred_failure", 0))
-    missing_final = int(counter.get("missing_final", 0))
-    valid_binary = tp + fn + fp + tn
-
-    f1_success = (2 * tp / (2 * tp + fp + fn)) if (2 * tp + fp + fn) else None
-    f1_failure = (2 * tn / (2 * tn + fp + fn)) if (2 * tn + fp + fn) else None
-    macro_f1_terminal = (
-        (f1_success + f1_failure) / 2.0
-        if f1_success is not None and f1_failure is not None
-        else None
-    )
-    return {
-        "support": support,
-        "gt_success": gt_success,
-        "gt_failure": gt_failure,
-        "valid_final": valid_final,
-        "missing_final": missing_final,
-        "pred_success": pred_success,
-        "pred_failure": pred_failure,
-        "tp": tp,
-        "fn": fn,
-        "fp": fp,
-        "tn": tn,
-        "tsa": ((tp + tn) / valid_binary) if valid_binary else None,
-        "f1_success": f1_success,
-        "f1_failure": f1_failure,
-        "macro_f1_terminal": macro_f1_terminal,
-    }
-
-
-def summarize_terminal(
-    trajectories: list[Trajectory],
-    pred_map: PredMap,
-    *,
-    success_threshold: float,
-    interpolate_missing: bool,
-) -> dict[str, Any]:
-    counter: Counter[str] = Counter()
-    for traj in trajectories:
-        counter["support"] += 1
-        gt_final = float(traj.gt_progress[-1])
-        gt_success = gt_final >= success_threshold
-        if gt_success:
-            counter["gt_success"] += 1
-        else:
-            counter["gt_failure"] += 1
-
-        pred_final = prediction_at(
-            pred_map,
-            traj.global_episode_id,
-            traj.frames[-1],
-            interpolate_missing=interpolate_missing,
-        )
-        if pred_final is None or not math.isfinite(float(pred_final)):
-            counter["missing_final"] += 1
-            continue
-        counter["valid_final"] += 1
-        pred_success = float(pred_final) >= success_threshold
-        if pred_success:
-            counter["pred_success"] += 1
-        else:
-            counter["pred_failure"] += 1
-
-        if gt_success and pred_success:
-            counter["tp"] += 1
-        elif gt_success and not pred_success:
-            counter["fn"] += 1
-        elif (not gt_success) and pred_success:
-            counter["fp"] += 1
-        else:
-            counter["tn"] += 1
-    return finalize_terminal_counter(counter)
-
-
-def build_report(
-    *,
-    trajectories: list[Trajectory],
-    pred_map: PredMap,
-    prediction_info: dict[str, Any],
-    config: dict[str, Any],
-) -> dict[str, Any]:
-    selected_buckets = list(config["buckets"])
-    by_bucket = {bucket: [traj for traj in trajectories if traj.bucket == bucket] for bucket in selected_buckets}
-    interpolate_missing = bool(config["interpolate_missing"])
-    success_threshold = float(config["success_threshold_percent"])
-    seen_trajs = [
-        traj for bucket in SEEN_BUCKETS for traj in by_bucket.get(bucket, [])
-    ]
-    unseen_trajs = [
-        traj for bucket in UNSEEN_BUCKETS for traj in by_bucket.get(bucket, [])
-    ]
-
-    curve_per_bucket = {
-        bucket: summarize_curve(
-            bucket_trajs,
-            pred_map,
-            interpolate_missing=interpolate_missing,
-            include_voc=(bucket in EXPERT_BUCKETS),
-        )
-        for bucket, bucket_trajs in by_bucket.items()
-    }
-    terminal_per_bucket = {
-        bucket: summarize_terminal(
-            bucket_trajs,
-            pred_map,
-            success_threshold=success_threshold,
-            interpolate_missing=interpolate_missing,
-        )
-        for bucket, bucket_trajs in by_bucket.items()
-    }
-    local_direction_per_bucket = {
-        bucket: summarize_local_direction_ap(
-            bucket_trajs,
-            pred_map,
-            tau_percent=LOCAL_DIRECTION_TAU_PERCENT,
-        )
-        for bucket, bucket_trajs in by_bucket.items()
-    }
-
-    return {
-        "config": config,
-        "benchmark": {
-            "traj_total": len(trajectories),
-            "point_total": sum(len(traj.frames) for traj in trajectories),
-            "buckets": {
-                bucket: {
-                    "traj_total": len(bucket_trajs),
-                    "point_total": sum(len(traj.frames) for traj in bucket_trajs),
-                }
-                for bucket, bucket_trajs in by_bucket.items()
-            },
-        },
-        "prediction_input": prediction_info,
-        "curve": {
-            "overall_4bucket": summarize_curve(
-                trajectories,
-                pred_map,
-                interpolate_missing=interpolate_missing,
-                include_voc=False,
-            ),
-            "per_bucket": curve_per_bucket,
-        },
-        "terminal": {
-            "overall_4bucket": summarize_terminal(
-                trajectories,
-                pred_map,
-                success_threshold=success_threshold,
-                interpolate_missing=interpolate_missing,
-            ),
-            "seen_merged": summarize_terminal(
-                seen_trajs,
-                pred_map,
-                success_threshold=success_threshold,
-                interpolate_missing=interpolate_missing,
-            ),
-            "unseen_merged": summarize_terminal(
-                unseen_trajs,
-                pred_map,
-                success_threshold=success_threshold,
-                interpolate_missing=interpolate_missing,
-            ),
-            "per_bucket": terminal_per_bucket,
-        },
-        "local_direction_ap": {
-            "tau_percent": LOCAL_DIRECTION_TAU_PERCENT,
-            "overall_4bucket": summarize_local_direction_ap(
-                trajectories,
-                pred_map,
-                tau_percent=LOCAL_DIRECTION_TAU_PERCENT,
-            ),
-            "seen_merged": summarize_local_direction_ap(
-                seen_trajs,
-                pred_map,
-                tau_percent=LOCAL_DIRECTION_TAU_PERCENT,
-            ),
-            "unseen_merged": summarize_local_direction_ap(
-                unseen_trajs,
-                pred_map,
-                tau_percent=LOCAL_DIRECTION_TAU_PERCENT,
-            ),
-            "per_bucket": local_direction_per_bucket,
-        },
-    }
-
-
-def validate_no_missing(report: dict[str, Any]) -> dict[str, Any]:
-    errors: list[str] = []
-
-    curve_sources = [("overall_4bucket", report["curve"]["overall_4bucket"])]
-    curve_sources.extend(
-        (bucket, item)
-        for bucket, item in report["curve"]["per_bucket"].items()
-    )
-    for scope, item in curve_sources:
-        if int(item.get("point_valid", 0)) != int(item.get("point_base_total", 0)):
-            errors.append(
-                f"curve.{scope}: point_valid={item.get('point_valid')} "
-                f"point_base_total={item.get('point_base_total')}"
-            )
-        if int(item.get("traj_with_valid_pred", 0)) != int(item.get("traj_base_total", 0)):
-            errors.append(
-                f"curve.{scope}: traj_with_valid_pred={item.get('traj_with_valid_pred')} "
-                f"traj_base_total={item.get('traj_base_total')}"
-            )
-
-    terminal_sources = [
-        ("overall_4bucket", report["terminal"]["overall_4bucket"]),
-        ("seen_merged", report["terminal"]["seen_merged"]),
-        ("unseen_merged", report["terminal"]["unseen_merged"]),
-    ]
-    terminal_sources.extend(
-        (bucket, item)
-        for bucket, item in report["terminal"]["per_bucket"].items()
-    )
-    for scope, item in terminal_sources:
-        if int(item.get("valid_final", 0)) != int(item.get("support", 0)) or int(item.get("missing_final", 0)) != 0:
-            errors.append(
-                f"terminal.{scope}: valid_final={item.get('valid_final')} "
-                f"support={item.get('support')} missing_final={item.get('missing_final')}"
-            )
-
-    direction_sources = [
-        ("overall_4bucket", report["local_direction_ap"]["overall_4bucket"]),
-        ("seen_merged", report["local_direction_ap"]["seen_merged"]),
-        ("unseen_merged", report["local_direction_ap"]["unseen_merged"]),
-    ]
-    direction_sources.extend(
-        (bucket, item)
-        for bucket, item in report["local_direction_ap"]["per_bucket"].items()
-    )
-    for scope, item in direction_sources:
-        if int(item.get("valid", 0)) != int(item.get("transition_total", 0)) or int(item.get("missing", 0)) != 0:
-            errors.append(
-                f"local_direction_ap.{scope}: valid={item.get('valid')} "
-                f"transition_total={item.get('transition_total')} missing={item.get('missing')}"
-            )
-
-    return {
-        "no_missing_check": not errors,
-        "error_count": len(errors),
-        "errors": errors,
-    }
-
-
-def point_ratio(item: dict[str, Any]) -> str:
-    return f"{int(item.get('point_valid', 0))}/{int(item.get('point_base_total', 0))}"
-
-
-def traj_ratio(item: dict[str, Any]) -> str:
-    return f"{int(item.get('traj_with_valid_pred', 0))}/{int(item.get('traj_base_total', 0))}"
-
-
-def terminal_ratio(item: dict[str, Any]) -> str:
-    return f"{int(item.get('valid_final', 0))}/{int(item.get('support', 0))}"
-
-
-def build_markdown(report: dict[str, Any]) -> str:
-    config = report["config"]
-    selected_buckets = list(config["buckets"])
-    lines: list[str] = []
-    lines.append("# Video-Progress Benchmark Evaluation")
-    lines.append("")
-    lines.append("## Protocol")
-    lines.append("")
-    lines.append(f"- eval_points: `{config['eval_points']}`")
-    lines.append(f"- sample_hz: `{config['sample_hz']}`")
-    lines.append(f"- success_threshold: `{config['success_threshold_percent']}`")
-    lines.append(f"- interpolate_missing: `{config['interpolate_missing']}`")
-    lines.append(f"- allow_missing: `{config['allow_missing']}`")
-    lines.append(f"- no_missing_check: `{report['validation']['no_missing_check']}`")
-    lines.append("- Curve metrics are trajectory-equal means over metric-valid trajectories.")
-    lines.append("- VOC is reported only for expert bucket rows.")
-    lines.append("- Local Direction AP uses adjacent released `semantic_anchors`; predictions are linearly interpolated at anchor frames.")
-    lines.append("- By default, missing curve, terminal, or local-direction predictions stop evaluation; use `--allow-missing` only for diagnostics.")
-    lines.append("")
-
-    curve_rows: list[list[Any]] = []
-    curve_sources = [("overall_4bucket", report["curve"]["overall_4bucket"])]
-    for bucket in selected_buckets:
-        curve_sources.append((bucket, report["curve"]["per_bucket"][bucket]))
-    for scope, item in curve_sources:
-        include_voc = scope in EXPERT_BUCKETS
-        row = [
-            scope,
-            format_percent(item.get("point_coverage_to_base")),
-            point_ratio(item),
-            traj_ratio(item),
-            format_metric(item.get("mae")),
-            format_metric(item.get("prc")),
-        ]
-        if include_voc:
-            row.append(format_metric(item.get("voc")))
-        else:
-            row.append("n/a")
-        curve_rows.append(
-            row
-        )
-    lines.append("## Curve Metrics")
-    lines.append("")
-    lines.append(
-        markdown_table(
-            ["scope", "coverage", "point_valid/base", "traj_valid/base", "MAE", "PRC", "VOC"],
-            curve_rows,
-        )
-    )
-    lines.append("")
-
-    terminal_rows: list[list[Any]] = []
-    terminal_sources = [
-        ("overall_4bucket", report["terminal"]["overall_4bucket"]),
-        ("seen_merged", report["terminal"]["seen_merged"]),
-        ("unseen_merged", report["terminal"]["unseen_merged"]),
-    ]
-    for scope, item in terminal_sources:
-        terminal_rows.append(
-            [
-                scope,
-                terminal_ratio(item),
-                format_metric(item.get("tsa")),
-                format_metric(item.get("f1_success")),
-                format_metric(item.get("f1_failure")),
-                format_metric(item.get("macro_f1_terminal")),
-                int(item.get("tp", 0)),
-                int(item.get("fn", 0)),
-                int(item.get("fp", 0)),
-                int(item.get("tn", 0)),
-                int(item.get("missing_final", 0)),
-            ]
-        )
-    lines.append("## Terminal Metrics")
-    lines.append("")
-    lines.append(
-        markdown_table(
-            [
-                "scope",
-                "valid_final/support",
-                "TSA",
-                "F1_S",
-                "F1_F",
-                "MacroF1_T",
-                "TP",
-                "FN",
-                "FP",
-                "TN",
-                "missing_final",
-            ],
-            terminal_rows,
-        )
-    )
-    lines.append("")
-
-    local_direction_rows: list[list[Any]] = []
-    local_direction_sources = [
-        ("overall_4bucket", report["local_direction_ap"]["overall_4bucket"]),
-        ("seen_merged", report["local_direction_ap"]["seen_merged"]),
-        ("unseen_merged", report["local_direction_ap"]["unseen_merged"]),
-    ]
-    for scope, item in local_direction_sources:
-        gt_counts = item.get("gt_counts") or {}
-        local_direction_rows.append(
-            [
-                scope,
-                f"{int(item.get('valid', 0))}/{int(item.get('transition_total', 0))}",
-                f"{int(gt_counts.get('positive', 0))}/{int(gt_counts.get('neutral', 0))}/{int(gt_counts.get('negative', 0))}",
-                f"{int(item.get('ap_positive_support', 0))}/{int(item.get('ap_negative_support', 0))}",
-                format_percent(item.get("ap_positive")),
-                format_percent(item.get("ap_negative")),
-                format_percent(item.get("macro_ap_d")),
-            ]
-        )
-    lines.append("## Local Direction AP")
-    lines.append("")
-    tau_text = f"{float(report['local_direction_ap']['tau_percent']):g}%"
-    lines.append(
-        f"`tau={tau_text}`. "
-        "`AP+ = AP(y=Delta_gt>tau, score=Delta_pred)`, "
-        "`AP- = AP(y=Delta_gt<-tau, score=-Delta_pred)`, "
-        "`MacroAP_D = (AP+ + AP-) / 2`."
-    )
-    lines.append("")
-    lines.append(
-        markdown_table(
-            ["scope", "valid/trans", "GT +/0/-", "support +/-", "AP+", "AP-", "MacroAP_D"],
-            local_direction_rows,
-        )
-    )
-    lines.append("")
-
-    lines.append("## Prediction Diagnostics")
-    lines.append("")
-    stats = report["prediction_input"]["stats"]
-    diagnostic_rows = [[key, value] for key, value in sorted(stats.items())]
-    lines.append(markdown_table(["key", "value"], diagnostic_rows))
-    lines.append("")
-    return "\n".join(lines)
-
-
-def run_self_test() -> None:
-    def row(gid: str, gt_values: list[float], *, success: bool = True) -> dict[str, Any]:
-        frames = [0, 30, 60]
-        if not success:
-            gt_values = [0.0, 20.0, 50.0]
-        return {
-            "global_episode_id": gid,
-            "metadata": {
-                "fps": 30.0,
-                "start_idx": 0,
-                "main_path": f"ARX-data/mock/videos/chunk-000/observation.images.front/{gid}",
-                "available_views": ["front"],
-                "task_instruction": "mock task",
-                "task_description": "mock task",
-            },
-            "frame_index": {
-                str(frame): {"front": f"__VLAC2_FRAMES_ROOT__/mock/{gid}/{frame}-90.jpg"}
-                for frame in frames
-            },
-            "dense_kinematic_progress": {
-                str(frame): value for frame, value in zip(frames, gt_values)
-            },
-            "semantic_anchors": [
-                {"frame": frame, "human_annotated_progress": value}
-                for frame, value in zip(frames, gt_values)
-            ],
-        }
-
-    with tempfile.TemporaryDirectory() as tmp_dir:
-        root = Path(tmp_dir) / "benchmark_splits"
-        rows_by_bucket = {
-            "test_expert_seen": [row("traj_success_a", [0.0, 50.0, 100.0])],
-            "test_expert_unseen": [row("traj_success_b", [0.0, 40.0, 100.0])],
-            "test_nonexpert_seen": [row("traj_failure_a", [0.0, 20.0, 50.0], success=False)],
-            "test_nonexpert_unseen": [row("traj_failure_b", [0.0, 10.0, 40.0], success=False)],
-        }
-        for bucket, rows in rows_by_bucket.items():
-            split_dir = root / bucket
-            split_dir.mkdir(parents=True)
-            (split_dir / "video_progress_benchmark_file.json").write_text(
-                json.dumps(rows),
-                encoding="utf-8",
-            )
-        pred_path = Path(tmp_dir) / "predictions.jsonl"
-        with pred_path.open("w", encoding="utf-8") as f:
-            for rows in rows_by_bucket.values():
-                for item in rows:
-                    points = sorted(
-                        (int(frame), float(value))
-                        for frame, value in item["dense_kinematic_progress"].items()
-                    )
-                    f.write(
-                        json.dumps(
-                            {
-                                "global_episode_id": item["global_episode_id"],
-                                "frames": [frame for frame, _value in points],
-                                "response": "\n".join(
-                                    f"时间: {idx:.1f}s, 进度: {value:g}%"
-                                    for idx, (_frame, value) in enumerate(points)
-                                ),
-                            },
-                            ensure_ascii=False,
-                        )
-                        + "\n"
-                    )
-        trajectories = build_trajectories(root, eval_points="time_hz", sample_hz=1.0)
-        pred_map, prediction_info = load_predictions(
-            pred_path,
-            trajectories=trajectories,
-            clip_range=None,
-        )
-        report = build_report(
-            trajectories=trajectories,
-            pred_map=pred_map,
-            prediction_info=prediction_info,
-            config={
-                "benchmark_root": str(root),
-                "predictions": str(pred_path),
-                "buckets": list(TEST_BUCKETS),
-                "eval_points": "time_hz",
-                "sample_hz": 1.0,
-                "success_threshold_percent": 90.0,
-                "interpolate_missing": False,
-                "clip_pred": None,
-            },
-        )
-        assert report["benchmark"]["traj_total"] == 4
-        assert report["curve"]["overall_4bucket"]["mae"] == 0.0
-        assert report["terminal"]["overall_4bucket"]["tsa"] == 1.0
-        assert report["local_direction_ap"]["overall_4bucket"]["ap_positive"] == 1.0
-        assert validate_no_missing(report)["no_missing_check"] is True
-    print("[self-test] ok")
-
-
-def main() -> None:
-    args = parse_args()
-    if args.self_test:
-        run_self_test()
-        return
-    if args.predictions is None:
-        raise SystemExit("--predictions is required unless --self-test is set")
-    if args.out_json is None and args.out_md is None:
-        raise SystemExit("At least one of --out-json or --out-md is required")
-    if args.sample_hz <= 0:
-        raise SystemExit("--sample-hz must be positive")
-
-    clip_range = None
-    if args.clip_pred is not None:
-        lo, hi = args.clip_pred
-        if lo > hi:
-            raise SystemExit("--clip-pred MIN must be <= MAX")
-        clip_range = (float(lo), float(hi))
-
-    trajectories = build_trajectories(
-        args.benchmark_root,
-        buckets=args.buckets,
-        eval_points=args.eval_points,
-        sample_hz=float(args.sample_hz),
-    )
-    pred_map, prediction_info = load_predictions(
-        args.predictions,
-        trajectories=trajectories,
-        clip_range=clip_range,
-    )
-    config = {
-        "benchmark_root": str(args.benchmark_root),
-        "predictions": str(args.predictions),
-        "buckets": list(args.buckets),
-        "eval_points": args.eval_points,
-        "sample_hz": float(args.sample_hz) if args.eval_points == "time_hz" else None,
-        "success_threshold_percent": float(args.success_threshold),
-        "interpolate_missing": bool(args.interpolate_missing),
-        "allow_missing": bool(args.allow_missing),
-        "clip_pred": list(clip_range) if clip_range is not None else None,
-    }
-    report = build_report(
-        trajectories=trajectories,
-        pred_map=pred_map,
-        prediction_info=prediction_info,
-        config=config,
-    )
-    report["validation"] = validate_no_missing(report)
-    if not args.allow_missing and not report["validation"]["no_missing_check"]:
-        preview = "\n".join(report["validation"]["errors"][:20])
-        raise SystemExit(
-            "Predictions do not cover every required evaluation item. "
-            "Use --allow-missing only for a diagnostic report.\n"
-            f"{preview}"
-        )
-    if args.out_json is not None:
-        dump_json(args.out_json, report)
-    if args.out_md is not None:
-        args.out_md.parent.mkdir(parents=True, exist_ok=True)
-        args.out_md.write_text(build_markdown(report), encoding="utf-8")
-
-    print(
-        json.dumps(
-            {
-                "traj_total": report["benchmark"]["traj_total"],
-                "point_total": report["benchmark"]["point_total"],
-                "curve_overall": report["curve"]["overall_4bucket"],
-                "terminal_overall": report["terminal"]["overall_4bucket"],
-            },
-            ensure_ascii=False,
-            indent=2,
-        )
-    )
-
-
-if __name__ == "__main__":
-    main()

scripts/extract_vlac2_release_frames.py

@@ -1,394 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import sys
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
-
-import tqdm
-
-SCRIPT_DIR = Path(__file__).resolve().parent
-if str(SCRIPT_DIR) not in sys.path:
-    sys.path.insert(0, str(SCRIPT_DIR))
-
-from vlac2_release_common import (
-    discover_benchmark_jsons,
-    dump_json,
-    ensure_generated_marker,
-    infer_main_path_from_row,
-    load_json,
-    normalize_main_path,
-    PORTABLE_IMAGE_ROOT,
-)
-
-try:
-    import cv2  # type: ignore
-except ImportError:
-    cv2 = None
-
-try:
-    import imageio.v2 as imageio  # type: ignore
-except ImportError:
-    imageio = None
-
-try:
-    import av  # type: ignore
-except ImportError:
-    av = None
-
-
-@dataclass(frozen=True)
-class EpisodeSpec:
-    main_path: Path
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Extract the portable VLAC2 release benchmark episodes into a JPG tree."
-    )
-    parser.add_argument(
-        "--data-root",
-        type=Path,
-        required=True,
-        help="Directory containing the extracted raw benchmark videos.",
-    )
-    parser.add_argument(
-        "--frames-root",
-        type=Path,
-        default=PORTABLE_IMAGE_ROOT,
-        help="Directory where extracted benchmark frames will be written. Defaults to _extracted_frames under the release directory.",
-    )
-    parser.add_argument("--jobs", type=int, default=max(1, (os.cpu_count() or 8) // 2))
-    parser.add_argument(
-        "--overwrite-existing",
-        action="store_true",
-        help="Re-extract even if an output manifest says the target episode-view is already complete.",
-    )
-    return parser.parse_args()
-
-
-def bundled_release_root() -> Path:
-    return SCRIPT_DIR.parent.resolve()
-
-
-def resolve_data_root(raw_arg: Path, release_root: Path) -> Path:
-    return raw_arg.resolve() if raw_arg.is_absolute() else (release_root / raw_arg).resolve()
-
-
-def resolve_frames_root(raw_arg: Path, release_root: Path) -> Path:
-    return raw_arg.resolve() if raw_arg.is_absolute() else (release_root / raw_arg).resolve()
-
-
-def require_decoder() -> None:
-    if cv2 is None and imageio is None and av is None:
-        raise SystemExit(
-            "No video decoder available. Install opencv-python, PyAV, or imageio before running frame extraction."
-        )
-
-
-def benchmark_files_from_root(benchmark_root: Path) -> list[Path]:
-    files = discover_benchmark_jsons(benchmark_root)
-    if not files:
-        raise SystemExit(f"No benchmark json found under {benchmark_root}")
-    return files
-
-
-def episode_group_key(main_path: Path) -> str:
-    parts = list(main_path.parts)
-    for idx, part in enumerate(parts):
-        if part.startswith("observation.images.") and idx + 1 < len(parts):
-            return str(Path(*parts[:idx], parts[idx + 1]))
-    return str(main_path)
-
-
-def collect_episode_specs(benchmark_paths: list[Path]) -> tuple[list[EpisodeSpec], dict[str, Any]]:
-    grouped: dict[str, tuple[Path, set[str]]] = {}
-    stats = {
-        "benchmark_files_total": len(benchmark_paths),
-        "rows_total": 0,
-        "rows_missing_main_path": 0,
-    }
-
-    for benchmark_path in benchmark_paths:
-        rows = load_json(benchmark_path)
-        if not isinstance(rows, list):
-            raise ValueError(f"Expected list json: {benchmark_path}")
-        stats["rows_total"] += len(rows)
-        for row in rows:
-            inferred_main_path = infer_main_path_from_row(row)
-            if inferred_main_path is None:
-                stats["rows_missing_main_path"] += 1
-                continue
-            normalized = normalize_main_path(inferred_main_path)
-            # Keep different camera views for the same episode separate. The
-            # benchmark's main_path can target wrist/head/bird/etc. views, and
-            # merging by episode drops required frame directories.
-            key = str(normalized)
-            if key not in grouped:
-                grouped[key] = (normalized, {str(benchmark_path)})
-            else:
-                grouped[key][1].add(str(benchmark_path))
-
-    specs = [
-        EpisodeSpec(main_path=main_path)
-        for _group_key, (main_path, _sources) in sorted(grouped.items())
-    ]
-    stats["episodes_unique"] = len(specs)
-    return specs, stats
-
-
-def resolve_main_video(raw_root: Path, main_path: Path) -> Path:
-    candidate = raw_root / main_path
-    if candidate.suffix == ".mp4":
-        return candidate
-
-    # Keep the full main_path leaf intact when appending ".mp4" so episode
-    # identifiers containing dots (for example timestamps like "....311186")
-    # are not truncated. Fall back to with_suffix(".mp4") for compatibility
-    # with any legacy raw layouts that already dropped the tail suffix.
-    preferred = Path(f"{candidate}.mp4")
-    legacy = candidate.with_suffix(".mp4")
-    if preferred.exists() or preferred == legacy:
-        return preferred
-    if legacy.exists():
-        return legacy
-    return preferred
-
-
-def discover_view_videos(raw_root: Path, main_path: Path) -> list[Path]:
-    main_video = resolve_main_video(raw_root, main_path)
-    if not main_video.exists():
-        raise FileNotFoundError(f"Missing raw video: {main_video}")
-    return [main_video]
-
-
-def manifest_path_for(output_dir: Path) -> Path:
-    return output_dir / ".vlac_extract_manifest.json"
-
-
-def output_dir_from_video(raw_root: Path, output_root: Path, video_path: Path) -> Path:
-    relative = video_path.relative_to(raw_root).with_suffix("")
-    return output_root / relative
-
-
-def is_complete(output_dir: Path, source_video: Path) -> bool:
-    manifest_path = manifest_path_for(output_dir)
-    if not manifest_path.exists():
-        return False
-    try:
-        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
-    except Exception:
-        return False
-
-    frame_count = int(manifest.get("frame_count") or 0)
-    if frame_count <= 0:
-        return False
-    source_mtime_ns = int(source_video.stat().st_mtime_ns)
-    source_size = int(source_video.stat().st_size)
-    if int(manifest.get("source_mtime_ns") or -1) != source_mtime_ns:
-        return False
-    if int(manifest.get("source_size") or -1) != source_size:
-        return False
-
-    jpg_files = sorted(output_dir.glob("*.jpg"))
-    return len(jpg_files) == frame_count
-
-
-def clear_output_dir(output_dir: Path) -> None:
-    if not output_dir.exists():
-        return
-    for pattern in ("*.jpg", "frame_*.jpg", ".vlac_extract_manifest.json"):
-        for path in output_dir.glob(pattern):
-            if path.is_file():
-                path.unlink()
-
-
-def write_manifest(output_dir: Path, source_video: Path, frame_count: int) -> None:
-    manifest = {
-        "source_video": str(source_video),
-        "source_size": int(source_video.stat().st_size),
-        "source_mtime_ns": int(source_video.stat().st_mtime_ns),
-        "frame_count": int(frame_count),
-    }
-    manifest_path_for(output_dir).write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-
-
-def extract_with_cv2(source_video: Path, output_dir: Path) -> int:
-    assert cv2 is not None
-    capture = cv2.VideoCapture(str(source_video))
-    if not capture.isOpened():
-        raise RuntimeError(f"cv2 failed to open {source_video}")
-
-    temp_paths: list[Path] = []
-    frame_idx = 0
-    try:
-        while True:
-            ok, frame = capture.read()
-            if not ok:
-                break
-            temp_path = output_dir / f"frame_{frame_idx:06d}.jpg"
-            if not cv2.imwrite(str(temp_path), frame):
-                raise RuntimeError(f"cv2 failed to write {temp_path}")
-            temp_paths.append(temp_path)
-            frame_idx += 1
-    finally:
-        capture.release()
-
-    for idx, temp_path in enumerate(temp_paths):
-        temp_path.rename(output_dir / f"{idx}-{frame_idx}.jpg")
-    return frame_idx
-
-
-def extract_with_imageio(source_video: Path, output_dir: Path) -> int:
-    assert imageio is not None
-    temp_paths: list[Path] = []
-    frame_idx = 0
-    try:
-        for frame in imageio.get_reader(str(source_video)):
-            temp_path = output_dir / f"frame_{frame_idx:06d}.jpg"
-            imageio.imwrite(str(temp_path), frame)
-            temp_paths.append(temp_path)
-            frame_idx += 1
-    except Exception as exc:
-        if frame_idx == 0:
-            raise RuntimeError(f"imageio failed to decode {source_video}: {exc}") from exc
-        raise
-    for idx, temp_path in enumerate(temp_paths):
-        temp_path.rename(output_dir / f"{idx}-{frame_idx}.jpg")
-    return frame_idx
-
-
-def extract_with_av(source_video: Path, output_dir: Path) -> int:
-    assert av is not None
-    container = av.open(str(source_video))
-    temp_paths: list[Path] = []
-    frame_idx = 0
-    try:
-        for frame in container.decode(video=0):
-            temp_path = output_dir / f"frame_{frame_idx:06d}.jpg"
-            frame.to_image().save(temp_path, format="JPEG")
-            temp_paths.append(temp_path)
-            frame_idx += 1
-    finally:
-        container.close()
-
-    for idx, temp_path in enumerate(temp_paths):
-        temp_path.rename(output_dir / f"{idx}-{frame_idx}.jpg")
-    return frame_idx
-
-
-def extract_one_video(source_video: Path, output_dir: Path, overwrite_existing: bool) -> dict[str, Any]:
-    if not overwrite_existing and is_complete(output_dir, source_video):
-        manifest = json.loads(manifest_path_for(output_dir).read_text(encoding="utf-8"))
-        return {
-            "source_video": str(source_video),
-            "output_dir": str(output_dir),
-            "frame_count": int(manifest["frame_count"]),
-            "status": "skipped_existing",
-        }
-
-    output_dir.mkdir(parents=True, exist_ok=True)
-    clear_output_dir(output_dir)
-    if cv2 is not None:
-        frame_count = extract_with_cv2(source_video, output_dir)
-        if frame_count == 0 and av is not None:
-            clear_output_dir(output_dir)
-            frame_count = extract_with_av(source_video, output_dir)
-        if frame_count == 0 and imageio is not None:
-            clear_output_dir(output_dir)
-            frame_count = extract_with_imageio(source_video, output_dir)
-    elif av is not None:
-        frame_count = extract_with_av(source_video, output_dir)
-    elif imageio is not None:
-        frame_count = extract_with_imageio(source_video, output_dir)
-    else:
-        raise RuntimeError("No available decoder")
-    if frame_count <= 0:
-        raise RuntimeError(f"Decoder produced zero frames for {source_video}")
-    write_manifest(output_dir, source_video, frame_count)
-    return {
-        "source_video": str(source_video),
-        "output_dir": str(output_dir),
-        "frame_count": frame_count,
-        "status": "extracted",
-    }
-
-
-
-
-def main() -> None:
-    args = parse_args()
-    require_decoder()
-
-    release_root = bundled_release_root()
-    benchmark_root = (release_root / "benchmark_splits").resolve()
-    if not benchmark_root.exists():
-        raise SystemExit(f"Missing benchmark_splits under {release_root}")
-    data_root = resolve_data_root(args.data_root, release_root)
-    output_root = resolve_frames_root(args.frames_root, release_root)
-    ensure_generated_marker(output_root)
-    benchmark_paths = benchmark_files_from_root(benchmark_root)
-
-    specs, stats = collect_episode_specs(benchmark_paths)
-    jobs: list[tuple[Path, Path]] = []
-    missing_raw_episodes: list[dict[str, str]] = []
-    for spec in specs:
-        try:
-            view_videos = discover_view_videos(data_root, spec.main_path)
-        except FileNotFoundError as exc:
-            missing_raw_episodes.append(
-                {
-                    "main_path": str(spec.main_path),
-                    "error": str(exc),
-                }
-            )
-            continue
-        for video_path in view_videos:
-            jobs.append((video_path, output_dir_from_video(data_root, output_root, video_path)))
-
-    results: list[dict[str, Any]] = []
-    with ThreadPoolExecutor(max_workers=max(1, args.jobs)) as executor:
-        future_to_job = {
-            executor.submit(extract_one_video, video_path, output_dir, args.overwrite_existing): (video_path, output_dir)
-            for video_path, output_dir in jobs
-        }
-        for future in tqdm.tqdm(as_completed(future_to_job), total=len(future_to_job), desc="Extract release frames"):
-            video_path, output_dir = future_to_job[future]
-            try:
-                results.append(future.result())
-            except Exception as exc:
-                results.append(
-                    {
-                        "source_video": str(video_path),
-                        "output_dir": str(output_dir),
-                        "status": "error",
-                        "error": str(exc),
-                    }
-                )
-
-    summary = {
-        **stats,
-        "release_root": str(release_root),
-        "benchmark_root": str(benchmark_root),
-        "data_root": str(data_root),
-        "output_root": str(output_root),
-        "benchmark_files": [str(path) for path in benchmark_paths],
-        "jobs_total": len(jobs),
-        "jobs_extracted": sum(1 for row in results if row["status"] == "extracted"),
-        "jobs_skipped_existing": sum(1 for row in results if row["status"] == "skipped_existing"),
-        "jobs_failed": sum(1 for row in results if row["status"] == "error"),
-        "missing_raw_episodes": missing_raw_episodes,
-        "results": results,
-    }
-    summary_path = output_root / "frame_extraction_summary.json"
-    dump_json(summary_path, summary)
-    print(f"[frame-extraction] {summary_path}")
-
-
-if __name__ == "__main__":
-    main()

scripts/run_vlac_cut_batch.py

@@ -1,352 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import json
-import os
-from pathlib import Path
-from typing import Any
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Run VLAC-Cut batch inference from a public VPB evaluation manifest."
-    )
-    parser.add_argument(
-        "--model-path",
-        type=Path,
-        required=True,
-        help="Path to the released VLAC-Cut model directory.",
-    )
-    parser.add_argument(
-        "--manifest",
-        type=Path,
-        required=True,
-        help="JSONL file produced by build_vlac_cut_eval_manifest.py.",
-    )
-    parser.add_argument(
-        "--out",
-        type=Path,
-        required=True,
-        help="Output prediction JSONL path.",
-    )
-    parser.add_argument(
-        "--limit",
-        type=int,
-        default=None,
-        help="Optional maximum number of manifest rows to run.",
-    )
-    parser.add_argument(
-        "--resume",
-        action="store_true",
-        help="Append to --out and skip global_episode_id values already present in it.",
-    )
-    parser.add_argument(
-        "--max-new-tokens",
-        type=int,
-        default=1024,
-        help="Generation cap for each response.",
-    )
-    parser.add_argument(
-        "--device-map",
-        default="auto",
-        help="Device map passed to Transformers from_pretrained.",
-    )
-    parser.add_argument(
-        "--dtype",
-        default=None,
-        help="Torch dtype passed to Transformers. Defaults to auto.",
-    )
-    parser.add_argument(
-        "--attn-implementation",
-        default=None,
-        help="Optional attention implementation passed to Transformers, for example flash_attention_2 or sdpa.",
-    )
-    parser.add_argument(
-        "--check-files",
-        action="store_true",
-        help="Fail before inference if any manifest image path is missing.",
-    )
-    return parser.parse_args()
-
-
-def load_transformers_runtime():
-    os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
-    os.environ.setdefault("IMAGE_MAX_TOKEN_NUM", "256")
-    os.environ.setdefault("VIDEO_MAX_TOKEN_NUM", "256")
-    os.environ.setdefault("VIDEO_MIN_TOKEN_NUM", "4")
-    os.environ.setdefault("QWEN_VL_UTILS_MAX_FRAME_LIST", "0")
-
-    try:
-        import torch
-    except ImportError as exc:
-        raise SystemExit("Missing dependency: torch is required for VLAC-Cut inference.") from exc
-
-    try:
-        from transformers import AutoModelForImageTextToText, AutoProcessor
-    except ImportError as exc:
-        raise SystemExit("Missing dependency: transformers is required for VLAC-Cut inference.") from exc
-
-    return torch, AutoModelForImageTextToText, AutoProcessor
-
-
-def iter_jsonl(path: Path):
-    with path.open("r", encoding="utf-8") as f:
-        for line_no, line in enumerate(f, start=1):
-            raw = line.strip()
-            if not raw:
-                continue
-            item = json.loads(raw)
-            if not isinstance(item, dict):
-                raise ValueError(f"{path}:{line_no} is not a JSON object")
-            yield line_no, item
-
-
-def existing_global_episode_ids(path: Path) -> set[str]:
-    if not path.exists():
-        return set()
-    done: set[str] = set()
-    for _line_no, row in iter_jsonl(path):
-        gid = str(row.get("global_episode_id") or "").strip()
-        if gid:
-            done.add(gid)
-    return done
-
-
-def require_manifest_row(row: dict[str, Any], line_no: int, *, check_files: bool) -> tuple[str, list[int], list[str], str, float]:
-    gid = str(row.get("global_episode_id") or "").strip()
-    if not gid:
-        raise ValueError(f"manifest line {line_no}: missing global_episode_id")
-
-    frames_raw = row.get("frames")
-    if not isinstance(frames_raw, list) or not frames_raw:
-        raise ValueError(f"manifest line {line_no}: missing non-empty frames")
-    try:
-        frames = [int(frame) for frame in frames_raw]
-    except (TypeError, ValueError) as exc:
-        raise ValueError(f"manifest line {line_no}: frames must be integers") from exc
-
-    image_paths_raw = row.get("image_paths")
-    if not isinstance(image_paths_raw, list) or len(image_paths_raw) != len(frames):
-        raise ValueError(f"manifest line {line_no}: image_paths must align with frames")
-    image_paths = [str(path) for path in image_paths_raw]
-    if check_files:
-        missing = [path for path in image_paths if not Path(path).exists()]
-        if missing:
-            preview = ", ".join(missing[:3])
-            raise FileNotFoundError(f"manifest line {line_no}: missing image files: {preview}")
-
-    prompt = str(row.get("vlac_cut_prompt") or "").strip()
-    if not prompt:
-        raise ValueError(f"manifest line {line_no}: missing vlac_cut_prompt")
-
-    sample_hz_raw = row.get("input_sample_hz", row.get("sample_hz", 2.0))
-    try:
-        sample_hz = float(sample_hz_raw)
-    except (TypeError, ValueError) as exc:
-        raise ValueError(f"manifest line {line_no}: invalid input_sample_hz") from exc
-    if sample_hz <= 0:
-        raise ValueError(f"manifest line {line_no}: input_sample_hz must be positive")
-    return gid, frames, image_paths, prompt, sample_hz
-
-
-def load_model_and_processor(
-    *,
-    model_path: Path,
-    device_map: str,
-    dtype: str | None,
-    attn_implementation: str | None,
-):
-    _torch, AutoModelForImageTextToText, AutoProcessor = load_transformers_runtime()
-    processor = AutoProcessor.from_pretrained(str(model_path))
-
-    model_kwargs: dict[str, Any] = {
-        "device_map": device_map,
-        "dtype": dtype or "auto",
-    }
-    if attn_implementation:
-        model_kwargs["attn_implementation"] = attn_implementation
-
-    try:
-        model = AutoModelForImageTextToText.from_pretrained(str(model_path), **model_kwargs)
-    except TypeError as exc:
-        if "dtype" not in str(exc):
-            raise
-        model_kwargs["torch_dtype"] = model_kwargs.pop("dtype")
-        model = AutoModelForImageTextToText.from_pretrained(str(model_path), **model_kwargs)
-    if getattr(model, "generation_config", None) is not None:
-        for key in ("temperature", "top_p", "top_k"):
-            if hasattr(model.generation_config, key):
-                setattr(model.generation_config, key, None)
-    model.eval()
-    return model, processor
-
-
-def infer_one(
-    *,
-    model,
-    processor,
-    image_paths: list[str],
-    prompt: str,
-    sample_hz: float,
-    max_new_tokens: int,
-) -> str:
-    messages = [
-        {
-            "role": "user",
-            "content": [
-                {"type": "video", "video": image_paths},
-                {"type": "text", "text": prompt},
-            ],
-        }
-    ]
-    text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-    video_metadata = {
-        "total_num_frames": len(image_paths),
-        "fps": float(sample_hz),
-        "frames_indices": list(range(len(image_paths))),
-    }
-    inputs = processor(
-        text=[text],
-        videos=[[image_paths]],
-        padding=True,
-        return_tensors="pt",
-        return_metadata=True,
-        do_sample_frames=False,
-        video_metadata=video_metadata,
-    )
-    normalize_qwen3_video_grid(inputs)
-    inputs = inputs.to(model.device)
-    inputs.pop("video_metadata", None)
-
-    generated_ids = model.generate(
-        **inputs,
-        max_new_tokens=int(max_new_tokens),
-        do_sample=False,
-    )
-    generated_ids_trimmed = [
-        output_ids[len(input_ids) :] for input_ids, output_ids in zip(inputs.input_ids, generated_ids, strict=True)
-    ]
-    return str(
-        processor.batch_decode(
-            generated_ids_trimmed,
-            skip_special_tokens=True,
-            clean_up_tokenization_spaces=False,
-        )[0]
-    )
-
-
-def count_token_type_spans(token_type_ids, token_type: int) -> int:
-    values = token_type_ids.tolist()
-    count = 0
-    previous = None
-    for value in values:
-        if value == token_type and previous != token_type:
-            count += 1
-        previous = value
-    return count
-
-
-def normalize_qwen3_video_grid(inputs) -> None:
-    mm_token_type_ids = inputs.get("mm_token_type_ids")
-    video_grid_thw = inputs.get("video_grid_thw")
-    if mm_token_type_ids is None or video_grid_thw is None:
-        return
-    if len(mm_token_type_ids) != 1 or len(video_grid_thw) != 1:
-        return
-
-    video_span_count = count_token_type_spans(mm_token_type_ids[0], 2)
-    if video_span_count <= 1:
-        return
-
-    grid = video_grid_thw[0]
-    temporal = int(grid[0].item())
-    if temporal % video_span_count != 0:
-        return
-
-    split_temporal = temporal // video_span_count
-    expanded = grid.repeat(video_span_count, 1)
-    expanded[:, 0] = split_temporal
-    inputs["video_grid_thw"] = expanded
-
-
-def main() -> int:
-    args = parse_args()
-    model_path = args.model_path.resolve()
-    manifest_path = args.manifest.resolve()
-    out_path = args.out.resolve()
-
-    if not model_path.exists():
-        raise SystemExit(f"Missing model path: {model_path}")
-    if not manifest_path.exists():
-        raise SystemExit(f"Missing manifest: {manifest_path}")
-    if args.limit is not None and args.limit <= 0:
-        raise SystemExit("--limit must be positive when provided")
-
-    done = existing_global_episode_ids(out_path) if args.resume else set()
-    out_path.parent.mkdir(parents=True, exist_ok=True)
-    mode = "a" if args.resume else "w"
-
-    model, processor = load_model_and_processor(
-        model_path=model_path,
-        device_map=str(args.device_map),
-        dtype=args.dtype,
-        attn_implementation=args.attn_implementation,
-    )
-
-    processed = 0
-    skipped = 0
-    with out_path.open(mode, encoding="utf-8") as out_f:
-        for line_no, row in iter_jsonl(manifest_path):
-            gid, frames, image_paths, prompt, sample_hz = require_manifest_row(
-                row,
-                line_no,
-                check_files=bool(args.check_files),
-            )
-            if gid in done:
-                skipped += 1
-                continue
-            if args.limit is not None and processed >= args.limit:
-                break
-
-            response = infer_one(
-                model=model,
-                processor=processor,
-                image_paths=image_paths,
-                prompt=prompt,
-                sample_hz=sample_hz,
-                max_new_tokens=int(args.max_new_tokens),
-            )
-            out_f.write(
-                json.dumps(
-                    {
-                        "global_episode_id": gid,
-                        "frames": frames,
-                        "response": str(response or ""),
-                    },
-                    ensure_ascii=False,
-                )
-                + "\n"
-            )
-            out_f.flush()
-            processed += 1
-            print(f"processed={processed} global_episode_id={gid}", flush=True)
-
-    print(
-        json.dumps(
-            {
-                "manifest": str(manifest_path),
-                "out": str(out_path),
-                "backend": "transformers",
-                "processed": processed,
-                "skipped_existing": skipped,
-            },
-            ensure_ascii=False,
-            indent=2,
-        )
-    )
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

scripts/unpack_data.sh

@@ -1,52 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-ARCHIVE_DIR="${ROOT_DIR}/data"
-DATA_ROOT="${1:-${ROOT_DIR}/data}"
-EXPECTED_BASES=(
-  "test_videos"
-  "train_videos"
-)
-
-mkdir -p "${DATA_ROOT}"
-
-archives=()
-for base in "${EXPECTED_BASES[@]}"; do
-  matches=()
-  for suffix in ".tar" ".tar.zst"; do
-    candidate="${ARCHIVE_DIR}/${base}${suffix}"
-    if [[ -f "${candidate}" ]]; then
-      matches+=("${candidate}")
-    fi
-  done
-
-  if [[ "${#matches[@]}" -eq 0 ]]; then
-    echo "missing expected archive under ${ARCHIVE_DIR}: ${base}.tar or ${base}.tar.zst" >&2
-    exit 1
-  fi
-  if [[ "${#matches[@]}" -gt 1 ]]; then
-    echo "found multiple archive variants for ${base} under ${ARCHIVE_DIR}; keep only one of .tar or .tar.zst" >&2
-    exit 1
-  fi
-
-  archives+=("${matches[0]}")
-done
-
-for archive in "${archives[@]}"; do
-  echo "extracting ${archive}"
-  case "${archive}" in
-    *.tar.zst)
-      tar --zstd -xf "${archive}" -C "${DATA_ROOT}"
-      ;;
-    *.tar)
-      tar -xf "${archive}" -C "${DATA_ROOT}"
-      ;;
-    *)
-      echo "unsupported archive format: ${archive}" >&2
-      exit 1
-      ;;
-  esac
-done
-
-echo "raw data extracted into ${DATA_ROOT}"

scripts/vlac2_release_common.py

@@ -1,261 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any, Callable
-
-
-KNOWN_DATASET_NAMES = (
-    "ARX-data",
-    "dex_fold_v2_mix",
-    "droid_lerobot",
-    "libero",
-    "libero_zty50",
-    "VLABench_5",
-)
-KNOWN_VIDEO_SUFFIXES = {".mp4", ".avi", ".mov", ".mkv", ".webm"}
-PORTABLE_IMAGE_ROOT = Path("_extracted_frames")
-LEGACY_PORTABLE_IMAGE_ROOTS = (
-    Path("extracted_frames"),
-    Path("progress_data") / "VLAC_preprocessed_data" / "data",
-)
-GENERATED_MARKER_FILENAME = "_GENERATED"
-PUBLIC_BENCHMARK_JSON_NAME = "video_progress_benchmark_file.json"
-PUBLIC_RELEASE_ROOT_PLACEHOLDER = "__VLAC2_RELEASE_ROOT__"
-PUBLIC_FRAMES_ROOT_PLACEHOLDER = "__VLAC2_FRAMES_ROOT__"
-PUBLIC_BENCHMARK_DIRNAME = "benchmark_splits"
-LEGACY_BENCHMARK_DIRNAME = "benchmark_json"
-
-
-def portable_image_roots() -> tuple[Path, ...]:
-    roots = [PORTABLE_IMAGE_ROOT, *LEGACY_PORTABLE_IMAGE_ROOTS]
-    deduped: list[Path] = []
-    seen: set[tuple[str, ...]] = set()
-    for root in roots:
-        key = root.parts
-        if key in seen:
-            continue
-        seen.add(key)
-        deduped.append(root)
-    return tuple(deduped)
-
-
-def load_json(path: Path) -> Any:
-    return json.loads(path.read_text(encoding="utf-8"))
-
-
-def dump_json(path: Path, payload: Any) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-
-
-def ensure_generated_marker(output_root: Path) -> Path:
-    output_root.mkdir(parents=True, exist_ok=True)
-    marker_path = output_root / GENERATED_MARKER_FILENAME
-    marker_path.write_text(
-        "This directory is generated by the VLAC2 public frame-extraction workflow.\n",
-        encoding="utf-8",
-    )
-    return marker_path
-
-
-def ensure_release_tree(release_root: Path) -> dict[str, Path]:
-    release_root = release_root.resolve()
-    paths = {
-        "release_root": release_root,
-        "raw_root": release_root / "data",
-        "benchmark_root": release_root / PUBLIC_BENCHMARK_DIRNAME,
-        "portable_image_root": release_root / PORTABLE_IMAGE_ROOT,
-        "scripts_root": release_root / "scripts",
-    }
-    for key in ("release_root", "raw_root", "benchmark_root", "scripts_root"):
-        paths[key].mkdir(parents=True, exist_ok=True)
-    return paths
-
-
-def _normalized_parts(raw_path: str | Path) -> list[str]:
-    raw = str(raw_path or "").strip().replace("\\", "/")
-    if not raw:
-        raise ValueError("empty path")
-    return [part for part in Path(raw).parts if part not in ("", ".", "/")]
-
-
-def dataset_relative_path(raw_path: str | Path) -> Path:
-    parts = _normalized_parts(raw_path)
-
-    for idx, part in enumerate(parts):
-        if part in KNOWN_DATASET_NAMES:
-            return Path(*parts[idx:])
-
-    for portable_root in portable_image_roots():
-        marker_parts = list(portable_root.parts)
-        marker_len = len(marker_parts)
-        for idx in range(max(0, len(parts) - marker_len + 1)):
-            if parts[idx : idx + marker_len] == marker_parts:
-                tail = parts[idx + marker_len :]
-                if not tail:
-                    break
-                for tail_idx, part in enumerate(tail):
-                    if part in KNOWN_DATASET_NAMES:
-                        return Path(*tail[tail_idx:])
-                return Path(*tail)
-
-    return Path(*parts)
-
-
-def normalize_main_path(raw_main_path: str | Path) -> Path:
-    rel = dataset_relative_path(raw_main_path)
-    if rel.suffix.lower() in KNOWN_VIDEO_SUFFIXES:
-        return rel.with_suffix("")
-    return rel
-
-
-def main_path_from_frame_path(raw_frame_path: str | Path) -> Path:
-    rel = dataset_relative_path(raw_frame_path)
-    if rel.suffix:
-        return rel.parent
-    return rel
-
-
-def portable_frame_path_from_any(raw_frame_path: str | Path) -> Path:
-    return PORTABLE_IMAGE_ROOT / dataset_relative_path(raw_frame_path)
-
-
-def placeholder_frame_path_from_any(raw_frame_path: str | Path) -> str:
-    return f"{PUBLIC_FRAMES_ROOT_PLACEHOLDER}/{dataset_relative_path(raw_frame_path).as_posix()}"
-
-
-def absolute_frame_path_from_any(raw_frame_path: str | Path, frames_root: Path) -> Path:
-    raw = str(raw_frame_path or "").strip()
-    if not raw:
-        raise ValueError("empty frame path")
-    path = Path(raw)
-    if path.is_absolute():
-        return path
-
-    parts = _normalized_parts(raw)
-    if parts and parts[0] in (PUBLIC_FRAMES_ROOT_PLACEHOLDER, PUBLIC_RELEASE_ROOT_PLACEHOLDER):
-        parts = parts[1:]
-
-    for portable_root in portable_image_roots():
-        marker_parts = list(portable_root.parts)
-        if parts[: len(marker_parts)] == marker_parts:
-            return frames_root.resolve() / Path(*parts[len(marker_parts) :])
-    if parts and parts[0] in KNOWN_DATASET_NAMES:
-        return frames_root.resolve() / Path(*parts)
-    return frames_root.resolve() / Path(*parts)
-
-
-def rewrite_benchmark_image_paths(
-    rows: list[dict[str, Any]],
-    path_rewriter: Callable[[str], str],
-) -> list[dict[str, Any]]:
-    rewritten_rows: list[dict[str, Any]] = []
-    for row in rows:
-        rewritten = dict(row)
-
-        frame_index = dict(row.get("frame_index") or {})
-        if frame_index:
-            rewritten_frame_index: dict[str, dict[str, str]] = {}
-            for frame_idx, images in frame_index.items():
-                image_map = dict(images or {})
-                rewritten_frame_index[str(frame_idx)] = {
-                    str(view): path_rewriter(str(image_path))
-                    for view, image_path in image_map.items()
-                    if str(image_path or "").strip()
-                }
-            rewritten["frame_index"] = rewritten_frame_index
-
-        reference_context = row.get("reference_context")
-        if isinstance(reference_context, dict):
-            rewritten_ref = dict(reference_context)
-            anchors = list(reference_context.get("reference_anchors") or [])
-            rewritten_anchors: list[dict[str, Any]] = []
-            for anchor in anchors:
-                rewritten_anchor = dict(anchor)
-                images = dict(anchor.get("images") or {})
-                if images:
-                    rewritten_anchor["images"] = {
-                        str(view): path_rewriter(str(image_path))
-                        for view, image_path in images.items()
-                        if str(image_path or "").strip()
-                    }
-                rewritten_anchors.append(rewritten_anchor)
-            rewritten_ref["reference_anchors"] = rewritten_anchors
-            rewritten["reference_context"] = rewritten_ref
-
-        videos = row.get("videos")
-        if isinstance(videos, list):
-            rewritten_videos: list[Any] = []
-            for item in videos:
-                if isinstance(item, list):
-                    rewritten_videos.append(
-                        [path_rewriter(str(path)) for path in item if str(path or "").strip()]
-                    )
-                elif isinstance(item, str) and item.strip():
-                    rewritten_videos.append(path_rewriter(item))
-            rewritten["videos"] = rewritten_videos
-
-        images = row.get("images")
-        if isinstance(images, list):
-            rewritten["images"] = [
-                path_rewriter(str(path))
-                for path in images
-                if str(path or "").strip()
-            ]
-
-        rewritten_rows.append(rewritten)
-    return rewritten_rows
-
-
-def infer_main_path_from_row(row: dict[str, Any]) -> Path | None:
-    for meta_key in ("metadata", "_meta", "meta"):
-        meta = row.get(meta_key)
-        if isinstance(meta, dict):
-            raw_main_path = str(meta.get("main_path") or "").strip()
-            if raw_main_path:
-                return normalize_main_path(raw_main_path)
-
-    frame_index = row.get("frame_index")
-    if isinstance(frame_index, dict):
-        for images in frame_index.values():
-            if not isinstance(images, dict):
-                continue
-            for image_path in images.values():
-                if str(image_path or "").strip():
-                    return main_path_from_frame_path(str(image_path))
-
-    videos = row.get("videos")
-    if isinstance(videos, list) and videos:
-        first = videos[0]
-        if isinstance(first, list) and first:
-            return main_path_from_frame_path(str(first[0]))
-        if isinstance(first, str) and first.strip():
-            return main_path_from_frame_path(first)
-
-    return None
-
-
-def discover_benchmark_jsons(benchmark_root: Path) -> list[Path]:
-    benchmark_root = benchmark_root.resolve()
-    candidates: list[Path] = []
-    seen: set[Path] = set()
-    for path in sorted(benchmark_root.glob(f"**/{PUBLIC_BENCHMARK_JSON_NAME}")):
-        resolved = path.resolve()
-        if resolved in seen:
-            continue
-        seen.add(resolved)
-        candidates.append(resolved)
-    return candidates
-
-
-def resolve_benchmark_root(release_root: Path) -> Path:
-    release_root = release_root.resolve()
-    preferred = release_root / PUBLIC_BENCHMARK_DIRNAME
-    legacy = release_root / LEGACY_BENCHMARK_DIRNAME
-    if preferred.exists():
-        return preferred
-    if legacy.exists():
-        return legacy
-    return preferred

scripts/vpb_public_eval_utils.py

@@ -1,366 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import json
-import math
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Iterable
-
-
-TEST_BUCKETS = (
-    "test_expert_seen",
-    "test_expert_unseen",
-    "test_nonexpert_seen",
-    "test_nonexpert_unseen",
-)
-EXPERT_BUCKETS = {"test_expert_seen", "test_expert_unseen"}
-BENCHMARK_JSON_NAME = "video_progress_benchmark_file.json"
-
-
-@dataclass(frozen=True)
-class SelectedFrames:
-    frames: list[int]
-    timestamps_sec: list[float | None]
-    mode: str
-    sample_hz: float | None
-
-
-@dataclass(frozen=True)
-class Trajectory:
-    bucket: str
-    global_episode_id: str
-    frames: list[int]
-    gt_progress: list[float]
-    timestamps_sec: list[float | None]
-    task_instruction: str
-    task_description: str
-    main_view: str | None
-    fps: float | None
-    start_idx: int
-    semantic_anchor_frames: list[int]
-    semantic_anchor_progress: list[float]
-
-
-def load_json(path: Path) -> Any:
-    return json.loads(path.read_text(encoding="utf-8"))
-
-
-def dump_json(path: Path, payload: Any) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-
-
-def iter_benchmark_rows(
-    benchmark_root: Path,
-    buckets: Iterable[str] = TEST_BUCKETS,
-) -> Iterable[tuple[str, int, dict[str, Any]]]:
-    for bucket in buckets:
-        path = benchmark_root / bucket / BENCHMARK_JSON_NAME
-        if not path.exists():
-            raise FileNotFoundError(f"Missing benchmark split: {path}")
-        rows = load_json(path)
-        if not isinstance(rows, list):
-            raise ValueError(f"Expected list in benchmark split: {path}")
-        for idx, row in enumerate(rows):
-            if not isinstance(row, dict):
-                raise ValueError(f"Expected object row in {path} at index {idx}")
-            yield bucket, idx, row
-
-
-def finite_float(value: Any) -> float | None:
-    try:
-        number = float(value)
-    except (TypeError, ValueError):
-        return None
-    return number if math.isfinite(number) else None
-
-
-def mean_or_none(values: Iterable[float | None]) -> float | None:
-    clean = [float(v) for v in values if v is not None and math.isfinite(float(v))]
-    if not clean:
-        return None
-    return float(sum(clean) / len(clean))
-
-
-def pearson_corr(xs: list[float], ys: list[float]) -> float | None:
-    if len(xs) != len(ys) or len(xs) < 2:
-        return None
-    mean_x = sum(xs) / len(xs)
-    mean_y = sum(ys) / len(ys)
-    num = sum((x - mean_x) * (y - mean_y) for x, y in zip(xs, ys))
-    den_x = sum((x - mean_x) ** 2 for x in xs)
-    den_y = sum((y - mean_y) ** 2 for y in ys)
-    if math.isclose(den_x, 0.0, rel_tol=0.0, abs_tol=1e-12):
-        return None
-    if math.isclose(den_y, 0.0, rel_tol=0.0, abs_tol=1e-12):
-        return None
-    value = num / math.sqrt(den_x * den_y)
-    return value if math.isfinite(value) else None
-
-
-def average_ranks(values: list[float]) -> list[float]:
-    order = sorted(range(len(values)), key=lambda idx: values[idx])
-    ranks = [0.0] * len(values)
-    i = 0
-    while i < len(order):
-        j = i + 1
-        while (
-            j < len(order)
-            and math.isclose(values[order[j]], values[order[i]], rel_tol=0.0, abs_tol=1e-9)
-        ):
-            j += 1
-        rank = (i + j - 1) / 2.0 + 1.0
-        for pos in order[i:j]:
-            ranks[pos] = rank
-        i = j
-    return ranks
-
-
-def spearman_corr(xs: list[float], ys: list[float]) -> float | None:
-    return pearson_corr(average_ranks(xs), average_ranks(ys))
-
-
-def extract_view_from_main_path(main_path: str | None) -> str | None:
-    raw = str(main_path or "").strip()
-    if not raw:
-        return None
-    for part in Path(raw).parts:
-        if part.startswith("observation.images."):
-            view = part.split("observation.images.", 1)[1].strip()
-            return view or None
-    return None
-
-
-def main_view_for_row(row: dict[str, Any]) -> str | None:
-    meta = dict(row.get("metadata") or {})
-    target_view = extract_view_from_main_path(meta.get("main_path"))
-    available = [str(v) for v in meta.get("available_views", []) if str(v).strip()]
-    if target_view:
-        return target_view
-    if available:
-        return available[0]
-    frame_index = row.get("frame_index")
-    if isinstance(frame_index, dict):
-        for image_map in frame_index.values():
-            if isinstance(image_map, dict) and image_map:
-                return sorted(str(k) for k in image_map.keys())[0]
-    return None
-
-
-def _nearest_frame(eligible: list[int], target_frame: float) -> int:
-    best_idx = eligible[0]
-    best_distance = abs(float(best_idx) - target_frame)
-    for idx in eligible[1:]:
-        distance = abs(float(idx) - target_frame)
-        if distance < best_distance:
-            best_idx = idx
-            best_distance = distance
-    return int(best_idx)
-
-
-def sample_frame_indices_by_hz(
-    frame_ids: list[int],
-    *,
-    start_idx: int,
-    fps: float,
-    sample_hz: float,
-) -> tuple[list[int], list[float]]:
-    if not frame_ids or fps <= 0 or sample_hz <= 0:
-        return [], []
-    eligible = [idx for idx in frame_ids if idx >= start_idx]
-    if not eligible:
-        eligible = list(frame_ids)
-    if not eligible:
-        return [], []
-
-    start_frame = eligible[0]
-    end_frame = eligible[-1]
-    duration_sec = max(0.0, (end_frame - start_frame) / fps)
-    step_sec = 1.0 / sample_hz
-
-    target_times: list[float] = []
-    current = 0.0
-    eps = 1e-9
-    while current <= duration_sec + eps:
-        target_times.append(round(current, 6))
-        current += step_sec
-    if not target_times:
-        target_times = [0.0]
-
-    selected_indices: list[int] = []
-    selected_times: list[float] = []
-    seen: set[int] = set()
-    for target_time in target_times:
-        target_frame = start_frame + target_time * fps
-        idx = _nearest_frame(eligible, target_frame)
-        if idx in seen:
-            continue
-        seen.add(idx)
-        selected_indices.append(idx)
-        selected_times.append(round((idx - start_frame) / fps, 6))
-
-    if not selected_indices:
-        selected_indices = [start_frame]
-        selected_times = [0.0]
-    return selected_indices, selected_times
-
-
-def selected_frames_for_row(
-    row: dict[str, Any],
-    *,
-    eval_points: str,
-    sample_hz: float,
-) -> SelectedFrames:
-    frame_index = dict(row.get("frame_index") or {})
-    dense_progress = dict(row.get("dense_kinematic_progress") or {})
-    frame_ids = sorted(
-        int(k)
-        for k in frame_index.keys()
-        if str(k) in dense_progress and finite_float(dense_progress.get(str(k))) is not None
-    )
-    if not frame_ids:
-        return SelectedFrames([], [], eval_points, sample_hz if eval_points == "time_hz" else None)
-
-    if eval_points == "dense":
-        return SelectedFrames(frame_ids, [None] * len(frame_ids), "dense", None)
-
-    if eval_points == "semantic_anchors":
-        anchor_frames: list[int] = []
-        seen: set[int] = set()
-        for anchor in row.get("semantic_anchors") or []:
-            if not isinstance(anchor, dict):
-                continue
-            frame = finite_float(anchor.get("frame"))
-            if frame is None:
-                continue
-            idx = int(frame)
-            if idx in seen or idx not in frame_ids:
-                continue
-            seen.add(idx)
-            anchor_frames.append(idx)
-        anchor_frames.sort()
-        return SelectedFrames(anchor_frames, [None] * len(anchor_frames), "semantic_anchors", None)
-
-    if eval_points != "time_hz":
-        raise ValueError(f"Unsupported eval_points: {eval_points}")
-
-    meta = dict(row.get("metadata") or {})
-    fps = finite_float(meta.get("fps")) or 0.0
-    start_idx = int(finite_float(meta.get("start_idx")) or frame_ids[0])
-    frames, timestamps = sample_frame_indices_by_hz(
-        frame_ids,
-        start_idx=start_idx,
-        fps=fps,
-        sample_hz=sample_hz,
-    )
-    valid = [
-        (frame, ts)
-        for frame, ts in zip(frames, timestamps)
-        if str(frame) in dense_progress and finite_float(dense_progress.get(str(frame))) is not None
-    ]
-    return SelectedFrames(
-        [frame for frame, _ in valid],
-        [ts for _, ts in valid],
-        "time_hz",
-        float(sample_hz),
-    )
-
-
-def semantic_anchor_points_for_row(row: dict[str, Any]) -> tuple[list[int], list[float]]:
-    points_by_frame: dict[int, float] = {}
-    for anchor in row.get("semantic_anchors") or []:
-        if not isinstance(anchor, dict):
-            continue
-        frame = finite_float(anchor.get("frame"))
-        progress = finite_float(anchor.get("human_annotated_progress"))
-        if frame is None or progress is None:
-            continue
-        points_by_frame[int(frame)] = float(progress)
-    frames = sorted(points_by_frame)
-    return frames, [points_by_frame[frame] for frame in frames]
-
-
-def build_trajectories(
-    benchmark_root: Path,
-    *,
-    buckets: Iterable[str] = TEST_BUCKETS,
-    eval_points: str = "time_hz",
-    sample_hz: float = 1.0,
-) -> list[Trajectory]:
-    trajectories: list[Trajectory] = []
-    seen_gids: set[str] = set()
-    for bucket, row_idx, row in iter_benchmark_rows(benchmark_root, buckets):
-        global_episode_id = str(row.get("global_episode_id") or "").strip()
-        if not global_episode_id:
-            raise ValueError(f"Missing global_episode_id in {bucket} row {row_idx}")
-        if global_episode_id in seen_gids:
-            raise ValueError(f"Duplicate global_episode_id across benchmark splits: {global_episode_id}")
-        seen_gids.add(global_episode_id)
-
-        selected = selected_frames_for_row(row, eval_points=eval_points, sample_hz=sample_hz)
-        dense_progress = dict(row.get("dense_kinematic_progress") or {})
-        gt_progress: list[float] = []
-        frames: list[int] = []
-        timestamps: list[float | None] = []
-        for frame, timestamp in zip(selected.frames, selected.timestamps_sec):
-            value = finite_float(dense_progress.get(str(frame)))
-            if value is None:
-                continue
-            frames.append(int(frame))
-            timestamps.append(timestamp)
-            gt_progress.append(float(value))
-        if not frames:
-            continue
-
-        meta = dict(row.get("metadata") or {})
-        anchor_frames, anchor_progress = semantic_anchor_points_for_row(row)
-        trajectories.append(
-            Trajectory(
-                bucket=bucket,
-                global_episode_id=global_episode_id,
-                frames=frames,
-                gt_progress=gt_progress,
-                timestamps_sec=timestamps,
-                task_instruction=str(meta.get("task_instruction") or ""),
-                task_description=str(meta.get("task_description") or ""),
-                main_view=main_view_for_row(row),
-                fps=finite_float(meta.get("fps")),
-                start_idx=int(finite_float(meta.get("start_idx")) or frames[0]),
-                semantic_anchor_frames=anchor_frames,
-                semantic_anchor_progress=anchor_progress,
-            )
-        )
-    return trajectories
-
-
-def format_metric(value: Any, digits: int = 4) -> str:
-    if value is None:
-        return "n/a"
-    if isinstance(value, float):
-        if not math.isfinite(value):
-            return "n/a"
-        return f"{value:.{digits}f}"
-    return str(value)
-
-
-def format_percent(value: Any, digits: int = 2) -> str:
-    if value is None:
-        return "n/a"
-    try:
-        number = float(value)
-    except (TypeError, ValueError):
-        return "n/a"
-    if not math.isfinite(number):
-        return "n/a"
-    return f"{number * 100.0:.{digits}f}%"
-
-
-def markdown_table(headers: list[str], rows: list[list[Any]]) -> str:
-    lines = [
-        "| " + " | ".join(headers) + " |",
-        "| " + " | ".join(["---"] * len(headers)) + " |",
-    ]
-    for row in rows:
-        lines.append("| " + " | ".join(str(cell) for cell in row) + " |")
-    return "\n".join(lines)