Aoraku/CMBench_NewRecipe

CMBench handoff — the remaining 40 videos

Everything needed to generate and score the 40 CMBench videos that have not been run yet, on a machine other than the one the first batch ran on.

The ten priority videos (26 questions) are already done. This bundle covers the other 40 videos, 87 questions, all with prompts and target annotations.

---

What is in here

Path	What it is
context_videos/	50 context clips, 60 s each, 832×480 @ 24 fps, named by bundle id
prompts/metadata_clip_and_gen.json	the authoritative source: per question a generation prompt, a target time and a normalised box; per clip a plain scene description
benchmark/metadata/benchmark_cases.jsonl	the same annotations in the evaluator's row format, all 113 questions
method_configs.json	the exact hyper-parameters of all 8 methods, extracted from the requests that produced the published table
build_benchmark_metadata.py	regenerates the metadata above, and verifies it
prepare_requests.py	builds the generation requests
scripts/	worker, guarded launcher, and evaluation scripts

Prompt contract, since this is the easiest thing to get wrong:

• the continuation prompt is the question's generation_prompt;
• the context is encoded clip-by-clip — one plain scene description per 10 s clip, scheduled at chunks 0, 10, 20, 30, 40, 50;
• context_prompt_mode is case, which passes that schedule through untouched. Setting it to scene silently replaces the schedule with a single prompt, and the clipwise setting then does not happen at all.

---

Prerequisites on the target machine

1. The code. Branch lingbotworld-lql of forcingkv_private:

   git clone https://github.com/xizaoqu/forcingkv_private.git
   cd forcingkv_private && git checkout lingbotworld-lql
   

   The runner is vendor/lingbot_world2/run_context_memory_lingbot_sp.py.

2. The checkpoint. LingBot-World-2 14B causal-fast. On the original machine: .../models/lingbot-world-v2-14b-causal-fast. Roughly 4 GPUs of 80 GB+ per worker at --ulysses-size 4.

3. Python environment. torch with flash-attention, opencv-python, omegaconf, einops. The original runs used a conda env at /home/n2501108a/miniconda3/envs/diff.

4. The head map, required by ours_fkv_reindex and forcingkv_reindex only: vendor/lingbot_world2/configs/lingbot_heads_q0_sink4_recent4_thr08_cal15_v2.json (ships with the repo).

5. Evaluation models: OWL-ViT, SAM and DINOv2 weights, resolved through CONTEXT_MEMORY_MODEL_ROOT.

---

Running it

Set the paths once:

export CMBENCH=/path/to/this/bundle
export REPO=/path/to/forcingkv_private
export CKPT=/path/to/lingbot-world-v2-14b-causal-fast
export CMBENCH_HEAD_MAP=$REPO/vendor/lingbot_world2/configs/lingbot_heads_q0_sink4_recent4_thr08_cal15_v2.json
export OUT=/path/to/output

1. Requests

ours_random_reindex matches Ours per-chunk keep counts, so it must be generated after ours_reindex at the same seed, and its ours_random_reference_root must point at that run. Hence two passes:

cd $CMBENCH

# pass A: Ours first, because Ours-Random matches it
python prepare_requests.py --out requests/passA.jsonl --output-root $OUT \
  --exclude-priority --seeds 42 1234 3407 --methods ours_reindex

# pass B: everything else
python prepare_requests.py --out requests/passB.jsonl --output-root $OUT \
  --exclude-priority --seeds 42 1234 3407 \
  --methods fullkv streaming_reindex ours_fkv_reindex forcingkv_reindex \
            dummyforcing_reindex patchify_reindex

# pass C: Ours-Random, after pass A has finished
python prepare_requests.py --out requests/passC.jsonl --output-root $OUT \
  --exclude-priority --seeds 42 1234 3407 --methods ours_random_reindex
# then set ours_random_reference_root on each line to
#   $OUT/ours_reindex_seed<SEED>

Scale: 87 cases × 8 methods × 3 seeds = 2088 runs. At the measured 110–340 s per run, one 4-GPU worker needs roughly three days. Split by case across several workers if more cards are available — the requests are independent apart from the Ours → Ours-Random ordering.

2. Generation

Point scripts/run_worker.sh at your repo, checkpoint and requests file, then:

LINGBOT_GPUS=0,1,2,3 ./scripts/run_worker.sh requests/passA.jsonl logs/passA.log

--skip-existing is on, so an interrupted batch resumes instead of restarting. scripts/guarded_launch.sh additionally waits for the cards to be genuinely free and verifies the output count before declaring success — worth using on a shared machine, where a neighbour's job otherwise causes an OOM that looks like completion.

3. Scoring

LINGBOT_EVAL_GPUS=0,1,2,3 ./scripts/run_eval_parallel.sh <profile tags...>

Scoring is the project's own OWL+SAM+DINO relevance eval. Do not substitute another metric: the published numbers are only comparable through this pipeline. Serial scoring manages about one video per minute, so shard it.

Headline metric is dino_score from video_summary.csv; seqPR comes from each run's seq_pr_metrics.json.

---

Method configurations

From method_configs.json, as used for the published table:

Method	Retention policy	Key settings
fullkv	none	the unpruned reference, no re-index
ours_reindex	per-chunk noisy-step vs ground-truth error	threshold 0.10, step 2
ours_fkv_reindex	as above, static/dynamic head split	threshold 0.10, needs head map
ours_random_reindex	random, matched to Ours keep counts	threshold 0.10, needs the Ours run
forcingkv_reindex	adjacent-frame patch cosine top-K	K=256 patches, window 32 chunks, needs head map
patchify_reindex	6×13 grid block retrieval, head-uniform	topk 2000 blocks
streaming_reindex	sink + recent ring	local 8, sink 4
dummyforcing_reindex	first/middle/last head groups	4 frames each, centre bank

Every *_reindex name runs its base policy with the RoPE re-index adapter on, and writes to its own directory so baseline runs stay reusable. The name implies the adapter; passing --rope-reindex-mode off with such a name is rejected rather than silently producing a baseline run under a re-index name.

patchify_reindex uses topk 2000, not the frozen 3328: without the head split every head pays for the retrieved blocks, so 3328 would retain far more. 2000 is calibrated to match Ours seqPR.

---

Notes on the metadata

Coverage is complete: all 113 questions carry a prompt and a target annotation, so all 87 remaining ones can be both generated and scored.

The row format is derived from the annotations, and the derivation is checked. The frozen benchmark shipped the evaluator's row format for the ten priority videos only, so the other forty needed the same conversion: target time to a 24 fps frame index, normalised box denormalised against 832×480. build_benchmark_metadata.py does that, reading only prompts/metadata_clip_and_gen.json so a corrected target cannot be shadowed by a stale copy elsewhere. Run:

python build_benchmark_metadata.py --verify

which reproduces all 26 already-published rows exactly, frame and box, and fails loudly otherwise. Regenerating the file is safe at any time.

Output length is a per-case property. Rotate questions generate 8 latent / 32 pixel frames, object-recreate 16 / 60. This is inherited from the benchmark unchanged and is why measured seqPR varies by about 0.01 between case types at a fixed budget.