amildravid4292/olmo3-7b-correctness-contrast-loras

Correctness-contrast LoRAs — Olmo-3-7B

1,972 rank-1 LoRA adapters isolating a causal correctness direction in the weight space of allenai/Olmo-3-1025-7B, together with that direction, every other direction derived from the bank, and the full evaluation record on MATH-500 and AIME 2025.

Each adapter is fit on either the correct or the incorrect solutions to a single math problem. Differencing them cancels the problem and leaves correctness.

Headline. Steering the weights along directions/d_bar_correctness_pc1.npy changes held-out accuracy monotonically: MATH-500 pass@1 runs 0.0285 → 0.3380 → 0.5005 from coefficient −32 to 0 to +8. A KL-matched random direction only destroys (0.0403 / 0.0503 at ±512), so the effect is not "any perturbation of this size."

---

⚠️ The adapters are raw lora_B vectors, not standalone PEFT adapters

Every adapter stores only its lora_B vector. lora_A was frozen for all adapters at one shared random gate A0 — that is what makes different adapters comparable, since every B lives in the same coordinate frame. The induced weight update is

ΔW = 2 · B · A0ᵀ          # rank 1, alpha/r = 2

A0.npz ships with the repo. Verify it: the sum of per-module L2 norms must be 129.38141268491745. load.py checks this on import and refuses to proceed otherwise.

from load import load_A0, load_adapters, correctness_diffs, make_peft_adapter
B, rows = load_adapters()                     # [1972, 1359872] float32, ~10 GB
keys, D = correctness_diffs(B, rows)          # per-problem correct − wrong, unit-norm
make_peft_adapter(D.mean(0), coef=8, out_dir="steer_p8")

---

The bank

base model	allenai/Olmo-3-1025-7B
adapters	1,972 = 493 problems × {correct, wrong} × {split 1, split 2}
dimension	D = 1,359,872 over 224 text-decoder modules
rank / alpha	1 / 2 (scaling 2.0), lora_A frozen at A0, lora_B trained from zero
training	30 epochs × 5 traces = 150 optimizer steps, lr 2e-4, answer-masked loss
KL(base ‖ adapter)	median 0.2736, IQR [0.1718, 0.4561]
problems	MATH train, filtered to those with ≥5 correct and ≥5 wrong committed rollouts

The 2×2 design (class × split) is what makes the contrast interpretable: the split factor gives a matched null for free, since two adapters trained on disjoint halves of the same class differ only by sampling noise.

Adapters are dominated by problem identity, not class. Ranking all 493 split-2 adapters against each problem's split-1 adapter, correct1 → correct2 retrieves the right problem at top-1 0.988 — but correct1 → wrong2 also retrieves it at 0.974, against a 1/493 = 0.002 chance rate. The correctness signal is a small residual on a large per-problem component, which is why the direction only emerges after averaging hundreds of problems.

---

Results

MATH-500, correctness direction (eval/steering_sweeps.json → olmo_correct)

500 held-out problems × 8 rollouts, 2048 max tokens.

coef	pass@1	commit	P(correct | committed)	pass@8
−32	0.0285	0.1240	0.2298	0.1620
−16	0.1192	0.4085	0.2919	0.4300
−8	0.2243	0.6305	0.3557	0.5840
−4	0.2830	0.7117	0.3976	0.6380
0	0.3380	0.7045	0.4798	0.7080
+4	0.4487	0.6350	0.7067	0.7740
+8	0.5005	0.5525	0.9059	0.7560
+16	0.4848	0.5032	0.9632	0.7360

Amplification +16.3 points, ablation −30.9 points. The curve turns over by +16, which is the usual over-steering signature — conditional accuracy keeps climbing (0.9632) while commit collapses.

KL-matched random null (olmo_null)

coef	pass@1	commit
−512	0.0403	0.1620
0	0.3422	0.7170
+512	0.0503	0.3240

A random direction at matched KL destroys in both directions and amplifies in neither. This is the control that separates the correctness axis from generic weight damage.

AIME 2025 (aime25_olmo_pc1)

30 problems × 64 rollouts, 8192 max tokens. Post-dates the MATH corpus.

coef	pass@1	commit	pass@8
0	0.0443	0.6500	0.2228
+4	0.1339	0.4370	0.3394
+8	0.1839	0.2786	0.3336

pass@1 quadruples. The random null reaches 0.0016 at +512.

Underpowered by construction: 19 of 30 problems are never solved in 64 rollouts, so the paired test draws on 11 problems.

Forcing the opening register by prompt (eval/prefill_math500.json)

No weights involved — a fixed string is appended to the prompt so generation must begin with it. 500 problems × 32 rollouts.

8192-token budget (the trustworthy numbers):

prefix	pass@1	commit	P(correct | committed)	truncated	pass@8	paired Δ	p
(none)	0.3526	0.7277	0.4846	0.0897	0.7723	—	—
" Okay, I need to"	0.6583	0.7158	0.9196	0.2391	0.9103	+0.3056	1.5e-69

+30.6 points from five tokens — nearly double the weight direction's +16.3. Commit is unchanged (0.7158 vs 0.7277), so unlike steering this does not buy accuracy by abstaining. And pass@8 moves +13.8 points (0.7723 → 0.9103) against steering's +4.8, making this the one intervention in the whole study that looks like more than a reliability gain.

2048-token budget, where the register's own verbosity is clipped (40% truncation) and the effect is correspondingly smaller:

prefix	tokens (mean/median)	pass@1	commit	truncated	paired Δ	p
(none)	499 / 181	0.3301	0.7055	0.1324	—	—
" Okay, I need to"	1341 / 1468	0.5576	0.5967	0.4014	+0.2275	2.7e-40
" Okay,"	1407 / 1599	0.5581	0.5984	0.4206	+0.2281	4.0e-41
" We can"	328 / 164	0.3202	0.7802	0.0671	−0.0099	0.13
verbose-textbook control	495 / 218	0.3236	0.6870	0.1241	−0.0065	0.22

Two tokens are the whole effect. " Okay," alone matches " Okay, I need to" exactly (0.5581 vs 0.5576) — the bare discourse marker carries it and the goal clause adds nothing. This is the opposite of the same experiment on Qwen3-4B, where goal-specificity was everything (To determine the +11.2 vs the goal-deferring To solve this problem, we need to +0.8). Two models, two registers, two mechanisms.

Textbook-voice prefixes do nothing (" We can" −0.99 points, p = 0.13), so this is not "any prefill helps."

Known gap — the length control failed. " Okay," triples output length (median 181 → 1599), so "it just reasons longer" is a live alternative. The control arm was meant to force long output in the textbook voice, but it produced 495 mean tokens against base's 499 — it never induced the length it was supposed to, so it does not test the hypothesis. The indirect evidence is that at 8192 the unprefixed model has ample room and still has a median of 182 tokens — it does not choose to reason long — while the prefixed model sits at 1462. A proper control still needs building.

Why that register

From the 9,860 graded bank traces, paired within problem:

opener	P(w | correct)	P(w | wrong)	paired Δ	p
Okay	0.140	0.005	+0.5358	2.7e-68
To	0.055	0.047	+0.0258	0.57
We	0.154	0.186	−0.0753	1.3e-05
First	0.111	0.141	−0.0893	1.3e-04
The	0.254	0.296	−0.0584	0.011

Olmo's correct register is first-person deliberative ("Okay, I need to…", "let's see"), not Qwen's assistant-markdown voice; opens To, Qwen's single best marker, is null here (p = 0.57). Register strata, unsteered:

register	share	pass@1	commit	P(correct | committed)
deliberative	6.4%	0.4147	0.4631	0.8956
textbook	84.8%	0.3462	0.7636	0.4535

Note the observational association is far too large to be proportionately causal: at Olmo's base rate those conditionals imply an acc|Okay of ~0.93 and a ceiling of +60 points, which no intervention approaches.

Mediation

Splitting each generation at token 32 and steering the halves with different coefficients: steering only the first 32 tokens gives mediated fraction m = 1.215 — more than steering throughout. Ablation is distributed instead, ~80% carried by the continuation. Amplification lives in the opening; ablation does not.

---

Other experiments in this repo

family	eval dir	what it tested	outcome
topic directions	cross_*	7 per-capability directions, balanced k×k cross	base 0.3680, null 0.0545
combo direction	xc_combo48, aime25_combo72	pooled multi-direction steering	MATH 0.5728 @48; AIME 0.1135 @72
ensembles	ens_m*	8 independent direction estimates	see directions/
gate / g3	gate_m*, g3_m*	shared-gate sensitivity	—
mixtures	xm_*	mixture directions B/C/D at two coefficients	—
wobble	xw_wob*	perturbation stability of the axis	—
recipe sweep	loras_mini_e{3,6,12,30}	epochs → KL calibration	30 epochs → median KL 0.27
behaviour axes	directions/wp_*.npy	12 within-problem behaviour directions	deliberation axis: split-half 0.757, cos 0.955 with correctness
split spectrum	directions/split_axes_olmo.npy	unsupervised axes from split variation	—

Raw per-problem counts for every steering arm are in eval/steering_sweeps.json; the underlying shards record n_correct, n_committed, and n_truncated per problem per coefficient.

---

Files

A0.npz                      frozen shared gate, 224 modules (checksum 129.38141268491745)
load.py                     loader, direction builder, PEFT materialiser; `python load.py` self-tests
grader.py                   the exact answer grader used for every number above
adapters/
  B_shard_00..07.npy        [~247, 1359872] float32 each
  meta_shard_00..07.json    per-row problem_key, cls, split, KL, B_norm, loss
  index.json                flat row index over all 1,972 adapters
directions/                 31 unit-norm vectors of length 1,359,872
  d_bar_correctness_pc1.npy     the headline direction
  d_bar_correctness_diffmean.npy, d_bar_correctness_lora.npy   alternative estimators
  d_bar_random_null.npy         KL-matched random control
  wp_*.npy (12)                 within-problem behaviour axes
  topic_*.npy (7), grp_*.npy (4), level.npy
  split_axes_olmo.npy, olmo_pca_basis.npy
problems/                   problems_usable_olmo.jsonl (493 bank) + math500 + aime2025
traces/
  traces_2x2_olmo.jsonl         the 9,860 graded traces the adapters were trained on
  unsteered_pool/               54,900 unsteered MATH-train rollouts -- the pool the 2x2 was
                                selected from, i.e. the model's untouched behaviour
  prefill/                      112,000 CAUSALLY FORCED rollouts, full text, 7 arms x 500
                                MATH-500 problems x 32. The forced string is stitched back onto
                                `solution`, so each row is the complete generation.
    ol_base.jsonl               no prefix, 2048            ol_base8k.jsonl   no prefix, 8192
    ol_okay.jsonl               " Okay, I need to", 2048   ol_okay8k.jsonl   " Okay, I need to", 8192
    ol_okay2.jsonl              " Okay,", 2048
    ol_wecan.jsonl              " We can", 2048
    ol_ctrl.jsonl               verbose-textbook control, 2048
eval/steering_sweeps.json       every steering arm, per coefficient
eval/prefill_math500.json       the prompt-prefix arms

Reproducing the evaluations

Non-obvious requirements, all load-bearing:

• Prompt is plain text, not a chat template: Problem: {q}\nPlease reason step by step, and put your final answer within \boxed{}.\nSolution: — Olmo has no chat template and falls into a thinking-out-loud voice rather than an assistant voice.
• Stop strings ["\nProblem:", "\nProblem :"]. Without them a base model finishes and then hallucinates a fresh Problem: block; the grader takes the last \boxed{} and silently grades against the wrong answer.
• vLLM needs the YaRN override or Olmo-3 dies on KeyError: 'rope_theta':

  {"rope_parameters": {"rope_type": "yarn", "attention_factor": 1.2079441541679836,
   "beta_fast": 32, "beta_slow": 1, "factor": 8.0,
   "original_max_position_embeddings": 8192, "rope_theta": 500000}}
  

• Sampling: temperature 0.6, top_p 0.95. pass@k is the unbiased Chen et al. estimator, not "did any of the first k succeed."
• Report pass@1 = commit × P(correct | committed). An over-steered model that stops answering looks identical to one that reasons badly unless the two channels are separated.