SCORING.md

fai_bench — Scoring

English: SCORING.md (this file) · 中文: SCORING.zh-CN.md

The authoritative implementation for each task is its own tests/compute_reward.py; this document describes the shape of the two reward classes so you don't misread the results. Scoring artifacts always land in /logs/verifier/:

reward.json     structured result: reward + breakdown (per-case pass counts, paired speedup, diagnostics)
reward.txt      plain text, same value as reward.json's reward

The reward field in reward.json is the task's final score — no second conversion is needed (you do not, as with some harnesses, treat score as a conservative value and have the leaderboard compute partial credit separately).

The two reward classes

Class	Tasks	Range	Shape
Performance	77	continuous [0, 1]	pass the correctness gate first, then score by the log speedup relative to oracle
Implementation	8	binary {0.0, 1.0}	all hidden cases pass and no gate fires → 1.0

Performance: log speedup, oracle is the zero point

The 77 performance tasks all use reward_md_log_speedup_v2_oracle_zero:

speedup ≤ ref_speedup  ⇒  reward = 0
speedup > ref_speedup  ⇒  reward = min(1.0, ln(speedup / ref_speedup) / ln(ref_speedup))
                                                                        range [0, 1]

Three anchors determine how to read it:

• speedup ≤ ref_speedup (did not exceed the oracle calibrated at authoring time) ⇒ reward = 0
• speedup == ref_speedup^1.5 ⇒ reward = 0.5
• speedup ≥ ref_speedup² ⇒ capped at 1.0

Key point: tying the oracle scores 0; you must "beat the oracle" before you score anything. This curve is a linear transform of the old curve r_v1 = min(1, 0.5·ln(speedup)/ln(ref_speedup)) (tying the oracle gave 0.5):

r_v2 = max(0, 2·r_v1 − 1)

The motivation is discrimination: the old curve packed a large mass of submissions near 0.5 (matching the oracle), leaving only half the range for the thing we actually want to distinguish — whether, and by how much, a submission beats the oracle. The new curve gives the entire [0,1] range to "after you've beaten the oracle."

⚠️ New and old scores are not directly comparable. To convert a historical score, r_v1 = (r_v2 + 1) / 2, and only when r_v2 > 0 (the [0, 0.5] half of v1 is all compressed to 0 in v2 — that information is irreversible). ref_speedup itself is unchanged, so the anchors need no re-calibration.

ref_speedup is a constant calibrated at authoring time, hard-coded into that task's manifest under tests/, read-only at scoring time (never recomputed) — so a task's score is comparable across models and across time. For example, kv-traffic-sol has ref_speedup = 2.5799: a speedup of 2.58 (tie) scores 0, ≈4.14 (ref^1.5) scores 0.5, ≥6.656 (ref²) scores 1.0.

"speedup" is not always a wall-clock speedup — it is the ratio of the task's declared perf_metric, of which there are three kinds:

perf_metric	Meaning	Example tasks
wall-clock / bandwidth speedup	ABBA-paired (baseline/candidate alternating for several pairs, geometric mean over each pair's timed cases), then median across pairs	kv-traffic-sol, varlen-prefill-attn-sol, vllm-scheduler
quality_at_fixed_budget	quality ratio under a fixed budget, e.g. baseline_bpb / candidate_val_bpb	a3-moe-train-budget, a4-token-efficiency-budget
quality_under_budget	retrieval quality ratio under a fixed byte budget, e.g. at 64 B/vector, candidate_nDCG@10 / baseline_nDCG@10	embed-compress-golf (strong baseline nDCG@10 = 0.459151, ref = 1.4290)

ABBA pairing is the key technique in performance measurement: baseline and candidate are measured alternately in pairs, the ratio is taken per pair, then the median across pairs. This way machine noise, warm-up effects, and frequency drift act equally on both sides and are not counted as speedup.

Implementation: binary, any single failure → 0

The 8 implementation tasks have rewards of only 0.0 and 1.0:

reward = 1.0  if and only if  all hidden cases pass  and  no cheat/forbidden-edit gate fires
reward = 0.0  in every other case

The number of cases varies by task, from a dozen to over a hundred hidden cases/gates (the actual count per task is decided by that task's tests/). Per-case pass counts and breakdown diagnostics are still written into reward.json, but the score is never moved out of {0.0, 1.0} — they are for offline analysis only.

Some implementation tasks carry timing measurements, but the timing does not enter the score — it is only a diagnostic, or a precondition gate ("must clear a strong baseline," e.g. requiring the paired-ratio median of several hidden workloads to be > 1.0 and non-degenerate). These tasks are still binary: all gates pass = 1.0, otherwise 0.0 — seeing a speedup field in reward.json does not make it a performance task; go by reward_class / reward_formula.

Zeroing gates (hard fail)

Any of the following, once hit, sets the task reward = 0 regardless of the measurement:

1. Build/import/readiness failure — the submitted code doesn't start
2. Any correctness case fails — the correctness gate for a performance task is all-or-nothing, no partial credit
3. Cheat detected — the frozen surface was tampered with, paired ratios are identically equal (fabricated measurement), or the speedup is physically implausible
4. Touched forbidden_edit_paths — paths listed in task.toml that are sha256-frozen
5. Performance task with speedup ≤ 1 — not beating the strong baseline is no improvement at all
6. ref_speedup missing or ≤ 1 — refuse to score when the anchor is untrustworthy, rather than emit a suspect score

Distinguish "zeroing gate" from "the curve gives 0": 1 < speedup ≤ ref_speedup (beat the strong baseline but didn't exceed the oracle) is not a hard fail — it is the curve itself evaluating to 0, with hard_fail_reasons left empty. The semantics of hard_fail are "this run is invalid / cheating," not "the score is low"; when reading results, reward = 0 with an empty hard_fail_reasons means "ran fine, just didn't beat the oracle."

Anti-cheat is not only these gates: before scoring, each task's tests/test.sh also does a source scan (forbidding references to verifier-internal paths like /tests/, compute_reward, reward.json), forces a rebuild from source when necessary, and does symbol-level checks (ldd/nm to see whether it secretly linked the original library).

Submission budget: decided by two dimensions [subset × task type]

Subset	Performance	Implementation
kfc (55 tasks)	1	1
lh (20 tasks)	1–16	1
e2e (10 tasks)	1–16	1

The entire kfc subset is single-submission, regardless of task type — all 55 have exactly one scoring opportunity, in one of two forms:

• 50 tasks ship the loop harness but with MIN_SUBMISSIONS=MAX_SUBMISSIONS=1: the first bash /opt/loop/submit.sh scores and then finalizes immediately, with no second scored attempt (calling it again just re-finalizes the same recorded snapshot, without scoring new changes)
• 5 tasks (chunked-mlp-recompute, ckpt-dcp-meta-bbox-merge, mamba-zoh-discretize, s4-fft-longconv, wre-verl-grpo-advantage-loop16) have no submit.sh: changes are left in the working tree and scored once by tests/test.sh mounted after the session ends

Only the lh/e2e performance tasks — 26 in total — run the 1–16 round protocol. The cap of 16 is not a hard requirement: the agent decides when to submit.sh --finalize and stop (auto-finalizes at k=16), and need not fill the quota. Implementation tasks are single-submission in every subset.

Each task's budget is declared in three places and must agree: MIN_SUBMISSIONS/MAX_SUBMISSIONS in environment/loop/submit.sh, environment/loop/private/manifest.json, and the [loop] section of task.toml. Any disagreement among the three is a package defect.

loop16 tasks score the "best round," not the last edit

For those 26 tasks running 1–16 rounds, submit.sh --finalize implants the historically best round pointed to by /logs/loop/best.json as the scored artifact. This means:

• if the agent's last edit is worse than something mid-run, it does not affect the score
• per-round measurements are in /logs/loop/state.jsonl, the round count in /logs/loop/count
• if the session is cut off by a timeout, --finalize still implants the best round so far — so a nonzero reward does not prove the session ended cleanly. To judge whether the task was fully answered, look at whether the session ended normally, not at whether reward > 0

A known behavior under the new curve: best.json is updated by strictly increasing dev reward. When a session never beats the oracle at any point, every round's dev reward is 0, so the "best round" stays at round 1 — the best_so_far feedback and the finally-implanted artifact are both the earliest tree, not the one with the highest speedup. This does not affect the score (below oracle throughout, whichever round is implanted the result is 0), but note that the finalized/implanted artifact in that case is that earliest round, not the highest-speedup one. The agent's progress signal is unaffected: each round's feedback still gives dev_speedup, so it sees the improvement from 1.05× → 1.99×, only the reward stays 0.

Aggregating to the bench level

tasks_index.json gives each task's category and medium_topic/big_topic. When comparing models:

• do not directly average performance and implementation classes together — the former is continuous, the latter binary, and mixing lets the implementation 1.0s drown out the differences among performance tasks
• cross-version comparison must confirm both sides use the same reward curve — check reward.json's schema_version (the v2 curve is kernelbench_reward_v3_oracle_relative); scores from different curves are not directly comparable