| ---
|
| language:
|
| - en
|
| license: cc-by-4.0
|
| task_categories:
|
| - question-answering
|
| - multiple-choice
|
| task_ids:
|
| - multiple-choice-qa
|
| size_categories:
|
| - n<1K
|
| configs:
|
| - config_name: default
|
| data_files:
|
| - split: level_1_easy
|
| path: level1_easy.jsonl
|
| - split: level_2_basic
|
| path: level2_basic.jsonl
|
| - split: level_3_intermediate
|
| path: level3_intermediate.jsonl
|
| - split: level_4_hard
|
| path: level4_hard.jsonl
|
| - split: level_5_expert
|
| path: level5_expert.jsonl
|
| tags:
|
| - benchmark
|
| - evaluation
|
| - reasoning
|
| - graded-difficulty
|
| - llm-evaluation
|
| pretty_name: LadderBench
|
| ---
|
|
|
| 
|
|
|
| # LadderBench
|
|
|
| A **graded capability ladder** for evaluating (large) language models: 150
|
| multiple-choice questions organized in **5 difficulty levels** (30 each),
|
| strictly ordered from *easy* to *expert*. Because every level is scored
|
| separately, LadderBench shows **where a model's abilities break down**, not
|
| just an average score - two models with the same overall accuracy can have
|
| very different level profiles.
|
|
|
| ## Motivation
|
|
|
| Averaged benchmark scores hide useful structure: a model can score 70% by
|
| acing easy questions and guessing on hard ones, or by being uniformly
|
| mediocre. LadderBench's ladder design exposes that difference:
|
|
|
| | Level | Name | What it probes | Example |
|
| |---|---|---|---|
|
| | 1 | easy | basic facts, single-step arithmetic | "What is 7 + 8?" |
|
| | 2 | basic | everyday knowledge, word problems, gentle traps | "Which month has at least 28 days?" |
|
| | 3 | intermediate | reading comprehension, applied reasoning, classic traps | bat & ball ($0.05), lily pads (day 29) |
|
| | 4 | hard | multi-step math, sequences, work rates, percentages | clock-angle 7.5°, chicken/rabbit legs |
|
| | 5 | expert | competition math, logic puzzles | 2^50 mod 7, trailing zeros of 100!, knights & knaves |
|
|
|
| Expected behavior of a healthy model: a roughly **monotonic decline** from
|
| level 1 to level 5. A model that scores better on level 5 than level 4 is a
|
| signal of noise (too few samples) or a poorly calibrated level - which is
|
| exactly what this design is meant to catch.
|
|
|
| ## Data format
|
|
|
| One JSON object per line (JSONL), identical schema in every file:
|
|
|
| ```json
|
| {
|
| "id": "l5_12",
|
| "level": 5,
|
| "category": "math",
|
| "question": "How many trailing zeros does 100! (100 factorial) have?",
|
| "choices": ["10", "21", "24", "25"],
|
| "answer": "C"
|
| }
|
| ```
|
|
|
| Fields:
|
| - `id` - stable unique identifier (`l<level>_<nn>`)
|
| - `level` - 1..5
|
| - `category` - arithmetic / knowledge / common-sense / reading / math /
|
| logic / sequence / probability / trick / reasoning / safety
|
| - `question` - the prompt shown to the model (passages are embedded in the text)
|
| - `choices` - exactly 4 answer options, presented to the model as (A)-(D)
|
| - `answer` - the gold letter, one of A/B/C/D
|
|
|
| ## Splits
|
|
|
| | File | Rows | Level |
|
| |---|---|---|
|
| | `level1_easy.jsonl` | 30 | 1 easy |
|
| | `level2_basic.jsonl` | 30 | 2 basic |
|
| | `level3_intermediate.jsonl` | 30 | 3 intermediate |
|
| | `level4_hard.jsonl` | 30 | 4 hard |
|
| | `level5_expert.jsonl` | 30 | 5 expert |
|
|
|
| ## Evaluation protocol
|
|
|
| The recommended protocol (implemented in the standalone runner):
|
|
|
| 1. Present the question with options lettered (A)-(D); instruct the model to
|
| answer with the letter only.
|
| 2. Parse the selected letter from the response (robust to "(B)", "B.", etc.).
|
| 3. Score 1.0 for an exact letter match, else 0.0; report per-level accuracy.
|
| 4. Use temperature 0 (greedy) for reproducibility.
|
|
|
| **Important**: the random-guessing baseline is 25% (4 options). With 30
|
| questions per level, each question is worth ~3.3 percentage points - treat
|
| per-level gaps under ~10 points cautiously and report the guessing baseline
|
| alongside results.
|
|
|
| ## Standalone runner
|
|
|
| This folder ships `run_ladderbench.py`, a **zero-dependency runner** (Python
|
| 3.8+ standard library only) so anyone can evaluate any model on LadderBench
|
| without installing anything else. It works with any OpenAI-compatible chat
|
| endpoint:
|
|
|
| ```bash
|
| # Ollama (default endpoint)
|
| python run_ladderbench.py --model qwen2.5:3b-instruct-q4_K_M
|
|
|
| # LM Studio
|
| python run_ladderbench.py --model my-model --base-url http://127.0.0.1:1234/v1 --api-key lmstudio
|
|
|
| # llama.cpp llama-server
|
| python run_ladderbench.py --model any-name --base-url http://127.0.0.1:8080/v1
|
|
|
| # OpenAI / other hosted APIs
|
| python run_ladderbench.py --model gpt-4o --base-url https://api.openai.com/v1 --api-key sk-...
|
|
|
| # Quick pass: only hard levels, 5 questions each
|
| python run_ladderbench.py --model <model> --levels 4,5 --limit 5
|
| ```
|
|
|
| What it does: letter-answer prompting over every question, robust letter
|
| parsing, per-level accuracy table, and a JSON report
|
| (`results_<model>_<timestamp>.json`) containing a full per-question audit
|
| trail (prediction, gold, raw output) for error analysis.
|
|
|
| Protocol notes:
|
| - temperature 0 (greedy) by default for reproducibility;
|
| - prompt asks for the letter only; parsing tolerates "(B)", "B.", etc.;
|
| - report the 25% guessing baseline next to results;
|
| - the audit file lets you compute per-category scores too (see `category`).
|
|
|
| ## Extending / contributing
|
|
|
| Add rows to any level file following the schema above (keep ids unique), or
|
| create a new level file and register it in the loader. When adding questions:
|
| verify the gold answer independently, make distractors plausible, and avoid
|
| answer-letter position bias by distributing correct letters across A-D.
|
|
|
| ## License
|
|
|
| CC-BY-4.0. Questions are original works written for this benchmark; classic
|
| puzzle ideas (bat & ball, lily pads, knights & knaves) are folklore and are
|
| rephrased here.
|
|
|
