Quantization

Dynamic quantization is a post-training method where the scaling factor for converting activations to integers is calculated on-the-fly at runtime for each individual input. Weights are typically quantized statically ahead of time. This approach is flexible and handles inputs with varying ranges effectively.

• Primary Use: Models with activation ranges that vary significantly per input (e.g., LSTMs, transformers for variable-length sequences).
• Runtime Overhead: Includes the cost of computing scaling factors for each inference.
• Advantage: No requirement for a representative calibration dataset; adapts to real input distribution.
• Trade-off: Less efficient than static quantization due to per-inference calculations.

Static quantization is a post-training method where the scaling factors for converting both weights and activations to integers are predetermined using a calibration dataset and then fixed for all inference runs. This enables integer-only inference, where the entire computational graph can be executed with pure integer arithmetic.

• Primary Use: High-performance, low-latency deployment on edge devices and NPUs with dedicated integer units.
• Requirement: A representative calibration dataset to capture activation statistics.
• Advantage: Maximum inference efficiency by eliminating floating-point operations.
• Challenge: Accuracy can degrade if the calibration data is not representative of runtime inputs.

This refers to the quantization granularity—the scope over which a single set of quantization parameters is shared.

• Per-Tensor Quantization: A single scale and zero-point is applied to an entire tensor. This is simple but can be suboptimal if the tensor's values have a wide or uneven distribution.
• Per-Channel Quantization: A unique set of parameters is applied to each output channel of a weight tensor (common for convolutional and fully connected layers). This finer granularity accounts for varying distributions across channels, typically leading to higher accuracy.

Example: Quantizing a convolutional layer's 4D weight tensor [OC, IC, KH, KW] per-channel applies different parameters to each of the OC output channels.

These are two schemes for defining the mapping range between floating-point and integer values.

• Symmetric Quantization: The quantization range is symmetric around zero. The zero-point is typically forced to 0. This simplifies the integer arithmetic (no zero-point offset needed in some operations) but can waste precision if the actual data range is not symmetric.

  Integer_Value = round(Float_Value / Scale)

• Asymmetric Quantization: The quantization range is offset to match the min/max of the data. It uses a non-zero zero-point to represent the real value zero. This better utilizes the integer range for skewed data (e.g., ReLU activations that are all non-negative) but requires more complex arithmetic involving the zero-point.

  Integer_Value = round(Float_Value / Scale) + Zero-Point

Weights are often quantized symmetrically, while activations may use asymmetric quantization for better accuracy.

A model compression technique that converts a pre-trained model's weights and activations from floating-point to lower-bit integer representations without requiring retraining.

• Uses a small calibration dataset to observe activation ranges and calculate optimal quantization parameters (scale and zero-point).
• Enables rapid deployment of smaller, faster models but may incur a slight accuracy loss compared to the original FP32 model.
• Common in production inference pipelines where retraining is impractical.

A process that simulates the effects of lower-precision arithmetic during the training phase, allowing a neural network to adapt its weights to mitigate accuracy loss.

• Employs fake quantization nodes in the computational graph to mimic rounding and clipping in the forward pass.
• Maintains high-precision weights for the backward pass, enabling effective gradient updates.
• Produces models that are more robust to quantization, often matching or exceeding the accuracy of PTQ, at the cost of additional training time.

The specific practice of representing neural network weights and activations using 8-bit integers.

• Offers a 4x reduction in model size and memory bandwidth compared to FP32.
• Enables significant acceleration on hardware with dedicated integer arithmetic units (ALUs), which are more power-efficient and faster than floating-point units.
• Requires careful calibration to manage quantization error, as the limited 256-value range can clip important signal information.

The two fundamental parameters in affine quantization that define the linear mapping between floating-point and integer value ranges.

• Scale (S): A floating-point number that determines the step size per integer unit. Calculated as (float_max - float_min) / (quant_max - quant_min).
• Zero-Point (Z): An integer that represents the quantized value corresponding to the real value zero. Allows for efficient representation of asymmetric data distributions.
• The dequantization formula is: float_value = scale * (int_value - zero_point).

Two schemes for defining the range of values mapped during quantization.

• Symmetric Quantization: The quantization range is symmetric around zero. The zero-point is typically 0, simplifying the integer arithmetic (no subtraction needed). Best for data distributions that are already symmetric (e.g., weights after normalization).
• Asymmetric Quantization: The quantization range is offset to match the min/max of the data. The zero-point is non-zero, allowing the full integer range to be used for skewed distributions (e.g., ReLU activations that are all non-negative). More accurate but adds computational overhead.

An execution mode where the entire neural network forward pass is performed using integer arithmetic, eliminating floating-point operations.

• Requires quantization of all layers, including activations, and the use of integer-compatible approximations for non-linear functions like GELU or Softmax.
• Enables highly efficient deployment on low-power edge devices, microcontrollers, and NPUs that lack or have slow floating-point units.
• The final dequantization to a human-readable output (e.g., class score) may still occur in floating-point, but the core compute is integer.