jev-bench

A small multiple-choice set for measuring a model that returns the probability of each option instead of writing an answer — the Jev / TypeSafe System One style of API, where a request carries a state and a question with named options and the response carries a distribution over them.

Ordinary multiple-choice benchmarks score the text a model generates. That says nothing about whether the probability attached to the answer means anything, which is the whole point of this kind of API. So this set is built to measure two things at once:

• accuracy — does the highest-probability option turn out to be the right one
• calibration — when the model says 0.7, is it right about 70% of the time

It also varies the number of options from 2 to 8, because a model that is well calibrated on binary questions is often badly calibrated on eight-way ones.

What is in it

split	questions	purpose
test	1,191	the reported numbers
val	358	fitting a temperature; never reported on

The two splits are disjoint, and both are disjoint from the training data used in the project this came from.

source	test	val
jcommonsenseqa	300	100
mmlu	291	100
arc_challenge	250	18
arc_easy	200	60
boolq	150	80

Option counts in test: 2 → 296, 3 → 151, 4 → 207, 5 → 158, 6 → 110, 7 → 162, 8 → 107. Always guessing scores 0.283, so treat that as the floor rather than 0.

Fields

field	meaning
id	stable identifier, prefixed with the source
source	one of mmlu, arc_challenge, arc_easy, jcommonsenseqa, boolq
question	the question text
context	a passage the question is about, or null (only boolq has one)
choices	the option texts, in a fixed order
answer_idx	index into choices of the right one
n_choices	len(choices), 2 to 8

How it was built

The five source datasets were merged and then reshaped so that the number of options varies. The original sets are mostly 4-option (ARC, MMLU), 5-option (JCommonsenseQA) or 2-option (BoolQ), which would leave the 5-to-8 range empty.

• to shrink a question, wrong options are dropped at random, keeping the right one
• to grow a question, wrong options are borrowed from other questions of the same group — the same MMLU subject, or the same source — so a borrowed option is topically plausible rather than obviously foreign. Options longer than 200 characters are not borrowed
• questions whose options are not all distinct after this are dropped

Everything is seeded (SEED = 1234), so the set is reproducible from the sources.

test uses all of 2–8 options. The project this came from trained on 2, 3, 4, 6 and 8 only, leaving 5 and 7 as held-out option counts, which is why those two are present here in quantity — they show whether a model generalises to a number of options it was not tuned for.

Evaluating

The evaluator lives in kishida/jev-bench on GitHub, together with the game benchmarks built on the same API:

git clone https://github.com/kishida/jev-bench
pip install requests numpy datasets
python jev-bench/eval.py --url http://127.0.0.1:8080

It pulls this dataset from the Hub, so nothing needs downloading by hand. eval.py sends each question as one choice question, with the option texts as the criteria, so it exercises the server the way an application would. It picks one of two modes automatically.

logits — the server accepts options.return_logits and options.temperature_scaling. Raw logits come back untouched, a single temperature T is fitted on val by minimising cross entropy, and accuracy and ECE are reported before and after applying it. This separates how often the model is right from how honest its probabilities are, and the two move independently: a model can be accurate and wildly overconfident.

probabilities — the server only returns probabilities. Accuracy comes out identical; the calibration numbers then describe whatever calibration the service already applies, and no temperature is fitted. Use this for a hosted API. Note that probabilities are usually rounded before being sent, so NLL and Brier are inflated and are only comparable within this mode; accuracy and ECE are not affected.

Useful flags: --api-key, --workers (lower it for a hosted API), --limit N for a quick check, --assistant-prefix for a model that writes something before the label, --data DIR to read test.jsonl / val.jsonl from disk instead of the Hub, --out FILE for the full JSON including per-source and per-option-count breakdowns.

ECE uses 15 equal-width bins over the confidence of the top option.

The prompt matters

These numbers are only comparable between servers that build the same prompt. The reference implementation is the /v1/systemone endpoint of the jev branch of llama.cpp, which composes one user message:

Context:
{state, or "(none)"}

Answer the question with only the label of the best option (the character before the colon), nothing else.
Question: {instructions}
Options:
A: {first criterion}
B: {second criterion}
...

and reads the probability of each single-token label A, B, … at the first generated position. A server that phrases this differently will get different numbers; that is a property of the server, not of this data.

Caveats

• 1,191 questions is small. Differences under about 0.02 in accuracy are not meaningful. Read the results as a rough ordering.
• The reshaping makes it its own benchmark. Numbers here are not comparable to published MMLU or ARC scores, because the option counts, the distractors and the prompt all differ.
• Borrowed distractors are not guaranteed wrong. They come from other questions, so a borrowed option is almost always wrong for this question, but nothing verifies it.
• val is for fitting, not reporting. A temperature fitted on test would flatter every model.

Licence and attribution

cc-by-sa-4.0. The data is derived from four upstream datasets, and the share-alike terms of some of them carry over to this derivative:

source	upstream
ARC-Challenge, ARC-Easy	allenai/ai2_arc
MMLU	cais/mmlu
JCommonsenseQA	sbintuitions/JCommonsenseQA (JGLUE)
BoolQ	google/boolq

If you use this, please cite the upstream datasets as well — the questions are theirs; only the selection, the reshaping and the evaluation protocol are new here.