code/README.md

VideoBenchEval

Multiple-choice evaluation of OnlineLong checkpoints (VideoLLaMA3-7B + qbase token compressor) on Video-MME, MLVU (dev) and LongVideoBench (val).

The model code comes from the training repo, pinned as a submodule at third_party/OnlineLong (branch ft, commit f76e08c "qbase timestemps fix": the first commit with per-segment time marks, which phase1_qbase_internvid was trained with).

Setup

git submodule update --init
bash scripts/setup_env.sh          # .venv: python 3.12, torch 2.9.1+cu126, flash-attn 2.8.3 built from source

Datasets are expected under /workspace/chicheng/datasets (DATA_ROOT to change):

benchmark	videos	annotation	questions
Video-MME	videomme/data/*.mp4	videomme/videomme/test-*.parquet	2700 (900 videos)
MLVU dev	mlvu/*.mp4	mlvu/mlvu/test-*.parquet	2174 (7 MCQ tasks)
LongVideoBench val	longvideobench/videos/*.mp4	longvideobench/lvb_val.json	1337

Run

bash scripts/run_budgets.sh                                  # B = 1k/2k/4k/8k/16k, one run each + summary table
bash scripts/run_eval.sh                                     # one budget (BUDGET, default 53820), all GPUs, all 3
MODEL=path/or/hub_id GPUS=0,1 BENCHMARKS="mlvu" bash scripts/run_eval.sh

All budgets run in one pass: each video is decoded once (for the largest budget; smaller budgets take an evenly spaced subset of those frames) and encoded once per frame size; the questions of a video share one prefill of the video prefix (KV cache). The cached prefill is not bit-identical to a single full prefill (bf16), which flips ~2% of near-tie answers.

Outputs go to results/<run>/<benchmark>/shard*.jsonl (one line per question: response, parsed letter, frame / vision-token counts) and results/<run>/scores.json. Re-running the same command resumes; python -m vbe.score results/<run> re-scores.

Protocol

Budgeted input (vbe/budget.py), B LLM-side vision tokens per video (BUDGET; run_budgets.sh sweeps 1024 / 2048 / 4096 / 8192 / 16384):

1. Frames: decided by B. 1 fps, at most B // 64 * 8 frames (128 ... 2048); longer videos are decoded at ~`max_frames / durationfps directly in ffmpeg. The target range is 0.2-1 fps; videos where B forces fps < 0.2 are flaggedfps_ok: false` per record.
2. One resolution for all frames: min(native, 2048, max(256, B // T)) tokens per frame. If T * hw <= B, every frame goes to the LLM uncompressed (raw).
3. Otherwise the Phase-1 adaptive segmenter cuts the video into T // 4 + 1 groups of 1-8 frames. Group variation = mean of consecutive-frame cosine distances of the mean encoder feature (1-frame groups: +inf, compressed last); groups are compressed (-> 64 qbase tokens) from the lowest variation up until the video fits (hybrid).
4. If compressing every adaptive group still does not fit, uniform 8-frame groups, all compressed (forced8).

Compressed groups use the checkpoint's projector; raw frames use the ORIGINAL VideoLLaMA3 projector (scripts/extract_orig_projector.py; encoder and LLM are bit-identical). LLM layout in time order: raw frame Time 12.0s:<hw rows>,, compressed group Time:{a}s-{b}s:<|compression_start|><64 rows><|compression_end|>. tests/test_equivalence.py checks the two extremes token-for-token: all-raw == plain VideoLLaMA3 with the original projector, all-compressed == the Phase-1 training path.

Prompts and answer parsing: official VideoLLaMA3 evaluation (VideoLLaMA3/evaluation/benchmarks/*.py), no subtitles. Greedy, 16 new tokens. Unparseable / unreadable / OOM count as wrong (no_answer, errors in scores.json). Reported: Video-MME overall + short/medium/long; MLVU M-Avg + per task; LongVideoBench val overall + per duration group; every benchmark also per layout mode.

Not covered: subtitle variants, Video-MME / MLVU test sets, LongVideoBench test (no labels).