Update public VPB evaluator and VLAC-Cut evaluation docs

README.md

@@ -25,6 +25,14 @@ benchmark_splits/
 scripts/
   unpack_data.sh
   extract_vlac2_release_frames.py
+  build_vpb_inference_manifest.py
+  evaluate_vpb_predictions.py
+  vlac2_release_common.py
+  vpb_public_eval_utils.py
+  upload_vlac2_release_archives_to_hf.sbatch
+
+docs/
+  vpb_public_evaluation.md
 
 data/
   train_videos.tar
@@ -69,6 +77,39 @@ __VLAC2_FRAMES_ROOT__/
 
 Replace `__VLAC2_FRAMES_ROOT__` with the absolute path to the extracted-frame directory. For example, `__VLAC2_FRAMES_ROOT__/...` should be resolved as `/path/to/data_extracted_frames/...`.
 
+### 4. Build an inference manifest
+
+```bash
+python scripts/build_vpb_inference_manifest.py \
+  --benchmark-root benchmark_splits \
+  --frames-root /path/to/data_extracted_frames \
+  --out manifests/vpb_test_1hz.jsonl
+```
+
+The default manifest uses 2Hz video input frames and also records the public 1Hz evaluation frames from the main view of each trajectory. This keeps model inference aligned with the VLAC-Cut input protocol while keeping evaluation aligned with the formal 1Hz benchmark protocol.
+
+For trajectory-level VLAC-Cut predictions, keep the manifest's 2Hz `frames` list in each prediction row. The evaluator maps predictions by original frame id and scores only the public 1Hz `eval_frames` for global progress and terminal metrics.
+
+By default, each manifest row is one trajectory with a list of sampled frame paths for video-model inference. For frame-level models, add `--record-format point`.
+
+### 5. Evaluate predictions
+
+```bash
+python scripts/evaluate_vpb_predictions.py \
+  --benchmark-root benchmark_splits \
+  --predictions predictions.jsonl \
+  --out-json reports/vpb_eval.json \
+  --out-md reports/vpb_eval.md
+```
+
+The evaluator reports global progress metrics, terminal success metrics, local direction AP on adjacent semantic anchors, and local keypoint progress metrics. Global and local-keypoint progress are shown for the 4-bucket overall split and each bucket; terminal metrics are shown for 4-bucket overall, seen merged, and unseen merged. See `docs/vpb_public_evaluation.md` for the accepted prediction schema and metric definitions.
+
+### 6. Evaluate VLAC-Cut
+
+VLAC-Cut is released separately at <https://huggingface.co/InternRobotics/VLAC-Cut>. This benchmark release does not vendor model weights or a VLAC-Cut batch inference runner; it only defines the benchmark frames, prediction schema, and evaluator.
+
+For strict VLAC-Cut evaluation, run the model on the 2Hz `image_paths` from the trajectory manifest instead of re-sampling the full raw video. Write one prediction row per trajectory with `global_episode_id`, `frames`, and either the raw VLAC-Cut `response` or an aligned `pred_progress_sequence`, then run `evaluate_vpb_predictions.py` as above. The evaluator parses VLAC-style keypoint responses, reconstructs the prediction curve, and reports the same public benchmark sections: global progress, terminal success, local direction AP, and local keypoint progress. The exact adapter contract is documented in `docs/vpb_public_evaluation.md`.
+
 ## Notes
 
 * This repository contains only the raw videos required by the released benchmark splits.

docs/vpb_public_evaluation.md

@@ -0,0 +1,268 @@
+# Public Video-Progress Benchmark Evaluation
+
+This release evaluates model progress predictions from the public benchmark files only.
+It does not require any private workspace paths or private metric code.
+
+## Protocol
+
+The default public protocol uses 2Hz video input for model inference, then
+evaluates predictions on the 1Hz formal evaluation points reconstructed from
+each released 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
+- video input points: `--input-sample-hz 2.0`
+- 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`
+- local keypoint progress metrics: `MAE`, `PRC`, and `VOC` for expert bucket rows on `semantic_anchors`
+
+The released JSON files also contain dense frame-level progress. Use
+`--eval-points dense` only for diagnostics; it is not the paper-comparable default.
+
+## End-to-End Workflow
+
+Unpack videos:
+
+```bash
+bash scripts/unpack_data.sh /path/to/data
+```
+
+Extract frames:
+
+```bash
+python scripts/extract_vlac2_release_frames.py \
+  --data-root /path/to/data \
+  --frames-root /path/to/frames
+```
+
+Build a 2Hz-input / 1Hz-evaluation inference manifest:
+
+```bash
+python scripts/build_vpb_inference_manifest.py \
+  --benchmark-root benchmark_splits \
+  --frames-root /path/to/frames \
+  --out manifests/vpb_test_1hz.jsonl
+```
+
+By default, the manifest is trajectory-level: each row contains `frames`,
+`timestamps_sec`, and `image_paths` lists for one 2Hz video trajectory. The row
+also contains `eval_frames` and `eval_timestamps_sec`, which define the 1Hz
+frames used by the evaluator. For frame-level models, add `--record-format point`
+to emit one row per 1Hz evaluation frame.
+
+### 2Hz input and 1Hz evaluation mapping
+
+The public benchmark GT is evaluated at 1Hz, but VLAC-Cut is run with 2Hz video
+input. The release keeps these two frame sets explicit:
+
+- `frames` / `input_frames`: the 2Hz frames passed to the video model.
+- `image_paths` / `input_image_paths`: the frame images corresponding to those
+  2Hz frames.
+- `eval_frames`: the 1Hz frames used for global progress and terminal metrics.
+
+For the default protocol, `eval_frames` are a subset of `input_frames`. A
+VLAC-Cut prediction row should therefore write the same 2Hz `frames` list used
+for inference, together with either the raw `response` or a
+`pred_progress_sequence` aligned to that list. The evaluator stores predictions
+by original frame id. When computing the 1Hz metrics, it compares only the
+predictions at the 1Hz `eval_frames` against the released
+`dense_kinematic_progress` GT.
+
+Run your model on the manifest and write predictions as JSONL. The canonical
+episode-level format is:
+
+```json
+{
+  "global_episode_id": "ARX-data/.../episode_000000",
+  "pred_progress_by_frame": {
+    "0": 0.0,
+    "30": 12.5,
+    "60": 28.0
+  }
+}
+```
+
+The point-level format is also accepted:
+
+```json
+{
+  "global_episode_id": "ARX-data/.../episode_000000",
+  "frame": 30,
+  "pred_progress": 12.5
+}
+```
+
+If your inference output is a sequence aligned with the trajectory manifest,
+include the frame list so the evaluator can map 2Hz predictions back to frame ids:
+
+```json
+{
+  "global_episode_id": "ARX-data/.../episode_000000",
+  "frames": [0, 15, 30, 45, 60],
+  "pred_progress_sequence": [0.0, 5.0, 12.5, 20.0, 28.0]
+}
+```
+
+For VLAC-style keypoint responses, the evaluator also accepts the raw response
+or parsed keypoints and applies the same index-normalized curve alignment as the
+formal VLAC evaluation code:
+
+```json
+{
+  "global_episode_id": "ARX-data/.../episode_000000",
+  "frames": [0, 15, 30, 45, 60],
+  "response": "时间: 0.5s, 进度: 0%\n时间: 2.0s, 进度: 30%"
+}
+```
+
+In the released benchmark, the default 1Hz evaluation frames are a subset of the
+default 2Hz input frames, so the evaluator can take the 1Hz subset directly from
+2Hz frame-level predictions. Use `--interpolate-missing` only for sparse outputs
+that do not contain the 1Hz frame ids.
+
+Evaluate:
+
+```bash
+python scripts/evaluate_vpb_predictions.py \
+  --benchmark-root benchmark_splits \
+  --predictions predictions.jsonl \
+  --out-json reports/vpb_eval.json \
+  --out-md reports/vpb_eval.md
+```
+
+## Evaluating VLAC-Cut
+
+The VLAC-Cut model release is hosted separately at
+<https://huggingface.co/InternRobotics/VLAC-Cut>. The benchmark release does
+not vendor model weights or a separate VLAC-Cut batch inference runner. Use the
+model release to produce a prediction JSONL in the evaluator schema above.
+
+For the strict benchmark setting, do not run the model quick-start directly on
+the full raw video and let it re-sample from frame `0`. Instead, read the
+trajectory manifest produced by `build_vpb_inference_manifest.py` and feed the
+listed 2Hz `image_paths` to VLAC-Cut as the video frames. This preserves the
+benchmark `start_idx`, main-view selection, and 2Hz input protocol.
+
+A minimal VLAC-Cut adapter should do only this:
+
+1. Read each trajectory row from `manifests/vpb_test_1hz.jsonl`.
+2. Build the same `chunk_all` prompt from `task_instruction` and
+   `task_description`.
+3. Run VLAC-Cut on `image_paths` with the frame list order unchanged.
+4. Write one prediction row per trajectory with the raw response:
+
+```json
+{
+  "global_episode_id": "ARX-data/.../episode_000000",
+  "frames": [0, 15, 30, 45, 60],
+  "response": "时间: 0.5s, 进度: 0%\n时间: 2.0s, 进度: 30%"
+}
+```
+
+The evaluator parses the keypoints, aligns them to the 2Hz frame list using the
+formal VLAC index-normalized alignment rule, and then takes the 1Hz subset from
+the aligned 2Hz predictions:
+
+```bash
+python scripts/evaluate_vpb_predictions.py \
+  --benchmark-root benchmark_splits \
+  --predictions vlac_cut_predictions.jsonl \
+  --out-json reports/vlac_cut_vpb_eval.json \
+  --out-md reports/vlac_cut_vpb_eval.md
+```
+
+This keeps the pipeline simple: the benchmark release defines the frames,
+prediction schema, evaluator, and metrics; the VLAC-Cut model release is
+responsible only for inference. The resulting benchmark report includes global
+progress, terminal success, local direction AP, local keypoint progress, and
+prediction diagnostics.
+
+## 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.
+- `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 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 formal 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.
+
+### Local Keypoint Progress
+
+Local keypoint progress evaluates predictions at all released
+`semantic_anchors`. Prediction values at anchor frames are obtained by linear
+interpolation over the model's valid predicted curve.
+
+- `MAE`: trajectory-equal mean absolute error over semantic-anchor keypoints.
+- `PRC`: trajectory-equal Spearman correlation between anchor GT progress and predicted anchor progress.
+- `VOC`: trajectory-equal Spearman correlation between predicted anchor progress and chronological anchor order for expert bucket rows.
+
+The report shows 4-bucket overall and four per-bucket rows. VOC is omitted for
+the 4-bucket overall and non-expert bucket rows.
+
+Missing predictions are not silently filled in strict mode. The report includes
+coverage, missing final counts, duplicate prediction counts, unknown episode ids,
+and counts for predictions outside the nominal `[0, 100]` range. Those nominal
+range counts are diagnostics only; predictions are not clipped unless
+`--clip-pred` is set.
+
+Use `--interpolate-missing` only when evaluating sparse model outputs that do
+not include the 1Hz evaluation frame ids. Reports generated with interpolation
+are not strict paper-comparable outputs.
+
+## 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_vpb_inference_manifest.py \
+  --benchmark-root benchmark_splits \
+  --frames-root /path/to/frames \
+  --out /tmp/vpb_manifest_smoke.jsonl \
+  --limit-trajectories 2
+```

scripts/build_vpb_inference_manifest.py

@@ -0,0 +1,303 @@
+#!/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,
+)
+
+
+def parse_args() -> argparse.Namespace:
+    release_root = SCRIPT_DIR.parent
+    parser = argparse.ArgumentParser(
+        description="Build a public Video-Progress Benchmark inference manifest."
+    )
+    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 matches the VLAC-Cut 2Hz input protocol.",
+    )
+    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 {})
+    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": str(meta.get("task_description") or ""),
+        "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 {})
+    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": str(meta.get("task_description") or ""),
+        "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

@@ -0,0 +1,1276 @@
+#!/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="Prediction JSONL or JSON file.")
+    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(
+        "--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"(?=时间[:：]?\s*[0-9])", cleaned)
+    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_sequence_predictions(
+    pred_map: PredMap,
+    *,
+    gid: str,
+    sequence: Any,
+    traj: Trajectory,
+    frame_sequence: Any,
+    clip_range: tuple[float, float] | None,
+    stats: Counter[str],
+) -> None:
+    if not isinstance(sequence, list):
+        stats["invalid_sequence_predictions"] += 1
+        return
+    if isinstance(frame_sequence, list) and len(frame_sequence) == len(sequence):
+        valid_frames: list[int] = []
+        for raw_frame in frame_sequence:
+            frame = finite_float(raw_frame)
+            if frame is None:
+                stats["invalid_sequence_frames"] += 1
+                return
+            valid_frames.append(int(frame))
+        for frame, value in zip(valid_frames, sequence):
+            add_prediction(
+                pred_map,
+                gid=gid,
+                frame=frame,
+                value=value,
+                clip_range=clip_range,
+                stats=stats,
+            )
+        stats["sequence_rows_aligned_by_row_frames"] += 1
+        return
+    if len(sequence) == len(traj.frames):
+        for frame, value in zip(traj.frames, sequence):
+            add_prediction(
+                pred_map,
+                gid=gid,
+                frame=frame,
+                value=value,
+                clip_range=clip_range,
+                stats=stats,
+            )
+        stats["sequence_rows_aligned_by_position"] += 1
+        return
+    if traj.frames and max(traj.frames) < len(sequence):
+        for frame in traj.frames:
+            add_prediction(
+                pred_map,
+                gid=gid,
+                frame=frame,
+                value=sequence[frame],
+                clip_range=clip_range,
+                stats=stats,
+            )
+        stats["sequence_rows_aligned_by_frame_id"] += 1
+        return
+    stats["sequence_length_mismatch"] += 1
+
+
+def add_vlac_keypoint_predictions(
+    pred_map: PredMap,
+    *,
+    gid: str,
+    row: dict[str, Any],
+    traj: Trajectory,
+    clip_range: tuple[float, float] | None,
+    stats: Counter[str],
+) -> bool:
+    frame_sequence = row.get("frames") or row.get("input_frames")
+    if not isinstance(frame_sequence, list) or not frame_sequence:
+        return False
+
+    raw_times: list[float] = []
+    raw_values: list[float] = []
+    if isinstance(row.get("pred_curve_point_times_sec"), list) and isinstance(row.get("pred_curve_point_progress"), list):
+        for time_val, progress_val in zip(row["pred_curve_point_times_sec"], row["pred_curve_point_progress"]):
+            time_num = finite_float(time_val)
+            progress_num = finite_float(progress_val)
+            if time_num is None or progress_num is None:
+                continue
+            raw_times.append(float(time_num))
+            raw_values.append(float(progress_num))
+    elif isinstance(row.get("response"), str):
+        raw_times, raw_values = parse_point_blocks(str(row.get("response") or ""))
+    else:
+        return False
+
+    if not raw_values:
+        stats["vlac_keypoint_parse_failed"] += 1
+        return True
+
+    aligned = align_curve_to_length(raw_times, raw_values, len(frame_sequence))
+    if not aligned:
+        stats["vlac_keypoint_align_failed"] += 1
+        return True
+
+    add_sequence_predictions(
+        pred_map,
+        gid=gid,
+        sequence=aligned,
+        traj=traj,
+        frame_sequence=frame_sequence,
+        clip_range=clip_range,
+        stats=stats,
+    )
+    stats["vlac_keypoint_rows_aligned_by_index"] += 1
+    return True
+
+
+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
+
+        by_frame = None
+        for key in ("pred_progress_by_frame", "progress_by_frame", "predictions_by_frame"):
+            value = row.get(key)
+            if isinstance(value, dict):
+                by_frame = value
+                break
+        if by_frame is not None:
+            stats["episode_rows"] += 1
+            for raw_frame, value in by_frame.items():
+                frame = finite_float(raw_frame)
+                if frame is None:
+                    stats["invalid_prediction_frames"] += 1
+                    continue
+                add_prediction(
+                    pred_map,
+                    gid=gid,
+                    frame=int(frame),
+                    value=value,
+                    clip_range=clip_range,
+                    stats=stats,
+                )
+            continue
+
+        if add_vlac_keypoint_predictions(
+            pred_map,
+            gid=gid,
+            row=row,
+            traj=traj,
+            clip_range=clip_range,
+            stats=stats,
+        ):
+            continue
+
+        sequence = None
+        for key in ("pred_progress_sequence", "pred_dense_progress_aligned_to_gt"):
+            value = row.get(key)
+            if isinstance(value, list):
+                sequence = value
+                break
+        if sequence is not None:
+            stats["sequence_rows"] += 1
+            add_sequence_predictions(
+                pred_map,
+                gid=gid,
+                sequence=sequence,
+                traj=traj,
+                frame_sequence=row.get("frames") or row.get("input_frames"),
+                clip_range=clip_range,
+                stats=stats,
+            )
+            continue
+
+        frame = finite_float(row.get("frame"))
+        value = None
+        for key in ("pred_progress", "pred_progress_percent", "progress", "prediction"):
+            if key in row:
+                value = row.get(key)
+                break
+        if frame is None or value is None:
+            stats["unrecognized_prediction_rows"] += 1
+            continue
+        stats["point_rows"] += 1
+        add_prediction(
+            pred_map,
+            gid=gid,
+            frame=int(frame),
+            value=value,
+            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 summarize_local_keypoint_progress(
+    trajectories: list[Trajectory],
+    pred_map: PredMap,
+    *,
+    include_voc: bool,
+) -> dict[str, Any]:
+    point_total = 0
+    point_valid = 0
+    traj_total = 0
+    traj_with_valid_pred = 0
+    mae_values: list[float] = []
+    prc_values: list[float] = []
+    voc_values: list[float] = []
+
+    for traj in trajectories:
+        frames = traj.semantic_anchor_frames
+        progress = traj.semantic_anchor_progress
+        if not frames:
+            continue
+        traj_total += 1
+        point_total += len(frames)
+        gt_curve: list[float] = []
+        pred_curve: list[float] = []
+        for frame, gt in zip(frames, progress):
+            pred = interpolated_prediction_for_frame(pred_map, traj.global_episode_id, frame)
+            if pred is None or not math.isfinite(float(pred)):
+                continue
+            point_valid += 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 {
+        "event_source": "semantic_anchors",
+        "traj_base_total": int(traj_total),
+        "traj_with_valid_pred": int(traj_with_valid_pred),
+        "point_base_total": int(point_total),
+        "point_valid": int(point_valid),
+        "point_coverage_to_base": (point_valid / point_total) if point_total else None,
+        "mae": mean_or_none(mae_values),
+        "mae_valid_traj": int(len(mae_values)),
+        "prc": mean_or_none(prc_values),
+        "prc_valid_traj": int(len(prc_values)),
+        "voc": mean_or_none(voc_values) if include_voc else None,
+        "voc_valid_traj": int(len(voc_values)) if include_voc else 0,
+    }
+
+
+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_keypoint_per_bucket = {
+        bucket: summarize_local_keypoint_progress(
+            bucket_trajs,
+            pred_map,
+            include_voc=(bucket in EXPERT_BUCKETS),
+        )
+        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,
+        },
+        "local_keypoint_progress": {
+            "overall_4bucket": summarize_local_keypoint_progress(
+                trajectories,
+                pred_map,
+                include_voc=False,
+            ),
+            "per_bucket": local_keypoint_per_bucket,
+        },
+    }
+
+
+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("- Curve metrics are trajectory-equal means.")
+    lines.append("- VOC is reported only for expert bucket rows.")
+    lines.append("- Local Direction AP and Local Keypoint Progress use released `semantic_anchors`; predictions are linearly interpolated at anchor frames.")
+    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("")
+
+    keypoint_rows: list[list[Any]] = []
+    keypoint_sources = [("overall_4bucket", report["local_keypoint_progress"]["overall_4bucket"])]
+    for bucket in selected_buckets:
+        keypoint_sources.append((bucket, report["local_keypoint_progress"]["per_bucket"][bucket]))
+    for scope, item in keypoint_sources:
+        keypoint_rows.append(
+            [
+                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")),
+                format_metric(item.get("voc")) if scope in EXPERT_BUCKETS else "n/a",
+            ]
+        )
+    lines.append("## Local Keypoint Progress")
+    lines.append("")
+    lines.append(
+        markdown_table(
+            ["scope", "coverage", "point_valid/keypoints", "traj_valid/base", "MAE", "PRC", "VOC"],
+            keypoint_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:
+                    f.write(
+                        json.dumps(
+                            {
+                                "global_episode_id": item["global_episode_id"],
+                                "pred_progress_by_frame": item["dense_kinematic_progress"],
+                            }
+                        )
+                        + "\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_keypoint_progress"]["overall_4bucket"]["mae"] == 0.0
+        assert report["local_direction_ap"]["overall_4bucket"]["ap_positive"] == 1.0
+    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),
+        "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,
+    )
+    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/upload_vlac2_release_archives_to_hf.sbatch

@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH -J vlac2-release-hf
+#SBATCH -p wam_critic
+#SBATCH -A research
+#SBATCH -N 1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=4
+#SBATCH --mem=16G
+#SBATCH --time=1-00:00:00
+#SBATCH --output=slurm/%x_%j.out
+#SBATCH --error=slurm/%x_%j.err
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+RELEASE_ROOT="${RELEASE_ROOT:-$(cd "${SCRIPT_DIR}/.." && pwd)}"
+HF_REPO_ID="${HF_REPO_ID:-InternRobotics/VLAC-Cut-Benchmark}"
+HF_REPO_TYPE="${HF_REPO_TYPE:-dataset}"
+ARCHIVE_NAMES=(
+  vlac2_release_data_part01_arx_group_a.tar.zst
+  vlac2_release_data_part02_arx_group_b.tar.zst
+  vlac2_release_data_part03_arx_group_c.tar.zst
+  vlac2_release_data_part04_droid_group_a.tar.zst
+  vlac2_release_data_part05_droid_group_b.tar.zst
+  vlac2_release_data_part06_droid_group_c.tar.zst
+  vlac2_release_data_part07_other_sources.tar.zst
+)
+
+if [[ -z "${HF_TOKEN:-}" ]]; then
+  echo "HF_TOKEN is required" >&2
+  exit 1
+fi
+
+HF_STAGE_ROOT="${RELEASE_ROOT}/vlac2_release_data/.hf_upload_stage"
+mkdir -p "${HF_STAGE_ROOT}"
+
+python3 - "${RELEASE_ROOT}" "${HF_REPO_ID}" "${HF_REPO_TYPE}" "${HF_TOKEN}" "${ARCHIVE_NAMES[@]}" <<'PY'
+import fnmatch
+import sys
+from pathlib import Path
+
+from huggingface_hub import HfApi
+
+release_root = Path(sys.argv[1]).resolve()
+repo_id = sys.argv[2]
+repo_type = sys.argv[3]
+token = sys.argv[4]
+archive_names = sys.argv[5:]
+api = HfApi(token=token)
+
+required = [
+    release_root / "README.md",
+    release_root / "docs" / "vpb_public_evaluation.md",
+    release_root / "scripts" / "build_vpb_inference_manifest.py",
+    release_root / "scripts" / "evaluate_vpb_predictions.py",
+    release_root / "scripts" / "unpack_data.sh",
+    release_root / "scripts" / "upload_vlac2_release_archives_to_hf.sbatch",
+    release_root / "scripts" / "extract_vlac2_release_frames.py",
+    release_root / "scripts" / "vlac2_release_common.py",
+    release_root / "scripts" / "vpb_public_eval_utils.py",
+]
+required.extend(sorted((release_root / "benchmark_splits").glob("**/video_progress_benchmark_file.json")))
+required.extend(release_root / "vlac2_release_data" / name for name in archive_names)
+missing = [str(p) for p in required if not p.exists()]
+if missing:
+    raise SystemExit(f"missing required local files: {missing}")
+
+delete_candidates = [
+    "_extracted_frames/_GENERATED",
+    "docs/vlac2_public_release.md",
+    "release_bundle_manifest.json",
+    "rebuild_validation_summary.json",
+    "benchmark_json/split_summary.json",
+    "benchmark_splits/split_summary.json",
+    "vlac2_release_data/vlac2_release_data_archives_manifest.json",
+    "vlac2_release_data/ARX-data/.gitkeep",
+    "vlac2_release_data/VLABench_5/.gitkeep",
+    "vlac2_release_data/dex_fold_v2_mix/.gitkeep",
+    "vlac2_release_data/droid_lerobot/.gitkeep",
+    "vlac2_release_data/libero/.gitkeep",
+    "vlac2_release_data/libero_zty50/.gitkeep",
+    "vlac2_release_data/README.md",
+]
+delete_patterns = [
+    "benchmark_json/*/benchmark_stats.json",
+    "benchmark_json/*/video_progress_benchmark_file.json",
+    "benchmark_splits/*/benchmark_stats.json",
+]
+remote_files = set(api.list_repo_files(repo_id=repo_id, repo_type=repo_type))
+for path_in_repo in delete_candidates:
+    if path_in_repo in remote_files:
+        api.delete_file(
+            path_in_repo=path_in_repo,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            commit_message=f"Delete {path_in_repo}",
+        )
+for remote_path in sorted(remote_files):
+    if any(fnmatch.fnmatch(remote_path, pattern) for pattern in delete_patterns):
+        api.delete_file(
+            path_in_repo=remote_path,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            commit_message=f"Delete {remote_path}",
+        )
+
+for local_path in required[:len(required) - len(archive_names)]:
+    rel = local_path.relative_to(release_root).as_posix()
+    api.upload_file(
+        path_or_fileobj=str(local_path),
+        path_in_repo=rel,
+        repo_id=repo_id,
+        repo_type=repo_type,
+        commit_message=f"Update {rel}",
+    )
+    print(f"uploaded={rel}", flush=True)
+PY
+
+hf_remote_file_exists() {
+  local rel_path="$1"
+  python3 - "${rel_path}" "${HF_REPO_ID}" "${HF_REPO_TYPE}" "${HF_TOKEN}" <<'PY'
+import sys
+
+from huggingface_hub import HfApi
+
+rel_path = sys.argv[1]
+repo_id = sys.argv[2]
+repo_type = sys.argv[3]
+token = sys.argv[4]
+api = HfApi(token=token)
+remote_files = set(api.list_repo_files(repo_id=repo_id, repo_type=repo_type))
+print("1" if rel_path in remote_files else "0")
+PY
+}
+
+for archive_name in "${ARCHIVE_NAMES[@]}"; do
+  archive_path="${RELEASE_ROOT}/vlac2_release_data/${archive_name}"
+  remote_rel="vlac2_release_data/${archive_name}"
+  if [[ "$(hf_remote_file_exists "${remote_rel}")" == "1" ]]; then
+    echo "remote_exists=${archive_name}"
+    continue
+  fi
+
+  stage_path="${HF_STAGE_ROOT}/${remote_rel}"
+  mkdir -p "$(dirname "${stage_path}")"
+  if [[ ! -f "${stage_path}" ]] || [[ "$(stat -c '%d:%i' "${stage_path}" 2>/dev/null || true)" != "$(stat -c '%d:%i' "${archive_path}")" ]]; then
+    rm -f "${stage_path}"
+    ln "${archive_path}" "${stage_path}"
+  fi
+
+  hf upload-large-folder "${HF_REPO_ID}" "${HF_STAGE_ROOT}" \
+    --repo-type "${HF_REPO_TYPE}" \
+    --token "${HF_TOKEN}" \
+    --include "${remote_rel}" \
+    --num-workers 4
+
+  echo "uploaded=${remote_rel}"
+  rm -f "${stage_path}"
+done

scripts/vlac2_release_common.py

@@ -241,13 +241,12 @@ def discover_benchmark_jsons(benchmark_root: Path) -> list[Path]:
     benchmark_root = benchmark_root.resolve()
     candidates: list[Path] = []
     seen: set[Path] = set()
-    for pattern in ("**/video_progress_benchmark_file.json", "**/intermediate_benchmark_*.json"):
-        for path in sorted(benchmark_root.glob(pattern)):
-            resolved = path.resolve()
-            if resolved in seen:
-                continue
-            seen.add(resolved)
-            candidates.append(resolved)
+    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
 
 

scripts/vpb_public_eval_utils.py

@@ -0,0 +1,366 @@
+#!/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)