add code/

code/exp/config.yaml

@@ -0,0 +1,13 @@
+# trimmed config for the off-cluster run package; the data roots come from BENCH_BASE (common.py)
+paths:
+  base: /replace/with/BENCH_BASE
+  work: /replace/with/BENCH_BASE/work
+  store: /replace/with/BENCH_BASE/store
+limits:
+  work_dir_limit_gb: 100000
+  store_limit_gb: 100000
+models:
+  diag_v: Qwen/Qwen3-VL-8B-Instruct
+normalize:
+  max_frames: 1024
+  too_short_frames: 32

code/exp/pipeline/common.py

@@ -0,0 +1,347 @@
+"""Shared infra: config, disk guard, manifest, failures, remote-zip access."""
+import hashlib
+import json
+import os
+import subprocess
+import time
+import zipfile
+
+import yaml
+
+CFG = yaml.safe_load(open(os.path.join(os.path.dirname(__file__), "..", "config.yaml")))
+# BENCH_BASE / BENCH_WORK / BENCH_STORE (2026-09-07): relocate the data roots for off-cluster run packages
+BASE = os.environ.get("BENCH_BASE") or CFG["paths"]["base"]
+WORK = os.environ.get("BENCH_WORK") or (f"{BASE}/work" if os.environ.get("BENCH_BASE") else CFG["paths"]["work"])
+STORE = os.environ.get("BENCH_STORE") or (f"{BASE}/store" if os.environ.get("BENCH_BASE") else CFG["paths"]["store"])
+for d in (WORK, STORE, f"{STORE}/annotations", f"{STORE}/samples",
+          f"{STORE}/needed_videos", f"{STORE}/normalized", f"{STORE}/audio",
+          f"{BASE}/logs"):
+    os.makedirs(d, exist_ok=True)
+
+FAILURES = f"{BASE}/logs/failures.jsonl"
+MANIFEST = f"{BASE}/logs/manifest.jsonl"
+DEDUP_LOG = f"{BASE}/logs/dedup_log.csv"
+
+
+def log_failure(stage, key, error, **kw):
+    rec = dict(ts=time.strftime("%F %T"), stage=stage, key=key, error=str(error)[:500], **kw)
+    with open(FAILURES, "a") as f:
+        f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+
+
+def manifest_done():
+    done = {}
+    if os.path.exists(MANIFEST):
+        with open(MANIFEST) as f:
+            for line in f:
+                try:
+                    r = json.loads(line)
+                    if r.get("status") == "done":
+                        done[r["key"]] = r
+                except Exception:
+                    pass
+    return done
+
+
+def manifest_write(key, status, **kw):
+    with open(MANIFEST, "a") as f:
+        f.write(json.dumps(dict(key=key, status=status, ts=time.strftime("%F %T"), **kw),
+                           ensure_ascii=False) + "\n")
+
+
+def du_gb(path):
+    r = subprocess.run(["du", "-sb", path], capture_output=True, text=True)
+    try:
+        return int(r.stdout.split()[0]) / 1e9
+    except Exception:
+        return 0.0
+
+
+_DISK_GUARD_CACHE = {"ts": 0.0, "val": None}
+DISK_GUARD_TTL_S = 600   # du over the store (~55k files on a network FS) takes seconds; with ~20
+                         # concurrent stage_c processes a per-item du dominated wall time (2026-09-03)
+
+
+def disk_guard(force=False):
+    """Return (ok, work_gb, store_gb). Caller MUST stop when not ok.
+    Result is cached per process for DISK_GUARD_TTL_S; a not-ok result is never cached."""
+    now = time.time()
+    c = _DISK_GUARD_CACHE
+    if not force and c["val"] is not None and c["val"][0] and now - c["ts"] < DISK_GUARD_TTL_S:
+        return c["val"]
+    w, s = du_gb(WORK), du_gb(STORE)
+    ok = w <= CFG["limits"]["work_dir_limit_gb"] and s <= CFG["limits"]["store_limit_gb"]
+    c["ts"], c["val"] = now, (ok, w, s)
+    return ok, w, s
+
+
+def sha256_file(path, bufsize=1 << 20):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        while True:
+            b = f.read(bufsize)
+            if not b:
+                break
+            h.update(b)
+    return h.hexdigest()
+
+
+def hf_token():
+    p = os.path.expanduser("~/.cache/huggingface/token")
+    return open(p).read().strip() if os.path.exists(p) else None
+
+
+def api_tree(repo, revision=None):
+    """Full recursive file listing with sizes. Uses huggingface_hub pagination —
+    the raw /tree REST endpoint silently truncates at 1000 entries.
+    revision=None keeps the historical behavior (default branch / main);
+    pass a commit sha or tag to pin (see exp/watch/REVISION_PINNING.md)."""
+    from huggingface_hub import HfApi
+    out = []
+    for it in HfApi(token=hf_token()).list_repo_tree(repo, repo_type="dataset",
+                                                     recursive=True, expand=False,
+                                                     revision=revision):
+        if getattr(it, "size", None) is not None:  # RepoFile
+            out.append(dict(type="file", path=it.path, size=it.size))
+    return out
+
+
+_fs = None
+
+def hffs():
+    global _fs
+    if _fs is None:
+        from huggingface_hub import HfFileSystem
+        _fs = HfFileSystem(token=hf_token())
+    return _fs
+
+
+_zip_handles = {}
+
+def remote_zip(repo, zip_path):
+    """Open a zip inside an HF dataset repo with range reads. Cached per path."""
+    key = f"datasets/{repo}/{zip_path}"
+    if key not in _zip_handles:
+        f = hffs().open(key, "rb")
+        _zip_handles[key] = zipfile.ZipFile(f)
+    return _zip_handles[key]
+
+
+def zip_namelist(repo, zip_path):
+    return remote_zip(repo, zip_path).namelist()
+
+
+def extract_member(repo, zip_path, member, dest):
+    """Stream ONE member out of a remote zip (only its bytes transferred)."""
+    zf = remote_zip(repo, zip_path)
+    with zf.open(member) as src, open(dest, "wb") as out:
+        while True:
+            b = src.read(1 << 20)
+            if not b:
+                break
+            out.write(b)
+    return dest
+
+
+TAR_EXT = (".tar", ".tar.gz", ".tgz", ".tar.bz2")
+TAR_COMPRESSED = (".tar.gz", ".tgz", ".tar.bz2")
+TAR_STREAM_CAP_GB = 10  # compressed tars have no random access; cap full-stream size
+
+_tar_handles = {}
+
+
+class ConcatFile:
+    """Read-only seekable concatenation of fsspec files (split .tar.part.* archives)."""
+
+    def __init__(self, fs, paths, sizes=None):
+        self.fs = fs
+        self.parts = []
+        off = 0
+        for i, p in enumerate(paths):
+            size = sizes[i] if sizes and sizes[i] is not None else fs.info(p)["size"]
+            self.parts.append((off, size, p))
+            off += size
+        self.size = off
+        self.pos = 0
+        self._open = {}
+
+    # tarfile callers use `with _open_remote(...) as f` — without these the
+    # first chunked-archive access dies with AttributeError: __enter__
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.close()
+        return False
+
+    def seek(self, pos, whence=0):
+        if whence == 1:
+            pos += self.pos
+        elif whence == 2:
+            pos += self.size
+        self.pos = max(0, pos)
+        return self.pos
+
+    def tell(self):
+        return self.pos
+
+    def read(self, n=-1):
+        if n is None or n < 0:
+            n = self.size - self.pos
+        out = []
+        while n > 0 and self.pos < self.size:
+            hit = next(((o, s, p) for o, s, p in self.parts if o <= self.pos < o + s), None)
+            if hit is None:
+                break
+            off, size, p = hit
+            f = self._open.get(p)
+            if f is None:
+                f = self._open[p] = self.fs.open(p, "rb")
+            f.seek(self.pos - off)
+            chunk = f.read(min(n, off + size - self.pos))
+            if not chunk:
+                break
+            out.append(chunk)
+            self.pos += len(chunk)
+            n -= len(chunk)
+        return b"".join(out)
+
+    def seekable(self):
+        return True
+
+    def readable(self):
+        return True
+
+    def close(self):
+        for f in self._open.values():
+            f.close()
+
+
+_glob_cache = {}
+
+
+def _natsort_key(p):
+    """Natural sort: 'x.part2' < 'x.part10' (lexicographic puts part10 between
+    part1 and part2 and CORRUPTS concatenated split archives)."""
+    import re
+    return [int(t) if t.isdigit() else t for t in re.split(r"(\d+)", str(p))]
+
+
+def _open_remote(key):
+    """fsspec handle for a repo path; a '*' means split chunks joined in order.
+    glob+sizes are cached per pattern: without this every per-key fallback
+    redoes 1 glob + N info() calls against the HF paths-info API and the
+    1000 req/5min quota dies (VideoEval-Pro: 194 keys x 36 calls -> 429)."""
+    fs = hffs()
+    if "*" in key:
+        cached = _glob_cache.get(key)
+        if cached is None:
+            detail = fs.glob(key, detail=True)
+            if not detail:
+                raise FileNotFoundError(key)
+            cached = sorted(((p, (info or {}).get("size"))
+                             for p, info in detail.items()),
+                            key=lambda x: _natsort_key(x[0]))
+            _glob_cache[key] = cached
+        return ConcatFile(fs, [p for p, _ in cached], [s for _, s in cached])
+    return fs.open(key, "rb")
+
+
+def remote_tar(repo, tar_path):
+    """Seekable tarfile for plain .tar (range reads). None for compressed.
+    If tar_path itself doesn't exist, looks for split parts <tar_path>.part*."""
+    import tarfile
+    key = f"datasets/{repo}/{tar_path}"
+    if key not in _tar_handles:
+        if tar_path.lower().endswith(TAR_COMPRESSED) or "*" in tar_path:
+            _tar_handles[key] = None
+        else:
+            fs = hffs()
+            if fs.exists(key):
+                f = fs.open(key, "rb")
+            else:
+                parts = sorted(fs.glob(key + ".part*"), key=_natsort_key)
+                if not parts:
+                    raise FileNotFoundError(key)
+                f = ConcatFile(fs, parts)
+            _tar_handles[key] = tarfile.open(fileobj=f, mode="r:")
+    return _tar_handles[key]
+
+
+def tar_namelist(repo, tar_path):
+    """Member listing with a disk cache — remote tar walks cost ~0.1s/member."""
+    import tarfile
+    cache_dir = f"{STORE}/tar_index"
+    os.makedirs(cache_dir, exist_ok=True)
+    cache = f"{cache_dir}/{repo.replace('/', '__')}__{tar_path.replace('/', '__')}.json"
+    if os.path.exists(cache):
+        return json.load(open(cache))
+    tf = remote_tar(repo, tar_path)
+    if tf is not None:
+        names = [m.name for m in tf.getmembers() if m.isfile()]
+    else:
+        names = []
+        with _open_remote(f"datasets/{repo}/{tar_path}") as f, \
+                tarfile.open(fileobj=f, mode="r|*") as t:
+            for m in t:
+                if m.isfile():
+                    names.append(m.name)
+    tmp = f"{cache}.tmp{os.getpid()}"    # atomic: concurrent shards write it
+    json.dump(names, open(tmp, "w"))
+    os.replace(tmp, cache)
+    return names
+
+
+def extract_tar_member(repo, tar_path, member, dest):
+    import shutil
+    import tarfile
+    tf = remote_tar(repo, tar_path)
+    if tf is not None:
+        src = tf.extractfile(member)
+        with open(dest, "wb") as out:
+            shutil.copyfileobj(src, out, 1 << 20)
+        return dest
+    with _open_remote(f"datasets/{repo}/{tar_path}") as f, \
+            tarfile.open(fileobj=f, mode="r|*") as t:
+        for m in t:
+            if m.name == member:
+                with open(dest, "wb") as out:
+                    shutil.copyfileobj(t.extractfile(m), out, 1 << 20)
+                return dest
+    raise KeyError(f"{member} not in {tar_path}")
+
+
+def extract_tar_members_bulk(repo, tar_path, members, dest_dir):
+    """One streaming pass through a (compressed) tar, extracting every wanted
+    member — avoids re-streaming the whole archive per video."""
+    import shutil
+    import tarfile
+    os.makedirs(dest_dir, exist_ok=True)
+    want = set(members)
+    got = {}
+    with _open_remote(f"datasets/{repo}/{tar_path}") as f, \
+            tarfile.open(fileobj=f, mode="r|*") as t:
+        for m in t:
+            if m.name in want:
+                dest = os.path.join(dest_dir, m.name.replace("/", "_"))
+                with open(dest, "wb") as out:
+                    shutil.copyfileobj(t.extractfile(m), out, 1 << 20)
+                got[m.name] = dest
+                if len(got) == len(want):
+                    break
+    return got
+
+
+def hf_download_file(repo, path, dest_dir, revision=None):
+    """revision=None keeps the historical behavior (default branch / main);
+    pass a commit sha to pin (see exp/watch/REVISION_PINNING.md)."""
+    from huggingface_hub import hf_hub_download
+    return hf_hub_download(repo_id=repo, filename=path, repo_type="dataset",
+                           local_dir=dest_dir, token=hf_token(), revision=revision)
+
+
+def ffprobe(path):
+    r = subprocess.run(["ffprobe", "-v", "error", "-print_format", "json",
+                        "-show_format", "-show_streams", path],
+                       capture_output=True, text=True, timeout=300)
+    return json.loads(r.stdout)

code/exp/pipeline/extract_frames.py

@@ -0,0 +1,154 @@
+"""Shared frame extraction for Stage D (caption + AuroraCap runners).
+
+Contract (unified across all stages):
+  - indices = round(linspace(0, n_frames-1, 32)) over meta.json n_frames
+  - decode via decord -> cv2 -> ffmpeg-select fallback
+  - JPEG q=85, long side capped at 768px
+  - single_frame condition = THE MIDDLE FRAME = round((n_frames-1)/2)
+    (= sample_indices(n_frames, 1); the data contract and stage_e1_api's
+    remote extractor use this rule — an earlier version of this module took
+    position 16 of the 32-index list, round(16*(n-1)/31), which drifts off
+    the true middle)
+
+frames_for_hash() deduplicates repeated indices (videos with n_frames < 32
+produce duplicate indices); callers can report len(result) as n_frames_used.
+Dependency-light on purpose: json/PIL only; decord/cv2 optional.
+"""
+import io
+import json
+import os
+import subprocess
+import tempfile
+
+from PIL import Image
+
+N_FRAMES_DEFAULT = 32
+LONG_SIDE = 768
+JPEG_QUALITY = 85
+
+
+def sample_indices(n_frames, n=N_FRAMES_DEFAULT):
+    """round(linspace(0, n_frames-1, n)) without numpy. May contain duplicates."""
+    if n_frames <= 0:
+        raise ValueError("n_frames must be positive")
+    if n == 1:
+        return [round((n_frames - 1) / 2)]
+    return [round(i * (n_frames - 1) / (n - 1)) for i in range(n)]
+
+
+def _resize(img):
+    w, h = img.size
+    m = max(w, h)
+    if m > LONG_SIDE:
+        img = img.resize((max(1, round(w * LONG_SIDE / m)),
+                          max(1, round(h * LONG_SIDE / m))), Image.LANCZOS)
+    return img.convert("RGB")
+
+
+def _decode_decord(path, idxs):
+    import decord
+    vr = decord.VideoReader(path, num_threads=2)
+    avail = len(vr)
+    uniq = sorted({min(i, avail - 1) for i in idxs})
+    out = {}
+    for c0 in range(0, len(uniq), 64):        # chunked: 600 frames of 720p as one batch = ~1.7 GB
+        chunk = uniq[c0:c0 + 64]
+        batch = vr.get_batch(chunk).asnumpy()
+        for j, u in enumerate(chunk):
+            out[u] = Image.fromarray(batch[j])
+    return out
+
+
+def _decode_cv2(path, idxs):
+    import cv2
+    cap = cv2.VideoCapture(path)
+    if not cap.isOpened():
+        raise RuntimeError(f"cv2 cannot open {path}")
+    want = sorted(set(idxs))
+    out, pos = {}, 0
+    hi = want[-1]
+    wi = 0
+    while wi < len(want):
+        ok = cap.grab()
+        if not ok:
+            break
+        if pos == want[wi]:
+            ok, fr = cap.retrieve()
+            if not ok:
+                break
+            out[pos] = Image.fromarray(cv2.cvtColor(fr, cv2.COLOR_BGR2RGB))
+            wi += 1
+        pos += 1
+        if pos > hi:
+            break
+    cap.release()
+    if not out:
+        raise RuntimeError(f"cv2 decoded 0/{len(want)} frames from {path}")
+    last = max(out)
+    for w in want:          # clamp missing tail indices to last decoded frame
+        if w not in out:
+            out[w] = out[last]
+    return out
+
+
+def _decode_ffmpeg(path, idxs):
+    uniq = sorted(set(idxs))
+    sel = "+".join(f"eq(n\\,{i})" for i in uniq)
+    with tempfile.TemporaryDirectory() as td:
+        cmd = [os.environ.get("FFMPEG_BIN", "ffmpeg"), "-y", "-v", "error",
+               "-i", path, "-vf", f"select='{sel}'", "-vsync", "0",
+               f"{td}/f_%05d.jpg"]
+        subprocess.run(cmd, check=True, capture_output=True, timeout=1800)
+        files = sorted(os.listdir(td))
+        if not files:
+            raise RuntimeError(f"ffmpeg extracted 0 frames from {path}")
+        imgs = [Image.open(os.path.join(td, f)) for f in files]
+        for im in imgs:
+            im.load()
+    out = {}
+    for j, u in enumerate(uniq):    # ffmpeg may drop trailing frames; clamp
+        out[u] = imgs[min(j, len(imgs) - 1)]
+    return out
+
+
+def _decode(path, idxs):
+    errs = []
+    for fn in (_decode_decord, _decode_cv2, _decode_ffmpeg):
+        try:
+            return fn(path, idxs)
+        except ImportError:
+            continue
+        except Exception as e:
+            errs.append(f"{fn.__name__}: {e}")
+    raise RuntimeError("all decoders failed: " + " | ".join(errs))
+
+
+def frames_for_hash(store, content_hash, n=N_FRAMES_DEFAULT, single=False):
+    """Return list[PIL.Image] (RGB, long side <=768) for a normalized video.
+
+    single=True -> [middle frame] = round((n_frames-1)/2), the contract rule
+    shared with stage_e1_api's remote extractor.
+    Otherwise the n sampled frames with duplicate indices removed
+    (order preserved); len(result) == n unless n_frames < n.
+    """
+    d = os.path.join(store, "normalized", content_hash)
+    meta = json.load(open(os.path.join(d, "meta.json")))
+    if single:
+        idxs = sample_indices(meta["n_frames"], 1)
+    else:
+        idxs = sample_indices(meta["n_frames"], n)
+    keep = list(dict.fromkeys(idxs))            # dedupe, keep order
+    decoded = _decode(os.path.join(d, "video.mp4"), keep)
+    avail_max = max(decoded)
+    return [_resize(decoded[min(i, avail_max)]) for i in keep]
+
+
+def to_jpeg_bytes(img):
+    buf = io.BytesIO()
+    img.save(buf, format="JPEG", quality=JPEG_QUALITY)
+    return buf.getvalue()
+
+
+def to_data_url(img):
+    import base64
+    return "data:image/jpeg;base64," + base64.b64encode(to_jpeg_bytes(img)).decode()

code/exp/pipeline/scoring.py

@@ -0,0 +1,399 @@
+"""Scoring rules shared by stages D/E/F.
+
+score(pred, answer, options, question_format) -> bool | None
+  * MCQ (question_format == "MCQ", or options is a list with >= 2 entries):
+    extract the leading option letter from pred (regex ^\\s*\\(?([A-J])[).\\s:]
+    plus bare-letter / "Answer: X" fallbacks); normalize the gold answer the
+    same way (it may be "A", "(A)", "A. text", or the full option text -> the
+    letter comes from its index in options). Compare letters; if either side
+    yields no letter, fall back to normalized-text comparison against the
+    resolved option text. A bare numeric answer ("0") resolves as an index
+    into options (text match has priority). A comma-separated multi-select
+    gold ("A,B,C") is scored as letter-set equality with the prediction.
+    str-typed options are coerced to a list when the format is recognizable
+    (JSON dict/list, python list repr, "A. ..." lines).
+  * temporal grounding (gold parses as EXACTLY two floats, e.g. "[ 0.  12.6]"
+    or "21 39"): extract the first two non-negative floats from pred and score
+    by interval IoU >= 0.5 (industry-standard R@0.5). Pred without two floats
+    falls back to normalized exact match.
+  * counting / numeric (gold parses as ONE number): if pred is not itself a
+    pure number sequence, extract the number from pred ("is/are/answer: N"
+    pattern preferred, else the last standalone number) and compare.
+  * free text (non-MCQ gold with >= FREETEXT_MIN_WORDS words): NOT rule-
+    scorable -> returns None. Callers must treat None as NA (exclude from
+    accuracy), never as wrong.
+  * other non-MCQ: normalized exact match (lowercase, punctuation stripped,
+    whitespace collapsed). If BOTH sides parse entirely as number sequences,
+    compare numerically ("5" == "5.0").
+
+chance_level(num_options, has_chance_level) -> float | None
+  None unless has_chance_level is truthy ("True"/"true"/True/1). num_options
+  may be junk from the CSV ('', 'NA', '4', '4 or 6'); every integer found
+  contributes 1/n and the mean is returned ("4 or 6" -> (1/4+1/6)/2).
+
+Run `python scoring.py` for the self-test.
+"""
+import ast
+import json
+import re
+
+# leading option letter: "B", "(B)", "B.", "B) text", "[b]", "b: text"
+_LEAD = re.compile(r"^\s*[\(\[]?([A-Ja-j])[\)\]\.,:]?(?:\s|$)")
+# comma-separated multi-select gold: "A,B,C" / "a, c"
+_MULTI = re.compile(r"^\s*[A-Ja-j](\s*,\s*[A-Ja-j])+\s*$")
+# "answer is (B)" / "Answer: B." / "option B"  (the LAST occurrence wins:
+# predictions often discuss wrong options before stating the answer)
+_STATED = re.compile(
+    r"(?:answer|option|choice)\s*(?:is|would\s+be)?\s*[:\-]?\s*[\(\[]?([A-Ja-j])[\)\]\.,:]?(?:\s|$)",
+    re.IGNORECASE)
+_STATED_CN = re.compile(r"答案\s*(?:是|为)?\s*[:：]?\s*[\(\[]?([A-Ja-j])(?![A-Za-z])")
+# extended alphabet K-P for benches with MORE than 10 options (N1 intake:
+# UCF101-AD 11, iSafetyBench 16). Selected only when len(options) > 10, so
+# every bench with <=10 options keeps the exact A-J behaviour above.
+_LEAD_X = re.compile(r"^\s*[\(\[]?([A-Pa-p])[\)\]\.,:]?(?:\s|$)")
+_MULTI_X = re.compile(r"^\s*[A-Pa-p](\s*,\s*[A-Pa-p])+\s*$")
+_STATED_X = re.compile(
+    r"(?:answer|option|choice)\s*(?:is|would\s+be)?\s*[:\-]?\s*[\(\[]?([A-Pa-p])[\)\]\.,:]?(?:\s|$)",
+    re.IGNORECASE)
+
+
+def _wide(options):
+    return isinstance(options, (list, tuple)) and len(options) > 10
+# non-negative decimal number (timestamps/counts); '-' is treated as a
+# separator ("10-20"), not a sign
+_NUM = re.compile(r"\d+(?:\.\d+)?")
+# "is/are/answer(ed)/total/count ... N" — preferred counting extraction
+_NUM_STATED = re.compile(
+    r"(?:\bis\b|\bare\b|\banswer\b|\banswered\b|\btotal\b|\bcount\b)"
+    r"[^0-9\n]{0,20}?(\d+(?:\.\d+)?)", re.IGNORECASE)
+# standalone number (not part of a word/identifier like "f16" or "1st")
+_NUM_ALONE = re.compile(r"(?<![\w.])(\d+(?:\.\d+)?)(?![\w])")
+
+FREETEXT_MIN_WORDS = 10  # gold this long cannot be scored by exact match
+IOU_THRESHOLD = 0.5      # temporal grounding R@0.5
+
+
+def _pre(s):
+    """Light normalization before letter extraction: full-width punctuation
+    and markdown emphasis defeat the regexes ('（C）', '**C**', 'C。')."""
+    s = str(s)
+    s = s.replace("（", "(").replace("）", ")").replace("：", ":")
+    s = s.replace("。", ".").replace("，", ",")
+    return s.replace("*", "").replace("#", "")
+
+
+def norm_text(s):
+    s = str(s).strip().lower()
+    s = re.sub(r"[‘’“”`]", "'", s)
+    s = re.sub(r"[^\w\s.\-]", " ", s)     # keep word chars, '.', '-' (numbers)
+    s = re.sub(r"\s+", " ", s).strip()
+    return s.strip(".").strip()
+
+
+def num_seq(s):
+    """Parse s as a pure sequence of numbers, else None."""
+    toks = re.sub(r"[\[\](){},;:]", " ", str(s)).split()
+    if not toks:
+        return None
+    out = []
+    for t in toks:
+        try:
+            out.append(float(t))
+        except ValueError:
+            return None
+    return out
+
+
+def coerce_options(options):
+    """Normalize an options field to a list (or None). The data contract
+    allows list|str|null; live str shapes: JSON dict '{"A": "Yes", ...}',
+    python-list repr, and newline 'A. ...' blocks."""
+    if options is None:
+        return None
+    if isinstance(options, (list, tuple)):
+        return list(options)
+    s = str(options).strip()
+    if not s:
+        return None
+    for parser in (json.loads, ast.literal_eval):
+        try:
+            v = parser(s)
+        except Exception:
+            continue
+        if isinstance(v, dict) and v:
+            # {'A': 'Yes', 'B': 'No'} -> values ordered by (letter) key
+            return [f"{k}. {v[k]}" for k in sorted(v, key=lambda x: str(x))]
+        if isinstance(v, (list, tuple)) and v:
+            return [str(x) for x in v]
+    lines = [l.strip() for l in s.splitlines() if l.strip()]
+    if len(lines) >= 2 and sum(
+            bool(re.match(r"^\(?[A-J][).:\.]\s*", l)) for l in lines) >= 2:
+        return lines
+    return None
+
+
+def _strip_letter_prefix(opt):
+    return re.sub(r"^\s*[\(\[]?[A-Ja-j][\)\]\.,:]\s+", "", str(opt)).strip()
+
+
+def mcq_letter(s, options=None):
+    """Extract an option letter from a prediction / gold answer."""
+    if s is None:
+        return None
+    s = _pre(s).strip()
+    options = coerce_options(options)
+    wide = _wide(options)
+    m = (_LEAD_X if wide else _LEAD).match(s)
+    if m:
+        letter = m.group(1).upper()
+        # bare 'A '/'I ' followed by more words is usually the article/pronoun
+        # ('A man walks...', 'I think...'), not the option letter: only accept
+        # it with an explicit delimiter or when the pred is the letter alone.
+        has_delim = any(ch in m.group(0) for ch in "()[].,:")
+        if has_delim or letter not in ("A", "I") or len(s.split()) == 1:
+            return letter
+    ms = (list((_STATED_X if wide else _STATED).finditer(s))
+          or list(_STATED_CN.finditer(s)))
+    if ms:
+        return ms[-1].group(1).upper()
+    if options:
+        ns = norm_text(s)
+        for i, opt in enumerate(options):
+            if ns and ns in (norm_text(opt), norm_text(_strip_letter_prefix(opt))):
+                return chr(65 + i)
+        # option text stated followed by explanation: containment, but only
+        # when EXACTLY ONE option matches (ambiguous containment stays None)
+        flat = lambda t: re.sub(r"\s+", " ", re.sub(r"[.\-]", " ", t)).strip()
+        nsf = flat(ns)
+        hits = []
+        for i, opt in enumerate(options):
+            ot = flat(norm_text(_strip_letter_prefix(opt)))
+            if ot and len(ot) >= 3 and f" {ot} " in f" {nsf} ":
+                hits.append(i)
+        if len(hits) == 1:
+            return chr(65 + hits[0])
+        # bare numeric index into options ("0" -> A); text match takes priority
+        if re.fullmatch(r"\d{1,2}", s) and int(s) < len(options):
+            return chr(65 + int(s))
+    return None
+
+
+def _letter_set(s, wide=False):
+    """Letters of a multi-select answer. Strict comma form first; otherwise
+    uppercase standalone letters ("The artifacts are A and C" -> {A, C}).
+    In the loose fallback 'I' is excluded (almost always the pronoun).
+    wide=True widens the alphabet to A-P (benches with >10 options)."""
+    s = _pre(s)
+    if (_MULTI_X if wide else _MULTI).match(s):
+        return {c.upper() for c in re.findall(r"[A-Pa-p]" if wide else r"[A-Ja-j]", s)}
+    toks = [t for t in re.findall(r"\b([A-P])\b" if wide else r"\b([A-J])\b", s)
+            if t != "I"]
+    return set(toks) if toks else None
+
+
+def parse_interval(s):
+    """(start, end) when s parses as exactly two numbers, else None."""
+    ns = num_seq(s)
+    if ns is not None and len(ns) == 2:
+        return (ns[0], ns[1])
+    return None
+
+
+def extract_pred_interval(pred):
+    """First two non-negative floats in pred ('from 10.5 to 20s' -> (10.5, 20))."""
+    nums = _NUM.findall(str(pred))
+    if len(nums) < 2:
+        return None
+    return (float(nums[0]), float(nums[1]))
+
+
+def interval_iou(a, b):
+    """Temporal IoU of two (start, end) intervals (order-normalized)."""
+    a = (min(a), max(a))
+    b = (min(b), max(b))
+    inter = max(0.0, min(a[1], b[1]) - max(a[0], b[0]))
+    union = max(a[1], b[1]) - min(a[0], b[0])
+    if union <= 0:  # both degenerate points
+        return 1.0 if abs(a[0] - b[0]) <= 1e-6 else 0.0
+    return inter / union
+
+
+def extract_pred_number(pred):
+    """Number stated in a verbose prediction; 'is/are/answer: N' pattern
+    preferred (last such match), else the last standalone number."""
+    s = str(pred).replace(",", "")   # '1,234' -> '1234'
+    ms = _NUM_STATED.findall(s)
+    if ms:
+        return float(ms[-1])
+    ms = _NUM_ALONE.findall(s)
+    if ms:
+        return float(ms[-1])
+    return None
+
+
+def score(pred, answer, options=None, question_format=None):
+    """True/False = rule-scored; None = NOT rule-scorable (free-text gold).
+    Callers must treat None as NA — excluded from accuracy, never 'wrong'."""
+    if pred is None or answer is None:
+        return False
+    options = coerce_options(options)
+    wide = _wide(options)
+    if (_MULTI_X if wide else _MULTI).match(_pre(answer)):  # multi-select gold "A,B,C"
+        return _letter_set(pred, wide) == _letter_set(answer, wide)
+    is_mcq = ((question_format or "").strip().upper() == "MCQ"
+              or (isinstance(options, (list, tuple)) and len(options) >= 2))
+    if is_mcq and isinstance(options, (list, tuple)) and options:
+        pl = mcq_letter(pred, options)
+        al = mcq_letter(answer, options)
+        if pl and al:
+            return pl == al
+        # one side unresolvable -> compare texts (resolve letters to option text)
+        ptxt = (norm_text(_strip_letter_prefix(options[ord(pl) - 65]))
+                if pl and ord(pl) - 65 < len(options) else norm_text(pred))
+        atxt = (norm_text(_strip_letter_prefix(options[ord(al) - 65]))
+                if al and ord(al) - 65 < len(options) else norm_text(answer))
+        return bool(ptxt) and ptxt == atxt
+    if is_mcq:  # MCQ without an options list: letter-vs-letter if possible
+        pl, al = mcq_letter(pred), mcq_letter(answer)
+        if pl and al:
+            return pl == al
+    # ---- temporal grounding: gold is exactly two floats -> IoU >= 0.5
+    gold_iv = parse_interval(answer)
+    if gold_iv is not None:
+        pred_iv = (parse_interval(pred) if num_seq(pred) is not None
+                   else extract_pred_interval(pred))
+        if pred_iv is not None:
+            return interval_iou(pred_iv, gold_iv) >= IOU_THRESHOLD
+        return bool(norm_text(pred)) and norm_text(pred) == norm_text(answer)
+    pn, an = num_seq(pred), num_seq(answer)
+    if pn is not None and an is not None:
+        return len(pn) == len(an) and all(abs(a - b) <= 1e-6 for a, b in zip(pn, an))
+    # ---- counting/numeric gold with a verbose prediction: extract the number
+    if an is not None and len(an) == 1:
+        pv = extract_pred_number(pred)
+        if pv is not None:
+            return abs(pv - an[0]) <= 1e-6
+        return bool(norm_text(pred)) and norm_text(pred) == norm_text(answer)
+    # ---- long free-text gold: not rule-scorable -> NA
+    if len(norm_text(answer).split()) >= FREETEXT_MIN_WORDS:
+        return None
+    return bool(norm_text(pred)) and norm_text(pred) == norm_text(answer)
+
+
+def chance_level(num_options, has_chance_level):
+    flag = str(has_chance_level).strip().lower()
+    if flag not in ("true", "1", "yes"):
+        return None
+    ns = [int(x) for x in re.findall(r"\d+", str(num_options or "")) if int(x) > 0]
+    if not ns:
+        return None
+    return sum(1.0 / n for n in ns) / len(ns)
+
+
+# ---------------------------------------------------------------- self-test
+def _selftest():
+    OPTS = ["Holding something", "Releasing something", "Not sure"]
+    LOPTS = ["A. Turn right and walk.", "B. Turn left and walk.", "C. Stay put."]
+    cases = [
+        # (pred, answer, options, fmt, expected)
+        ("B", "B", LOPTS, "MCQ", True),                       # bare letter
+        ("(B)", "B", LOPTS, "MCQ", True),                     # parenthesized
+        ("b) Turn left and walk.", "B", LOPTS, "MCQ", True),  # lowercase + text
+        ("B.", "C", LOPTS, "MCQ", False),                     # wrong letter
+        ("The answer is (C)", "C", LOPTS, "MCQ", True),       # stated answer
+        ("Answer: A", "A. Turn right and walk.", LOPTS, "MCQ", True),  # gold has text
+        ("Turn left and walk.", "B", LOPTS, "MCQ", True),     # pred is option text
+        ("Releasing something", "Releasing something", OPTS, "mixed", True),  # unlabeled opts
+        ("A", "Holding something", OPTS, "MCQ", True),        # letter vs option text
+        ("B", "Holding something", OPTS, "MCQ", False),
+        ("As shown, people run.", "C", LOPTS, "MCQ", False),  # 'As' is not letter A
+        ("Not sure.", "Not sure", OPTS, "MCQ", True),         # trailing period
+        # numeric index answers ("0" -> options[0]); text match has priority
+        ("A", "0", OPTS, "MCQ", True),                        # gold is index
+        ("Holding something", "0", OPTS, "MCQ", True),        # pred text vs gold index
+        ("B", "0", OPTS, "MCQ", False),
+        ("1", "B", ["cat", "dog", "fox"], "MCQ", True),       # pred is index
+        ("3", "5", ["5", "3", "1"], "MCQ", False),            # "3" is option text (B), not index
+        # multi-select "A,B,C": normalized letter-set equality
+        ("A,C", "C, A", LOPTS, "MCQ", True),
+        ("B, A and C", "A,B,C", None, "MCQ", True),
+        ("The artifacts are A and C.", "A,C", None, "MCQ", True),
+        ("A", "A,B", None, "MCQ", False),
+        ("A,B,C", "A,B", None, "MCQ", False),
+        # non-MCQ text
+        ("  Yes. ", "yes", None, "open", True),
+        ("A dog", "a  dog!", None, "open", True),
+        ("dog", "cat", None, "open", False),
+        ("", "cat", None, "open", False),                     # empty pred never correct
+        # numeric equivalence
+        ("5", "5.0", None, "numeric", True),
+        ("5", "6", None, "numeric", False),
+        # ---- letter-extraction robustness (review fixes) -----------------
+        ("I think the answer is B", "B", LOPTS, "MCQ", True),   # 'I' not letter I
+        ("A man walks by; the answer is C", "C", LOPTS, "MCQ", True),
+        ("A man walks in the park.", "A", LOPTS, "MCQ", False),  # article, no signal
+        ("**C**", "C", LOPTS, "MCQ", True),                   # markdown bold
+        ("（C）", "C", LOPTS, "MCQ", True),                    # full-width parens
+        ("C。", "C", LOPTS, "MCQ", True),                      # full-width period
+        ("答案是C", "C", LOPTS, "MCQ", True),                  # Chinese stated
+        ("Option A is wrong. The answer is B.", "B", LOPTS, "MCQ", True),  # last stated wins
+        ("Turn left and walk. That matches what happens.", "B", LOPTS, "MCQ", True),  # opt text + explanation
+        ("The artifacts I see are A and C.", "A,C", None, "MCQ", True),   # 'I' in multi-select prose
+        # str-typed options are coerced
+        ("A", "A", '{"A": "Yes", "B": "No"}', "MCQ", True),
+        ("Yes", "A", '{"A": "Yes", "B": "No"}', "MCQ", True),
+        ("B", "A", "['Yes', 'No']", None, False),
+        # ---- temporal grounding: IoU >= 0.5 (R@0.5) ----------------------
+        ("0, 12.6", "[ 0.  12.6]", None, "grounding", True),   # exact interval
+        ("0.0 12.0", "[ 0.  12.6]", None, "grounding", True),  # IoU 0.95
+        ("From 10.2 to 20.5 seconds.", "[10, 21]", None, "grounding", True),
+        ("5 - 8", "[20, 30]", None, "grounding", False),       # IoU 0
+        ("10-20", "[12, 22]", None, "grounding", True),        # '-' as separator, IoU 0.67
+        ("around 14", "[10, 20]", None, "grounding", False),   # one float -> exact fallback
+        ("2702 2715", "[2702. 2715.]", None, "grounding", True),  # numpy repr gold
+        ("[21, 39]", "[21, 39]", None, "open", True),
+        ("22 38", "[21, 39]", None, "open", True),             # IoU 16/18
+        # ---- counting: extract the number from a sentence ----------------
+        ("There are 13 repetitions.", "13", None, "numeric", True),
+        ("The person does 12 push-ups in total, so the answer is 12.", "12", None, "numeric", True),
+        ("I counted 5 pull-ups and then 7 squats.", "7", None, "numeric", True),  # last standalone
+        ("The count is 27.", "27", None, "open", True),
+        ("approximately 14.1 meters", "14.10", None, "open", True),
+        ("There are 5 people.", "6", None, "numeric", False),
+        ("many repetitions", "13", None, "numeric", False),    # no number -> exact fallback
+        ("13", "13", None, "numeric", True),
+        # ---- long free-text gold -> None (NA, not rule-scorable) ---------
+        ("some answer", "A woman wearing a white coat and black pants attacks "
+         "a public trash can with her feet on the street", None, "open", None),
+        ("the man opens the door", "the man opens the door", None, "open", True),
+    ]
+    for i, (p, a, o, f, want) in enumerate(cases):
+        got = score(p, a, o, f)
+        assert got is want if want is None else got == want, \
+            f"case {i}: score({p!r}, {a!r}) = {got}, want {want}"
+    assert chance_level("4", "True") == 0.25
+    assert chance_level("4 or 6", "True") == (0.25 + 1 / 6) / 2
+    assert chance_level("NA", "True") is None
+    assert chance_level("4", "False") is None
+    assert chance_level("", True) is None
+    assert abs(chance_level(5, True) - 0.2) < 1e-9
+    # coerce_options shapes
+    assert coerce_options('{"A": "Yes", "B": "No"}') == ["A. Yes", "B. No"]
+    assert coerce_options("['x', 'y']") == ["x", "y"]
+    assert coerce_options("A. foo\nB. bar\nC. baz") == ["A. foo", "B. bar", "C. baz"]
+    assert coerce_options("free text blob") is None
+    assert coerce_options(None) is None
+    assert coerce_options(["a", "b"]) == ["a", "b"]
+    # interval helpers
+    assert parse_interval("[ 0.  12.6]") == (0.0, 12.6)
+    assert parse_interval("12") is None
+    assert extract_pred_interval("from 3.5s to 9s") == (3.5, 9.0)
+    assert abs(interval_iou((0, 10), (5, 15)) - 1 / 3) < 1e-9
+    assert extract_pred_number("the answer is 42.") == 42.0
+    assert extract_pred_number("no digits here") is None
+    print(f"scoring selftest: {len(cases)} score cases + option/interval/"
+          f"number helper cases OK")
+
+
+if __name__ == "__main__":
+    _selftest()

code/exp/pipeline/stage_p1_runner.py

@@ -0,0 +1,777 @@
+"""Stage P1 — DIAG_V profiling conditions over sampled benchmarks (runs ON 104).
+
+Model: DIAG_V = config models.diag_v (Qwen/Qwen3-VL-8B-Instruct) served by the
+local vLLM fleet (default endpoints localhost:8011-8016, round-robin).
+NOTE: the fleet must be serving with --limit-mm-per-prompt '{"image": 128}'
+and --max-model-len 65536 (MM_IMAGES=128 MAX_LEN=65536 serve_qwen3vl.sh);
+the original 32-image/32k launch rejects v_128 and storage-res v_32 prompts.
+
+Input : store/samples/<bench>.jsonl rows {qid,question,options,answer,
+        subcategory,video_ref}; video_key = f"{repo}::{zip_path}::{member}"
+        -> logs/manifest.jsonl (status=done) content_hash
+        -> store/normalized/<hash>/{video.mp4,meta.json}. The normalized MP4
+        is the only visual source.
+Output: store/p1_raw/<condition>/<bench>__DIAG_V.jsonl
+            {qid, pred_raw, status, meta{...}}          (append-only)
+        store/conditions_results.csv
+            benchmark,condition,model,question_id,correct,raw_output_path
+            (append-only; resume dedups on (benchmark,condition,question_id))
+        logs/p1_timing.jsonl  per (bench,condition) timing/token stats
+Failures -> common.log_failure (logs/failures.jsonl); never silently skipped.
+
+Conditions (frame targets are TIME-uniform over meta frame_timestamps; frame
+index = nearest timestamp; duplicate indices deduped, order kept):
+  v_blind      no frames, same prompt skeleton
+  v_1          the middle element (position 16, 0-based) of the 32-frame grid
+  v_32         32 frames, storage resolution
+  v_32_s448    v_32 frames, short side downscaled to 448 at decode time.
+               Videos stored at short side 480 (meta normalized_short_side)
+               are NOT re-inferred: the v_32 result row is copied with
+               meta.reused_from = "v_32".
+  v_32_s224    v_32 frames, short side downscaled to 224
+  v_128        128 frames time-uniform; n_frames < 128 -> all frames,
+               meta.capped = True
+  v_32_shuffle exactly the v_32 frames, order shuffled by one fixed per-item
+               permutation random.Random(f"42|{qid}"); meta.perm_seed records
+               the seed string
+  v_half1/2    16 frames time-uniform inside the first / second temporal half
+  v_32_off1/2  32-cell uniform grid with a random phase offset
+               phase = random.Random(f"42|{qid}|off1|2").uniform(0,1);
+               target_j = t0 + (j + phase) * span/32; meta.offset = phase
+too_short=True videos skip {v_128, v_32_shuffle, v_half1/2, v_32_off1/2}:
+the row is recorded with status=NA (raw + correct=NA in the csv).
+
+Design decisions (recorded here on purpose):
+  * JPEG q=85 everywhere (extract_frames convention); v_32 sends the frames
+    at storage resolution (no 768 long-side cap — the resolution ladder
+    s448/s224 must sit BELOW the base condition).
+  * Context safety: est. Qwen3-VL tokens/img = ceil(w/32)*ceil(h/32) (+small
+    overhead). If a prompt estimate exceeds --token-budget (default 58000),
+    all frames are scaled by sqrt(budget/est) and meta.fit_short_side records
+    the resulting short side (mainly v_128 on 720p-stored videos, which
+    cannot physically fit at storage res in a 65536 ctx).
+  * Scoring: scoring.score(pred, answer, options, question_format from
+    ../video_benchmarks.csv).
+  * Decode: extract_frames._decode (decord -> cv2 -> ffmpeg); per-video LRU
+    cache of storage-res JPEGs keyed (hash, index-tuple) so v_32 / s448 /
+    s224 / shuffle share one decode pass.
+
+Usage (on 104, vllm_qwen python):
+  python stage_p1_runner.py --bench MVBench,LVBench --conditions v_blind,v_32 \
+      --limit 300 --workers 12 [--endpoints URL,URL,...] [--dry-run]
+
+Task 11 conditions (2026-09-07, notes/server_tasks_2026-09-07.md):
+  v_32_s168 / v_32_s336   the v_32 frames, short side 168 / 336 (resolution ladder with s224, s448, v_32)
+  v_8_s224 / v_128_s224   8 / 128 time-uniform frames at short side 224 (frame-count ladder with v_32_s224);
+                          v_128_s224: n_frames < 128 -> all frames, meta.capped = True
+  v_fps{0.25,0.5,1,2}_s224 nearest stored frame to a fixed-fps grid from t0, deduped, short side 224;
+                          N_max = min(--max-images, floor((--token-budget - 1500) / tokens_per_frame)) with
+                          tokens_per_frame = ceil(w/32)*ceil(h/32)+6 at the 224 dims of the video; when the grid
+                          exceeds N_max the frames are re-sampled time-uniformly to N_max and meta.capped_ctx =
+                          True (meta also records fps, n_grid, n_max, tokens_per_frame, n_frames_used).
+  too_short videos: v_128_s224 and the fps ladder are NA (existing rule); vLLM needs --max-model-len 65536 and
+  --limit-mm-per-prompt images >= --max-images (default 1024).
+  P1_MANIFEST     manifest.jsonl to read instead of <base>/logs/manifest.jsonl (off-cluster run package)
+  BENCH_BASE / BENCH_STORE (common.py) relocate the data root / store off-cluster.
+
+Environment overrides (2026-09-07, phase-B top-up items; both optional):
+  P1_SAMPLES_DIR   sample directory read instead of store/samples
+                   (top-up: exp/data/samples_topup)
+  P1_RESULTS_ROOT  root that receives p1_raw/<cond>/<bench>__DIAG_V.jsonl and
+                   conditions_results.csv instead of store (top-up:
+                   store/topup -> store/topup/p1_raw, store/topup/conditions_results.csv);
+                   the main P1 outputs are not read or written in that case.
+"""
+import argparse
+import base64
+import csv
+import io
+import json
+import math
+import os
+import random
+import sys
+import threading
+import time
+from collections import OrderedDict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import requests
+from PIL import Image
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+from common import BASE, CFG, STORE, log_failure          # noqa: E402
+from extract_frames import JPEG_QUALITY, _decode          # noqa: E402
+from scoring import score                                 # noqa: E402
+
+MODEL_LABEL = "DIAG_V"
+MODEL_NAME = CFG.get("models", {}).get("diag_v", "Qwen/Qwen3-VL-8B-Instruct")
+SAMPLES_DIR = os.environ.get("P1_SAMPLES_DIR") or f"{STORE}/samples"
+RESULTS_ROOT = os.environ.get("P1_RESULTS_ROOT") or STORE
+RAW_DIR = f"{RESULTS_ROOT}/p1_raw"
+RESULTS_CSV = f"{RESULTS_ROOT}/conditions_results.csv"
+TIMING_LOG = f"{BASE}/logs/p1_timing.jsonl"
+BENCH_CSV = os.path.join(HERE, "..", "video_benchmarks.csv")
+DEFAULT_ENDPOINTS = ",".join(f"http://127.0.0.1:{p}/v1" for p in range(8011, 8017))
+
+# ---- prompt skeleton: identical wording across all conditions -------------
+ANSWER_INSTR = ("Reply with ONLY the option letter "
+                "(or the exact short answer if no options).")
+PROMPT = "{intro}\n\nQuestion: {q}\n{opts}\n" + ANSWER_INSTR
+INTRO_VISUAL = ("You are given {n} frame(s) sampled from a video. "
+                "Answer the question based on these frames.")
+INTRO_OPT_ONLY = ("You are given NO frames from the video and NO question text. "
+                  "Using only the answer options below, choose the option most likely to be correct.")
+PROMPT_OPT_ONLY = "{intro}\n\n{opts}\n" + ANSWER_INSTR
+INTRO_BLIND = ("You are given NO frames from the video. "
+               "Answer the question from the text alone.")
+
+# Task 11 (notes/server_tasks_2026-09-07.md, "frames or pixels"): resolution ladder at the v_32 frames
+# (s168 / s336 new; s224 / s448 / storage exist), frame-rate ladder at short side 224 (nearest stored
+# frame to a fixed-fps grid, deduped, capped by what the context holds: N_max = min(--max-images,
+# floor((--token-budget - TEXT_RESERVE) / tokens_per_frame_at_224)); capped videos are re-sampled
+# time-uniformly to N_max and record meta.capped_ctx = True, n_grid, n_max), and a frame-count ladder
+# at 224 (v_8_s224 / v_128_s224 new, v_32_s224 exists). vLLM must run with --max-model-len 65536 and
+# --limit-mm-per-prompt images >= --max-images.
+FPS_CONDS = {"v_fps0.25_s224": 0.25, "v_fps0.5_s224": 0.5, "v_fps1_s224": 1.0, "v_fps2_s224": 2.0}
+CONDITIONS = ["v_blind", "v_1", "v_32", "v_32_s448", "v_32_s224", "v_128",
+              "v_32_shuffle", "v_half1", "v_half2", "v_32_off1", "v_32_off2",
+              "v_opt_only",   # N0.2 options-only (2026-09-06): no frames, no question text
+              "v_32_s168", "v_32_s336", "v_8_s224", "v_128_s224",
+              "v_fps0.25_s224", "v_fps0.5_s224", "v_fps1_s224", "v_fps2_s224"]
+NO_VIDEO_CONDS = {"v_blind", "v_opt_only"}
+NA_WHEN_TOO_SHORT = {"v_128", "v_32_shuffle", "v_half1", "v_half2",
+                     "v_32_off1", "v_32_off2", "v_128_s224", *FPS_CONDS}
+SHORT_SIDE = {"v_32_s448": 448, "v_32_s224": 224, "v_32_s168": 168, "v_32_s336": 336,
+              "v_8_s224": 224, "v_128_s224": 224, **{c: 224 for c in FPS_CONDS}}
+V32_SHARED = {"v_32", "v_32_s448", "v_32_s224", "v_32_s168", "v_32_s336", "v_32_shuffle"}
+MAX_ATTEMPTS = 6    # enough to ride out one wedged endpoint + ctx shrinks
+TOKEN_OVERHEAD_PER_IMG = 6         # vision start/end tokens etc. (measured ~2-5)
+TEXT_RESERVE_TOKENS = 1500         # prompt text + answer headroom when sizing the fps ladders
+MAX_IMAGES_DEFAULT = 1024          # stored videos hold <= 1024 frames; vLLM --limit-mm-per-prompt must be >= this
+
+
+def log(msg):
+    print(f"[P1] {msg}", file=sys.stderr, flush=True)
+
+
+def video_key(row):
+    r = row["video_ref"]
+    return f"{r['repo']}::{r.get('zip_path', '')}::{r['member']}"
+
+
+def fmt_opts(o):
+    if not o:
+        return ""
+    if isinstance(o, str):
+        return o
+    return "\n".join(str(x) for x in o)
+
+
+def load_bench_fmt():
+    fmt = {}
+    if os.path.exists(BENCH_CSV):
+        for r in csv.DictReader(open(BENCH_CSV)):
+            fmt[r["name"]] = r.get("question_format", "")
+    return fmt
+
+
+def manifest_map():
+    m = {}
+    for line in open(os.environ.get("P1_MANIFEST") or f"{BASE}/logs/manifest.jsonl"):
+        try:
+            r = json.loads(line)
+        except Exception:
+            continue
+        if r.get("status") == "done" and r.get("content_hash"):
+            m[r["key"]] = r["content_hash"]
+    return m
+
+
+# ------------------------------------------------------- frame-grid selection
+def _nearest_indices(ts, targets):
+    """Nearest frame index per target time; ts is sorted ascending."""
+    import bisect
+    out = []
+    for t in targets:
+        i = bisect.bisect_left(ts, t)
+        if i <= 0:
+            out.append(0)
+        elif i >= len(ts):
+            out.append(len(ts) - 1)
+        else:
+            out.append(i if ts[i] - t < t - ts[i - 1] else i - 1)
+    return out
+
+
+def _uniform_times(t0, t1, k):
+    if k == 1:
+        return [(t0 + t1) / 2.0]
+    return [t0 + j * (t1 - t0) / (k - 1) for j in range(k)]
+
+
+def _dedupe(idxs):
+    return list(dict.fromkeys(idxs))
+
+
+def frame_dims_at(meta, short_side):
+    """(w, h) of a stored frame after downscaling its short side to `short_side` (never upscaled)."""
+    res = meta.get("original_resolution") or [1280, 720]
+    try:
+        ow, oh = int(res[0]), int(res[1])
+    except Exception:
+        ow, oh = 1280, 720
+    ss = int(meta.get("normalized_short_side") or min(ow, oh))
+    sc = ss / max(1, min(ow, oh))
+    w, h = max(1, round(ow * sc)), max(1, round(oh * sc))     # stored dims
+    s = min(1.0, short_side / max(1, min(w, h)))
+    return max(1, round(w * s)), max(1, round(h * s))
+
+
+def tokens_per_frame(meta, short_side):
+    w, h = frame_dims_at(meta, short_side)
+    return math.ceil(w / 32) * math.ceil(h / 32) + TOKEN_OVERHEAD_PER_IMG
+
+
+def cond_indices(cond, meta, qid, budget=None, max_images=None):
+    """-> (ordered index list, extra meta dict). Time-uniform via timestamps.
+    budget / max_images size the fps ladders (N_max); unused by the other conditions."""
+    n = int(meta["n_frames"])
+    ts = meta.get("frame_timestamps") or []
+    if len(ts) != n:                       # defensive: fall back to index grid
+        ts = list(range(n))
+    t0, t1 = ts[0], ts[-1]
+    grid32 = _nearest_indices(ts, _uniform_times(t0, t1, 32))
+    extra = {}
+    if cond == "v_1":
+        idxs = [grid32[16]]
+    elif cond in ("v_32", "v_32_s448", "v_32_s224", "v_32_s168", "v_32_s336"):
+        idxs = _dedupe(grid32)
+    elif cond == "v_8_s224":
+        idxs = _dedupe(_nearest_indices(ts, _uniform_times(t0, t1, 8)))
+    elif cond in ("v_128", "v_128_s224"):
+        if n < 128:
+            idxs = list(range(n))
+            extra["capped"] = True
+        else:
+            idxs = _dedupe(_nearest_indices(ts, _uniform_times(t0, t1, 128)))
+            extra["capped"] = False
+    elif cond in FPS_CONDS:
+        fps = FPS_CONDS[cond]
+        k = int(math.floor((t1 - t0) * fps + 1e-9)) + 1
+        idxs = _dedupe(_nearest_indices(ts, [t0 + j / fps for j in range(k)]))
+        extra.update(fps=fps, n_grid=len(idxs))
+        tpf = tokens_per_frame(meta, SHORT_SIDE[cond])
+        n_max = int(max(1, ((budget or 58000) - TEXT_RESERVE_TOKENS) // tpf))
+        n_max = min(n_max, max_images or MAX_IMAGES_DEFAULT)
+        extra.update(n_max=n_max, tokens_per_frame=tpf)
+        if len(idxs) > n_max:
+            idxs = _dedupe(_nearest_indices(ts, _uniform_times(t0, t1, n_max)))
+            extra["capped_ctx"] = True
+        else:
+            extra["capped_ctx"] = False
+    elif cond == "v_32_shuffle":
+        idxs = _dedupe(grid32)
+        seed = f"42|{qid}"
+        random.Random(seed).shuffle(idxs)
+        extra["perm_seed"] = seed
+    elif cond in ("v_half1", "v_half2"):
+        tm = (t0 + t1) / 2.0
+        lo, hi = (t0, tm) if cond == "v_half1" else (tm, t1)
+        idxs = _dedupe(_nearest_indices(ts, _uniform_times(lo, hi, 16)))
+    elif cond in ("v_32_off1", "v_32_off2"):
+        seed = f"42|{qid}|{'off1' if cond.endswith('off1') else 'off2'}"
+        phase = random.Random(seed).uniform(0.0, 1.0)
+        w = (t1 - t0) / 32.0
+        idxs = _dedupe(_nearest_indices(ts, [t0 + (j + phase) * w
+                                             for j in range(32)]))
+        extra["offset"] = round(phase, 6)
+    else:
+        raise ValueError(cond)
+    return idxs, extra
+
+
+# ----------------------------------------------------------- decode + resize
+class FrameCache:
+    """LRU of storage-resolution JPEG frame lists keyed (hash, idx-tuple)."""
+
+    def __init__(self, maxsize=12):
+        self.maxsize = maxsize
+        self.d = OrderedDict()
+        self.lock = threading.Lock()
+
+    def get(self, chash, idxs):
+        key = (chash, tuple(idxs))
+        with self.lock:
+            if key in self.d:
+                self.d.move_to_end(key)
+                return self.d[key]
+        path = os.path.join(STORE, "normalized", chash, "video.mp4")
+        decoded = _decode(path, list(idxs))          # dict idx -> PIL
+        avail = max(decoded)
+        frames = []
+        for i in idxs:
+            im = decoded[min(i, avail)].convert("RGB")
+            buf = io.BytesIO()
+            im.save(buf, format="JPEG", quality=JPEG_QUALITY)
+            frames.append((buf.getvalue(), im.size[0], im.size[1]))
+        with self.lock:
+            self.d[key] = frames
+            self.d.move_to_end(key)
+            while len(self.d) > self.maxsize:
+                self.d.popitem(last=False)
+        return frames
+
+
+def _resize_jpegs(frames, scale=None, short_target=None):
+    """Downscale (never upscale) each (jpeg,w,h); returns new list."""
+    out = []
+    for blob, w, h in frames:
+        s = scale
+        if s is None:
+            s = short_target / min(w, h)
+        if s >= 1.0:
+            out.append((blob, w, h))
+            continue
+        im = Image.open(io.BytesIO(blob)).convert("RGB")
+        nw, nh = max(1, round(w * s)), max(1, round(h * s))
+        im = im.resize((nw, nh), Image.LANCZOS)
+        buf = io.BytesIO()
+        im.save(buf, format="JPEG", quality=JPEG_QUALITY)
+        out.append((buf.getvalue(), nw, nh))
+    return out
+
+
+def est_tokens(frames):
+    return sum(math.ceil(w / 32) * math.ceil(h / 32) + TOKEN_OVERHEAD_PER_IMG
+               for _, w, h in frames)
+
+
+def fit_to_budget(frames, budget):
+    """Scale all frames down until the token estimate fits. -> (frames, fitted)"""
+    fitted = False
+    for _ in range(4):
+        e = est_tokens(frames)
+        if e <= budget:
+            break
+        frames = _resize_jpegs(frames, scale=math.sqrt(budget / e) * 0.98)
+        fitted = True
+    return frames, fitted
+
+
+# ------------------------------------------------------------------ vLLM API
+class ContextTooLong(Exception):
+    pass
+
+
+def vllm_chat(endpoint, prompt, frames, max_tokens=128, timeout=(10, 600)):
+    content = [{"type": "image_url",
+                "image_url": {"url": "data:image/jpeg;base64,"
+                              + base64.b64encode(b).decode()}}
+               for b, _, _ in (frames or [])]
+    content.append({"type": "text", "text": prompt})
+    r = requests.post(f"{endpoint}/chat/completions",
+                      json={"model": MODEL_NAME, "temperature": 0.0,
+                            "max_tokens": max_tokens,
+                            "messages": [{"role": "user", "content": content}]},
+                      timeout=timeout)
+    if r.status_code == 400 and ("maximum" in r.text or "longer than" in r.text
+                                 or "context length" in r.text):
+        raise ContextTooLong(r.text[:200])
+    r.raise_for_status()
+    d = r.json()
+    text = (d["choices"][0]["message"]["content"] or "").strip()
+    ptok = (d.get("usage") or {}).get("prompt_tokens", 0)
+    if not text:
+        raise RuntimeError("empty completion")
+    return text, ptok
+
+
+# ------------------------------------------------------------------ run state
+class Ctx:
+    def __init__(self, args):
+        self.endpoints = [e.strip().rstrip("/") for e in args.endpoints.split(",")
+                          if e.strip()]
+        self.budget = args.token_budget
+        self.max_images = getattr(args, "max_images", MAX_IMAGES_DEFAULT)
+        self.cache = FrameCache(args.cache_size)
+        self.key2hash = manifest_map()
+        self.bench_fmt = load_bench_fmt()
+        self.meta_cache, self.meta_lock = {}, threading.Lock()
+        self.io_lock = threading.Lock()
+        self.tick_lock = threading.Lock()
+        self.tick = 0
+        self.cooldown = {}   # endpoint -> unix ts until which it is avoided
+        # a wedged instance (engine dead, frontend still accepting) is a
+        # tar pit: without a cooldown every retry eventually parks there
+        self.done = set()            # (bench, cond, qid) already in the csv
+        self.v32_preds = {}          # (bench, qid) -> pred_raw (for s448 reuse)
+        self.stats = {}              # (bench, cond) -> counters
+        self.stats_lock = threading.Lock()
+        self._load_done()
+
+    def _load_done(self):
+        if not os.path.exists(RESULTS_CSV):
+            return
+        # repair a torn final line (killed mid-append): without the trailing
+        # newline the next append would fuse two rows into one corrupt record
+        with open(RESULTS_CSV, "rb+") as f:
+            f.seek(0, 2)
+            if f.tell() and (f.seek(-1, 2) or True) and f.read(1) != b"\n":
+                f.write(b"\n")
+                log("repaired missing trailing newline in conditions_results.csv")
+        for r in csv.DictReader(open(RESULTS_CSV)):
+            if r.get("model") == MODEL_LABEL:
+                self.done.add((r["benchmark"], r["condition"], r["question_id"]))
+
+    def preload_v32(self, bench):
+        p = f"{RAW_DIR}/v_32/{bench}__{MODEL_LABEL}.jsonl"
+        if os.path.exists(p):
+            for l in open(p):
+                try:
+                    r = json.loads(l)
+                except Exception:
+                    continue
+                if r.get("pred_raw") is not None:
+                    self.v32_preds[(bench, str(r["qid"]))] = r["pred_raw"]
+
+    def next_endpoint(self):
+        now = time.time()
+        with self.tick_lock:
+            for _ in range(len(self.endpoints)):
+                self.tick += 1
+                ep = self.endpoints[self.tick % len(self.endpoints)]
+                if self.cooldown.get(ep, 0) <= now:
+                    return ep
+            return self.endpoints[self.tick % len(self.endpoints)]  # all cooling
+
+    def mark_dead(self, ep, secs=180):
+        with self.tick_lock:
+            self.cooldown[ep] = time.time() + secs
+        log(f"endpoint {ep} on {secs}s cooldown (timeout/conn error)")
+
+    def meta(self, chash):
+        with self.meta_lock:
+            if chash in self.meta_cache:
+                return self.meta_cache[chash]
+        m = json.load(open(os.path.join(STORE, "normalized", chash, "meta.json")))
+        with self.meta_lock:
+            self.meta_cache[chash] = m
+        return m
+
+    def bump(self, bench, cond, **kw):
+        with self.stats_lock:
+            st = self.stats.setdefault((bench, cond), dict(
+                infer=0, reused=0, na=0, fail=0, decode_s=0.0, infer_s=0.0,
+                prompt_tokens=0, fitted=0))
+            for k, v in kw.items():
+                st[k] += v
+
+    def write(self, bench, cond, qid, pred_raw, correct, meta, status="ok"):
+        raw_dir = f"{RAW_DIR}/{cond}"
+        os.makedirs(raw_dir, exist_ok=True)
+        raw_p = f"{raw_dir}/{bench}__{MODEL_LABEL}.jsonl"
+        row = dict(qid=qid, pred_raw=pred_raw, status=status, meta=meta)
+        with self.io_lock:
+            with open(raw_p, "a") as f:
+                f.write(json.dumps(row, ensure_ascii=False) + "\n")
+            new_csv = not os.path.exists(RESULTS_CSV)
+            with open(RESULTS_CSV, "a", newline="") as f:
+                w = csv.writer(f)
+                if new_csv:
+                    w.writerow(["benchmark", "condition", "model",
+                                "question_id", "correct", "raw_output_path"])
+                w.writerow([bench, cond, MODEL_LABEL, qid,
+                            "NA" if correct is None else bool(correct), raw_p])
+            self.done.add((bench, cond, qid))
+        if cond == "v_32" and pred_raw is not None:
+            self.v32_preds[(bench, qid)] = pred_raw
+
+
+# ------------------------------------------------------------------- workers
+def infer_with_retry(ctx, prompt, frames, who):
+    """-> (text, prompt_tokens, n_shrinks, final_frames). Raises on final
+    failure. final_frames is what was ACTUALLY sent (ContextTooLong shrinks
+    mutate the frame list — meta.sent_short_side must reflect it)."""
+    shrinks = 0
+    empties = 0
+    last = None
+    for attempt in range(MAX_ATTEMPTS):
+        ep = ctx.next_endpoint()
+        try:
+            text, ptok = vllm_chat(ep, prompt, frames)
+            return text, ptok, shrinks, frames
+        except ContextTooLong as e:
+            if frames is None or shrinks >= 3:
+                raise
+            frames = _resize_jpegs(frames, scale=0.8)
+            shrinks += 1
+            last = e
+        except (requests.Timeout, requests.ConnectionError) as e:
+            ctx.mark_dead(ep)          # likely wedged/dead instance
+            last = e
+        except RuntimeError as e:
+            if "empty completion" in str(e):
+                # temperature=0: an empty reply is (near-)deterministic —
+                # one cross-endpoint retry, then fail fast instead of
+                # burning all attempts on backoff sleeps
+                empties += 1
+                last = e
+                if empties >= 2:
+                    raise RuntimeError(f"{who}: empty completion x{empties} "
+                                       f"(deterministic at temp=0)")
+                continue
+            last = e
+            time.sleep(min(30, 2 ** attempt + random.uniform(0, 2)))
+        except Exception as e:
+            last = e
+            time.sleep(min(30, 2 ** attempt + random.uniform(0, 2)))
+    raise RuntimeError(f"{who}: {type(last).__name__}: {str(last)[:200]}")
+
+
+def process_row(ctx, bench, row, conds, fmt):
+    qid = str(row["qid"])   # csv resume keys are strings
+    pending = [c for c in conds if (bench, c, qid) not in ctx.done]
+    if not pending:
+        return
+    chash = ctx.key2hash.get(video_key(row))
+    if not chash:
+        # v_blind needs no video; every visual condition is a hard failure
+        visual = [c for c in pending if c not in NO_VIDEO_CONDS]
+        if visual:
+            for c in visual:
+                ctx.bump(bench, c, fail=1)
+            log_failure("stage_p1", f"{bench}::{qid}",
+                        "no normalized video in manifest",
+                        conditions=",".join(visual))
+        pending = [c for c in pending if c in NO_VIDEO_CONDS]
+        if not pending:
+            return
+        meta, stored_ss = {}, None
+    else:
+        try:
+            meta = ctx.meta(chash)
+        except Exception as e:
+            # manifest says done but meta.json is missing/corrupt: fail the
+            # visual conditions INDIVIDUALLY (qid + condition list logged),
+            # keep v_blind — never abort the whole row anonymously
+            visual = [c for c in pending if c not in NO_VIDEO_CONDS]
+            for c in visual:
+                ctx.bump(bench, c, fail=1)
+            if visual:
+                log_failure("stage_p1", f"{bench}::{qid}",
+                            f"meta.json unreadable for {chash}: "
+                            f"{type(e).__name__}: {e}",
+                            conditions=",".join(visual))
+            pending = [c for c in pending if c in NO_VIDEO_CONDS]
+            if not pending:
+                return
+            meta, stored_ss = {}, None
+        else:
+            stored_ss = meta.get("normalized_short_side")
+    opts = row.get("options")
+    for cond in pending:
+        base_meta = dict(stored_short_side=stored_ss)
+        try:
+            if cond in NA_WHEN_TOO_SHORT and meta.get("too_short"):
+                ctx.write(bench, cond, qid, None, None,
+                          dict(base_meta, reason="too_short"), status="NA")
+                ctx.bump(bench, cond, na=1)
+                continue
+            if cond == "v_32_s448" and stored_ss == 480:
+                pred = ctx.v32_preds.get((bench, qid))
+                if pred is None:
+                    ctx.bump(bench, cond, fail=1)
+                    log_failure("stage_p1", f"{bench}::{qid}::{cond}",
+                                "v_32 result missing for stored-480 reuse; "
+                                "run v_32 first")
+                    continue
+                ok = score(pred, row.get("answer"), opts, fmt)
+                ctx.write(bench, cond, qid, pred, ok,
+                          dict(base_meta, reused_from="v_32"))
+                ctx.bump(bench, cond, reused=1)
+                continue
+            frames = None
+            if cond == "v_blind":
+                prompt = PROMPT.format(intro=INTRO_BLIND, q=row["question"],
+                                       opts=fmt_opts(opts))
+            elif cond == "v_opt_only":
+                if not opts:
+                    ctx.bump(bench, cond, fail=1)
+                    log_failure("stage_p1", f"{bench}::{qid}", "v_opt_only: item has no options list", conditions=cond)
+                    continue
+                prompt = PROMPT_OPT_ONLY.format(intro=INTRO_OPT_ONLY, opts=fmt_opts(opts))
+            else:
+                idxs, extra = cond_indices(cond, meta, qid, ctx.budget, ctx.max_images)
+                base_meta.update(extra)
+                t0 = time.time()
+                if cond in V32_SHARED and cond != "v_32":
+                    # share the v_32 decode pass (shuffle reorders afterwards)
+                    v32_idxs, _ = cond_indices("v_32", meta, qid)
+                    got = ctx.cache.get(chash, v32_idxs)
+                    pos = {ix: j for j, ix in enumerate(v32_idxs)}
+                    frames = [got[pos[i]] for i in idxs]
+                elif cond in FPS_CONDS:
+                    # one decode pass for the whole fps ladder: union of the four (capped) grids
+                    union = set()
+                    for c in FPS_CONDS:
+                        union.update(cond_indices(c, meta, qid, ctx.budget, ctx.max_images)[0])
+                    union = sorted(union)
+                    got = ctx.cache.get(chash, union)
+                    pos = {ix: j for j, ix in enumerate(union)}
+                    frames = [got[pos[i]] for i in idxs]
+                else:
+                    frames = ctx.cache.get(chash, idxs)
+                if cond in SHORT_SIDE:
+                    frames = _resize_jpegs(frames, short_target=SHORT_SIDE[cond])
+                ctx.bump(bench, cond, decode_s=time.time() - t0)
+                frames, fitted = fit_to_budget(frames, ctx.budget)
+                if fitted:
+                    base_meta["fit_short_side"] = min(min(w, h)
+                                                      for _, w, h in frames)
+                    ctx.bump(bench, cond, fitted=1)
+                base_meta["n_frames_used"] = len(frames)
+                prompt = PROMPT.format(intro=INTRO_VISUAL.format(n=len(frames)),
+                                       q=row["question"], opts=fmt_opts(opts))
+            t1 = time.time()
+            pred, ptok, shrinks, sent_frames = infer_with_retry(
+                ctx, prompt, frames, f"{bench}/{cond}/{qid}")
+            ctx.bump(bench, cond, infer_s=time.time() - t1, prompt_tokens=ptok)
+            if shrinks:
+                base_meta["ctx_shrinks"] = shrinks
+            if sent_frames:
+                # AFTER retries: ContextTooLong shrinks scale the frames, so
+                # the recorded resolution must be what was actually sent
+                base_meta["sent_short_side"] = min(min(w, h)
+                                                   for _, w, h in sent_frames)
+            ok = score(pred, row.get("answer"), opts, fmt)
+            ctx.write(bench, cond, qid, pred[:2000], ok, base_meta)
+            ctx.bump(bench, cond, infer=1)
+        except Exception as e:
+            ctx.bump(bench, cond, fail=1)
+            log_failure("stage_p1", f"{bench}::{qid}::{cond}",
+                        f"{type(e).__name__}: {e}")
+
+
+# ---------------------------------------------------------------------- main
+def order_conditions(conds):
+    bad = [c for c in conds if c not in CONDITIONS]
+    if bad:
+        sys.exit(f"unknown conditions: {bad}")
+    return [c for c in CONDITIONS if c in conds]
+
+
+def run_bench(ctx, path, conds, limit, workers, dry):
+    bench = os.path.basename(path)[:-6]
+    fmt = ctx.bench_fmt.get(bench, "")
+    rows = [json.loads(l) for l in open(path) if l.strip()]
+    # duplicate qids would race past the resume check and append twice
+    seen_q, uniq = set(), []
+    for r in rows:
+        if str(r["qid"]) in seen_q:
+            continue
+        seen_q.add(str(r["qid"]))
+        uniq.append(r)
+    if len(uniq) != len(rows):
+        log(f"{bench}: {len(rows) - len(uniq)} duplicate qid row(s) in the "
+            f"samples file — deduped (first wins)")
+    rows = uniq
+    if limit:
+        rows = rows[:limit]
+    ctx.preload_v32(bench)
+    # sort by video hash so the frame cache gets adjacent same-video rows
+    rows.sort(key=lambda r: (ctx.key2hash.get(video_key(r), ""), str(r["qid"])))
+    todo = [r for r in rows
+            if any((bench, c, str(r["qid"])) not in ctx.done for c in conds)]
+    if dry:
+        for c in conds:
+            miss = sum(1 for r in rows
+                       if (bench, c, str(r["qid"])) not in ctx.done)
+            na = reuse = novideo = 0
+            for r in rows:
+                if (bench, c, str(r["qid"])) in ctx.done:
+                    continue
+                h = ctx.key2hash.get(video_key(r))
+                if not h:
+                    novideo += 1
+                    continue
+                try:
+                    m = ctx.meta(h)
+                except Exception:      # video not present in this copy of the store
+                    novideo += 1
+                    continue
+                if c in NA_WHEN_TOO_SHORT and m.get("too_short"):
+                    na += 1
+                elif c == "v_32_s448" and m.get("normalized_short_side") == 480:
+                    reuse += 1
+            log(f"DRY {bench}/{c}: todo={miss} of {len(rows)} "
+                f"(na={na} reuse={reuse} no_video={novideo} infer={miss - na - reuse - novideo})")
+        return
+    t0 = time.time()
+    log(f"{bench}: {len(todo)} rows x {len(conds)} conditions "
+        f"(of {len(rows)} sampled)")
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        futs = [ex.submit(process_row, ctx, bench, r, conds, fmt) for r in todo]
+        for i, fut in enumerate(as_completed(futs)):
+            try:
+                fut.result()
+            except Exception as e:      # row-level crash must not kill the bench
+                log_failure("stage_p1", f"{bench}::row", f"{type(e).__name__}: {e}")
+            if (i + 1) % 25 == 0:
+                done_inf = sum(v["infer"] for (b, _), v in ctx.stats.items()
+                               if b == bench)
+                log(f"{bench}: {i + 1}/{len(todo)} rows (infer={done_inf})")
+    wall = time.time() - t0
+    with open(TIMING_LOG, "a") as f:
+        for (b, c), st in sorted(ctx.stats.items()):
+            if b != bench:
+                continue
+            f.write(json.dumps(dict(ts=time.strftime("%F %T"), bench=b,
+                                    condition=c, wall_s=round(wall, 1), **{
+                                        k: (round(v, 1) if isinstance(v, float)
+                                            else v) for k, v in st.items()}))
+                    + "\n")
+            log(f"{b}/{c}: infer={st['infer']} reused={st['reused']} "
+                f"na={st['na']} fail={st['fail']} decode={st['decode_s']:.0f}s "
+                f"infer={st['infer_s']:.0f}s ptok={st['prompt_tokens']}")
+    log(f"{bench}: bench wall {wall / 60:.1f} min")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--bench", default=None,
+                    help="comma list of exact names, or a substring")
+    ap.add_argument("--conditions", default=",".join(CONDITIONS))
+    ap.add_argument("--limit", type=int, default=None)
+    ap.add_argument("--workers", type=int, default=12)
+    ap.add_argument("--endpoints", default=DEFAULT_ENDPOINTS)
+    ap.add_argument("--token-budget", type=int, default=58000)
+    ap.add_argument("--max-images", type=int, default=MAX_IMAGES_DEFAULT,
+                    help="upper bound of frames per request for the fps ladders (= vLLM --limit-mm-per-prompt images)")
+    ap.add_argument("--cache-size", type=int, default=12)
+    ap.add_argument("--dry-run", action="store_true")
+    a = ap.parse_args()
+    conds = order_conditions([c.strip() for c in a.conditions.split(",")
+                              if c.strip()])
+    import glob
+    files = sorted(glob.glob(f"{SAMPLES_DIR}/*.jsonl"))
+    if a.bench:
+        names = [b.strip() for b in a.bench.split(",") if b.strip()]
+        exact = [f for f in files if os.path.basename(f)[:-6] in names]
+        files = exact or [f for f in files
+                          if any(n in os.path.basename(f) for n in names)]
+    if not files:
+        sys.exit("no benchmarks matched")
+    ctx = Ctx(a)
+    log(f"model={MODEL_NAME} ({MODEL_LABEL}) endpoints={len(ctx.endpoints)} "
+        f"benches={[os.path.basename(f)[:-6] for f in files]} conds={conds} "
+        f"resume_keys={len(ctx.done)} samples={SAMPLES_DIR} results_root={RESULTS_ROOT}")
+    t0 = time.time()
+    for p in files:
+        run_bench(ctx, p, conds, a.limit, a.workers, a.dry_run)
+    log(f"ALL DONE in {(time.time() - t0) / 60:.1f} min")
+
+
+if __name__ == "__main__":
+    main()

code/exp/video_benchmarks.csv

@@ -0,0 +1,215 @@
+name,hf_repo,eval_type,question_format,has_chance_level,num_options,text_heavy,video_repo
+Video-MME,lmms-eval/Video-MME,llm_fallback,mixed,False,4,False,
+LongVideoBench,longvideobench/LongVideoBench,llm_fallback,mixed,False,5,False,
+MLVU,sy1998/MLVU_dev,llm_fallback,MCQ,False,,False,
+MVBench,OpenGVLab/MVBench,llm_fallback,mixed,False,,False,
+VideoMMMU,lmms-eval/VideoMMMU,rule_only,MCQ,True,4,True,
+EgoSchema,lmms-eval/egoschema,rule_only,MCQ,True,4,False,
+LVBench,lmms-eval/LVBench,rule_only,MCQ,False,,False,
+NExT-QA,lmms-eval/NExTQA,rule_only,MCQ,True,4,False,
+PerceptionTest,lmms-eval/PerceptionTest,rule_only,MCQ,False,,False,lmms-eval/PerceptionTest_Val
+MMVU,lmms-eval/MMVU,llm_required,MCQ,False,,False,
+MMBench-Video,opencompass/MMBench-Video,llm_required,open,False,,False,
+Charades-STA,lmms-eval/charades_sta,rule_only,mixed,False,,False,
+TempCompass,lmms-eval/TempCompass,llm_fallback,mixed,False,2,False,
+ActivityNet-QA,lmms-eval/ActivityNetQA,llm_required,open,False,,False,
+VideoChatGPT,lmms-eval/VideoChatGPT,llm_required,open,False,,False,
+MotionBench,zai-org/MotionBench,rule_only,MCQ,True,5,False,
+VSI-Bench,nyu-visionx/VSI-Bench,rule_only,MCQ,False,,False,
+CG-Bench,CG-Bench/CG-Bench,llm_required,mixed,False,,False,
+HourVideo,HourVideo/HourVideo,rule_only,MCQ,False,,False,
+VideoDetailCaption,lmms-lab/VideoDetailDescription,llm_required,open,False,,False,
+TOMATO,lmms-eval/TOMATO,llm_required,MCQ,True,4,False,
+Video-MME-v2,MME-Benchmarks/Video-MME-v2,llm_fallback,mixed,False,5,False,
+WorldSense,lmms-lab/worldsense,llm_fallback,mixed,False,4,False,
+ActivityNet-Captions,unknown,rule_only,open,False,,False,
+STAR,unknown,rule_only,MCQ,False,,False,
+DREAM-1K,mjuicem/DREAM-1k-VLMEvalKit,llm_required,open,False,,False,omni-research/DREAM-1K
+MovieChat-1K,Enxin/lmms_MovieChat_test,llm_required,open,False,,False,
+Kinetics-700,unknown,unknown,unknown,False,,False,
+ReVSI,3dlg-hcvc/ReVSI,rule_only,MCQ,False,,False,
+VSI-Super,nyu-visionx/VSI-SUPER-Count,rule_only,MCQ,False,,False,
+TimeLens,kcz358/timelens,rule_only,grounding,False,,False,
+VDC,wchai/lmms_VDC_test,llm_required,open,False,,False,
+VideoEval-Pro,TIGER-Lab/VideoEval-Pro,llm_required,MCQ,False,,False,
+FAVOR-Bench,FAVOR-Bench/FAVOR,rule_only,mixed,False,,False,
+Video-Holmes,TencentARC/Video-Holmes,llm_fallback,MCQ,True,6,False,
+MSVD-QA,unknown,rule_only,open,False,,False,
+Molmo2-VideoCount,allenai/Molmo2-VideoCountEval,rule_only,numeric,False,,False,
+VideoHallucer,bigai-nlco/VideoHallucer,rule_only,MCQ,False,,False,
+StreamingBench,mjuicem/StreamingBench,rule_only,MCQ,False,,False,
+Video-TT,lmms-eval/video-tt,llm_fallback,mixed,False,5,unknown,
+OMTGBench,insomnia7/omtg_bench,rule_only,grounding,False,,False,
+SiteBench-Video,franky-veteran/SITE-Bench,rule_only,mixed,False,4,False,
+LongTimeScope,Apollo-LMMs/LongTimeScope2,rule_only,MCQ,False,,unknown,
+LSDBench,TainU/LSDBench,rule_only,open,False,,False,
+MVP-Bench,facebook/minimal_video_pairs,rule_only,MCQ,False,,unknown,
+OSI-Bench,HarmlessSR07/OSI-Bench,rule_only,mixed,False,,unknown,
+PAIBench-U,Jialuo21/PAIBench-U,rule_only,MCQ,True,2/3/4,unknown,
+SIS-Bench,choucsan/SIS-Bench,rule_only,MCQ,True,4,unknown,
+FALCONBench,cplou99/FALCON-Bench,llm_required,mixed,False,4,False,
+DSRBench,lmms-lab-si/EASI-Leaderboard-Data,rule_only,MCQ,True,4,False,
+STI-Bench,MINT-SJTU/STI-Bench,rule_only,MCQ,True,5,False,
+MVTamperBench,Srikant86/MVTamperBench,llm_fallback,mixed,False,,False,
+OVOBench,kcz358/OVOBench,rule_only,open,False,,False,JoeLeelyf/OVO-Bench
+RepCount,lmms-lab-eval/repcount,rule_only,open,False,,False,
+SSv2,lmms-lab-eval/ssv2,rule_only,open,False,,False,
+TemporalBench,microsoft/TemporalBench,rule_only,open,False,,False,
+QBench-Video,zhangzicheng/Q-Bench-Video,rule_only,MCQ,False,,False,
+EgoTaskQA,nv-njb/EgoTaskQA-MCQ,rule_only,MCQ,False,,False,
+Countix,unknown,rule_only,open,False,,False,
+HD-EPIC,unknown,rule_only,grounding,False,,False,
+FunQA,fesvhtr/FunQA_LMMs,llm_required,open,False,,False,
+MMWorld,MMWorld/MMWorld,rule_only,MCQ,True,4,False,
+Minerva,unknown,rule_only,unknown,False,,False,
+EgoTempo,lmms-lab-eval/egotempo,rule_only,grounding,False,,False,
+PLM-VideoBench,facebook/PLM-VideoBench,llm_required,mixed,False,,False,
+Vinoground,HanSolo9682/Vinoground,rule_only,open,False,,False,
+Video-MMLU,Enxin/Video-MMLU,llm_required,open,False,,True,
+VITATECS,lscpku/VITATECS,llm_required,mixed,False,,False,
+CG-AV-Counting,CG-Bench/CG-AV-Counting,rule_only,mixed,False,,False,
+OVR-Kinetics,lmms-lab-eval/ovr_kinetics,rule_only,mixed,False,,False,
+CVRR-ES,lmms-eval/CVRR-ES,llm_required,open,False,,False,
+TVBench,FunAILab/TVBench,rule_only,mixed,False,,False,
+CinePile,tomg-group-umd/cinepile,rule_only,MCQ,True,5,False,
+Neptune,lmms-eval/GoogleDeepMind-NEPTUNE,rule_only,MCQ,True,5,False,
+EgoPlan-Bench,EgoLife-v1/EgoPlan,rule_only,mixed,False,4,False,
+EgoExoBench,Heleun/EgoExoBench_MCQ,llm_fallback,MCQ,False,,False,
+SciVideoBench,groundmore/scivideobench,rule_only,MCQ,True,10,True,
+VideoMathQA,MBZUAI/VideoMathQA,rule_only,mixed,False,5,True,
+MMSI-Video,oscarqjh/MMSI-Video-Bench_lmmseval,rule_only,unknown,False,,False,
+V2P-Bench,gaotiexinqu/V2P-Bench,rule_only,MCQ,False,,False,
+VCR-Bench,VLM-Reasoning/VCR-Bench,rule_only,MCQ,True,3/4/5,False,
+MEGA-Bench(video),TIGER-Lab/MEGA-Bench,rule_only,grounding,False,,unknown,
+AV-SpeakerBench,plnguyen2908/AV-SpeakerBench,rule_only,MCQ,True,4,False,
+AV-Odyssey,AV-Odyssey/AV_Odyssey_Bench_LMMs_Eval,rule_only,MCQ,True,4,False,
+CameraBench,chancharikm/camerabench_vqa_lmms_eval,rule_only,MCQ,True,2,False,
+COVER,lmms-lab-eval/COVER,rule_only,MCQ,False,,unknown,PeterPanonly/COVER
+CUVA,fesvhtr/CUVA_LMMs,rule_only,open,False,,False,
+IntPhys2,facebook/IntPhys2,rule_only,open,False,,False,
+JumpScore,lmms-lab-encoder/JumpScore,rule_only,mixed,False,,unknown,
+TimeScope,Apollo-LMMs/TimeScope,rule_only,MCQ,False,,False,
+LongVT,longvideotool/VideoSIAH-Eval,rule_only,MCQ,True,4,unknown,
+Lemonade,amathislab/LEMONADE,rule_only,MCQ,True,4,unknown,
+MMOU,kcz358/MMOU,rule_only,MCQ,True,10,unknown,
+PerceptionComp,hrinnnn/PerceptionComp,rule_only,MCQ,True,5,unknown,
+PhysicalAI-Understanding,shi-labs/physical-ai-bench-understanding,rule_only,MCQ,True,4,False,
+PushupBench,anonymousatom/pushupbench,rule_only,numeric,False,,False,
+SpatialTreeBench,LongfeiLi/SpatialTree-Bench,rule_only,MCQ,False,,False,
+VStaT,nyu-visionx/vstat,rule_only,MCQ,False,,unknown,
+WorldQA,lmms-eval/worldqa,llm_required,MCQ,True,4,False,
+ExtremeWhenBench,min1321/extreme-when-bench,rule_only,grounding,False,,False,
+MVU-Eval,MVU-Eval-Team/MVU-Eval-Data,rule_only,MCQ,False,,unknown,
+VIABench,MCG-NJU/VIABench,unknown,open,False,NA,unknown,
+E-VQA,Salesforce/ST-Evidence-Bench,rule_only,mixed,False,5,unknown,
+Camera Movement Understanding (BU/Google),Yuwen2024/ACaM-Bench,unknown,MCQ,True,4,unknown,
+AnyGroundBench,rinost081/AnyGroundBench,unknown,grounding,False,NA,unknown,
+VidPair-Halluc,Jethro37/VidPair-Halluc,rule_only,MCQ,True,2,unknown,
+Video-MME-Logical,marcuskwan/video-mme-logical,rule_only,open,False,NA,unknown,
+Ego-MC-Bench,neuripsedtracksub/ego-counterfactual-mistakes,unknown,mixed,False,NA,unknown,
+ChronoPhyBench,Kohsin/ChronoPhyBench,unknown,mixed,False,NA,unknown,
+VideoKR,minuzero/VideoKR-Eval,llm_fallback,mixed,False,NA,unknown,
+VideoOdyssey,maifoundations/VideoOdyssey,rule_only,MCQ,True,4,unknown,
+Artifact-Bench,DogNeverSleep/Artifact-Bench,rule_only,mixed,False,NA,unknown,
+VURB,wyccccc/VURB_Data,unknown,MCQ,False,NA,unknown,
+SFI-Bench,le723z/SFI-Bench,unknown,MCQ,True,4,unknown,
+GasVideo-1000,kk12ff/GasVideo1000,unknown,mixed,False,NA,unknown,
+VideoZeroBench,marinero4972/VideoZeroBench,rule_only,mixed,False,NA,unknown,
+SAW-Bench,ucsbai/SAW-Bench,llm_fallback,MCQ,True,3,unknown,
+TimeBlind,BaiqiL/TimeBlind,rule_only,MCQ,True,2,unknown,
+AVMeme Exam,naplab/AVMeme-Exam,unknown,MCQ,False,NA,unknown,
+FutureOmni,OpenMOSS-Team/FutureOmni,rule_only,MCQ,False,4 or 6,unknown,
+VKnowU,Eurayka/VKnowU,rule_only,MCQ,False,NA,unknown,
+TeleEgo,David0219/TeleEgo,llm_fallback,mixed,False,NA,unknown,
+DSI-Bench,Viglong/DSI-Bench,rule_only,MCQ,True,4,unknown,
+Omni-Cloze,BoJack/Omni-Cloze,llm_required,MCQ,True,5,unknown,
+ExpVid,OpenGVLab/ExpVid,unknown,mixed,False,NA,unknown,
+EgoNight,dehezhang2/EgoNight,llm_fallback,open,False,NA,unknown,
+v-HUB,Foreverskyou/v-HUB,llm_fallback,mixed,False,5,unknown,
+ELV-Halluc,HLSv/ELV-Halluc,rule_only,MCQ,True,2,unknown,shuzhig/elv-halluc-videos
+RynnEC-Bench,Alibaba-DAMO-Academy/RynnEC-Bench,llm_required,mixed,False,NA,unknown,
+GLIMPSE,AIMING-Lab-UNC/GLIMPSE,rule_only,MCQ,True,4,unknown,
+SoMi-ToM,SoMi-ToM/SoMi-ToM,rule_only,MCQ,True,3,unknown,
+ShotBench,Vchitect/ShotBench,llm_fallback,MCQ,True,4,unknown,
+VRBench,OpenGVLab/VRBench,llm_required,mixed,False,NA,unknown,
+ViMUL-Bench,MBZUAI/ViMUL-Bench,llm_required,mixed,False,4,unknown,
+MF2 (Movie Facts and Fibs),sardinelab/MF2,rule_only,MCQ,True,2,unknown,
+MORSE-500,video-reasoning/morse-500,llm_required,mixed,False,NA,unknown,
+MMR-V,JokerJan/MMR-VBench,rule_only,MCQ,False,NA,unknown,
+SAVVY-Bench,uwneuroai/SAVVY-Bench,rule_only,mixed,False,4,unknown,
+AoTBench,sherryxzh/AoTBench,rule_only,MCQ,False,NA,unknown,
+VSI-Super-Wild,THUSI-Lab/VSI-Super-Wild,rule_only,mixed,False,NA,unknown,
+FindingDory,yali30/findingdory,rule_only,grounding,False,NA,unknown,
+ExAct,Alexhimself/ExAct,rule_only,MCQ,True,5,unknown,
+K9-Bench,K9Bench/K9Bench,unknown,MCQ,False,,True,yt::K9-Bench
+S3-Bench,kszucs/buckets-vs-s3-benchmark,unknown,mixed,False,,True,
+REVEAL,aaeagal/Reveal,unknown,mixed,False,,True,
+HumanPCR,HumanPCR/HumanPCR,rule_only,mixed,False,,True,
+EgoMonth,anonymous-egomonth/egomonth-dataset,rule_only,mixed,False,,True,
+VideoGAIA,Karl28/VideoGAIA,unknown,mixed,False,,True,
+TAR-Bench,nvidia/PhysicalAI-Traffic-Anomaly-Reasoning,rule_only,mixed,False,,True,
+VideoVIBE,AdwolfCzar/video_vibe_captioned_dataset,unknown,MCQ,False,,True,
+ViSTR-Bench,homothetic/ViSTR-Bench-Public,unknown,MCQ,False,,True,
+LongVILBench,cq838/LongVILBench,rule_only,mixed,False,,True,
+ID-VTG,Chloe-UniU-oO/ID-VTG,rule_only,mixed,False,,True,
+RISE-Bench,PhoenixZ/RISEBench,rule_only,mixed,False,,True,
+UAV-DualCog,Lozumi/UAV-DualCog,unknown,mixed,False,,True,
+SLVMBench,SLVMBench/SLVMBench,unknown,MCQ,False,,True,
+S-EMBER,facebook/S-EMBER,unknown,mixed,False,,True,
+MedStreamBench,Venn2024/MedStreamBench,unknown,mixed,False,,True,
+VideoLLM-BoE,lab-flair/VideoLLM-BoE,unknown,MCQ,False,,True,
+OmniVDCBench,videobenchlab/omniVDCBench,rule_only,mixed,False,,True,
+ReactHuman Benchmark (Scaled),Alan123/reacthuman-benchmark-scaled-with-videos,rule_only,MCQ,False,,True,
+VideoMemory-Bench,viktorcyt/VideoMemory-Bench,rule_only,MCQ,False,,True,
+VideoAesBench,chris-123/VideoAesBench,unknown,mixed,False,,True,
+V-NIAH-D,Tianyi1112/VideoRoPE,rule_only,MCQ,False,,True,
+VideoIntentMCQ_OE,KHUjongseo/VideoIntentMCQ_OE,unknown,mixed,False,,True,
+NaturalBench-Video,BaiqiL/NaturalBench-Video,rule_only,MCQ,False,,True,
+LongVideo-Reason-eval,LongVideo-Reason/longvideo_eval_videos,unknown,MCQ,False,,True,
+Causal2Needles,causal2needles/Causal2Needles,unknown,mixed,False,,True,
+InstructionBench,sunwhw/InstructionBench,mixed,mixed,False,,True,
+TemporalVQA,fazliimam/temporal-vqa,rule_only,MCQ,False,,True,
+Charades-CON / ActivityNet-CON,mjjung/Consistency-Evaluation-for-Video-LLMs,rule_only,MCQ,False,,True,
+TaskMeAnything-v1-videoqa-2024,weikaih/TaskMeAnything-v1-videoqa-2024,rule_only,MCQ,False,,True,local::TaskMeAnything-v1-videoqa-2024
+Colon-Bench,ajhamdi/colon-bench,unknown,MCQ,True,5,True,
+"ID-VTG (IDVTG-Gym, IDVTG-InternVid)",Chloe-UniU-oO/ID-VTG,unknown,mixed,False,,True,
+SVCBench,buaaplay/SVCBench,unknown,numeric,False,,True,
+ScaleLong,m-a-p/ScaleLong,unknown,MCQ,False,,True,
+TOC-Bench,anonymous-video-benchmark/toc_bench,unknown,mixed,False,,True,
+VideoGameQA-Bench,taesiri/VideoGameQA-Bench,unknown,mixed,False,,True,
+IV-Bench,m-a-p/IV-Bench,unknown,MCQ,False,,True,
+SmartHome-Bench,violetcliff/SmartHome-Bench,unknown,MCQ,False,,True,yt::SmartHome-Bench
+VStream-QA,IVGSZ/VStream-QA,unknown,mixed,False,,True,
+Charades-CON,mjjung/Consistency-Evaluation-for-Video-LLMs,unknown,MCQ,False,,True,lmms-eval/charades_sta
+ActivityNet-CON,mjjung/Consistency-Evaluation-for-Video-LLMs,unknown,MCQ,False,,True,friedrichor/ActivityNet_Captions
+EventHallusion,lccshunli/EventHallusion,unknown,MCQ,False,,True,lccshunli/EventHallusion
+KFS-Bench,longvideobench/LongVideoBench,unknown,MCQ,False,,True,longvideobench/LongVideoBench
+UCF101-AD,raiyaanabdullah/UCF101-AD,unknown,MCQ,False,,True,raiyaanabdullah/UCF101-AD
+iSafetyBench,raiyaanabdullah/isafety-bench,unknown,MCQ,False,,True,raiyaanabdullah/isafety-bench
+OVO-S-Bench,JoeLeelyf/OVO-S-Bench,unknown,MCQ,False,,True,url::OVO-S-Bench
+VANE-Bench,rohit901/VANE-Bench,unknown,MCQ,False,,True,local::VANE-Bench
+M^3-Verse,modelscope::WalKaWay/M3-Verse,unknown,MCQ,False,,True,local::M^3-Verse
+VNBench,videoniah/VNBench,unknown,MCQ,False,,True,local::VNBench
+CAViAR,sparshgarg57/CAViAR,unknown,MCQ,False,,True,nexar-ai/nexar_collision_prediction
+Video-LevelGauge,Cola-any/Video-LevelGauge,unknown,MCQ,False,,True,
+HERBench,DanBenAmi/HERBench,unknown,MCQ,False,,False,
+MME-VideoOCR,DogNeverSleep/MME-VideoOCR_Dataset,unknown,MCQ,False,,True,
+E.T. Bench,PolyU-ChenLab/ETBench,unknown,MCQ,False,,False,
+VRU-Accident,VRUAccidentAnonymous/VRU-Accident,unknown,MCQ,False,,True,
+ALLVB,ALLVB/ALLVB,unknown,MCQ,False,,False,
+GUI-World,ONE-Lab/GUI-World,unknown,MCQ,False,,True,
+VideoEspresso,hshjerry0315/VideoEspresso-Test,unknown,MCQ,False,,True,
+VAU-Bench (UCF-Crime),7xiang/VAU-Bench,unknown,MCQ,False,,False,AllenXeon/ucf_crime
+VF-Eval,songtingyu/vf-eval,unknown,MCQ,False,,True,
+UrbanVideo-Bench,EmbodiedCity/UrbanVideo-Bench,unknown,MCQ,False,,False,
+HLV-1K,ZouHQ/HLV-1K,unknown,MCQ,False,,True,yt::HLV-1K
+CineTechBench,Xinran0906/CineTechBench,unknown,MCQ,False,,True,yt::CineTechBench
+ReXTime,ReXTime/ReXTime,unknown,MCQ,False,,True,yt::ReXTime
+LOKI,bczhou/LOKI,unknown,MCQ,False,,True,
+ContPhy,zzcnewly/ContPhy_Dataset,unknown,MCQ,False,,True,
+FineBench,FINEBENCH/FineBench,unknown,MCQ,False,,False,yt::FineBench
+ForeSeaQA,qualcomm/ForeSeaQA,unknown,MCQ,False,,False,AllenXeon/ucf_crime
+VideoAds,Zheyuan14/VideoAds,unknown,MCQ,False,,False,
+VELOCITI,katha-ai-iiith/VELOCITI,unknown,MCQ,False,,False,
+VGenST-Bench,NeurIPS2026-VGenST-Bench/VGenST-Bench,unknown,MCQ,False,,False,
+SportsD,addisonwu05/sportsd,unknown,MCQ,False,,False,

code/requirements.txt

@@ -0,0 +1,10 @@
+# origin cluster versions (Python 3.12); vLLM CUDA 12.8 wheels (RTX 5090 = sm_120 needs torch 2.8 cu128)
+vllm==0.11.0
+torch==2.8.0
+transformers==4.57.6
+decord>=0.6.0          # frame decoder (fallbacks: opencv-python-headless, ffmpeg on PATH)
+opencv-python-headless>=4.10
+pillow>=10
+pyyaml>=6
+requests>=2.32
+huggingface_hub>=0.34

code/run_frames_pixels.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+# run_frames_pixels.sh — task 11 (resolution x frame-rate sweep) on a multi-GPU machine without Slurm.
+#   bash code/run_frames_pixels.sh --dry-run                 # count the work per benchmark x condition (no GPU)
+#   PILOT=1 bash code/run_frames_pixels.sh                    # MVBench, LVBench, TimeScope only (report timing first)
+#   bash code/run_frames_pixels.sh                            # all 84 benchmarks
+#   BENCH="MVBench,LVBench" bash code/run_frames_pixels.sh    # explicit benchmark list
+# One vLLM server per GPU (Qwen3-VL-8B, --max-model-len 65536, --limit-mm-per-prompt images 1024), one
+# runner process that round-robins over the servers. Resumable: rows already in results/conditions_results.csv
+# are skipped, so the conditions that exist on the origin cluster are never re-run.
+# Env: NGPU (default all), WORKERS (default 4 per GPU), GPU_UTIL (0.85), MAX_SEQS (default 8), PORT0 (8011),
+#      PY (python3), VLLM (vllm), CONDS (default: the task-11 list below), TOKEN_BUDGET (58000), MAX_IMAGES (1024)
+set -u
+CODE=$(cd "$(dirname "$0")" && pwd); ROOT=$(cd "$CODE/.." && pwd)
+export BENCH_BASE=${BENCH_BASE:-$ROOT/data}            # <root>/data/store/normalized/<hash>/..., <root>/data/logs
+export P1_SAMPLES_DIR=${P1_SAMPLES_DIR:-$ROOT/items/samples}
+export P1_RESULTS_ROOT=${P1_RESULTS_ROOT:-$ROOT/results}
+export P1_MANIFEST=${P1_MANIFEST:-$ROOT/manifest/manifest_subset.jsonl}
+mkdir -p "$BENCH_BASE/logs" "$P1_RESULTS_ROOT" "$ROOT/logs"
+[ -d "$BENCH_BASE/store/normalized" ] || { echo "unpack the video shards into $BENCH_BASE/store/normalized first"; exit 2; }
+PY=${PY:-python3}; VLLM=${VLLM:-vllm}; PORT0=${PORT0:-8011}; GPU_UTIL=${GPU_UTIL:-0.85}; MAX_SEQS=${MAX_SEQS:-8}
+TOKEN_BUDGET=${TOKEN_BUDGET:-58000}; MAX_IMAGES=${MAX_IMAGES:-1024}
+MODEL="Qwen/Qwen3-VL-8B-Instruct"; REV=0c351dd01ed87e9c1b53cbc748cba10e6187ff3b
+CONDS=${CONDS:-v_blind,v_1,v_32,v_32_s448,v_32_s224,v_32_s168,v_32_s336,v_8_s224,v_128_s224,v_fps0.25_s224,v_fps0.5_s224,v_fps1_s224,v_fps2_s224}
+RUNNER="$CODE/exp/pipeline/stage_p1_runner.py"
+if [ "${PILOT:-0}" = "1" ]; then BENCH=${BENCH:-MVBench,LVBench,TimeScope}; fi
+BENCH_ARG=(); [ -n "${BENCH:-}" ] && BENCH_ARG=(--bench "$BENCH")
+if [ "${1:-}" = "--dry-run" ]; then
+  "$PY" "$RUNNER" --conditions "$CONDS" --endpoints http://127.0.0.1:1/v1 --token-budget "$TOKEN_BUDGET" --max-images "$MAX_IMAGES" "${BENCH_ARG[@]}" --dry-run; exit $?
+fi
+NGPU=${NGPU:-$(nvidia-smi -L 2>/dev/null | wc -l)}; [ "$NGPU" -ge 1 ] || { echo "no GPU found"; exit 2; }
+WORKERS=${WORKERS:-$((4 * NGPU))}
+export VLLM_USE_FLASHINFER_SAMPLER=0 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True TOKENIZERS_PARALLELISM=false
+PIDS=(); EPS=""
+for i in $(seq 0 $((NGPU - 1))); do
+  PORT=$((PORT0 + i)); EPS="${EPS:+$EPS,}http://127.0.0.1:$PORT/v1"
+  CUDA_VISIBLE_DEVICES=$i "$VLLM" serve "$MODEL" --revision "$REV" --served-model-name "$MODEL" --host 127.0.0.1 --port "$PORT" \
+      --max-model-len 65536 --gpu-memory-utilization "$GPU_UTIL" --max-num-seqs "$MAX_SEQS" \
+      --limit-mm-per-prompt "{\"image\": $MAX_IMAGES}" --mm-processor-cache-gb 0 \
+      > "$ROOT/logs/vllm_gpu${i}.log" 2>&1 &
+  PIDS+=($!)
+done
+trap 'for p in "${PIDS[@]}"; do kill "$p" 2>/dev/null; done' EXIT
+for i in $(seq 0 $((NGPU - 1))); do
+  PORT=$((PORT0 + i))
+  for t in $(seq 1 180); do curl -sf "http://127.0.0.1:$PORT/v1/models" >/dev/null 2>&1 && break; kill -0 "${PIDS[$i]}" 2>/dev/null || { echo "vLLM on GPU $i died, see logs/vllm_gpu${i}.log"; exit 1; }; sleep 10; done
+  echo "[frames_pixels] vLLM ready on GPU $i (:$PORT)"
+done
+echo "[frames_pixels] launch: --max-model-len 65536 --limit-mm-per-prompt images=$MAX_IMAGES --max-num-seqs $MAX_SEQS --gpu-memory-utilization $GPU_UTIL; runner --token-budget $TOKEN_BUDGET --max-images $MAX_IMAGES --workers $WORKERS" | tee -a "$ROOT/logs/launch_params.txt"
+"$PY" "$RUNNER" --conditions "$CONDS" --endpoints "$EPS" --workers "$WORKERS" --token-budget "$TOKEN_BUDGET" --max-images "$MAX_IMAGES" "${BENCH_ARG[@]}" 2>&1 | tee -a "$ROOT/logs/runner.log"
+rc=${PIPESTATUS[0]}
+echo "[frames_pixels] runner finished rc=$rc"; exit $rc