A Full Compression Pipeline for Green Federated Learning in Communication-Constrained Environments Elouan Colybes∗ , Shirin Salehi∗ , and Anke Schmeink∗ ∗ Chair of Information Theory and Data Analytics (INDA), RWTH Aachen University, Aachen, Germany
arXiv:2604.11146v1 [cs.LG] 13 Apr 2026
[email protected], {shirin.salehi, anke.schmeink}@inda.rwth-aachen.de Abstract Federated Learning (FL) enables collaborative model training across distributed clients without sharing raw data, thereby preserving privacy. However, FL often suffers from significant communication and computational overhead, limiting its scalability and sustainability. In this work, we introduce a Full Compression Pipeline (FCP) for FL in communication-constrained environments. FCP integrates three complementary deep compression techniques—pruning, quantization, and Huffman encoding—into a unified end-to-end framework. By compressing local models and communication payloads, FCP substantially reduces transmission costs and resource consumption while maintaining competitive accuracy. To quantify its impact, we develop an evaluation framework that captures both communication and computation overheads as a unified model cost, allowing a holistic assessment of efficiency trade-offs. The pipeline is evaluated in an independent and identically distributed (IID) and non-IID data setting. In one representative scenario, training a ResNet-12 model on the CIFAR-10 dataset with ten clients and a 2 Mbps bandwidth, the FCP achieves more than 11× reduction in model size, with only a 2% drop in accuracy compared to the uncompressed baseline. This results in an FL training that is more than 60% faster.
I. I NTRODUCTION Recent advances in artificial intelligence (AI), particularly large language models (LLM), have transformed the perception and applications of AI across domains. This progress, enabled by increasing computational power, has led to unprecedented model complexity but also to significant energy demands and environmental concerns. The emerging paradigm of green AI advocates for efficient, sustainable learning systems [1], [2], contrasting with red AI, which prioritizes performance regardless of computational cost. Within machine learning (ML), federated learning (FL) [3] offers a distributed training paradigm where clients collaboratively train a global model without sharing raw data, enhancing privacy. However, despite these benefits, FL still suffers from significant communication and computational overhead due to frequent model updates. To address these challenges, we propose integrating deep compression techniques [4]—pruning, quantization, and Huffman encoding—into an end-to-end Full Compression Pipeline (FCP) for FL. FCP aims to improve communication efficiency, scalability, and sustainability while maintaining accuracy, aligning with green AI principles. The main goals of this paper are: (1) develop a flexible FL simulation framework supporting compression techniques; (2) provide an analytical characterization of the proposed FCP, including compression ratio, compression loss, and complexity analysis; (3) design a comprehensive FL evaluation framework to gauge computation and communication overheads as a unified model cost; and (4) demonstrate FCP’s generalizability across datasets and data distributions. The remainder of this paper reviews related work (Sec. II), describes the system setup (Sec. III), details the FCP (Sec. IV), presents results (Sec. V), and concludes (Sec. VI). II. R ELATED W ORKS Communication efficiency remains a major bottleneck in FL due to frequent model exchanges over constrained networks. Shahid et al. [5] highlight that bandwidth limits, device heterogeneity, and non-IID data hinder scalability, and survey mitigation strategies such as client selection, local updates, compression, and decentralization. Grativol et al. [6] integrate pruning and quantization-aware training (QAT) into the FL pipeline, but only as separate components to achieve a reduction in message size with small accuracy loss. Similarly, FedZip [7] combines Top-z sparsification, k-means quantization, and encoding to reduce the communication costs. ResFed [8] transmits compressed residuals predicted by local and server models, to yield communication savings while maintaining accuracy. CMFL [9] filters non-aligned client updates to improve efficiency, and FedCompress [10] employs adaptive clustering and server-side distillation for reduction. While existing approaches promote lightweight communication, they typically lack analytical evaluation of compression techniques in terms of compression ratio, accuracy loss, and computational complexity. Moreover, they often overlook the additional
Server
FedAvg
Step (1): Broadcast model to clients
Step (4): Decode and Aggregate
Weights
Clients
Step (2): Apply FCP
Train
Prune
101011101
Step (3): Send back compressed models to the server 01011100010110111110
Indices 0 2 3 7 8 10 131516
0: -2.33 1: 2.5
Encode
00: 4
Quantize
Calculate Difference
Weights
Indices
Generate Huffman Tree
0 2 1 4 1 2 3 2 1
10: 1 11: 2
010: 0 011: 3
Fig. 1: Our full compression pipeline to reduce communication overhead in federated learning
overhead introduced by these methods. In contrast, we introduce a unified cost model that analytically captures their joint impact on FL performance. III. S YSTEM SETUP We consider a server tasked with training a global model using the FL paradigm. The server coordinates a set of clients C, each holding private local data. At each communication round i, the server selects a subset S ⊂ C, sends them the current global (i) model, and receives their locally updated parameters ws . The server then aggregates these updates using the Federated Averaging (FedAvg) algorithm [11] to refine the global model through weighted averaging. Clients, simulating edge devices, perform local training and evaluation before transmitting their compressed updates to the central server. In our setup, we apply deep compression techniques after local training and before model upload, while maintaining full control over optimization hyperparameters such as learning rate, batch size, and momentum. In FL, compression can be applied upstream (client-to-server), downstream (serverto-client), or bidirectionally [12], though most approaches focus on the first two [7]. Upstream compression reduces server-side bottlenecks by minimizing update transmission, whereas downstream compression adds decoding overhead and may propagate errors to clients. Hence, we apply compression only upstream to balance efficiency and model integrity. IV. P ROPOSED FULL COMPRESSION PIPELINE FOR FL The goal of the proposed FCP is to minimize communication costs in FL while maintaining model fidelity. To achieve this, we adapt established compression techniques—pruning, quantization, and Huffman encoding, in the same order as introduced by Han et al. [4]—to the federated setting by integrating them sequentially within a single, layer-wise pass. Executing them in this order present multiple advantages, as detailed later. Performing all compression steps per layer in one loop improves computational efficiency compared to applying each method independently across all layers. We then derive explicit expressions for the communication compression ratio, analytical bounds on accuracy degradation due to compression noise, and a per-layer complexity characterization for client-side operations. The FCP pipeline is illustrated in Fig. 1 and Algorithm 1. A. Compression Pipeline 1) Pruning: We adopt unstructured, model-wise pruning, which removes individual weights with small magnitudes across the entire model. Our ablation studies indicate that this approach achieves a favorable trade-off between model sparsity and accuracy retention compared to structured or layer-wise pruning. Specifically, we set a global pruning threshold λ as the γquantile of all weight magnitudes, so that the smallest γ fraction of weights—those contributing least to the model output—are removed. This reduces memory usage and computational cost without significantly affecting model performance. Formally, let W = {w1 , w2 , . . . , wN } denote the set of all model weights, and let Wnp = {wi ∈ W | |wi | ≥ λ} be the set of non-pruned weights, so that |Wnp | = (1 − γ)N . 2) Post-training quantization (PTQ): We adopt codebook quantization (CQ) [4], a k-means-based method that clusters the reduced set of non-pruned weights Wnp = {w1 , . . . , w|Wnp | } into k clusters C = {c1 , . . . , ck }, with each cluster sharing a common Pk P value. Weights are not shared across layers. The clustering minimizes the within-cluster sum of squares: argmin i=1 w∈ci |w− C
ci |2 . The number of clusters is typically set by a bit parameter q so that k = 2q . The set of non-pruned and quantized weights
Algorithm 1 FL with Full Compression Pipeline (FCP) Input: γ: pruning rate Input: k: number of clusters for quantization Input: h: hyperparameters for local training Input: R: number of communication rounds Input: C: set of all clients Input: W (0) : initial global model weights 1: for each round i = 1 to R do 2: randomly select a subset S ⊂ C 3: broadcast W (i−1) to all s ∈ S 4: for each client s ∈ S in parallel do (i−1) 5: perform local training using h to obtain Ws (i−1) 6: λ ← γ-quantile(Ws ) //threshold for the unstructured pruning 7: for ℓ = 1, . . . , L do (i−1) 8: Find Wnp = {wi ∈ Ws,ℓ | |wi | ≥ λ} //set of non-pruned weights 9: Quantize Wnp in k clusters: Wnpq |W | 10: Calculate differences on Wnpq : {∆i }i=1np |Wnp | 11: Huffman encode Wnpq , {∆i }i=1 and send the encrypted values and codebooks 12: end for 13: end for 14: server decodesPall received updates 15: compute n = s∈S ns 16: aggregate: X ns (i) w(i) wglobal = n s s∈S
17: end for
is then Wnpq , having the same size as Wnp , and ∀ w ∈ Wnpq , ∃ i ∈ {1, k}, w = ci . Based on our ablation studies, we adopt layer-wise quantization for better results. With Huffman encoding, fixed-length bit representation is unnecessary, allowing flexible cluster specification. 3) Huffman Encoding for Pruned and Quantized Networks: We apply Huffman encoding to compress pruned and quantized weights in a lossless manner. Each weight value w ∈ Wnpq is replaced by a variable-length code c(w) such that the length ℓ(w) ∝ − log2 p(w), where p(w) is the empirical frequency of w in the layer. This ensures shorter codes for common values and longer codes for rare ones, minimizing storage and memory overhead without affecting accuracy. The encoded data is transmitted to the server. Following Han et al. [4], we Huffman-encode the index differences ∆(w) corresponding to the positions of nonzero weights to exploit repeated sparsity patterns within each layer. This step further reduces communication cost while preserving exact model reconstruction. The sequence of the three compression techniques is theoretically fixed: pruning prepares the model for subsequent compression steps, while quantization further structures the weight distribution in a way that facilitates more effective entropy encoding. 4) Huffman decoding: At the server, the neural network is reconstructed by reversing client-side encoding: Huffman-encoded data, indices, and codebooks are read, and using the Huffman trees, data and index differences are decoded into 1-D arrays. Index differences are converted to absolute indices via cumulative sums, enabling reconstruction of the sparse matrix (CSR/CSC) and full weight matrices by filling zeros. Once all client models are rebuilt, aggregation methods like FedAvg are applied as usual. B. Analytical Evaluation 1) Compression Ratio: During each communication round, clients transmit pruned, quantized, and Huffman encoded model updates to the central server for global aggregation. The communication overhead is measured by the total number of bits transmitted per round, denoted as B(γ, k). Let the uncompressed model contain N trainable parameters, each represented with b bits. The corresponding baseline transmission cost is B0 = N · b. After applying pruning with rate γ and quantization with
k clusters, and before Huffman encoding, the effective transmission cost becomes Bpq (γ, k) = (1 − γ)N · log2 (k). The final transmission cost for a single client after applying Huffman encoding is given by Bpqh (γ, k) =
X
ℓ(w) + ℓ(∆(w))
+ kb +
k X
M X ℓ(cj ) + M b∆ + ℓ(∆r ) .
(1)
r=1
j=1
w∈Wnpq
The total communication per round is obtained by summing over all participating clients. The first term represents the encoded payload (quantized weight values and their index differences). The second term corresponds to the codebook for centroids Codebookcentroids = {(cj , ℓ(cj )) | j = 1, . . . , k}, where k is the number of clusters and b is the number of bits used to represent each centroid. The third term accounts for the codebook of distinct index differences, Codebookidx = {(∆r , ℓ(∆r )) | r = 1, . . . , M }, where {∆r }M r=1 is the set of distinct index differences, M = |{∆r }|, and b∆ is the number of bits required to represent each ∆r . We can rewriteP the encoded payload of quantized weights as PM k Bweights = (1−γ)N j=1 p(cj ) ℓ(cj ) and their index differences as Bindices = (1−γ)N r=1 p(∆r ) ℓ(∆r ). Then the corresponding B (γ,k) is compression ratio pqhB0 k M k M X 1−γ X 1 X 1 X k M b∆ Hcomm (γ, k) = + + p(cj )ℓ(cj ) + p(∆r )ℓ(∆r ) + ℓ(cj ) + ℓ(∆r ). b N N b j=1 Nb N b r=1 r=1 j=1
(2)
As N is usually very large, and the codebooks have a relatively small size, the first term is widely dominant. This indicates that the codebook overhead becomes negligible for large models. 2) Compression Loss: Assumptions. We consider an L-smooth loss function, assume local stochastic gradients have bounded variance σg2 , and model compression (pruning and k-means quantization) as an additive error ϵs with bounded energy: E∥ϵs ∥2 ≤ σϵ2 . (i) Let ws denote the local model of client s at round i, and let Q(·) represent the compression operator. The compressed update (i) (i) (i) (i) (i) can be written as w̃s = Q(ws ) = ws + ϵs , where ϵs captures the compression-induced error. Since k-means quantization (i) and pruning are generally biased, E[ϵs ] ̸= 0, and this bias propagates through FedAvg aggregation: X ns X ns X ns (i+1) wglobal = w̃s(i) = ws(i) + ϵ(i) . (3) n n n s s∈S
s∈S
s∈S
(i+1) Under moderate pruning ratios and sufficiently fine quantization (large k), the perturbation remains bounded: E ∥wglobal − (i+1,uncompressed) 2 wglobal ∥ ≤ σϵ2 . As long as σϵ2 is small relative to the stochastic gradient variance σg2 , the global model converges with only minor accuracy degradation. This additive-noise perspective provides a tractable way to relate compression strength to expected accuracy loss without exhaustive per-layer simulations. 3) Computational Complexity: We compare the computational complexity of FCP with standard FL to quantify the additional cost PL introduced by pruning, quantization, and encoding. Let nℓ denote the number of trainable parameters in layer ℓ, and N = ℓ=1 nℓ the total model size. Baseline FL. For each client, forward and backward propagation as well as parameter updates scale linearly with N , giving a per-client, per-round complexity of O(N ). Across R communication rounds with |S| participating clients per round, the total FL cost is Ototal = O(R|S|N ). FCP. Beyond local training, each client performs model pruning, k-means quantization, and Huffman encoding. Pruning requires finding the threshold using a selection algorithm, O(N ), and scanning all parameters, O(N ). Quantization on the remaining (1 − γ)N weights adds O((1−γ)N kI), where k is the number of clusters and I is the number of k-means iterations. Huffman encoding of the quantized weights and index differences contributes O((1 − γ)N + k log k) for the values and O((1 − γ)N + M log M ) FCP for the indices, where M ≪ N . Summing over all layers yields a per-client complexity of Ocomp = O N + (1 − γ)N kI + 2(1 − γ)N + k log k + M log M . Treating k and I as constants, the overall complexity remains linear in N , assuming M ≪ N . Thus, FCP the total computational cost over all clients and rounds becomes Ototal = O(R|S|N ). Discussion. Although FCP introduces additional local computations, the overall complexity remains linear in N , similar to standard FL. Since k and I are small constants and 1 − γ ≤ 1, the extra compression overhead is modest relative to training cost. Moreover, applying a compression layer-wise helps reduce memory footprint and computational load. In practice, the compression overhead is not dominant compared to the communication savings achieved in bandwidth-limited environments.
V. S IMULATION R ESULTS A. Models and Dataset Our implementation builds upon the Flower framework [13], where we replace the default uniform partitioner with a Dirichlet partitioner [6] to control data heterogeneity via the concentration parameter α. Experiments are conducted on ResNet-12, a residual neural network with 780k trainable parameters. We evaluate on CIFAR-10 [14], a standard image classification dataset with 50,000 32×32 color images across 10 classes, and FEMNIST [15], a federated variant of MNIST, including 814,000 28×28 monochrome images. We consider both IID and non-IID data distributions, where the Dirichlet concentration parameter is set to α = 100 for the IID case and α = 1 for the non-IID case. In each communication round, 40% of the total clients (4 out of 10) are selected for the IID setting, and 20% (20 out of 100) for the non-IID setting. B. Hyper-Parameter Tuning For CQ, centroid initialization strongly impacts clustering quality and thus overall model performance; among the evaluated methods—Forgy (random), density-based, and linear—linear initialization consistently achieved superior accuracy. We further accelerated the quantization process by adopting CuML’s GPU-optimized k-Means implementation [16]. The best-performing federated configuration used a learning rate of 0.01, a batch size of 8, and one local training epoch per round. C. Accuracy Analysis As shown in Table I, IID CIFAR-10 maintains accuracy up to γ = 0.5 and k = 32, while non-IID CIFAR-10 degrades more sharply, reflecting higher sensitivity to compression. IID FEMNIST remains stable across all compression levels, and non-IID FEMNIST retains accuracy above 0.8 even under aggressive pruning and quantization. This dataset-dependent behavior arises because, in IID settings (CIFAR-10, FEMNIST), client updates are similar (ϵ̄(i) ≈ 0), minimizing compression effects. In nonIID CIFAR-10, diverse updates make ϵ̄(i) significant, amplifying accuracy loss. In contrast, non-IID FEMNIST benefits from redundancy and partial alignment among updates, keeping ϵ̄(i) small and preserving accuracy. Pruning Rate γ Number of
0.1
0.2
0.3
0.4
80.6 / 73.6 81.1 / 73.2 80.6 / 59.4 79.2 / 45.4 70.8 / 38.4 61.4 / 35.2 54.6 / 29.4
80.3 / 75.0 80.3 / 73.4 79.8 / 59.8 79.2 / 45.8 69.7 / 39.0 62.9 / 36.0 54.1 / 29.0
79.8 / 74.5 80.3 / 72.3 80.3 / 57.0 79.1 / 44.9 70.2 / 39.5 61.5 / 34.4 56.7 / 27.3
80.0 / 75.0 80.0 / 70.6 79.9 / 53.0 78.9 / 43.6 70.3 / 38.1 62.9 / 34.5 55.0 / 26.4
centroids k 256 128 64 32 16 8 4
0.5
0.6
0.7
0.8
0.9
0.95
77.9 / 65.5 77.9 / 59.1 77.2 / 50.5 74.8 / 40.3 66.5 / 34.3 60.9 / 29.8 52.1 / 23.4
73.9 / 59.3 73.9 / 55.7 72.8 / 44.1 69.6 / 36.2 64.3 / 34.0 57.7 / 28.1 51.4 / 20.4
70.3 / 54.3 70.9 / 50.2 69.5 / 43.5 66.9 / 35.5 61.6 / 31.8 55.2 / 25.6 47.3 / 20.0
88.4 / 84.8 88.5 / 85.1 88.4 / 84.5 88.3 / 84.2 88.0 / 83.2 87.9 / 82.2 87.0 / 79.3
88.1 / 83.8 88.5 / 83.8 88.2 / 83.6 88.1 / 83.7 87.9 / 82.3 87.5 / 81.0 86.7 / 78.8
88.0 / 82.6 88.1 / 82.8 87.8 / 82.7 87.7 / 82.5 87.4 / 81.4 87.0 / 79.8 86.0 / 76.8
IID / non-IID CIFAR-10, baseline = 80.7% / 75.6% 80.1 / 72.0 79.0 / 69.0 80.2 / 57.2 78.5 / 42.5 69.5 / 36.5 64.1 / 34.2 53.8 / 27.9
79.9 / 70.6 79.9 / 66.6 79.5 / 53.4 75.5 / 43.8 68.3 / 37.8 60.3 / 32.6 55.0 / 26.9
78.6 / 67.5 79.8 / 63.7 79.1 / 51.4 75.7 / 42.1 67.8 / 36.7 60.7 / 31.9 52.9 / 24.7
IID / non-IID FEMNIST, baseline = 88.8% / 85.7% 256 128 64 32 16 8 4
88.5 / 85.5 88.9 / 85.8 88.7 / 86.0 88.7 / 85.5 88.4 / 83.8 88.1 / 83.4 87.2 / 80.0
88.8 / 85.8 88.9 / 85.6 88.7 / 85.9 88.6 / 85.5 88.3 / 84.2 88.1 / 82.7 87.3 / 80.7
88.5 / 86.0 88.7 / 85.6 88.9 / 85.7 88.6 / 84.8 88.5 / 84.8 88.2 / 83.0 87.3 / 80.3
88.7 / 85.4 88.7 / 85.6 88.6 / 85.8 88.6 / 84.6 88.4 / 84.0 88.2 / 82.9 87.4 / 80.3
88.6 / 85.6 88.7 / 85.8 88.6 / 85.4 88.7 / 85.1 88.4 / 83.8 88.1 / 82.9 87.3 / 80.9
88.4 / 85.3 88.7 / 84.9 88.7 / 85.3 88.4 / 84.7 88.4 / 83.7 88.1 / 82.7 87.3 / 80.3
88.5 / 85.0 88.4 / 85.0 88.6 / 85.0 88.5 / 84.7 88.4 / 83.7 87.8 / 82.7 87.2 / 79.6
TABLE I: FCP performance accuracy values for different pruning rates and quantization levels in multiple scenarios. D. Compression Ratio Table II presents the compression ratios Hcomm (γ, k), representing the client communication overhead in the proposed FCP framework compared to the baseline FL. The results illustrate how different pruning rates and quantization levels affect the amount of data transmitted per communication round. As expected, higher pruning rates and lower quantization levels consistently reduce the communication load, demonstrating that FCP can effectively compress model updates while offering flexibility in selecting compression parameters.
Pruning Rate γ
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
0.95
256 128 64 32 16 8 4
0.227 0.193 0.165 0.133 0.103 0.092 0.084
0.205 0.179 0.151 0.122 0.097 0.089 0.079
0.183 0.158 0.134 0.111 0.085 0.080 0.073
0.160 0.139 0.117 0.097 0.079 0.074 0.067
0.140 0.122 0.104 0.086 0.073 0.069 0.061
0.117 0.101 0.085 0.073 0.063 0.056 0.054
0.090 0.079 0.068 0.057 0.049 0.046 0.043
0.065 0.056 0.048 0.043 0.035 0.034 0.032
0.037 0.032 0.027 0.023 0.021 0.020 0.018
0.022 0.019 0.016 0.014 0.013 0.012 0.011
Number of centroids k
TABLE II: Compression ratio for client communication overhead for different pruning rates and quantization levels.
E. Computation Overhead We analyze the computational overhead in terms of client, server, and total computation cost per round. Each client performs local training and compression before sending updates to the server. The client overhead for compression parameters γ, k is measured as a time ratio relative to the baseline training cost (without compression): Hclient (γ, k) =
ttrain + tcompress . ttrain
(4)
The server performs client selection, decompression, and aggregation. The server overhead is measured as a ratio relative to the baseline FL server cost (without decompression): Hserver (γ, k) =
tselect + taggregate + tdecompress . tselect + taggregate
(5)
Here, tdecompress is CPU-bound and typically much bigger than taggregate , thus server-side overhead is dominated by decompression. The ratio of the total computation cost per round relative to baseline, overall overhead, is given by: Hcompute (γ, k) =
tcompute , tselect + ttrain + taggregate
(6)
with tcompute = tselect + ttrain + tcompress + tdecompress + taggregate . Each H denotes an overhead ratio comparing FCP computation overhead with the baseline FL, with H > 1 indicating additional overhead introduced by the FCP pipeline. After simulation on CIFAR-10 (IID), we observe that the client overhead remains nearly constant (∼1.28–1.1) across pruning rates and quantization levels, suggesting minimal compression cost. In contrast, server overhead decreases sharply (from ∼117 to ∼26) mostly as γ increases, indicating that higher compression substantially reduces server processing. Consequently, the overall computational overhead declines steadily from approximately 2.4 to 1.36, demonstrating that the proposed method achieves significant efficiency gains with negligible impact on computation, especially for clients. Although relying on GPU for clients is not realistic, this assumption doesn’t affect the validity of the FCP. The reason is that the compression cost is small compared to the training cost, and downgrading the computation resources will affect the training much more than the compression. F. Convergence Speed We observe that FL training accuracy curves look much like first order systems step response behavior. Keeping the comparison up, we introduce a metric τ that corresponds to the round at which the FL training reaches 63% of its final accuracy. This metric allows an efficient comparison for convergence speed between trainings that don’t reach the same final accuracy. In the FEMNIST settings, the value of τ remains unchanged, while with CIFAR-10, compression induces a small overhead (∼10% to 20%) in terms of convergence speed. G. FCP Unified Model Cost To evaluate the FCP on the global scale, the ratio of the whole training time with the FCP TFCP (γ, k) is compared to that of the baseline Tbaseline : γ,k 5τγ,k · (tγ,k TFCP (γ, k) compute + tcomm_down + tcomm_up ) ρFCP (γ, k) = = . (7) γ,k t tγ,k Tbaseline 5τ · ( compute + t + comm_up ) baseline
Hcompute (γ,k)
comm_down
Hcomm (γ,k)
The numerator is the total FCP training time, calculated as 5τ times the per-round execution time. The denominator is computed similarly for the baseline. Downstream communication time is unchanged since FCP only compresses upstream transmissions. For a practical example, we can use the results of the first experiment (CIFAR-10 IID with 10 clients and 40% selection rate) with pruning rate γ = 0.5 and k = 32 quantization clusters. In this setup, the final accuracy drop is around 2% compared to the baseline. We consider two situations for the network bandwidth available: a. using a modern Bluetooth technology on low energy mode with 2 Mbit/s bidirectional rate; b. using an early 4g technology (LTE Cat 3) with 100 Mbps download rate and (IID),0.5,32 50 Mbps upload rate. We also measure tCIFAR-10 = 2.8466s and a model size of 3177 kB before compression (using compute pytorch.save()) and 274 kB after compression (using the FCP). The convergence speed is τ = 14 compared to 12 for the baseline. After calculation, for both situations we find respectively ρFCP (0.5, 32) = 0.3569 and 0.9790, so a global training time reduction of 64% and 2.1%. This illustrates the efficiency of the FCP under communication-restrained environments. VI. C ONCLUSION This study tackles the challenges of communication overhead and energy efficiency in FL by introducing the Full Compression Pipeline (FCP), a combination of pruning, quantization, and Huffman encoding. Each component is fine-tuned through detailed analysis and hyperparameter optimization to maximize efficiency with minimal accuracy loss. Evaluations on models like ResNet12 trained on CIFAR-10 show that under some conditions, the FCP can significantly reduce size of the model (e.g. by more than 90%) and speeds up the training rounds about 3× while maintaining near-baseline accuracy. Future works may extend the FCP on other model architectures and datasets. ACKNOWLEDGMENT This work was supported by the Federal Ministry of Research, Technology, and Space (BMFTR, Germany) as part of NeuroSys: Efficient AI-methods for neuromorphic computing in practice (Projekt D) - under Grant 03ZU2106DA, and also German Research Foundation (DFG) under the Cluster of Excellence CARE: Climate-Neutral And Resource-Efficient Construction (EXC 3115), project number 533767731. R EFERENCES [1] Roy Schwartz, Jesse Dodge, Noah A Smith, and Oren Etzioni, “Green ai,” Communications of the ACM, vol. 63, no. 12, pp. 54–63, 2020. [2] Shirin Salehi and Anke Schmeink, “Data-centric green artificial intelligence: A survey,” IEEE Transactions on Artificial Intelligence, vol. 5, no. 5, pp. 1973–1989, 2024. [3] H. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Agüera y Arcas, “Communication-efficient learning of deep networks from decentralized data,” 2023. [4] Song Han, Huizi Mao, and William J. Dally, “Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding,” 2016. [5] Osama Shahid, Seyedamin Pouriyeh, Reza M. Parizi, Quan Z. Sheng, Gautam Srivastava, and Liang Zhao, “Communication efficiency in federated learning: Achievements and challenges,” 2021. [6] Lucas Grativol Ribeiro, Mathieu Leonardon, Guillaume Muller, Virginie Fresse, and Matthieu Arzel, “Federated learning compression designed for lightweight communications,” 2023. [7] Amirhossein Malekijoo, Mohammad Javad Fadaeieslam, Hanieh Malekijou, Morteza Homayounfar, Farshid Alizadeh-Shabdiz, and Reza Rawassizadeh, “Fedzip: A compression framework for communication-efficient federated learning,” 2021. [8] Rui Song, Liguo Zhou, Lingjuan Lyu, Andreas Festag, and Alois Knoll, “Resfed: Communication-efficient federated learning with deep compressed residuals,” IEEE Internet of Things Journal, vol. 11, no. 6, pp. 9458–9472, 2023. [9] Luping WANG, Wei WANG, and Bo LI, “Cmfl: Mitigating communication overhead for federated learning,” in 2019 IEEE 39th International Conference on Distributed Computing Systems (ICDCS), 2019, pp. 954–964. [10] Vasileios Tsouvalas, Aaqib Saeed, Tanir Ozcelebi, and Nirvana Meratnia, “Communication-efficient federated learning through adaptive weight clustering and server-side distillation,” in ICASSP 2024-2024 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 2024, pp. 5805–5809. [11] Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas, “Communication-efficient learning of deep networks from decentralized data,” in Artificial intelligence and statistics. PMLR, 2017, pp. 1273–1282. [12] Suhail Mohmad Shah and Vincent K. N. Lau, “Model compression for communication efficient federated learning,” IEEE Transactions on Neural Networks and Learning Systems, vol. 34, no. 9, pp. 5937–5951, 2023. [13] Daniel J. Beutel, Taner Topal, Akhil Mathur, Xinchi Qiu, Javier Fernandez-Marques, Yan Gao, Lorenzo Sani, Kwing Hei Li, Titouan Parcollet, Pedro Porto Buarque de Gusmão, and Nicholas D. Lane, “Flower: A friendly federated learning research framework,” 2022. [14] Alex Krizhevsky, “Learning multiple layers of features from tiny images,” Tech. Rep., University of Toronto, 2009. [15] Sebastian Caldas, Peter Wu, Tian Li, Jakub Konečný, H Brendan McMahan, Virginia Smith, and Ameet Talwalkar, “Leaf: A benchmark for federated settings,” in Workshop on Federated Learning for Data Privacy and Confidentiality, 2018. [16] RAPIDS AI, “cuml api reference: K-means clustering,” 2025, Accessed: 2025-04-07.