Quantization Bitwidth

The bitwidth determines the number of discrete integer values available to represent a continuous range of floating-point numbers. This is calculated as 2^n, where n is the bitwidth. For example:

• 1-bit (Binary): 2^1 = 2 levels (e.g., -1, +1).
• 4-bit: 2^4 = 16 levels.
• 8-bit (INT8): 2^8 = 256 levels.
• 16-bit (FP16/BF16): 65,536 levels (though formats like BF16 use bits differently for exponent/mantissa). Fewer levels increase quantization error, as more of the original distribution must be mapped to the same integer value.

Bitwidth directly dictates the model's memory footprint and the bandwidth required to load weights and activations. Compression is typically linear relative to full 32-bit precision (FP32).

• 8-bit (INT8): Reduces memory by ~75% (4x compression). A 1GB FP32 model becomes ~250MB.
• 4-bit: Reduces memory by ~87.5% (8x compression). The same model becomes ~125MB.
• 2-bit: Achieves ~93.75% reduction (16x compression). This compression is critical for deploying large models on edge devices with limited RAM and for reducing I/O bottlenecks during inference.

Lower bitwidth integer arithmetic is significantly faster and more energy-efficient than floating-point math on most hardware. Key hardware support includes:

• INT8/INT4 on GPUs: NVIDIA Tensor Cores (Ampere+), AMD Matrix Cores.
• CPU Vector Instructions: AVX-512 VNNI, ARM NEON dot product.
• NPU/TPU Native Ops: Dedicated silicon for low-precision matrix multiplication. Operations per second (OPS) often scale inversely with bitwidth; 8-bit ops can be 2-4x faster than FP16 on supported hardware. However, 4-bit and below may require specialized kernels or dequantization to higher precision during computation.

Model accuracy typically degrades non-linearly as bitwidth decreases. The relationship forms a Pareto frontier where each bit reduction yields diminishing returns in compression but increasing accuracy cost.

• 16-bit to 8-bit: Often negligible loss (<1% for many models) with proper calibration.
• 8-bit to 4-bit: Moderate to significant loss (1-5%+), requiring techniques like Mixed-Precision Quantization or Quantization-Aware Training (QAT).
• Below 4-bit: Often requires advanced methods like GPTQ, AWQ, or fine-grained per-channel quantization to maintain usability. Quantization Sensitivity Analysis is used to identify layers where higher precision must be preserved.

Bitwidth interacts with other quantization parameters that define how the bits are used:

• Per-Tensor vs. Per-Channel: Applying one bitwidth to an entire tensor is simpler, but per-channel quantization (different scale/zero-point per output channel) uses the same bitwidth more effectively, often improving accuracy at 4/8-bit.
• Symmetric vs. Asymmetric: Symmetric quantization (range centered on zero) uses the bitwidth to represent values like [-127, 127] in INT8, simplifying computation. Asymmetric quantization uses a zero-point to shift the range (e.g., [0, 255]), better capturing asymmetric data distributions but adding an extra integer addition per operation.

Specific bitwidths have become standard targets due to hardware, tooling, and accuracy trade-offs:

• FP32 (32-bit): Baseline training and high-precision inference.
• BF16/FP16 (16-bit): Training and inference with minimal accuracy loss; standard for GPU tensor cores.
• INT8 (8-bit): The standard for production post-training quantization (PTQ), offering a reliable 4x compression with widely supported hardware acceleration.
• INT4 (4-bit): Frontier for extreme compression, enabling 70B+ parameter models on consumer GPUs (e.g., via GPTQ). Often requires grouped quantization (e.g., 32 weights share a scale).
• INT2/1-bit (Binary): Research frontier for ternary networks (+1, 0, -1) or binary networks, primarily for ultra-low-power edge AI and specialized hardware.

The process of converting floating-point model parameters and operations into integer representations (e.g., INT8, INT4). This enables efficient computation on hardware with native integer arithmetic units, which are faster and more power-efficient than floating-point units. It is the practical outcome of selecting a specific bitwidth.

• Core Mechanism: Maps float values to integers using a scale and zero-point.
• Hardware Target: Essential for deployment on CPUs, DSPs, and NPUs optimized for integer math.

Defines the scope over which a single set of quantization parameters (scale/zero-point) is shared. The choice directly impacts the accuracy/efficiency trade-off for a given bitwidth.

• Per-Tensor: One scale/zero-point per entire tensor. Simple but can have high error.
• Per-Channel: Unique parameters for each output channel of a weight tensor. Accounts for variance, preserving accuracy at the same bitwidth.
• Per-Group/Block: Parameters shared across small blocks of values (e.g., 64 weights). A middle-ground for ultra-low bitwidth (e.g., 4-bit) quantization.

The mathematical method for mapping values from a high-precision to a low-precision range. The scheme determines how the available discrete levels of a given bitwidth are distributed.

• Uniform Quantization: Levels are evenly spaced (constant step size). Simpler for hardware.
• Non-Uniform Quantization: Levels are unevenly spaced, allowing denser clustering where values occur most frequently. Can achieve lower error for the same bitwidth but requires more complex hardware support.
• Symmetric vs. Asymmetric: Defines if the quantized range is centered on zero (symmetric, zero-point=0) or offset (asymmetric). Asymmetric can better capture skewed data distributions.

A strategy that applies different bitwidths to different parts of a model. It recognizes that not all layers have the same sensitivity to precision reduction.

• Objective: Allocate higher bitwidth (e.g., 8-bit) to sensitive layers and lower bitwidth (e.g., 4-bit) to robust layers, optimizing the overall accuracy vs. size/ latency trade-off.
• Implementation: Requires quantization sensitivity analysis to profile layer-wise error contribution.
• Example: A model might use 4-bit for most weights, 8-bit for attention output projections, and 16-bit for layer normalization.

The process of determining optimal quantization parameters (scale, zero-point) for a given bitwidth and scheme. It is a critical step in Post-Training Quantization (PTQ).

• Process: Run a small, representative calibration dataset through the model to observe the statistical range (min/max) of activations.
• Algorithms: Simple min-max, entropy minimization, or percentile-based methods to clip outliers.
• Outcome: Produces the constants needed to statically quantize the model for efficient integer inference.

The numerical discrepancy introduced when reducing precision. For a fixed bitwidth, managing this error is the central challenge.

• Sources: Rounding error from mapping to integers and clipping error from values outside the representable range.
• Propagation: Error accumulates through network layers, potentially degrading task accuracy.
• Mitigation: Techniques like fine-grained granularity, advanced calibration, and Quantization-Aware Training (QAT) are used to minimize error for a target bitwidth.