Clarify VLAC-Cut evaluation workflow and metrics

README.md

@@ -10,7 +10,7 @@ license: other
 
 # Video-Progress Benchmark Release
 
-Video-Progress Benchmark is a benchmark for evaluating progress prediction in long-horizon robot manipulation. This release provides the benchmark split files, the minimal subset of raw videos required by the benchmark protocol, and a frame-extraction workflow for reproducible evaluation.
+Video-Progress Benchmark is a benchmark for evaluating progress prediction in long-horizon robot manipulation. This release provides the benchmark split files, the minimal subset of raw videos required by the benchmark protocol, and a frame-extraction workflow for reproducible evaluation of VLAC-Cut benchmark metrics.
 
 ## Contents
 
@@ -25,14 +25,13 @@ benchmark_splits/
 scripts/
   unpack_data.sh
   extract_vlac2_release_frames.py
-  build_vpb_inference_manifest.py
+  build_vlac_cut_eval_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
+  evaluate_vlac_cut_on_vpb.md
 
 data/
   train_videos.tar
@@ -77,38 +76,38 @@ __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
+### 4. Build a VLAC-Cut evaluation manifest
 
 ```bash
-python scripts/build_vpb_inference_manifest.py \
+python scripts/build_vlac_cut_eval_manifest.py \
   --benchmark-root benchmark_splits \
   --frames-root /path/to/data_extracted_frames \
-  --out manifests/vpb_test_1hz.jsonl
+  --out manifests/vlac_cut_vpb_eval.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 our VLAC-Cut benchmark evaluation, the manifest samples 2Hz video input frames and also records the public 1Hz evaluation frames from the main view of each trajectory. The 2Hz setting is an evaluation choice for VLAC-Cut input, not a benchmark-wide requirement. Metrics are computed on the released 1Hz evaluation frames.
 
 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`.
+By default, each manifest row is one trajectory with a list of sampled frame paths for VLAC-Cut inference.
 
-### 5. Evaluate predictions
+### 5. Evaluate VLAC-Cut 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
+  --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, 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.
+The evaluator reports global progress metrics, terminal success metrics, and local direction AP on adjacent semantic anchors. Global progress is shown for the 4-bucket overall split and each bucket; terminal metrics and local direction AP are shown for 4-bucket overall, seen merged, and unseen merged. See `docs/evaluate_vlac_cut_on_vpb.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`.
+For our VLAC-Cut evaluation, run the model on the 2Hz `image_paths` from the trajectory manifest instead of re-sampling the full raw video. This 2Hz input setting is what we use for VLAC-Cut evaluation; the public benchmark metrics themselves are computed on the 1Hz `eval_frames`. 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 global progress, terminal success, and local direction AP. The exact adapter contract is documented in `docs/evaluate_vlac_cut_on_vpb.md`.
 
 ## Notes
 

docs/{vpb_public_evaluation.md → evaluate_vlac_cut_on_vpb.md}

@@ -1,27 +1,40 @@
-# Public Video-Progress Benchmark Evaluation
+# Evaluating VLAC-Cut on Video-Progress Benchmark
 
-This release evaluates model progress predictions from the public benchmark files only.
-It does not require any private workspace paths or private metric code.
+This document describes how to evaluate VLAC-Cut benchmark metrics using only
+the public Video-Progress Benchmark release files. It does not require private
+workspace paths or private metric code.
 
-## Protocol
+The VLAC-Cut model release is hosted separately at
+<https://huggingface.co/InternRobotics/VLAC-Cut>. This benchmark release
+contains the split files, frame extraction scripts, a VLAC-Cut evaluation
+manifest builder, and a prediction evaluator. It does not vendor model weights
+or a VLAC-Cut batch inference runner.
+
+## Evaluation Scope
 
-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:
+The public 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`
+- 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`
+- local direction metrics: `AP+`, `AP-`, and `MacroAP_D` on adjacent
+  `semantic_anchors` with `tau=0`
+
+For our VLAC-Cut evaluation, we feed the model video frames sampled at 2Hz. This
+2Hz input rate is an evaluation setting for VLAC-Cut, not a benchmark-wide
+protocol requirement. The evaluator maps VLAC-Cut predictions back to original
+frame ids and computes the benchmark metrics on the public 1Hz evaluation
+frames.
 
 The released JSON files also contain dense frame-level progress. Use
-`--eval-points dense` only for diagnostics; it is not the paper-comparable default.
+`--eval-points dense` only for diagnostics; it is not the paper-comparable
+default.
 
-## End-to-End Workflow
+## Workflow
 
 Unpack videos:
 
@@ -37,77 +50,41 @@ python scripts/extract_vlac2_release_frames.py \
   --frames-root /path/to/frames
 ```
 
-Build a 2Hz-input / 1Hz-evaluation inference manifest:
+Build the VLAC-Cut evaluation manifest:
 
 ```bash
-python scripts/build_vpb_inference_manifest.py \
+python scripts/build_vlac_cut_eval_manifest.py \
   --benchmark-root benchmark_splits \
   --frames-root /path/to/frames \
-  --out manifests/vpb_test_1hz.jsonl
+  --out manifests/vlac_cut_vpb_eval.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.
+Each trajectory-level manifest row contains:
 
-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.
+- `frames` / `input_frames`: the 2Hz frame ids used as VLAC-Cut video input.
+- `image_paths` / `input_image_paths`: the extracted images for those 2Hz
+  frames.
+- `eval_frames`: the public 1Hz frame ids used for global progress and terminal
+  metrics.
+- `task_instruction` and `task_description`: text fields used to build the
+  VLAC-Cut prompt.
 
-Run your model on the manifest and write predictions as JSONL. The canonical
-episode-level format is:
+For this release, the default 1Hz `eval_frames` are a subset of the default 2Hz
+`input_frames`. Keep the 2Hz `frames` list in each VLAC-Cut prediction row. The
+evaluator stores predictions by original frame id, then compares only the 1Hz
+`eval_frames` against the released `dense_kinematic_progress` GT.
 
-```json
-{
-  "global_episode_id": "ARX-data/.../episode_000000",
-  "pred_progress_by_frame": {
-    "0": 0.0,
-    "30": 12.5,
-    "60": 28.0
-  }
-}
-```
+## VLAC-Cut Prediction Rows
 
-The point-level format is also accepted:
+A minimal VLAC-Cut adapter should:
 
-```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]
-}
-```
+1. Read each row from `manifests/vlac_cut_vpb_eval.jsonl`.
+2. Build the same VLAC-Cut prompt from `task_instruction` and
+   `task_description`.
+3. Run VLAC-Cut on `image_paths` with the frame order unchanged.
+4. Write one prediction row per trajectory with the raw VLAC-Cut response.
 
-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:
+Example:
 
 ```json
 {
@@ -117,53 +94,23 @@ formal VLAC evaluation code:
 }
 ```
 
-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.
+The evaluator parses VLAC-style keypoint responses, aligns the parsed progress
+curve to the provided 2Hz `frames` list using the same index-normalized
+alignment rule as the formal VLAC evaluation code, and then takes the 1Hz subset
+for metric computation.
 
-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:
+If your adapter has already converted the response into a progress sequence
+aligned to the 2Hz frames, this format is also accepted:
 
 ```json
 {
   "global_episode_id": "ARX-data/.../episode_000000",
   "frames": [0, 15, 30, 45, 60],
-  "response": "时间: 0.5s, 进度: 0%\n时间: 2.0s, 进度: 30%"
+  "pred_progress_sequence": [0.0, 5.0, 12.5, 20.0, 28.0]
 }
 ```
 
-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:
+Run evaluation:
 
 ```bash
 python scripts/evaluate_vpb_predictions.py \
@@ -173,11 +120,9 @@ python scripts/evaluate_vpb_predictions.py \
   --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.
+Use `--interpolate-missing` only for sparse outputs that do not contain the 1Hz
+evaluation frame ids. Reports generated with interpolation are not strict
+paper-comparable outputs.
 
 ## Metrics
 
@@ -186,16 +131,20 @@ prediction diagnostics.
 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.
+- `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:
+Terminal success uses the last selected 1Hz evaluation frame:
 
 - GT success: final GT progress `>= 90`
 - predicted success: final predicted progress `>= 90`
@@ -226,28 +175,13 @@ 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.
+## Diagnostics
 
 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.
+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.
 
 ## Quick Checks
 
@@ -260,9 +194,9 @@ python scripts/evaluate_vpb_predictions.py --self-test
 Build a small smoke-test manifest:
 
 ```bash
-python scripts/build_vpb_inference_manifest.py \
+python scripts/build_vlac_cut_eval_manifest.py \
   --benchmark-root benchmark_splits \
   --frames-root /path/to/frames \
-  --out /tmp/vpb_manifest_smoke.jsonl \
+  --out /tmp/vlac_cut_vpb_manifest_smoke.jsonl \
   --limit-trajectories 2
 ```

scripts/{build_vpb_inference_manifest.py → build_vlac_cut_eval_manifest.py}

@@ -25,7 +25,7 @@ from vpb_public_eval_utils import (
 def parse_args() -> argparse.Namespace:
     release_root = SCRIPT_DIR.parent
     parser = argparse.ArgumentParser(
-        description="Build a public Video-Progress Benchmark inference manifest."
+        description="Build a VLAC-Cut evaluation manifest for the public Video-Progress Benchmark."
     )
     parser.add_argument(
         "--benchmark-root",
@@ -69,7 +69,7 @@ def parse_args() -> argparse.Namespace:
         "--input-sample-hz",
         type=float,
         default=2.0,
-        help="Trajectory-level video input sampling rate. The default matches the VLAC-Cut 2Hz input protocol.",
+        help="Trajectory-level video input sampling rate. The default is the 2Hz input setting used in our VLAC-Cut evaluation.",
     )
     parser.add_argument(
         "--view",

scripts/evaluate_vpb_predictions.py

@@ -673,67 +673,6 @@ def summarize_local_direction_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))
@@ -854,14 +793,6 @@ def build_report(
         )
         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,
@@ -934,14 +865,6 @@ def build_report(
             ),
             "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,
-        },
     }
 
 
@@ -971,7 +894,7 @@ def build_markdown(report: dict[str, Any]) -> str:
     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("- Local Direction AP uses adjacent released `semantic_anchors`; predictions are linearly interpolated at anchor frames.")
     lines.append("")
 
     curve_rows: list[list[Any]] = []
@@ -1086,32 +1009,6 @@ def build_markdown(report: dict[str, Any]) -> str:
     )
     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"]
@@ -1201,7 +1098,6 @@ def run_self_test() -> 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")
 

scripts/upload_vlac2_release_archives_to_hf.sbatch

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