A quantizer with a fixed integer width has only a finite set of representable codes. When many activations share one scale, a single value with much larger magnitude can force that scale to cover a wider real-valued range. The remaining values then occupy fewer useful code intervals around the region where they are concentrated.
This behavior is not a generic statement that quantization fails in the presence of large numbers. It follows from a specific coupling: values inside the same quantization group share parameters that map real numbers to integer codes.
The scale connects range to resolution
Consider symmetric uniform quantization to signed integers with maximum positive code Q. A simplified mapping is
s = amax / Q
q = clamp(round(x / s), -Q, Q)
x_hat = s * qHere, amax is the magnitude chosen to define the represented range, s is the scale, q is the stored integer code, and x_hat is the reconstructed value.
If amax increases while Q stays fixed, s increases. Adjacent integer codes then correspond to real values that are farther apart. A large range and fine resolution cannot both be obtained from the same fixed set of codes without changing the quantization scheme.
The exact endpoints vary across integer formats and implementations. Asymmetric quantization also introduces a zero point, and some schemes derive scale from statistics other than the observed maximum. The coupling between represented range and code spacing remains the relevant mechanism for uniform quantization.
One outlier can affect values it never resembles
Suppose a group contains values concentrated near zero plus one activation with a much larger magnitude. Under a max-based scale, that large activation can determine amax. Smaller values are then rounded on the coarser grid created for the entire group.
For a simplified signed range with Q = 127, compare two scales:
amax = 1 -> s = 1 / 127
amax = 16 -> s = 16 / 127The second group has sixteen times the real-valued spacing between adjacent integer codes. This does not mean every reconstructed value has sixteen times the error. Rounding error depends on each value’s location relative to the grid, and clipping behavior adds another source of error when values exceed the represented range. The example isolates the change in grid spacing.
The scope of the effect is determined by parameter sharing. An outlier in one independently quantized group does not directly set the scale of another group.
Group granularity changes the coupling
Per-tensor quantization can use one scale for a whole tensor. Per-channel schemes assign independent scales along a selected channel dimension. Grouped schemes divide a dimension into smaller blocks and assign parameters per block.
Finer granularity can isolate an outlier so fewer unrelated values share its scale. It also creates more quantization metadata and can change kernel layout, memory access, and supported execution paths. Whether that produces a useful end-to-end result depends on the runtime and hardware rather than on scale arithmetic alone.
Granularity also has semantic consequences for evaluation. Two implementations both described as INT8 can apply different grouping rules and therefore produce different reconstructed tensors from the same floating-point values. Bit width alone does not specify the quantizer.
Clipping exchanges range for resolution
A quantizer does not have to preserve the largest observed magnitude. It can select a smaller range and clip values outside it. That reduces s, giving more closely spaced reconstruction levels inside the retained range, while values beyond the boundary saturate.
The choice therefore changes the location of error rather than removing it. A max-based range avoids clipping values used to establish that range but can devote substantial code space to rare extremes. A clipped range can represent the dense central region more finely while introducing explicit saturation error at the tails.
Calibration methods differ in the criterion used to choose this boundary. A calibration rule is part of the quantization definition; it should not be treated as an interchangeable preprocessing detail. The selected data also matters because it determines which activation ranges the calibration procedure observes.
Static and dynamic activation scales expose different assumptions
With static activation quantization, scale parameters are established ahead of the inference operation from calibration data or another fixed procedure. A later input whose activation distribution extends beyond the selected range may clip, depending on the quantizer.
Dynamic quantization can derive parameters from values available at runtime. That can adapt the represented range to the current tensor or group, but scale computation becomes part of the execution path. It also does not remove the shared-scale problem inside a group: an outlier present in the current group can still widen its scale.
The distinction matters when diagnosing output differences. A model can use the same integer width and grouping layout yet behave differently because one runtime fixes activation scales while another derives them per execution.
Weight outliers and activation outliers are separate cases
Weights are fixed for a given checkpoint during inference, so their quantization parameters can generally be prepared from known tensors. Activations depend on the input and intermediate model state. Their ranges can therefore vary across requests and sequence positions.
A technique that handles weight range well does not automatically address activation range. Weight-only quantization can leave activations in a higher-precision format, avoiding activation quantization entirely while still changing storage and computation for weights. A weight-and-activation scheme has additional range and calibration decisions.
This boundary is useful when comparing model formats. The label attached to a quantized checkpoint should be resolved into what is quantized, at which bit width, with which grouping, and with which scale rule before numerical behavior is compared.
Scale metadata is part of the numerical contract
Integer tensors alone are not sufficient to reconstruct quantized values. Their scales, zero points when present, grouping layout, axis conventions, clipping rule, and rounding behavior determine the mapping back to real values.
For serving systems, that means quantized weights cannot be moved between kernels solely because their packed integer shapes match. A kernel must interpret the metadata with the same quantization convention used to produce the packed values.
Activation outliers expose this contract particularly well: their effect is bounded not by the tensor name or nominal bit width, but by the exact set of values sharing quantization parameters. Changing that boundary changes which values compete for the same finite code range.