Practical Hybrid Gradient Compression for Federated Learning Systems

1 Introduction

Federated learning (FL) [McMahan et al., 2017] enables collaborative learning of a global model from multiple clients without directly communicating each client's private data, by passing model parameters, gradients, or other information about the models. The high communication cost is one of the key bottlenecks in FL training processes, especially for geographically distributed settings required by federated learning. In practice, their bandwidth is often limited to less than 100Mbps [Yang et al., 2019; Philippenko and Dieuleveut, 2022], or it is simultaneously charged, such as 4G/5G networks. Since the communication of uncompressed FL often take gigabytes or even terabytes through iterations, it can easily cost over 80% of the total training time [Xu et al., 2021; Chen et al., 2020] and waste bandwidth resources. Thus, reducing the communication cost in the FL training process is essential for practical deployment of FL systems.

Methods that utilize sparsification [Aji and Heafield, 2017; Lin et al., 2018; Stich et al., 2018; Chen et al., 2020], quantization [Wen et al., 2017; Alistarh et al., 2017; Bernstein et al., 2018; Wu et al., 2022], and their combinations [Basu et al., 2020; Sattler et al., 2020] are shown to be the most effective methods for reducing the communication costs in FL training processes. However, they only focus on compressing the messages in the uplink channel (i.e., model/gradients sent from clients to the server). Although the downlink channel is generally considered to be less bandwidth-limited when compared to the uplink channel [Yue et al., 2022; Philippenko and Dieuleveut, 2022], their bandwidth difference is still within the same order of magnitude. Even within the same cluster, regular Ethernet switch usually provides 1Gbps bandwidth at maximal [Wen et al., 2017], while mobile devices are more limited, averaging at 33.88/9.75 Mbps downlink/uplink in the U.S. in 2019 [Zhang et al., 2020]. In this paper, we show that under a 1Gbps network, with a model having tens of megabytes, the downlink communication can still dominate the training process by taking more than 50% of the training time, even when the uplink communication is sufficiently compressed, as shown in the experiments in Section 5. Therefore, compression algorithms that apply to both uplink and downlink channels are essential to effectively reduce the communication costs in FL training.

To achieve bi-directional compression, a naive idea is to simply apply the same compression method on the downlink channel that is originally used for uplink compression, as employed by existing works [Tang et al., 2019; Zheng et al., 2019; Sattler et al., 2020]. However, these algorithms do not efficiently utilize gradient information. First, they tend to over-compress the gradients. Since each gradient is compressed twice in a communication round, only partial information gathered from the clients is used for updating the global model, consequently degrading the quality of the global model. Second, they only focus on compressing individual clients' gradients but overlook the potential for further reducing the communication cost by utilizing redundancies between clients and across the temporal dimension. Thus, the quality of their global models is not satisfactory. As an example of these two inefficiencies, STC [Sattler et al., 2020] only achieves 83.82% accuracy in the CIFAR-10

task when the sparsification ratio is 0.1% in our reproduction, while the accuracy for the baseline FedAvg algorithm in the same setting is 90.52%.

In short, existing gradient compression algorithms for FL have deficiencies in balancing communication and model accuracy. It involves two aspects: 1) Optimizing communication cost in both the uplink and downlink directions to prevent loss of model quality or convergence rate due to overcompression in the downlink channel. 2) Reduce repetitive or similar information within the gradient of one client, across different clients, and among consecutive gradients updates, to achieve superior compression ratios. We name these repetition intrinsic, cross-client, and temporal redundancy.

To address these issues, we propose a Hybrid Gradient Compression (HGC) algorithm in this paper that utilizes combined compression techniques, including sparsification, quantization, and encoding, to optimize the trade-off between model quality and communication cost. More specifically, we first apply sparsification on the gradients with a shared sparsification mask. Then, the sparsified gradients are quantized and entropy-coded to maximize the compression ratio. These techniques maximizes the compression ratio in both uplink and downlink channels by exploiting the redundancies we have identified, reducing the total size of gradients and metadata such as sparsification masks transmitted.

Our contributions can be summarized as follows.

• We design a FL gradient compression algorithm that operates efficiently on uplink and downlink channels simultaneously and supports existing secure FL techniques. To the best of our knowledge, we are the first to identify and utilize the three types of redundancies for FL gradient compression to achieve a state-of-the-art compression ratio.
• We propose novel optimization methods, namely compression ratio correction and dynamic momentum correction. They effectively improve our compression algorithm to enable efficient trade-off between communication cost and model performance.
• With theoretical analysis of our algorithm, we provide both the convergence guarantees of a generalized gradient compression system. We also provide guidelines for selecting its components and parameters.
• With empirical analysis of our algorithm, we show that our algorithm can achieve a compression ratio much higher than state-of-the-art methods without loss of model accuracy. We also show that our algorithm performs well in various FL scenarios, including skewed data distribution, large-scale training, and secure FL.

In the following part of this paper, we first formalize the problem and elaborate on the backgrounds of gradient compression in Section 2. In Section 3, we present the details of our compression algorithm. Section 4 and Section 5 present the theoretical and empirical analysis, respectively. Finally, we summarize and conclude our work in Section 6.

2 Backgrounds

The FL problem with N clients collaboratively training on a global model w can be formalized as, where wi are the model weight of client i (i ∈ [N]). The weight update rules of its uplink (from client to server) and downlink (from server to client) channels are should be:

To compress the gradient, we apply compressors to the communication process:

The main target of this paper is to find good compressors comp up and comp down that balance well between the model quality, communication cost, and computation cost. Note that the non-compressed algorithm can be viewed as a special case of Equation 2, where comp up = comp down = f : x ↦→ x (the identity function).

Related works can be categorized based the on compression techniques they use. While gradient compression has a broad range of techniques, we specifically focus on those that are particularly relevant to our work and align with our focus on compression in FL settings.

Sparsification. Sparsification algorithms utilize the sparsity of gradients and only transmit part of them using sparsification masks. The top-k mask selection method [Aji and Heafield, 2017; Alistarh et al., 2018] is widely used due to its implementation simplicity and high convergence efficiency. Top-k selects and transmits k elements in the gradient sorted by their absolute values. Other index selection methods such as random-k [Stich et al., 2018] and sketch-based [Ivkin et al., 2019] methods have also been widely studied, but they do not show efficiency superior to top-k-based methods.

A typical example of top-k-based compression algorithms is Deep Gradient Compression (DGC) [Lin et al., 2018]. It is a widely tested and compared sparsification algorithm. It updates each client's top-k mask in every communication round and uses the mask to compress the uplink channel communication. Additionally, it performs error feedback to amortize the error inducted by top-k, where the error is stored locally and added to the momentum in subsequent communication rounds. Another noteworthy application of top-k sparsification is ScaleCom [Chen et al., 2020]. It proposes the cyclic top-k (CLT-k) method that explores and utilizes the similarity between the gradients on each client, which shows scalability advantage compared to other algorithms [Strom, 2015; Chen et al., 2018; Lin et al., 2018] that simply apply of top-k on all the clients.

Quantization. Quantization is another way of compressing the gradient by reducing the number of bits of each element in the transmitted gradients. Existing studies such as signSGD [Bernstein et al., 2018] and 1-bit SGD [Seide et al., 2014] show that 1-bit quantization is practical and sometimes sufficient in the model training process. More quantization bits are often allowed to better approach the uncompressed gradients by optimizing the selection of quantization levels [Alistarh et al., 2017; Yu et al., 2019]. Other auxiliary methods such as error-feedback mentioned in the sparsification methods can also be applied in the quantization process [Karimireddy et al., 2019; Wu et al., 2018] to further improve the convergence of the training process.

Encoding. Quantization provides a fixed maximum compression ratio. That is, if we compress all 32-bit floats to 1-bit, the overall compression ratio will be 32×. If combined with proper lossless encoding, the overall communication cost can be further reduced. Traditional Huffman-codingbased encoding algorithms such as DEFLATE [Deutsch, 1996] and entropy encoding methods like arithmetic encoding [Witten et al., 1987] have shown their efficiency for quantized gradients [Abdi and Fekri, 2019]. Golomb coding [Golomb, 1966] can also reduce the size of indices after sparsification [Sattler et al., 2020; Wu et al., 2022]. Recently, predictive coding techniques [Yue et al., 2022] inspired by video processing have also been proposed, which utilize historical gradient data to further improve the compression ratio of the encoding process.

Hybrid Algorithms. Hybrid approaches utilizing multiple compression methods, especially sparsification and quantization, have been studied to further improve the compression ratio and also achieve other goals such as improving the communication-computation trade-off. Both Qsparselocal-SGD [Basu et al., 2020] and STC [Sattler et al., 2020] combine top-k sparsification and quantization, while SketchML [Jiang et al., 2018] combines sketching and quantization to improve the compression ratio.

However, as we compare the performance of the above methods in Table 1, we find that none of them achieve an optimal state in terms of utilizing data redundancies to achieve a sufficient compression ratio, while also handling bi-directional compression. Most of them only target reducing the intrinsic redundancies of the gradients on individual clients. Meanwhile, they do not ensure compatibility to secure FL, since the gradient size increases when exchanging data between clients. As of today, these algorithms still remain the most performant ones in their respective settings to the best of our knowledge. Other related works such as GossipFL [Tang et al., 2023] either add a different objective other than maximizing the compression ratio or do not provide comparable performance. This leaves us with the possibility to further optimize the entire compression framework.

3 Hybrid Gradient Compression

We design our framework to exploit intrinsic redundancies within a gradient, cross-client redundancies among different clients, and temporal redundancies between consecutive gradients updates to achieve superior compression ratios. The training loop of our algorithm resembles that of FedAvg [McMahan et al., 2017]. The clients train models and compress gradients, which are then sent to the server.

The server decompresses and aggregates the gradients, then broadcasts the gradients to all clients.

Figure 1 illustrates the detailed compression steps on the server and clients, respectively. Note that the communication rounds begin with the model trainer in Figure 1. For each client i, the model trainer computes the gradient gi. The gradient gi is then passed through the sparsifier and quantizer, along with the predicted gradient p. The compressed gradient ˜ gi and prediction ˜ p are combined using the XOR operator to compute the gradient residue ˜ ei in order to reduce the entropy of the message. The residue ˜ ei is then sent to the server through the uplink channel 2 together with the encoded sparsification mask, where both ˜ ei and the mask is encoded with lossless entropy-encoding methods.

The server reverses the client's compression process and mirrors the client's prediction process for restoring the compressed gradient residue ˜ ei to the original compressed gradient ˜ gi. After aggregating gradient ˜ gi with the aggregator to obtain ˜ g, the server uses ˜ g to update the global model. Simultaneously, ˜ g is sent to both the server's prediction buffer and the clients' prediction buffers to keep all buffers synchronized 4 . The local model updates are also performed in this process, completing a communication round.

Compared to existing hybrid gradient compression algorithms, our proposed algorithm has two major differences. First, all clients' sparsifiers and the server's sparsifier share the same user-selectable mask, effectively reducing the indices transmission cost. On the uplink channel, only one client transmits the hard-to-compress mask, while other clients only transmit highly-compressible gradient. On the downlink channel, our approach maintains sparsity of ˜ g when aggregating ˜ gi while preventing over-compression in the downlink channel. Second, unlike other studies utilizing gradient residues [Chen et al., 2018; Yue et al., 2022], our algorithm computes the gradient residue ˜ ei after the sparsification and quantization processes. This decouples the prediction process from sparsification and quantization, making it optional and providing us with more control over the lossy compression aspect of the entire algorithm. A more detailed pseudo code implementation is provided in Appendix A.3.

3.1 Hybrid Compression

As shown in Figure 1, our hybrid compression method mainly involves three components: sparsification, quantization, and encoding. The gradient of each client gi is fed through the sparsifier and quantizer, then through the encoder. The sparsifier and quantizer exploit the intrinsic redundancies of the gradient. The mask generation process of the sparsifier utilizes the cross-client redundancy, and then the predictor combined with the encoder utilizes the temporal redundancy. We now elaborate on these three phases separately. The detailed analysis of the redundancies can be found in Appendix A.1.

Table 1: Comparison of compression algorithms.

Sparsification. Both the low efficiency of current compression methods in downlink and secure-aggregation scenarios are caused by sparsification mask mismatch. We illustrate it with a toy example shown in Figure 2a. When performing sparsification independently on different clients, there is a high chance that the sparsification masks differ. Adding these sparse vectors together reduces the result's sparsity, which affects communication efficiency in FL training. However, if the sparsification masks are matched, as shown in Figure 2b, the result shows no sparsity drop. Therefore, well-matched masks can greatly improve the effectiveness of sparsification.

Maintaining a high sparsity level during training is crucial, since the cost of transmitting sparse mask indices is generally higher than the cost of transmitting the sparsified gradient elements. While the sparsified gradient elements can be further compressed through quantization and encoding, the sparse indices themselves are typically incompressible. Therefore, reducing the communication cost of indices is crucial. One effective method to achieve this is by allowing all clients to share indices. By doing so, the communication cost associated with transmitting indices can be significantly reduced.

Apart from making the mask shared, there are no extra restrictions on how the mask should be selected. Either top-k, random-k or even a combination of them can be used. In practice, we find that it is most efficient to make all clients share

(a) Mismatched masks

(b) Matched masks one client's top-k mask, minimizing the communication cost of uploading and downloading indices while still maintaining a high global model quality.

Figure 2: Sparsification with mismatched/matched masks.

Quantization. We choose the quantizer Q with L quantization levels where the l-th level has lower and upper bounds of xmin l and xmax l . We define the index set of l-th level as Il = {i|xmin l ≤ xi < xmax l } and quantize every element in the original tensor x such that:

We select the quantization levels by evenly dividing the positive and negative elements in x separately, so that all levels of the same sign have roughly the same number of elements. This quantizer can be viewed as a generalized version of the quantizer used in STC [Sattler et al., 2020], which has been proven effective when combined with the top-k sparsifier.

Encoding. We use the Golomb encoding [Golomb, 1966] to compress the sparsified indices, which can achieve a compression ratio of 2-3× for 32-bit indices [Sattler et al., 2019; Sattler et al., 2020]. We then use arithmetic encoding combined with gzip to compress the quantized and sparsified gradients. Since encoding of the gradient is closely related to the entropy of the data being encoded, we introduce a predictive coding module to reduce such entropy, inspired by a prior predictive encoding work [Yue et al., 2022]. Instead of predicting model weights, the predictor in our approach is expected to generate predictions p that are either positively or negatively correlated with gradient gi, so that their sparsified and quantized difference ˜ ei can be more biased than ˜ gi to reduce the entropy of the data being encoded. Specifically, in each communication round, we store the aggregated gradient ˜ gt and generate the prediction pt as shown in Equation 4, similar to the update rule of the Adam optimizer [Kingma and Ba, 2017]. ut and vt are initialized as zeros, and β is the running average coefficient.

The buffers only need to store ut, vt and ˜ gt, all having the same size of the sparsified gradient. The buffers are synchronized among the server and all clients to make sure that the server and clients get the same predictions. As such, the residue can be correctly restored.

3.2 Optimization Techniques

We consider optimization techniques when implementing HGC, namely sparsification ratio and momentum adjustment, and error feedback. Both of them are essential for improving the model quality in FL when compression is applied.

Dynamic sparsification ratio and momentum adjustment. Through preliminary experiments, we find that sparsification of gradients can lead to the training process to be trapped by saddle point or local minima, since it essentially limits the dimension of optimization direction. We also find that dynamic adjustment of the sparsification ratio helps alleviate this issue and improves the convergence accuracy when used together with error feedback. Further demonstrations of this issue can be found in Appendix A.2. Regarding momentum, multiple studies have addressed its ability to accelerate convergence [Phansalkar and Sastry, 1994; Qian, 1999] and to enable the model to jump out of saddle points [Wang et al., 2020]. Therefore, the adjustment of momentum is also given special consideration in our design.

Although the time and duration for adjusting these two parameters are decided empirically, we find that adjusting these parameters after the optimization process reaches a plateau can minimize the adjustment duration required, and thus incur trivial communication overhead. When using stepped learning rate schedulers, we temporarily lower the compression ratio before and after the learning rate is changed, followed by the momentum change.

Error Feedback. Since the sparsification and quantization used in our algorithm are biased, error feedback is necessary. We adopt the same error feedback algorithm used in existing algorithms [Lin et al., 2018; Karimireddy et al., 2019]. Specifically, we maintain error buffers mi that have the same size as the model on each client i and initialize them as 0. At the end of each local training, we accumulate the errors locally by updating mi as follows: mi ← mi + ˆ∇fi(w) - Decompress(Compress( ˆ∇fi(w))), where ˆ∇fi(w) is the gradient on client i. Then, we add them back to the gradients in the next communication round by ˆ∇fi(w) ← ˆ∇fi(w)+mi.

4 Analysis

We theoretically analyze the HGC from two perspectives: the convergence rate and the system utilization (i.e., the communication and computation cost). The precondition for the convergence analysis also provides us with some insights for the selection of the compressor. The detailed proofs of the convergence can be found in Appendix B.

4.1 Selection of the Compressor

Lemma 1 (Contraction property of the compressor). For any sparsifier S and quantizer Q satisfying min(0, 2µl) < Q(xi) < max(0, 2µl) for all its quantization level l, compressor Q ◦ S satisfies the following contraction property:

where 0 ≤ γ ≤ 1 is the contraction coefficient.

Remark. The contraction property of the compressor has been shown to be fundamental to various convergence analyses that involve gradient compression [Alistarh et al., 2018; Stich et al., 2018]. This lemma states that the convergence bound shown in the following Theorem 1 is applicable to a wide range of compressors, quantizers, and their combinations that meet the stated criteria.

4.2 Convergence Analysis

With the contraction property in Lemma 1, the proof in convex optimizations immediately follows the proof of Stich et al. [Stich et al., 2018]. The convergence bound in the nonconvex case is shown as follows.

Assumption 1 (L-Lipschitz Continuity). We assume that the target function is L-Lipschitz continuous, i.e., ∥∇f(x) - ∇f (y)∥ ≤ L∥x - y∥, ∀x, y ∈ Rd .

Assumption 2 (Stochastic Gradient Bound). We assume that the stochastic gradients are unbiased and bounded in every client: Eˆ∇fi(x) = ∇fi(x), ∥ˆ∇fi(x)∥ ≤ G, ∀i. It immediately follows that the sum of them is also bounded: E∥ 1n ∑ni=1 ˆ∇fi(x)∥2 ≤ G2 .

Theorem 1 (Convergence bound). Under Assumption 1 and 2, with a learning rate ηt = η0 = c/√T, ∀t where 0 < c < √T · min{1, 1/(√2γ)} being a constant, the algorithm converges to a local optimum. Specifically, after T communication rounds, we have

Indicating that the algorithm implemented by our algorithm has O(1/√T ) convergence rate.

Remark. Assumptions 1 and 2 are the assumptions widely used in convergence analysis of machine learning studies [Alistarh et al., 2018; Stich et al., 2018]. Theorem 1 shows that the convergence rate is at least the same as FedAvg (i.e. O(1/√T)), which can be further verified in the experiments in Section 5.

4.3 Communication and Computation Cost

In the worst-case scenario, assuming all data after sparsification and quantization are incompressible, the uplink compression ratio of one communication round, with N clients, a top-k sparsifier and quantization bits of q (assuming 32-bit indices and gradients) applied to a model with M parameters, the uplink compression ratio of one communication round will be 32MN/((Nq + 32)k) and the downlink compression ratio M/2k. However, the actual situation can deviate significantly from this worst-case due to multiple factors influencing the compression ratio, including the effectiveness of the predictor and the entropy encoder. When considering end-to-end compression ratios, additional factors come into play, such as the sparsification ratio warm-up method and the adjustment of the sparsification ratio. Therefore, it is necessary to measure these ratios empirically.

Table 2: Communication and computation costs.

The additional computational overhead required for compression is negligible compared to the training time, as it only involves a few basic operations such as sorting, addition, and bitwise operations on the gradients. On the contrary, the reduction in gradient size significantly reduces the server's workload, as fewer data from each client needs to be processed. A formalized definition and analysis of the communication and computation costs can be found in Appendix 4.3.

5 Experiments

We use FedAvg [McMahan et al., 2017] as the baseline algorithm and evaluate our method using ResNet-18 [He et al., 2016] on CIFAR-10 [Krizhevsky et al., 2009] and two-layer LSTM [Press and Wolf, 2017] on Penn-TreeBank (PTB) [Marcus et al., 1993]. Unless otherwise specified, we deploy the FL system with four clients with a learning rate of 0.1 for CIFAR-10, and a learning rate of 20 for PTB. We reduce the learning rate by a factor of 0.1 at 50% and 75% of the training process. For algorithms involving sparsification, we use the same sparsification ratio warm-up technique to speed up the training process. Specifically, we exponentially step down the sparsification ratio from 0.25 to the target in 300 iterations. We conduct experiments on a server with two Intel Xeon Gold 6248 CPUs @ 2.50GHz, 192GB of memory @ 3200MHz, and four Nvidia Tesla V100 GPUs.

5.1 Comparison with Other Methods

In addition to the FedAvg baseline, we compare our algorithm with DGC [Lin et al., 2018], EF-signSGD [Karimireddy et al., 2019], and STC [Sattler et al., 2020], which represent the current state-of-the-art algorithms of sparsification, quantization, and hybrid algorithms, respectively. To ensure fair comparisons, we set the sparsification ratio to 0.1% for all algorithms and use 1-bit quantization for all quantizers. We apply the same encoders for indices and data to all algorithms where possible.

In the baseline FedAvg experiments, the amount of data transmitted is identical for both uplink and downlink channels. For the CIFAR-10 task, the size per client per communication round is 44.70MB, resulting in a total data transmitted of 8760.48GB. For the PTB task, the size per client per communication round is 104.50MB, and the total data transmitted is 4915.84GB. We can see that the huge communication volume can be problematic, when the bandwidth is limited on the uplink and downlink channels.

Table 2 presents the communication costs of the tested algorithms, measured by the maximum compression ratio per client per communication round (i.e., Max CR) and the endto-end compression ratio (i.e., Total CR), separately for the uplink and downlink channels. We also report the speedup achieved by our algorithm compared to FedAvg, assuming a 1000Mbps uplink and downlink bandwidth for the server.

From Table 2 we observe that: 1) The downlink channel is essential for total compression ratio, but over-compression on this channel impairs model quality. 2) Our algorithm achieves the best in maximum compression ratios and total uplink compression ratios without losing accuracy. The total downlink compression ratio is lower than the STC algorithm since it also quantizes the downlink channel while our algorithm doesn't. However, STC does not achieve a convergence accuracy comparable to the baseline due to its over-compression, and the total speedup is not mitigated by the extra downlink compression. Detailed breakdown analysis of accuracy and compression ratio can be found in Appendix C.1.

5.2 Adaptiveness to Federated Learning

To evaluate the compatibility of our algorithm and other FL features, we perform experiments with changes to FL aspects as shown in prior surveys and studies [Li et al., 2022; Yue et al., 2022], namely non-i.i.d (non-identical and independently distributed) datasets, large number of clients, and secure FL.

Figure 3 shows each algorithm's performance under heterogeneously distributed datasets. Although the model quality degrades in this scenario, our algorithm still converges to a higher accuracy compared to other algorithms under non-i.i.d settings, indicating that our algorithm is more robust against heterogeneously distributed data. The HGC + FedProx result also demonstrate our algorithm's compatibility with other optimization algorithms like FedProx [Li et al., 2020].

The experiments in Figure 4 and 5 are performed with a 4-layer CNN on the FEMNIST [Caldas et al., 2018] dataset. Since the FEMNIST dataset is collected from 3550 different users, it more closely simulates real-life scenarios. We sample users from the dataset equal to the number of clients and assign each user's data to a client. The result in Figure 4 shows that all algorithms, including the baseline, scale linearly with the number of clients, but our algorithm saves significantly more communication bandwidth with clients.

When secure aggregation is applied to the FL algorithms, the total communication cost of other algorithms scales superlinearly with the number of clients due to additional data being exchanged between clients. As shown in Figure 5, since our algorithm utilizes cross-client redundancy that applies the same mask to all clients, the cost per client remains constant with the number of clients changed as opposed to other sparsification-based algorithms communication. All the above results show that our compression algorithm can be more efficiently adapted to various FL scenarios compared to other compression algorithms. Detailed setup and analysis of these experiments can be found in Appendix C.2.

5.3 Ablation Studies

To explore the effects of various hyperparameters and gain deeper insights into the internals of our algorithm, we conduct a detailed analysis of the maximum uplink gradient compression ratio. This ratio is categorized into three parts, which makes use of the three types of redundancies discussed in the backgrounds. These parts are denoted as CRi, CRc, CRt. By manipulating the algorithm setup, we evaluate these ratios alongside other relevant metrics. A subset of the results is presented in Table 3 and 4.

• ∗ CRup denotes overall uplink compression ratio of the entire training process.

Table 4: Compression ratio decomposition.

From Table 3 we observe that in our algorithm, the utilization of the intrinsic redundancy contributes most to the total compression ratio, while the other two types of redundancies help amplify it. Table 4 shows that both quantization and sparsification have a significant impact on the overall compression ratio and speedup, but they affect the system in different ways. Furthermore, we notice that the optimal hyper-parameters settings for balancing the communication and model accuracy are different under different scenarios. Appendix C.3 shows more detailed evaluations of the impact and effectiveness of each component on resource utilization and model accuracy.

6 Conclusion

In this paper, we present a novel hybrid gradient compression algorithm for federated learning, which effectively compresses the messages both on the uplink and downlink in the FL training process by leveraging three types of redundancies. Through theoretical analysis, we show that our approach achieves convergence at least as fast as the conventional FedAvg method. Furthermore, our empirical studies show the high performance of our algorithm in complex scenarios, including skewed data distribution, large-scale training, and secure FL. Our algorithm achieves a high compression ratio and offers valuable insights for future implementations of compression algorithms in FL.

Acknowledgments

This research is supported by the National Research Foundation, Singapore and DSO National Laboratories under the AI Singapore Programme (AISG Award No: AISG2-RP2020-018), and the National Research Foundation, Singapore and Infocomm Media Development Authority under its Trust Tech Funding Initiative. Any opinions, findings and conclusions or recommendations expressed in this material are those of the author(s) and do not reflect the views of National Research Foundation, Singapore and Infocomm Media Development Authority.