| # BenchCheck-FramesPixels: resolution x frame-rate sweep (task 11 run package) |
|
|
| Run package for an agent on a separate GPU machine. Goal: for each of 84 video benchmarks, answer the |
| same 300 multiple-choice items with Qwen3-VL-8B-Instruct under a resolution ladder, a frame-rate |
| ladder and a frame-count ladder, and send the per-item outputs back. The analysis (which benchmark |
| prefers pixels, frames, both or neither) is done on the origin side from your outputs. |
|
|
| Produce: the new rows appended to `results/conditions_results.csv` and the raw files |
| `results/p1_raw/<condition>/<benchmark>__DIAG_V.jsonl`, plus `logs/` (section 8). |
|
|
| ## 1. Conditions (fixed protocol, do not change) |
|
|
| All conditions use the same prompt skeleton and the same 300 items per benchmark; frames are taken |
| from the normalized video (stored at 2 fps or 1024 frames max, short side 720 up to 30 min, 480 beyond), |
| JPEG q=85, time-uniform grids over the stored frame timestamps. `temperature=0`, `max_tokens=128`. |
|
|
| | ladder | conditions | note | |
| |---|---|---| |
| | resolution (32 time-uniform frames) | v_32_s168, v_32_s336 (new); v_32_s224, v_32_s448, v_32 (exist for most benchmarks) | short side downscaled to 168 / 224 / 336 / 448 / storage. Videos stored at 480 reuse the v_32 answer for v_32_s448 (rule in the code). | |
| | frame rate (short side 224) | v_fps0.25_s224, v_fps0.5_s224, v_fps1_s224, v_fps2_s224 (new) | nearest stored frame to a fixed-fps grid, deduplicated. Cap = what the context holds: N_max = min(1024, floor((58000 - 1500) / tokens_per_frame)), tokens_per_frame = ceil(w/32)*ceil(h/32)+6 at the 224-px dims (97 for 16:9, so N_max = 582). Longer grids are re-sampled time-uniformly to N_max and the row records meta.capped_ctx = true, n_grid, n_max, n_frames_used. | |
| | frame count (short side 224) | v_8_s224, v_128_s224 (new); v_32_s224 (exists) | v_128_s224: videos with fewer than 128 frames send all frames (meta.capped = true). | |
| | base conditions | v_blind, v_1, v_32, v_32_s224, v_32_s448 | already computed on the origin cluster for most benchmarks; the runner skips rows present in `results/conditions_results.csv` and runs only the missing ones (24 of the 84 benchmarks lack some base condition). | |
|
|
| too_short videos (<= 32 stored frames) get `status = NA` for v_128_s224 and the four fps conditions |
| (existing rule). Items without a normalized video are logged as failures, not rows. |
| |
| Work: 84 benchmarks x 300 items x 8 new conditions = 201,600 inferences, plus about 30,000 base-condition |
| inferences for the benchmarks that lack them (see `items/scope_summary.json`, `existing_by_condition`). |
|
|
| ## 2. Hardware and software |
|
|
| Target: 4x NVIDIA B200 (180 GB each); one vLLM server per GPU. Qwen3-VL-8B bf16 weights ~16.4 GB; each server |
| runs with `--max-model-len 65536` (the fps ladders need it) and `--limit-mm-per-prompt '{"image": 1024}'`. |
| The launcher default `MAX_SEQS=32` suits 180 GB GPUs; on 32 GB GPUs (e.g. RTX 5090) set `MAX_SEQS=8`. |
|
|
| ```bash |
| python3 -m venv fp-env && source fp-env/bin/activate |
| pip install -r code/requirements.txt # vllm 0.11.0 + torch 2.8 cu128 (sm_120 for RTX 5090) |
| pip install -U "huggingface_hub[cli]" |
| huggingface-cli download Qwen/Qwen3-VL-8B-Instruct --revision 0c351dd01ed87e9c1b53cbc748cba10e6187ff3b |
| ffmpeg -version # needed only if decord and opencv both fail to decode |
| ``` |
|
|
| Disk: videos 94 GB unpacked (+94 GB for the tar shards until deleted), items/results/code 40 MB, model 17 GB. |
| CPU: frame decoding is CPU-bound (the fps ladders decode up to 582 frames per video); 16+ cores recommended. |
|
|
| ## 3. Get the data |
|
|
| ```bash |
| huggingface-cli download GMLRVigil/BenchCheck-FramesPixels --repo-type dataset --local-dir fp |
| cd fp |
| python3 - <<'PY' |
| import json, hashlib |
| m = json.load(open("videos/videos_manifest.json")) |
| for s in m["shards"]: |
| h = hashlib.sha256(open("videos/" + s["file"], "rb").read()).hexdigest() |
| assert h == s["sha256"], s["file"]; print(s["file"], "OK") |
| PY |
| mkdir -p data/store/normalized && for t in videos/videos_*.tar; do tar -xf "$t" -C data/store/normalized; done |
| ls data/store/normalized | wc -l # expect n_videos of videos_manifest.json (19,633) |
| ``` |
|
|
| Layout after this step: `code/`, `items/samples/<bench>.jsonl` (84 files), `manifest/manifest_subset.jsonl`, |
| `results/conditions_results.csv` + `results/p1_raw/v_32/` (existing rows, needed for resume and for the |
| stored-480 reuse rule), `data/store/normalized/<hash>/{video.mp4, meta.json}`. |
|
|
| ## 4. Run |
|
|
| `code/run_frames_pixels.sh` starts one vLLM server per GPU (ports 8011+i), waits until they answer, |
| then runs the P1 runner once with all endpoints (round-robin). It is resumable: rows already in |
| `results/conditions_results.csv` are skipped, so re-running the same command continues. |
|
|
| ```bash |
| cd fp |
| bash code/run_frames_pixels.sh --dry-run # per benchmark x condition: todo / NA / reuse counts |
| PILOT=1 bash code/run_frames_pixels.sh # MVBench, LVBench, TimeScope first |
| python3 - <<'PY' # per-condition timing of the pilot -> report it |
| import json, collections |
| t = collections.defaultdict(lambda: [0, 0.0, 0.0, 0]) |
| for l in open("data/logs/p1_timing.jsonl"): |
| r = json.loads(l); k = r["condition"] |
| t[k][0] += r["infer"]; t[k][1] += r["infer_s"]; t[k][2] += r["decode_s"]; t[k][3] += r["prompt_tokens"] |
| for k, (n, s, d, tok) in sorted(t.items()): |
| print(f"{k:16s} infer={n:5d} infer_s/item={s/max(n,1):6.2f} decode_s/item={d/max(n,1):6.2f} prompt_tok/item={tok/max(n,1):8.0f}") |
| PY |
| bash code/run_frames_pixels.sh # all 84 benchmarks (skips what the pilot did) |
| ``` |
|
|
| Environment knobs: `NGPU`, `WORKERS` (default 6 per GPU; the fps ladders are decode-bound, raise it with the core |
| count), `MAX_SEQS` (32), `GPU_UTIL` (0.85), `BENCH="A,B"` to restrict, `CONDS` to |
| restrict conditions (default = the full task-11 list). Logs: `logs/vllm_gpu<i>.log`, `logs/runner.log`, |
| `logs/launch_params.txt`, `data/logs/p1_timing.jsonl` (per benchmark x condition), `data/logs/failures.jsonl`. |
|
|
| Time estimate (not measured on this hardware): about 230k inferences; the fps ladders dominate (up to 582 frames |
| x 97 tokens = 56k prompt tokens per item). Expect roughly one day on 4x B200; the pilot timing calibrates it. |
|
|
| ## 5. Checks |
|
|
| - `--dry-run` before the pilot: the base conditions should show `todo=0` for the 60 benchmarks that have |
| them; every new condition shows `todo=300` (or fewer for benchmarks with < 300 sampled items). |
| - After the pilot: `meta.capped_ctx` is true for the long videos of LVBench / TimeScope at fps1 and fps2 |
| and false at fps0.25; MVBench videos are short and are never capped. `n_max` is 582 for 16:9 videos. |
| - `data/logs/failures.jsonl` should stay short (items without a video, rare decode errors). A benchmark |
| with hundreds of failures for one condition points at a vLLM restart (check `logs/vllm_gpu*.log` for OOM; |
| lower `MAX_SEQS` then re-run, the runner resumes). |
| - Do not delete or edit rows in `results/conditions_results.csv`. |
|
|
| ## 6. Do not change |
|
|
| Prompts, frame selection, resolutions, the fps grids and the cap rule, JPEG quality, `temperature=0`, |
| model revision, `--token-budget 58000`, `--max-images 1024`. If the machine cannot serve 65536 tokens of |
| context, stop and report instead of lowering it (the fps ladders would silently change). |
|
|
| ## 7. Known limits |
|
|
| - vLLM 0.11.0 with the CUDA 12.8 torch 2.8 wheels (Blackwell: B200 sm_100, RTX 5090 sm_120). |
| - `data/store/normalized` must keep the `<hash>/video.mp4 + meta.json` layout; the runner reads |
| `meta.json` for frame timestamps, resolution and the too_short flag. |
| - 96 of the 25,193 items have no normalized video in this snapshot; they are logged as failures and stay |
| missing (they are handled on the origin cluster). |
| |
| ## 8. Return the results |
| |
| ```bash |
| cd fp |
| tar -czf fp_returns_$(hostname)_$(date +%Y%m%d).tar.gz results/conditions_results.csv results/p1_raw logs data/logs |
| sha256sum fp_returns_*.tar.gz > fp_returns.sha256 |
| huggingface-cli upload GMLRVigil/BenchCheck-FramesPixels fp_returns_$(hostname)_$(date +%Y%m%d).tar.gz returns/fp_returns_$(hostname)_$(date +%Y%m%d).tar.gz --repo-type dataset |
| huggingface-cli upload GMLRVigil/BenchCheck-FramesPixels fp_returns.sha256 returns/fp_returns_$(hostname)_$(date +%Y%m%d).sha256 --repo-type dataset |
| ``` |
| |
| Without a write token, send the tarball and its sha256 by any file transfer. In the report, give the pilot |
| timing table (section 4), total wall time, rows added per condition, the failure count with example |
| item ids, and the exact vLLM launch line from `logs/launch_params.txt`. |
| |
