8-Bit Fixed-Point Quantization

• 8-bit fixed-point quantization is a method that represents neural network parameters using 8-bit integers with a fixed binary-point scaling to approximate 32-bit floating-point values.
• It reduces memory usage and accelerates computation through hardware-friendly techniques like bit-shifting and per-layer calibration, achieving near-baseline performance.
• Approaches include post-training calibration, quantization-aware training, and end-to-end integer-only processing, balancing efficiency and precision for diverse applications.

8-bit fixed-point quantization is a hardware-oriented approximation method for representing, storing, and computing neural network parameters and activations using 8-bit integer types with fixed binary-point scaling. Its principal objectives are to reduce memory usage, accelerate computation on digital hardware, and lower energy consumption, while closely preserving the accuracy of the original full-precision (typically 32-bit floating-point) models. Approaches to 8-bit fixed-point quantization span the entire model lifecycle—from post-training quantization and calibration to quantization-aware training (QAT), with recent developments supporting end-to-end integer-only inference and even training. This article overviews the mathematical foundation, design choices, analysis of trade-offs, algorithmic implementations, use in training, and empirical performance of 8-bit fixed-point quantization, drawing on state-of-the-art methodologies from the recent literature.

1. Mathematical Foundation and Scaling Mechanisms

The canonical form of 8-bit fixed-point quantization employs either a uniform symmetric or affine (asymmetric) quantizer. For a real-valued tensor $x$, quantization is parameterized by a scaling factor $s$ (and optionally zero-point $z$):

• Symmetric quantization: $z=0$; used when tensors are zero-centered.
• Affine quantization: allows $z\neq0$ to ensure zero is representable.

General quantization and dequantization are: $$q = \mathrm{clip}\left(\mathrm{round}\left(\frac{x}{s}\right) + z,\, n,\, p\right), \qquad x \approx s \cdot (q - z)$$ where $n=-2^{b-1}$, $p=2^{b-1}-1$ for signed 8-bit ($b=8$).

Calibration of $s$ and $s$0 is either data-driven (from tensor min/max, percentile, or KL divergence minimization) or analytically derived. Fixed-point networks further constrain $s$1 to powers-of-two to enable implementation as bit-shifts [$s$2, $s$3 integer; e.g., TQT in (Jain et al., 2019)].

The internal representation $s$4 divides the total bitwidth into $s$5 integer bits (including sign) and $s$6 fractional bits: $s$7 with $s$8 recovered as $s$9.

2. Post-Training Quantization, Calibration, and Fine-Tuning

Post-training quantization (PTQ) refers to converting a pretrained floating-point network to fixed-point without retraining, often with per-layer or per-channel quantizer calibration:

• Scale and zero-point determination: Generally by scanning calibration data to find $z$0, $z$1, constraining outliers (e.g., by minimizing KL divergence of the quantized distribution relative to the full-precision) (Bhandare et al., 2019).
• Layer-wise optimization: Some methods (e.g., OptSearchCNN (Goyal et al., 2021)) search for the minimal bitwidth and optimal binary-point per layer that does not degrade accuracy beyond a specified threshold.
• Non-uniform quantizer codebooks: For weight quantization in compression, multi-regime or non-linear quantizers may be deployed without lookup tables, as in group-wise nonlinear quantization with memory-free codebooks for image compression (Sun et al., 2020).
• Model footprint and cost: Uniform 8-bit quantization delivers $z$2 memory and bandwidth savings, while per-layer optimization can further reduce the bit-multiply cost by $z$3 without loss of accuracy (Goyal et al., 2021).

Empirical results show that 8-bit PTQ, when combined with careful calibration, achieves near-baseline performance even on challenging models and tasks (e.g., BLEU drop $z$4 on Transformer NMT (Bhandare et al., 2019), top-1 accuracy drop $z$5 on multiple image classification models).

3. Quantization-Aware Training and Gradient Flows

Quantization-aware training (QAT) improves robustness to quantization artifacts by exposing the model to quantization noise during training, typically via “fake quantization” or differentiable surrogates:

• Straight-through estimator (STE): The non-differentiability introduced by the integer quantization operation is bypassed in backpropagation by overriding the gradient ($z$6) (Jain et al., 2019, Sun et al., 2021, Dai et al., 2024).
• Learned quantization parameters: Thresholds (clipping bounds), scale, or even the integer/fractional bit partition can be directly optimized during training as parameters (e.g., TQT optimizes binary-point logarithms; QFX learns integer-bitwidth per layer (Jain et al., 2019, Dai et al., 2024)).
• Wavelet and multiscale techniques: Multiscale decomposition (e.g., via DWT/IDWT) allows for diverse quantized representations across bitwidths, enabling hot-swappable QAT models supporting $z$7 bits with minimal loss (Sun et al., 2021).
• Losses and regularization: QAT may incorporate regularizers to encourage alignment with quantization levels (e.g., squashed-weight distribution via $z$8, absolute-cosine regularization) and address the distribution of weights for efficient integer mapping (Macha et al., 2023, Zeng et al., 2022).

Empirical findings indicate that QAT (e.g., TQT, F8Net, “One for All” QAT) recovers or even exceeds FP32 accuracy on standard benchmarks (e.g., ResNet, MobileNet ImageNet), and enables extreme bitwidth flexibility, with graceful degradation at ultralow precision (Jain et al., 2019, Sun et al., 2021, Jin et al., 2022).

4. Unified 8-Bit Integer Training and Error Budget Management

End-to-end integer-only training, as exemplified by WAGEUBN (Yang et al., 2019) and the per-tensor optimal quantization of backpropagation (Sakr et al., 2018), requires quantization of all data paths:

• All tensors quantized: Weights, activations, errors, gradients, parameter updates, BatchNorm statistics, and optimizer variables all reside in quantized fixed-point representations.
• Specialized quantizers: Distinct mappings (direct, constant, shift quantization) are used to meet differing dynamic range/resolution demands of various tensor types.
• Error sensitivity: Critical points—such as the error signal between Conv and BatchNorm—require enhanced schemes (e.g., “FlagSQ” 8-bit with dynamic scaling and extra flag-bit) to prevent non-convergence from underflow/clipping.
• Balanced noise assignment: Analytical methods (e.g., EFQN, gradient clipping, bias, and backprop noise constraints) allow layer-wise bitwidth assignment while matching FP32 convergence and mitigating accuracy loss (Sakr et al., 2018).
• Optimized integer accumulators: Strategies such as two-tier accumulator-buffers optimize utilization of hardware SIMD pipeline, even under the aggressive 8%%%%27$s$28%%%%16 (or even 8$z=0$18) multiplication regimes (Macha et al., 2023).

Quantitative results confirm that full 8-bit integer training with rigorous error and optimizer quantization leads to a mere $z=0$2–$z=0$3 drop in top-1 accuracy, but yields $z=0$4 memory savings, and up to $z=0$5 circuit area and power savings compared to FP32 baselines (Yang et al., 2019, Sakr et al., 2018).

5. Hardware-Aware Implementation and Graph Transformations

8-bit fixed-point quantization is engineered for hardware efficiency:

• Bit-shifts over floating-point scalings: Power-of-two or dyadic scale factors permit replacing multiplications with fast bit-shifts in digital logic (Jain et al., 2019, Dai et al., 2024).
• Graph rewrites: Quantization nodes and scale/bias folding (e.g., folding BatchNorm into conv weights, integrating quantizer into substructures) eliminate floating-point operations (Jain et al., 2019, Gao et al., 2019, Dai et al., 2024).
• Integer-only GEMM and accumulators: End-to-end processing including convolution, matmuls, normalization, and even LSTM gate computations, maintain 8-bit (or lower) integer constraints throughout (Bhandare et al., 2019, Li et al., 2021, Jin et al., 2022).
• Parallelism and memory footprint: Inference on CPUs with VNNI/AVX, ARM NEON, or FPGAs exploits integer parallelism for $z=0$6–$z=0$7 throughput gains and $z=0$8 smaller model sizes (Bhandare et al., 2019, Macha et al., 2023).
• Multiplier-free quantization: Schemes such as "K-hot" quantization express weights as bit-shift-and-add operations, enabling DSP-free arithmetic on FPGA and ASICs with negligible accuracy cost (Dai et al., 2024).
• Integrated threshold logic: Particularly for embedded vision (e.g., IFQ-Net), quantizer thresholds are derived as pure integer operations, enabling entirely float-free inference including batch normalization and activation functions (Gao et al., 2019).

6. Empirical Performance and Trade-Offs

A broad set of architectures and tasks, ranging from ImageNet ResNets/MobileNets to Transformer NMT and streaming KWS, have been assessed under 8-bit fixed-point quantization:

Network	FP32 Acc	8-bit QAT/PTQ Acc	ΔAcc (abs)	Context
ResNet-50 (TQT)	75.2 %	75.4 %	+0.2%	Symmetric, power-of-2, per-tensor TQT (Jain et al., 2019)
MobileNetV2 (TQT)	70.1 %	71.8 %	+1.7%	TQT recovers full gap, PTQ fails (0.3%)
ResNet-18 (WAGEUBN)	68.7 %	64.8 %	-3.9%	Full INT8 train, sensitive E₂ quant (Yang et al., 2019)
ResNet-50 (F8Net)	78.5 %	78.1 %	-0.4%	QAT, zero INT32 multiplies (Jin et al., 2022)
Transformer NMT	BLEU 27.7	BLEU 27.3	-0.4	<0.5 BLEU drop, 1.5$z=0$9 speedup (Bhandare et al., 2019)

Performance drop is typically $z\neq0$0 when using appropriate per-layer or per-channel scaling, QAT, and/or optimized quantizer assignments. More aggressive quantization (e.g., group-wise, sub-8-bit, integer-only training) increases the performance drop but confers greater efficiency.

7. Advanced Topics: Hot-Swap, Dynamic Format, and Sub-8-Bit Extensions

Recent research extends 8-bit fixed-point quantization in several advanced directions:

• Bit-width hot-swapping: Dynamically adjustable per-layer bitwidths with a single model (e.g., "One Model for All Quantization" employs DWT-based weight scaling and successfully switches from 8 bits down to 1 bit at inference without retraining, maintaining near-optimal accuracy at 8 bits and graceful degradation below (Sun et al., 2021)).
• Layer-wise format assignment: Automatic assignment of fractional/integer bits per layer (Qm.n) based on statistical analysis and error minimization maintains quantization error under 1% (Jin et al., 2022).
• Sub-8-bit and non-uniform quantization: Memory-free codebooks, non-linear scaling, or tanh-squashed regularization permit further reductions to $z\neq0$1–$z\neq0$2 bits with marked efficiency gains and limited accuracy loss, particularly in KWS and edge vision tasks (Zeng et al., 2022, Macha et al., 2023, Sun et al., 2020).
• Integer-only batchnorm, error gradients, and optimizers: End-to-end fixed-point enables deployment on integer-only and multiplier-free digital logic (e.g., quantized momentum and batch-norm (Yang et al., 2019, Macha et al., 2023)).

Ongoing research addresses the tension between range and precision, trade-offs in error quantization, and the challenges of generalizing the methodology to training at ultra-low bitwidths and to wider class of neural architectures.