MUFFLe: Efficient Model Update Compression via Generalized Deduplication for Federated Learning Xiaobo Zhao, Daniel E. Lucani
arXiv:2606.14354v1 [cs.LG] 12 Jun 2026
DIGIT, Department of Electrical and Computer Engineering, Aarhus University {xiaobo.zhao, daniel.lucani}@ece.au.dk
Abstract—Federated learning is well suited to edge environments but is often limited by the uplink cost of transmitting model updates. This Work-in-Progress paper presents MUFFLe, a communication-efficient update compression scheme that integrates generalized deduplication (GD) into the FedAvg pipeline. MUFFLe deduplicates repeated patterns across the update vector, yielding a fixed-rate, variable-count compression scheme. Preliminary experiments on IID MNIST with 20 clients show that MUFFLe reaches the target accuracy of 92.93% with 38 MB cumulative uplink communication, compared with 75 MB for 8bit quantization, 86 MB for Top-k sparsification, and 310 MB for uncompressed FedAvg. These results demonstrate the feasibility of applying GD to communication-efficient federated learning. Index Terms—Federated learning, communication-efficient learning, edge computing, generalized deduplication
I. I NTRODUCTION Federated learning (FL) enables distributed model training across edge devices without centralizing raw data [1]. In practical edge deployments, however, client-to-server update transmission often becomes the main bottleneck due to limited uplink bandwidth, non-negligible latency, and increased device energy consumption [2], [3]. A common way to reduce communication cost is to compress local updates before transmission. Representative approaches include quantization [4], which reduces the bit-width of each value, and Top-k sparsification [5], which transmits a subset of update entries. In this paper, we investigate a different direction based on generalized deduplication (GD) [6]–[9]. Specifically, MUFFLe adapts GD to lossy federated update compression by retaining non-constant most-significant bits and deduplicating repeated base patterns across update entries. This yields a fixed-rate, variable-count compression scheme, where the retained bitwidth is fixed while the number of transmitted bases depends on the redundancy structure of the update. Although MUFFLe may appear similar to a combination of quantization and Top-k sparsification, as shown in Fig. 1, it is fundamentally different in that it reduces communication by exploiting repeated patterns across the full update, rather than by uniformly lowering precision or transmitting only a subset of entries. Moreover, MUFFLe is orthogonal to these strategies and can be combined with quantization or sparsification in future work. We present this study as a proof of concept in a preliminary Work-in-Progress (WiP) setting. Experiments on independent This work has been supported in part by the Forever Bearing project (Grant No. 4353-00017B) and the CRISPER-IoT project (Grant No. 5364-00007B) granted by the Innovation Foundation Denmark.
q-bit
32-bit
d-dim
d-dim
(a) Uncompressed
(b) Quantization
32-bit k-dim
g-bit nb-dim
(d) MUFFLe
(c) Top-k
Fig. 1: Comparison of update-transmission strategies considered in this work: (a) uncompressed communication, (b) Quantization, (c) Top-k sparsification, and (d) MUFFLe. and identically distributed (IID) MNIST [10] with 20 clients and a lightweight multilayer perceptron (MLP) under FedAvg [1] show that MUFFLe achieves the target accuracy with substantially lower cumulative uplink communication than uncompressed FedAvg, quantization, and Top-k sparsification. The main contribution of this paper is the introduction of MUFFLe as a communication-efficient compression scheme for federated learning update transmission. We also provide a preliminary empirical evaluation against standard compression baselines under a common communication-oriented metric. II. P ROBLEM F ORMULATION A. The Federated Averaging (FedAvg) Algorithm As the primary algorithmic framework for FL, FedAvg trains a global model w ∈ Rd across U edge clients by solving: U X nu min F (w) = Fu (w), (1) d Ntot w∈R u=1 where nu is the number of samples at client u, Ntot is the total dataset size, and Fu (w) is the local loss. At communication round t, the server selects clients St (|St | = m) and broadcasts wt . Each selected client computes: u ∆wtu = wt,E − wt ,
(2)
u where wt,E is the local model state after E epochs of SGD. The server then performs a weighted model aggregation: X nu wt+1 = wt + ∆wtu , (3) NSt u∈St
P where NSt = u∈St nu is the total number of samples across the selected clients. B. Communication-Efficient Formulation In resource-constrained edge networks, transmitting fullprecision updates ∆wtu incurs substantial latency and energy overhead. We use a compression operator C : Rd → M to map each local update to a compact message, and a reconstruction mapping D : M → Rd to approximate it at the server: ˆ ut = D(C(∆wtu )). ∆w
C
Deviations IDs
bit0 1 2 3 4 5 6 7 idx 0 1 0 1 0 0 0 0 0
0 1 2 7 1 0 1 0
3 4 5 6 0 0 0 0
0
1 1 1 1 0 0 0 1 0
1 1 1 0
0 0 0 1
1
2 1 0 1 1 0 1 1 0
1 1 0 0
1 0 1 1
0
3 1 1 1 1 1 0 0 0
1 1 0 0
1
4 1 1 1 0 0 0 1 0
0 0 0 1
1
5 1 1 0 0 0 0 0 0
0 0 0 0
2
6 1 1 1 1 1 1 1 0
1 1 1 1
1
Fig. 2: An example of GD applied to 8- bit data chunks.
A. Generalized Deduplication (GD)
∗
min B =
Compressed data Bases
(4)
The objective is to minimize the cumulative communication volume B needed to reach target accuracy Atarget : T X X
Uncompressed data Data chunks
size (C(∆wtu )) ,
(5)
t=1 u∈St
where size(·) is the message bit-length, and T ∗ is the first round at which the global model meets the performance threshold. This captures the communication-efficient FL tradeoff: aggressive compression lowers per-round latency and energy but can introduce reconstruction errors that increase the convergence rounds T ∗ . C. Baseline Compression Schemes We benchmark two standard compression schemes. Quantization: This scheme maps each scalar in ∆wtu to a q-bit signed integer. Given α = ∥∆wtu ∥∞ , the scale factor is S = α/(2q−1 − 1). The encoding mapping is CQ (x) = round(x/S), and the server reconstructs the update with DQ (i) = i · S. The transmission cost is (d × q) + 32 bits: d quantized parameters plus one 32-bit float for S. Top-k: This scheme keeps the k elements with the largest absolute magnitudes. The client transmits k tuples, each containing a 32-bit floating-point value vj and index j ∈ {1, . . . , d}. The reconstruction mapping Dk (·) is given by: ( u ˆ t ]j = vj if j ∈ transmitted indices (6) [∆w 0 otherwise The compressed bit-length is k(32 + ⌈log2 d⌉), where ⌈log2 d⌉ bits encode each index. III. M ETHODOLOGY: MUFFL E We propose MUFFLe, a communication-efficient compression scheme for client-to-server model updates in federated learning. Let ∆wtu ∈ Rd denote the local update generated by client u at communication round t. In contrast to conventional quantization, which assigns a fixed bit-width to every element, and Top-k sparsification, which transmits a number of selected elements, MUFFLe combines fixed-rate symbol truncation with redundancy-aware deduplication across the update vector. The key idea is to convert the update into a sequence of fixed-length binary symbols and exploit repeated patterns among their most-significant bits. This yields a fixed-rate, variable-count compression scheme: the bit-width per symbol is fixed, while the number of distinct transmitted symbols depends on the redundancy structure of the update.
As illustrated in Fig. 2, Generalized Deduplication (GD) is a compression framework that partitions data chunks into frequently recurring bit patterns, termed bases, and highvariance residual components, termed deviations. It achieves lossless compression by deduplicating the bases and storing the deviations together with the corresponding base IDs. For example, chunks 0 and 2 in Fig. 2 share the common base 101....0, which is stored only once and referenced by base ID 0, while their distinct deviations are recorded separately. Compression is effective when the number of unique bases is substantially smaller than the total number of data chunks. B. MUFFLe MUFFLe adapts GD from lossless data compression to lossy client-update compression in federated learning. Since floating-point data can be compressed more effectively after being scaled and transformed into an unsigned integer representation [11], we follow the preprocessing steps in [11] to convert the local update ∆wtu into a binary integer representation. MUFFLe first identifies the constant bits shared across all d update elements and retains only a predefined number of g non-constant most-significant bits (MSBs) for each element. These retained MSBs form the base representation of each update element and establish the fixed bit-rate of the scheme. Deduplication is then performed over the truncated MSB bases. Specifically, update elements with the same retained g-bit MSB pattern are mapped to a single base entry and represented by the corresponding base ID. Unlike existing GD-based methods, which store deviations to enable lossless reconstruction, MUFFLe omits them to obtain a lossy approximation of the update. As illustrated in Fig. 1d, MUFFLe therefore reduces uplink communication through two complementary mechanisms: fixed-rate truncation decreases the number of bits retained per element, while deduplication avoids transmitting replication across the updates. In this work-in-progress study, we do not apply error feedback or compensation to the considered compression methods. A future extension could store the discarded deviation bits as residual information and accumulate them into the next round’s update. Since these deviations require fewer bits than residuals stored in the original high-precision floating-point format, this extension may also reduce device RAM usage.
TABLE I: MNIST Results: Communication vs. Accuracy Method Uncompressed Quantization Top-k MUFFLe
Acc. (%) 92.93 92.93 92.93 92.93
Round 200 193 221 195
1.0
Comm. Cost (MB) 310 75 86 38
Gain 1× 4.1× 3.6× 8.3×
0.8
Comm. Cost Ratio (Baseline / MUFFLe)
8x
Test Accuracy
The transmitted representation therefore consists of a dictionary of unique bases and a sequence of base IDs, one for each update element. Since the redundancy structure of the update can vary across communication rounds, the number of unique bases is data-dependent. The total compressed cost of MUFFLe is nb · g + d · ⌈log2 (nb )⌉, where nb denotes the number of unique base symbols transmitted, g denotes the non-constant base bit length, and ⌈log2 (nb )⌉ denotes the number of bits required to encode the base ID of each update element. Since the constant bits are shared across all update entries and stored only once, and metadata overhead is negligible, they are omitted from the total bit calculation. Upon receiving the compressed stream, the server reconstructs the ˆ u by mapping the received symbols to their original update ∆w t indices according to the IDs and then converting the binary representation back into the approximate update vector.
6x
0.6 0.4 100
Uncompressed Quantization (8-bit) Top-k (quant-budget) MUFFLe 1 10 102 103
Cumulative Communication (MB)
(a) Acc. vs comm. cost.
Uncompressed Quantization (8-bit) Top-k (quant-budget)
4x 2x 1x 0.5
0.6
0.7
0.8
Test Accuracy
0.9
1.0
(b) Gains of MUFFLe.
Fig. 3: Comparison of communication efficiency on MNIST. IV. E XPERIMENTAL R ESULTS We evaluate the communication efficiency of MUFFLe on MNIST under an IID partition, with the training set uniformly distributed across K = 20 clients. In each communication round, a fraction C = 0.2 of clients is selected uniformly at random, yielding n = 4 participating clients. The model is a lightweight MLP with a flattening layer, a 128-unit ReLU hidden layer, and a 10-class Softmax output layer. Local training uses SGD with learning rate η = 0.01 and E = 1 local epoch. Fixed random seeds ensure reproducible weight initialization and client selection. All methods compress client-to-server parameter updates. We compare MUFFLe with: (i) Uncompressed: 32-bit FedAvg; (ii) 8-bit Quantization; and (iii) Top-k Sparsification, with k matched to the 8-bit quantization budget. For simplicity, updates are rounded to four decimal places before MUFFLe preprocessing. Communication efficiency is measured by cumulative bits, defined as the total uplink transmission across all participating clients. We report the communication cost required to reach the target accuracy, defined as the test accuracy of the uncompressed baseline at 200 rounds. Table I summarizes the communication cost required by each method to reach the target accuracy of 92.93%, defined as the test accuracy achieved by the uncompressed baseline at 200 rounds. As shown in Table I, MUFFLe reaches this target with a cumulative communication cost of 38 MB, compared with 75 MB for 8-bit quantization, 86 MB for Top-k sparsification, and 310 MB for uncompressed FedAvg. This corresponds to a 8.3x reduction relative to uncompressed transmission. Fig. 3a further illustrates the communication–accuracy tradeoff. MUFFLe achieves the target accuracy with the lowest cumulative uplink communication among all evaluated methods, indicating that exploiting repeated patterns can substantially reduce transmission cost. Fig. 3b shows the communication gain of MUFFLe over the baselines across different accuracy levels. The gain remains substantial throughout and is largest near the target accuracy, reaching up to 8.3× over uncompressed and more than 2× over quantization and Top-k.
V. C ONCLUSION AND F UTURE W ORK This WiP paper presented MUFFLe, a communicationefficient update compression scheme for FedAvg. Results on IID MNIST show that MUFFLe achieves the target accuracy with substantially lower cumulative uplink communication than uncompressed FedAvg, 8-bit quantization, and Top-k sparsification. These preliminary results demonstrate the feasibility of MUFFLe. Future work will extend the evaluation to non-IID data, larger models, and error-feedback mechanisms. R EFERENCES [1] B. McMahan, E. Moore, D. Ramage, S. Hampson, and B. A. y Arcas, “Communication-efficient learning of deep networks from decentralized data,” in Artificial intelligence and statistics. Pmlr, 2017, pp. 1273– 1282. [2] W. Y. B. Lim, N. C. Luong, D. T. Hoang, Y. Jiao, Y.-C. Liang, Q. Yang, D. Niyato, and C. Miao, “Federated learning in mobile edge networks: A comprehensive survey,” IEEE communications surveys & tutorials, vol. 22, no. 3, pp. 2031–2063, 2020. [3] M. Vahabi, H. Fotouhi et al., “Federated learning at the edge in industrial internet of things: A review,” Sustainable Computing: Informatics and Systems, vol. 46, p. 101087, 2025. [4] A. Reisizadeh, A. Mokhtari, H. Hassani, A. Jadbabaie, and R. Pedarsani, “Fedpaq: A communication-efficient federated learning method with periodic averaging and quantization,” in International conference on artificial intelligence and statistics. PMLR, 2020, pp. 2021–2031. [5] S. U. Stich, J.-B. Cordonnier, and M. Jaggi, “Sparsified sgd with memory,” NeurIPS, vol. 31, 2018. [6] R. Vestergaard, D. E. Lucani, and Q. Zhang, “Generalized deduplication: Lossless compression for large amounts of small iot data,” in European Wireless Conference. VDE, 2019, pp. 1–5. [7] R. Vestergaard, Q. Zhang, and D. E. Lucani, “Generalized deduplication: Bounds, convergence, and asymptotic properties,” in IEEE Global Communications Conference (GLOBECOM), 2019. [8] R. Vestergaard, D. E. Lucani, and Q. Zhang, “A randomly accessible lossless compression scheme for time-series data,” in IEEE INFOCOM, 2020. [9] X. Zhao and D. E. L. Rötter, “Entrogd: Scalable generalized deduplication for efficient direct analytics on compressed iot data,” in IEEE INFOCOM Workshops. IEEE, 2026. [10] Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner, “Gradient-based learning applied to document recognition,” Proceedings of the IEEE, vol. 86, no. 11, pp. 2278–2324, 2002. [11] A. Hurst, D. E. Lucani, and Q. Zhang, “GreedyGD: Enhanced generalized deduplication for direct analytics in IoT,” IEEE Transactions on Industrial Informatics, vol. 20, no. 4, pp. 6954–6962, 2024.