Release FIRM-Video-Bench (part 2)

data/videos/vphy2_v2_3335_A_person_twists_a_piece_of_fabric_tightly,_creating_a_tourniquet_around_their_arm.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d20e8cb413fe8ac829fdd9796389fabe36874b0e2770e68ca5591f9a466b9c2e
+size 1461663

data/videos/vphy2_v2_3388_c09f35b4-f527-498e-ac08-5149c282709a_result.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f28cdf3ccdab870b7388dbfade7e644247f0cd003bfcaa4e3c9aafc0484dd2e
+size 962425

prompts/definitions.md

@@ -0,0 +1,8 @@
+### Instruction Following
+Measures how accurately and completely the video follows the text prompt, including requested subjects, attributes, actions, scene, style, camera/viewpoint, and temporal event order.
+
+### Perceptual Quality
+Measures the perceptual and technical quality of the rendered video, including resolution, overall and local clarity, sharpness or blurriness, brightness and color stability, flicker, compression artifacts, and low-level visual distortions that affect the viewing experience.
+
+### World Coherence
+Measures whether the video contains any violations of everyday knowledge, common sense, or basic physical laws, including temporal inconsistencies, unnatural or incoherent motion, physically implausible interactions, and structural abnormalities or deformities in objects or characters.

prompts/vanilla_prompts.py

@@ -0,0 +1,224 @@
+"""
+Inference prompts for the video-generation reward model.
+
+**Per-dimension** query templates: one prompt per scoring dimension,
+each tailored to the dimension's evaluation perspective. Each template
+asks the judge to evaluate the video on that dimension and to return a
+single strict JSON object ``{"reasoning": "...", "score": <int 1-5>}``.
+
+The dimensions are:
+  - instruction_following
+  - visual_quality
+  - world_consistency
+"""
+from __future__ import annotations
+
+from string import Template
+from typing import Dict, List, Optional
+
+
+DIMENSIONS: List[str] = [
+    "instruction_following",
+    "visual_quality",
+    "world_consistency",
+]
+
+#: Dimensions that require the text-to-video prompt as input. All three
+#: dimensions consume ``t2v_prompt`` -- IF as the object of evaluation,
+#: VQ/WC as context only (see module docstring).
+DIMENSIONS_REQUIRING_PROMPT: frozenset[str] = frozenset(DIMENSIONS)
+
+#: Number of uniformly sampled frames per video that the judge will receive.
+NUM_SAMPLED_FRAMES: int = 8
+
+
+# ---------------------------------------------------------------------------
+# Shared JSON output contract (response shape only — what the model must
+# return, regardless of which dimension it was asked about).
+# ---------------------------------------------------------------------------
+_JSON_OUTPUT_CONTRACT = """\
+Your output must be a valid JSON object and nothing else, in exactly \
+the following format:
+
+{
+  "reasoning": "<reasoning>",
+  "score": <score>
+}
+
+DO NOT include anything before or after the JSON object.\
+"""
+
+
+# ---------------------------------------------------------------------------
+# Per-dimension query bodies.
+# ---------------------------------------------------------------------------
+
+# (1) instruction_following  -- uses ${t2v_prompt}
+_IF_BODY = """\
+You are an expert for evaluating how well an AI-generated video \
+follows its text prompt.
+
+The video is given as ${n_frames} frames uniformly sampled in temporal \
+order (frame 1 = earliest, frame ${n_frames} = latest). Judge only \
+from these ${n_frames} frames.
+
+We evaluate the dimension 'instruction_following': how accurately and \
+completely the video follows the text prompt, including requested \
+subjects, attributes, actions, scene, style, camera/viewpoint, and \
+temporal event order.
+
+Text prompt:
+${t2v_prompt}
+
+Based on the video content, the text prompt, and the dimension \
+definition, please evaluate the video's instruction_following and \
+give the score. The score must be an integer in the range of 1 - 5. \
+FIRST give a brief reasoning, THEN give the score.
+
+""" + _JSON_OUTPUT_CONTRACT
+
+
+# (2) visual_quality  -- judged from frames; prompt shown as context only
+_VQ_BODY = """\
+You are an expert for evaluating the perceptual quality of \
+AI-generated videos.
+
+The video is given as ${n_frames} frames uniformly sampled in temporal \
+order (frame 1 = earliest, frame ${n_frames} = latest). Judge only \
+from these ${n_frames} frames.
+
+We evaluate the dimension 'visual_quality': the perceptual and \
+technical quality of the rendered video, including resolution, \
+overall and local clarity, sharpness or blurriness, brightness and \
+color stability, flicker, compression artifacts, and low-level visual \
+distortions that affect the viewing experience.
+
+Text prompt (context only):
+${t2v_prompt}
+
+The text prompt is provided so that you can recognize intentional \
+creative choices it requests (e.g. a stylized look, a non-realistic \
+scene, an unusual camera) and NOT penalize them on this dimension. \
+DO NOT judge how faithfully the video follows the prompt here -- \
+that is covered by a separate dimension.
+
+Based on the video content and the dimension definition, please \
+evaluate the video's visual_quality and give the score. The score \
+must be an integer in the range of 1 - 5. FIRST give a brief \
+reasoning, THEN give the score.
+
+""" + _JSON_OUTPUT_CONTRACT
+
+
+# (3) world_consistency  -- judged from frames; prompt shown as context only
+_WC_BODY = """\
+You are an expert for evaluating whether an AI-generated video is \
+coherent with the real world.
+
+The video is given as ${n_frames} frames uniformly sampled in temporal \
+order (frame 1 = earliest, frame ${n_frames} = latest). Judge only \
+from these ${n_frames} frames.
+
+We evaluate the dimension 'world_consistency': whether the video \
+contains any violations of everyday knowledge, common sense, or basic \
+physical laws, including temporal inconsistencies, unnatural or \
+incoherent motion, physically implausible interactions, and \
+structural abnormalities or deformities in objects or characters.
+
+Text prompt (context only):
+${t2v_prompt}
+
+The text prompt is provided so that you can recognize intentional \
+creative choices it requests (e.g. a non-realistic scene or a \
+deliberately fantastical setup) and NOT penalize them on this \
+dimension. DO NOT judge how faithfully the video follows the prompt \
+here -- that is covered by a separate dimension.
+
+Based on the video content and the dimension definition, please \
+evaluate the video's world_consistency and give the score. The score \
+must be an integer in the range of 1 - 5. FIRST give a brief \
+reasoning, THEN give the score.
+
+""" + _JSON_OUTPUT_CONTRACT
+
+
+# Pre-built per-dimension templates.
+VANILLA_QUERY_TEMPLATES: Dict[str, Template] = {
+    "instruction_following": Template(_IF_BODY),
+    "visual_quality":        Template(_VQ_BODY),
+    "world_consistency":     Template(_WC_BODY),
+}
+
+
+def build_query(
+    dimension: str,
+    t2v_prompt: Optional[str] = None,
+    n_frames: int = NUM_SAMPLED_FRAMES,
+) -> str:
+    """Render the single-dimension query for ``dimension``.
+
+    Parameters
+    ----------
+    dimension:
+        One of :data:`DIMENSIONS`.
+    t2v_prompt:
+        The text-to-video prompt. Required (non-empty) for all
+        dimensions: ``instruction_following`` evaluates the video
+        against it; ``visual_quality`` and ``world_consistency`` use
+        it as context only (see module docstring).
+    n_frames:
+        Number of uniformly sampled frames the judge will receive.
+    """
+    if dimension not in VANILLA_QUERY_TEMPLATES:
+        raise KeyError(
+            f"Unknown dimension: {dimension!r}. "
+            f"Expected one of {DIMENSIONS}."
+        )
+    if t2v_prompt is None or not str(t2v_prompt).strip():
+        raise ValueError(
+            f"`t2v_prompt` must be a non-empty string for "
+            f"dimension {dimension!r}."
+        )
+    return VANILLA_QUERY_TEMPLATES[dimension].substitute(
+        n_frames=int(n_frames),
+        t2v_prompt=str(t2v_prompt).strip(),
+    )
+
+
+def build_prompt(
+    dimension: str,
+    video_prompt: Optional[str] = None,
+    n_frames: int = NUM_SAMPLED_FRAMES,
+) -> Dict[str, str]:
+    """Build the (system, user) prompt pair for a single-dimension call.
+
+    The whole query is sent as the user message; no separate system
+    message is used (matches the original VS2 setup).
+
+    All three dimensions require a non-empty ``video_prompt``. For
+    ``visual_quality`` and ``world_consistency`` it is shown as
+    context only (see module docstring).
+
+    Returns
+    -------
+    Dict[str, str]
+        ``{"system": "", "user": <rendered_query>}``.
+    """
+    return {
+        "system": "",
+        "user": build_query(
+            dimension=dimension,
+            t2v_prompt=video_prompt,
+            n_frames=n_frames,
+        ),
+    }
+
+
+__all__ = [
+    "DIMENSIONS",
+    "DIMENSIONS_REQUIRING_PROMPT",
+    "NUM_SAMPLED_FRAMES",
+    "VANILLA_QUERY_TEMPLATES",
+    "build_query",
+    "build_prompt",
+]

scripts/_core.py

@@ -0,0 +1,419 @@
+"""Shared scoring core (per-dimension version).
+
+Backend-agnostic helpers for the vanilla video-reward pipeline. The
+``infer.py`` entry script handles CLI parsing and client construction;
+everything below is duck-typed on a client object exposing:
+
+    client.infer_with_frames(user_text, frame_b64_list, system_text)
+    client.max_retries          : int
+    client.retry_base_delay     : float
+    client.request_interval     : float
+
+Each video triggers ONE multimodal model call **per scoring dimension**
+(see ``prompts/vanilla_prompts.py``). For the canonical 3-dim setup that
+means up to 3 calls per video. Each reply must be a single JSON object
+of the form::
+
+    {"reasoning": "...", "score": <int 1-5>}
+
+The orchestrator aggregates the per-dimension replies into the SAME
+``scoring`` block layout used by the previous single-call pipeline, so
+all downstream consumers (``compute_mae.py``, the gradio app, etc.)
+keep working unchanged::
+
+    {
+      "dimensions": [
+        {"dimension": "instruction_following", "score": 4, "reasoning": "..."},
+        {"dimension": "visual_quality",        "score": 3, "reasoning": "..."},
+        {"dimension": "world_consistency",     "score": 5, "reasoning": "..."}
+      ],
+      "scores_by_dim": {
+        "instruction_following": 4,
+        "visual_quality": 3,
+        "world_consistency": 5
+      }
+    }
+
+Resumability
+------------
+Per-dimension calls are independent, so we can cache partial progress.
+Two layers are persisted under the same parent dir as ``score_path``:
+
+  * ``<score_path>``                — final results (only fully-scored
+                                      videos appear here, same schema as
+                                      before).
+  * ``<score_path>.partial.json``   — per-video, per-dim cache. Each
+                                      entry maps ``video_id`` to a dict
+                                      ``{dim: {"reasoning": str, "score": int}}``
+                                      containing only the dims that have
+                                      already succeeded.
+
+On rerun, fully-scored videos are skipped; partially-scored videos only
+re-issue the missing dimensions; failed videos are retried from scratch
+(of whatever is missing).
+"""
+from __future__ import annotations
+
+import os
+import sys
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Any, Optional
+
+from tqdm import tqdm
+
+# --- Path bootstrapping so we can import from `prompts/` and `tools/` -----
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.dirname(SCRIPT_DIR)
+for _p in (PROJECT_ROOT, os.path.join(PROJECT_ROOT, "prompts")):
+    if _p not in sys.path:
+        sys.path.insert(0, _p)
+
+from prompts.vanilla_prompts import (  # noqa: E402
+    DIMENSIONS,
+    NUM_SAMPLED_FRAMES,
+    build_prompt,
+)
+from tools import (  # noqa: E402
+    ensure_video_local,
+    extract_frames_from_video,
+    load_json_safe,
+    parse_json_from_model_output,
+    save_json_atomic,
+)
+
+# ---------------------------------------------------------------------------
+# Shared defaults
+# ---------------------------------------------------------------------------
+
+DEFAULT_DATA_PATH = os.path.join(PROJECT_ROOT, "data", "firm-video-bench.json")
+DEFAULT_RESULTS_DIR = os.path.join(PROJECT_ROOT, "results")
+
+VALID_SCORES = {1, 2, 3, 4, 5}
+
+
+# ---------------------------------------------------------------------------
+# Output normalization (per-dimension)
+# ---------------------------------------------------------------------------
+
+def _coerce_score(score_raw: Any) -> int:
+    if isinstance(score_raw, bool):  # bool is a subclass of int — reject
+        raise ValueError(f"score must be an integer, got bool: {score_raw}")
+    if isinstance(score_raw, int):
+        score = score_raw
+    elif isinstance(score_raw, float) and float(score_raw).is_integer():
+        score = int(score_raw)
+    elif isinstance(score_raw, str) and score_raw.strip().lstrip("-").isdigit():
+        score = int(score_raw.strip())
+    else:
+        raise ValueError(f"score must be an integer in 1-5, got: {score_raw!r}")
+    if score not in VALID_SCORES:
+        raise ValueError(f"score out of range 1-5: {score}")
+    return score
+
+
+def _normalize_single_dim_output(parsed: Any) -> dict[str, Any]:
+    """Validate the per-dimension JSON ``{"reasoning":..., "score":...}``."""
+    if not isinstance(parsed, dict):
+        raise ValueError(f"Expected JSON object, got {type(parsed).__name__}")
+    reasoning = parsed.get("reasoning", "")
+    if not isinstance(reasoning, str):
+        reasoning = str(reasoning)
+    score = _coerce_score(parsed.get("score"))
+    return {"reasoning": reasoning.strip(), "score": score}
+
+
+def _aggregate_scoring(
+    dim_results: dict[str, dict[str, Any]],
+) -> dict[str, Any]:
+    """Build the final ``scoring`` block from per-dimension results."""
+    dimensions_block = [
+        {
+            "dimension": dim,
+            "score": dim_results[dim]["score"],
+            "reasoning": dim_results[dim]["reasoning"],
+        }
+        for dim in DIMENSIONS
+    ]
+    scores_by_dim = {dim: dim_results[dim]["score"] for dim in DIMENSIONS}
+    return {
+        "dimensions": dimensions_block,
+        "scores_by_dim": scores_by_dim,
+    }
+
+
+def _sort_key(video_id: str) -> tuple[int, str]:
+    try:
+        return int(str(video_id).split("_", 1)[0]), str(video_id)
+    except Exception:  # noqa: BLE001
+        return 10**12, str(video_id)
+
+
+# ---------------------------------------------------------------------------
+# Per-dimension scoring (one model call per dimension)
+# ---------------------------------------------------------------------------
+
+def _score_one_dimension(
+    client: Any,
+    dimension: str,
+    video_prompt: Optional[str],
+    frame_b64_list: list[str],
+    video_id: str,
+) -> Optional[dict[str, Any]]:
+    """Issue ONE multimodal call for a single ``dimension``.
+
+    All three dimensions consume ``video_prompt``: ``instruction_following``
+    evaluates the video against it; ``visual_quality`` and
+    ``world_consistency`` use it as context only (see
+    ``prompts/vanilla_prompts.py``).
+
+    Returns ``{"reasoning": str, "score": int}`` on success or ``None``
+    after exhausting retries.
+    """
+    spec = build_prompt(
+        dimension=dimension,
+        video_prompt=video_prompt,
+        n_frames=len(frame_b64_list),
+    )
+    user_text = spec["user"]
+
+    last_err: Optional[str] = None
+    for attempt in range(client.max_retries):
+        try:
+            raw = client.infer_with_frames(
+                user_text=user_text,
+                frame_b64_list=frame_b64_list,
+                system_text=spec["system"],
+            )
+            parsed = parse_json_from_model_output(raw)
+            normalized = _normalize_single_dim_output(parsed)
+            print(
+                f"    [{video_id}::{dimension}] OK score={normalized['score']}"
+            )
+            return normalized
+        except Exception as exc:  # noqa: BLE001
+            last_err = str(exc)
+            print(
+                f"    [{video_id}::{dimension}] attempt "
+                f"{attempt + 1}/{client.max_retries} failed: {exc}"
+            )
+            if attempt < client.max_retries - 1:
+                time.sleep(client.retry_base_delay * (2 ** attempt))
+
+    print(
+        f"    [{video_id}::{dimension}] FAILED after "
+        f"{client.max_retries} attempts ({last_err})"
+    )
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Partial cache (per-dim) helpers
+# ---------------------------------------------------------------------------
+
+def _partial_path(score_path: str) -> str:
+    """Sidecar path for the per-dim partial cache."""
+    return score_path + ".partial.json"
+
+
+def _load_partial(score_path: str) -> dict[str, dict[str, dict[str, Any]]]:
+    """Load the per-video, per-dim cache, validating shape.
+
+    Returns ``{video_id: {dim: {"reasoning": str, "score": int}}}``.
+    Malformed entries are silently dropped.
+    """
+    raw = load_json_safe(_partial_path(score_path), default={})
+    if not isinstance(raw, dict):
+        return {}
+    out: dict[str, dict[str, dict[str, Any]]] = {}
+    for vid, dims in raw.items():
+        if not isinstance(dims, dict):
+            continue
+        clean: dict[str, dict[str, Any]] = {}
+        for dim, entry in dims.items():
+            if dim not in DIMENSIONS or not isinstance(entry, dict):
+                continue
+            try:
+                clean[dim] = _normalize_single_dim_output(entry)
+            except Exception:  # noqa: BLE001
+                continue
+        if clean:
+            out[str(vid)] = clean
+    return out
+
+
+def _save_partial(
+    score_path: str,
+    partial: dict[str, dict[str, dict[str, Any]]],
+) -> None:
+    save_json_atomic(partial, _partial_path(score_path))
+
+
+# ---------------------------------------------------------------------------
+# Pipeline
+# ---------------------------------------------------------------------------
+
+def run_scoring(
+    client: Any,
+    expanded_data: list[dict[str, Any]],
+    score_path: str,
+    concurrency: int,
+) -> None:
+    print("\n" + "=" * 72)
+    print("Vanilla per-dimension scoring (one model call per dim per video)")
+    print(f"Dimensions ({len(DIMENSIONS)}): {DIMENSIONS}")
+    print(f"Frames per video: {NUM_SAMPLED_FRAMES}")
+    print(f"Concurrency:      {concurrency} (videos in flight)")
+    print(f"Calls per video:  up to {len(DIMENSIONS)}")
+    print("=" * 72)
+
+    # Final results (fully-scored videos only).
+    results = load_json_safe(score_path, default=[])
+    if not isinstance(results, list):
+        results = []
+    result_by_id = {
+        r.get("video_id"): r for r in results if r.get("scoring") is not None
+    }
+
+    # Per-dim partial cache (covers BOTH not-yet-scored and partially-
+    # scored videos). Final results take precedence.
+    partial_by_id = _load_partial(score_path)
+    for vid in list(partial_by_id.keys()):
+        if vid in result_by_id:
+            partial_by_id.pop(vid, None)
+
+    todo = [
+        item for item in expanded_data if item["video_id"] not in result_by_id
+    ]
+    n_partial = sum(
+        1 for item in todo if partial_by_id.get(item["video_id"])
+    )
+    print(
+        f"[scoring] videos={len(expanded_data)}, "
+        f"done={len(result_by_id)}, remaining={len(todo)} "
+        f"(of which {n_partial} have partial per-dim progress)"
+    )
+    if not todo:
+        return
+
+    results_lock = threading.Lock()
+    partial_lock = threading.Lock()
+    fail_counter = {"n": 0}
+    fail_lock = threading.Lock()
+
+    def process_video(item: dict[str, Any]) -> None:
+        video_id = item["video_id"]
+        caption = item["caption"]
+        try:
+            video_path = ensure_video_local(item)
+            frame_b64_list = extract_frames_from_video(
+                video_path, num_frames=NUM_SAMPLED_FRAMES
+            )
+        except Exception as exc:  # noqa: BLE001
+            print(f"  [{video_id}] preparation failed: {exc}")
+            with fail_lock:
+                fail_counter["n"] += 1
+            return
+
+        # Start from any cached per-dim results for this video.
+        cached = dict(partial_by_id.get(video_id, {}))
+        missing_dims = [d for d in DIMENSIONS if d not in cached]
+        print(
+            f"  [{video_id}] scoring {video_path} "
+            f"({len(frame_b64_list)} frames; "
+            f"cached={len(cached)}/{len(DIMENSIONS)}, "
+            f"to_run={missing_dims})"
+        )
+
+        dim_results: dict[str, dict[str, Any]] = dict(cached)
+        # Run missing dims sequentially within a single video (keeps the
+        # client's retry/rate-limit semantics simple). Outer thread pool
+        # provides throughput across videos.
+        for dim in missing_dims:
+            single = _score_one_dimension(
+                client=client,
+                dimension=dim,
+                video_prompt=caption,
+                frame_b64_list=frame_b64_list,
+                video_id=video_id,
+            )
+            if single is None:
+                # Persist whatever succeeded so far, then bail on this video.
+                if dim_results:
+                    with partial_lock:
+                        partial_by_id[video_id] = dim_results
+                        _save_partial(score_path, partial_by_id)
+                with fail_lock:
+                    fail_counter["n"] += 1
+                time.sleep(client.request_interval)
+                return
+
+            dim_results[dim] = single
+
+            # Persist incrementally so a crash mid-video doesn't waste
+            # successful per-dim calls.
+            with partial_lock:
+                partial_by_id[video_id] = dict(dim_results)
+                _save_partial(score_path, partial_by_id)
+
+            # Light rate-limit between successive per-dim calls.
+            time.sleep(client.request_interval)
+
+        # All dimensions succeeded: assemble the final record.
+        scoring = _aggregate_scoring(dim_results)
+        result_item = {
+            "video_id": video_id,
+            "video_name": item["video_name"],
+            "caption": caption,
+            "video_path": item.get("video_path", ""),
+            "video_local_path": video_path,
+            "source": item.get("source", ""),
+            "source_index": item["source_index"],
+            "source_row_index": item.get("source_row_index"),
+            "metadata": item.get("metadata", {}),
+            "scoring": scoring,
+        }
+
+        with results_lock:
+            result_by_id[video_id] = result_item
+            ordered = [
+                result_by_id[k]
+                for k in sorted(result_by_id.keys(), key=_sort_key)
+            ]
+            save_json_atomic(ordered, score_path)
+
+        # Drop this video from the partial cache once it's fully done.
+        with partial_lock:
+            partial_by_id.pop(video_id, None)
+            _save_partial(score_path, partial_by_id)
+
+        dim_summary = " | ".join(
+            f"{d[:10]}={scoring['scores_by_dim'][d]}" for d in DIMENSIONS
+        )
+        print(f"  [{video_id}] OK {dim_summary}")
+
+    with ThreadPoolExecutor(max_workers=max(1, int(concurrency))) as pool:
+        futures = [pool.submit(process_video, item) for item in todo]
+        for _ in tqdm(
+            as_completed(futures), total=len(futures), desc="vanilla scoring"
+        ):
+            pass
+
+    print(
+        f"[scoring] saved={score_path}; "
+        f"partial_cache={_partial_path(score_path)}; "
+        f"failures/skips={fail_counter['n']}"
+    )
+
+
+__all__ = [
+    "DIMENSIONS",
+    "NUM_SAMPLED_FRAMES",
+    "VALID_SCORES",
+    "DEFAULT_DATA_PATH",
+    "DEFAULT_RESULTS_DIR",
+    "PROJECT_ROOT",
+    "SCRIPT_DIR",
+    "run_scoring",
+]

scripts/infer.py

@@ -0,0 +1,134 @@
+"""Vanilla scoring pipeline for a vLLM/OpenAI-compatible backend.
+
+Each video uses one model call per scoring dimension; strict per-dim
+JSON outputs are aggregated into the final ``scoring`` block. This entry
+talks to an OpenAI-compatible ``/v1/chat/completions`` endpoint.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+
+from _core import (
+    DEFAULT_DATA_PATH,
+    DEFAULT_RESULTS_DIR,
+    run_scoring,
+)
+from tools import VLLMClient, load_pointwise_data
+
+# ---------------------------------------------------------------------------
+# Defaults
+# ---------------------------------------------------------------------------
+
+DEFAULT_TAG = "infer"
+DEFAULT_SCORE_OUTPUT = os.path.join(
+    DEFAULT_RESULTS_DIR, f"{DEFAULT_TAG}_scores.json"
+)
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Vanilla video reward scoring pipeline (per-dimension, "
+            "3 dims = 3 calls/video) — local vLLM OpenAI-compatible "
+            "backend."
+        )
+    )
+    parser.add_argument("--data", type=str, default=DEFAULT_DATA_PATH)
+    parser.add_argument("--score_output", type=str, default=DEFAULT_SCORE_OUTPUT)
+    parser.add_argument(
+        "--num_samples",
+        type=str,
+        default="all",
+        help="Number of input videos, or 'all'",
+    )
+    parser.add_argument(
+        "--concurrency",
+        type=int,
+        default=32,
+        help="Max concurrent worker threads (videos in flight). Each "
+        "video issues one model call per scoring dimension; the per-dim "
+        "calls run sequentially within a video.",
+    )
+
+    # vLLM connection / generation params
+    parser.add_argument(
+        "--vllm_base_url",
+        type=str,
+        default=os.environ.get("VLLM_BASE_URL", "http://127.0.0.1:8000/v1"),
+        help="vLLM OpenAI base URL, e.g. http://127.0.0.1:8000/v1",
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        default=os.environ.get("VLLM_MODEL", "Qwen3-VL-8B-Instruct"),
+        help="Served model name for vLLM backend",
+    )
+    parser.add_argument(
+        "--api_key",
+        type=str,
+        default=os.environ.get("VLLM_API_KEY", "EMPTY"),
+        help="OpenAI-compatible API key; vLLM usually accepts EMPTY",
+    )
+    parser.add_argument("--max_tokens", type=int, default=2048)
+    parser.add_argument("--temperature", type=float, default=0.0)
+    parser.add_argument("--top_p", type=float, default=None)
+    parser.add_argument(
+        "--request_interval",
+        type=float,
+        default=0.0,
+        help="Sleep seconds between successive videos on the same worker.",
+    )
+    parser.add_argument("--max_retries", type=int, default=3)
+    parser.add_argument("--retry_base_delay", type=float, default=2.0)
+    parser.add_argument("--request_timeout", type=int, default=300)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+
+    print(f"[vllm] base_url: {args.vllm_base_url}")
+    print(f"[vllm] model:    {args.model}")
+    print(
+        f"[vllm] max_tokens={args.max_tokens}, "
+        f"temperature={args.temperature}, top_p={args.top_p}"
+    )
+
+    _, expanded_data = load_pointwise_data(
+        data_path=args.data,
+        num_samples=args.num_samples,
+    )
+
+    client = VLLMClient(
+        base_url=args.vllm_base_url,
+        model_name=args.model,
+        api_key=args.api_key,
+        max_tokens=args.max_tokens,
+        temperature=args.temperature,
+        top_p=args.top_p,
+        request_interval=args.request_interval,
+        max_retries=args.max_retries,
+        retry_base_delay=args.retry_base_delay,
+        request_timeout=args.request_timeout,
+    )
+
+    run_scoring(
+        client=client,
+        expanded_data=expanded_data,
+        score_path=args.score_output,
+        concurrency=args.concurrency,
+    )
+
+    print("\n" + "=" * 72)
+    print("DONE")
+    print(f"Scores:  {args.score_output}")
+    print("=" * 72)
+
+
+if __name__ == "__main__":
+    main()

scripts/infer.sh

@@ -0,0 +1,102 @@
+#!/usr/bin/env bash
+# ======================================================================
+#  Vanilla Video Reward Pipeline — vLLM/OpenAI-compatible backend,
+#  per-dimension scoring (3 dims):
+#      - instruction_following
+#      - visual_quality
+#      - world_consistency
+#  Definitions live in ../prompts/definitions.md.
+#
+#  For every video, the model is called once per scoring dimension and
+#  asked to first reason, then assign an integer score in 1..5.
+#
+#  Input data: a point-wise benchmark JSON whose ``video_path`` field is
+#  resolved relative to the JSON's directory.
+#
+#  Start a vLLM OpenAI-compatible server in another terminal first.
+#
+#  Usage:
+#    bash infer.sh
+#    bash infer.sh 50
+#    bash infer.sh all 12 my_run
+#    bash infer.sh all 12 my_run /path/data.json
+#
+#    $1 num_samples        : number of videos or 'all' (default: all)
+#    $2 concurrency        : default 32
+#    $3 output tag         : default infer
+#    $4 data json path     : default ../data/firm-video-bench.json
+#    $5 vLLM base URL      : default http://127.0.0.1:8000/v1
+#    $6 served model name  : default Qwen3-VL-8B-Instruct
+# ======================================================================
+
+set -euo pipefail
+
+NUM_SAMPLES="${1:-all}"
+CONCURRENCY="${2:-32}"
+TAG="${3:-infer}"
+DATA="${4:-}"
+VLLM_BASE_URL="${5:-${VLLM_BASE_URL:-http://127.0.0.1:8000/v1}}"
+VLLM_MODEL="${6:-${VLLM_MODEL:-Qwen3-VL-8B-Instruct}}"
+VLLM_API_KEY="${VLLM_API_KEY:-EMPTY}"
+VLLM_MAX_TOKENS="${VLLM_MAX_TOKENS:-4096}"
+VLLM_TEMPERATURE="${VLLM_TEMPERATURE:-0}"
+VLLM_REQUEST_INTERVAL="${VLLM_REQUEST_INTERVAL:-0.0}"
+VLLM_MAX_RETRIES="${VLLM_MAX_RETRIES:-3}"
+VLLM_RETRY_BASE_DELAY="${VLLM_RETRY_BASE_DELAY:-2.0}"
+VLLM_REQUEST_TIMEOUT="${VLLM_REQUEST_TIMEOUT:-300}"
+
+if [[ "${VLLM_BASE_URL}" != */v1 ]]; then
+    VLLM_BASE_URL="${VLLM_BASE_URL%/}/v1"
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+
+if [ -z "${DATA}" ]; then
+    DATA="${PROJECT_ROOT}/data/firm-video-bench.json"
+fi
+
+RESULTS_DIR="${PROJECT_ROOT}/results"
+SCORE_JSON="${RESULTS_DIR}/${TAG}_scores.json"
+
+mkdir -p "${RESULTS_DIR}"
+
+if command -v curl >/dev/null 2>&1; then
+    if ! curl -fsS "${VLLM_BASE_URL}/models" >/dev/null; then
+        echo "Cannot reach vLLM endpoint: ${VLLM_BASE_URL}" >&2
+        echo "Please start a vLLM OpenAI-compatible server first." >&2
+        exit 1
+    fi
+fi
+
+echo "============================================================"
+echo "  Vanilla Pipeline (vLLM/OpenAI-compatible, 3 dims, per-dim calls)"
+echo "============================================================"
+echo "  vLLM base:    ${VLLM_BASE_URL}"
+echo "  Model:        ${VLLM_MODEL}"
+echo "  Data:         ${DATA}"
+echo "  Num samples:  ${NUM_SAMPLES} (videos)"
+echo "  Concurrency:  ${CONCURRENCY}"
+echo "  Max tokens:   ${VLLM_MAX_TOKENS}"
+echo "  Temperature:  ${VLLM_TEMPERATURE}"
+echo "  Scores:       ${SCORE_JSON}"
+echo "============================================================"
+
+python "${SCRIPT_DIR}/infer.py" \
+    --data "${DATA}" \
+    --score_output "${SCORE_JSON}" \
+    --num_samples "${NUM_SAMPLES}" \
+    --concurrency "${CONCURRENCY}" \
+    --vllm_base_url "${VLLM_BASE_URL}" \
+    --model "${VLLM_MODEL}" \
+    --api_key "${VLLM_API_KEY}" \
+    --max_tokens "${VLLM_MAX_TOKENS}" \
+    --temperature "${VLLM_TEMPERATURE}" \
+    --request_interval "${VLLM_REQUEST_INTERVAL}" \
+    --max_retries "${VLLM_MAX_RETRIES}" \
+    --retry_base_delay "${VLLM_RETRY_BASE_DELAY}" \
+    --request_timeout "${VLLM_REQUEST_TIMEOUT}"
+
+echo ""
+echo "Done!"
+echo "  Scores:  ${SCORE_JSON}"

scripts/metric.py

@@ -0,0 +1,261 @@
+"""Compute Metrics between model scores and human-labeled scores.
+
+Ground truth is loaded from the point-wise sampled file, where each item
+exposes top-level fields ``if_score`` / ``vq_score`` / ``wc_score`` keyed by
+``video_name``.
+"""
+import argparse
+import json
+from pathlib import Path
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+PROJECT_ROOT = SCRIPT_DIR.parent
+DEFAULT_RESULTS_DIR = PROJECT_ROOT / "results"
+DEFAULT_GT_FILE = PROJECT_ROOT / "data" / "firm-video-bench.json"
+
+MODEL_FILES = {
+    "gemini-3.1-pro": "gemini31pro_scores.json",
+    "gpt5": "gpt5_scores.json",
+    "seed-2.0-lite": "seed20lite_scores.json",
+    "qwen3vl-8b": "qwen3vl8b_scores.json",
+    "qwen3vl-30b": "qwen3vl30ba3b_scores.json",
+    "qwen3vl-235b": "qwen3vl235ba22b_scores.json",
+    "internvl3-8b": "internvl3-8b_scores.json",
+    "internvl3-38b": "internvl3-38b_scores.json",
+    "firm-video-8b-qwen3vl": "firm-video-qwen3vl_scores.json",
+    "firm-video-8b-internvl3": "firm-video-internvl3_scores.json"
+}
+
+# model dimension -> ground-truth key in GT_FILE
+DIM_MAP = {
+    "instruction_following": "if_score",
+    "visual_quality": "vq_score",
+    "world_consistency": "wc_score",
+}
+
+
+def load(path):
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def load_gt(path):
+    """Return dict: video_name -> {if_score, vq_score, wc_score}."""
+    gt = {}
+    for item in load(path):
+        key = item.get("video_name")
+        if not key:
+            continue
+        gt[key] = {k: item.get(k) for k in DIM_MAP.values()}
+    return gt
+
+
+def _std(abs_errors):
+    """绝对误差 |pred - human| 的样本标准差（围绕 MAE 的波动，ddof=1）。"""
+    m = len(abs_errors)
+    if m <= 1:
+        return None
+    mean_err = sum(abs_errors) / m
+    return (sum((e - mean_err) ** 2 for e in abs_errors) / (m - 1)) ** 0.5
+
+
+def _accuracy(abs_errors):
+    """预测与 human GT 完全相等的比例。"""
+    if not abs_errors:
+        return None
+    return sum(1 for e in abs_errors if e == 0) / len(abs_errors)
+
+
+def _relaxed_accuracy(abs_errors):
+    """预测与 human GT 相差不超过 1 的比例。"""
+    if not abs_errors:
+        return None
+    return sum(1 for e in abs_errors if e <= 1) / len(abs_errors)
+
+
+def _rankdata(values):
+    """返回带 ties 平均秩（1-based）的秩数组。"""
+    order = sorted(range(len(values)), key=lambda i: values[i])
+    ranks = [0.0] * len(values)
+    i = 0
+    while i < len(values):
+        j = i
+        while j + 1 < len(values) and values[order[j + 1]] == values[order[i]]:
+            j += 1
+        avg_rank = (i + j) / 2.0 + 1.0
+        for k in range(i, j + 1):
+            ranks[order[k]] = avg_rank
+        i = j + 1
+    return ranks
+
+
+def _spearman(pairs):
+    """Spearman 秩相关系数（对秩做 Pearson，含 ties 处理）。pairs: [(pred, human)]。"""
+    n = len(pairs)
+    if n < 2:
+        return None
+    xs = [p for p, _ in pairs]
+    ys = [h for _, h in pairs]
+    rx = _rankdata(xs)
+    ry = _rankdata(ys)
+    mean_rx = sum(rx) / n
+    mean_ry = sum(ry) / n
+    cov = sum((a - mean_rx) * (b - mean_ry) for a, b in zip(rx, ry))
+    var_x = sum((a - mean_rx) ** 2 for a in rx)
+    var_y = sum((b - mean_ry) ** 2 for b in ry)
+    denom = (var_x * var_y) ** 0.5
+    if denom == 0:
+        return None
+    return cov / denom
+
+
+def compute_mae(items, gt):
+    """Return per-dimension (MAE, std, N), overall (MAE, std) and extra metrics.
+
+    extra 部分返回 per-dimension 的 (accuracy, relaxed_accuracy, spearman)，
+    overall 仅返回 (accuracy, relaxed_accuracy)。
+    """
+    diffs = {dim: [] for dim in DIM_MAP}
+    pairs = {dim: [] for dim in DIM_MAP}
+    missing = 0
+    for item in items:
+        key = item.get("video_name")
+        human_scores = gt.get(key)
+        if human_scores is None:
+            missing += 1
+            continue
+        dims = {
+            d["dimension"]: d.get("score")
+            for d in item.get("scoring", {}).get("dimensions", [])
+        }
+        for model_dim, gt_key in DIM_MAP.items():
+            human = human_scores.get(gt_key)
+            pred = dims.get(model_dim)
+            if human is None or pred is None:
+                missing += 1
+                continue
+            try:
+                pv = float(pred)
+                hv = float(human)
+            except (TypeError, ValueError):
+                missing += 1
+                continue
+            diffs[model_dim].append(abs(pv - hv))
+            pairs[model_dim].append((pv, hv))
+
+    per_dim = {
+        dim: (sum(v) / len(v) if v else None, _std(v), len(v))
+        for dim, v in diffs.items()
+    }
+    all_diffs = [x for v in diffs.values() for x in v]
+    overall = sum(all_diffs) / len(all_diffs) if all_diffs else None
+    overall_std = _std(all_diffs)
+
+    per_dim_extra = {
+        dim: (_accuracy(diffs[dim]), _relaxed_accuracy(diffs[dim]), _spearman(pairs[dim]))
+        for dim in DIM_MAP
+    }
+    overall_extra = (
+        _accuracy(all_diffs),
+        _relaxed_accuracy(all_diffs),
+    )
+    return per_dim, overall, overall_std, per_dim_extra, overall_extra, missing, len(items)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Compute metrics between model scores and human-labeled scores."
+    )
+    parser.add_argument(
+        "--gt_file",
+        type=str,
+        default=str(DEFAULT_GT_FILE),
+        help="Ground-truth JSON file with if_score/vq_score/wc_score fields.",
+    )
+    parser.add_argument(
+        "--results_dir",
+        type=str,
+        default=str(DEFAULT_RESULTS_DIR),
+        help="Directory containing model score JSON files.",
+    )
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    gt_file = Path(args.gt_file).expanduser()
+    results_dir = Path(args.results_dir).expanduser()
+
+    if not gt_file.exists():
+        print(f"GT file not found: {gt_file}")
+        return
+    gt = load_gt(gt_file)
+    print(f"Loaded {len(gt)} GT entries from {gt_file}")
+
+    fmt = lambda x: f"{x:.4f}" if x is not None else "  N/A "
+    header = (
+        f"{'Model':<12} {'N':>4} "
+        f"{'IF':>10} {'IF_std':>10} "
+        f"{'PQ':>10} {'PQ_std':>10} "
+        f"{'WC':>10} {'WC_std':>10} "
+        f"{'Overall':>10} {'Ovr_std':>10} {'missing':>8}"
+    )
+    print(header)
+    print("-" * len(header))
+
+    # 收集每个模型的额外指标
+    extra_rows = []
+    for name, fname in MODEL_FILES.items():
+        path = results_dir / fname
+        if not path.exists():
+            print(f"{name}: file not found: {path}")
+            continue
+        items = load(path)
+        (per_dim, overall, overall_std, per_dim_extra,
+         overall_extra, missing, n) = compute_mae(items, gt)
+        if_mae, if_std, _ = per_dim["instruction_following"]
+        vq_mae, vq_std, _ = per_dim["visual_quality"]
+        wc_mae, wc_std, _ = per_dim["world_consistency"]
+        print(
+            f"{name:<12} {n:>4} "
+            f"{fmt(if_mae):>10} {fmt(if_std):>10} "
+            f"{fmt(vq_mae):>10} {fmt(vq_std):>10} "
+            f"{fmt(wc_mae):>10} {fmt(wc_std):>10} "
+            f"{fmt(overall):>10} {fmt(overall_std):>10} {missing:>8}"
+        )
+        extra_rows.append((name, per_dim_extra, overall_extra))
+
+    # ---- 额外指标：accuracy / relaxed accuracy / spearman ----
+    if extra_rows:
+        print("\n== Extra metrics: Accuracy(=) / Relaxed(|d|<=1) / Spearman ==")
+        extra_header = (
+            f"{'Model':<12} "
+            f"{'IF_acc':>8} {'IF_racc':>8} {'IF_spr':>8} "
+            f"{'PQ_acc':>8} {'PQ_racc':>8} {'PQ_spr':>8} "
+            f"{'WC_acc':>8} {'WC_racc':>8} {'WC_spr':>8} "
+            f"{'Ovr_acc':>8} {'Ovr_racc':>8}"
+        )
+        print(extra_header)
+        print("-" * len(extra_header))
+        for name, per_dim_extra, overall_extra in extra_rows:
+            if_acc, if_racc, if_spr = per_dim_extra["instruction_following"]
+            vq_acc, vq_racc, vq_spr = per_dim_extra["visual_quality"]
+            wc_acc, wc_racc, wc_spr = per_dim_extra["world_consistency"]
+            ovr_acc, ovr_racc = overall_extra
+            print(
+                f"{name:<12} "
+                f"{fmt(if_acc):>8} {fmt(if_racc):>8} {fmt(if_spr):>8} "
+                f"{fmt(vq_acc):>8} {fmt(vq_racc):>8} {fmt(vq_spr):>8} "
+                f"{fmt(wc_acc):>8} {fmt(wc_racc):>8} {fmt(wc_spr):>8} "
+                f"{fmt(ovr_acc):>8} {fmt(ovr_racc):>8}"
+            )
+
+    print("\nDimension mapping: instruction_following<->if_score, "
+          "perceptual quality (PQ; input: visual_quality<->vq_score), "
+          "world_coherence<->wc_score")
+    print("std = 模型打分绝对误差|pred - human|的样本标准差(ddof=1)")
+    print("acc = 完全相等准确率; racc = 相差<=1准确率; spr = Spearman秩相关系数")
+
+
+if __name__ == "__main__":
+    main()

tools/__init__.py

@@ -0,0 +1,33 @@
+"""Reusable utilities for the open vLLM benchmark pipeline.
+
+Public sub-modules:
+    - io_utils    : safe JSON load/save + JSON parsing from messy LLM outputs.
+    - frames      : uniform frame sampling from a video to base64 JPEGs.
+    - data_loader : point-wise benchmark JSON loader.
+    - vllm_client : OpenAI-compatible HTTP client for a vLLM server.
+"""
+from .io_utils import (
+    load_json_safe,
+    save_json_atomic,
+    parse_json_from_model_output,
+)
+from .frames import (
+    DEFAULT_NUM_SAMPLE_FRAMES,
+    extract_frames_from_video,
+)
+from .data_loader import (
+    load_pointwise_data,
+    ensure_video_local,
+)
+from .vllm_client import VLLMClient
+
+__all__ = [
+    "load_json_safe",
+    "save_json_atomic",
+    "parse_json_from_model_output",
+    "DEFAULT_NUM_SAMPLE_FRAMES",
+    "extract_frames_from_video",
+    "load_pointwise_data",
+    "ensure_video_local",
+    "VLLMClient",
+]

tools/data_loader.py

@@ -0,0 +1,134 @@
+"""Point-wise benchmark JSON loader.
+
+The expected schema is a flat JSON list of records of the form::
+
+    {
+      "video_name": "000434_c.mp4",
+      "video_path": "videos/000434_c.mp4",   # relative to the JSON file
+      "prompt": "...",
+      "source": "vs2",
+      "metadata": {
+        "visual_score": 4,
+        "t2v_score": 4,
+        "phy_score": 4
+      }
+    }
+
+``video_path`` is interpreted relative to the directory that contains the
+JSON file (and may also be absolute).
+"""
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Tuple
+
+
+def _json_records(payload: Any, data_path: str) -> list[dict[str, Any]]:
+    if not isinstance(payload, list):
+        raise ValueError(
+            f"JSON data must be a list of records: {data_path} "
+            f"(got {type(payload).__name__})"
+        )
+    if not all(isinstance(item, dict) for item in payload):
+        raise ValueError(f"JSON data must contain objects only: {data_path}")
+    return payload
+
+
+def _resolve_video_path(base_dir: str, video_path: str) -> str:
+    """Resolve a record's ``video_path`` against the JSON file's directory."""
+    if not isinstance(video_path, str) or not video_path:
+        return ""
+    if os.path.isabs(video_path):
+        return video_path
+    return os.path.normpath(os.path.join(base_dir, video_path))
+
+
+def load_pointwise_data(
+    data_path: str,
+    num_samples: str = "all",
+) -> Tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    """Load a point-wise benchmark JSON.
+
+    Parameters
+    ----------
+    data_path : str
+        Path to the benchmark JSON file.
+    num_samples : str
+        Either ``"all"`` or a positive integer (as a string) capping the
+        number of records.
+
+    Returns
+    -------
+    (raw_prompts, expanded)
+        raw_prompts : list of de-duplicated prompts with their source row
+                      indices (handy for any prompt-level step).
+        expanded    : list of per-video records ready for scoring.
+    """
+    data_path = os.path.abspath(data_path)
+    base_dir = os.path.dirname(data_path)
+
+    with open(data_path, "r", encoding="utf-8") as f:
+        records = _json_records(json.load(f), data_path)
+    print(f"[data] Loaded {len(records)} videos from {data_path}")
+
+    if num_samples != "all":
+        records = records[: int(num_samples)]
+        print(f"[data] Truncated to {len(records)} videos")
+
+    prompt_to_index: dict[str, int] = {}
+    raw_prompts: list[dict[str, Any]] = []
+    expanded: list[dict[str, Any]] = []
+
+    for row_idx, item in enumerate(records):
+        video_name = str(item["video_name"])
+        prompt_text = str(item["prompt"])
+        source_index = prompt_to_index.get(prompt_text)
+        if source_index is None:
+            source_index = len(raw_prompts)
+            prompt_to_index[prompt_text] = source_index
+            raw_prompts.append(
+                {"prompt": prompt_text, "prompt_id": source_index, "source_rows": []}
+            )
+        raw_prompts[source_index]["source_rows"].append(row_idx)
+
+        rel_video_path = item.get("video_path", "")
+        local_path = _resolve_video_path(base_dir, rel_video_path)
+        source = str(item.get("source", "")).strip()
+        metadata = item.get("metadata", {}) or {}
+        if not isinstance(metadata, dict):
+            metadata = {}
+
+        expanded.append(
+            {
+                "video_id": f"{row_idx}_{os.path.splitext(video_name)[0]}",
+                "video_name": video_name,
+                "caption": prompt_text,
+                "video_path": rel_video_path,
+                "video_local_path": local_path,
+                "source": source,
+                "source_index": source_index,
+                "source_row_index": row_idx,
+                "metadata": metadata,
+            }
+        )
+
+    print(
+        f"[data] Unique prompts: {len(raw_prompts)}; videos to score: {len(expanded)}"
+    )
+    return raw_prompts, expanded
+
+
+def ensure_video_local(item: dict[str, Any]) -> str:
+    """Validate that the local video file exists; return its absolute path."""
+    local_path = item.get("video_local_path")
+    if (
+        isinstance(local_path, str)
+        and local_path
+        and os.path.exists(local_path)
+        and os.path.getsize(local_path) > 0
+    ):
+        return local_path
+    raise FileNotFoundError(
+        f"Video not found: {local_path or item.get('video_name')}"
+    )

tools/frames.py

@@ -0,0 +1,72 @@
+"""Uniform frame sampling from a video into base64-encoded JPEG strings."""
+from __future__ import annotations
+
+import base64
+import io
+import os
+
+import cv2
+from PIL import Image
+
+DEFAULT_NUM_SAMPLE_FRAMES: int = 8
+
+
+def extract_frames_from_video(
+    video_path: str,
+    num_frames: int = DEFAULT_NUM_SAMPLE_FRAMES,
+    jpeg_quality: int = 90,
+    verbose: bool = True,
+) -> list[str]:
+    """Uniformly sample frames from a video and return them as base64 JPEGs.
+
+    Returns
+    -------
+    list[str]
+        Base64-encoded JPEG strings, in temporal order
+        (frame 1 = earliest, frame N = latest).
+    """
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise RuntimeError(f"Cannot open video: {video_path}")
+
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    if fps <= 0 or total_frames <= 0:
+        cap.release()
+        raise RuntimeError(
+            f"Invalid video metadata: fps={fps}, total_frames={total_frames}"
+        )
+
+    duration = total_frames / fps
+    num_to_sample = max(1, min(int(num_frames), total_frames))
+    if num_to_sample == 1:
+        sample_indices = [0]
+    else:
+        sample_indices = [
+            int(round(i * (total_frames - 1) / (num_to_sample - 1)))
+            for i in range(num_to_sample)
+        ]
+
+    frame_b64_list: list[str] = []
+    for frame_idx in sample_indices:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
+        ret, frame = cap.read()
+        if not ret:
+            continue
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        img = Image.fromarray(frame_rgb)
+        buf = io.BytesIO()
+        img.save(buf, format="JPEG", quality=int(jpeg_quality))
+        frame_b64_list.append(base64.b64encode(buf.getvalue()).decode("utf-8"))
+
+    cap.release()
+    if not frame_b64_list:
+        raise RuntimeError(f"Failed to extract any frames from {video_path}")
+
+    if verbose:
+        print(
+            f"  [frames] Extracted {len(frame_b64_list)} frames from "
+            f"{os.path.basename(video_path)} "
+            f"(duration={duration:.1f}s, fps={fps:.1f})"
+        )
+    return frame_b64_list

tools/io_utils.py

@@ -0,0 +1,65 @@
+"""I/O utilities: safe JSON read/write and lenient JSON parsing
+of LLM outputs (handles ```json fences, trailing prose, etc.)."""
+from __future__ import annotations
+
+import json
+import os
+import re
+from typing import Any
+
+
+def load_json_safe(path: str, default: Any) -> Any:
+    """Load JSON if file exists; otherwise return ``default``."""
+    if os.path.exists(path):
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    return default
+
+
+def save_json_atomic(data: Any, path: str) -> None:
+    """Atomic JSON save (write to .tmp then rename), creates parent dir."""
+    parent = os.path.dirname(path) or "."
+    os.makedirs(parent, exist_ok=True)
+    tmp_path = f"{path}.tmp"
+    with open(tmp_path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+    os.replace(tmp_path, path)
+
+
+def parse_json_from_model_output(output_text: str) -> dict[str, Any]:
+    """Best-effort extraction of a JSON object from a model response.
+
+    Order of attempts:
+        1. ```json ... ``` fenced block.
+        2. ``` ... ``` fenced block whose content starts with '{'.
+        3. Substring between the first '{' and the last '}'.
+    """
+    text = (output_text or "").strip()
+
+    match = re.search(r"```json\s*(.*?)\s*```", text, re.DOTALL)
+    if match:
+        try:
+            return json.loads(match.group(1))
+        except json.JSONDecodeError:
+            pass
+
+    match = re.search(r"```\s*(.*?)\s*```", text, re.DOTALL)
+    if match:
+        candidate = match.group(1).strip()
+        if candidate.startswith("{"):
+            try:
+                return json.loads(candidate)
+            except json.JSONDecodeError:
+                pass
+
+    first_brace = text.find("{")
+    last_brace = text.rfind("}")
+    if first_brace != -1 and last_brace > first_brace:
+        try:
+            return json.loads(text[first_brace : last_brace + 1])
+        except json.JSONDecodeError:
+            pass
+
+    raise ValueError(
+        f"Failed to extract valid JSON from model output. Preview: {text[:300]}..."
+    )

tools/vllm_client.py

@@ -0,0 +1,169 @@
+"""OpenAI-compatible HTTP client for a vLLM server.
+
+The wire format uses the standard OpenAI ``/v1/chat/completions`` schema.
+Frames are sent inline as base64 ``data:`` URLs.
+"""
+from __future__ import annotations
+
+import json
+import time
+from typing import Any, Optional
+
+import requests
+
+
+class VLLMClient:
+    """OpenAI-compatible client backed by a vLLM server."""
+
+    def __init__(
+        self,
+        base_url: str,
+        model_name: str,
+        api_key: str = "EMPTY",
+        max_tokens: int = 2048,
+        temperature: float = 0.0,
+        top_p: Optional[float] = None,
+        request_interval: float = 0.0,
+        max_retries: int = 3,
+        retry_base_delay: float = 2.0,
+        request_timeout: int = 300,
+    ) -> None:
+        base_url = (base_url or "").rstrip("/")
+        if not base_url.endswith("/v1"):
+            base_url = f"{base_url}/v1"
+        self.base_url = base_url
+        self.model_name = model_name
+        self.max_tokens = int(max_tokens)
+        self.temperature = float(temperature)
+        self.top_p = top_p
+        self.request_interval = float(request_interval)
+        self.max_retries = int(max_retries)
+        self.retry_base_delay = float(retry_base_delay)
+        self.request_timeout = int(request_timeout)
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key or 'EMPTY'}",
+        }
+
+    # ------------------------------------------------------------------
+    # Public inference entry points
+    # ------------------------------------------------------------------
+
+    def infer_text_only(
+        self,
+        user_text: str,
+        system_text: Optional[str] = None,
+    ) -> str:
+        messages = self._build_messages(
+            user_content=[{"type": "text", "text": user_text}],
+            system_text=system_text,
+        )
+        return self._infer(messages)
+
+    def infer_with_frames(
+        self,
+        user_text: str,
+        frame_b64_list: list[str],
+        system_text: Optional[str] = None,
+    ) -> str:
+        content_parts: list[dict[str, Any]] = []
+        for frame_b64 in frame_b64_list:
+            content_parts.append(
+                {
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/jpeg;base64,{frame_b64}"},
+                }
+            )
+        content_parts.append({"type": "text", "text": user_text})
+        messages = self._build_messages(
+            user_content=content_parts, system_text=system_text
+        )
+        return self._infer(messages)
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _build_messages(
+        user_content: list[dict[str, Any]],
+        system_text: Optional[str],
+    ) -> list[dict[str, Any]]:
+        messages: list[dict[str, Any]] = []
+        if system_text and system_text.strip():
+            messages.append(
+                {
+                    "role": "system",
+                    "content": [{"type": "text", "text": system_text}],
+                }
+            )
+        messages.append({"role": "user", "content": user_content})
+        return messages
+
+    def _infer(self, messages: list[dict[str, Any]]) -> str:
+        url = f"{self.base_url}/chat/completions"
+        payload: dict[str, Any] = {
+            "model": self.model_name,
+            "messages": messages,
+            "max_tokens": self.max_tokens,
+            "temperature": self.temperature,
+        }
+        if self.top_p is not None:
+            payload["top_p"] = self.top_p
+
+        resp = self._post_with_retry(url, payload)
+        data = resp.json()
+        if data.get("error"):
+            raise RuntimeError(f"vLLM API error: {data['error']}")
+
+        choices = data.get("choices", [])
+        if not choices:
+            raise RuntimeError(
+                "vLLM API returned no choices: "
+                f"{json.dumps(data, ensure_ascii=False)[:500]}"
+            )
+
+        content = choices[0].get("message", {}).get("content", "")
+        if isinstance(content, str) and content.strip():
+            return content
+        if isinstance(content, list):
+            text_parts = [
+                part.get("text", "")
+                for part in content
+                if isinstance(part, dict)
+            ]
+            text = "\n".join(p for p in text_parts if p)
+            if text.strip():
+                return text
+
+        raise RuntimeError(
+            "No text found in vLLM response: "
+            f"{json.dumps(data, ensure_ascii=False)[:500]}"
+        )
+
+    def _post_with_retry(
+        self, url: str, payload: dict[str, Any]
+    ) -> requests.Response:
+        last_exc: Optional[Exception] = None
+        for attempt in range(self.max_retries):
+            try:
+                resp = requests.post(
+                    url,
+                    headers=self.headers,
+                    json=payload,
+                    timeout=self.request_timeout,
+                )
+                resp.raise_for_status()
+                return resp
+            except Exception as exc:  # noqa: BLE001
+                last_exc = exc
+                if attempt < self.max_retries - 1:
+                    delay = self.retry_base_delay * (2 ** attempt)
+                    print(
+                        f"  [vllm retry] attempt {attempt + 1}/"
+                        f"{self.max_retries} failed: {exc}; sleep {delay:.1f}s"
+                    )
+                    time.sleep(delay)
+        raise RuntimeError(
+            f"vLLM request failed after {self.max_retries} attempts: {last_exc}"
+        )