Per-Tensor Quantization

The defining characteristic of per-tensor quantization is the use of one scale factor and one zero-point for an entire tensor. This is in contrast to finer-grained methods like per-channel quantization. For a weight tensor W of shape [O, I], all O * I elements share the same quantization parameters. This simplifies the dequantization step, as the same formula float_value = scale * (int_value - zero_point) applies uniformly.

This scheme offers significant implementation advantages:

• Kernel Optimization: Hardware and software kernels (e.g., for INT8 matrix multiplication) are simpler to write and optimize because the scaling logic is consistent across the entire operation.
• Reduced Metadata: Storing only one scale and zero-point per tensor minimizes the memory overhead for quantization parameters.
• Efficient Dequantization: Output tensors from integer operations can be rescaled to floating-point in a single, vectorized step, reducing post-processing latency.

The primary trade-off is between simplicity and representational fidelity. Using one set of parameters for a large tensor can lead to higher quantization error if the tensor's value distribution is wide or non-uniform. Outliers in the data force the scale factor to cover a large range, reducing the effective precision for the more densely populated central values. This makes per-tensor quantization generally less accurate than per-channel for weight tensors, where channel-wise distributions often vary significantly.

Per-tensor quantization is most commonly and effectively applied to activation tensors (the outputs of layers). During inference, activations are dynamic and their range can be data-dependent. Static quantization schemes determine a single, fixed scale/zero-point for activations using a calibration dataset. While dynamic quantization computes these parameters on-the-fly per inference batch, it still typically applies them per-tensor. This is acceptable because activation distributions across channels within a layer are often more uniform than weight distributions.

Due to its simplicity, per-tensor quantization enjoys universal support:

• Hardware: Integer Arithmetic Logic Units (ALUs) in CPUs (e.g., VNNI), GPUs, and NPUs are designed around this paradigm.
• Frameworks: It is the default or highly optimized path in runtimes like TensorRT, TensorFlow Lite (TFLite), PyTorch Mobile, and ONNX Runtime. Many legacy kernels and acceleration libraries were first built for per-tensor INT8 operations.

Understanding the key differentiator:

• Per-Tensor: One [scale, zero_point] pair for the entire [O, I] weight matrix. Simpler, potentially lower accuracy.
• Per-Channel: One [scale, zero_point] pair for each output channel O. Accounts for per-channel variation, typically yielding higher accuracy for weights but requiring more complex kernels that apply a different scale per channel during dequantization. Per-channel is now standard for weight quantization in frameworks like TFLite and PyTorch for convolutional and linear layers.

The choice of per-tensor granularity is a fundamental engineering trade-off:

• Implementation Simplicity: A single scale and zero-point per tensor drastically reduces metadata overhead and simplifies the arithmetic required for quantized operations, leading to straightforward, optimized kernels.
• Accuracy Limitation: Because one set of parameters must cover the entire range of values in a tensor, outliers can cause significant quantization error. If a weight tensor has channels with vastly different ranges, per-tensor quantization must use a scale large enough to cover all values, resulting in poor resolution for the majority of values.
• Contrast with Per-Channel: For convolutional or linear weight tensors, per-channel quantization uses a unique scale per output channel, often preserving accuracy better but requiring more complex hardware support and kernel implementation.

Determining the optimal per-tensor scale and zero-point is a critical calibration step in static quantization:

• Data Range Collection: A small, representative calibration dataset is passed through the model. Observers track the minimium and maximum floating-point values (or moving averages) encountered for each target activation tensor.
• Scheme Selection: The calibration algorithm chooses between symmetric (range centered on zero) or asymmetric quantization based on the observed distribution. Asymmetric is more expressive but requires handling the zero-point.
• Parameter Calculation: The scale is computed as (float_max - float_min) / (quant_max - quant_min). The zero-point is calculated to map the real zero into the integer grid. These values are then frozen into the model for inference.

A more granular scheme than per-tensor, where a unique set of quantization parameters (scale and zero-point) is applied to each output channel of a convolutional or linear layer's weight tensor. This accounts for variation in weight distributions across channels, typically preserving higher accuracy but requiring more parameter storage and slightly more complex computation.

• Key Difference: Per-tensor uses one scale/zero-point for the entire tensor; per-channel uses one per channel.
• Typical Use: Often applied to weight tensors in convolutional neural networks (CNNs).
• Hardware Support: May require specialized kernel implementations for optimal performance.

The two fundamental parameters that define the linear mapping between floating-point and integer values.

• Scale (S): A floating-point multiplier. Defines the step size between integer values in the original float range. Calculated as S = (float_max - float_min) / (quant_max - quant_min).
• Zero-Point (Z): An integer value. Represents which quantized integer corresponds to the real value zero in the float domain. Crucial for asymmetric quantization to handle tensors whose values are not centered on zero (e.g., ReLU activations).

In per-tensor quantization, a single (S, Z) pair is determined for the entire tensor.

Two schemes defining how the quantization range is aligned with the data distribution.

• Symmetric Quantization: The quantized range is symmetric around zero. The zero-point is fixed at 0. This simplifies the arithmetic (no zero-point offset needed in some operations) but can be inefficient if the tensor's min/max values are not symmetric (e.g., after a ReLU activation).
• Asymmetric Quantization: The quantized range maps precisely to the observed min/max of the tensor data. Uses a non-zero zero-point. This utilizes the full integer range more efficiently for asymmetric distributions, reducing quantization error, but adds an extra offset term to calculations.

Per-tensor quantization can be implemented using either scheme.

A post-training quantization (PTQ) method where the quantization parameters for activations are determined statically before inference using a calibration dataset. This is the most common context for per-tensor quantization.

Process:

1. Feed calibration data through the model.
2. Observe the range (min/max) of activations in each tensor.
3. Calculate fixed scale and zero-point values (per-tensor or per-channel).
4. Freeze these parameters into the quantized model.

Advantage: Eliminates runtime overhead of calculating activation ranges. Enables full graph optimization and kernel fusion. Per-tensor activation quantization is a hallmark of static PTQ.

The primary execution mode enabled by per-tensor quantization, where weights and activations are represented as 8-bit integers. The core computation (e.g., matrix multiplication) is performed using integer arithmetic, which is significantly faster and more energy-efficient than floating-point on most hardware.

How Per-Tensor Enables It:

• The per-tensor scale and zero-point parameters define the linear transformation for the entire tensor.
• A quantized matrix multiply (e.g., for a linear layer) can be expressed as integer operations followed by a re-scaling using the per-tensor parameters of the inputs, weights, and output.
• Frameworks like TensorRT and TFLite convert models with per-tensor (or per-channel) parameters into highly optimized INT8 execution engines.

A small, representative set of unlabeled data (typically 100-500 samples) used to determine the optimal quantization parameters in static post-training quantization. For per-tensor quantization, the calibration process observes the dynamic range of each activation tensor across these samples.

Common Calibration Methods:

• Min/Max: Uses the absolute min and max values observed. Simple but sensitive to outliers.
• Entropy / KL Divergence: Selects a range that minimizes the information loss between the original and quantized distributions. Often more accurate.
• Percentile (e.g., 99.99%): Uses a percentile threshold to exclude outliers, providing a more robust range estimate.

The output of calibration is the fixed scale and zero-point for each tensor.