It Sees the Damage, Not the Repair

Ongoing research. This is an experimental result from active work, not a settled conclusion. The numbers are what we measured and the method is described so you can judge it, but the programme is still running and later experiments may revise what it means.

A note on the language in these records. This is a working laboratory notebook for research into training AI models more cheaply and efficiently, so you will read that an approach did not work, that a result did not hold up, or that one method was worse than another. That is the research doing its job, not a verdict on the engineering we deliver to clients. Ruling an approach out is how the search narrows, and these are the pages that teach us the most: nearly every technique we now rely on came from understanding why something else fell short. Testing our own ideas at least as hard as anyone else's is the point of publishing them. More about this programme and why we run it.

Part of a bigger question: How much model does a task need, and what changes when it has more? – The abrupt jump is what spare capacity buys -- it fades smoothly as the model shrinks, long before the model stops working. Capacity and task difficulty act separately, not as a ratio.

In plain English

What we asked. To run an AI model on smaller hardware, its numbers are usually rounded to fewer digits, which saves memory and costs some accuracy. A tool released this week makes it easy to look inside rounded models. We used that idea on small models to ask two things: does measuring the internal shape of a model tell you how badly rounding has hurt it, better than simply measuring how much its numbers changed? And when a damaged model is repaired with a little extra training, does its internal shape come back?

What we found. Rounding down to about 4 digits' worth of precision did almost no harm; below that the models broke quickly. Among models rounded the same amount, the internal-shape measurement picked out which ones were hurt most somewhat better than the change in their numbers did. (A follow-up with four times as many models found that edge smaller and not certain; see the note at the top of the record.) The damage was spread evenly across the model, not concentrated in its least important parts, which is what we had predicted. Then the repair: a small add-on trained on top of the rounded model won back all of the lost accuracy, but the internal shape stayed different. The model did the same job a different way.

Why it matters. The lesson: looking inside a model can tell you it was damaged, and it needs no answer key to do so, which is useful for a model already in use. But it cannot tell you whether a repaired model is fixed, because working again does not mean looking the same inside. To know whether a model works, test what it does.

The rest of this page is the technical record: the design, every number, and the limits. It is written for a reviewer, and you do not need it to have understood the result above.

New here? How to read a research record

• Start at the verdict. Every record states, before the experiment was run, what result would have made us abandon the idea. That is the "kill test". Then it says whether the test fired. Nothing gets reinterpreted after the fact.
• Numbers in square brackets are uncertainty. 23.4 [18.1, 28.7] means our best estimate is 23.4 and the true value is probably somewhere in that range. If a range includes zero, we cannot claim an effect.
• Results that rule an idea out are kept. Roughly half of what is published here says an approach did not work, including plenty of our own. Those pages are the output, not a shortfall: knowing which direction is a dead end is what lets the next experiment go somewhere better, and most of what we now rely on came out of understanding why something else fell short. Work that only publishes what worked is not measuring anything.
• Read the Limits section. Every record ends with what it does not show. It is the most honest part of any experiment and usually the shortest.
• Pro tip: the figures near the top are designed to carry the result on their own. If you read nothing else, read the caption under each one, which says what it shows and what to take from it.

EXPLORATORY. Not a preregistered study. Local CPU, twelve models, about five minutes. The design, kill test and prediction were committed (7a56fcc) before any measured run. No calibration run was needed for this one.

Program v2 Bucket S, item S5. Decisive computation: analysis/quantisation_geometry.py. Output: analysis/quantisation_geometry.json. Reproduce with python analysis/quantisation_geometry.py; --reuse re-derives every endpoint from the saved measurements.

QUALIFIED 2026-09-26 by S12. The kill-test result below does not survive four times the models. On forty-eight models (S5's twelve reproduced exactly, plus thirty-six), CKA on the readout input still ranks 3-bit damage better than weight error, but by +0.160 [-0.196, +0.521] rather than the 0.481-against-0.154 headline: weight error's correlation was +0.07 on twelve models and is +0.28 on forty-eight, so most of the gap was the weaker measure's small-sample noise. The direction stands; "three times better" does not. The repair finding -- accuracy restored without the geometry -- is a comparison of means and is unaffected.

The question

Transformers can now run llama.cpp's GGUF quantised checkpoints directly while keeping PyTorch hooks on the activations (Hugging Face, 2026-09-22). The maintainer's report asked what that makes possible: not only how much accuracy quantisation costs, but which representational degrees of freedom it destroys, and which survive adaptation.

Underneath that is the report's synthesis, which this programme is in a position to test: that "representation geometry may be a diagnostic of available learning capacity rather than a target to optimize". Program v1 closed the target half -- reshaping a model's internal coordinates is free and does nothing for learning. S1 found the first evidence for the diagnostic half: the old skill's measured dimensionality predicted where null-basis adaptation would run out of room. Quantisation is the cleanest place to test it head-on, because the damage is real, graded, and costs nothing to produce.

The real-model version is S7, blocked on a maintainer decision: the optimised GGUF path is Apple-Silicon and Qwen only, and anything else means a multi-gigabyte download run dequantised.

Kill test, fixed before execution: within each bit width, across twelve models, CKA to full precision does not rank accuracy loss better than plain relative weight error does -- mean within-bit Spearman magnitude, over the bit widths where accuracy moves (mean loss at least 0.01). Across bit widths both are monotone in bits and agree trivially, which is why the test is within.

Prediction, fixed before execution: damage concentrates in the low-variance directions; the leading principal directions survive down to 4 bits.

Prior recorded in advance: low on the kill test. Weight error is a strong, cheap baseline.

Design

Twelve width-48 GRUs on the house task (delayed copy, lag 4, 400 steps), trained by P1's committed loop so they are the archive's own models; every one reaches at least 0.976. Every weight matrix -- embedding, input-to-hidden, hidden-to-hidden, readout -- is quantised by blockwise symmetric round-to-nearest, blocks of up to 32 along the input dimension, the shape of GGUF's Q*_0 formats, at 8, 6, 5, 4, 3, 2 bits. Biases and norms stay full precision, as GGUF keeps them.

The representation measured is the normalised hidden state the readout reads, at every scored position of a fixed held-out batch. Per full-precision principal direction, the correlation between the full-precision and quantised projections says how well that direction survived.

Repair, QLoRA-style, at 4, 3 and 2 bits: the quantised model frozen, rank-8 full-precision adapters on the three recurrent-path matrices, trained 200 steps on the task.

What quantisation costs

Bits	Accuracy lost	Weight error	CKA to full precision	Stable rank	Participation
8	-0.0001	0.005	0.9999	0.999	1.000
6	0.0006	0.021	0.998	0.999	1.000
5	0.0037	0.043	0.992	0.994	1.000
4	0.014	0.092	0.962	0.991	0.996
3	0.119	0.216	0.816	0.928	0.978
2	0.779	0.630	0.300	0.788	0.872

(Stable rank and participation are ratios to the full-precision model.) Down to 5 bits nothing happens; 4 costs a point and a half; 3 costs twelve; 2 destroys the model. The representation also narrows as bits fall -- a fifth of the stable rank is gone at 2 bits -- so quantisation damage is partly a loss of dimensions, not only noise on them.

Result: the kill test does not fire, and it is weaker than it sounds

Within each bit width where accuracy moves, rank correlation with accuracy lost across the twelve models:

Bits	Geometry (1 - CKA)	Weight error
4	-0.288	-0.267
3	+0.399	+0.070
2	+0.755	+0.126
mean magnitude	0.481	0.154

Geometry ranks the damage three times better than weight error, and the kill test as fixed does not fire. Three things keep this from being the clean positive the table suggests:

• Only the 2-bit correlation is individually convincing. With twelve models, a rank correlation needs about 0.58 to be distinguishable from zero at the usual level. 3 bits is suggestive, 4 bits is noise -- and at 4 bits both correlations have the wrong sign, which the preregistered magnitude average counts as evidence for both. Weight error is flat at every width, which is the more robust finding: how much a model's weights moved says almost nothing about which model was hurt most.
• The representation measured is one linear map from the output. CKA on the readout's input is close to measuring the output's disagreement directly; a diagnostic that sits that close to the outcome is less a diagnostic than an early reading of it.
• It is not cheaper than measuring the damage. CKA needs the same forward passes on a data batch that accuracy does. Its only advantage is that it needs no labels -- a real advantage for a deployed model, and the one worth pursuing.

Result: the prediction half-holds

The leading directions survive to 4 bits (0.981), as predicted. The damage does not concentrate in the low-variance directions:

Bits	Top 5 directions	Ranks 6-10	Ranks 11-20
4	0.981	0.978	0.980
3	0.902	0.890	0.902
2	0.445	0.420	0.497

Quantisation damage is spread evenly across the directions the model uses, at every width. The coded check reports HOLDS, because it tests "tail below top" and 0.980 is below 0.981 -- a margin of 0.001 inside noise. This record reads the second half of the prediction as failed, and the code's verdict as an example of this programme's rule that a comparison inside one interval is decided by the code, not the data.

The repair restores the function and not the geometry

After 200 steps of QLoRA-style repair on the frozen quantised model:

Bits	Accuracy lost, quantised	after repair	CKA, quantised	after repair
4	0.014	-0.007	0.962	0.949
3	0.119	-0.002	0.816	0.904
2	0.779	0.112	0.300	0.616

At 4 and 3 bits the repair recovers all of the lost accuracy, and the representation does not come back. At 4 bits it moves further from the original (0.962 to 0.949) while accuracy rises past it. At 3 bits it recovers only half the geometric distance while recovering all of the accuracy. The repaired model does the same job through a different representation. (The small gains past full precision are because the repair is also 200 more steps of training; the full-precision models stopped at 400.)

That is program v1's closed result arriving from the other direction. v1 found that reshaping a model's coordinates changes nothing about its function. Here, restoring the function changes little about the coordinates. Geometry follows the damage and does not follow the repair, so as a diagnostic it can say a quantised model has been hurt, and cannot say whether a repaired one is fixed.

What stands

• The kill test does not fire as fixed: within a bit width, CKA to full precision ranks accuracy loss better than weight error (mean |rho| 0.481 against 0.154). The evidence is carried by 2 and 3 bits; at 4 bits both are noise. Weight error ranks nothing at any width.
• The prediction half-holds: the leading directions survive to 4 bits; damage does not concentrate in low-variance directions -- it is spread evenly.
• A repair restores function without restoring geometry. After QLoRA-style adaptation, 3- and 4-bit models match full-precision accuracy at CKA 0.90-0.95.
• For the report's synthesis: S1 and S5 together say geometry is a usable diagnostic of damage and of room -- it told S1 where adaptation would run out, and it ranks quantisation damage without labels -- and not a diagnostic of function, because function can be restored somewhere else. That is a narrower claim than the report's, and a testable one. It is enough to keep S6 open and not enough to promote it.

Limits

• Tiny recurrent models, one task, twelve seeds. The within-bit correlations are underpowered by design at twelve models; a stronger test needs more models per width, which is cheap here, or S7.
• Quantisation is uniform round-to-nearest. Real GGUF K-quant formats use importance-weighted scales and mixed precision by layer, which could change both how much damage and where. S7 is the test on those.
• The representation measured is the readout's input. A layer further from the output might be a more independent diagnostic, and a weaker one.
• The repaired models trained longer than the full-precision reference. The geometric distance after repair is therefore partly ordinary continued training moving the representation, which is itself part of the point: a model can keep its function while its geometry drifts.

Terms on this page

Every piece of vocabulary this record uses, in plain language. Generated from the text above, so it cannot drift out of step with it.

accuracy

The fraction of answers a model gets right on questions it was not trained on.

adapter

A small set of extra weights attached to a trained model and trained on a new task while the original weights stay fixed.

baseline

The thing you compare against. A result without one is not a result.

calibration

Working out an instrument's settings from runs whose answer you already know, so it can be used on a run whose answer you do not.

checkpoint

A saved copy of a model partway through training, so you can come back and inspect what it looked like at that moment.

CKA

Centred kernel alignment: a score from 0 to 1 for how similar two sets of internal model activity are, where 1 means the same up to rotation and scale.

GRU

Gated Recurrent Unit. A compact design for processing sequences one item at a time, with internal switches controlling what it keeps in memory.

held-out

Data the model was never trained on, kept back specifically to test it. Scoring a model on data it has already seen measures memorisation, not learning.

hidden state

The model's working memory: the internal numbers it carries from one step of a sequence to the next.

kill test

A condition written down before running the experiment that says what result would make us abandon the idea. Fixing it in advance is what stops a disappointing result being reinterpreted as an encouraging one.

null basis

The directions inside a layer that a particular skill does not use. A change made only along them cannot disturb that skill's calculation at that layer.

quantisation

Rounding a model's numbers to fewer bits so it takes less memory and runs on smaller hardware, at some cost in accuracy. Spelled quantization in US usage.

rank

How many independent directions a set of numbers really uses. A low-rank structure is one that looks high-dimensional but is actually simple underneath.

recurrent

A design that reads a sequence one item at a time, carrying memory forward. The main alternative is attention, which looks at everything at once.

seed

The number that fixes all the randomness in a training run. Same seed, same run. Running several seeds is how you tell a real effect from a lucky one.

stable rank

A way of counting how many directions a set of numbers meaningfully uses that does not depend on the overall scale.

transformer

The architecture behind most modern large language models. It uses attention to look at every part of the input at once, rather than reading in order.

variance

How spread out a set of numbers is. Rising variance in a signal means it is becoming more erratic.

width

How many internal numbers a model uses at each layer. The usual way we vary model size in these experiments.

---

Get new results as we publish them

Roughly monthly, one finding per email, in plain English first. Including the approaches that turned out not to work, which are usually the useful ones. No sales email.

Leave this empty Email address Subscribe

Double opt-in: we send a confirmation link and add nobody who does not click it. One-click unsubscribe on every email.