add supplement_20260910/code/

9e19fa1 verified about 1 month ago

15.8 kB

"""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)

	"""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)