File size: 5,756 Bytes
a2ee198 4b798be a2ee198 cba3a51 a2ee198 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 | ---
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.
|