weitaikang/Weitaikang_bench_github

HeroFrame-Bench — evaluation code

Evaluation code for a key-frame selection benchmark that scores a selected frame directly — without routing it through a question-answering model, and without requiring it to match a fixed reference set.

204 films · 2,031 frozen comparison chains · 1,970 learned criteria

The project is three repositories:

	Repository	Contents
code	you are here	the evaluation package, all eleven baselines, four numbered scripts
benchmark	Weitaikang_bench_data	2.8 GB — chains, images, rubrics, frame-track index
archive	Weitaikang_bench_paper	400 MB — judge calls, human study, ablations, per-unit scores

🏆 Leaderboard · 📄 Citation

random  0.501  ──────────────  best method  0.586  ──────  human stills  0.722
                                        38% of the way

---

What this measures

A film is almost always met first as a single still — a cover, a thumbnail, a poster. Producing that still is key-frame selection, and we call its target a hero frame: a single still image taken from within a movie that would work as its cover, thumbnail, or promotional entry point.

Existing evaluation takes one of two routes, and each loses the thing being measured.

Routing through question answering — feed the frames to a frozen VLM, ask questions, report accuracy — makes the score a joint property of two systems. A weak reader punishes a good selection; a strong one forgives a redundant selection. And the questions have to be machine-checkable, so they probe retrievable content, which is not the part of hero-frame quality in doubt.

Comparing against a fixed answer — a reference summary, or proxies like brightness and sharpness — records any good frame outside the reference as a miss, and measures exposure and focus rather than whether an image works as a cover.

Here, a candidate frame is inserted into a chain of six stills from the same film that are already ordered from best hero frame to worst, and scored by the position it reaches:

s(F, C) = (chain images F was placed above) / 6      in [0, 1]

Nothing has to match a reference, and no downstream QA model is involved.

Getting started

Six steps. Steps 1, 2 and 5 are quick; step 3 depends on a dataset request and step 4 on how many films you rebuild.

1. Install

hf download weitaikang/Weitaikang_bench_github --repo-type dataset --local-dir HeroFrame-Bench
cd HeroFrame-Bench
pip install -e ".[all]"

Needs Python 3.10+, and decord for decoding. GPU only for the reader model and for the SigLIP baseline. pip install -e . alone skips the optional dependencies if you only want to read the benchmark.

2. Download the benchmark

./scripts/00_download_benchmark.sh
export HEROFRAME_ROOT=~/.cache/heroframe-bench

2.8 GB: the chains, their images, the rubrics, the frame-track index. At this point you can already read the benchmark:

from heroframe import Benchmark

bench = Benchmark()
movie = bench["0001_American_Beauty"]
chain = movie.chains[0]

print(chain.image_ids)          # six images, best hero frame first
print(chain.anchor_rank)        # where the human publicity still landed
print(movie.rubric[0]["as_the_judge_read_it"])

Verification point: len(bench) is 204.

3. Obtain the film footage

Request LSMDC access at https://sites.google.com/site/describingmovies/.

This is the only thing you have to source yourself, and it is unavoidable — the footage is licensed and cannot be redistributed. Expect the request to take some days.

Layout the code expects:

<lsmdc>/<movie_id>/<clip_id>.avi

If yours differs, adapt heroframe.track.clip_file rather than renaming 128,085 files.

4. Rebuild the candidate frame pool

Every method selects from one shared pool, so the comparison is about selection strategy and not about whose decoder samples on a denser grid. The pool is ~500,000 frames at 1 fps, and the benchmark ships its coordinates rather than its pixels.

Try three films first.

python scripts/01_rebuild_track.py --lsmdc /data/lsmdc --out ./track \
    --movies 0001_American_Beauty 0003_CASABLANCA 0008_Fargo

python scripts/02_verify_track.py --track ./track \
    --movies 0001_American_Beauty 0003_CASABLANCA 0008_Fargo

Verification point: 3/3 films verified.

Then the rest:

python scripts/01_rebuild_track.py --lsmdc /data/lsmdc --out ./track --workers 8
python scripts/02_verify_track.py --track ./track

Several hours, reading 1.3 TB. It resumes if interrupted — re-running skips finished films.

Do not skip verification. A wrong pool raises no error anywhere downstream: selection runs, scoring runs, a number comes out, and it is not comparable with anything. Verification compares perceptual hashes on 24 frames per film, with a tolerance measured to separate real errors from harmless encoder differences.

5. Run your method

Your method receives only the film's footage. No rubric, no reference stills, no metadata. Multimodal methods additionally get one fixed sentence, identical for every film:

from heroframe import QUERY

Output at most 5 frames per film, as indices into the track:

{"movie_id": "0001_American_Beauty", "frames": [{"rank": 1, "frame_idx": 2477}, {"rank": 2, "frame_idx": 1893}]}
{"movie_id": "0002_As_Good_As_It_Gets", "frames": [{"rank": 1, "frame_idx": 412}]}

You choose how many, up to five. Scoring averages rather than takes the best, so a fifth mediocre frame can pull you down — which is why the benchmark does not legislate the count.

Smoke-test the chain with a built-in baseline first:

python scripts/03_run_baseline.py --track ./track --method random

6. Score

Start a reader. Every published number used Qwen3.6-27B locally, at zero API cost:

vllm serve Qwen/Qwen3-VL-27B-Instruct \
    --max-model-len 16384 --gpu-memory-utilization 0.90 \
    --reasoning-parser qwen3 --no-enable-prefix-caching

Then:

python scripts/04_evaluate.py --selections my_method.jsonl \
    --track ./track --name my_method

Verification point: score random on the full corpus and it should land at 0.501. That value is not fitted — a chain is one human still plus five random frames from the film, so a random candidate should beat about half of them, and 0.5 is what construction implies.

You get S, S@k, top-1 rate, and a table against the eleven official rows.

---

What comes out

# my_method

S = 0.5721   (43.3% of the way from random to human publicity stills)

204 films, 10,155 units

| | Method | S | Insert rank | Top-1 | Journey |
|---|---|---|---|---|---|
| | Human IMDb still _ref_ | 0.7218 | 2.67 | 13.4% | +100.0% |
| | CueKFS j7 (gpt-5.5, budget 96) | 0.5855 | 3.49 | 6.5% | +38.2% |
| **>** | **my_method** | **0.5721** | 3.57 | 6.0% | +33.2% |
| | Largest-face heuristic _probe_ | 0.5571 | 3.66 | 5.0% | +25.3% |
| | Random _ref_ | 0.5015 | 3.99 | 2.9% | +0.0% |

Read S against the two reference lines rather than in isolation. 0.57 sounds unremarkable until you know random is 0.501 and humans are 0.722.

---

Two ways to get an incomparable number

Editing the scoring prompt. Every published number came from one exact prompt text. heroframe.verify.check_prompts() hashes it and scoring refuses to run if it has drifted. Studying the metric by changing the prompt is legitimate — pass --allow-modified-prompt and report the result as your own measurement, not as a benchmark score.

Substituting a method's internal LLM. This is not hypothetical. Replacing CueKFS's published gpt-5.5 with a cheaper local model moved it to the other side of the random baseline, because 99.7% of its batch-review actions collapsed into the parse-failure fallback and that stage silently stopped running. No error, no interruption. Report methods in their published configuration, name the internal model in the method name, and verify by checking a stage's action distribution rather than by checking for exceptions.

---

Repository layout

heroframe/
  data.py        load the benchmark; Benchmark, Movie, Chain
  track.py       rebuild the candidate pool from your LSMDC copy
  verify.py      confirm the rebuild matched, and the prompt is unedited
  prompts.py     the frozen scoring prompt
  reader.py      reader model interface; OpenAI-compatible implementation
  evaluate.py    scoring
  report.py      result table against the official rows
baselines/       all eleven rows, runnable — see baselines/README.md
scripts/         the four numbered steps above
examples/        quickstart notebook and submission format
tests/           end-to-end regression on three sample films

Submitting to the leaderboard

Open a pull request adding a row to LEADERBOARD.md with your result JSON attached. See examples/submit_your_method.md for what to include.

Where the chain orderings came from

Not from human annotators, and not from an off-the-shelf notion of image quality. Each film's ordering was produced by a judge model reading a rubric learned for that film, starting from nothing, written by the model while it was ordering the images. Every criterion had to survive two falsifiable admission gates; in the second round they rejected 94.4% of proposals.

Two results matter for trusting it. Against 450 pairs judged blind by humans, the rubric-guided judge agrees 83.78% of the time against 77.56% with no rubric. And serving a film another film's rubric is statistically indistinguishable from serving no rubric at all (p = 0.41) — the gain is not generic photographic common sense.

The full protocol, all ablations, and the evidence behind every number are in the paper archive.

Limitations

• Chain orderings are model judgements, validated against human agreement on a sample rather than certified as ground truth.
• Each human pair carries one vote, so inter-annotator agreement cannot be computed; 83.78% is agreement with a single person's choice.
• The positive end is IMDb publicity stills, themselves products of a marketing process with its own conventions.
• 204 English-language films from LSMDC, 1943–2014 — Western theatrical cinema. No episodic content, no non-Western cinema, no user-generated video.
• The reader is part of the specification. Frame-level scores are not comparable across readers, though the method ranking survives a change.

Citation

@inproceedings{heroframebench,
  title     = {HeroFrame-Bench: Evaluating Key-Frame Selection Without
               Delegating to Question Answering},
  booktitle = {International Conference on Learning Representations (ICLR)},
  year      = {2027}
}

Licence

Code under MIT. Data and images under research-only terms — see the dataset's LICENSE.md. baselines/cuekfs/upstream/ and baselines/wfs_sb/upstream/ retain their own licences.