Quantization Scale and Zero-Point

The mathematical relationship is defined by the affine transformation: real_value = scale * (quantized_value - zero_point). The scale is a positive floating-point number that determines the resolution of the mapping. The zero-point is an integer within the quantized range (e.g., 0-255 for INT8) that corresponds exactly to the real value of zero, allowing for efficient representation of asymmetric data distributions.

This distinction is defined by the zero-point:

• Symmetric Quantization: Zero-point is forced to 0. The quantization range is symmetric around zero (e.g., [-127, 127] for INT8). This simplifies arithmetic but is inefficient if the tensor's value distribution is not symmetric.
• Asymmetric Quantization: Zero-point is calculated from the observed min/max values. This allows the quantized range to precisely match the tensor's distribution, minimizing clipping error. It is the standard method for activations, which often have skewed, non-zero-centered distributions (e.g., after a ReLU activation).

Scale and zero-point are not guessed; they are calibrated using a representative dataset. Common algorithms include:

• Min-Max: scale = (float_max - float_min) / (quant_max - quant_min); zero_point = quant_min - round(float_min / scale). Simple but sensitive to outliers.
• Entropy / KL Divergence: Selects parameters to minimize the information loss between the original and quantized distributions, often yielding higher accuracy.
• Percentile: Uses a percentile (e.g., 99.99%) of the observed range to mitigate outlier effects. Calibration is a one-time, offline process for static quantization.

The primary purpose of these parameters is to enable integer-only inference. NPUs contain dedicated integer arithmetic logic units (ALUs) that are faster and more power-efficient than floating-point units. The scale and zero-point allow the core computation, such as a matrix multiplication Y = X * W, to be performed entirely in the integer domain using adjusted formulas. The final integer result is then dequantized back to floating-point only if necessary for downstream layers or output.

Quantization parameters can be shared at different granularities, trading accuracy for complexity:

• Per-Tensor: A single scale and zero-point for an entire tensor. Simple but can lead to high error if the tensor's channels have widely varying ranges.
• Per-Channel: A unique scale and zero-point for each output channel of a weight tensor (common for convolutions and linear layers). This dramatically improves accuracy by adapting to each filter's distribution but requires more parameter storage and slightly more complex hardware support.

Major ML frameworks provide explicit APIs for handling these parameters:

• PyTorch: torch.quantize_per_tensor(), torch.quantize_per_channel(). The QuantizedTensor object stores int_repr, scale, and zero_point.
• TensorFlow / TFLite: The TFLiteConverter calculates parameters during conversion. The flatbuffer model format stores them for each relevant tensor.
• ONNX: Uses QuantizeLinear and DequantizeLinear operators in the graph, which explicitly carry scale and zero-point as inputs. These abstractions allow developers to define quantization schemes that are later executed by optimized backends like TensorRT, OpenVINO, or vendor-specific NPU SDKs.

Affine quantization is the linear mapping method that uses a scale factor (s) and a zero-point (z) to convert between floating-point and integer domains. The formula is: Q = round(R / s) + z, where R is the real value and Q is the quantized integer. This method is asymmetric, allowing the quantized range to better fit data distributions that are not centered on zero, which is common for activations after a ReLU function.

Symmetric quantization is a simplified linear mapping where the quantized range is forced to be symmetric around zero. This is achieved by setting the zero-point to 0. The mapping formula becomes Q = round(R / s). It simplifies computation by eliminating the zero-point addition in certain operations but can be less accurate if the original data distribution is significantly offset from zero, leading to wasted quantization bins.

Quantization granularity defines the scope over which a single set of quantization parameters (scale and zero-point) is shared. Common levels include:

• Per-tensor: One scale/zero-point for an entire tensor. Simple but less accurate.
• Per-channel: Unique parameters for each output channel of a weight tensor (e.g., in Conv2D layers). Higher accuracy, common for weights.
• Per-token/Per-axis: Unique parameters for specific dimensions, such as per token in sequence data. Granularity trades off between model accuracy, memory for parameters, and computational overhead.

A calibration dataset is a small, representative subset of the training data (typically 100-1000 samples) used during Post-Training Quantization (PTQ). Its purpose is to run inference on the FP32 model to collect the statistical range (min/max) or histogram of activation tensors. These statistics are used to calculate the optimal scale and zero-point parameters for each tensor, ensuring the integer range is properly allocated without requiring model retraining.

A quantized tensor is a data structure that stores integer values (e.g., INT8) alongside its associated quantization parameters: the scale (a floating-point number) and the zero-point (an integer). It enables efficient storage and computation using integer arithmetic. During operations, the hardware or runtime uses these parameters to interpret the integers. For example, a framework like PyTorch stores these as torch.quint8 or torch.qint8 dtypes.

Integer-only inference is an execution paradigm where the entire forward pass of a neural network is computed using integer arithmetic, without any floating-point operations. This is enabled by using affine quantization with pre-computed scales and zero-points, and by reformulating operations like matrix multiplication to work directly on integers. It is critical for deployment on low-power NPUs, microcontrollers, and edge devices that lack efficient FPUs, maximizing speed and energy efficiency.