Upload README.md with huggingface_hub

README.md

@@ -0,0 +1,137 @@
+# 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.
+
+```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; 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
+
+```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.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
+
+```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`.