add supplement_20260910/code/

supplement_20260910/code/exp/analysis/pool/TASK.md

@@ -0,0 +1,55 @@
+# 全量题池构建:三步筛选跑批(parcc,单卡 B200,Slurm)(用户 2026-09-06)
+
+## 目标
+对 benchmark 全部题目建题池。三步跑批,任一步答对即出池,其余全部保留并带标签。
+产物是一张逐题表和一个可查询的题池数据库,供后续的规格查询与 Vendi 选择使用。
+
+## 输入
+- 已下载的 benchmark,路径与格式见现有 loader;先补齐 loader 缺失的 benchmark。
+- 统一 item schema:benchmark、item_id、video_id、video_path、question、options(列表)、answer_idx、
+  duration、declared_task、declared_scene、license。选项缺失或 ground truth 非选项的题标 format=open,不进后续跑批。
+
+## 步骤 0:筛(CPU)
+- 视频内容哈希去重,得到 video_id;同 benchmark 内题干加选项文本近重复(bge-large-en-v1.5,余弦 > 0.9)只留一道。
+- 判分规则固定为三步级联(选项字母、答案行正则、选项文本),与主文 3.2 一致。
+- 输出 screen_counts_full.csv:每个 benchmark 的总题数、去重后题数、format=open 题数。
+
+## 步骤 1:盲测(Qwen3-VL-8B,文本模式,vLLM)
+- 每题 4 次选项置换,每次只做一个前向,取四个选项字母的 log-prob,选最大者。
+- 记录 blind_acc_4perm(0 到 1)与 blind_margin = 平均 log-prob 边际。
+- 出池条件:blind_acc_4perm 在 chance 之上显著(单侧二项检验,n=4 太小,改用 log-prob 边际的阈值:
+  正确选项 log-prob 高于其余三者均值超过 log(2),且 4 次置换中至少 3 次选中正确项)。
+
+## 步骤 2:单帧(Qwen3-VL-8B,448 像素,vLLM)
+- 每题取视频中点一帧,一个前向,取选项 log-prob。
+- 记录 sf_correct、sf_margin。
+- 出池条件:sf_correct 且 sf_margin > log(2)。
+
+## 步骤 3:32 帧(Qwen3-VL-2B,448 像素,vLLM)
+- 每题均匀 32 帧,一个前向,取选项 log-prob。
+- 记录 v32_2b_correct、v32_2b_margin。
+- 出池条件:v32_2b_correct 且 v32_2b_margin > log(2)。
+
+## 调度
+- 每片一个 vLLM 进程,端口按 SLURM_ARRAY_TASK_ID 错开。
+- 帧解码单独一个 CPU 数组作业先跑,缓存到本地 SSD,格式 jpg,命名 video_id/frame_k.jpg。
+- 步骤 1 不依赖帧,先跑;步骤 2 和 3 等帧缓存完成。
+- 断点续跑:逐题写 jsonl,重启时跳过已完成 item_id。
+- run_accounting.csv 记录每步的请求数、GPU 小时、失败数。
+
+## 输出
+- pool_items.parquet:上面 schema 的全部列,加 blind_acc_4perm、blind_margin、sf_correct、sf_margin、
+  v32_2b_correct、v32_2b_margin、removed_by(none / blind / single_frame / v32_2b,多个用逗号连接)、
+  task_class、scene_type(先用 declared 字段,打标 agent 之后覆盖)、cell_thin(该任务 × 场景格子剩余不足 30 题)。
+- pool.duckdb:同一张表,供 SQL 查询。
+- pool_summary.md:总题数、各步出池数与占比、剩余题数、按 benchmark 与按格子的剩余分布、薄格子清单。
+- 三步的逐题 jsonl 原始输出保留。
+
+## 验收
+- 任意一个 benchmark 剩余为 0 时单独报告,不自动删除。
+- 全部完成后把 pool_summary.md 和 screen_counts_full.csv build 进 Overleaf 的 fig_tex/。
+
+## 执行说明(主会话 2026-09-06)
+- 用户要求"根据集群实际情况进行调度优化,尽快跑完":GPU 分区 mig45 本组作业已排队 1.5 天,
+  作业拆小(短时限、单片)以利回填;步骤 1 纯文本可先跑;帧解码与视频下载并行推进。
+- 全量视频仍在下载(2026-09-06 11:50 完成 43%),步骤 0/1 用已解析的全量题目先跑,步骤 2/3 随视频到齐分批。

supplement_20260910/code/exp/analysis/pool/frames_decode.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""frames_decode.py — frame cache for steps 2 and 3.
+
+Cache location: bench_exp/work/pool_frames/<video_id>/frame_<k>.jpg + frames.json
+(video_id = content_hash). Decision (2026-09-06): the cluster runs
+job_container/tmpfs (per-job private /tmp, destroyed at job end) and the MIG node
+reports TmpDisk=0, so node-local storage cannot be shared between the CPU decode array
+and the GPU array. /vast is the shared NVMe-backed (VAST) filesystem every node mounts;
+it is the only cache that the decode array and all GPU tasks can read and write, and
+it survives job boundaries for incremental re-runs. GPU tasks decode any video still
+missing from the cache on the fly (same function) so steps 2-3 never block on the array.
+
+Frames = the stage_p1_runner v_32 grid: 32 time-uniform targets over meta
+frame_timestamps, nearest frame index each, duplicates (short videos) collapsed to the
+first grid position. frame_<k>.jpg is named by grid position k (0..31); frames.json
+lists the positions that exist (`keys`), the single-frame position `mid_k` (grid
+position 16 = v_1), and the frame size after resizing to a 448 px long side (never
+upscaled), JPEG q85.
+
+  frames_decode.py [--shard i/k] [--workers 8] [--limit N] [--video-ids FILE]
+                   [--all-videos]   (default: videos of items still in the pool)
+  frames_decode.py --stats
+"""
+import argparse
+import hashlib
+import io
+import json
+import os
+import shutil
+import sys
+import time
+from concurrent.futures import ProcessPoolExecutor, as_completed
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import pool_common as pc  # noqa: E402
+from pool_common import log  # noqa: E402
+
+
+def frames_json_path(video_id):
+    return os.path.join(pc.FRAMES_DIR, video_id, "frames.json")
+
+
+def load_frames_json(video_id):
+    p = frames_json_path(video_id)
+    if not os.path.exists(p):
+        return None
+    try:
+        d = json.load(open(p))
+        return d if d.get("ok") else None
+    except Exception:
+        return None
+
+
+def grid_positions(meta):
+    """-> (grid of 32 frame indices, ordered unique positions k, mid_k)."""
+    from stage_p1_runner import _nearest_indices, _uniform_times
+    n = int(meta["n_frames"])
+    ts = meta.get("frame_timestamps") or []
+    if len(ts) != n or n == 0:
+        ts = list(range(max(n, 1)))
+    grid = _nearest_indices(ts, _uniform_times(ts[0], ts[-1], pc.N_FRAMES_V32))
+    first = {}
+    keys = []
+    for k, idx in enumerate(grid):
+        if idx not in first:
+            first[idx] = k
+            keys.append(k)
+    mid_k = first[grid[pc.MID_POS]]
+    return grid, keys, mid_k
+
+
+def ensure_frames(video_id, video_path, meta=None, long_side=pc.FRAME_LONG_SIDE):
+    """Decode + cache if missing; returns the frames.json dict (or raises)."""
+    d = load_frames_json(video_id)
+    if d is not None:
+        return d
+    from PIL import Image
+    from extract_frames import _decode
+    if meta is None:
+        meta = pc.meta_of(video_id)
+    if not meta:
+        raise RuntimeError("meta.json missing")
+    grid, keys, mid_k = grid_positions(meta)
+    idxs = [grid[k] for k in keys]
+    decoded = _decode(video_path, idxs)                 # {idx: PIL}
+    avail = max(decoded)
+    out_dir = os.path.join(pc.FRAMES_DIR, video_id)
+    tmp_dir = f"{out_dir}.tmp{os.getpid()}"
+    os.makedirs(tmp_dir, exist_ok=True)
+    w = h = None
+    for k, idx in zip(keys, idxs):
+        im = decoded[min(idx, avail)].convert("RGB")
+        W, H = im.size
+        s = long_side / max(W, H)
+        if s < 1.0:
+            im = im.resize((max(1, round(W * s)), max(1, round(H * s))), Image.LANCZOS)
+        w, h = im.size
+        im.save(os.path.join(tmp_dir, f"frame_{k}.jpg"), format="JPEG", quality=pc.JPEG_QUALITY)
+    info = dict(video_id=video_id, n_frames_video=int(meta.get("n_frames", 0)), grid=grid, keys=keys,
+                mid_k=mid_k, w=w, h=h, long_side=long_side, jpeg_quality=pc.JPEG_QUALITY,
+                too_short=bool(meta.get("too_short")), ok=True, ts=time.strftime("%F %T"))
+    json.dump(info, open(os.path.join(tmp_dir, "frames.json"), "w"))
+    try:
+        os.rename(tmp_dir, out_dir)
+    except OSError:
+        # another worker finished first: keep theirs
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+        d = load_frames_json(video_id)
+        if d is None:
+            raise
+        return d
+    return info
+
+
+def frame_bytes(video_id, k):
+    with open(os.path.join(pc.FRAMES_DIR, video_id, f"frame_{k}.jpg"), "rb") as f:
+        return f.read()
+
+
+# ------------------------------------------------------------------ selection
+def pool_videos(all_videos=False):
+    """(video_id, video_path) of videos whose items are still in the pool: base items
+    that are mcq, kept by step 0 (if run) and not removed by step 1 (if run)."""
+    import pyarrow.parquet as pq
+    df = pq.read_table(pc.BASE_PARQUET, columns=["benchmark", "item_id", "video_key", "video_id",
+                                                 "video_path", "format"]).to_pandas()
+    hashes = pc.manifest_hashes()
+    pend = df["video_id"].str.startswith("k:")
+    new = df.loc[pend, "video_key"].map(hashes)
+    got = new.notna()
+    df.loc[new[got].index, "video_id"] = new[got].values
+    df.loc[new[got].index, "video_path"] = [pc.normalized_path(x) for x in new[got].values]
+    df = df[df["video_path"].notna()]
+    if not all_videos:
+        df = df[df["format"] == "mcq"]
+        if os.path.exists(pc.STEP0_KEPT):
+            kept = pq.read_table(pc.STEP0_KEPT, columns=["item_id", "kept"]).to_pandas()
+            keep_ids = set(kept.loc[kept["kept"], "item_id"])
+            df = df[df["item_id"].isin(keep_ids)]
+        ok1, _ = pc.load_step_rows(1)
+        if ok1:
+            removed = {i for i, r in ok1.items() if r.get("remove")}
+            df = df[~df["item_id"].isin(removed)]
+    vids = df.drop_duplicates("video_id")[["video_id", "video_path"]]
+    return list(vids.itertuples(index=False, name=None))
+
+
+def shard_of(video_id, n):
+    return int(hashlib.sha1(video_id.encode()).hexdigest()[:8], 16) % n
+
+
+def work_one(video_id, video_path):
+    t0 = time.time()
+    try:
+        info = ensure_frames(video_id, video_path)
+        return video_id, None, len(info["keys"]), round(time.time() - t0, 2)
+    except Exception as e:
+        return video_id, f"{type(e).__name__}: {str(e)[:200]}", 0, round(time.time() - t0, 2)
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    ap.add_argument("--shard", default=None, help="i/k (default: Slurm array env or 0/1)")
+    ap.add_argument("--workers", type=int, default=max(1, int(os.environ.get("SLURM_CPUS_PER_TASK", 16)) // 2))
+    ap.add_argument("--limit", type=int, default=None)
+    ap.add_argument("--video-ids", default=None, help="file with one video_id per line (smoke tests)")
+    ap.add_argument("--all-videos", action="store_true", help="every normalized video of the base items")
+    ap.add_argument("--stats", action="store_true")
+    a = ap.parse_args()
+    pc.ensure_dirs()
+    vids = pool_videos(a.all_videos)
+    if a.video_ids:
+        want = {l.strip() for l in open(a.video_ids) if l.strip()}
+        vids = [v for v in vids if v[0] in want]
+    cached = [v for v in vids if load_frames_json(v[0]) is not None]
+    if a.stats:
+        print(f"pool videos with a normalized file: {len(vids)}; frames cached: {len(cached)}; "
+              f"missing: {len(vids) - len(cached)}")
+        return
+    if a.shard:
+        tid, n = (int(x) for x in a.shard.split("/"))
+    else:
+        tid, n = pc.slurm_task()
+    todo = [v for v in vids if load_frames_json(v[0]) is None and shard_of(v[0], n) == tid]
+    if a.limit:
+        todo = todo[:a.limit]
+    log(f"frames shard {tid}/{n}: {len(todo)} video(s) to decode of {len(vids)} "
+        f"({len(cached)} already cached); workers={a.workers}", "frames")
+    if not todo:
+        return
+    t0 = time.time()
+    n_ok = n_err = n_frames = 0
+    errs = []
+    with ProcessPoolExecutor(max_workers=a.workers) as ex:
+        futs = [ex.submit(work_one, v, p) for v, p in todo]
+        for i, f in enumerate(as_completed(futs), 1):
+            vid, err, nf, dt = f.result()
+            if err:
+                n_err += 1
+                errs.append(dict(video_id=vid, error=err))
+            else:
+                n_ok += 1
+                n_frames += nf
+            if i % 200 == 0 or i == len(todo):
+                el = time.time() - t0
+                log(f"{i}/{len(todo)} ok={n_ok} err={n_err} {i / el:.2f} videos/s", "frames")
+    el = time.time() - t0
+    if errs:
+        with open(os.path.join(pc.LOG_DIR, "pool_frames_errors.jsonl"), "a") as f:
+            for e in errs:
+                f.write(json.dumps(dict(ts=time.strftime("%F %T"), **e)) + "\n")
+    with open(os.path.join(pc.LOG_DIR, "pool_timing.jsonl"), "a") as f:
+        f.write(json.dumps(dict(ts=time.strftime("%F %T"), stage="frames", shard=f"{tid}/{n}", n_videos=len(todo),
+                                n_ok=n_ok, n_err=n_err, n_frames=n_frames, wall_s=round(el, 1),
+                                videos_per_s=round(len(todo) / max(el, 1e-9), 3), workers=a.workers)) + "\n")
+    log(f"done: ok={n_ok} err={n_err} frames={n_frames} in {el / 60:.1f} min "
+        f"({len(todo) / max(el, 1e-9):.2f} videos/s)", "frames")
+
+
+if __name__ == "__main__":
+    main()

supplement_20260910/code/exp/analysis/pool/pool_common.py

@@ -0,0 +1,392 @@
+"""Shared paths, schema helpers and the vLLM option-letter log-prob client for the
+full-item-pool screening run (exp/analysis/pool/TASK.md).
+
+Layout
+  exp/results/pool/                      small tabular outputs (csv/md) + parquet/duckdb
+      pool_items_base.parquet            pool_schema.py   (all items, TASK schema)
+      step0_kept.parquet                 step0_screen.py  (dedup verdict per item)
+      screen_counts_full.csv             step0_screen.py
+      step1/<bench>[.p<j>].jsonl         step1_blind.py   (one row per item, append-only)
+      step2/<bench>[.p<j>].jsonl         step2_single_frame.py
+      step3/<bench>[.p<j>].jsonl         step3_v32_2b.py
+      pool_items.parquet, pool.duckdb, pool_summary.md, run_accounting.csv  (assemble/accounting)
+  bench_exp/work/pool_items_cache/       per-bench enumeration cache (jsonl) for the 88
+                                         benchmarks without a T3 full-text export
+  bench_exp/work/pool_embeddings/        bge-large-en-v1.5 cache per bench (ids.json + .npy),
+                                         same layout as exp/data/embeddings/text
+  bench_exp/work/pool_frames/<video_id>/ frame_<k>.jpg (448 px long side) + frames.json
+
+Item id = the pipeline qid (f"{bench}_{pool_index}", or the stage_b adapter qid for
+MVBench / LVBench / VideoMMMU). video_id = normalized content_hash, or
+"k:" + sha1(video_key)[:16] while the video is not yet normalized.
+"""
+import fcntl
+import hashlib
+import json
+import math
+import os
+import random
+import re
+import sys
+import time
+
+HERE = os.path.dirname(os.path.abspath(__file__))           # exp/analysis/pool
+EXP = os.path.abspath(os.path.join(HERE, "..", ".."))        # exp
+REPO = os.path.dirname(EXP)
+PIPE = os.path.join(EXP, "pipeline")
+for p in (PIPE, os.path.join(EXP, "t3")):
+    if p not in sys.path:
+        sys.path.insert(0, p)
+os.environ.setdefault("FINEBENCH_ROUTE", "yt")   # FineBench samples were drawn with the YouTube route
+
+# Off-cluster runs (exp/analysis/pool/REMOTE_README.md, HF dataset GMLRVigil/BenchCheck-Pool): POOL_BASE
+# replaces the cluster data root (the store / manifest / caches under it are optional for steps 1-3),
+# POOL_FRAMES_DIR points at the unpacked frame cache, POOL_RESULTS_ROOT at the items + step outputs.
+BASE = os.environ.get("POOL_BASE") or "/vast/projects/jgu32/lab/enxin/bench_exp"
+STORE = f"{BASE}/store"
+WORK = f"{BASE}/work"
+NORMALIZED = f"{STORE}/normalized"
+MANIFEST_JSONL = f"{BASE}/logs/manifest.jsonl"
+T3_FULL = f"{BASE}/t3_export_n1_fulltext/full"
+ITEMS_CACHE = f"{WORK}/pool_items_cache"
+EMB_DIR = f"{WORK}/pool_embeddings"
+FRAMES_DIR = os.environ.get("POOL_FRAMES_DIR") or f"{WORK}/pool_frames"
+LOG_DIR = f"{BASE}/logs"
+
+RESULTS = os.environ.get("POOL_RESULTS_ROOT") or os.path.join(EXP, "results", "pool")   # override for smoke tests
+BASE_PARQUET = os.path.join(RESULTS, "pool_items_base.parquet")
+SCHEMA_MANIFEST = os.path.join(RESULTS, "pool_schema_manifest.csv")
+STEP0_KEPT = os.path.join(RESULTS, "step0_kept.parquet")
+STEP0_REMOVED = os.path.join(RESULTS, "step0_removed.jsonl")
+SCREEN_CSV = os.path.join(RESULTS, "screen_counts_full.csv")
+POOL_PARQUET = os.path.join(RESULTS, "pool_items.parquet")
+POOL_DUCKDB = os.path.join(RESULTS, "pool.duckdb")
+POOL_SUMMARY_MD = os.path.join(RESULTS, "pool_summary.md")
+POOL_SUMMARY_CSV = os.path.join(RESULTS, "pool_summary.csv")
+ACCOUNTING_CSV = os.path.join(RESULTS, "run_accounting.csv")
+
+VB_CSV = os.path.join(EXP, "video_benchmarks.csv")
+REGISTRY_CSV = os.path.join(REPO, "meta", "benchmark_registry.csv")
+SAMPLE_DIRS = [os.path.join(EXP, "data", "samples"), os.path.join(EXP, "data", "samples_n1")]
+
+HF_HUB = "/vast/projects/jgu32/lab/enxin/cache/hf/hub"
+MODELS = {
+    # step -> (served model name, snapshot dir)
+    "8b": ("Qwen/Qwen3-VL-8B-Instruct",
+           f"{HF_HUB}/models--Qwen--Qwen3-VL-8B-Instruct/snapshots/0c351dd01ed87e9c1b53cbc748cba10e6187ff3b"),
+    "2b": ("Qwen/Qwen3-VL-2B-Instruct",
+           f"{HF_HUB}/models--Qwen--Qwen3-VL-2B-Instruct/snapshots/89644892e4d85e24eaac8bacfd4f463576704203"),
+}
+BGE_SNAPSHOT = f"{HF_HUB}/models--BAAI--bge-large-en-v1.5/snapshots/d4aa6901d3a41ba39fb536a557fa166f842b0e09"
+
+# 2026-09-10 (user decision, pool <= 50k without per-benchmark caps): three more removal steps that mirror
+# the paper's pyramid levels missing from the screen -- option level (options-only, 8B), the frame-level
+# reference model (8B on the 32-frame grid at 448 px) and the order level (2B on the shuffled 32-frame grid).
+STEPS = {1: "blind", 2: "single_frame", 3: "v32_2b", 4: "opt_only", 5: "v32_2b_shuffle", 6: "v32_8b"}
+STEP_MODEL = {1: "8b", 2: "8b", 3: "2b", 4: "8b", 5: "2b", 6: "8b"}
+VISUAL_STEPS = {2, 3, 5, 6}
+PROMPT_OPT_ONLY = "{intro}\n\nOptions:\n{opts}\nAnswer with the option letter only."
+STEP_DIR = {k: os.path.join(RESULTS, f"step{k}") for k in STEPS}
+
+SEED = 42
+N_PERM = 4
+LOG2 = math.log(2.0)
+LP_FLOOR = math.log(1e-6)          # letter absent from the top-20 log-probs
+TOP_LOGPROBS = 20
+MAX_OPTIONS = 26                   # letters A..Z; more options -> format=open
+LETTERS = [chr(65 + i) for i in range(MAX_OPTIONS)]
+FRAME_LONG_SIDE = 448
+N_FRAMES_V32 = 32
+MID_POS = 16                       # stage_p1_runner v_1: grid32[16]
+JPEG_QUALITY = 85
+MAX_ERRORS_PER_ITEM = 3            # error rows before an item is treated as permanently failed
+
+# one prompt skeleton for all three steps (intro strings reused from stage_p1_runner)
+PROMPT = "{intro}\n\nQuestion: {q}\nOptions:\n{opts}\nAnswer with the option letter only."
+ASSISTANT_PREFIX = "Answer:"      # continue_final_message -> the next token is the letter
+_TOKEN_LETTER = re.compile(r"^\s*[\(\[]?([A-Z])[\)\]\.:]?\s*$")
+
+
+def log(msg, tag="pool"):
+    print(f"[{tag}] {time.strftime('%H:%M:%S')} {msg}", file=sys.stderr, flush=True)
+
+
+def ensure_dirs():
+    for d in (RESULTS, ITEMS_CACHE, EMB_DIR, FRAMES_DIR, LOG_DIR, *STEP_DIR.values()):
+        os.makedirs(d, exist_ok=True)
+
+
+# ------------------------------------------------------------------ benches
+def bench_list():
+    """Stems of exp/data/samples/*.jsonl + exp/data/samples_n1/*.jsonl (139 onboarded)."""
+    import glob
+    names = set()
+    for d in SAMPLE_DIRS:
+        for p in glob.glob(os.path.join(d, "*.jsonl")):
+            if os.path.exists(p):
+                names.add(os.path.basename(p)[:-6])
+    return sorted(names)
+
+
+def sample_path(bench):
+    for d in SAMPLE_DIRS:
+        p = os.path.join(d, f"{bench}.jsonl")
+        if os.path.exists(p):
+            return p
+    return None
+
+
+def read_jsonl(path):
+    out = []
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            if line.strip():
+                try:
+                    out.append(json.loads(line))
+                except json.JSONDecodeError:
+                    continue   # torn final line of a killed writer
+    return out
+
+
+def key_of(ref):
+    return f"{ref['repo']}::{ref.get('zip_path', '')}::{ref['member']}"
+
+
+def manifest_hashes():
+    """video_key -> content_hash for logs/manifest.jsonl status=done rows (last wins)."""
+    m = {}
+    if not os.path.exists(MANIFEST_JSONL):
+        return m
+    with open(MANIFEST_JSONL, encoding="utf-8") as f:
+        for line in f:
+            try:
+                r = json.loads(line)
+            except Exception:
+                continue
+            if r.get("status") == "done" and r.get("content_hash") and "::" in str(r.get("key", "")):
+                m[r["key"]] = r["content_hash"]
+    return m
+
+
+def key_video_id(key):
+    return "k:" + hashlib.sha1(key.encode("utf-8")).hexdigest()[:16]
+
+
+def normalized_path(h):
+    return f"{NORMALIZED}/{h}/video.mp4"
+
+
+def meta_of(h):
+    try:
+        return json.load(open(f"{NORMALIZED}/{h}/meta.json"))
+    except Exception:
+        return None
+
+
+# ------------------------------------------------------------------ options
+_SEQ_PREFIX = re.compile(r"^\s*[\(\[]?([A-Za-z])[\)\]\.:]\s*(.*)$", re.S)
+
+
+def strip_sequential_prefix(opts):
+    """['A. x', 'B. y'] -> (['x', 'y'], True) when every option carries the letter of
+    its position (A, B, C, ...); otherwise the list is returned unchanged."""
+    texts = []
+    for i, o in enumerate(opts):
+        m = _SEQ_PREFIX.match(str(o))
+        if not m or m.group(1).upper() != chr(65 + i):
+            return [str(o) for o in opts], False
+        texts.append(m.group(2).strip())
+    return texts, True
+
+
+def render_options(texts):
+    return "\n".join(f"{LETTERS[i]}. {t}" for i, t in enumerate(texts))
+
+
+def item_text(question, options):
+    """Text embedded for the near-duplicate check: question + options."""
+    q = " ".join(str(question or "").split())
+    if isinstance(options, list) and options:
+        return q + "\n" + "\n".join(str(o) for o in options)
+    return q
+
+
+def permutations_for(item_id, k, n_perm=N_PERM, seed=SEED):
+    """TASK.md step 1: n_perm option shuffles, seed 42, per item. perm[j] = original
+    option index shown at position j."""
+    rng = random.Random(f"{seed}|{item_id}")
+    return [rng.sample(range(k), k) for _ in range(n_perm)]
+
+
+# ------------------------------------------------------------------ log-probs
+def letter_logprobs(top_logprobs, k):
+    """top_logprobs: list of {token, logprob} for the first generated position.
+    -> (lp list over the k presented letters, missing letters, matched variants).
+    Tokenization variants ('A', ' A', '(A', 'A.') are merged by log-sum-exp."""
+    acc = {}
+    variants = {}
+    for e in top_logprobs or []:
+        m = _TOKEN_LETTER.match(e.get("token") or "")
+        if not m:
+            continue
+        L = m.group(1)
+        if L not in acc:
+            acc[L] = e["logprob"]
+        else:
+            a, b = acc[L], e["logprob"]
+            acc[L] = max(a, b) + math.log1p(math.exp(-abs(a - b)))
+        variants.setdefault(L, []).append(e.get("token"))
+    lp, missing = [], []
+    for i in range(k):
+        L = LETTERS[i]
+        if L in acc:
+            lp.append(float(acc[L]))
+        else:
+            lp.append(LP_FLOOR)
+            missing.append(L)
+    return lp, missing, variants
+
+
+def margin_of(lp, correct_pos):
+    others = [v for i, v in enumerate(lp) if i != correct_pos]
+    return lp[correct_pos] - (sum(others) / len(others) if others else 0.0)
+
+
+def argmax_pos(lp):
+    best = max(lp)
+    return lp.index(best)
+
+
+class ContextTooLong(Exception):
+    pass
+
+
+def logprob_request(endpoint, model, prompt, images_b64=None, timeout=(10, 600)):
+    """One forward: max_tokens=1, logprobs=true, top_logprobs=20; the assistant turn is
+    prefilled with ASSISTANT_PREFIX (continue_final_message) so the next token is the
+    letter. -> dict(top=[{token, logprob}], top1_token, prompt_tokens, latency_s)."""
+    import requests
+    content = [{"type": "image_url", "image_url": {"url": "data:image/jpeg;base64," + b}}
+               for b in (images_b64 or [])]
+    content.append({"type": "text", "text": prompt})
+    body = {"model": model, "temperature": 0.0, "max_tokens": 1,
+            "logprobs": True, "top_logprobs": TOP_LOGPROBS,
+            "messages": [{"role": "user", "content": content},
+                         {"role": "assistant", "content": ASSISTANT_PREFIX}],
+            "continue_final_message": True, "add_generation_prompt": False}
+    t0 = time.time()
+    r = requests.post(f"{endpoint}/chat/completions", json=body, 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()
+    ch = d["choices"][0]
+    lpc = (ch.get("logprobs") or {}).get("content") or []
+    if not lpc:
+        raise RuntimeError("no logprobs in response")
+    top = [{"token": e.get("token"), "logprob": e.get("logprob")} for e in (lpc[0].get("top_logprobs") or [])]
+    return dict(top=top, top1_token=lpc[0].get("token"),
+                prompt_tokens=(d.get("usage") or {}).get("prompt_tokens", 0),
+                latency_s=round(time.time() - t0, 4))
+
+
+# ------------------------------------------------------------------ result files
+def bench_files(step, bench):
+    """All jsonl files of a benchmark under step<k>/ (part files included)."""
+    d = STEP_DIR[step]
+    if not os.path.isdir(d):
+        return []
+    out = []
+    for f in os.listdir(d):
+        if f == f"{bench}.jsonl" or (f.startswith(f"{bench}.p") and f.endswith(".jsonl")
+                                     and f[len(bench) + 2:-6].isdigit()):
+            out.append(os.path.join(d, f))
+    return sorted(out)
+
+
+def unit_file(step, bench, part, n_parts):
+    return os.path.join(STEP_DIR[step], f"{bench}.jsonl" if n_parts == 1 else f"{bench}.p{part}.jsonl")
+
+
+def load_step_rows(step, benches=None):
+    """item_id -> last successful row; plus item_id -> error count.
+    Rows with status != ok are errors (never counted as done)."""
+    ok, errs = {}, {}
+    d = STEP_DIR[step]
+    if not os.path.isdir(d):
+        return ok, errs
+    files = []
+    for f in sorted(os.listdir(d)):
+        if not f.endswith(".jsonl"):
+            continue
+        if benches is not None:
+            b = f[:-6]
+            if "." in b and b.rsplit(".", 1)[1][1:].isdigit() and b.rsplit(".", 1)[1].startswith("p"):
+                b = b.rsplit(".", 1)[0]
+            if b not in benches:
+                continue
+        files.append(os.path.join(d, f))
+    for p in files:
+        for r in read_jsonl(p):
+            iid = r.get("item_id")
+            if iid is None:
+                continue
+            if r.get("status", "ok") == "ok":
+                ok[iid] = r
+            else:
+                errs[iid] = errs.get(iid, 0) + 1
+    return ok, errs
+
+
+def append_rows(path, rows):
+    """Append json rows under an exclusive flock (several array tasks may touch a file
+    across re-runs; the lock keeps rows whole)."""
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    data = "".join(json.dumps(r, ensure_ascii=False, default=str) + "\n" for r in rows)
+    with open(path, "a", encoding="utf-8") as f:
+        fcntl.flock(f, fcntl.LOCK_EX)
+        try:
+            f.write(data)
+            f.flush()
+        finally:
+            fcntl.flock(f, fcntl.LOCK_UN)
+
+
+# ------------------------------------------------------------------ sharding
+def plan_units(work, max_unit=20000):
+    """work: list of (bench, [item_ids sorted]) -> units [(bench, part, n_parts, ids)].
+    Big benchmarks are split into parts of <= max_unit items (deterministic by sorted
+    item_id) so one array task never owns more than max_unit items of one file."""
+    units = []
+    for bench, ids in work:
+        ids = sorted(ids)
+        n_parts = max(1, math.ceil(len(ids) / max_unit)) if ids else 1
+        size = math.ceil(len(ids) / n_parts) if ids else 0
+        for part in range(n_parts):
+            units.append((bench, part, n_parts, ids[part * size:(part + 1) * size]))
+    return units
+
+
+def assign_units(units, n_tasks, task_id, weight=lambda u: len(u[3])):
+    """Deterministic LPT (largest first to the least loaded task)."""
+    loads = [0.0] * n_tasks
+    mine = []
+    for u in sorted(units, key=lambda u: (-weight(u), u[0], u[1])):
+        t = min(range(n_tasks), key=lambda i: (loads[i], i))
+        loads[t] += weight(u)
+        if t == task_id:
+            mine.append(u)
+    return mine, loads
+
+
+def slurm_task():
+    """(task_id, n_tasks) from the Slurm array environment; (0, 1) outside Slurm."""
+    tid = int(os.environ.get("SLURM_ARRAY_TASK_ID", 0))
+    n = os.environ.get("SLURM_ARRAY_TASK_COUNT")
+    if n is None:
+        lo, hi = os.environ.get("SLURM_ARRAY_TASK_MIN"), os.environ.get("SLURM_ARRAY_TASK_MAX")
+        n = int(hi) - int(lo) + 1 if lo is not None and hi is not None else 1
+        if lo is not None:
+            tid -= int(lo)
+    return tid, int(n)

supplement_20260910/code/exp/analysis/pool/pool_prompts.py

@@ -0,0 +1,20 @@
+"""Prompt intro strings of the pool screening steps.
+
+Copied verbatim from exp/pipeline/stage_p1_runner.py (INTRO_BLIND / INTRO_VISUAL) so the pool
+client runs off-cluster without the P1 runner and its dependencies. When stage_p1_runner is
+importable the strings are asserted equal at import time.
+"""
+INTRO_VISUAL = ("You are given {n} frame(s) sampled from a video. "
+                "Answer the question based on these frames.")
+INTRO_BLIND = ("You are given NO frames from the video. "
+               "Answer the question from the text alone.")
+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.")
+
+try:  # keep the two copies in lockstep on the cluster
+    import stage_p1_runner as _p1  # noqa: E402
+    assert _p1.INTRO_VISUAL == INTRO_VISUAL and _p1.INTRO_BLIND == INTRO_BLIND \
+        and _p1.INTRO_OPT_ONLY == INTRO_OPT_ONLY, \
+        "pool_prompts.py drifted from stage_p1_runner.py"
+except ImportError:
+    pass

supplement_20260910/code/exp/analysis/pool/pool_steps.py

@@ -0,0 +1,375 @@
+#!/usr/bin/env python3
+"""pool_steps.py — shared vLLM client for the three screening steps (TASK.md).
+
+step 1 blind        Qwen3-VL-8B, text only. N_PERM=4 option shuffles per item
+                    (random.Random(f"42|{item_id}")), one forward each, log-probs of the
+                    presented letters. blind_acc_4perm = share of permutations whose
+                    argmax letter is the correct one; blind_margin = mean over permutations
+                    of (log p(correct) - mean log p(others)). Removed when
+                    blind_margin > log 2 AND >= 3 of 4 permutations pick the correct option.
+step 2 single_frame Qwen3-VL-8B, the middle grid frame (v_1 position, 448 px long side),
+                    original option order, one forward. sf_correct = argmax is correct;
+                    sf_margin as above. Removed when sf_correct AND sf_margin > log 2.
+step 3 v32_2b       Qwen3-VL-2B, the 32-frame grid (448 px), one forward.
+                    v32_2b_correct / v32_2b_margin; same removal rule.
+
+Chain: step 1 runs on step-0 kept mcq items; step 2 on step-1 survivors with a normalized
+video; step 3 on step-2 survivors. Every step is resumable by item_id (rows with
+status != ok are retried up to MAX_ERRORS_PER_ITEM times). Log-probs: max_tokens=1,
+logprobs=true, top_logprobs=20, assistant turn prefilled with "Answer:" so the next token
+is the letter; token variants ("A", " A", "(A", "A.") are merged; a letter absent from
+the top-20 gets log(1e-6) and is listed in `missing`.
+
+Usage (inside the GPU job; step1_blind.py / step2_single_frame.py / step3_v32_2b.py wrap this):
+  pool_steps.py --step 1 --endpoint http://127.0.0.1:8001/v1 [--workers 32]
+                [--bench A,B] [--limit N] [--max-minutes M] [--plan-only] [--shard i/k]
+"""
+import argparse
+import base64
+import json
+import os
+import random
+import sys
+import threading
+import time
+from collections import OrderedDict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import pyarrow.parquet as pq
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import pool_common as pc  # noqa: E402
+from pool_common import log  # noqa: E402
+import frames_decode as fd  # noqa: E402
+from pool_prompts import INTRO_BLIND, INTRO_OPT_ONLY, INTRO_VISUAL  # noqa: E402  (verbatim copies of stage_p1_runner)
+
+MAX_ATTEMPTS = 5
+DEFAULT_WORKERS = {1: 32, 2: 16, 3: 8, 4: 32, 5: 8, 6: 8}
+
+
+# ------------------------------------------------------------------ items
+def load_items():
+    """Base items with video_id/video_path refreshed from the current manifest."""
+    cols = ["benchmark", "item_id", "video_key", "video_id", "video_path", "question", "options",
+            "n_options", "answer_idx", "format"]
+    df = pq.read_table(pc.BASE_PARQUET, columns=cols).to_pandas()
+    hashes = pc.manifest_hashes()
+    pend = df["video_id"].str.startswith("k:")
+    new = df.loc[pend, "video_key"].map(hashes)
+    got = new.notna()
+    df.loc[new[got].index, "video_id"] = new[got].values
+    df.loc[new[got].index, "video_path"] = [pc.normalized_path(x) for x in new[got].values]
+    return df
+
+
+def eligible(step, df):
+    """Items this step should process (chain rule), plus a note on upstream state.
+    2026-09-10: items whose options are a bare yes/no (true/false) pair are not multiple-choice items
+    under the project rule and are skipped by every step (they stay in the parquet, assemble marks them)."""
+    df = df[df["format"] == "mcq"]
+    from chance import _yes_no_options
+    yn = df["options"].map(lambda o: _yes_no_options(list(o)) if o is not None else False)
+    df = df[~yn]
+    notes = [f"yes/no-option items skipped={int(yn.sum())}"]
+    if os.path.exists(pc.STEP0_KEPT):
+        kept = pq.read_table(pc.STEP0_KEPT, columns=["item_id", "kept"]).to_pandas()
+        keep_ids = set(kept.loc[kept["kept"], "item_id"])
+        df = df[df["item_id"].isin(keep_ids)]
+    else:
+        notes.append("step0_kept.parquet missing: no dedup applied")
+    if step in (2, 3):
+        ok1, _ = pc.load_step_rows(1)
+        surv = {i for i, r in ok1.items() if not r.get("remove")}
+        df = df[df["item_id"].isin(surv)]
+        df = df[df["video_path"].notna()]
+        notes.append(f"step1 done={len(ok1)} survivors={len(surv)}")
+    if step == 3:
+        ok2, _ = pc.load_step_rows(2)
+        surv = {i for i, r in ok2.items() if not r.get("remove")}
+        df = df[df["item_id"].isin(surv)]
+        notes.append(f"step2 done={len(ok2)} survivors={len(surv)}")
+    if step >= 4:
+        # steps 4-6 run on the step-1 survivors that no other step (with rows) has removed; they do not
+        # wait for steps 2/3 (removal is "any step"), so machines can share the work; visual steps need frames
+        ok1, _ = pc.load_step_rows(1)
+        surv = {i for i, r in ok1.items() if not r.get("remove")}
+        df = df[df["item_id"].isin(surv)]
+        notes.append(f"step1 done={len(ok1)} survivors={len(surv)}")
+        for other in pc.STEPS:
+            if other in (1, step):
+                continue
+            oko, _ = pc.load_step_rows(other)
+            removed = {i for i, r in oko.items() if r.get("remove")}
+            if removed:
+                df = df[~df["item_id"].isin(removed)]
+                notes.append(f"step{other} removed={len(removed)} excluded")
+        if step in pc.VISUAL_STEPS:
+            df = df[df["video_path"].notna()]
+    return df, notes
+
+
+# ------------------------------------------------------------------ runner
+class Runner:
+    def __init__(self, step, endpoint, model, workers):
+        self.step, self.endpoint, self.model, self.workers = step, endpoint, model, workers
+        self.frames_cache = OrderedDict()          # video_id -> (info, {k: b64})
+        self.cache_lock = threading.Lock()
+        self.meta_cache = {}
+        self.stats = dict(items=0, forwards=0, errors=0, latency_s=0.0, prompt_tokens=0,
+                          removed=0, missing_letter_forwards=0, decode_s=0.0)
+        self.stats_lock = threading.Lock()
+        self.variants = {}
+
+    def bump(self, **kw):
+        with self.stats_lock:
+            for k, v in kw.items():
+                self.stats[k] += v
+
+    def note_variants(self, variants):
+        with self.stats_lock:
+            for L, toks in variants.items():
+                for t in toks:
+                    key = repr(t)
+                    self.variants[key] = self.variants.get(key, 0) + 1
+
+    def frames_b64(self, video_id, video_path, keys):
+        with self.cache_lock:
+            ent = self.frames_cache.get(video_id)
+            if ent is not None:
+                self.frames_cache.move_to_end(video_id)
+        if ent is None:
+            t0 = time.time()
+            meta = self.meta_cache.get(video_id) or pc.meta_of(video_id)
+            self.meta_cache[video_id] = meta
+            info = fd.ensure_frames(video_id, video_path, meta)
+            b64 = {k: base64.b64encode(fd.frame_bytes(video_id, k)).decode() for k in info["keys"]}
+            ent = (info, b64)
+            self.bump(decode_s=time.time() - t0)
+            with self.cache_lock:
+                self.frames_cache[video_id] = ent
+                while len(self.frames_cache) > 64:
+                    self.frames_cache.popitem(last=False)
+        info, b64 = ent
+        if keys == "mid":
+            return info, [b64[info["mid_k"]]], [info["mid_k"]]
+        return info, [b64[k] for k in info["keys"]], list(info["keys"])
+
+    def forward(self, prompt, images, who):
+        last = None
+        for attempt in range(MAX_ATTEMPTS):
+            try:
+                return pc.logprob_request(self.endpoint, self.model, prompt, images)
+            except pc.ContextTooLong:
+                raise
+            except Exception as e:                      # connection / 5xx / timeout
+                last = e
+                time.sleep(min(20, 2 ** attempt + random.uniform(0, 1)))
+        raise RuntimeError(f"{who}: {type(last).__name__}: {str(last)[:200]}")
+
+    # ---- per item
+    def run_item(self, row):
+        iid, bench = row["item_id"], row["benchmark"]
+        opts = list(row["options"])
+        k, aidx = len(opts), int(row["answer_idx"])
+        base = dict(item_id=iid, benchmark=bench, step=pc.STEPS[self.step], model=self.model,
+                    n_options=k, ts=time.strftime("%F %T"))
+        try:
+            if self.step == 1:
+                out = self.blind(iid, row["question"], opts, k, aidx)
+            elif self.step == 4:
+                out = self.blind(iid, None, opts, k, aidx, opt_only=True)
+            else:
+                out = self.visual(iid, row, opts, k, aidx)
+            out.update(base)
+            out["status"] = "ok"
+            self.bump(items=1, removed=int(bool(out["remove"])))
+            return out
+        except Exception as e:
+            self.bump(errors=1)
+            return dict(base, status="error", error=f"{type(e).__name__}: {str(e)[:300]}")
+
+    def blind(self, iid, question, opts, k, aidx, opt_only=False):
+        perms = pc.permutations_for(iid, k)
+        recs, hits, margins, lat, ptok = [], 0, [], 0.0, 0
+        for perm in perms:
+            texts = [opts[i] for i in perm]
+            cpos = perm.index(aidx)
+            if opt_only:   # step 4: option level of the pyramid -- no frames, no question text
+                prompt = pc.PROMPT_OPT_ONLY.format(intro=INTRO_OPT_ONLY, opts=pc.render_options(texts))
+            else:
+                prompt = pc.PROMPT.format(intro=INTRO_BLIND, q=question, opts=pc.render_options(texts))
+            r = self.forward(prompt, None, f"{iid}/{'opt_only' if opt_only else 'blind'}")
+            lp, missing, variants = pc.letter_logprobs(r["top"], k)
+            self.note_variants(variants)
+            am = pc.argmax_pos(lp)
+            m = pc.margin_of(lp, cpos)
+            hit = int(am == cpos and lp[am] > pc.LP_FLOOR)
+            hits += hit
+            margins.append(m)
+            lat += r["latency_s"]
+            ptok += r["prompt_tokens"]
+            self.bump(forwards=1, latency_s=r["latency_s"], prompt_tokens=r["prompt_tokens"],
+                      missing_letter_forwards=int(bool(missing)))
+            recs.append(dict(order=perm, correct_pos=cpos, lp=[round(x, 4) for x in lp], argmax=am,
+                             hit=hit, margin=round(m, 4), missing=missing, top1_token=r["top1_token"]))
+        acc = hits / len(perms)
+        margin = sum(margins) / len(margins)
+        remove = bool(margin > pc.LOG2 and hits >= len(perms) - 1)
+        pre = "opt" if opt_only else "blind"
+        out = dict(perms=recs, remove=remove, n_forwards=len(perms), latency_s=round(lat, 4), prompt_tokens=ptok)
+        out[f"{pre}_acc_4perm"] = round(acc, 4)
+        out[f"{pre}_margin"] = round(margin, 4)
+        return out
+
+    def visual(self, iid, row, opts, k, aidx):
+        vid, vpath = row["video_id"], row["video_path"]
+        info, images, keys = self.frames_b64(vid, vpath, "mid" if self.step == 2 else "all")
+        perm_seed = None
+        if self.step == 5:   # order level: the same 32 frames, one fixed per-item shuffle (stage_p1_runner v_32_shuffle)
+            perm_seed = f"42|{iid}"
+            order = list(range(len(images)))
+            random.Random(perm_seed).shuffle(order)
+            images, keys = [images[i] for i in order], [keys[i] for i in order]
+        prompt = pc.PROMPT.format(intro=INTRO_VISUAL.format(n=len(images)), q=row["question"],
+                                  opts=pc.render_options(opts))
+        r = self.forward(prompt, images, f"{iid}/{pc.STEPS[self.step]}")
+        lp, missing, variants = pc.letter_logprobs(r["top"], k)
+        self.note_variants(variants)
+        am = pc.argmax_pos(lp)
+        m = pc.margin_of(lp, aidx)
+        correct = bool(am == aidx and lp[am] > pc.LP_FLOOR)
+        remove = bool(correct and m > pc.LOG2)
+        self.bump(forwards=1, latency_s=r["latency_s"], prompt_tokens=r["prompt_tokens"],
+                  missing_letter_forwards=int(bool(missing)))
+        pre = {2: "sf", 3: "v32_2b", 5: "v32_2b_shuffle", 6: "v32_8b"}[self.step]
+        out = dict(video_id=vid, frame_keys=keys, n_frames=len(images), frame_wh=[info.get("w"), info.get("h")],
+                   correct_pos=aidx, lp=[round(x, 4) for x in lp], argmax=am, missing=missing,
+                   top1_token=r["top1_token"], remove=remove, n_forwards=1,
+                   latency_s=r["latency_s"], prompt_tokens=r["prompt_tokens"])
+        if perm_seed:
+            out["perm_seed"] = perm_seed
+        out[f"{pre}_correct"] = correct
+        out[f"{pre}_margin"] = round(m, 4)
+        return out
+
+
+def run_unit(runner, unit, rows_by_id, workers, deadline, flush_every=20):
+    bench, part, n_parts, ids = unit
+    path = pc.unit_file(runner.step, bench, part, n_parts)
+    rows = [rows_by_id[i] for i in ids]
+    if runner.step in pc.VISUAL_STEPS:                    # same-video items share the frame cache
+        rows.sort(key=lambda r: (r["video_id"], r["item_id"]))
+    buf, n_done, t0 = [], 0, time.time()
+    stopped = False
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        pending = set()
+        it = iter(rows)
+        while True:
+            while len(pending) < workers * 2 and not stopped:
+                if deadline and time.time() > deadline:
+                    stopped = True
+                    break
+                r = next(it, None)
+                if r is None:
+                    stopped = True
+                    break
+                pending.add(ex.submit(runner.run_item, r))
+            if not pending:
+                break
+            done = next(as_completed(pending))
+            pending.discard(done)
+            buf.append(done.result())
+            n_done += 1
+            if len(buf) >= flush_every:
+                pc.append_rows(path, buf)
+                buf = []
+            if n_done % 200 == 0:
+                st = runner.stats
+                el = time.time() - t0
+                log(f"{bench}.p{part}: {n_done}/{len(rows)} items, {st['forwards']} fwd total, "
+                    f"{n_done / el:.2f} items/s, mean fwd latency {st['latency_s'] / max(st['forwards'], 1):.3f}s, "
+                    f"errors={st['errors']}", f"step{runner.step}")
+    if buf:
+        pc.append_rows(path, buf)
+    return n_done, len(rows) - n_done
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    ap.add_argument("--step", type=int, required=True, choices=[1, 2, 3, 4, 5, 6])
+    ap.add_argument("--endpoint", default=None)
+    ap.add_argument("--workers", type=int, default=None)
+    ap.add_argument("--bench", default=None, help="comma list (default: all)")
+    ap.add_argument("--limit", type=int, default=None, help="first N eligible items per benchmark (smoke tests)")
+    ap.add_argument("--max-minutes", type=float, default=None, help="stop starting new items after M minutes")
+    ap.add_argument("--max-unit", type=int, default=20000)
+    ap.add_argument("--shard", default=None, help="i/k (default: Slurm array env or 0/1)")
+    ap.add_argument("--plan-only", action="store_true", help="print the remaining work of this shard and exit")
+    a = ap.parse_args()
+    pc.ensure_dirs()
+    step = a.step
+    model_name, _snap = pc.MODELS[pc.STEP_MODEL[step]]
+    workers = a.workers or DEFAULT_WORKERS[step]
+    t_start = time.time()
+
+    df = load_items()
+    elig, notes = eligible(step, df)
+    if a.bench:
+        want = {b.strip() for b in a.bench.split(",") if b.strip()}
+        elig = elig[elig["benchmark"].isin(want)]
+    ok, errs = pc.load_step_rows(step)
+    todo = elig[~elig["item_id"].isin(set(ok))]
+    perm_fail = {i for i, n in errs.items() if n >= pc.MAX_ERRORS_PER_ITEM}
+    todo = todo[~todo["item_id"].isin(perm_fail)]
+    if a.limit:
+        todo = todo.sort_values("item_id").groupby("benchmark", sort=False).head(a.limit)
+    work = [(b, list(g["item_id"])) for b, g in todo.groupby("benchmark", sort=True)]
+    units = pc.plan_units(work, a.max_unit)
+    if a.shard:
+        tid, n = (int(x) for x in a.shard.split("/"))
+    else:
+        tid, n = pc.slurm_task()
+    mine, loads = pc.assign_units(units, n, tid)
+    n_mine = sum(len(u[3]) for u in mine)
+    log(f"step {step} ({pc.STEPS[step]}, {model_name}): eligible={len(elig)} done={len(ok)} "
+        f"permanently_failed={len(perm_fail)} remaining={len(todo)}; shard {tid}/{n} -> {len(mine)} unit(s), "
+        f"{n_mine} items (max shard load {max(loads) if loads else 0:.0f}); {'; '.join(notes)}", f"step{step}")
+    if a.plan_only:
+        print(f"REMAINING_TOTAL={len(todo)} REMAINING_SHARD={n_mine} UNITS={len(mine)}")
+        return
+    if not mine:
+        log("nothing to do", f"step{step}")
+        print("INCOMPLETE=0")
+        return
+    if not a.endpoint:
+        sys.exit("--endpoint required")
+    runner = Runner(step, a.endpoint.rstrip("/"), model_name, workers)
+    rows_by_id = {r["item_id"]: r for r in todo.to_dict("records")}
+    deadline = (t_start + a.max_minutes * 60) if a.max_minutes else None
+    left_total = 0
+    for u in mine:
+        if deadline and time.time() > deadline:
+            left_total += len(u[3])
+            continue
+        n_done, left = run_unit(runner, u, rows_by_id, workers, deadline)
+        left_total += left
+        log(f"{u[0]}.p{u[1]}: done {n_done}, left {left}", f"step{step}")
+    st = runner.stats
+    wall = time.time() - t_start
+    summary = dict(ts=time.strftime("%F %T"), stage=f"step{step}", shard=f"{tid}/{n}", model=model_name,
+                   items=st["items"], forwards=st["forwards"], errors=st["errors"], removed=st["removed"],
+                   wall_s=round(wall, 1), mean_fwd_latency_s=round(st["latency_s"] / max(st["forwards"], 1), 4),
+                   fwd_per_s=round(st["forwards"] / max(wall, 1e-9), 3),
+                   items_per_s=round(st["items"] / max(wall, 1e-9), 3),
+                   mean_prompt_tokens=round(st["prompt_tokens"] / max(st["forwards"], 1), 1),
+                   missing_letter_forwards=st["missing_letter_forwards"], decode_s=round(st["decode_s"], 1),
+                   workers=workers, token_variants=dict(sorted(runner.variants.items(), key=lambda kv: -kv[1])[:8]),
+                   left=left_total, slurm_job=os.environ.get("SLURM_JOB_ID"))
+    with open(os.path.join(pc.LOG_DIR, "pool_timing.jsonl"), "a") as f:
+        f.write(json.dumps(summary) + "\n")
+    log(json.dumps(summary), f"step{step}")
+    print(f"INCOMPLETE={left_total}")
+
+
+if __name__ == "__main__":
+    main()

supplement_20260910/code/exp/analysis/pool/step1_blind.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""TASK.md step 1 (blind) — thin wrapper: pool_steps.py --step 1 (see that module for the
+rule, the log-prob extraction and the output row format). Output: exp/results/pool/step1/."""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from pool_steps import main  # noqa: E402
+
+if __name__ == "__main__":
+    sys.argv = [sys.argv[0], "--step", "1"] + [x for x in sys.argv[1:] if x not in ("--step", "1")]
+    main()

supplement_20260910/code/exp/analysis/pool/step2_single_frame.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""TASK.md step 2 (single_frame) — thin wrapper: pool_steps.py --step 2 (see that module for the
+rule, the log-prob extraction and the output row format). Output: exp/results/pool/step2/."""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from pool_steps import main  # noqa: E402
+
+if __name__ == "__main__":
+    sys.argv = [sys.argv[0], "--step", "2"] + [x for x in sys.argv[1:] if x not in ("--step", "2")]
+    main()

supplement_20260910/code/exp/analysis/pool/step3_v32_2b.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""TASK.md step 3 (v32_2b) — thin wrapper: pool_steps.py --step 3 (see that module for the
+rule, the log-prob extraction and the output row format). Output: exp/results/pool/step3/."""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from pool_steps import main  # noqa: E402
+
+if __name__ == "__main__":
+    sys.argv = [sys.argv[0], "--step", "3"] + [x for x in sys.argv[1:] if x not in ("--step", "3")]
+    main()

supplement_20260910/code/requirements.txt

@@ -0,0 +1,9 @@
+# versions used on the origin cluster (Python 3.12.14); vLLM wheels for CUDA 12.8 (Blackwell B200 / RTX 5090 need torch 2.8 cu128)
+vllm==0.11.0
+torch==2.8.0
+transformers==4.57.6
+pyarrow>=17
+pandas>=2.2
+requests>=2.32
+pillow>=10
+huggingface_hub>=0.34

supplement_20260910/code/run_remote.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+# run_remote.sh — run one pool screening step on a multi-GPU machine (no Slurm).
+#   STEP=1 bash code/run_remote.sh            # run step 1 on every GPU (one vLLM server + one client shard per GPU)
+#   STEP=2 bash code/run_remote.sh --plan-only   # show the remaining work of a step, no GPU used
+# Env (optional): NGPU (default: nvidia-smi count), WORKERS (client threads per GPU; defaults per step),
+#                 VLLM (default: vllm on PATH), PY (default: python3), PORT0 (default 8001), GPU_UTIL (default 0.85)
+# Layout: this script lives in <package>/code/; items are read from <package>/results/pool/ (copy items/* there
+# once), frames from <package>/frames/pool_frames/<video_id>/, outputs go to <package>/results/pool/step<N>/.
+set -u
+CODE=$(cd "$(dirname "$0")" && pwd); ROOT=$(cd "$CODE/.." && pwd)
+export POOL_BASE=${POOL_BASE:-$ROOT/work_base}
+export POOL_FRAMES_DIR=${POOL_FRAMES_DIR:-$ROOT/frames/pool_frames}
+export POOL_RESULTS_ROOT=${POOL_RESULTS_ROOT:-$ROOT/results/pool}
+mkdir -p "$POOL_BASE" "$POOL_RESULTS_ROOT" "$ROOT/logs"
+PY=${PY:-python3}; VLLM=${VLLM:-vllm}; PORT0=${PORT0:-8001}; GPU_UTIL=${GPU_UTIL:-0.85}
+STEPS_PY="$CODE/exp/analysis/pool/pool_steps.py"
+STEP=${STEP:?set STEP=1..6}
+case "$STEP" in
+  1) MODEL="Qwen/Qwen3-VL-8B-Instruct"; REV=0c351dd01ed87e9c1b53cbc748cba10e6187ff3b; MAX_LEN=8192;  MAX_SEQS=64; MM_IMAGES=1;  WORKERS=${WORKERS:-32};;
+  2) MODEL="Qwen/Qwen3-VL-8B-Instruct"; REV=0c351dd01ed87e9c1b53cbc748cba10e6187ff3b; MAX_LEN=8192;  MAX_SEQS=32; MM_IMAGES=1;  WORKERS=${WORKERS:-16};;
+  3) MODEL="Qwen/Qwen3-VL-2B-Instruct"; REV=89644892e4d85e24eaac8bacfd4f463576704203; MAX_LEN=16384; MAX_SEQS=16; MM_IMAGES=32; WORKERS=${WORKERS:-8};;
+  4) MODEL="Qwen/Qwen3-VL-8B-Instruct"; REV=0c351dd01ed87e9c1b53cbc748cba10e6187ff3b; MAX_LEN=8192;  MAX_SEQS=64; MM_IMAGES=1;  WORKERS=${WORKERS:-32};;
+  5) MODEL="Qwen/Qwen3-VL-2B-Instruct"; REV=89644892e4d85e24eaac8bacfd4f463576704203; MAX_LEN=16384; MAX_SEQS=16; MM_IMAGES=32; WORKERS=${WORKERS:-8};;
+  6) MODEL="Qwen/Qwen3-VL-8B-Instruct"; REV=0c351dd01ed87e9c1b53cbc748cba10e6187ff3b; MAX_LEN=16384; MAX_SEQS=16; MM_IMAGES=32; WORKERS=${WORKERS:-8};;
+  *) echo "STEP must be 1..6"; exit 2;;
+esac
+[ ! -e "$POOL_RESULTS_ROOT/pool_items_base.parquet" ] && { echo "copy items/* into $POOL_RESULTS_ROOT first"; exit 2; }
+if [ "${1:-}" = "--plan-only" ]; then "$PY" "$STEPS_PY" --step "$STEP" --plan-only --shard 0/1; exit $?; fi
+NGPU=${NGPU:-$(nvidia-smi -L 2>/dev/null | wc -l)}
+[ "$NGPU" -ge 1 ] || { echo "no GPU found"; exit 2; }
+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+=("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 "$MAX_LEN" --gpu-memory-utilization "$GPU_UTIL" --max-num-seqs "$MAX_SEQS" \
+      --limit-mm-per-prompt "{\"image\": $MM_IMAGES}" --mm-processor-cache-gb 0 --max-logprobs 20 \
+      > "$ROOT/logs/vllm_s${STEP}_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
+  for t in $(seq 1 180); do curl -sf "${EPS[$i]}/models" >/dev/null 2>&1 && break; kill -0 "${PIDS[$i]}" 2>/dev/null || { echo "vLLM on GPU $i died, see logs/vllm_s${STEP}_gpu${i}.log"; exit 1; }; sleep 10; done
+  echo "[run_remote] step $STEP: vLLM ready on GPU $i (${EPS[$i]})"
+done
+CPIDS=()
+for i in $(seq 0 $((NGPU - 1))); do
+  "$PY" "$STEPS_PY" --step "$STEP" --endpoint "${EPS[$i]}" --shard "$i/$NGPU" --workers "$WORKERS" \
+      > "$ROOT/logs/client_s${STEP}_gpu${i}.log" 2>&1 &
+  CPIDS+=($!)
+done
+rc=0; for p in "${CPIDS[@]}"; do wait "$p" || rc=1; done
+echo "[run_remote] step $STEP finished rc=$rc; remaining:"; "$PY" "$STEPS_PY" --step "$STEP" --plan-only --shard 0/1 | tail -1
+exit $rc