Outlier Features and Why LLM Quantization Breaks Without Handling Them

Somewhere around 6.7 billion parameters, transformer activations develop a small set of hidden dimensions whose magnitudes sit far outside everything else and stay there. This is not noise and not a training defect. It is the single reason naive 8-bit quantization works on small models and fails on the ones you want to quantize.

What an outlier feature is

Run a batch of text through a transformer and look at the hidden state entering a linear layer — a matrix with one row per token and one column per hidden dimension. Most entries sit within a few units of zero. A handful of columns do not: their values are an order of magnitude or more larger, they are the same columns from one batch to the next, and they are large for most of the tokens in the batch rather than for a few unusual ones.

The three properties that make this a structural problem rather than a statistical curiosity are worth separating. They are systematic — the same dimensions, not a random scatter. They are persistent across depth — present in all layers, not confined to a stage. And they are emergent — absent below a scale threshold and present above it, rather than growing smoothly.

The published evidence

The measurement is in the LLM.int8() paper by Dettmers, Lewis, Belkada and Zettlemoyer (NeurIPS 2022), and the numbers are specific enough to be worth quoting rather than paraphrasing.

• The paper finds systematic outliers emerging at a scale of 6.7B parameters, and reports that classic quantization at scale fails for transformer models above about 6B.
• It defines an outlier feature by magnitude: a value of at least 6.0. That threshold is not arbitrary — the paper reports that perplexity degradation stops once any feature of magnitude 6 or larger is treated as an outlier. It is the same number that survives today as llm_int8_threshold, default 6.0, in Hugging Face’s BitsAndBytesConfig.
• The affected dimensions are about 0.1% of all input features, and are active in up to 75% of all sequence dimensions, in all layers.
• Zeroing them costs more than their share suggests: the paper reports top-1 attention softmax probability mass dropping by more than 20% and validation perplexity degrading by 600–1000%.

That last figure is the one to hold on to. A tenth of a percent of the features, removed, degrades the model by roughly an order of magnitude. These dimensions are not incidental to what the model computes; they carry a disproportionate share of it.

Why it kills per-tensor int8

The arithmetic is short. Int8 gives 256 levels. A per-tensor scale is set by the largest absolute value in the tensor. If the ordinary activations occupy roughly [-3.5, 3.5] and one outlier dimension reaches 60 — a range Hugging Face’s own documentation describes for these outliers — then:

grid step = 2 * 60 / 255      = 0.47
ordinary range 7.0 wide
levels available to it = 7.0 / 0.47 ≈ 15 levels

15 levels ≈ log2(15) ≈ 3.9 bits of effective resolution

You asked for 8 bits and the ordinary values got four. Every dimension that carries the bulk of the signal is now quantized more coarsely than a 4-bit weight format quantizes weights, and unlike weights they have no per-group scale to rescue them — because, as granularity explains, a scale that varies along the reduction dimension cannot be factored out of the accumulation.

And clipping instead of scaling is worse. Capping the outlier at, say, 6 to protect the grid does exactly what the paper measured when it zeroed those dimensions: it destroys the feature that was carrying 20% of the attention mass.

The three responses

Every method that makes activation quantization work is one of these three, and knowing which one you are running tells you what its failure mode will be.

• Isolate them. LLM.int8()’s mixed-precision decomposition splits the matrix multiply: dimensions above the threshold go through a 16-bit multiply, everything else through an 8-bit one, and the results are summed. The paper notes more than 99.9% of values still go through the 8-bit path. The cost is a branch, a gather, and two matmuls where there was one — correctness at the price of the speedup.
• Move them. SmoothQuant rescales the outlier channels down and the corresponding weight rows up, using an algebraic identity that leaves the product unchanged. Difficulty migrates to the operand that can carry per-channel scales. No branch, no gather, nothing extra at runtime — but the transform is architecture-dependent and its migration strength has to be tuned per model.
• Avoid them. Do not quantize the activations at all. This is what every popular local format does, and it is the response with no failure mode rather than a cheaper one.

Why weight-only quantization dodges it

It is worth being precise about what “dodges” means, because the outlier problem does not vanish — it stops being a quantization problem.

In a W4A16 kernel the activations arrive in FP16 and stay there. FP16 has an exponent, so a value of 60 and a value of 0.001 in the same tensor cost the same relative precision; there is no shared scale for an outlier to dominate. The weights are quantized, but weight distributions do not have this structure — they are approximately normal per channel, which is exactly the assumption NF4 is built on and the reason it works.

What survives is a second-order effect, and it is the one AWQ names. Weights are still quantized per group, so a weight that multiplies an outlier activation channel contributes an outsized share of the output error even though its own magnitude is unremarkable. That is why AWQ selects salient channels from activation statistics rather than weight magnitudes, and why GPTQ weights its error compensation by a Hessian built from activations. Both are handling outlier features — just on the weight side of the multiply, where a per-group scale is available to do something about it.