1 Introduction↩︎

The rapid growth of Internet of Things (IoT) devices, mobile systems, and embedded sensors has enabled large-scale distributed intelligence at the network edge. While these devices generate vast amounts of data, transmitting raw data to centralized servers for model training raises serious concerns related to privacy, bandwidth, latency, and energy consumption. Federated Learning (FL) [1] addresses these challenges by enabling multiple clients to collaboratively train a shared global model without sharing local data. By keeping data localized, FL reduces communication overhead and preserves privacy, making it well suited for edge and mobile environments. Despite its advantages, deploying FL in real-world settings remains challenging due to device heterogeneity, limited computational resources, and high communication costs. In large-scale FL systems, the exchange of model updates between clients and the server often dominates training time and energy consumption, leading to latency, unstable convergence, and reduced participation of resource-constrained devices [2]. Consequently, improving communication efficiency is a central challenge in scalable FL.

To address this issue, numerous communication-efficient techniques have been proposed, including client scheduling, sparsification, pruning, knowledge distillation, low-rank approximation, and quantization [3]–[5]. However, many of these methods introduce additional overhead or complexity. For example, pruning requires transmitting masks, knowledge distillation demands additional training pipelines [6], and sparsification may degrade convergence under non-IID data. In contrast, quantization consistently reduces both communication and computation cost by lowering numerical precision, making it particularly attractive for resource-constrained and energy-limited FL deployments.

Model quantization compresses model parameters, gradients, or activations into low-bit representations, enabling efficient communication and computation on edge devices. While quantization improves efficiency, it also introduces challenges such as accuracy degradation, convergence instability, and sensitivity to data heterogeneity [7]. Understanding these trade-offs is therefore critical for designing robust and scalable FL systems.

1.1 Comparison with Related Survey and Motivation↩︎

A large number of surveys have studied FL from diverse perspectives, including FL fundamentals [8]–[16], mobile and edge FL [17]–[20], communication efficiency [10], [21]–[24], heterogeneity [25], [26], privacy and security [27]–[30], and green FL [5]. As summarized in Table 1, it is evident that existing surveys on FL primarily concentrate on isolated challenges such as privacy and security, statistical and system heterogeneity, communication efficiency, computation efficiency, and energy efficiency. These surveys typically treat quantization as a subcomponent of communication efficiency or model compression. However, no existing survey provides a dedicated and systematic review of quantization techniques in FL. Prior works do not analyze quantization as a standalone design dimension, nor do they provide a comprehensive taxonomy of quantization strategies and their trade-offs in terms of accuracy, convergence, communication cost, and system heterogeneity. In contrast, this paper is, to the best of our knowledge, the first survey exclusively focused on quantization in FL, offering a unified and comparative synthesis across algorithmic, system, and security dimensions.

4pt

As evidenced by the growing number of recent studies on quantized FL, there is a clear need for a systematic review that consolidates existing knowledge, identifies limitations, and outlines future research directions. This motivates the present PRISMA-based systematic literature review. Furthermore, the number of publications related to quantization in FL for improving effectiveness and efficiency has increased considerably in recent years. This growing body of work highlights the need for a systematic review that synthesizes existing knowledge, analyzes methodological strengths and limitations, and outlines future research opportunities. Therefore, this paper proposes a systematic literature review (SLR) focused on examining quantization techniques within the scope of enhancing effectiveness and efficiency in FL.

This systematic review is designed to address the following research questions (RQs): RQ1: How do different quantization methods impact the performance, efficiency, and effectiveness of FL systems? RQ2: What challenges and limitations characterize existing quantization approaches in FL? RQ3: What research gaps persist across algorithmic, statistical, and system dimensions of quantized FL? and RQ4: What emerging trends can guide the design of scalable, robust, and privacy-aware quantized FL systems? By systematically addressing these research questions, this survey provides the first systematic synthesis of quantization methods in FL, offering a new perspective that bridges communication efficiency, computation cost, and model performance. This work thereby lays a foundation for developing scalable, communication-efficient, and resource-aware FL systems in future research and industrial applications.

1.2 Contributions↩︎

In this survey, we present a PRISMA-based systematic review of model quantization in FL. Specifically, we synthesize and critically analyze existing research to evaluate the impact, challenges, gaps, and future directions of quantization techniques within FL frameworks. This work gives a novel taxonomy and serves as a structured guide for researchers and practitioners aiming to understand and apply quantization methods to improve communication efficiency, model performance, and scalability in FL. To the best of our knowledge, this article constitutes the first systematic and holistic review focusing exclusively on model quantization in FL. The key contributions are summarized as follows:

• Comprehensive synthesis of quantization techniques in FL (RQ1): We systematically categorize and analyze quantization methods from an FL-centric perspective to provide design dimensions and evaluate their impact on six different system-level properties, such as system heterogeneity, communication efficiency, non-iid robustness, aggregation consistency, privacy/security integration, and hardware-energy co-optimization to introduce a novel taxonomy.

• Critical evaluation of limitations and trade-offs (RQ2): We identify and assess the primary challenges faced by existing quantized FL approaches, including communication overhead, system heterogeneity, scalability, aggregation consistency, and convergence instability under non-IID data, and privacy–utility trade-offs.

• Identification of research gaps and methodological deficiencies (RQ3): Through systematic mapping along FL-specific dimensions, we uncover critical gaps in the literature, including the lack of standardized benchmarks, limited evaluation under realistic non-IID and heterogeneous settings, and insufficient exploration of adaptive quantization strategies co-designed with aggregation, scheduling, and system constraints.

• Exploration of emerging trends and future research directions (RQ4): We highlight promising directions for advancing quantized FL, including adaptive precision mechanisms, joint design with aggregation and scheduling policies, integration with privacy-preserving techniques, and hardware- and energy-aware optimization for mobile, IoT, and edge platforms.

1.3 Structure of the Paper↩︎

The scope and organization of the survey is shown in Figure 1. Section 2 outlines the PRISMA-based review methodology. Section 3 categorizes and analyzes quantization techniques in FL, addressing RQ1. Section 4 discusses existing challenges and trade-offs (RQ2), while Section 5 highlights key research gaps (RQ3). Section 6 presents promising future research directions (RQ4). Finally, Sections 7 and 8 provide an integrated discussion and concluding remarks.

2 Research Methodology↩︎

2.1 Objective↩︎

The proposed work is a systematic literature review (SLR) using PRISMA (Preferred Reporting Items for Systematic Reviews) [35]. Figure 2 shows a complete flowchart of the proposed methodology. In the first step of SLR, research questions are defined, and then relevant articles are extracted using appropriate search strings. Selected articles are then filtered based on inclusion-exclusion criteria to remove irrelevant studies, and then the remaining articles are analyzed in detail.

2.2 Article Search Process↩︎

We consider standard databases with a custom range of year 2019-2026. Advanced options for different databases are also used to extract all the relevant articles. The search strings, we used are depicted in Table 2 along with an initial number of studies retrieved in each database. The search starts with the title, abstract, and keywords in each of the mentioned databases. Abstracts are analyzed, and irrelevant articles are discarded at this stage. The overview of the search process to extract articles is depicted in Figure 3.

2.3 Inclusion and Exclusion Criteria↩︎

The search process results in the extraction of articles, including irrelevant articles. To remove the irrelevant articles, an inclusion and exclusion criterion is defined. This procedure filters the articles to only those that include specific types of studies relevant to our problem. The inclusion and exclusion criteria are defined to ensure relevance and quality of the selected studies. Specifically, we include peer-reviewed articles written in English that investigate quantization as a primary research focus within FL frameworks, with particular attention to its role in improving communication-computation and energy efficiency or system performance. Included articles are quantization-related publications in flagship conferences or reputable journals. Figure 4 shows the number of articles extracted at each stage of the process.

3 Quantization in FL: State of the Art↩︎

Quantization plays a pivotal role in FL by reducing the communication overhead associated with transmitting model updates between clients and the central server. In large-scale FL systems, the size of model parameters or gradients can be prohibitively large, leading to communication bottlenecks, energy inefficiency, and slow convergence. Quantization mitigates these challenges while maintaining model accuracy and convergence stability [4], [36], [37]. In this section, we discuss quantization methods that are not intended to be mutually exclusive. Instead, they represent complementary design dimensions along which quantization can be applied in FL systems. Specifically, these dimensions include (i) the training stage at which quantization is introduced (post-training quantization versus quantization-aware training), (ii) the object being quantized (model parameters, gradients, or model updates), (iii) the encoding structure (scalar versus vector, uniform vs non-uniform), and (iv) the precision strategy (fixed-bit, variable-bit, or adaptive precision) as shown in Figure 5. Each dimension corresponds to a distinct mechanism that affects optimization behavior, error propagation, communication efficiency, and convergence in different ways. Consequently, methods drawn from different dimensions may be combined within a single FL algorithm, while still constituting fundamentally different quantization approaches. These dimensions capture where quantization is applied in the learning pipeline (training stage), what is quantized (object), how values are encoded (encoding structure), and with what precision control strategy (precision). Together, they define the fundamental algorithmic choices underlying quantized FL methods and serve as the basis for the taxonomy presented in this work to address RQ1.

In addition, the diagram highlights system-level properties—including client heterogeneity (CH), aggregation consistency (AC), communication scheduling adaptation (CSA), robustness to non-IID data (NIR), privacy and security integration (PI), and hardware/energy co-optimization (HE), that influence the practical deployment of quantized FL systems.

3.0.0.1 Post-Training Quantization (PTQ)

PTQ is one of the most practical and widely adopted model compression techniques for deploying deep neural networks on resource-constrained edge devices. PTQ applies quantization after model training, eliminating the need for retraining or fine-tuning [38], [39]. PTQ is computationally efficient but may cause minor accuracy loss, especially under non-IID data [40], [41]. It converts full-precision (e.g., 32-bit floating-point) parameters and activations into low-bit representations (e.g., 8-bit integers) to reduce model size, memory footprint, and inference latency [38], [40]. PTQ techniques rely on calibration or statistical approximations to estimate quantization parameters (scale and zero-point) that best represent the original data distribution. The main advantage of PTQ is its simplicity and compatibility with existing pretrained models, making it ideal for large-scale deployment and FL environments where retraining is costly or impractical. However, PTQ typically incurs a slight accuracy drop compared to QAT, especially for very low bit-widths or non-uniform data distributions. In the context of FL, PTQ provides a lightweight yet effective approach for communication-efficient model sharing. Clients can quantize their local model updates before transmitting them to the central server, thereby reducing communication bandwidth and energy consumption [39], [41].

3.0.0.2 Dynamic Range Quantization:

Dynamic Range Quantization (DRQ) is a post-training uniform scalar quantization scheme in which quantization scales are determined from the observed dynamic range (min–max statistics) of model parameters, while activations remain in floating-point precision. Unlike full integer quantization, where both weights and activations are quantized, DRQ performs quantization only on static model parameters and dynamically rescales activations during inference. This approach provides a favorable balance between computational efficiency and model accuracy [40], [42]. The quantization process involves computing the dynamic range of each tensor, using the observed minimum and maximum values, and mapping them linearly into a lower precision format. The quantized integer values are dequantized during computation to maintain compatibility with mixed-precision hardware. Mathematically, given a weight tensor \(W\), the quantization function can be expressed as \(W_q = \mathrm{round}\!\left(\frac{W}{s}\right), \quad s = \frac{\max(W) - \min(W)}{2^{b} - 1},\) where \(b\) denotes the bit-width (e.g., \(b=8\)), and \(s\) is the scaling factor or quantization step size. The reconstructed tensor is obtained as \(\hat{W} = s \times W_q\), which approximates the original full-precision weights. By quantizing only the weights and maintaining floating-point activations, DRQ minimizes model size and computation costs while avoiding accuracy degradation associated with fully quantized arithmetic. It provides up to \(4\times\) reduction in model storage and \(2\)-\(3\times\) faster inference with negligible accuracy loss [38]. Moreover, DRQ requires no retraining, making it particularly effective for rapid model deployment.

In the context of FL, DRQ is especially advantageous because it reduces the communication cost between clients and the central server. Quantizing weights before transmission reduces bandwidth usage and accelerates model aggregation without compromising accuracy [39], [41]. Since activations remain in floating-point form, local computation remains stable, which is crucial for heterogeneous devices with varying hardware capabilities. Modern frameworks such as TensorFlow Lite and PyTorch Mobile adopt dynamic range quantization as a default quantization method for edge deployment due to its simplicity and hardware compatibility [43]. Overall, DRQ offers a practical balance between model efficiency, communication reduction, and performance preservation. However, when activation distributions differ significantly across federated clients, DRQ may exhibit minor accuracy loss, suggesting the need for adaptive quantization strategies in future FL implementations.

Table 3 summarizes key approaches to DRQ used in neural network compression and FL. While standard DRQ achieves memory and latency efficiency by quantizing only weights, adaptive and hardware-aware variants extend its flexibility to heterogeneous FL environments and edge devices, balancing accuracy with communication and computation efficiency.

3.0.0.3 Weight Clipping and Calibration

Weight clipping and calibration are auxiliary mechanisms that operate within the training-stage and quantized-object dimensions, primarily supporting uniform scalar PTQ by stabilizing dynamic range and reducing quantization error by constraining and rescaling the numerical range of model parameters and activations. These methods are particularly crucial when quantizing models for deployment on resource-constrained edge devices or in FL environments, where device heterogeneity and non-IID data distributions can cause severe quantization distortion. Weight clipping limits the dynamic range of weights by restricting them within a pre-defined threshold. Outlier values that fall outside this range are clipped, effectively reducing the quantization range and enabling finer granularity for frequently occurring small weights. The clipping process can be expressed as: \[w_c = \mathrm{clip}(w, -\alpha, \alpha) = \begin{cases} -\alpha, & \text{if } w < -\alpha, \\ w, & \text{if } -\alpha \leq w \leq \alpha, \\ \alpha, & \text{if } w > \alpha, \end{cases}\] where \(\alpha\) is the clipping threshold chosen to balance between preserving information and minimizing quantization noise. Excessively large \(\alpha\) values waste quantization levels on rare outliers, while overly small \(\alpha\) values may remove significant signal information. To find an optimal \(\alpha\), calibration techniques such as Kullback–Leibler Divergence (KLD) minimization [45], [46] or Mean Squared Error (MSE) optimization [47] are applied. These methods estimate the threshold \(\alpha\) that minimizes the divergence between the full-precision and quantized distributions. Formally, the optimal threshold is computed as \(\alpha^* = \arg \min_{\alpha} D_{\mathrm{KL}}(P_{\text{float}}(x) \parallel P_{\text{quant}}(x; \alpha))\), where \(P_{\text{float}}\) and \(P_{\text{quant}}\) denote the distributions of the full-precision and quantized values, respectively.

Calibration further refines quantization by determining scale factors and zero-points for each tensor based on representative calibration data. In practice, a small subset of data (typically 5–10% of the training set) is used to estimate activation ranges. Calibration ensures that the quantization parameters reflect real operational data statistics, thereby minimizing activation saturation and quantization error [40], [42]. In the context of FL, weight clipping and calibration play a critical role in stabilizing communication and aggregation. Since each client may have a unique data distribution, applying global quantization thresholds can lead to biased model updates. Weight clipping with adaptive thresholds mitigates this by constraining local updates within consistent dynamic ranges, improving convergence stability. Calibration ensures that each client’s quantized updates align statistically with the global model, reducing aggregation bias. Techniques such as clipped uniform quantization in FL [41] employ layer-wise clipping and calibration to balance communication efficiency with accuracy preservation. Overall, these methods significantly enhance quantized FL performance under heterogeneous and non-IID data conditions.

Table 4 summarizes the key approaches and developments in weight clipping and calibration techniques for neural network quantization and FL. They function as range-control and parameter-estimation mechanisms that improve the robustness of scalar PTQ and QAT schemes. These methods aim to optimize the quantization range by constraining outliers and calibrating scaling factors to minimize quantization error. While fixed threshold and KLD-based calibration techniques provide simple yet effective post-training solutions, adaptive approaches such as MSE-based clipping and PACT introduce learnable or data-driven thresholds for improved precision. In FL contexts, layer-wise clipping and client-specific calibration enhance aggregation stability and reduce communication overhead under non-IID data distributions. Collectively, these methods highlight the evolution from static clipping toward adaptive and federated-aware quantization strategies that balance efficiency, robustness, and accuracy.

3.0.0.4 Quantization-Aware Training (QAT)

QAT incorporates quantization effects directly into the training process to make neural networks robust to quantization noise during deployment. Unlike PTQ, which applies quantization after model training, QAT simulates low-precision arithmetic throughout forward and backward passes so that the model parameters are optimized with quantization constraints in mind [42]. This integration allows QAT models to achieve accuracy levels close to their full-precision counterparts, even at ultra-low bit-widths such as 4-bit or 2-bit. Given a weight tensor \(W\) and quantization function \(Q(\cdot)\), the quantized weight used during training is expressed as \(\tilde{W} = Q(W) = \mathrm{round}\!\left(\frac{W}{s}\right) \times s\), where \(s\) is the scale factor determined per tensor, per-channel, or per-layer. The loss function used for training becomes \(\mathcal{L}_{QAT} = \mathcal{L}_{\text{task}}(f(x; Q(W), Q(a))) + \lambda R(Q(W))\), where \(\mathcal{L}_{\text{task}}\) is the primary task loss, \(Q(a)\) denotes quantized activations, and \(R(Q(W))\) is a regularization term (e.g., for stability or sparsity). Since quantization involves a non-differentiable rounding operation, gradients are approximated using the Straight-Through Estimator (STE) [48]: \(\frac{\partial \mathcal{L}}{\partial W} \approx \frac{\partial \mathcal{L}}{\partial Q(W)}\). This enables backpropagation through discrete quantization functions and ensures effective optimization.

3.0.0.5 Advanced Variants of QAT:

While standard QAT effectively models quantization noise during training, several advanced variants have emerged to enhance adaptability, convergence, and scalability in practical deployments. These methods focus on dynamically learning quantization parameters, improving gradient estimation, or enabling heterogeneous quantization settings in distributed environments such as FL. Differentiable Quantization: Differentiable quantization integrates quantization into the optimization process by relaxing discrete quantization operations into differentiable approximations. Instead of relying solely on the STE, this approach employs continuous surrogates such as the Gumbel-Softmax or sigmoid-based approximations [49], [50]. This allows backpropagation through quantization levels, enabling end-to-end optimization of both weights and quantization thresholds. Differentiable quantization methods achieve smoother convergence and higher accuracy for low-bit quantization, particularly in transformer and vision models. Gradient-Based QAT (Learned Quantization Parameters): In gradient-based QAT, both quantization scales and zero-points are treated as trainable parameters optimized using backpropagation [51], [52]. This eliminates manual calibration and allows layer-wise or channel-wise bit-width adaptation. The gradient updates refine quantization parameters jointly with model weights, significantly improving model performance at extreme bit-widths (e.g., 2–4 bits). This approach forms the foundation for methods such as LSQ and LSQ+ that achieve near-floating-point accuracy without post-training fine-tuning. Adaptive Precision QAT: Adaptive precision QAT dynamically adjusts bit-widths during training or across communication rounds in FL to optimize the trade-off between model accuracy and resource constraints. This technique employs layer sensitivity metrics or reinforcement learning agents to modify quantization levels as training progresses [53], [54]. In federated settings, adaptive QAT enables heterogeneous clients to maintain different quantization precisions based on hardware capabilities or communication bandwidth [16]. This flexibility enhances scalability while maintaining convergence consistency across clients. Federated Hybrid QAT: Federated Hybrid QAT combines QAT with other compression techniques, such as pruning, mixed precision, or weight clustering—to further improve efficiency and robustness under non-IID data distributions. Clients apply QAT locally while the server aggregates models using adaptive precision control [39]. This hybridization helps correct quantization-induced drift and mitigates aggregation bias, allowing models to maintain accuracy even under asynchronous or partial participation scenarios.

Overall, these advanced QAT variants extend traditional quantization-aware training toward differentiable, adaptive, and federated paradigms, enabling deep neural networks to operate efficiently in distributed and resource-constrained environments.

In the context of FL, QAT provides robustness against quantization-induced bias in distributed training. Since clients perform local updates with quantized weights and activations, QAT helps the global model adapt to device-level quantization errors, improving both convergence and accuracy [41], [55]. Federated QAT frameworks, such as QA-FedAvg and QFL, integrate quantization simulation within each client’s local training loop, enabling effective training on heterogeneous devices. Furthermore, combining QAT with mixed-precision or clipping techniques enhances communication efficiency while maintaining near-floating-point performance [16], [39]. By quantizing updates before transmission, bandwidth consumption is significantly reduced. QAT-aware clients compensate for quantization errors during training, maintaining near full-precision accuracy. QAT allows heterogeneous clients (e.g., edge, IoT, or GPU devices) to train using precision levels suited to their computational capabilities. Incorporating bias correction and clipping during QAT reduces drift among client updates, ensuring more stable aggregation. QAT thus serves as a bridge between efficient model compression and accuracy preservation, especially in distributed edge and federated environments. Recent framework, QA-FedAvg [55] extends standard FL algorithms by incorporating QAT into local training. These frameworks differ primarily in how they quantize weights, gradients, or activations, such as QA-FedAvg: Combines QAT with FedAvg using bias correction to account for coarse quantization. This framework demonstrate that QAT not only reduces model size and communication cost but also enhances robustness against client heterogeneity and gradient distortion in non-IID data environments.

In Quantization-Aware FL (QA-FL), clients locally train quantized models using fake quantization operations during both forward and backward passes, as shown in Algorithm 6. Quantization effects are simulated throughout training, and gradients are computed using the Straight-Through Estimator (STE), allowing clients to adapt their model weights to quantized representations. After each local training phase, the quantized updates are transmitted to the server, where aggregation (e.g., weighted averaging) is performed in full or mixed precision. This joint optimization ensures that both local and global models become robust to quantization-induced noise and communication compression. Overall, QAT-based FL frameworks combine quantization robustness with communication efficiency, offering a pathway to deploy deep learning at scale on resource-limited, heterogeneous edge networks.

Table 5 provides a unified comparison of major QAT methods and QAT-based FL frameworks. It consolidates standard approaches such as fake quantization, PACT, and LSQ with advanced variants including differentiable, adaptive, and hybrid precision quantization. The table also summarizes key FL frameworks, such as QA-FedAvg, FedDQ, and FedMixQAT-highlighting how QAT has evolved from basic quantization simulation to adaptive, device-aware, and communication-efficient paradigms. Collectively, these methods demonstrate that QAT not only preserves model accuracy under low-bit regimes but also enhances robustness and scalability in heterogeneous FL environments.

3.0.0.6 Mixed Precision Quantization

Mixed Precision Quantization (MPQ) is an advanced quantization strategy that assigns different bit-widths to different layers, channels, or tensors within a neural network, instead of using a uniform bit-width across the entire model. It can be implemented under either PTQ or QAT without changing the underlying encoding structure. The key idea is to apply higher precision (e.g., 16-bit or 8-bit) to layers or parameters that are more sensitive to quantization noise, while using lower precision (e.g., 4-bit or 2-bit) for less critical layers. This adaptive allocation of bit-widths achieves a better trade-off between model accuracy and computational efficiency compared to fixed uniform quantization [54], [57]–[59]. Formally, let each layer \(l\) in the model be quantized using a distinct bit-width \(b_l\), with the objective of minimizing a global cost function that balances accuracy and resource consumption as \(\min_{\{b_l\}} \mathcal{L}_{\text{task}}(Q(W; \{b_l\})) + \lambda \sum_{l} \mathrm{Cost}(b_l)\), where \(\mathcal{L}_{\text{task}}\) denotes the task-specific loss (e.g., classification loss), \(Q(W; \{b_l\})\) represents the quantized model under bit-width configuration \(\{b_l\}\), and \(\mathrm{Cost}(b_l)\) models hardware or communication cost constraints. The regularization term \(\lambda\) controls the trade-off between efficiency and accuracy. MPQ can be implemented using analytical, reinforcement learning (RL), or differentiable search methods. Analytical approaches rely on sensitivity analysis or Hessian-based metrics [57] to estimate how quantization affects each layer’s loss, while RL-based methods [54] automatically learn optimal bit-width assignments through feedback from performance and latency metrics. More recent differentiable methods, such as AdaQuant and HAQ-V2 [53], integrate quantization into the training process, enabling gradient-based optimization over bit-widths.

In the context of FL, MPQ provides a flexible mechanism for adapting models to heterogeneous client hardware. Clients with powerful GPUs can operate with higher bit-widths, whereas edge devices or IoT clients can use lower precision to reduce computational load and communication cost. This heterogeneous deployment improves the inclusivity and scalability of FL systems. Moreover, adaptive MPQ can dynamically adjust precision across training rounds, improving energy efficiency and communication efficiency without sacrificing global accuracy [39]. While MPQ offers considerable advantages in balancing efficiency and precision, it introduces complexity in optimization and calibration. The need to manage multiple quantization scales and per-layer configurations can increase the implementation burden, particularly in federated environments where synchronization between clients is required. Nonetheless, MPQ remains one of the most promising directions for achieving hardware-aware and communication-efficient FL.

Table 6 summarizes major MPQ methods developed for neural network compression and FL. These approaches dynamically allocate precision across layers or clients to balance accuracy, energy efficiency, and communication cost. While methods such as HAWQ and HAQ employ Hessian-based or reinforcement learning techniques to determine bit-widths, federated extensions like MPQ-FL adapt quantization settings to client hardware heterogeneity. The evolution of MPQ highlights a shift from static, uniform quantization toward adaptive, device-aware, and communication-efficient strategies for large-scale distributed learning.

Quantization in FL can be applied to various entities in the training process, primarily including model parameters, gradients, and activations.

3.0.0.7 Parameter Quantization:

In parameter quantization, the global model parameters are encoded into lower-precision formats before being transmitted to clients. Each weight \(w_i\) is mapped to a discrete value \(Q(w_i)\) according to \(Q(w_i) = \mathrm{round}\!\left(\frac{w_i}{s}\right) \times s\), where \(s\) is the quantization step size, defined as \(s = \frac{w_{\max} - w_{\min}}{2^b - 1}\) for a \(b\)-bit representation [42]. This reduces the model’s memory footprint and communication cost linearly with respect to \(b\) while maintaining the approximate structure of the global model, making it ideal for low-bandwidth or energy-constrained edge devices [4], [60], [61]. In particular, Reisizadeh et al. [4] introduced FedPAQ, which combines periodic averaging with parameter quantization to lower communication cost while maintaining convergence guarantees. Similarly, Shen et al. [60] proposed QFNN, a bit-limited model quantization technique applied directly to network parameters before uplink communication. Jhunjhunwala et al.  [61] extended this idea with AdaQuantFL, adaptively changing quantization bit-widths during training to balance convergence and bandwidth efficiency. More recently, Ni et al.  [62] integrated parameter quantization with energy-aware scheduling, showing significant gains in sustainability for edge devices. Overall, parameter quantization remains the backbone of FL compression methods, serving as the foundation for more advanced schemes such as gradient quantization, mixed-precision quantization, and vector quantization.

3.0.0.8 Gradient Quantization:

Gradient quantization aims to compress updates \(\nabla W_k^t\) before communication to the server. The quantized gradient \(\tilde{\nabla W_k^t}\) is given as \(\tilde{\nabla W_k^t} = Q(\nabla W_k^t) = s \cdot \mathrm{round}\!\left(\frac{\nabla W_k^t}{s}\right)\), where \(Q(\cdot)\) is a stochastic or deterministic quantization function [36]. Stochastic quantization preserves unbiasedness, i.e., \(\mathbb{E}[Q(x)] = x\), ensuring that the global gradient estimator remains consistent as \(\mathbb{E}\left[\tilde{\nabla W_k^t}\right] = \nabla W_k^t\). Gradient quantization has emerged as one of the most effective strategies to alleviate the communication bottleneck in FL by compressing model updates before transmission. Unlike parameter quantization, which targets static model weights, gradient quantization focuses on dynamically exchanged gradients, enabling significant bandwidth reduction during each training round. Early studies such as QSGD [36] established the theoretical foundations for unbiased stochastic quantization, while subsequent works including FedPAQ [4] and LAQ [63] demonstrated the benefits of combining quantization with periodic averaging and lazy aggregation. More recent frameworks like DAdaQuant [64], AdaGQ [65], and FedVQCS [66] introduced adaptive, client-specific, and vector-based quantization to further balance accuracy, convergence, and communication cost.

3.0.0.9 Activation and Intermediate Quantization:

Activation and intermediate quantization aim to reduce the memory footprint and computational cost of local training in FL by compressing the activation tensors and intermediate feature maps generated during forward propagation. Unlike parameter or gradient quantization, which focus on communication efficiency, activation quantization primarily targets on-device efficiency—making FL feasible on mobile and IoT devices with limited memory and power budgets [40], [46], [60]. Formally, consider an activation tensor \(\mathbf{a}_l \in \mathbb{R}^{n_l}\) produced at layer \(l\) during forward propagation. The quantized activation \(\hat{\mathbf{a}}_l\) is obtained by mapping \(\mathbf{a}_l\) to a discrete set of representable values based on a quantization step size \(s_l\), computed from the activation range: \(\hat{\mathbf{a}}_l = Q(\mathbf{a}_l) = s_l \cdot \mathrm{round}\!\left(\frac{\mathbf{a}_l}{s_l}\right), \quad s_l = \frac{\max(\mathbf{a}_l) - \min(\mathbf{a}_l)}{2^{b_l} - 1}\), where \(b_l\) denotes the bit-width used for quantizing activations at layer \(l\).

In practice, the quantization process can also be expressed in integer form by defining the integer activation representation \(\mathbf{a}_l^q\) and its dequantized approximation \(\hat{\mathbf{a}}_l\) using \(\mathbf{a}_l^q = \mathrm{clip}\!\left(\mathrm{round}\!\left(\frac{\mathbf{a}_l}{s_l}\right) + z_l, \, 0, \, 2^{b_l}-1\right), \quad \hat{\mathbf{a}}_l = s_l \cdot (\mathbf{a}_l^q - z_l)\), where \(z_l\) is the zero-point that ensures non-negative quantized representations (used in asymmetric quantization).

This process effectively replaces floating-point activations with low-bit integer approximations (e.g., INT8 or INT4), which reduces both the memory access cost and the energy required for matrix multiplications on embedded hardware. However, as deeper layers tend to amplify quantization noise, proper calibration and clipping techniques—such as PACT [46] or per-layer scaling [42]—are essential to maintain convergence and accuracy.

In the context of FL, activation and intermediate quantization are particularly effective for on-device training and privacy-preserving inference. For instance, Shen et al. [60] introduced the Quantized Federated Neural Network (QFNN), which quantizes both parameters and activations to reduce client-side memory usage while preserving model accuracy. Similarly, Feng et al. [67] developed a fully quantized activation (FAQ) scheme for federated edge devices, quantizing both weights and activations to INT8 for end-to-end efficiency.

Intermediate quantization, a related technique, compresses intermediate feature maps exchanged between layers or between clients and servers in split or hierarchical FL setups [68], [69]. Let \(\mathbf{f}_l\) represent the feature map at an intermediate layer \(l\) transmitted from the client to the server. The quantized feature map \(\hat{\mathbf{f}}_l\) is computed as \(\hat{\mathbf{f}}_l = s_f \cdot \mathrm{round}\!\left(\frac{\mathbf{f}_l}{s_f}\right), \quad s_f = \frac{\max(\mathbf{f}_l) - \min(\mathbf{f}_l)}{2^{b_f}-1}\), where \(b_f\) is the bit-width for feature quantization. By transmitting \(\hat{\mathbf{f}}_l\) instead of \(\mathbf{f}_l\), clients achieve substantial communication savings during forward-backward synchronization.

Although activation and intermediate quantization significantly enhance computational and communication efficiency, they introduce challenges such as activation saturation, quantization noise propagation, and accuracy degradation in deep or non-IID federated settings. To mitigate these issues, adaptive calibration, per-layer clipping, and mixed-precision quantization strategies have been proposed [42], [46]. Overall, activation and intermediate quantization form a critical bridge between hardware-efficient FL deployment and energy-aware distributed intelligence.

3.0.0.10 Model Update Quantization:

Alternatively, clients transmit quantized model updates \(\Delta W_k^t = W_k^t - W^{t-1}\) rather than full model parameters, i.e., \(Q(\Delta W_k^t) = s \cdot \mathrm{round}\!\left(\frac{\Delta W_k^t}{s}\right)\), which further improves communication efficiency in synchronous aggregation frameworks [4]. Model update quantization has emerged as a practical strategy to improve communication efficiency in FL. Instead of transmitting complete model parameters, clients communicate quantized updates \(\Delta W_k^t = W_k^t - W^{t-1}\), which substantially reduces bandwidth requirements during each aggregation round. Reisizadeh et al. [4] introduced FedPAQ, combining periodic averaging with uniform quantization, while Sun et al. [63] proposed LAQ, leveraging lazy aggregation and innovation-based quantization. Further, Amiri and Gündüz [70] explored quantized model transmission over wireless channels, and Elkordy and Avestimehr [71] enhanced this approach through secure and heterogeneous quantization under variable bandwidths. Recent adaptive approaches such as AdaGQ [65] dynamically adjust quantization precision per client based on gradient norms and device capabilities.

3.0.0.11 Uniform Quantization

Uniform quantization is one of the most widely implemented quantization strategies in FL due to its simplicity, hardware efficiency, and ease of integration into existing communication and computation pipelines. The fundamental idea is to represent model parameters or gradients with equally spaced discrete values by dividing the numerical range \([x_{\min}, x_{\max}]\) into fixed-size intervals. Each real value \(x\) is approximated by its nearest quantized level according to \(x_q = \mathrm{round}\!\left(\frac{x - x_{\min}}{s}\right) \times s + x_{\min}, \quad s = \frac{x_{\max} - x_{\min}}{2^{b} - 1}\), where \(b\) denotes the bit-width, and \(s\) is the quantization step size. In the context of FL, uniform quantization significantly reduces communication overhead by compressing model updates exchanged between clients and the server, while maintaining competitive accuracy. However, a key limitation arises from outlier values-large deviations in model weights or gradients, which stretch the quantization range and thus lower precision for frequently occurring small values. This is particularly challenging in non-IID client settings, where data heterogeneity causes wide dynamic variations in parameter distributions. Recent research has refined the uniform quantization paradigm through clipping and stochastic extensions. For instance, Bozorgasl and Chen [41] proposed clipped uniform quantization that adaptively determines optimal clipping thresholds to minimize quantization noise while maintaining accuracy. Their method introduces stochastic quantization, which adds controlled randomness to reduce bias and enhance robustness during aggregation. Similarly, Dubey and Kumar [39] compared uniform quantization with post-training and quantization-aware methods, showing that uniform quantization achieves substantial memory reduction (up to 75%) and inference acceleration (2-4\(\times\)) with minimal accuracy loss (1-2%). Overall, uniform quantization remains a baseline technique for communication-efficient FL, often serving as a foundation for more advanced quantizers (e.g., per-layer, non-uniform, or clipped methods). Its combination of simplicity, interpretability, and hardware compatibility (e.g., INT8) makes it indispensable for scalable, privacy-preserving federated systems deployed on heterogeneous edge devices.

Table 7 provides a comparative summary of the major variants of uniform quantization employed either in NN or FL. The table highlights their core methodologies, advantages, and limitations, emphasizing how each successive refinement, ranging from standard fixed-step quantization to clipped, stochastic, and adaptive/per-layer approaches, enhances communication efficiency and model robustness. Standard uniform quantization remains the simplest and most hardware-friendly technique but struggles with outlier sensitivity and non-uniform data. Clipped and stochastic variants mitigate quantization noise and bias, while adaptive or per-layer strategies introduce flexibility across model layers or clients, balancing accuracy with efficiency in heterogeneous FL environments. Collectively, these methods illustrate the evolution of uniform quantization from basic discretization toward adaptive, context-aware compression techniques that better suit the challenges of decentralized and resource-constrained learning systems.

3.0.0.12 Non-uniform Quantization:

Non-uniform quantization extends the concept of fixed-step quantization by allocating quantization levels unevenly across the value range to better match the statistical distribution of model parameters or activations. Unlike uniform quantization, which assigns equal spacing between quantization bins, non-uniform schemes use variable step sizes, often smaller near dense regions (e.g., around zero) and larger toward the tails of the distribution, thereby minimizing quantization error and improving low-bit precision [73], [74]. Methods such as Lloyd–Max quantization, logarithmic scaling, and learned non-uniform step sizes adaptively fit quantization intervals to the data distribution, achieving better trade-offs between accuracy and compression [75], [76]. Techniques like Additive Powers-of-Two (APoT) [74] and PowerQuant [76] offer hardware-friendly implementations with non-uniform discretization. In FL, distribution-aware non-uniform quantization further enhances communication efficiency by tailoring quantization to client-specific data distributions, as demonstrated in approaches like FedWSQ [77] and Non-QuanFL [78]. However, these adaptive schemes introduce additional computational complexity and calibration overhead compared to simpler uniform quantization methods.

Table 8 summarizes the primary non-uniform quantization techniques used in neural networks and FL. These approaches introduce adaptive quantization levels that better fit data or weight distributions, minimizing quantization noise and preserving model accuracy in heterogeneous environments. While methods like APoT and PowerQuant achieve hardware-friendly implementations, FL-specific schemes such as FedWSQ and Non-QuanFL extend non-uniform quantization to communication-efficient, privacy-preserving decentralized learning frameworks.

3.0.0.13 Vector Quantization

Vector Quantization (VQ) groups model parameters or gradients into small fixed-size vectors and replaces each vector with the index of the closest codeword from a pre-defined codebook (dictionary). Instead of transmitting every value independently, as in scalar quantization, clients send indices referring to codewords, thereby drastically reducing communication overhead. Mathematically, the quantization process can be expressed as \(q(\mathbf{x}) = \mathbf{c}_k, \quad \text{where } k = \arg\min_{j} \|\mathbf{x} - \mathbf{c}_j\|_2\), where \(\mathbf{x} \in \mathbb{R}^d\) is a vectorized group of model parameters or gradients, \(\mathcal{C} = \{\mathbf{c}_1, \mathbf{c}_2, \ldots, \mathbf{c}_K\}\) denotes the shared codebook containing \(K\) representative codewords, and \(\mathbf{c}_k\) is the codeword that minimizes the Euclidean distortion \(\|\mathbf{x} - \mathbf{c}_j\|_2\). During model aggregation, the server reconstructs the approximate updates using \(\hat{\mathbf{x}} = \mathbf{c}_k\), where the transmitted index \(k\) corresponds to the nearest codeword in the codebook. VQ achieves \(\mathcal{O}(\log_2 K)\) communication cost per vector group instead of \(\mathcal{O}(d)\) for raw transmission, making it highly suitable for large-scale FL systems involving thousands of clients. By capturing correlations among grouped parameters, vector quantization enables a better rate–distortion trade-off compared to scalar quantization, providing a balance between accuracy and compression efficiency in communication-constrained federated settings. While standard VQ provides a compact representation of model updates through shared codebooks, its scalability and reconstruction accuracy can be further enhanced by advanced variants such as Product Quantization (PQ) and Lattice Quantization (LQ) approaches extend VQ by improving the trade-off between compression ratio, distortion, and computational efficiency, making them particularly suitable for large-scale and heterogeneous FL environments.

3.0.0.14 Product Quantization:

Product Quantization divides a high-dimensional vector (e.g., gradient or model update) into multiple lower-dimensional subvectors, each quantized independently using its own sub-codebook [82], [83]. Formally, given a parameter vector \(\mathbf{x} \in \mathbb{R}^d\), it is decomposed into \(M\) sub-vectors as \(\mathbf{x} = [\mathbf{x}_1, \mathbf{x}_2, \ldots, \mathbf{x}_M]\), where each \(\mathbf{x}_m \in \mathbb{R}^{d/M}\) is quantized using its corresponding sub-codebook \(\mathcal{C}_m = \{\mathbf{c}_{m,1}, \ldots, \mathbf{c}_{m,K}\}\). The quantization function is defined as \[\begin{align} Q_{PQ}(\mathbf{x}) = [q_1(\mathbf{x}_1), q_2(\mathbf{x}_2), \ldots, q_M(\mathbf{x}_M)], \\ q_m(\mathbf{x}_m) = \mathbf{c}_{m, k^*}, \; k^* = \arg\min_k \|\mathbf{x}_m - \mathbf{c}_{m,k}\|_2. \end{align}\] The reconstructed vector at the server is given by \(\hat{\mathbf{x}} = [\mathbf{c}_{1,k_1}, \mathbf{c}_{2,k_2}, \ldots, \mathbf{c}_{M,k_M}]\).

This decomposition enables exponential compression efficiency, as the number of possible reconstructed vectors becomes \(K^M\), while storage and communication scale only with \(M \log_2 K\). PQ is highly effective in FL, where clients can independently quantize sub-vectors using local sub-codebooks, and the server performs codeword index aggregation. Yang et al. [83] introduced FedMPQ, a secure and communication-efficient FL framework that employs multi-codebook PQ combined with residual pruning and secure aggregation. Each client transmits compressed updates, pseudo-centroids, and residuals, while the server constructs global shared codebooks in a trusted execution environment (TEE) to ensure privacy. PQ achieves up to \(90\%\) communication reduction with minimal accuracy degradation, outperforming scalar and standard vector quantization methods.

3.0.0.15 Lattice Quantization:

Lattice Quantization encodes model updates onto discrete lattice points within Euclidean space, enabling highly structured and computationally efficient quantization. Given a lattice \(\Lambda \subset \mathbb{R}^d\), the quantized vector \(\hat{\mathbf{x}}\) is the nearest lattice point to \(\mathbf{x}\) as \(Q_{LQ}(\mathbf{x}) = \arg\min_{\lambda \in \Lambda} \|\mathbf{x} - \lambda\|_2\). A simple example is the cubic lattice \(\Lambda = s \mathbb{Z}^d\), where each coordinate of \(\mathbf{x}\) is rounded to the nearest multiple of the step size \(s\). More advanced constructions such as the Voronoi lattice or E8 lattice [84] minimize quantization error through geometric packing optimization.

In FL, Shlezinger et al. [37] and Chen et al. [85] applied lattice-based quantization to encode model updates and gradient information efficiently. LQ allows unbiased gradient reconstruction while achieving near-optimal rate–distortion trade-offs. The JoPEQ framework [86] extended this by combining lattice quantization with privacy-preserving additive noise to satisfy local differential privacy (LDP) constraints. Similarly, Universal Vector Quantization (UVQ) [85] used random lattice structures to achieve communication-efficient and task-agnostic compression. Lattice quantization is particularly advantageous for wireless FL and over-the-air aggregation, where structured encoding enables low-complexity decoding at the parameter server [37], [70]. However, challenges such as high encoding complexity for large-scale models and synchronization of random lattice parameters among clients remain open research directions. Product and lattice quantization thus represent advanced directions in model compression for FL, jointly optimizing communication efficiency, privacy, and accuracy. While PQ focuses on modular compression through sub-vector decomposition, LQ provides geometric regularity and efficient reconstruction under structured encoding. Future research trends aim to integrate these techniques with adaptive bit-allocation, privacy guarantees, and mixed-precision optimization to further enhance federated scalability.

Quantization schemes can be further classified based on the precision levels and the quantization step adaptation strategy.

3.0.0.16 Fixed-Point Quantization.

Fixed-point quantization (FPQ) is a widely used and hardware-compatible approach for reducing the precision of model parameters and gradients in federated learning (FL). FPQ represents real-valued variables using a fixed bit-width \(b\) (typically 8 or 16 bits) and integer arithmetic, enabling efficient computation and reduced memory footprint on CPUs, GPUs, and edge accelerators. Given a scaling factor \(s\), a real-valued parameter \(x\) is quantized as \(x_q = \mathrm{clip}\!\left(\mathrm{round}\!\left(\tfrac{x}{s}\right), -2^{b-1}, 2^{b-1}-1\right), \quad \hat{x} = s \cdot x_q ,\) where the clip operation enforces the representable dynamic range. Owing to its simplicity and low overhead, FPQ has been widely adopted in practical inference and training pipelines [40], [42].

Despite these advantages, standard FPQ typically employs static scaling factors, which can be suboptimal in FL settings characterized by non-IID data and heterogeneous client updates. Fixed scaling may induce quantization bias, saturation, or degraded convergence when parameter or gradient ranges vary significantly across clients or communication rounds. To mitigate these effects, recent work has explored adaptive fixed-point quantization schemes that dynamically adjust scaling factors based on observed data statistics. In particular, dynamic fixed-point quantization (DFPQ) computes the scaling factor at communication round \(t\) as \(s_t = \tfrac{\max(\mathbf{x}_t) - \min(\mathbf{x}_t)}{2^b - 1}\), allowing quantization precision to adapt to evolving parameter or gradient distributions. Such dynamic recalibration has been shown to stabilize convergence under heterogeneous updates and to be especially effective for low-bit (\(\leq 8\)-bit) quantization. For example, Reisizadeh et al. [4] incorporated adaptive fixed-point quantization into FedPAQ, while Honig et al. [64] proposed doubly adaptive schemes combining dynamic scaling and stochastic rounding to improve robustness under non-IID data.

3.0.0.17 Asymmetric Quantization:

In contrast to symmetric quantization, which assumes zero-centered distributions, asymmetric quantization introduces a zero-point offset \(z\) to shift the representable integer range, enabling more accurate mapping of non-zero-mean tensors [40], [42]. This technique is widely used in hardware implementations (e.g., TensorRT, TFLite) to minimize bias and improve precision under uneven value distributions. Given a tensor \(\mathbf{x}\) and bit-width \(b\), asymmetric quantization is defined as: \(x_q = \mathrm{clip}\!\left(\mathrm{round}\!\left(\frac{x - x_{\min}}{s}\right), 0, 2^b - 1\right), \quad \hat{x} = s \cdot (x_q - z)\), where \(s = \frac{x_{\max} - x_{\min}}{2^b - 1}, \quad z = \mathrm{round}\!\left(-\frac{x_{\min}}{s}\right)\). Here, \(z\) represents the integer zero-point ensuring that the minimum input value \(x_{\min}\) maps to 0, while the maximum \(x_{\max}\) maps to \(2^b - 1\).Asymmetric quantization is particularly useful when model parameters or activations have non-symmetric distributions, such as in ReLU-based networks or non-IID client updates in FL. Recent studies [39], [67] show that combining asymmetric quantization with post-training calibration improves model accuracy by up to 1–2% compared to symmetric schemes, especially for highly skewed data. Hardware frameworks like TensorFlow Lite and NVIDIA TensorRT use per-tensor asymmetric quantization by default to balance dynamic range precision and hardware efficiency.

3.0.0.18 Ternary and Binary Quantization:

Low-bit quantization such as ternary (\(\{-1, 0, +1\}\)) or binary (\(\{-1, +1\}\)) encoding drastically reduces communication cost [87]. The quantized representation is defined as \(Q(x) = \alpha \cdot \mathrm{sign}(x), \quad \text{where } \alpha = \frac{1}{n}\sum_{i=1}^{n} |x_i|\), with \(\alpha\) serving as a scaling factor. Despite high compression, these methods often lead to accuracy degradation unless compensated through quantization-aware fine-tuning.

3.0.0.19 Adaptive and Layer-Wise Quantization:

Adaptive quantization dynamically adjusts the bit-width or scaling factor for different layers, communication rounds, or clients, depending on sensitivity and resource constraints [54], [57]. This flexibility helps maintain model accuracy while optimizing bandwidth and computational efficiency across heterogeneous federated systems. The bit allocation problem is formulated as a multi-objective optimization task as \(\min_{\{b_l\}} \mathcal{L}(Q(W; \{b_l\})) + \lambda \sum_l C(b_l)\), where \(\mathcal{L}\) is the model loss, \(b_l\) represents the bit-width of layer \(l\), \(C(b_l)\) denotes the communication or computation cost, and \(\lambda\) is a regularization coefficient controlling the trade-off between accuracy and efficiency. This framework allows layer-wise or client-wise bit-width adaptation in FL, where devices exhibit varying computational and communication capabilities. Adaptive quantization methods outperform static quantization schemes in non-IID or resource-constrained FL setups because they can allocate higher precision to more critical layers or communication rounds and lower precision elsewhere, achieving an optimal trade-off between efficiency and accuracy. Qu et al. [88] proposed a stochastic uniform quantization approach where the quantization level decreases as training progresses. Compared to ascending quantization schedules, this descending-trend approach converges faster and requires fewer transmitted bits. However, the presence of stochastic noise and accumulated quantization errors may reduce accuracy, particularly in sensitive models, thereby increasing computational overhead for stabilization. Ni et al. [62] formulated adaptive quantization as a non-convex mixed-integer nonlinear programming (MINLP) problem, simultaneously optimizing client scheduling, quantization precision, and transmission energy under energy causality constraints. This method ensures fairness by maintaining balanced client participation but introduces auxiliary variables to convexify the optimization, potentially leading to suboptimal local minima. Chen et al. [89] developed an adaptive compression strategy that divides gradients into essential and non-essential components via dynamic interval partitioning. Essential gradients undergo fine-grained high-bit quantization, while less important gradients are averaged or coarsely quantized, reducing total communication cost while preserving accuracy. Mao et al. [90] extended adaptive quantization to handle client dropout and variance reduction in heterogeneous FL. Their method amplified gradient magnitudes to compensate for dropped clients, but improper amplification could either overcompensate, introducing bias, or undercompensate, resulting in suboptimal convergence. Finally, Honig et al. [64] introduced DAdaQuant (Doubly Adaptive Quantization), combining time-adaptive and client-adaptive scaling within the QSGD framework. While computationally efficient, its dynamic adjustment mechanism demands careful tuning and synchronization, as per-round scaling updates can increase both implementation complexity and communication variance.

Adaptive and layer-wise quantization thus form an essential component of modern FL compression techniques. By dynamically adjusting quantization precision across layers, rounds, or clients, these methods enable communication-efficient and robust training under varying data and hardware conditions. Adaptive and layer-wise quantization has become a key component in modern FL systems, enabling flexible bit-width allocation across layers, communication rounds, or clients. Foundational works such as HAWQ [57] and HAQ [54] established sensitivity- and hardware-aware mixed-precision quantization frameworks. Building on these, Qu et al. [88] and Ni et al. [62] proposed adaptive schemes that dynamically adjust quantization precision based on training stage or energy constraints, achieving faster convergence and better energy efficiency. Further, Chen et al. [89] and Mao et al. [90] introduced gradient-based adaptive quantization techniques that reduce communication overhead while maintaining robustness to non-IID data. The DAdaQuant framework [64] represents the state-of-the-art by combining client- and time-adaptive scaling mechanisms.

4pt

6pt

Table 10 ensures complete coverage of all quantized FL methods surveyed in Table 9, with methods appearing under multiple system-level properties when applicable. For completeness, the full ungrouped taxonomy is provided in the Appendix (Table 1).

3.0.0.20 Key Observations and Trade-offs:

Quantization consistently enables significant communication reduction, often with marginal accuracy loss. Energy-efficient schemes such as QNN-FL [102] and FedQNN [97] achieve up to 90% energy savings and 30\(\times\) compression. Adaptive and client-aware methods (e.g., DAdaQuant [64], FedMPQ [104], AdaQuantFL [61]) dominate the accuracy–efficiency Pareto frontier, dynamically adjusting bit-widths across clients or rounds to preserve convergence under non-IID settings. Vector and lattice quantization techniques (e.g., UVQ [85], SDQ [112], FedVQCS [66]) offer superior compression–distortion trade-offs but incur higher computational and codebook overheads—trading bandwidth for local computation.

3.0.0.21 Accuracy and Convergence Behavior:

Several works (FedSQ [94], FedPAQ [4], Lian [107]) provide formal convergence guarantees under convex and non-convex losses. Stochastic, unbiased quantizers preserve convergence asymptotically but add gradient variance, while deterministic quantizers may introduce bias unless corrected (e.g., via error feedback [70] or bias compensation [55]). Distribution-aware methods (e.g., Non-QuanFL [78], FedMPQ [104]) demonstrate better resilience to non-IID client data through adaptive or non-uniform quantization.

3.0.0.22 Communication and Energy Efficiency:

Combining sparsification with quantization (e.g., [107], [108]) achieves up to \(10\times\) bandwidth reduction with minor accuracy drop. Energy-aware designs (QNN-FL [102], FedQNN [97], Ni [106]) effectively balance power consumption and model utility, though many rely on hardware-level support for low-precision operations. Heterogeneous quantization frameworks (HeteroSAg [71], FedMPQ [104]) further improve fairness across diverse client capabilities.

3.0.0.23 Privacy, Robustness, and Scalability:

Privacy-preserving quantization (DP-FedQ [105], JoPEQ [86]) integrates differential privacy or lattice dithering, trading slight accuracy loss for stronger confidentiality. Robust aggregation under quantization (e.g., [109]) ensures resilience to Byzantine attacks but requires careful quantization step calibration. Vector and lattice-based approaches (e.g., FedVQCS [66]) face scalability challenges due to decoding complexity, motivating lightweight, structured quantizers for large models.

In summary, adaptive and mixed-precision methods achieve the best balance between accuracy and communication in realistic FL scenarios, while vector/lattice approaches provide the highest compression efficiency at higher computation cost. Privacy and robustness can be synergistically integrated but demand precise tuning. The optimal quantization strategy depends on deployment constraints—device energy, network bandwidth, privacy budget, and model size. Future research should emphasize: (i) low-overhead vector quantizers with real-time adaptability, (ii) automated tuning of bit allocation under non-IID conditions, and (iii) scalable secure aggregation with heterogeneous precision.

Rather than ranking quantization methods in isolation, the following discussion distills practical design guidelines for selecting quantization strategies in FL systems.

PTQ is preferable in FL scenarios where client-side computational resources, energy budget, or training time are strongly constrained. Since PTQ applies quantization only after local training, it avoids the additional forward–backward quantization simulation required by QAT, making it particularly suitable for large-scale FL deployments with lightweight edge or IoT devices, frequent client dropout, or limited local training epochs. PTQ is also advantageous when moderate accuracy degradation (typically 1–2%) is acceptable in exchange for reduced training complexity and faster system deployment. In contrast, QAT is better suited to accuracy-critical applications or ultra-low-bit regimes, where its higher training cost can be amortized by improved convergence stability. QAT generally achieves better convergence but increases training cost. In FL, PTQ is ideal for edge devices where computational resources are limited, while QAT is preferred for applications, requiring higher accuracy across heterogeneous clients.

Per-layer quantization is especially effective in heterogeneous FL settings because it enables layer-wise precision adaptation in response to both model sensitivity and client capability. In practical FL deployments, clients differ significantly in hardware, memory, and data distributions; uniform quantization can therefore either over-compress sensitive layers or underutilize capable devices. By allocating higher precision to accuracy-critical layers and more aggressive quantization to robust layers, per-layer quantization mitigates accuracy degradation caused by client heterogeneity and reduces aggregation instability. This fine-grained control allows diverse clients to contribute effectively to the global model, improving convergence robustness under non-IID data and mixed device participation.

Advanced quantization techniques, such as non-uniform, vector, lattice, and adaptive mixed-precision quantization-achieve superior compression and rate-distortion trade-offs by exploiting data distribution, parameter correlation, or layer sensitivity. However, these gains come at the cost of increased tuning and system complexity, including codebook learning, sensitivity estimation, dynamic bit allocation, or per-client calibration. In federated settings, this additional complexity is amplified by client heterogeneity, synchronization requirements, and privacy constraints, making implementation and deployment more challenging than uniform or post-training quantization. Consequently, while advanced methods are attractive for bandwidth-limited or large-model FL systems, their practical adoption requires careful consideration of calibration overhead, computational cost, and system scalability.

4 Challenges, Limitations, and Trade-offs↩︎

Existing quantization approaches in federated learning (FL) are fundamentally characterized by a set of interrelated challenges and trade-offs arising from the interaction between communication efficiency, optimization dynamics, system heterogeneity, privacy constraints, and hardware limitations. While quantization is an effective mechanism for reducing communication overhead, it inherently introduces quantization noise and bias, leading to a fundamental communication-accuracy trade-off. Specifically, reducing the bit-width lowers transmission cost but increases quantization error, which raises the convergence error floor and limits achievable model performance. addressing RQ2: What challenges and limitations characterize existing quantization approaches in FL?

4.0.0.1 Communication–Accuracy Trade-off:

Quantization directly reduces the number of bits used to represent model parameters or gradients, achieving substantial communication savings. However, this reduction comes at the expense of model accuracy, as low-bit representations introduce quantization noise and rounding errors [4], [36]. The trade-off can be expressed as \(\mathrm{MSE} = \mathbb{E}\!\left[\|x - Q(x)\|^2\right] \propto 2^{-2b}\), where \(b\) denotes bit-width, and \(Q(x)\) is the quantized version of \(x\). Reducing \(b\) enhances communication efficiency but increases mean-squared quantization error, potentially degrading convergence. To balance this, hybrid and adaptive quantization strategies adjust precision dynamically across layers or communication rounds [54], [57]. Yet, finding optimal trade-offs remains difficult due to varying model sensitivities and data distributions across clients.

4.0.0.2 Impact of Client Heterogeneity and Non-IID Data:

Client heterogeneity is an inherent challenge in FL, where devices differ in computation power, communication bandwidth, and local data distribution. Quantization amplifies this issue because clients quantize model updates with varying precision and dynamic ranges, leading to inconsistent scaling across updates [132], [133]. In non-IID settings, gradients across clients may have large variance as \(\mathrm{Var}\!\left(\nabla \mathcal{L}_k\right) \gg \mathrm{Var}\!\left(\nabla \mathcal{L}_{\text{global}}\right)\), which, when quantized, results in bias accumulation during global aggregation. Clipped or normalized quantization methods (e.g., FedWSQ [77] and ClippedFedAvg [41]) have been proposed to address this, but they often require layer-wise calibration or extra communication overhead. Moreover, device heterogeneity means that some clients cannot support higher-bit or quantization-aware operations, leading to imbalance between clients and inconsistent local model updates [39].

4.0.0.3 Stability and Convergence Issues:

Quantization introduces noise that can destabilize the training process, particularly in early FL rounds. The convergence behavior of quantized federated optimization can be described as [4], [37] \(\mathbb{E}\!\left[\|W^t - W^*\|^2\right] \leq (1 - \eta \mu)^t \|W^0 - W^*\|^2 + \frac{\eta \sigma_q^2}{\mu}\), where \(\eta\) is the learning rate, \(\mu\) the strong convexity constant, and \(\sigma_q^2\) represents quantization-induced variance. As \(\sigma_q^2\) increases (i.e., lower bit-widths), the error floor rises, leading to slower or biased convergence. Bias correction, stochastic quantization, and error feedback methods help mitigate this issue [36], [55], but quantization noise remains a limiting factor for convergence speed in highly heterogeneous FL networks.

4.0.0.4 Communication-Convergence Trade-off:

If low-bit quantization is employed throughout the communication process, the network convergence is extremely slow, even if QAT-FL can achieve greater convergence than PTQ-FL at the same communication bits. Additionally, it will converge more quickly if the high-quantization bit is utilized for quantization, but it will cost more for transmission. In either event, communication efficiency will decline due to the quantization of fixed bits [126].

4.0.0.5 Privacy and Security Implications:

While quantization reduces communication overhead, it may inadvertently weaken privacy guarantees or introduce new attack surfaces. In particular, quantized updates can leak statistical information about local data distributions through quantization patterns or gradient sparsity [134], [135]. Additionally, model inversion and reconstruction attacks may exploit low-bit updates to infer client data [136]. Integrating quantization with privacy-preserving mechanisms such as differential privacy (DP) and secure aggregation [137] is challenging, as DP noise and quantization noise may interact non-linearly, affecting both utility and privacy. Finding an optimal balance between communication efficiency, model accuracy, and privacy preservation remains an open problem.

4.0.0.6 Hardware and Energy Constraints on Edge Devices:

Quantized FL models are typically deployed on heterogeneous hardware platforms—ranging from high-performance GPUs to low-power edge devices such as IoT sensors and smartphones [40]. Although integer quantization (e.g., INT8) is well supported by modern accelerators (TensorRT, TFLite), ultra-low-bit quantization (e.g., 2-bit or binary) often lacks hardware support [43], [44]. Furthermore, frequent quantization and dequantization operations can incur additional computational overhead and energy cost, especially in devices without dedicated low-precision units [38]. Designing hardware-friendly quantization algorithms that align with edge computing architectures remains an active area of research.

The integration of quantization into FL introduces an intricate balance among accuracy, efficiency, and robustness. Table 11 summarizes the key challenges, their causes, and potential mitigation strategies reported in the literature.

5 Research Gaps and Open Issues↩︎

Although quantization has proven effective in reducing communication and computation costs in FL, several research gaps and unresolved challenges hinder its full potential. This section identifies and discusses the key limitations and open issues observed across the current body of literature, addressing RQ3: What are the key gaps in current research and implementations?

5.0.0.1 Lack of Standardized Benchmarks and Evaluation Protocols:

A major limitation in existing quantized FL studies is the absence of standardized benchmarks and evaluation methodologies. Different works employ diverse datasets (e.g., CIFAR-10, FEMNIST, Shakespeare), quantization levels, and aggregation protocols, making it difficult to fairly compare results [38], [39]. Furthermore, metrics such as communication cost, convergence rate, and model accuracy are often reported inconsistently or without energy profiling. Developing standardized benchmark suites and reproducible experimental pipelines—similar to TensorFlow Federated or LEAF [138]—would enable more reliable cross-comparison and progress tracking. This would also facilitate reproducibility and foster fair evaluation of new quantization strategies.

5.0.0.2 Incomplete Theoretical Understanding of Quantized Convergence:

Despite numerous empirical studies, the theoretical understanding of how quantization affects convergence in FL remains incomplete. While convergence bounds for quantized stochastic gradient descent (QSGD) exist [4], [36], most analyses assume IID data and synchronous client participation. Real-world FL systems, however, operate under non-IID data and partial client participation, where quantization noise interacts non-linearly with gradient variance [132]. The convergence dynamics of quantized FL can be expressed as \(\mathbb{E}\!\left[\mathcal{L}(W^{t+1}) - \mathcal{L}(W^*)\right] \leq (1 - \eta \mu)\mathbb{E}\!\left[\mathcal{L}(W^t) - \mathcal{L}(W^*)\right] + \eta^2 \sigma_q^2\), where \(\sigma_q^2\) represents the variance introduced by quantization. A precise characterization of \(\sigma_q^2\) under non-IID and asynchronous FL remains an open research problem.

5.0.0.3 Limited Real-World Deployment and Reproducibility:

Most quantized FL studies are validated in simulated environments rather than real-world edge or IoT settings. Real deployments involve unstable connectivity, device failures, and limited energy budgets, factors rarely modeled in current research [40], [54]. Additionally, reproducibility remains a major concern as many studies lack open-source implementations or sufficient experimental details, making it difficult to verify claims or extend existing work. Future work should prioritize hardware-in-the-loop evaluations and open benchmarking initiatives to assess quantized FL performance under realistic edge computing conditions.

5.0.0.4 Neglect of Adaptive and Personalized Quantization Strategies:

Most existing quantization methods employ static bit-widths and global quantization scales shared among clients. However, in heterogeneous FL, where clients differ in computational capability and data distribution, static quantization is suboptimal [57]. There is limited exploration of personalized quantization, where each client uses customized bit-widths or quantization schemes depending on its data complexity, model sensitivity, or network bandwidth. An open challenge lies in designing adaptive quantization algorithms that dynamically allocate precision during training or communication while ensuring fairness and stable aggregation across clients.

5.0.0.5 Insufficient Exploration of Multi-Objective Optimization:

Quantized FL systems inherently involve trade-offs between communication cost, model accuracy, energy efficiency, and privacy preservation [38], [39]. However, few studies formulate quantization as a multi-objective optimization problem. An ideal quantization strategy should jointly minimize communication cost \(C\), quantization error \(E_q\), and energy consumption \(E_{dev}\) as \(\min_{\theta_q} \; \lambda_1 C + \lambda_2 E_q + \lambda_3 E_{dev}\), subject to accuracy and privacy constraints. Balancing these objectives adaptively during FL training—especially under resource heterogeneity—remains an underexplored direction for future work.

5.0.0.6 Privacy and Security Gaps in Quantized FL:

Quantization introduces new privacy challenges that are often overlooked. While reducing communication data size, quantized gradients or weights may expose distributional information about client data [134], [136]. Combining quantization with differential privacy (DP) or secure aggregation is non-trivial because quantization noise and DP noise may interfere, leading to unpredictable accuracy–privacy trade-offs [135], [137]. Systematic studies are needed to characterize privacy leakage risks introduced by quantization and to develop integrated quantization–privacy frameworks that jointly optimize for efficiency and confidentiality.

5.0.0.7 Energy and Hardware-Aware Quantization Gaps:

Although quantization is designed to enable low-power inference on edge devices, few studies explicitly evaluate the energy efficiency of quantized FL models. Existing works often assume idealized hardware conditions and do not consider the overhead of repeated quantization and dequantization [43], [44]. Additionally, hardware support for ultra-low-bit quantization (e.g., 1-bit or 2-bit) is still limited across mobile accelerators, restricting deployment feasibility [38]. Future research should incorporate energy profiling and hardware-aware quantization strategies that align with device-level computation and memory characteristics.

Table 12 summarizes the key research gaps and their corresponding research opportunities identified in current quantized FL studies.

6 Future Research Directions↩︎

Building upon the challenges and research gaps identified in Section 5, this section outlines potential research directions and emerging trends that could advance the integration of quantization into FL. These future directions address RQ4: What emerging trends can guide the design of scalable, robust, and privacy-aware quantized FL systems?.

6.0.0.1 Adaptive and Hybrid Quantization Frameworks

Future quantization strategies should move beyond fixed bit-width designs toward adaptive and hybrid quantization. Adaptive frameworks dynamically allocate bit-widths based on layer sensitivity, communication cost, or hardware capability [54], [57]. Hybrid schemes can combine PTQ for stable layers with QAT for sensitive ones, thus achieving both computational efficiency and high accuracy [39]. Mathematically, this can be formulated as a resource-constrained optimization as \(\min_{\{b_l\}} \mathcal{L}(Q(W; \{b_l\})) + \lambda \sum_{l} \alpha_l C(b_l)\), where \(b_l\) is the bit-width assigned to layer \(l\), \(C(b_l)\) denotes the communication cost, and \(\alpha_l\) encodes layer sensitivity. Such adaptive frameworks can balance precision and efficiency dynamically during FL training, especially in heterogeneous environments.

6.0.0.2 Integration with Pruning, Sparsification, and Compression:

Combining quantization with complementary model compression techniques—such as pruning, weight clustering, or low-rank approximation—offers another promising direction [4], [139]. Joint optimization can yield multiplicative gains in communication and memory efficiency while maintaining accuracy as \(\min_{\theta} \mathcal{L}(\theta) \quad \text{s.t.} \quad \|\theta\|_0 \leq k, \; \theta \in \mathcal{Q}\), where \(\mathcal{Q}\) represents the quantization constraint set and \(\|\theta\|_0\) enforces model sparsity. Integrating quantization with pruning-aware aggregation in FL (e.g., sparse FedAvg) could reduce model size and communication rounds simultaneously.

6.0.0.3 Energy-Aware and Hardware-Friendly Quantized FL:

Most current works evaluate quantization only in terms of accuracy and communication cost, neglecting energy and hardware aspects. Future research should incorporate energy profiling and hardware-awareness into quantization design [38], [44]. Energy-aware FL can optimize quantization under power constraints as \(\min_{\theta_q} \mathcal{L}(Q(\theta_q)) + \lambda E_{\text{device}}\), where \(E_{\text{device}}\) represents device-level energy consumption. Hardware-friendly quantization that aligns with INT8 accelerators (e.g., TensorRT, TFLite) or neuromorphic processors will enable real-world deployment on edge devices with strict power budgets.

6.0.0.4 Quantum-Inspired and Neuromorphic Quantization Methods:

Emerging hardware paradigms such as quantum computing and neuromorphic architectures offer new possibilities for quantization research. Quantum-inspired quantization could exploit probabilistic amplitude encoding for compressing model parameters efficiently, while spike-based quantization in neuromorphic FL mimics brain-inspired analog communication for energy-efficient distributed learning [140], [141]. Integrating these paradigms could significantly enhance both compression and inference efficiency. Future work may also explore quantum federated quantization frameworks, where clients encode quantized gradients as quantum states for secure and lossless aggregation.

6.0.0.5 Benchmarking and Reproducibility Standards:

To ensure scientific rigor and comparability, future FL quantization research must adopt standardized benchmarks and reproducibility practices [135], [138]. Benchmarking frameworks such as LEAF, FedML, and TensorFlow Federated can be extended with quantization metrics, e.g., bits-per-update, compression ratio, and energy-per-inference. Furthermore, establishing open repositories with unified experimental pipelines will promote fair evaluation across PTQ, QAT, and hybrid approaches.

6.0.0.6 Application-Specific Quantization for Edge Intelligence:

Quantization techniques should also be tailored to domain-specific FL applications such as healthcare, autonomous driving, and IoT systems [15]. For instance, precision-sensitive medical FL systems (e.g., federated diagnosis models) require higher bit-widths for critical layers, whereas sensor-driven IoT models can use more aggressive quantization. Designing application-aware quantization policies that account for data sensitivity, latency, and domain constraints will improve both efficiency and trustworthiness.

6.0.0.7 Federated Multi-Objective Optimization for Quantized Models:

As quantization in FL involves competing objectives—accuracy, communication efficiency, privacy, and energy—future frameworks should adopt multi-objective optimization strategies [39]. This can be expressed as \(\min_{\theta_q} \; \lambda_1 \mathcal{L}(\theta_q) + \lambda_2 C(\theta_q) + \lambda_3 E_{\text{device}} + \lambda_4 P(\theta_q)\), where \(\mathcal{L}\) denotes model loss, \(C\) the communication cost, \(E_{\text{device}}\) energy consumption, and \(P\) the privacy loss. Such frameworks can dynamically adjust quantization levels to balance performance and efficiency across diverse FL environments.

Table 13 summarizes the key emerging research directions and their expected contributions toward advancing quantized FL.

7 Discussion↩︎

This section synthesizes the key findings across all research questions (RQ1–RQ4), reflecting on how quantization impacts FL effectiveness, scalability, and practical deployment. It also discusses methodological insights, comparative observations, and the broader implications of quantized FL in real-world systems.

7.0.0.1 Synthesis of Findings Across Research Questions

RQ1 - Impact of Quantization on FL Effectiveness: Quantization techniques fundamentally reshape the trade-off between communication efficiency and model accuracy in FL. The review reveals that uniform and fixed-point quantization methods remain dominant due to their hardware compatibility and simplicity [40], [42], while adaptive and non-uniform schemes improve performance under non-IID client data distributions [73], [77]. PTQ offers practical deployment advantages without retraining, whereas QAT delivers superior robustness at the cost of additional computation [39], [55]. The results indicate that carefully designed quantization strategies can reduce communication bandwidth by up to 90% with less than 2% accuracy degradation, provided quantization noise and clipping thresholds are well-calibrated.

RQ2 - Challenges and Limitations in Quantized FL: Despite significant progress, integrating quantization within FL faces persistent issues related to communication–accuracy trade-offs, client heterogeneity, and convergence instability [41], [132]. Quantization noise amplifies the effects of non-IID data and device heterogeneity, slowing convergence and causing gradient bias during aggregation [4]. Privacy risks also emerge from quantized updates, which may leak local distributional statistics [134], [136]. Furthermore, limited hardware support for ultra-low-bit quantization constrains deployment on edge devices. Thus, the field still lacks unified strategies that jointly optimize communication efficiency, robustness, and privacy.

RQ3 - Key Research Gaps and Open Issues: The literature reveals several open gaps that must be addressed to realize the full potential of quantized FL. There is no standardized evaluation protocol for comparing quantization schemes, leading to inconsistent reporting of communication savings and convergence metrics [38], [138]. Theoretical analyses of convergence behavior under quantization and non-IID data remain incomplete [36], [132]. Few studies incorporate real-world energy or hardware profiling, limiting practical relevance [43], [44]. Additionally, adaptive and personalized quantization—where clients employ device-specific or data-aware bit-widths—has received limited exploration. Addressing these gaps will require unified benchmarking, theoretical frameworks, and hardware–software co-design.

RQ4 - Promising Future Directions: Emerging trends point toward adaptive, hybrid, and hardware-aware quantization frameworks that balance accuracy, communication cost, and energy efficiency [54], [57]. Integrating quantization with pruning, sparsification, and differential privacy will enable holistic optimization of FL systems [137], [139]. Furthermore, quantum-inspired and neuromorphic quantization paradigms offer novel avenues for ultra-efficient and secure distributed learning [140], [141]. Future frameworks should incorporate multi-objective optimization to dynamically tune precision based on communication bandwidth, energy constraints, and privacy requirements.

7.0.0.2 Comparative Insights and Methodological Observations:

A key observation from the systematic review is the divergence between theoretical advances and practical implementations. While many quantized FL algorithms demonstrate strong empirical results in simulation, real-world validations on heterogeneous hardware are rare. Moreover, studies often focus narrowly on accuracy and bandwidth metrics, overlooking energy and latency trade-offs. In particular, adaptive quantization methods that adjust bit-widths per client or communication round have shown potential in reducing total energy consumption by up to 40% [39], yet lack consistent reproducibility due to dataset and system differences. Another insight concerns the complementary nature of PTQ and QAT. While PTQ is more suitable for low-power or resource-limited clients, QAT remains the preferred choice for applications demanding high reliability. Hybrid PTQ-QAT frameworks, which combine static quantization for stable layers with quantization-aware optimization for sensitive ones, represent a promising compromise between deployment simplicity and robustness.

7.0.0.3 Implications for Real-World FL Systems:

The findings highlight that quantization is not a universal solution but rather a configurable component within FL pipelines. For deployment at scale, quantization schemes must align with application-specific requirements, device capabilities, and privacy constraints. In edge intelligence scenarios—such as autonomous vehicles or medical IoT—quantization must maintain interpretability and fairness across clients. Hardware-aware quantization that considers the computational graph of accelerators (e.g., NPUs or TPUs) will be essential for efficient FL implementation [38], [44]. Moreover, integrating quantization with secure aggregation and differential privacy can ensure confidentiality while maintaining communication efficiency.

7.0.0.4 Limitations of This Review:

While this systematic survey follows the PRISMA methodology for transparency, several limitations remain. The scope of reviewed works is restricted to peer-reviewed publications available up to early 2025, potentially excluding recent preprints. Finally, while this review emphasizes quantization, other model compression techniques—such as knowledge distillation and low-rank factorization—were not deeply explored. Future reviews could examine the synergy between quantization and broader compression paradigms for federated optimization.

Overall, quantization remains a cornerstone technique for achieving communication-efficient and scalable FL. While significant advancements have been made in quantization algorithms and federated adaptations, challenges persist in maintaining accuracy under heterogeneity, achieving theoretical convergence guarantees, and deploying models on constrained hardware. The next phase of research must emphasize adaptive precision control, energy-aware optimization, and rigorous benchmarking to transform quantized FL from a theoretical concept into a practical enabler for large-scale, privacy-preserving distributed intelligence.

8 Conclusion↩︎

This paper presented a comprehensive PRISMA-based review of quantization techniques in FL, analyzing their impact on communication efficiency, accuracy, and scalability. By organizing existing methods into PTQ and QAT paradigms, the study provides a unified framework for understanding quantization’s role in communication-efficient FL. Regarding RQ1, findings show that quantization can achieve up to 10\(\times\)–50\(\times\) compression with minimal accuracy loss when properly calibrated. PTQ ensures deployment simplicity, while QAT enhances robustness in heterogeneous and non-IID environments. Hybrid PTQ–QAT approaches offer promising trade-offs between efficiency and precision. For RQ2, major challenges include balancing communication efficiency and model accuracy, handling client heterogeneity, mitigating convergence instability, and ensuring privacy in quantized updates. Addressing these requires adaptive, bias-compensated, and privacy-preserving quantization techniques. Under RQ3, research gaps persist in standardized evaluation, theoretical understanding of convergence, and real-world validation on edge hardware. The limited study of multi-objective, personalized, and privacy-preserving quantization frameworks highlights the field’s immaturity. Finally, RQ4 points to future directions such as adaptive and hybrid quantization, integration with pruning and compression, energy- and hardware-aware methods, and quantum-inspired paradigms. Establishing open benchmarks and multi-objective optimization frameworks will be vital for scalable, sustainable FL.

In summary, quantization is a key enabler of efficient, privacy-preserving FL. Progress now depends on bridging theory and practice through adaptive precision, standardized evaluation, and hardware–software co-design to realize robust and energy-efficient distributed intelligence.

9 Appendix A↩︎

In FL, model parameters denote the absolute network weights, model updates refer to the weight differences transmitted from clients to the server, and gradients correspond to local loss derivatives; although closely related, these quantities have distinct communication, convergence, and quantization properties and should be treated separately in FL system design.

References↩︎