Four-bit quantization looks like a deployment-time decision: pick a method, run it, recover the accuracy. It is not — genuine low-bit quantizability is fixed at pre-training time by optimizer and normalization choices, and the post-hoc rotation tricks you reach for at deploy time yield less the lower the bit-width goes.
A team has a model to serve and a GPU bill to cut, and quantization is the lever. They have read the serving literature, so they already know FP8 is close to free and INT8 costs a point or two. The interesting line is four bits: it quarters the weight memory, and a model that needed an expensive card now fits on a cheap one. The plan is the plan everybody runs — take the trained checkpoint, apply a strong post-training quantization method (GPTQ, a rotation like Hadamard, a smoothing pass), measure the benchmark, confirm the recovery is acceptable, ship. Quantization, in this plan, is a thing you do to a finished model, at the end, on the way out the door.
There is a refinement the team is proud of. They have read that the difficulty in low-bit quantization is a small set of activation outliers — a handful of features with magnitudes far larger than the rest of the tensor — so they instrument for them: they compute the kurtosis of the activation distributions, track the max-to-mean ratio, and treat those numbers as a dashboard. Low outlier statistics, safe to quantize; high, reach for a stronger method. It feels rigorous. It is measuring the thing the literature said was the villain.
The plan has two flaws, and they compound. The first: the post-hoc rotation and smoothing tricks the team is relying on yield less and less as the bit-width drops — at four bits and below they are fighting a losing battle, and on some modern formats a rotation makes the result worse. The second, more fundamental: the dashboard is wrong. Kurtosis and max-to-mean do not reliably predict how a model will behave under four-bit quantization. The team is watching a gauge that is not wired to the outcome, applying fixes that fade exactly when they are needed most, to a property — low-bit quantizability — that was settled long before the checkpoint reached them, at pre-training time, by choices they did not make and cannot redo at deploy.
This post is about where four-bit quantizability is really decided, why the deployment-time fixes give diminishing returns, and why the outlier count you are probably tracking is the wrong predictor.
The mistake is worth stating precisely, because the corrected version is more subtle than the slogan it replaces. “Four-bit is not a free lunch” is true and stays true for the whole post. “Outliers alone decide it, so count the outliers” is the part that does not survive contact with the measurements.
The reasoning behind the dashboard is sound as far as it goes. Uniform quantization maps a tensor’s values onto a small grid of levels; a few outlier features with very large magnitudes force that grid to stretch to cover them, which makes every level coarse, which crushes the ordinary small-magnitude values into a handful of indistinguishable levels. At four bits — sixteen levels — that crushing is severe. So outliers genuinely are a dominant source of four-bit error, and a method that does not handle them produces a broken model. That much the literature supports, and this post does not walk it back.
What does not follow is that a scalar summary of the outliers — kurtosis, max-to-mean ratio, an outlier count — predicts the accuracy you will get after quantization. It does not, and the reason is structural. Those metrics are computed on one tensor at a time, in isolation; they describe how hard that tensor is to put on a coarse grid, and say nothing about how its quantization error propagates — how it accumulates through the layers downstream, interacts with the errors in every other quantized tensor, gets amplified or absorbed by the network’s later computation. A model’s four-bit accuracy is a property of the whole network’s error behavior. A per-tensor outlier statistic is a property of one tensor’s shape. Treating the second as a forecast of the first is the modeling error, and it is why a team can watch a clean dashboard and still ship a degraded model.
There is a second, quieter problem: the dashboard is an artifact of an older generation of models. The outlier story was characterized on the LLMs of a few years ago, where the outliers were severe; on some modern models that is measurably less true, a point the scope section returns to with the paper that measured it. The metric is not just structurally weak as a predictor — it is pointed at a target that has shrunk.
Grant that four-bit error is real and outlier-driven. The team’s instinct — reach for a stronger post-training method — is not crazy; it is just subject to a diminishing return the bit-width controls.
The post-training toolkit is, at its core, a set of ways to make a tensor easier to put on a coarse grid before you put it there. Rotation methods multiply weights and activations by an orthogonal matrix — a Hadamard transform is the common choice — to spread the energy of a few outlier features across many dimensions, so no single dimension forces the grid to stretch. Smoothing and channel-wise scaling migrate magnitude from activations, where it is hard to quantize, to weights, where it is easier. GPTQ adjusts the remaining weights to compensate for the rounding error. These work — at eight bits, so well the result is near-lossless. The question is what happens as the grid gets coarser.
The answer the literature gives is: they give back less, and sometimes they backfire. SmoothRot: Combining Channel-Wise Scaling and Rotation for Quantization-Friendly LLMs (arXiv 2506.05413) states the failure mode directly — rotation alone, the paper finds, can amplify quantization errors in 4-bit scenarios involving extremely large outliers. A rotation spreads outlier energy across dimensions, but if the outlier is large enough, spreading it raises the floor across every dimension it touches, and on a sixteen-level grid that raised floor costs more than the concentrated spike did. The measured gap is wide. On W4A4, going from the FP16 baseline through a rotation-only method (QuaRot) to SmoothRot, WikiText-2 perplexity moves 5.47 → 8.33 → 7.51 for LLaMA2-7B and 6.24 → 9.83 → 9.48 for LLaMA3.1-8B; six-task zero-shot accuracy for LLaMA2-7B moves 69.61 → 55.94 → 59.83. Read the middle column: rotation alone leaves a 12-to-14-point accuracy hole, and you need channel-wise scaling on top to claw back even part of the way — and even then four bits is not free.
The format itself can turn the fix negative. Bridging the Gap Between Promise and Performance for Microscaling FP4 Quantization (arXiv 2509.23202), the first systematic study of MXFP4 and NVFP4 for LLMs, finds rotation’s value format-dependent and, for one format, counterproductive. NVFP4 uses very small 16-element quantization groups; within a group that small, a Hadamard rotation makes the result worse — round-to-nearest with a Hadamard transform drops Llama-3.1-8B-Instruct to 74.05% from plain round-to-nearest’s 74.73% — while MXFP4’s larger 32-element groups still benefit. Same trick, opposite sign, decided by the format’s group size. There is no general “apply a rotation” rule at four bits; there is a per-format question, and on the newest formats the answer is sometimes no.
This is the diminishing return, stated plainly: the post-training method is most effective at the bit-widths where you least need it — eight bits, near-lossless anyway — and least effective, occasionally negative, at four bits and below, where you are actually asking it to save the model. The deployment-time fix fades exactly into the regime it was supposed to rescue.
If post-hoc methods give back less as the bits drop, the question is where four-bit quantizability actually comes from. The strongest evidence says pre-training — set by specific, nameable choices.
Establish the baseline first, because the post-training literature is not all gloom. The FP4 study’s eight-bit results are genuinely near-lossless: Llama-3.1-8B-Instruct at FP8 with GPTQ recovers 78.58% against a 78.93% FP16 baseline — 99.55% recovery, a rounding error. The four-bit results are where the lunch gets billed: the best FP4 configuration measured, NVFP4 with the paper’s MR-GPTQ method, reaches 75.84% (96.08% recovery), and MXFP4 with the same method 73.65%. The gap between “FP8 is free” and “FP4 costs three to five points of recovery” is the real, measured shape of the problem. FP8 is not where quantizability is in question; four bits is.
Now the pre-training evidence. Outlier-Safe Pre-Training for Robust 4-Bit Quantization of Large Language Models (arXiv 2506.19697) runs the cleanest possible experiment: hold the architecture and the data fixed, change only the pre-training recipe, and measure four-bit behavior. A 1.4B-parameter model is trained on 1T tokens two ways — a conventional Adam-trained twin, and an Outlier-Safe Pre-Training model using the Muon optimizer, a Single-Scale RMSNorm, and a learnable embedding projection. Under four-bit quantization, the OSP model scores 35.7 average across 10 benchmarks against 26.5 for the Adam twin: +9.2 points, a 35% relative improvement, from nothing but the pre-training recipe. The excess kurtosis tells the mechanism — 0.04 for OSP, 1818.56 for the Adam model. The conventional optimizer manufactured the outliers; the outlier-safe recipe did not. The paper’s own framing is the sentence to carry away: outliers are not inherent to LLMs but are consequences of training strategies.
The perplexity numbers make the prevention-versus-mitigation point exactly. On WikiText-2 at four bits, plain round-to-nearest gives the Adam model a perplexity of 14,475 and the OSP model 45.9; add GPTQ and the Adam model improves to 3,723 while OSP reaches 14.3; add SpinQuant and the Adam model finally becomes usable at 14.94 — against OSP’s 13.66. Trace the SpinQuant column: a heavy post-training method rescues the Adam model dramatically, from unusable to nearly matching, but adds almost nothing to a model that was outlier-free to begin with. The post-hoc method does enormous work to undo damage the right pre-training recipe simply never did. Prevention and mitigation are not two routes to the same place; mitigation is the expensive route, and it is the one you take because the prevention decision was already made for you, the wrong way.
The lever is the optimizer, and a second paper confirms it from a different angle. Beyond Outliers: A Study of Optimizers Under Quantization (arXiv 2509.23500) finds the effect real and consistent — models trained with Shampoo degrade least under quantization-aware training. The same paper delivers the other half of the corrected thesis, worth stating in its own words: standard outlier metrics — max-to-mean ratio, kurtosis — fail to predict post-training-quantization accuracy across optimizers, precisely because they do not account for error accumulation through the network. One paper, both halves: the optimizer decides quantizability, and the outlier dashboard does not forecast it.
The honest scope of this post is narrower than the slogan it corrects, and the narrowing is the point — so here is what these numbers do not say.
They do not say outliers set the accuracy ceiling. That is the overclaim, and two papers in this very literature push against it. Outliers and Calibration Sets have Diminishing Effect on Quantization of Modern LLMs (arXiv 2405.20835) measures exactly that: newer LLMs — Llama-2 and Llama-3, Command-R, Mistral — show strong robustness to outlier preservation, with Mistral 7B exhibiting what the authors call near-immunity to outliers, and it argues the field should pivot away from outlier preservation as a quantization strategy. And Beyond Outliers is the reason “count the outliers” is the wrong instrument at all. The corrected thesis lives in the gap between those two and the strong claim: four bits is genuinely not free — the FP4 and SmoothRot numbers are not a mirage — but the difficulty is not a single measurable quantity called “outlier count,” and on modern architectures the measured impact of outliers is shrinking. If your mental model is “minimize the outlier metric and four-bit will be fine,” both papers say that model is broken.
They do not say “pre-training fixes everything, so quantize freely.” The OSP and Shampoo results say the lever is the pre-training recipe — and they are specific about which lever: the optimizer (Muon, Shampoo) and the normalization (Single-Scale RMSNorm), not “architecture” loosely. If you are not the team that pre-trained the model, this lever is not in your hands; what you can do is choose a model whose makers pulled it, and stop expecting a deploy-time pass to manufacture quantizability the pre-training did not build in.
And the scope is bounded by model scale. The OSP evidence is from a 1.4B model; SmoothRot and FP4 are on 7-to-8B models; there is no verified evidence here at 70B and above. The mechanism has no obvious reason to reverse at scale, but “no obvious reason” is not a measurement — treat frontier-scale behavior as unconfirmed. And keep every claim scoped where it belongs, at four bits and below: FP8 is genuinely near-lossless at 99.5%-plus recovery, and none of this is an argument against eight-bit serving, which remains the free lunch the four-bit version is not.
You cannot quantize your way to a free four-bit model at deploy time. What you can do is choose models whose pre-training bought the quantizability, budget the gap you cannot close, and stop trusting the wrong gauge.
Treat four-bit quantizability as a model-selection criterion, not a deployment step. The decision that matters is which checkpoint you start from. When low-bit serving is on the roadmap, a model pre-trained with a quantization-aware recipe — an outlier-safe optimizer, a controlled normalization — is a better starting point than an equally capable model that was not, and the difference is not recoverable later. This is the discipline serving-time quantization applies to bit-width selection, pushed one step upstream: the cheapest place to influence four-bit accuracy is before training, not after.
Stop using outlier metrics as the predictor. Kurtosis and max-to-mean ratio describe one tensor’s shape; they do not forecast post-quantization accuracy, because they ignore how error accumulates through the network. Measure them for diagnosis if you like, but do not gate a deployment on them — the gauge wired to the outcome is an end-to-end evaluation of the quantized model, not a per-tensor statistic.
Budget a real four-bit gap; do not assume a method erases it. Plan for a three-to-five-point recovery gap at four bits and decide, on purpose, whether the capability you sell can absorb it. The same per-capability evaluation that the distillation case insists on applies here — a four-bit model that holds on knowledge benchmarks can still have lost reasoning, and an aggregate will not tell you, just as an aggregate hid the uneven degradation under KV-cache compression.
Match the post-training method to the format, and pair rotation with scaling. Rotation is not universally good at four bits: on small-group formats like NVFP4 a Hadamard rotation can make the result worse, while larger-group formats benefit. Test rotation on and off against your actual format and model. And where rotation does help, the measured evidence is that it leaves a double-digit accuracy gap on its own and needs channel-wise scaling on top — a rotation-only pipeline is leaving recoverable accuracy on the floor.
Decide between prevention and mitigation deliberately. Post-hoc methods rescue an outlier-heavy model dramatically and add almost nothing to an outlier-free one — so if you control pre-training, prevention is the cheaper and stronger route, and if you do not, mitigation’s diminishing return at four bits is a cost to plan around, not a surprise to discover.
Before you call a four-bit configuration safe to serve:
The team in the opening did everything its plan asked. It picked a strong method, ran the rotation, watched the outlier dashboard — and shipped a four-bit model that lost more than the benchmark admitted. The plan was not lazy; it was aimed one layer too late and at the wrong gauge. Four-bit quantizability is not a property you add to a finished model with a clever pass — it is a property the model either has or lacks by the time training ends, set by the optimizer and the normalization, and no amount of deploy-time rotation fully substitutes for it. Choose the checkpoint that was built to survive four bits. The pass you run afterward can only finish a job that pre-training already either did or did not start.
Chinchilla's twenty-to-one was fit on unique data, one pass. Teams now repeat scarce corpora at tens of times that ratio, where the law breaks — and past a repetition threshold the re-derivations reverse its verdict: spend compute on capacity, not more epochs.
14 min →
Teams pick a tokenizer on cheap intrinsic numbers — fertility, parity, bytes-per-token — believing better compression means a better model. Those numbers are weak-to-non-predictive of downstream quality, sharpest outside English, and the choice is a frozen, irreversible bet.
13 min →
One batch posts a record tokens/sec while a single prefill chunk stalls every in-flight decode behind it. The number that pays the bill is goodput — SLO-compliant requests/sec — and it can be several-fold lower. The fix is a capacity-planning decision, not a kernel tweak.
13 min →