FAQ

Benchmarks

LLM evaluation datasets, and what each one actually measures

MMLU, GSM8K, MATH, IFEval, HumanEval and the reasoning benchmarks — with the published scores that give you a sense of scale, and the contamination problem.

Benchmark numbers are the common currency of model comparison and are easy to misread. Knowing what each set contains, and what a given score means in context, is the difference between using them and being misled by them.

The standard set, and what it probes

These are the benchmarks you will see on nearly every model card. They measure genuinely different things, which is why models can be strong on one and weak on another.

BenchmarkWhat it measuresPublished reference points
MMLUbroad multiple-choice knowledge across many subjectsChinchilla 67.5; DCLM 7B 64; Nemotron-CC 8B 70.3 vs Llama 3.1 8B 65.3
GSM8Kgrade-school multi-step arithmetic word problemsTülu 3 8B 87.6; 70B 93.5
MATHcompetition-level mathematicsTülu 3 8B 43.7; 70B 63.0
IFEvalwhether a model follows explicit, checkable instructionsTülu 3 8B 82.4; 70B 83.2
HumanEvalPython function synthesis from a docstring, pass@1phi-1 1.3B 50.6
MBPPbasic Python programming problemsphi-1 1.3B 55.5
AIME 24 / 25olympiad-level maths, now the headline reasoning testOpenThinker3-7B 69.0 / 53.3
GPQA-Diamondgraduate-level science questions resistant to searchOpenThinker3-7B 53.7
LiveCodeBenchcompetitive programming, with contamination controlsOpenThinker3-7B 51.7
A three-panel comparison of mathematics datasets. Top left, a Metamath theorem-proving example with a GPT-f generated formal proof; bottom left, DeepMind Mathematics problems such as 'Divide 1136975704 by -142121963' with one-line answers; right, three MATH problems, on counting pairs of marbles, a geometric series in cos squared theta and the roots of a complex quadratic, each with a worked solution and a boxed final answer.
What MATH asks for, beside two earlier maths datasets: competition problems with worked solutions that end in one boxed answer, rather than formal proofs or one-step arithmetic. Scoring compares the boxed answer, which keeps MATH cheap to grade and means a score says nothing about whether the working was sound. Image: hendrycks/math · MIT repository · from “Measuring Mathematical Problem Solving With the MATH Dataset”, arXiv:2103.03874
A prompt-construction diagram broken into three labelled parts: a task description line, a block of in-context examples each showing an input and its answer, and a final prompt whose answer is left blank for the model to complete. The example text is a word-to-translation task.
How a benchmark item is actually presented: task description, k in-context examples, then the question. Change k and you change the headline number without touching the dataset at all. Image: EleutherAI/lm-evaluation-harness · MIT repository

IFEval is the one to pay attention to

Most benchmarks test knowledge or reasoning. IFEval tests something more basic and often more commercially relevant: does the model do what it was told. Answer in exactly three sentences. Do not use commas. Reply in JSON. Include the word “therefore” twice.

Its virtue is that compliance is programmatically checkable, which makes the metric hard to argue with and the data cheap to generate. It is also why instruction-following shows up in RLVR mixes: Tülu 3’s verifiable prompt set is 14,973 instruction-following prompts alongside 7,473 GSM8K and 7,500 MATH.

If your application depends on structured output or format compliance — as most production integrations do — IFEval-style evaluation is a better predictor of whether a model will work for you than MMLU.

A three-step diagram: a prompt with verifiable instructions (write a casual summary of the US maternity leave policy with two sections and at least 25 sentences), the model's response with Section 1 and Section 2, and an instruction-following verification with green ticks for two sections and at least 25 sentences.
How IFEval works: each prompt carries instructions a program can check, such as 'two sections' or 'at least 25 sentences', so a response is scored by code rather than by a judge model. Verifiable constraints are what make an instruction-following benchmark cheap to run and impossible to argue with. Image: Figure 1 of the paper · CC BY 4.0 · from Zhou et al. 2023, “Instruction-Following Evaluation for Large Language Models”, arXiv:2311.07911

Contamination, and why scores drift upward

The central problem with public benchmarks is that they are public. Test items leak into pretraining corpora, and a model that has seen the answers scores well without the capability.

A line chart titled 'Code Generation Live Evaluation': pass@1 against LeetCode problem release month, May to February, for DS-Ins-33B (red dashed), GPT-4 (green dotted) and GPT-3.5-Turbo (blue). Months before the arrowed 'DS-Ins Release Date' in September are shaded red, later months green. DS-Ins-33B scores 62, 51, 57 and 43 from May to August, then between 5 and 25; GPT-4 stays between about 19 and 45 throughout.
Pass@1 by the month each LeetCode problem was published. DeepSeek's 33B instruct coder scores 43 to 62 on problems released before its release date and 5 to 25 on those after; GPT-4 and GPT-3.5-Turbo show no such cliff. Dating every item is what lets LiveCodeBench tell memorised problems from solved ones. Image: LiveCodeBench/LiveCodeBench · MIT repository · from “LiveCodeBench: Holistic and Contamination Free Evaluation of Large Language Models for Code”, arXiv:2403.07974

This is not hypothetical. The web-scale corpora are built from Common Crawl, which contains benchmark pages, discussion of benchmark questions, and repositories of worked solutions. Deduplication against test sets helps and is not complete.

Three practical defences. Prefer benchmarks with contamination controls — LiveCodeBench dates its problems specifically so you can evaluate only on items postdating a model's training. Watch for the signature of contamination: excellent benchmark scores alongside disappointing behaviour on your own similar-looking tasks. And keep a private evaluation set, which is the only defence that fully works.

The same logic applies to generated training data: if your training and evaluation data come from the same teacher model, your benchmark measures agreement with that teacher rather than correctness.

Build the held-out set before the training set, shuffle whole sources rather than rows, and split by source. Random splits leak near-duplicates and inflate your metrics.

What public benchmarks cannot tell you

They are built to compare models on general capability. Your question is almost always narrower: will this model do my task on my inputs.

No public benchmark covers your document formats, your domain vocabulary, your users' phrasing, your latency budget or your failure costs. A model can lead every leaderboard and be the wrong choice for you, usually because your inputs are unlike anything in the benchmark suite.

So use the public numbers for what they are good at — shortlisting two or three candidates — and decide between them on your own evaluation set. That set is also the only thing that can tell you whether a fine-tune helped, which makes it the highest-value artefact in the whole pipeline.

A single-row heat map titled 'Chat Arena Spearman correlation', giving each benchmark's rank correlation with Chatbot Arena: output length 0.35, TruthfulQA 0.51, HellaSwag 0.59, GSM-8K 0.63, Open LLM 0.66, WinoGrande 0.69, ARC-C 0.83, MMLU 0.87, AlpacaEval 2.0 0.94, MT-bench 0.94 and LC AlpacaEval 2.0 0.98, the last highlighted in red.
How closely each benchmark's ranking of models agrees with Chatbot Arena's human votes, from 0.51 for TruthfulQA to 0.98 for length-controlled AlpacaEval; output length alone manages 0.35. The best of them predict general chat preference well, and that is all they predict: none was built on your formats or your inputs. Image: tatsu-lab/alpaca_eval · Apache-2.0 repository · from “Length-Controlled AlpacaEval: A Simple Way to Debias Automatic Evaluators”, arXiv:2404.04475

Questions people ask

Which benchmarks should I report for a fine-tuned model?

The ones covering what you changed and the ones covering what you did not. A fine-tune that improves your task while degrading general capability is a common outcome, and reporting only the target metric hides it. Include at least one general benchmark as a regression check.

Is a 2-point benchmark difference meaningful?

Usually not on its own. Scores vary with prompt formatting, few-shot examples, decoding parameters and evaluation harness. Treat small gaps between models as noise unless the evaluation setup is identical, and be wary of comparisons assembled from different papers' reported figures.

How large should my own evaluation set be?

A few hundred hand-checked examples is enough to be useful and small enough to actually curate. Coverage of your real input distribution matters far more than size, and a set you have read every item of is worth more than a large one you have not.

Should I use a model as a judge?

It is practical and widely done — UltraFeedback uses GPT-4 ratings across four aspects. The limits are the judge's biases, a known preference for longer and more confident answers, and the circularity if the judge also generated your training data. Validate the judge against human ratings on a slice before trusting it at scale.

Stop hunting. Start searching.

Tens of thousands of curated datasets, searchable in plain language — with the licence and size checked before you download anything.

Search Dataset Finder →