# 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

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.

```bash
# 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

```bash
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).

```bash
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

```bash
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`.