Add VLAC-Cut public benchmark evaluation workflow

README.md

@@ -26,6 +26,7 @@ scripts/
   unpack_data.sh
   extract_vlac2_release_frames.py
   build_vlac_cut_eval_manifest.py
+  run_vlac_cut_batch.py
   evaluate_vpb_predictions.py
   vlac2_release_common.py
   vpb_public_eval_utils.py
@@ -40,6 +41,11 @@ data/
 
 ## Usage
 
+VLAC-Cut inference uses the model release's Transformers interface and requires
+an environment that can load `Qwen3VLMoeForConditionalGeneration`, plus enough
+GPU memory for the 30B checkpoint. Frame extraction and metric computation use
+only the files in this benchmark release.
+
 ### 1. Unpack the video archives
 
 ```bash
@@ -85,30 +91,41 @@ python scripts/build_vlac_cut_eval_manifest.py \
   --out manifests/vlac_cut_vpb_eval.jsonl
 ```
 
-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 our VLAC-Cut benchmark evaluation, the manifest samples 2Hz video input frames, records the public 1Hz evaluation frames, and materializes the exact `chunk_all` text prompt in `vlac_cut_prompt`. 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 VLAC-Cut inference.
 
-### 5. Evaluate VLAC-Cut predictions
+### 5. Run VLAC-Cut batch inference
+
+VLAC-Cut is released separately at <https://huggingface.co/InternRobotics/VLAC-Cut>.
+
+```bash
+python scripts/run_vlac_cut_batch.py \
+  --model-path /path/to/VLAC-Cut \
+  --manifest manifests/vlac_cut_vpb_eval.jsonl \
+  --out predictions/vlac_cut_predictions.jsonl
+```
+
+The batch prediction file uses one fixed schema:
+
+```json
+{"global_episode_id": "...", "frames": [65, 80, 95], "response": "时间: 0.0s, 进度: 0%\n时间: 1.0s, 进度: 50%"}
+```
+
+### 6. Evaluate VLAC-Cut predictions
 
 ```bash
 python scripts/evaluate_vpb_predictions.py \
   --benchmark-root benchmark_splits \
-  --predictions vlac_cut_predictions.jsonl \
+  --predictions predictions/vlac_cut_predictions.jsonl \
   --out-json reports/vlac_cut_vpb_eval.json \
   --out-md reports/vlac_cut_vpb_eval.md
 ```
 
 The evaluator reports global progress metrics, 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 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
 
 * This repository contains only the raw videos required by the released benchmark splits.

docs/evaluate_vlac_cut_on_vpb.md

@@ -1,18 +1,12 @@
 # Evaluating VLAC-Cut on Video-Progress Benchmark
 
-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.
-
-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.
+This document describes the public VLAC-Cut evaluation workflow for
+Video-Progress Benchmark. It uses only this benchmark release plus the separate
+VLAC-Cut model release at <https://huggingface.co/InternRobotics/VLAC-Cut>.
 
 ## Evaluation Scope
 
-The public benchmark metrics are computed on the released 1Hz evaluation frames
+The benchmark metrics are computed on the released 1Hz evaluation frames
 reconstructed from each dense video timeline:
 
 - split scope: `test_expert_seen`, `test_expert_unseen`,
@@ -24,25 +18,25 @@ reconstructed from each dense video timeline:
 - 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.
+For VLAC-Cut evaluation we feed the model frames sampled at 2Hz. This 2Hz input
+rate is a VLAC-Cut evaluation setting, not a benchmark-wide protocol
+requirement. The evaluator maps VLAC-Cut outputs back to original frame ids and
+computes metrics on the public 1Hz evaluation frames.
 
 ## Workflow
 
+VLAC-Cut inference requires the model release environment: `torch`,
+`transformers` with `Qwen3VLMoeForConditionalGeneration` support, and enough GPU
+memory for the 30B checkpoint. The benchmark-side frame extraction, manifest
+building, and evaluation scripts are included in this release.
+
 Unpack videos:
 
 ```bash
 bash scripts/unpack_data.sh /path/to/data
 ```
 
-Extract frames:
+Extract benchmark frames:
 
 ```bash
 python scripts/extract_vlac2_release_frames.py \
@@ -59,70 +53,68 @@ python scripts/build_vlac_cut_eval_manifest.py \
   --out manifests/vlac_cut_vpb_eval.jsonl
 ```
 
-Each trajectory-level manifest row contains:
+Run VLAC-Cut batch inference:
 
-- `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.
+```bash
+python scripts/run_vlac_cut_batch.py \
+  --model-path /path/to/VLAC-Cut \
+  --manifest manifests/vlac_cut_vpb_eval.jsonl \
+  --out predictions/vlac_cut_predictions.jsonl
+```
 
-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.
+Evaluate the batch predictions:
 
-## VLAC-Cut Prediction Rows
+```bash
+python scripts/evaluate_vpb_predictions.py \
+  --benchmark-root benchmark_splits \
+  --predictions predictions/vlac_cut_predictions.jsonl \
+  --out-json reports/vlac_cut_vpb_eval.json \
+  --out-md reports/vlac_cut_vpb_eval.md
+```
 
-A minimal VLAC-Cut adapter should:
+## Manifest Fields
 
-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.
+Each trajectory-level manifest row contains the fields needed by the batch
+inference script:
 
-Example:
+- `global_episode_id`: episode key used to match predictions with GT.
+- `frames` / `image_paths`: the 2Hz frame ids and frame images passed to
+  VLAC-Cut.
+- `eval_frames`: the public 1Hz frame ids used for global progress and terminal
+  metrics.
+- `vlac_cut_prompt`: the exact text prompt passed to the Qwen/VLAC-Cut model.
+- `prompt_variant`: fixed to `chunk_all`.
+- `prompt_source`: fixed to `task_description`.
 
-```json
-{
-  "global_episode_id": "ARX-data/.../episode_000000",
-  "frames": [0, 15, 30, 45, 60],
-  "response": "时间: 0.5s, 进度: 0%\n时间: 2.0s, 进度: 30%"
-}
+The prompt is materialized by the manifest builder as:
+
+```text
+任务描述和具体规划: {task_description}
+
+请根据任务描述和具体规划，找到并���点生成视频中的关键动作点和相应的进度标注。输出格式要求：每个关键点一行，格式为：
+时间: X.Xs, 进度: Y%
+
+请严格按照上述格式输出，不要输出额外说明。
 ```
 
-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.
+`task_description` already contains the task and progress plan, so it is not
+prefixed again with `task_instruction`.
 
-If your adapter has already converted the response into a progress sequence
-aligned to the 2Hz frames, this format is also accepted:
+## Prediction Schema
+
+`run_vlac_cut_batch.py` writes one JSON object per trajectory:
 
 ```json
 {
   "global_episode_id": "ARX-data/.../episode_000000",
   "frames": [0, 15, 30, 45, 60],
-  "pred_progress_sequence": [0.0, 5.0, 12.5, 20.0, 28.0]
+  "response": "时间: 0.5s, 进度: 0%\n时间: 2.0s, 进度: 30%"
 }
 ```
 
-Run evaluation:
-
-```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
-```
-
-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.
+This is the public evaluator schema. The evaluator parses `response`, aligns the
+parsed keypoints to the provided 2Hz `frames` list using index-normalized curve
+alignment, and then evaluates the aligned curve on the benchmark points.
 
 ## Metrics
 
@@ -163,7 +155,7 @@ 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`:
+model's valid predicted curve. The public report uses `tau=0`:
 
 ```text
 AP+       = AP(y = 1[Delta_gt > 0], score = Delta_pred)
@@ -177,11 +169,12 @@ merged, and unseen merged rows.
 
 ## Diagnostics
 
-Missing predictions are not silently filled in strict mode. The report includes
-coverage, missing final counts, duplicate prediction counts, unknown episode
-ids, prediction frames outside the selected 1Hz evaluation points, and counts
-for predictions outside the nominal `[0, 100]` range. The nominal range counts
-are diagnostics only; predictions are not clipped unless `--clip-pred` is set.
+Missing or unparsable prediction rows are not silently filled. The report
+includes coverage, missing final counts, duplicate prediction counts, unknown
+episode ids, prediction frames outside the selected 1Hz evaluation points, and
+counts for predictions outside the nominal `[0, 100]` range. The nominal range
+counts are diagnostics only; predictions are not clipped unless `--clip-pred` is
+set.
 
 ## Quick Checks
 

scripts/build_vlac_cut_eval_manifest.py

@@ -21,6 +21,20 @@ from vpb_public_eval_utils import (
     selected_frames_for_row,
 )
 
+PROMPT_VARIANT = "chunk_all"
+PROMPT_SOURCE = "task_description"
+
+
+def build_vlac_cut_prompt(task_description: str) -> str:
+    task_and_plan = str(task_description or "").strip()
+    return (
+        f"任务描述和具体规划: {task_and_plan}\n\n"
+        "请根据任务描述和具体规划，找到并逐点生成视频中的关键动作点和相应的进度标注。"
+        "输出格式要求：每个关键点一行，格式为：\n"
+        "时间: X.Xs, 进度: Y%\n\n"
+        "请严格按照上述格式输出，不要输出额外说明。"
+    )
+
 
 def parse_args() -> argparse.Namespace:
     release_root = SCRIPT_DIR.parent
@@ -105,6 +119,7 @@ def build_record(
     sample_hz: float,
 ) -> dict[str, Any]:
     meta = dict(row.get("metadata") or {})
+    task_description = str(meta.get("task_description") or "")
     record: dict[str, Any] = {
         "bucket": bucket,
         "row_index": row_idx,
@@ -114,7 +129,10 @@ def build_record(
         "image_path": str(image_path),
         "view": view,
         "task_instruction": str(meta.get("task_instruction") or ""),
-        "task_description": str(meta.get("task_description") or ""),
+        "task_description": task_description,
+        "vlac_cut_prompt": build_vlac_cut_prompt(task_description),
+        "prompt_variant": PROMPT_VARIANT,
+        "prompt_source": PROMPT_SOURCE,
         "is_terminal_point": bool(is_terminal_point),
         "selected_frame_count": int(selected_count),
         "eval_points": eval_points,
@@ -142,6 +160,7 @@ def build_trajectory_record(
     input_sample_hz: float,
 ) -> dict[str, Any]:
     meta = dict(row.get("metadata") or {})
+    task_description = str(meta.get("task_description") or "")
     record: dict[str, Any] = {
         "bucket": bucket,
         "row_index": row_idx,
@@ -156,7 +175,10 @@ def build_trajectory_record(
         "eval_timestamps_sec": eval_timestamps_sec,
         "view": view,
         "task_instruction": str(meta.get("task_instruction") or ""),
-        "task_description": str(meta.get("task_description") or ""),
+        "task_description": task_description,
+        "vlac_cut_prompt": build_vlac_cut_prompt(task_description),
+        "prompt_variant": PROMPT_VARIANT,
+        "prompt_source": PROMPT_SOURCE,
         "terminal_frame": int(eval_frames[-1]) if eval_frames else None,
         "selected_frame_count": len(input_frames),
         "input_frame_count": len(input_frames),

scripts/evaluate_vpb_predictions.py

@@ -54,7 +54,11 @@ def parse_args() -> argparse.Namespace:
         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(
+        "--predictions",
+        type=Path,
+        help="VLAC-Cut batch prediction JSONL with global_episode_id, frames, and response.",
+    )
     parser.add_argument("--out-json", type=Path, help="Output JSON report.")
     parser.add_argument("--out-md", type=Path, help="Output Markdown report.")
     parser.add_argument(
@@ -176,7 +180,7 @@ def parse_point_blocks(text: str) -> tuple[list[float], list[float]]:
             [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)
+    blocks = re.split(r"(?=(?:Time|时间)[:：]?\s*[0-9])", cleaned, flags=re.IGNORECASE)
     times: list[float] = []
     values: list[float] = []
     for block in blocks:
@@ -264,113 +268,52 @@ def add_prediction(
     stats["valid_prediction_values"] += 1
 
 
-def add_sequence_predictions(
+def add_canonical_vlac_response_predictions(
     pred_map: PredMap,
     *,
     gid: str,
-    sequence: Any,
-    traj: Trajectory,
-    frame_sequence: Any,
+    row: dict[str, 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
+    frame_sequence = row.get("frames")
+    if not isinstance(frame_sequence, list) or not frame_sequence:
+        stats["canonical_rows_missing_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
+    valid_frames: list[int] = []
+    for raw_frame in frame_sequence:
+        frame = finite_float(raw_frame)
+        if frame is None:
+            stats["canonical_rows_invalid_frames"] += 1
+            return
+        valid_frames.append(int(frame))
+
+    response = row.get("response")
+    if not isinstance(response, str) or not response.strip():
+        stats["canonical_rows_missing_response"] += 1
         return
-    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
+    raw_times, raw_values = parse_point_blocks(response)
 
     if not raw_values:
-        stats["vlac_keypoint_parse_failed"] += 1
-        return True
+        stats["canonical_response_parse_failed"] += 1
+        return
 
-    aligned = align_curve_to_length(raw_times, raw_values, len(frame_sequence))
+    aligned = align_curve_to_length(raw_times, raw_values, len(valid_frames))
     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
+        stats["canonical_response_align_failed"] += 1
+        return
+
+    for frame, value in zip(valid_frames, aligned):
+        add_prediction(
+            pred_map,
+            gid=gid,
+            frame=frame,
+            value=value,
+            clip_range=clip_range,
+            stats=stats,
+        )
+    stats["canonical_response_rows_aligned_by_index"] += 1
 
 
 def load_predictions(
@@ -398,73 +341,10 @@ def load_predictions(
                 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(
+        add_canonical_vlac_response_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,
         )
@@ -1065,12 +945,21 @@ def run_self_test() -> None:
         with pred_path.open("w", encoding="utf-8") as f:
             for rows in rows_by_bucket.values():
                 for item in rows:
+                    points = sorted(
+                        (int(frame), float(value))
+                        for frame, value in item["dense_kinematic_progress"].items()
+                    )
                     f.write(
                         json.dumps(
                             {
                                 "global_episode_id": item["global_episode_id"],
-                                "pred_progress_by_frame": item["dense_kinematic_progress"],
-                            }
+                                "frames": [frame for frame, _value in points],
+                                "response": "\n".join(
+                                    f"时间: {idx:.1f}s, 进度: {value:g}%"
+                                    for idx, (_frame, value) in enumerate(points)
+                                ),
+                            },
+                            ensure_ascii=False,
                         )
                         + "\n"
                     )

scripts/run_vlac_cut_batch.py

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