Upload code/exp/analysis/pool/pool_steps.py with huggingface_hub

code/exp/analysis/pool/pool_steps.py

@@ -0,0 +1,337 @@
+#!/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_VISUAL  # noqa: E402  (verbatim copies of stage_p1_runner)
+
+MAX_ATTEMPTS = 5
+DEFAULT_WORKERS = {1: 32, 2: 16, 3: 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."""
+    df = df[df["format"] == "mcq"]
+    notes = []
+    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 >= 2:
+        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)}")
+    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)
+            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):
+        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)
+            prompt = pc.PROMPT.format(intro=INTRO_BLIND, q=question, opts=pc.render_options(texts))
+            r = self.forward(prompt, None, f"{iid}/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)
+        return dict(perms=recs, blind_acc_4perm=round(acc, 4), blind_margin=round(margin, 4),
+                    remove=remove, n_forwards=len(perms), latency_s=round(lat, 4), prompt_tokens=ptok)
+
+    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")
+        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 = "sf" if self.step == 2 else "v32_2b"
+        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"])
+        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 >= 2:                                  # 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])
+    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()