Datasets:

GMLRVigil
/

BenchCheck-Pool

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.

Fix 2026-09-11: the first upload of supplement_20260910/code/ (and of the main package's code/) lacked code/exp/pipeline/ (chance.py, scoring.py, stage_d_blind.py). pool_steps.eligible imports chance._yes_no_options (the yes/no-option rule of 2026-09-10) from that folder, so --plan-only and the run stop with ModuleNotFoundError: No module named 'chance'. Both repos now carry the folder; re-download supplement_20260910/code/ and copy it over pool/code/ (the three files are verbatim copies of our pipeline, the screening rule is unchanged). Nothing else in the package changed.

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

Target: 4x NVIDIA B200 (180 GB each); also runs on 32 GB GPUs. 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. On 32 GB GPUs, 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; Blackwell B200 / 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-2 h on 4x B200 (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 this hardware; 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 with the CUDA 12.8 torch 2.8 wheels (Blackwell B200 / RTX 5090). If pip install vllm==0.11.0 pulls a torch without Blackwell 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.