Organizations: Department of Electrical Engineering, Indian Institute of Technology Madras · Department of Computer Science and Engineering, Jadavpur University
Federated Learning (FL) preserves privacy by distributing training across devices. However, using DNNs is computationally intensive at the low-powered edge during inference. Edge deployment demands models that simultaneously optimize memory footprint and computational efficiency, a dilemma where conventional DNNs fail by exceeding resource limits. Traditional post-training binarization reduces model size but suffers from severe accuracy loss due to quantization errors. To address these challenges, we propose FedBNN, a rotation-aware binary neural network framework that learns binary representations directly during local training. By encoding each weight as a single bit {+1,−1} instead of a 32-bit float, FedBNN shrinks the model footprint, significantly reducing runtime (during inference) FLOPs and memory requirements in comparison to federated methods using real models. Evaluations across multiple benchmark datasets demonstrate that FedBNN significantly reduces resource consumption while performing similarly to existing federated methods using real-valued models.
Figures & tables
Figure 1: FedBNN overall architecture.
Method
Dataset
Accuracy
FLOPs
Memory
Binarized Accuracy
(Model)
IID
Non -IID 1
Non -IID 2
(MB)
IID
Non -IID 1
Non -IID 2
FedAvg
92.24
91.44
89.28
2.02×107
1.5635
53.42
63.68
54.72
FedBAT
FMNIST
89.12
87.66
85.56
2.02×107
1.5635
14.34
16.98
8.0
FedMUD
(CNN4)
89.60
88.60
86.00
2.02×107
1.6291
63.2
66.5
66.08
FedBNN
88.46
87.76
83.38
3.48×105
0.0489
88.46
87.76
83.38
FedAvg
92.10
90.60
89.34
3.00×107
1.5965
28.01
22.56
16.92
Table 1: Performance comparison for Nc=100 . The FLOPs and memory values are calculated during runtime. Binarized accuracy refers to the model’s performance after the weights and activations have been binarized.
Method
Dataset (Model)
IID
Non-IID 1
Non-IID 2
FedBNN
FMNIST
88.46
87.76
83.38
FedBNN ( β=1 , λ=1 )
(CNN4)
88.54
87.68
82.48
FedBNN
SVHN
86.89
85.63
84.40
FedBNN ( β=1 , λ=1 )
(CNN4)
86.77
85.38
84.13
FedBNN
CIFAR10
89.95
82.84
73.82
FedBNN ( β=1 , λ=1 )
(ResNet10)
89.34
82.82
68.54
Table 2: Ablation study for Nc=100 comparing with and without server aggregation.
Appendix figures & tables16 assets
Supplementary material from the paper’s appendix.
Appendix
Method
Dataset
Accuracy
(Model)
IID
Non-IID 1
Non-IID 2
FedBNN
FMNIST
88.46
87.76
83.38
Aggregating w~
(CNN4)
87.88
87.24
80.40
FedBNN
SVHN
86.89
85.63
84.40
Aggregating w~
(CNN4)
86.25
84.74
80.40
FedBNN
CIFAR10
89.95
82.84
73.82
Appendix
Table 3: Ablation study under different aggregation and binarization strategies for Nc=100 .
Method
Dataset
Accuracy
(Model)
IID
Non-IID 1
Non-IID 2
FedBNN
CIFAR10
72.08
67.08
63.00
FedBNN ( β=1 , λ=1 )
(ConvNext-Tiny)
70.78
61.78
58.50
Appendix
Table 4: Ablation study for Nc=100 comparing with and without server aggregation.
Method
Dataset
(Model)
Accuracy
FLOPs
Memory
IID
Non-IID 1
Non-IID 2
(MB)
FedBNN
ResNet10
89.95
82.84
73.82
1.11×107
0.61
FedAvg
ResNet10
90.86
86.28
70.62
4.40×108
19.62
FedAvg
CIFAR10
ResNet10 (FLOPs matched)
84.74
81.06
66.16
1.12×107
0.49
FedAvg
ResNet10 (Memory matched)
86.60
81.50
68.78
1.35×107
0.59
FedBNN
ResNet18
46.54
43.00
45.74
9.05×107
1.41
Appendix
Table 5: Performance comparison for Nc=100 . The FLOPs and memory values are calculated during runtime.
Method
Dataset
Model
No of parameters for w
No of parameters for R1,R2
Overhead Percentage
FedBNN
FMNIST
CNN4
387,360
4,070
1.05%
SVHN
CNN4
387,936
4,142
1.07%
CIFAR10
ResNet10
4,890,624
27,552
0.56%
FEMNIST
ResNet18
11,157,504
62,272
0.56%
TinyImageNet
ResNet18
11,157,504
62,272
0.56%
CIFAR10
ConvNext-Tiny
27,751,392
78,084
0.28%
Appendix
Table 6: Parameter overhead of the rotation matrices R1 and R2 in FedBNN. Across all datasets and architectures, the additional parameters remain below 1% of the model weights, demonstrating negligible overhead (in comparison to FedAvg) and good scalability to larger models.
Figure 2: Performance comparison between FedAvg and FedBNN on FMNIST using the CNN4 architecture under IID, Non-IID1 (Dirichlet α=0.3 ), and Non-IID2 (label-skew) data partitions.
Figure 3: Performance comparison between FedAvg and FedBNN on SVHN using the CNN4 architecture under IID, Non-IID1 (Dirichlet α=0.3 ), and Non-IID2 (label-skew) data partitions.
Figure 4: Performance comparison between FedAvg and FedBNN on CIFAR10 using the ResNet10 architecture under IID, Non-IID1 (Dirichlet α=0.3 ), and Non-IID2 (label-skew) data partitions.
Figure 5: Performance comparison between FedAvg and FedBNN on CIFAR10 using the ConvNeXt-Tiny architecture under IID, Non-IID1 (Dirichlet α=0.3 ), and Non-IID2 (label-skew) data partitions.
Figure 6: Performance comparison between FedAvg and FedBNN on TinyImageNet using the ResNet18 architecture under IID, Non-IID1 (Dirichlet α=0.3 ), and Non-IID2 (label-skew) data partitions.
Figure 7: Performance comparison between FedAvg and FedBNN on FEMNIST using the ResNet18 architecture under IID, Non-IID1 (Dirichlet α=0.3 ), and Non-IID2 (label-skew) data partitions.
Figure 8: Hyperparameter sensitivity on FMNIST under IID, Non-IID1, and Non-IID2.
Figure 9: Hyperparameter sensitivity on SVHN under IID, Non-IID1, and Non-IID2.
Figure 10: Hyperparameter sensitivity on CIFAR10 (ResNet10) under IID, Non-IID1, and Non-IID2 data heterogeneity settings.
Figure 11: Sensitivity analysis of the hyperparameters (1−α) , αβ , α(1−β) , and λ on CIFAR10 (ConvNeXT-Tiny) under three data heterogeneity settings: IID, Non-IID1 (LabelCnt=0.3), and Non-IID2 (Dirichlet=0.3).
Figure 12: Hyperparameter sensitivity on TinyImageNet under IID, Non-IID1, and Non-IID2 settings.
Figure 13: Hyperparameter sensitivity on FEMNIST under IID, Non-IID1, and Non-IID2 settings.
Federated Learning (FL) enables privacy-preserving intelligence on Internet of Things (IoT) devices but incurs a significant carbon footprint due to the high energy cost of frequent uplink transmission. While pre-trained models are increasingly available on edge devices, their potential to reduce the energy overhead of fine-tuning remains underexplored. In this work, we propose QuantFL, a sustainable FL framework that leverages pre-trained initialisation to enable aggressive, computationally lightweight quantisation. We demonstrate that pre-training naturally concentrates update statistics, allowing us to use memory-efficient bucket quantisation without the energy-intensive overhead of complex error-feedback mechanisms. On MNIST and CIFAR-100, QuantFL reduces total communication by 40% (≃40% total-bit reduction with full-precision downlink; ≥80% on uplink or when downlink is quantised) while matching or exceeding uncompressed baselines under strict bandwidth budgets; BU attains 89.00% (MNIST) and 66.89% (CIFAR-100) test accuracy with orders of magnitude fewer bits. We also account for uplink and downlink costs and provide ablations on quantisation levels and initialisation. QuantFL delivers a practical, "green" recipe for scalable training on battery-constrained IoT networks.
Charuka Herath, Yogachandran Rahulamathavan, Varuna De Silva +1
Institute of Digital Technologies, Loughborough University, UK
Federated Learning (FL) empowers multiple clients to collaboratively learn a model, enlarging the training data of each client for high accuracy while protecting data privacy. However, when deploying FL in real-time edge systems, the heterogeneity of devices among systems has a severe impact on the performance of the inferred model. Existing optimizations on FL focus on improving the training efficiency but fail to speed up inference, especially when there is a latency constraint. In this work, we propose Collate, a novel training framework that collaboratively learns heterogeneous models to meet the latency constraints of multiple edge systems simultaneously. We design a dynamic zeroizing-recovering method to adjust each local model architecture for high accuracy under its latency constraint. A proto-corrected federated aggregation scheme is also introduced to aggregate all heterogeneous local models, satisfying the latency constraint of different systems with only one training process and maintaining high accuracy. Extensive experiments indicate that, compared to state-of-the-art methods and under a latency constraint, our extended models can improve the accuracy by 1.96% on average, and our shrunk models can also obtain a 3.09% accuracy improvement on average, with almost no extra training overhead. The related codes and data will be available at https://github.com/ntuliuteam/Collate
Shuo Huai, Di Liu, Hao Kong +5
School of Computer Science and Engineering, Nanyang Technological University, Singapore · HP-NTU Digital Manufacturing Corporate Lab, Nanyang Technological University, Singapore · HP Inc., Palo Alto, California, USA
Federated fine-tuning is bottlenecked by communication: FedAvg and pseudo-gradient schemes transmit a payload that scales with the model, and gradient compression shrinks it by only a constant factor. We take a different lever. Mapping networks generate a network's weights from a small trainable latent through a frozen affine projection; because the map is shared and affine, averaging latents is exactly averaging the generated weights. We turn this into a practical low-bandwidth federated channel with two changes: a low-rank, seed-regenerable factorisation of the projection (cutting generator memory from ~80 GB to ~10 MB), and a delta formulation θ=θpre+UV⊤z that learns an additive correction around a shared centrally-pretrained base -- federated fine-tuning, which is what makes the method work at scale. A frozen orthogonal classifier head further removes the head from the payload while improving accuracy. On CIFAR-100 with ResNet-18+GroupNorm, our method (FLITE, Federated Low-rank Iterative Training Engine) communicates 1,280 floats (~5 KB) per client per round -- an 8718x reduction -- and reaches 74.67%, within ~0.5 pp of full-weight FedAvg. The averaging identity holds to floating-point precision (6×10−8); the method sits one to two orders of magnitude below PowerSGD and top-k on the bandwidth-accuracy Pareto; it matches or exceeds full-weight FedAvg under strong non-IID skew. int4 latents reach 648 bytes per round at unchanged accuracy, whereas int4 full-weight FedAvg collapses to chance.