Uniform Quantization

The scale factor (S) and zero-point (Z) are the fundamental parameters defining a uniform quantizer. The scale factor determines the spacing between quantization levels: S = (rmax - rmin) / (qmax - qmin). The zero-point is the integer value that maps exactly to the real value zero, ensuring that zero quantization is error-free, which is critical for operations like padding. These parameters are calibrated per tensor (layer-wise) or per channel (channel-wise) using a small calibration dataset.

Uniform quantization is typically implemented as an affine transformation. A real-valued input r is quantized to an integer q using the formula: q = clamp(round(r / S) + Z, qmin, qmax). Dequantization reconstructs an approximate value r' via: r' = S * (q - Z). This affine scheme is the basis for INT8 and lower-bit quantization, converting floating-point matrix multiplications into efficient integer operations.

This defines how the quantization range [rmin, rmax] is chosen.

• Symmetric Quantization: Forces rmin = -rmax. The zero-point Z is typically 0. This simplifies computation but is inefficient if the value distribution is not symmetric around zero (e.g., ReLU activations, which are all non-negative).
• Asymmetric Quantization: Uses the actual min/max values (rmin, rmax). This uses the available integer range more efficiently for skewed distributions but introduces a non-zero Z, adding a slight overhead.

This defines the granularity at which scale and zero-point are applied.

• Per-Tensor Quantization: A single (S, Z) pair is used for an entire weight or activation tensor. This is simple and widely supported by hardware.
• Per-Channel Quantization: A unique (S, Z) pair is applied to each output channel of a weight tensor (common for convolutional and linear layers). This accounts for varying dynamic ranges across channels, significantly reducing quantization error, especially for weights. It is the standard for modern Post-Training Quantization (PTQ) of models like MobileNet and EfficientNet.

The primary goal of uniform quantization is to replace all floating-point operations with integer arithmetic. For a layer like Y = W * X, after quantizing weights W_q and activations X_q, the core computation becomes integer matrix multiplication: Y_q = W_q * X_q. This is followed by a re-quantization step (involving fixed-point scaling) to produce outputs in the correct integer range for the next layer. This enables execution on hardware lacking FPUs, such as microcontrollers and many Neural Processing Units (NPUs).

Calibration is the process of determining the optimal (S, Z) parameters for a pre-trained model without retraining. A representative dataset is passed through the model to observe the dynamic ranges of activations. Common methods include:

• Min-Max: Uses the absolute observed min/max values.
• Moving Average Min-Max: Tracks min/max over batches.
• Entropy Minimization (e.g., KL Divergence): Selects a range that minimizes the information loss between the original and quantized distributions, often yielding the best accuracy for activations.

Neural Processing Units (NPUs) and Tensor Processing Units (TPUs) have hardware-native support for low-precision, uniform integer arithmetic, which is the primary target of uniform quantization.

• Integer Matrix Multiply-Accumulate (MAC) Units: These accelerators contain dedicated silicon for high-throughput INT8 (or INT4) operations, dramatically outperforming floating-point units in operations per watt.
• Compiler Stack: Frameworks like Google's MLIR (for TPUs) and Qualcomm's SNPE or NVIDIA's TensorRT compile quantized models down to hardware-specific instructions that leverage these integer MAC units.
• Symmetric vs. Asymmetric Support: Most hardware prefers symmetric quantization (zero-point = 0) as it simplifies the computation, but modern accelerators also support asymmetric quantization.

SDKs for mobile and edge System-on-Chips (SoCs) provide tailored toolchains for deploying uniformly quantized models.

• Core ML (Apple): The coremltools Python package can quantize models to 16-bit, 8-bit, or palettized weights. It generates a .mlmodel file that runs efficiently on Apple Neural Engine, which uses low-precision compute blocks.
• Android NNAPI / Qualcomm SNPE: The Android Neural Networks API delegates execution to vendor drivers. Qualcomm's SNPE toolkit includes a quantization-aware conversion tool (snpe-dlc-quantize) that calibrates and produces a quantized Deep Learning Container (DLC) file optimized for Hexagon DSPs.
• NVIDIA TensorRT: For edge GPUs like Jetson, TensorRT performs calibration-based PTQ to find optimal scaling factors for each layer, fusing quantization ops, and generating a highly optimized INT8 engine.

Advanced compiler frameworks take a quantized model and perform hardware-specific graph optimizations.

• Apache TVM: Its Relay quantization pass converts a floating-point graph to a quantized one. TVM then generates optimized kernel code for the target (e.g., using ARM DOT instructions for INT8 convolution on Cortex-A CPUs).
• MLIR & IREE: The MLIR compiler infrastructure has dialects like TOSA (Tensor Operator Set Architecture) that define quantized operations. IREE uses MLIR to compile for mobile GPUs and DSPs, applying transformations like quantization constant folding to eliminate runtime overhead.
• Kernel Fusion: A key optimization is fusing the dequantize-activation-quantize pattern between layers into a single integer operation with rescaling, minimizing memory traffic.

Non-uniform quantization allocates quantization levels unevenly across the value range, typically concentrating more levels in regions of high probability density. This contrasts with uniform quantization's evenly spaced grid.

• Purpose: Minimizes quantization error for non-uniform parameter distributions (e.g., weights following a Gaussian or Laplacian distribution).
• Methods: Includes logarithmic quantization (powers of two) and learned codebooks via k-means clustering.
• Trade-off: Achieves higher accuracy for a given bit-width but requires more complex, often lookup-based, dequantization logic during inference.

Quantization-Aware Training (QAT) is a process where quantization error is simulated during the training or fine-tuning phase, allowing the model to adapt its parameters for optimal performance at lower precision.

• Mechanism: Inserts fake quantization nodes into the computational graph. Forward passes use quantized values; backward passes use the Straight-Through Estimator (STE) to approximate gradients.
• Benefit: Models trained with QAT typically outperform those quantized after training (Post-Training Quantization), especially at very low bit-widths (e.g., 4-bit or below).
• Key Techniques: Include PACT (Parameterized Clipping Activation) and LSQ (Learned Step Size Quantization) which learn optimal clipping ranges and step sizes.

Post-Training Quantization (PTQ) is a compression technique applied to a pre-trained model without retraining. It uses a small calibration dataset to determine optimal scaling factors and dynamic ranges for weights and activations.

• Process: Involves calibration (analyzing activation ranges), clipping, and mapping to integer grids. Uniform PTQ is the most common and hardware-friendly variant.
• Advantage: Fast, requires no labeled data for retraining, and is ideal for rapid deployment.
• Limitation: Accuracy degradation is typically higher than QAT, especially for models with high dynamic ranges or non-uniform activations. Advanced methods like AdaRound improve PTQ results.

Integer-only inference is an execution paradigm where all computations in a quantized neural network are performed using integer arithmetic, eliminating the need for floating-point units.

• Foundation: Enabled by uniform quantization, which maps floating-point values to integers via a linear transformation: Q = round(R / S) + Z, where S is a scaling factor and Z is a zero-point.
• Hardware Benefit: Leverages efficient integer ALUs prevalent in edge processors, NPUs, and microcontrollers, leading to significant speed and power gains.
• Challenge: Requires careful handling of operations like batch normalization and residual additions to maintain integer-only data flow.

Mixed-precision quantization assigns different numerical bit-widths to different parts of a neural network (e.g., layers, channels, or individual weights) based on their sensitivity to quantization error.

• Principle: Not all layers contribute equally to final accuracy. Sensitive layers (e.g., first and last) may use 8-bit precision, while less sensitive internal layers use 4-bit.
• Optimization: The bit-width allocation is often determined via sensitivity analysis or automated search to find the optimal accuracy-efficiency Pareto frontier.
• Outcome: Achieves a better compression ratio and lower latency than uniform bit-width assignment for a given accuracy target.

In uniform quantization, the scaling factor (or step size) and zero-point are the critical parameters that define the linear mapping between floating-point and integer domains.

• Scaling Factor (S): Determines the resolution of the quantization grid. Calculated as S = (R_max - R_min) / (Q_max - Q_min).
• Zero-Point (Z): An integer value that ensures that a real zero is exactly representable in the quantized space, crucial for avoiding bias in operations like padding. Calculated as Z = Q_min - round(R_min / S).
• Role: These parameters are stored per-tensor (layer-wise) or per-channel (channel-wise scaling) and are used during dequantization: R = S * (Q - Z).