BenchCheck-Pool: full-item-pool screening, steps 1-3 (run package)

This package lets an agent on a separate GPU machine run the three model-based screening steps of the BenchCheck full-item pool and send the per-item results back. Everything needed is here except the two open-weight models (downloaded from the Hugging Face hub) and the frame cache, which sits in the companion dataset GMLRVigil/BenchCheck-Pool-Frames (public).

Produce: results/pool/step1/*.jsonl, results/pool/step2/*.jsonl, results/pool/step3/*.jsonl (one row per item, append-only, resumable), packed and uploaded as described in section 8.

1. What the three steps do (do not change any of it)

Items: multiple-choice questions of 139 video benchmarks (299,366 after the step-0 dedup, table in items/). Each step asks a Qwen3-VL model the question and reads the log-probability of every option letter as the first generated token (assistant turn prefilled with Answer:, max_tokens=1, logprobs=true, top_logprobs=20). An item leaves the pool when the model is right with a margin above log 2:

step	model	input	removal rule
1 blind	Qwen3-VL-8B-Instruct	question + options, no frames, 4 option permutations per item	≥ 3 of 4 permutations pick the gold letter and mean margin > log 2
2 single frame	Qwen3-VL-8B-Instruct	the middle frame (448 px long side) + question	gold letter is argmax and margin > log 2
3 32 frames	Qwen3-VL-2B-Instruct	32 uniform frames (448 px) + question	same

Step 2 runs only on items that survived step 1 and have frames; step 3 only on survivors of step 2. Prompts, permutation seeds, frame selection, resolution, model revisions and the margin rule are fixed in the code (code/exp/analysis/pool/pool_steps.py, pool_common.py, pool_prompts.py); the paper protocol depends on them, so run the code as is. code/exp/analysis/pool/TASK.md is the original task note (Chinese).

2. Hardware and software

Tested target: 4x RTX 5090 (32 GB each). Per GPU one vLLM server and one client shard. VRAM: Qwen3-VL-8B bf16 weights ~16.4 GB, Qwen3-VL-2B ~4.4 GB; the launcher uses --gpu-memory-utilization 0.85. If vLLM fails with out-of-memory at start-up, lower MAX_SEQS in code/run_remote.sh (e.g. 64 -> 32 for step 1); do not lower the resolution or the frame count.

# Python 3.12 environment
python3 -m venv pool-env && source pool-env/bin/activate
pip install -r code/requirements.txt          # vllm 0.11.0 + torch 2.8 (CUDA 12.8 wheels; sm_120 for RTX 5090)
pip install -U "huggingface_hub[cli]"
# models (pinned revisions; served under their hub names)
huggingface-cli download Qwen/Qwen3-VL-8B-Instruct --revision 0c351dd01ed87e9c1b53cbc748cba10e6187ff3b
huggingface-cli download Qwen/Qwen3-VL-2B-Instruct --revision 89644892e4d85e24eaac8bacfd4f463576704203

Disk: items 80 MB, frames ~35 GB unpacked (+35 GB for the tar shards until you delete them), results < 2 GB, model weights ~21 GB.

3. Get the data

huggingface-cli download GMLRVigil/BenchCheck-Pool --repo-type dataset --local-dir pool
cd pool
mkdir -p results/pool && cp items/*.parquet items/*.csv items/*.jsonl results/pool/
# frames (public repo)
huggingface-cli download GMLRVigil/BenchCheck-Pool-Frames --repo-type dataset --local-dir frames_tar
python3 - <<'PY'
import json, hashlib, sys
m = json.load(open("frames_tar/frames_manifest.json"))
for s in m["shards"]:
    h = hashlib.sha256(open("frames_tar/" + s["file"], "rb").read()).hexdigest()
    print(s["file"], "OK" if h == s["sha256"] else "SHA256 MISMATCH"); assert h == s["sha256"]
PY
mkdir -p frames/pool_frames && for t in frames_tar/frames_*.tar; do tar -xf "$t" -C frames/pool_frames; done
ls frames/pool_frames | wc -l      # expect the n_videos value of frames_tar/frames_manifest.json (67,021)

After this the package root pool/ holds code/, items/, results/pool/, frames/pool_frames/.

4. Run

code/run_remote.sh starts one vLLM server per GPU (ports 8001+i), waits until they answer, runs one client shard per GPU, then prints the remaining work. Run the steps in order; each command can be re-run at any time and continues where it stopped (rows are keyed by item_id).

cd pool
STEP=1 bash code/run_remote.sh --plan-only    # 299,366 items expected before the first run
STEP=1 bash code/run_remote.sh                # ~1.5-2 h on 4x 5090 (estimate)
STEP=2 bash code/run_remote.sh --plan-only    # survivors of step 1 that have frames (upper bound 183,196)
STEP=2 bash code/run_remote.sh                # ~1.5-2.5 h (estimate)
STEP=3 bash code/run_remote.sh --plan-only
STEP=3 bash code/run_remote.sh                # ~2-4 h (estimate); 2B model, 32 images per request

Environment variables the launcher accepts: NGPU (default: all visible GPUs), WORKERS (client threads per GPU; defaults 32 / 16 / 8 for steps 1 / 2 / 3), PORT0, GPU_UTIL, PY, VLLM. Logs: logs/vllm_s<STEP>_gpu<i>.log, logs/client_s<STEP>_gpu<i>.log.

The time estimates come from throughput on the origin cluster's smaller GPU slices and were not measured on a 5090; step 1 calibrates them (its client log prints items/s).

5. Progress and expected counts

STEP=N bash code/run_remote.sh --plan-only prints REMAINING_TOTAL=<n>; a step is complete when it prints 0. Step 1 covers 299,366 items = 1,197,464 forwards. Of these items, 183,196 (67,021 videos) have frames in this snapshot; the other 116,170 items reference videos that were not yet downloaded on the origin cluster (video_id starting with k:), so steps 2 and 3 skip them here. They will be finished on the origin cluster; nothing to do about them on your side.

Sanity checks:

• Step 1 removes a minority of items per benchmark (blind removal on the 300-item samples was mostly 20-60 %); a benchmark with ~100 % removal or ~0 % removal deserves a look at its client log.
• Every step-1 item has 4 permutation forwards (n_perm / per-permutation fields in the row).
• Rows with status != "ok" are retried automatically up to the limit in the code; a few hundred permanent errors in a million forwards is normal, thousands is not (check the vLLM log for OOM).

6. Files that must not be edited

code/exp/analysis/pool/*.py (protocol), items/* (inputs). The launcher code/run_remote.sh may be adapted to the machine (ports, GPU count, paths) but not the vLLM model arguments other than --max-num-seqs and --gpu-memory-utilization.

7. Known limits

• vLLM 0.11.0 needs the CUDA 12.8 torch 2.8 wheels for RTX 5090 (sm_120). If pip install vllm==0.11.0 pulls a torch without sm_120 support, install torch 2.8.0 from the cu128 index first.
• --max-logprobs 20 and continue_final_message are vLLM features; the client will not work against other serving stacks.
• The frame cache is a snapshot; missing directories for some video_id values are expected (see 5).

8. Return the results

cd pool
tar -czf pool_returns_$(hostname)_$(date +%Y%m%d).tar.gz results/pool/step1 results/pool/step2 results/pool/step3 logs
sha256sum pool_returns_*.tar.gz > pool_returns.sha256
# with a write token for GMLRVigil:
huggingface-cli upload GMLRVigil/BenchCheck-Pool pool_returns_$(hostname)_$(date +%Y%m%d).tar.gz returns/pool_returns_$(hostname)_$(date +%Y%m%d).tar.gz --repo-type dataset
huggingface-cli upload GMLRVigil/BenchCheck-Pool pool_returns.sha256 returns/pool_returns_$(hostname)_$(date +%Y%m%d).sha256 --repo-type dataset

If you have no write token, send the tarball and its sha256 by any file transfer. In the report, state per step: items done, items removed, rows with status error (count and example item_ids), wall time and items/s per GPU, and anything you changed in run_remote.sh.