rtx-5090-benchmarks

Rig: one RTX 5090 32GB (sm_120) · Qwen2.5-Math-7B · greedy pass@1 · the authors' Qwen2.5-Math grader, reused verbatim Claim under test: One-Shot EM (arXiv 2505.20282) — minimize the model's output entropy on one unlabeled example for ~10 steps, reported +24.7 avg on Qwen2.5-Math-7B (MATH500 53.0→78.8, AMC23 44.1→70.3, greedy pass@1). What I could actually run: the paper's recipe is full-parameter bf16 with optimizer offload, trained on multiple GPUs. On 32GB that OOMs (weights 14GB + bf16 grads 14GB + activations > 32GB, measured), so the only consumer-feasible version is LoRA (r=16, 40M trainable params, 0.53%), batch 16, 15 steps. That is a real deviation — read the caveats before quoting this.

The numbers (Qwen2.5-Math-7B, RTX 5090)

	MATH500	AMC23
base, paper protocol (ours)	53.4	45.0
base, fair protocol (max-tokens 4096)	54.6	45.0
EM @ step 10 (ours)	55.4	42.5
EM @ step 15 (ours)	53.0	42.5
EM (paper's claim)	78.8	70.3

Two things happened, and the gap between them is the whole report.

Finding 1 — the base reproduces, the gain does not

Our base lands at 53.4 on MATH500 against the paper's reported 53.0 — the harness, the qwen25-math-cot template, and the vendored sympy grader all agree with the paper to within a point. So the baseline is honest (raising max-tokens to 4096 moves it +1.2, not the +12 a truncation artifact would need).

Then one-shot EM adds +2.0 on MATH500 at its best step and −2.5 on AMC23 — against a claimed +25.8 and +26.2. By step 15 MATH500 has fallen back to the base (53.0): the peak-then-collapse the paper itself describes. The +24.7 headline does not survive on a single consumer card.

Finding 2 — the entropy fell exactly as designed; the accuracy ignored it

This is the part worth keeping. The training worked: mean per-token entropy on the pi1 rollouts dropped 0.098 → 0.035 over 15 steps, steepest in the last five. The model became measurably more confident. Accuracy did not follow it up — +2.0 at most, then down. Output length and repetition barely moved at the peak (MATH500: 1191→1195 tokens, repetition 0.332→0.338), so this isn't a generation-degeneracy story at step 10; it's simply that sharpening a distribution is not the same as making it more correct. The paper says as much about its own method — "a distribution-shaping tool rather than a learning method" — and on this hardware that is all we measured it to be. It sits in the same place as the Spurious Rewards result for this exact base model (Qwen2.5-Math-7B gains ~+21 on MATH500 from random rewards): the signal is doing less than the headline implies.

Caveats (these matter more than usual here)

This is not a refutation of the paper's full-param result. The full-parameter recipe needs more than 32GB and did not run; LoRA + batch 16 is a weaker training setup and could be why the gain is absent. The honest claim is narrow: on a 32GB consumer GPU, the recipe that fits does not reproduce +24.7, and the entropy objective trained fine while accuracy stayed flat.
The format-elicitation control backfired and is inconclusive. A 2-shot scaffold meant to isolate "the model already knows the format" instead degraded Qwen2.5-Math (MATH500 14.2, repetition 0.52) — the model's strength is its native zero-shot CoT, and few-shot examples disrupt it. So I can't cleanly separate format-elicitation from capability here; I'm reporting the raw result rather than a clean three-way split.
AMC23 is 40 problems — high variance; the −2.5 is two questions. MATH500 (500q) is the number to weight.
Greedy pass@1, single seed, the authors' grader. Base-reproduction (53.4 vs 53.0) is the evidence the pipeline is sound.

Worth it if / not if

Not a free consumer win. If you have one 32GB card, there is no one-example +24.7 waiting for you: the full-param recipe doesn't fit, and the LoRA version that does fit moves MATH500 by +2 then gives it back.
The mechanism is the takeaway. Entropy minimization reliably makes a math model more confident; on this hardware it did not make it more correct. Treat "unsupervised, one example, huge gain" claims on Qwen-Math bases as elicitation-shaped until a controlled run on a non-Qwen-Math base (the real falsification) says otherwise — that is the follow-up worth doing.

Repro

EM loss + collapse metrics + prompt builders (dep-free, tested): lib/em.py. Vendored Qwen2.5-Math grader (the math_equal oracle, not reimplemented): lib/qwen_math_grader/. Data: scripts/fetch_em_data.py → dataset/em/{math500,amc23,pi1}.jsonl (from the one-shot-em repo).
Train: scripts/train_em.py (batched rollouts → entropy backward; --lora for the 32GB memory gate). Eval: scripts/eval_math.py (vLLM greedy gen — set VLLM_USE_FLASHINFER_SAMPLER=0 on sm_120) + scripts/grade_em.py (grader-env). Chart: scripts/chart_em.py.
Grader-env note: the PyPI latex2sympy2 is broken on modern Python; install the repo's vendored latex2sympy (1.9.0) pinned to antlr4-python3-runtime==4.11.1 + sympy==1.12.