Quantized Tensor

The core payload of a quantized tensor is an array of integer values (e.g., INT8, INT4). These integers represent the original high-precision floating-point values (like FP32) mapped into a discrete, lower-bit space. This array provides the primary memory and bandwidth savings—for example, an INT8 array is 75% smaller than its FP32 equivalent. On hardware with dedicated integer arithmetic units, such as many NPUs, operations on these integer arrays execute significantly faster than their floating-point counterparts.

The scale is a floating-point multiplier that defines the resolution of the quantization mapping. It is calculated as: scale = (float_max - float_min) / (quant_max - quant_min).

• Purpose: Converts integer steps back to floating-point increments. Multiplying an integer value by the scale approximates its original floating-point magnitude.
• Example: If a tensor's values range from -2.5 to 2.5 and are quantized to INT8 (-128 to 127), the scale is approximately 5.0 / 255 ≈ 0.0196. An integer value of 64 would dequantize to 64 * 0.0196 ≈ 1.25. The scale is a critical parameter for maintaining the dynamic range of the original tensor.

The zero-point is an integer value that corresponds exactly to the real value of zero in the floating-point domain. It enables asymmetric quantization, where the quantized range is not centered on zero.

• Purpose: Ensures that an exact value of zero can be represented without error, which is crucial for operations like padding and ReLU activations.
• Calculation: zero_point = quant_min - round(float_min / scale).
• Usage in Dequantization: The full formula to reconstruct a float value is: float_value = scale * (int_value - zero_point). Without a zero-point, representing zero often requires rounding, introducing persistent bias in networks.

This defines the scope over which a single scale and zero-point pair is applied. The choice of granularity is a key trade-off between accuracy and computational/metadata overhead.

• Per-Tensor: One set of parameters for the entire tensor. Simple but can lose accuracy if the tensor's value distribution varies widely.
• Per-Channel: Unique parameters for each output channel of a weight tensor (common in convolutions and linear layers). This accounts for varying weight distributions and is the standard for high-accuracy INT8 quantization.
• Group-Wise: Parameters shared across blocks of values within a tensor, offering a middle ground between per-tensor and per-channel approaches.

This specifies the integer format used for storage and computation. The bit width directly determines the compression ratio and influences the quantization error.

• Common Types: INT8 (8-bit), INT4 (4-bit), UINT8 (unsigned 8-bit). INT8 is the industry standard for inference, offering a 4x size reduction over FP32.
• Impact: Lower bit widths (e.g., INT4, binary) increase compression but also increase quantization error. The choice is hardware-dependent; many NPUs have optimized pipelines for specific bit widths like INT8 or INT4.
• Metadata Overhead: The scale and zero-point parameters add a small, fixed overhead, which becomes more significant with lower bit widths and finer granularity.

While not stored as raw data, the dequantization operation is an intrinsic property of the quantized tensor structure. It is the mathematical inverse of the quantization process, defined by the scale and zero-point.

• Function: dequantize(int_tensor) = scale * (int_tensor - zero_point).
• Runtime Consideration: In integer-only inference pipelines, explicit dequantization is avoided during compute-heavy layers. Instead, scales and zero-points are folded into adjacent layers or handled with integer arithmetic, allowing the NPU to operate purely on integer data paths. The logic, however, remains encoded in the model's execution graph.

Quantization is the foundational process of mapping continuous, high-precision floating-point values to a discrete set of lower-bit integers. This reduces the computational and memory footprint of neural networks, enabling faster inference and deployment on resource-constrained hardware like NPUs and edge devices. The process introduces quantization error, which must be managed to preserve model accuracy.

These are the two critical parameters stored with a quantized tensor that define the linear (affine) mapping between integer and floating-point domains.

• Scale: A floating-point value that determines the resolution of the mapping (the size of each integer step in FP space).
• Zero-Point: An integer value that corresponds exactly to the floating-point value zero, enabling efficient representation of asymmetric data ranges. Together, they allow reconstruction of approximate FP values: fp_value ≈ scale * (int_value - zero_point).

These are two schemes for defining the quantization range:

• Symmetric Quantization: The range is symmetric around zero (e.g., [-127, 127] for INT8). The zero-point is typically forced to 0, simplifying the integer arithmetic by eliminating an addition step.
• Asymmetric Quantization: The range is offset to match the actual min/max of the tensor data (e.g., [0, 255]). This better captures skewed distributions (like ReLU activations, which are all non-negative) but requires handling the non-zero zero-point in calculations.

A quantization granularity method where a unique set of quantization parameters (scale and zero-point) is calculated and applied to each output channel of a weight tensor (e.g., in convolutional or linear layers). This is more granular than per-tensor quantization, where one set of parameters is used for the entire tensor. Per-channel quantization typically yields higher accuracy because it accounts for the varying dynamic ranges across different filters or neurons.

Dequantization is the inverse operation of quantization. It converts the stored integer values in a quantized tensor back into floating-point numbers using the tensor's scale and zero-point parameters. This is necessary in hybrid execution graphs where some operations still require FP inputs, or for debugging and analysis. The formula is: float_value = scale * (int_value - zero_point).