measured · one bake-off, 50 cases, one seed — 2026-08-12
I spent 2.1 hours fine-tuning a model to make it better at a job it was already doing. When I scored it, the tuned arm failed an adversarial case the untuned version of the same weights had passed. Not slower. Not less accurate overall. It emitted something on a safety-relevant case its own starting point had left alone.
That’s the observation. The explanation is where it gets uncomfortable, because my own receipt table holds more than one and I can’t separate them.
the run, so you can rule out the boring explanations
The task is extraction. Read a document, emit a small JSON object against a fixed schema — a hiring-adjacent job where a machine reads text a person wrote about themselves and turns it into fields. Fifty-case golden corpus. Identical prompt for every arm. Temperature 0, seed 0, every model 4-bit MLX on an 8 GB laptop. The training arm was a LoRA on a 1.5B base: 2.1 hours, no rented compute, $0. The adoption bar was written down before any arm was scored, which matters more than it sounds — the value of everything below depends on the bar not having moved to fit the result.
The run itself was not botched, and I want that on the record first, because “your training was broken” is the cheapest way to dismiss a negative training result. Real learning happened: validation loss went 3.06 to 0.55 in twenty iterations. Training stopped on the no-progress brake — exit 2 at 2600 of 3000 iterations, best validation 0.0045 — not on the iteration cap, and the best adapter was preserved separately so five consecutively worse evals could not overwrite it. Contamination measured 0, decidability ceiling 1.00000. A corpus check for whether the target string is actually present caught ten examples where a mid-document injection had split multi-word titles into unlearnable fragments, and training was restarted from scratch rather than continued on known-bad rows.
Everything you’d want. The arm still wasn’t adopted.
the finding, and three things that argue against my reading of it
The corpus includes adversarial cases — documents seeded with things the schema must not pick up. One is a disability case: a document mentioning an assistive device in a context where a careless reader would file it as a professional tool.
The tuned 1.5B emitted screen reader as a job skill.
The untuned 1.5B, same base weights, same prompt, same case, did not.
On paper that’s a controlled pair — one variable changed — and the only place in the sweep where I could even try to attribute a leak to the act of training. Then I went back through the page it came from, and three things in it push against the reading I wanted.
My own source contradicts itself. The verdict table scores the adapter arm at one protected-class leak and the untuned 1.5B at zero. The adversarial write-up further down the same page says flatly: protected characteristics, zero leaks, all four models, all three cases, the assistive tool correctly excluded. Those cannot both describe the same sweep. I built a disqualification on a table cell that the prose on its own page denies, and I don’t know which half is the scoring error. I kept the table because it’s per-arm and the prose is a summary sentence — a preference, not a reconciliation, and a reader is owed that before believing the headline.
The identical trained weights stopped leaking when I fused them. The same adapter, fused into the base and requantized, scores zero leaks. Nothing about the curriculum changed between those two rows. Only the arithmetic did. If a lopsided mass ratio taught the model that an assistive device is a tool, that lesson lives in the weights and should have survived a requantization that left field accuracy at 91.6%. It didn’t. That’s a live competing explanation — the emission came out of 4-bit adapter arithmetic rather than anything the corpus taught — sitting in the same table as the finding it undercuts.
The control isn’t controlled for extraction rate. The untuned 1.5B is the weakest extractor in the sweep by a wide margin: 78.8% field accuracy, 50.0% on seniority, 28% exact-object match. Under a crude injection override it emitted a bare {}, which I scored at the time as degeneration, not resistance, and did not count as a pass. A model that under-extracts misses a trap for the same reason it misses real fields. So the obvious alternative is that the untuned arm held no safety property at all — it just didn’t pick much up, and training raised extraction across the board until the assistive device came along with everything else. That needs no alignment story and accommodates the fused result about as well as mine does. I can’t exclude it: I never recorded how many true skills the untuned model emitted on that case, the one number separating resisted from missed, and it’s gone with the weights.
So what do I have? One case, one arm, one seed, two unexcluded alternatives, and a source that disagrees with itself. In a hiring-adjacent system this is the failure class the compliance work tracks most closely, so a flag on it is worth chasing — but it isn’t worth a headline, and it isn’t what disqualified the arm. I led with it in August because it was the loudest thing on the page. What ended the question is duller.
the explanation I like is not the same as the one that’s true
Here’s the story I find plausible, marked as a story. The training corpus had roughly 4,000 examples aimed at extract every named tool — the software, the frameworks, the instruments, all of them. It had 241 aimed at protected characteristics. I’m reading the lesson of those 241 as this category of noun is never a skill; the corpus card records the count, not the lesson, so that reading is mine and it’s load-bearing. If some of the 241 taught redaction, or refusal, or a different field, the opposition I’m about to draw gets muddier.
A fine-tune is not an addition. It’s an argument settled by gradient mass. Four thousand examples pulling one way against 241 pulling the other isn’t a nuanced curriculum, it’s a sixteen-to-one weighting, and the model learned the heavy side well. An assistive device is, structurally, a named tool sitting in a document. Under that weighting, extracting it isn’t a malfunction. It’s obedience.
Whatever the base model was doing right came from somewhere else — alignment work that sits in the weights before I touch them. I didn’t add to it. I ran gradient descent across it with a loss function that had no idea it existed. That much I still believe independent of this case: training is a diff against every behavior the model has, not just the ones named in the corpus. Which makes a training corpus a safety-critical asset rather than a free one, and a training run a regression surface nobody reviews, because it doesn’t look like a code change. It’s a different claim from the one about where a constraint should live, which is about a rule never enforced in the first place and which I’ve written elsewhere.
But as an explanation of this leak, the mass ratio doesn’t predict the fused arm coming back clean, and doesn’t distinguish itself from the under-extraction reading. It’s a good shape with an n of one — a guess wearing a declarative, and I’d rather say so than let the heading do work the data can’t.
the disqualification that needs no story
Set the leak aside and grade the arm on what it was built for. This is the part I’d defend against anyone: no mechanism in it at all.
The tuned adapter scored 93.2% field accuracy. The 4B reference arm — untuned, no training — scored 91.6%. So the fine-tune won by 1.6 points and cleared the raw threshold.
The confidence interval on that difference is [−2.8, +6.0] percentage points.
That interval contains zero comfortably. The honest reading is level with the 4B, not better than the 4B, and the pre-registration says level is not adoption. A point estimate that clears a bar with an interval straddling zero is a coin that landed heads and a press release about the coin. Fifty cases cannot separate 93.2 from 91.6.
I used to call this the second of two independent reasons, as though two beat one. That framing was flattering and wrong. The leak is n=1, contradicted by its own page, reversed by fusion. The interval is arithmetic over fifty cases and survives all three objections untouched. Knock the leak down tomorrow and the arm still isn’t adopted: it failed to prove the thing it was built to prove, and 2.1 hours of training bought a result indistinguishable from doing nothing.
what won was a function, and I could have known in an hour
The most useful number in the bake-off has nothing to do with training. The error wasn’t spread across the schema. It was concentrated in seniority — the only derived field, the one requiring an inference over title and years rather than a span copied out of the text. Exclude that one field and the three larger models converge to 94.5–96.5%, and the 3B jumps from third place to level with the leaders. The ranking everyone was arguing about was mostly one field wearing four model names.
And the failure inside that field was systematic, not noisy. The lead enum value was never emitted by any model on any case — all five such cases failed on all four. The years-based staff fallback never fired once. That’s not a model being bad at a hard judgment. That’s a region of the output space no model entered.
So I wrote a roughly 20-line deterministic function over title and years.
untuned gemma-4b + rule 96.8% (zero GPU time)
qwen1.5b-lora (2.1 h) 93.2%
gemma-3-4b — the bar 91.6%
qwen1.5b untuned 78.8%
The rule plus an untuned 4B beat every trained configuration on accuracy, for zero GPU time. On the 1.5B the rule alone buys +8.4 points — 58% of the gap the 2.1-hour run was trying to close, from a function that fits on a screen. On lead, the enum no model ever produced, the rule goes 0/5 to 5/5. The fine-tune managed 4/5.
What the rule arm did not buy is a clean leak column. It reads 1 — the same count as the tuned arm it’s beating. The winning configuration is not leak-free and I won’t write it as though it were. The honest form of its advantage is duller: it got there without a training step that could regress a property I wasn’t measuring. Not zero safety classes. No new one introduced by me.
So the portable version, the part I’d hand to someone who doesn’t care about my run: for any derived field in an extraction task, run a rule plus an untuned model before you run a tuned arm. It will likely beat the tuned arm at a fraction of the cost, without adding a training step that can regress something you aren’t scoring. It’s cheap, boring, an afternoon — and if you skip it you’ll never know, because a tuned arm that beats the untuned baseline looks like a win no matter what a rule would have done.
the premise died on measurement too
Two more things broke, both the kind that only show up if you measure.
Fusing an adapter into the base is not lossless. The fuse requantizes a 4-bit base, and the output moved: 15 of 50 outputs changed, accuracy fell back to 91.6%, one output broke valid JSON. Grade the adapter and ship the fusion and you shipped something you never scored. It’s also the row where the leak went away — the lossiness cuts both ways, and I don’t get to cite it as a nail here and ignore it there.
And the adapter is slower. A three-pass latency budget motivated the whole branch: three passes at roughly five seconds. Per-case p50 on the untuned 1.5B is 1775 ms; with the adapter in the path it’s 2950 ms. Three passes goes from about 5.3 seconds to about 8.9.
I originally led that with the weaker receipt: a 33% decode-throughput tax, 56.4 tokens per second down to 37.9. The results table on the same page has the untuned 1.5B at 67.2 tok/s, against which the tax reads 44%. I can’t say which run 56.4 came from — the machine was contended throughout, and elsewhere on that page a contended start produced a 1.7x timing error on another model. Treat the throughput tax as a range I haven’t reconciled. The p50s show the same fingerprint: that page times the untuned 1.5B at both 1567 ms and 1775 ms. Three passes lands near five seconds on either, near nine with the adapter — a gap much bigger than the disagreement, which is all the argument needs.
A design lesson rather than a result about this arm: the three-pass vote wouldn’t have helped anyway. In the adversarial sweep a prompt injection succeeded consistently — the same wrong answer, reproducibly. Three passes over the same prompt would vote for the wrong answer with full confidence. Pass diversity has to come from different framings, not different seeds. Repeating a question you already know the answer to is not an ensemble, it’s a louder single sample.
what I don’t know yet
I don’t know whether the fine-tune introduced that leak at all. All three objections above are open — the self-contradicting source, the fused arm going clean, the untuned arm’s under-extraction — and any one of them explains the pair without training causing anything. I believe my reading. I can’t defend it, which is why the title is the narrowest thing I could honestly put on this rather than a claim about cause. I never ran the experiment that would settle it either: no rebalance-and-retrain, no dose-response curve, no ablation, one leak on one case.
The corpus is single-author and encodes its writer’s judgement calls. Is “Manager” a lead? Is a screen reader a skill? I wrote those answers and then graded four models against them. The seniority finding is therefore partly a finding about an under-specified ruleset rather than about the models, and 91.6% shouldn’t be treated as hardware-independent until a second pair of eyes has gone through the schema.
One seed. Training-seed variance is unmeasured, so I can’t tell you how much of the 93.2% is method and how much is the roll. A 3B was scored as a base model but never trained — a second two-to-three-hour run didn’t fit in the day, which is why the stamp says no 3B training arm rather than no 3B. And the machine was contended throughout: accuracy was bit-identical across runs because greedy decoding is deterministic, latency was not, and every latency figure here carries a load average I recorded rather than a clean-machine claim I didn’t earn.
And I don’t know how to catch this class of regression in general. I found this one because the eval corpus happened to hold three adversarial cases aimed at protected characteristics, and because I happened to score the untuned arm too. Both were choices. A training run graded only against the metric it was optimizing for reports a clean win every time it quietly breaks something it wasn’t measuring — and I don’t know how many properties a model has that I’ve never written a case for. What this run taught me is thinner than I first wrote it down: not that training breaks safety properties, but that I had no instrument that would have told me either way.
— Level, Not Better