Choosing Readout Heads That Extrapolate on Frozen Features

Large pre-trained encoders often already know how many things they are looking at, even when the system built on top of them cannot say the number. When a vision-language model is shown 75 stones after being trained to name visual counts only up to 49, it outputs 0% correct answers. Yet a simple linear readout on its frozen image features recovers the count almost perfectly. This proposal argues that, in pipelines that keep the backbone frozen and train only a small head on its output vectors, much of the failure to extrapolate to larger numbers comes from the head and from how the head is chosen. Standard practice tunes heads on held-out data drawn from the training range. That rewards heads that fit the range smoothly, including heads that rely on cues which stop tracking magnitude just past the training boundary. We propose a cheap way to choose heads by how well they extrapolate rather than how well they interpolate. Each candidate head is trained on the lower part of the labeled range and scored on its top slice, and a training-free geometric score is added on top.

The practical point is that searching over heads is nearly free: thousands of candidates cost less than one fine-tuning run of the backbone. If the selection signal reliably predicts true out-of-range accuracy, numerical extrapolation on frozen features becomes a model-selection problem that can be solved on a laptop. That would remove the need for a new architecture or a 120-billion-parameter in-context learner.

Core Claim

When frozen features encode magnitude in a direction that remains ordered beyond the training range, the head that extrapolates can be identified before seeing any out-of-range data. The test is how the head behaves on an "inner extrapolation split", which sorts the training data by target and holds out its top slice. Ordinary random validation and standard training-free architecture scores both rank heads by in-range fit. They therefore systematically prefer heads that extrapolate badly. Simplicity bias is the proposed mechanism. Gradient descent latches onto whatever feature direction predicts the target most easily within the range. In frozen embeddings, such directions (image density, contextual statistics) often saturate outside it.

Where This Sits

The motivating evidence comes from two papers that pair numerical extrapolation with pre-trained models. Unveiling the Visual Counting Bottleneck in Vision-Language Models builds synthetic Go boards in which visual counts are trained only up to 49 and tested on 50–99. It shows that linear probes on the frozen vision encoder recover counts with >99% accuracy in the extrapolation range, while generation collapses to 0% on attractor tokens such as 49 and 99. The authors trace the collapse to visual and textual counting circuits that are 95.7% disjoint.

The file does not say whether those probes were fit only on in-range counts. If they were fit on out-of-range labels, they show that magnitude is present in the features, not that a head trained in-range will read it out. That distinction is exactly what this proposal tests. The authors conclude that architectural priors are needed. We ask the narrower question of whether choosing the right small head on frozen features is enough.

TabularMath supplies the tabular case. It turns GSM8K and AIME problems into deterministic tables, then tests on rows whose targets lie above the training range. TabPFN v2.5 keeps a median $R^2$ of 0.75 on GSM8K-OOD, but its rounded consistency (exact match after rounding) falls from 62.0% in interpolation to about 8%. Tree ensembles fall below 1%, and in-context learning with GPT-OSS-120B keeps about 40%. TabularMath treats these models as fixed baselines. We instead treat the tabular foundation model as a frozen encoder, in the manner of TabMDA, which passes each row through TabPFN to obtain embeddings and trains ordinary classifiers on them. TabMDA evaluated only in-distribution accuracy.

The simplicity-bias literature supplies the mechanism and one candidate intervention. The Pitfalls of Simplicity Bias in Neural Networks shows that networks can become completely invariant to a fully predictive complex feature when a simpler one is available. Gradient Starvation explains why: once an easy feature reduces the loss, gradients for the others decay. It also proposes spectral decoupling, a penalty on output size. Both papers study classification with spurious categorical cues. We carry the argument to regression on magnitudes, where the "easy" feature is one that is monotone inside the range but bounded outside it.

Arithmetic units supply part of the search space. Neural Arithmetic Logic Units and Neural Arithmetic Units build layers whose weights are pushed toward exact addition and multiplication. NMU reached a 94% success rate on 10-parameter multiplication with near-zero extrapolation error, but only on raw scalar inputs and hand-designed topologies. We place these units on top of frozen embeddings.

The architecture-search papers act as a constraint and as foils. EZNAS, HNAS and budgeted performance estimation all make ranking cheap, but every one is calibrated to in-distribution accuracy. EZNAS-A reaches Kendall τ of 0.65 on NAS-Bench-201 (Kendall τ measures how well two rankings agree). None of them asks whether its ranking survives a shift in target magnitude. We test that directly, and we expect them to fail for the same reason random validation fails.

Research Program

The search space is deliberately small and covers heads that are plausible for numbers. It includes linear regression, a log-linear head (a linear readout followed by exponentiation, the multiplicative path of NALU), and NAU/NMU stacks of depth one to three. It also includes ReLU MLPs of varying width and depth, with and without spectral decoupling, a classification head over integer bins (this mimics what a language model's token output effectively does), and k-nearest neighbors. Each is crossed with input choices: which encoder layer to read, whether features are first reduced to their top principal directions, and whether a sparsity penalty is applied.

The selection signal has two parts. The first is the inner extrapolation score. We sort the training rows by target $y$ and train each head on rows with $y \le q_{0.8}$, where $q_{0.8}$ is the 80th percentile of training targets. We then compute the head's exact-match accuracy on rows above $q_{0.8}$, and retrain on all rows for deployment. The 80/20 split mirrors TabularMath's own outer split. This costs one extra fit per head, which for these heads takes seconds.

The second part is a training-free geometry score computed on the frozen features alone. We fit the single best magnitude direction on in-range data. We then measure how the ordering along that direction holds up across the upper in-range quantiles, and how much the target relationship curves there, separately for a linear and a log link. This predicts which link function will survive extrapolation before any head is trained. It is our analogue of a zero-cost architecture proxy, but it is aimed at extrapolation rather than at trainability.

To test the simplicity-bias mechanism, we identify every feature direction that correlates with the target in-range and record which one each trained head relies on, using input-gradient attribution onto those directions. We then check whether heads that rely on directions that saturate in the inner split are the ones that fail outside the range. A controlled version adds a deliberately saturating cue: on Go boards, a board-fill texture that is predictive up to count 49 and then constant. This lets us vary shortcut strength, in the spirit of Shah et al.'s linear-plus-slab construction.

Baselines

The naive reference point is the system as practitioners would build it. That means the frozen encoder with a head chosen by random-split validation, plus the original model's own output: the VLM generating the count, and TabPFN v2.5 predicting directly. For the VLM on Go-board extrapolation, the cited paper reports 0% explicit counting accuracy on counts 50–99 (Pang et al.). For TabPFN v2.5 on GSM8K-OOD, the reported figure is about 8% rounded consistency (TabularMath). Beating random-split selection is the central test, because it isolates the selection criterion with the head pool held fixed.

The strongest existing competitor on the tabular benchmark is in-context learning with GPT-OSS-120B, reported at about 40% rounded consistency on GSM8K-OOD (TabularMath). We take that number as reported and run our heads on identical OOD splits and row counts. Beating it would mean exceeding 40% with only TabPFN-sized compute. Matching it at a tiny fraction of the cost would already be a meaningful result. On Go boards we found no reported result on Lacuna for any trained-head baseline that extrapolates past count 49. The comparison there is against the 0% generation figure and against our own random-split-selected heads.

The architecture-search baselines are HNAS-style NTK-trace and condition-number scores (HNAS) and an EZNAS-A-style evolved proxy (EZNAS), applied to the same head pool. They are judged by Kendall τ against true out-of-range accuracy. In-distribution, EZNAS-A reports τ = 0.65 on NAS-Bench-201 CIFAR-10, but we found no reported result on Lacuna for any zero-cost proxy ranked against extrapolation accuracy. Our selection signal should clearly exceed these proxies' τ on our pool.

Every method sees the same frozen features, the same labeled range, the same candidate pool and the same number of head fits. Ablations remove the arithmetic and log-linear heads from the pool, remove spectral decoupling, replace the inner split with a random split of equal size, and use the geometry score alone without training. These isolate whether the gain comes from the search space, the selection rule, or the regularizer.

Why not just…?

Why not just fit a linear regression head? This is the most serious threat. If counts lie on a straight line in the encoder's features, linear regression extrapolates and no search is needed. It is in our pool, and we will report how often it wins. We expect it to fail when the encoding is compressive, as log-like magnitude codes are, and on TabularMath, where targets are products and multi-step functions of inputs, so no linear readout of a fixed embedding can give exact rounded answers. If linear heads win everywhere, the claim narrows to "the geometry score tells you in advance that linear is safe". That would still be useful, but we would say plainly that it is the smaller result.

Why not just fine-tune the backbone on the training range? Fine-tuning costs orders of magnitude more than fitting heads. Pang et al.'s finding of disjoint circuits and boundary attractors suggests that training on counts up to 49 entrenches 49 as a ceiling rather than removing it. We will run one parameter-efficient fine-tune on the Go-board encoder at a fixed GPU-hour budget. Its out-of-range accuracy will be compared against the best searched head at under 1% of that compute.

Why not just use an LLM in context, as TabularMath found works best? At about 40% consistency it is the number to beat, but it requires a 120B-parameter model per query and has no visual counterpart for counting. If our heads on TabPFN embeddings stay well below 40%, the honest conclusion is that frozen tabular embeddings do not carry the needed arithmetic structure. That is still a clean negative result about Direction 4.

Why not just use an existing zero-cost proxy? Those scores measure trainability and in-range fit at initialization, which is exactly the quantity we hypothesize is anticorrelated with extrapolation when shortcuts exist. Rank-correlation measurements on our pool settle this directly.

Proposed Experiments

The decisive check comes first. On Go boards with a frozen Qwen3-VL vision encoder and with RADIOv2.5-B features, and on all 114 TabularMath problems with frozen TabPFN embeddings, we compute the Kendall τ between each selection signal and true out-of-range exact-match accuracy across the full head pool. The hypothesis fails if the inner-split score does not beat random-split validation by a clear margin. It also fails if the head it selects does not beat the random-split choice on out-of-range exact match.

The second check varies the extrapolation distance. We keep the 50–99 test range fixed while shrinking the training range (0–39, 0–29) and record how the inner score's predictive power decays. This shows how far an inner 20% slice can vouch for.

The third check is the shortcut sweep. As the injected saturating cue grows stronger, random-split selection should increasingly pick heads that rely on it, and their out-of-range accuracy should drop. Inner-split selection should not. Spectral decoupling should shift attribution back toward the stable direction, which would extend Pezeshki et al.'s classification result to magnitudes.

As a final transfer test, we apply the selected head to the VLM's language input in place of free-form count generation. This asks whether reading the number from the frozen features with a searched head breaks the 0% attractor result without retraining the language model.