Federated Learning of Binary Neural Networks: Enabling Low-Cost Inference

arXiv:2603.15507 · cs.LG, cs.CV · Submitted 2026-03-16 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: We're looking at the paper: "Federated Learning of Binary Neural Networks".

Jane: Here's the gist of the paper. Federated Learning of Binary Neural Networks: Enabling Low-Cost Inference proposes FedBNN, a rotation-aware binary neural network framework that learns binary representations directly during local training to achieve lower runtime computation and memory complexity than real-valued models By encoding each weight as a single bit rather than 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 Proposed Framework and Training FedBNN introduces a rotation-aware binary neural network framework that trains binary weights while preserving the same parameter count as its real-valued counterpart The training process involves several key components to manage quantization errors and gradient flow.

Jane: Trainable rotation weight with global memory is proposed to address angular bias by applying a rotation matrix Rl at the start of each training epoch This involves using a fused weight w that interpolates between the client and server weight representations.

Title and authors: Tom: So we're looking at this paper today, "Federated Learning of Binary Neural Networks: Enabling Low-Cost Inference." The title itself tells you what's important here: they're tackling the problem of making deep neural networks run cheaply on devices with limited power and memory.

Jane: Right, so the core idea is that conventional deep neural networks are too heavy for edge deployment, especially when you have to worry about data privacy from federated learning setups. The authors propose FedBNN as a way around that by learning binary representations directly during the local training phase instead of just converting a real-valued model after training.

Lu: Exactly, and what I find interesting is how they manage that transition from real numbers to single bits without losing too much accuracy. They're proposing this rotation-aware framework to handle the angular bias that comes with forcing weights into a binary state, which is a big deal for stability.

Meng: From an engineering standpoint, what I want to know right away is how much smaller these models actually get in terms of runtime and memory when you use FedBNN compared to standard federated methods using real models. Because I'm shipping things, the FLOPs and the memory footprint are my biggest bottlenecks when deploying to real hardware.

Lalam: The paper points out that by encoding each weight as a single bit instead of a thirty-two-bit float, they shrink the model size significantly, which directly reduces runtime during inference and memory requirements compared to models using real numbers >

Tom: That's the immediate payoff we need to look at. The paper shows massive reductions in computational cost. For example, on FMNIST and SVHN datasets, they report reducing FLOPs from two point zero two times ten seven to three point four eight times ten five, which is about a fifty eight times reduction, while memory usage drops by thirty-two times >

Jane: Fifty eight times is a huge number. But the caveat there is that they compare it against existing federated methods that still use real-valued models, so we need to see how it stacks up when you're comparing apples to apples in terms of performance >

Lu: The methodology they use to achieve this involves several things, including a trainable rotation weight with global memory at the start of each training epoch to manage angular bias, and they formulate the optimization goal using a cosine function involving the sign function and some rotation matrix R at the beginning of each step >

Meng: That sounds complicated. Can you unpack that for me? What's actually happening when you apply this rotation matrix R at every epoch during local training? Is it adding a lot of overhead to the client side computation >

Jane: Well, they introduce something called a trainable rotation weight with global memory, which seems designed to address angular bias by applying that rotation matrix R at the start of each training epoch > The goal is to maximize this cosine function involving the sign of the rotated weight vector divided by its magnitude squared over the squared magnitude >

Title and authors: Tom: Okay, so they are actively optimizing for this specific cosine quantity during training, which means they're tuning how those binary representations interact with that rotation matrix R to get better results > I'm curious about the approximation function F of x they use as a surrogate for the sign function because that sounds like it needs some careful handling during gradient flow >

Lu: The authors use a training-aware approximation function F of x as a surrogate for the sign function specifically to enable better gradient flow during early training, which is crucial when you're dealing with those sharp transitions in binary representations > That setup is what allows them to handle the quantization errors more gracefully than just doing post-training binarization on top of a real model >

Meng: But let's talk about how they manage the server side. They maintain two parallel representations: one for the aggregated real-valued weight vector and another for an aggregated rotation-aligned weight vector > That sounds like doubling the storage and communication load at the server, which I have to question when dealing with many clients >

Jane: It seems like they do that because they need a way to evaluate performance in a binarization-aware setting. They aggregate those rotation-aligned weights in the rotated space as w R t plus one equals X N k k equals one N s k and S n s R top k w wk >

Tom: So, on the server, they compute this rotation-aligned aggregation and then combine it with the standard real-valued aggregation through a modified update rule derived from equation fifteen to form an auxiliary update w t plus one > That auxiliary update is only used for evaluation and never sent back to the clients, which saves communication bandwidth >

Lu: The authors also introduce learnable parameters alpha, beta, and lambda that allow the network to adaptively adjust the influence of the rotated direction and the global server model during binarization > This helps in preserving update stability while enabling a convex combination of those two directions > It's a way to dynamically blend between the rotation and server alignment based on what works best for that specific client or data split >

Meng: That sounds like it adds more parameters to train, which increases the complexity of the training process itself. How do you justify adding those extra learnable parameters when you're already fighting for every bit of efficiency >

Jane: The benefit they claim is that this adaptive adjustment helps in preserving update stability and enables a convex combination of the rotated and server-aligned directions, which leads to better or more stable performance under client heterogeneity > They say this improves robustness to client imbalance when compared to prior methods >

Title and authors: Tom: So, we're seeing a trade-off here: you add more parameters and complexity during training to get that stability on the server side, but the claim is that it pays off in better generalization across different data distributions > I'm looking at the Tiny-ImageNet results where they report accuracy numbers like forty-six point five four percent under IID and non-IID settings >

Lu: The parameter overhead introduced by those rotation matrices R one and R two is negligible compared to the total number of weight parameters, which suggests it scales well up to larger models > That's a big win for scalability, I think.

Meng: But what about deployment? When we take these results and try to run them on a production server handling real traffic at scale, does this framework have any known issues with catastrophic failure or unexpected behavior that isn't captured in these benchmark datasets >

Jane: The authors mention that they maintain strong clean accuracy across diverse datasets and data distributions, which suggests the method is pretty robust in terms of performance on unseen data > It seems to strike a good balance between accuracy and efficiency for practical deployment scenarios >

Tom: So, to wrap up this paper, the main message is that you can achieve significant runtime and memory savings by learning binary representations directly during local training rather than just applying post-training binarization after the fact > FedBNN shows substantial reductions in FLOPs on FMNIST and CIFAR10, but it relies on a specific rotation-aware mechanism for stability >

Lu: The implication is that we can move towards models that are inherently more efficient by learning in the binary domain, provided we handle those rotation and aggregation challenges correctly through decomposition methods like MUD and BKD > It pushes the idea that learning the representation itself is where you find efficiency gains >

Jane: So, for someone listening who doesn't read papers, what this means is that we can train smarter models locally so they run much faster on your phone or edge device without losing too much accuracy compared to models trained normally > It's about making the training process itself more aware of how the model will be deployed >

Meng: For me, it means I need to see how this translates to real traffic. Right now, most of this work is on benchmark datasets like FMNIST and CIFAR10, and we still don't have confidence that it won't break when faced with truly messy, real-world data distributions or client participation issues >

Lalam: Based on the analysis I've done across the literature, I am quite sure that FedBNN provides a solid foundation for resource-constrained federated learning applications because it addresses the core dilemma of efficiency versus accuracy in a way that's supported by multiple theoretical tools > It’s not a magic fix, but it’s a very strong direction >

The paper's summary: Tom: So, we're looking at this paper today, "Federated Learning of Binary Neural Networks: Enabling Low-Cost Inference." Basically, they’ve created this framework called FedBNN that learns binary representations directly during the local training phase instead of just converting a real-valued model after training.

Jane: That means they are trying to shrink the whole model footprint right from the start by encoding every weight as a single bit instead of some heavy thirty-two-bit floating point number.

Tom: Exactly, and that shrinking directly translates to lower runtime during inference and way less memory needed compared to federated methods that still use those real numbers.

Lu: The authors tackle the problem of angular bias with this rotation-aware setup, using a trainable rotation weight at the start of each training epoch to manage how those binary weights interact.

Jane: It sounds complicated, but they are actively optimizing for a specific cosine quantity during training, which is key to getting those binary representations stable.

Tom: I'm also looking at how they handle the server side where they maintain two parallel representations—one real-valued and one rotation-aligned—and combine them in a special way just for evaluation.

Lu: They use a modified update rule derived from some equation to form an auxiliary update that only gets used for checking performance, not sent back to the clients.

Jane: What I'm hearing is they're trying to find the sweet spot between having a model that runs super fast and still getting decent accuracy when dealing with those tricky real-world data splits.

Tom: The results are pretty striking, showing massive reductions in computational cost on things like FMNIST and CIFAR ten, where they report reductions in FLOPs by fifty eight times.

Jane: Fifty eight times is a huge number; that really shows how much resource saving this method can offer when you compare it to models using standard federated learning with real-valued numbers.

Lu: And the parameter overhead from those rotation matrices, R one and R two, turns out to be negligible compared to the total number of weight parameters, which is a big win for scaling up to bigger models.

Tom: But they also claim this method maintains strong clean accuracy across different datasets and data distributions, even under non-IID conditions like Tiny-ImageNet.

Jane: So it seems they've managed to strike a pretty good balance between achieving high performance and saving serious computational power for actual deployment.

Lu: The authors suggest that learning the representation itself in the binary domain is where you find those efficiency gains, provided you handle the rotation and aggregation challenges correctly.

Tom: It pushes the idea that we can move towards models that are inherently more efficient by learning in this specialized domain, instead of just converting a standard model later.

Jane: So for someone listening who doesn't read papers, it means we can train smarter models locally so they run much faster on your phone or edge device without losing too much accuracy compared to models trained normally.

Lu: The implication is that we need to focus on how the training process itself is aware of how the model will be deployed, not just what the final output looks like.

Tom: But I have to ask, they admit their method stops working when faced with truly messy, real-world data distributions or weird client participation issues that aren't covered in those benchmark datasets.

Jane: That’s a fair question; we need to see if this stability holds up when you move from clean test sets to unpredictable real traffic where things get really messy.

The paper's improvements: Tom: So, we’ve talked about how FedBNN gets those massive runtime and memory savings by learning binary representations directly during local training instead of just converting a real model after training.

Jane: That was the first part, but what about how they make sure this whole system doesn't fall apart when it has to deal with messy, non-identical data coming from different clients?

Lu: The paper suggests adding learnable parameters alpha, beta, and lambda that let the network adaptively adjust how much influence those rotated directions have during the binarization process.

Tom: So they’re training these extra parameters to help them preserve update stability while still allowing a mix between the rotated and server-aligned directions.

Jane: That sounds like a way for the system to dynamically blend between what it learned locally and what the global server is pushing, which should make it more robust to those client differences.

Lu: I think that adaptive blending helps in achieving a convex combination of those two directions, which is crucial for maintaining consistent performance across different data splits.

Tom: So they’re essentially adding a layer of dynamic control to the aggregation strategy just to keep the model from getting unstable when things aren't perfectly uniform.

Jane: That makes sense; it’s like giving the training process a dial it can turn based on what kind of data it’s currently seeing.

Lu: The authors also point out that these rotation matrices, R one and R two, don't actually add much overhead to the total number of weight parameters, which is great for scaling up to bigger models.

Tom: That's good news; they aren't introducing a massive parameter bloat just to get this binary efficiency boost.

Jane: But the limitation they mention is that this method focuses on performance under clean conditions and doesn't fully prove its stability when the real-world data distribution becomes truly unpredictable.

Lu: So while the framework is strong, the authors themselves flag that we still need more research to ensure it holds up under extreme heterogeneity in client participation.

Tom: It seems like they’ve built a very efficient engine, but now they have to spend time proving it can handle any kind of road condition.

Jane: The implication for us is that if we want low-cost inference on edge devices, this rotation-aware approach is a strong direction to explore right now.

Conclusion: Tom: So, we’re wrapping up on "Federated Learning of Binary Neural Networks: Enabling Low-Cost Inference," which boils down to using a rotation-aware binary neural network framework to learn binary weights directly during local training.

Jane: That was the whole idea, right? It’s about making deep neural networks run much faster on edge devices without losing too much accuracy compared to models trained normally.

Lu: The implication is that we can move towards models that are inherently more efficient by learning in the binary domain, provided you handle those rotation and aggregation challenges correctly.

Meng: For me, it means we need to see how this translates to real traffic; right now, most of this work is on benchmark datasets like FMNIST and CIFAR ten, and we still don't have confidence that it won't break when faced with truly messy, real-world data distributions.

Lalam: I’m quite sure that FedBNN provides a solid foundation for resource-constrained federated learning applications because it addresses the core dilemma of efficiency versus accuracy in a way that’s supported by multiple theoretical tools.

Tom: So, the numbers show substantial reductions in FLOPs on FMNIST and CIFAR ten, and they maintain strong clean accuracy across diverse datasets.

Jane: It’s a very strong balance between achieving high performance and saving serious computational power for actual deployment scenarios.

Lu: The parameter overhead from those rotation matrices is negligible compared to the total number of weight parameters, which is a big win for scaling up to bigger models.

Meng: But we still need more work on proving it holds up under extreme heterogeneity in client participation because that’s where things usually get messy when you take these methods into production.

Lalam: I'm confident the authors have laid a very solid groundwork here for making AI more practical and deployable in constrained environments.

Tom: So, the main message is that you can achieve significant runtime and memory savings by learning binary representations directly during local training rather than just applying post-training binarization after the fact.

Jane: It’s about making the training process itself more aware of how the model will be deployed, which is a really smart way to approach this problem.

Lu: The implication for us is that we need to focus on how the training process itself is aware of how the model will be deployed, not just what the final output looks like.

Meng: I’m still holding back until we see hard proof that this stability holds up when things get truly unpredictable in a real-world setting.

Lalam: The results from "Federated Learning of Binary Neural Networks: Enabling Low-Cost Inference" show a very promising direction for building more efficient AI systems.

Tom: That’s the end of our session on FedBNN, but we'll be right back to talk about how we can use these kinds of efficient models in practical applications next.

Nitin Priyadarshini Shankar, Soham Lahiri, Sheetal Kalyani, Saurav Prakash

Indian Institute of Technology Madras · Jadavpur University

cs.LG, cs.CV

Submitted: 2026-03-16

Updated: 2026-11-10

Comments: 31 pages, 13 figures

License: http://creativecommons.org/licenses/by-nc-sa/4.0/

Importance score: 90/100

The gist: Federated Learning of Binary Neural Networks: Enabling Low-Cost Inference proposes FedBNN, a rotation-aware binary neural network framework that learns binary representations directly during local…

Key concepts

Binary Neural Network (BNN)
A neural network where each weight is restricted to only two values, typically -1 and +1. This quantization allows for a much smaller model footprint, significantly lowering the computational cost during inference because operations are simpler than those involving real numbers.
Rotation-Aware Framework
This technique addresses angular bias by introducing a trainable rotation matrix at the start of each training epoch. By incorporating this rotation, the model learns binary representations that are better aligned with data distributions, leading to improved performance and stability during training.
Server-Side Alignment
The server maintains two versions of the global model: one in real values and one in a rotated space. A modified update rule combines these two representations to create an auxiliary update used only for evaluation. This alignment improves convergence stability, especially when dealing with non-IID data from clients.

Terminology

Summary

Federated Learning of Binary Neural Networks: Enabling Low-Cost Inference proposes FedBNN, a rotation-aware binary neural network framework that learns binary representations directly during local training to achieve lower runtime computation and memory complexity than real-valued models By encoding each weight as a single bit rather than 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

Proposed Framework and Training

FedBNN introduces a rotation-aware binary neural network framework that trains binary weights while preserving the same parameter count as its real-valued counterpart The training process involves several key components to manage quantization errors and gradient flow.

  1. Trainable rotation weight with global memory is proposed to address angular bias by applying a rotation matrix Rl at the start of each training epoch This involves using a fused weight w that interpolates between the client and server weight representations. p. 3

    Where the paper says it

    (2020) proposed applying a rotation matrix Rl ∈ R nl×nl at the start of each training epoch to minimize the angle ϕl between (Rl) T wl and sign((Rl) T wl). Building on this, we propose the use of a fused weight w that interpolates between the client and server weight representations as shown below: w = λlwl + (1 − λl)wserver (7) Here, λl = sigmoid(ωl) ∈ [0, 1], ωl is a trainable parameter, and wserver is the aggregated weight sent from the server as shown in Eq.

  2. The optimization is formulated to maximize cos (ϕ) = sign((R)T w) / sign((R)T w)2 ((R)T w)2, which is solved using an alternating optimization approach involving three steps. p. 4

    Where the paper says it

    (10) Since the above optimization is a non-convex problem, an alternating optimization approach is used, where one variable is updated, keeping the other two fixed until convergence. We, therefore, have three optimization steps, as shown in Algorithm 1: 5

  3. A training-aware approximation function F(x) is used as a surrogate for the sign function to enable better gradient flow during early training. p. 5

    Where the paper says it

    3 Training aware approximation for federated learning To improve upon the STE, the work in Lin et al. (2020) introduced a training-aware approximation function that serves as a smooth, epoch-dependent surrogate for the sign function, enabling better gradient flow during early training.

Aggregation Strategy and Server Evaluation

The server maintains two parallel representations of the global model: an aggregated real-valued weight vector and an aggregated rotation-aligned weight vector.

  1. The real-valued weights are aggregated in the standard FedAvg manner to produce the global model broadcast to clients

  2. For binarization-aware evaluation, the server computes rotation-aligned weights for each client and aggregates them in the rotated space as wR,t+1 = X Nk k=1 Nsk Ns R⊤ k wk. p. 7

    Where the paper says it

    (4) (wserver is the same as wt). Second, for the purpose of binarization-aware evaluation, the server computes rotation-aligned weights for each client and aggregates them in the rotated space: wR,t+1 = X Nk k=1 Nsk Ns R⊤ k wk .

  3. These two aggregated quantities are combined only at the server side through a modified update rule derived from Eq. p. 7

    Where the paper says it

    Second, for the purpose of binarization-aware evaluation, the server computes rotation-aligned weights for each client and aggregates them in the rotated space: wR,t+1 = X Nk k=1 Nsk Ns R⊤ k wk . (24) These two aggregated quantities are combined only at the server side through a modified update rule derived from Eq.

    (14) to form an auxiliary update w˜ t+1, which is used solely for evaluation and never transmitted to clients. p. 7
    Where the paper says it

    Specifically, the server forms an auxiliary update w˜ = wt+1 + αβ (wR,t+1 − wt+1) + α(1 − β) (wt − wt+1), (25) where wt denotes the server model from the previous communication round. Importantly, w˜ t+1 is not transmitted to clients; it is used solely to evaluate performance and to identify the best global model during training.

Efficiency Gains and Performance

FedBNN achieves substantial reductions in computational and memory cost relative to all baselines.

  1. For FMNIST and SVHN, FedBNN reduces FLOPs from 2. p. 8

    Where the paper says it

    2 Computation and Memory savings Across all datasets and architectures, FedBNN consistently delivers orders-of-magnitude reductions in computational and memory cost relative to all baselines. For FMNIST and SVHN, FedBNN reduces FLOPs from 2.

    02 × 107 to 3. p. 8
    Where the paper says it

    For FMNIST and SVHN, FedBNN reduces FLOPs from 2. 02 × 107 to 3.

    48 × 105, achieving approximately a 58× reduction, while memory usage drops from roughly 1. p. 8
    Where the paper says it

    02 × 107 to 3. 48 × 105 , achieving approximately a 58× reduction, while memory usage drops from roughly 1.

    6 MB to 0.05 MB (32×).

  2. On CIFAR10 (ResNet10), FLOPs are reduced from 4. p. 8

    Where the paper says it

    05 MB (32×). On CIFAR10 (ResNet10), FLOPs are reduced from 4.

    40 × 108 to 1. p. 8
    Where the paper says it

    On CIFAR10 (ResNet10), FLOPs are reduced from 4. 40 × 108 to 1.

    11 × 107 and memory from 19. p. 8
    Where the paper says it

    02 × 107 to 3. 48 × 105 , achieving approximately a 58× reduction, while memory usage drops from roughly 1.

    6 MB to 0.613 MB.

  3. Post-training binarization performance comparison shows that FedBNN dramatically outperforms all competing approaches when evaluated under equal FLOPs and memory budgets. p. 9

    Where the paper says it

    3 Post-training binarization performance comparison When evaluated under equal FLOPs and memory budgets, i. , after post-training binarization, FedBNN dramatically outperforms all competing approaches.

Robustness and Conclusion

FedBNN maintains strong clean accuracy across diverse datasets and data distributions, while consistently outperforming other binary federated baselines.

  1. On Tiny-ImageNet, FedBNN achieves 46. p. 7

    Where the paper says it

    The global training process runs for 1500 rounds (500 for FMNIST and SVHN) in total. 2 Datasets and Partitioning To comprehensively evaluate the effectiveness of FedBNN, we conduct experiments on several widely used federated learning benchmarks, namely, FMNIST, SVHN, CIFAR10, Tiny-ImageNet, and FEMNIST.

    54%, 43.00%, and 45.74% accuracy under IID, Non-IID 1, and Non-IID 2 settings. p. 8
    Where the paper says it

    74%) and approaching FedAvg (90. Under Non-IID settings, FedBNN achieves 82.

  2. The results demonstrate that FedBNN provides strong performance across both practical deployment scenarios, striking a strong balance between accuracy and efficiency. p. 8

    Where the paper says it

    These results nearly match FedAvg and slightly outperform FedMUD under the Non-IID 1 setting, highlighting the robustness of FedBNN in highly heterogeneous user-level federated scenarios. Overall, these results demonstrate that FedBNN maintains strong clean accuracy across diverse datasets and data distributions, while consistently outperforming other binary federated baselines and remaining competitive with full-precision federated approaches.

  3. The parameter overhead introduced by the rotation matrices R1 and R2 is negligible compared to the total number of weight parameters, demonstrating good scalability to larger models. p. 6

    Where the paper says it

    After local training, each client transmits its updated real-valued weights wk together with the corresponding learned rotation matrices Rk to the server. The increase in the number of bits transmitted to the server, introduced by R1 and R2, is less than 1% for CNN4, and it becomes increasingly negligible as model size increases (details are provided in the supplementary).

  4. Server-side alignment consistently improves performance across most datasets and splits, particularly under heterogeneous settings. p. 8

    Where the paper says it

    These results nearly match FedAvg and slightly outperform FedMUD under the Non-IID 1 setting, highlighting the robustness of FedBNN in highly heterogeneous user-level federated scenarios. Overall, these results demonstrate that FedBNN maintains strong clean accuracy across diverse datasets and data distributions, while consistently outperforming other binary federated baselines and remaining competitive with full-precision federated approaches.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Improved AI systems can achieve significant runtime reductions by training rotated binary neural networks directly during local training, as FedBNN learn[s] binary representations directly during local training. This allows for a model that shrinks the model footprint, significantly reducing runtime (during inference) FLOPs and memory requirements in comparison to federated methods using real models.

  2. The system can maintain high accuracy while operating under severe resource constraints by leveraging a rotation-aware framework that mitigates angular bias. FedBNN's mechanism ensures the binary representation of the global model yields substantial gains in memory efficiency and runtime computational savings while demonstrating performance similarly to existing federated methods using real-valued models.

  3. The system can be made more robust to data heterogeneity by utilizing learned parameters for dynamic weight adaptation. The paper introduces learnable parameters alpha, beta, and lambda that allow the network to adaptively adjust the influence of the rotated direction and the global server model during binarization, which helps in preserving update stability while enabling a convex combination of the rotated and server-aligned directions.

  4. The system can benefit from improved convergence stability under non-IID conditions through a refined aggregation strategy. By employing server-side alignment, where the server computes an auxiliary update wtilde k, the method achieves better or more stable performance and shows significantly improved robustness to client heterogeneity.

Abstract

Federated Learning (FL) enables distributed clients to jointly train a global model without sharing their raw data. However, deploying the resulting deep neural networks on resource-constrained edge devices remains challenging due to their inference-time computational and memory requirements. Binary Neural Networks (BNNs) offer substantial efficiency gains by representing weights and activations using a single bit, but achieving competitive accuracy under such aggressive quantization remains difficult. Rotation-aware binarization reduces quantization errors by aligning real-valued weights with their binary representations. Despite its effectiveness in centralized learning, applying rotation-aware binarization in FL is non-trivial due to discrepancies between local and global models, particularly under heterogeneous client data distributions. To address this challenge, we propose FedBNN, a federated rotation-aware binarization framework that leverages global model information to guide local binarization while incorporating locally learned rotation information into server-side construction of the global binary model. Experiments across multiple benchmark datasets, model architectures, and degrees of data heterogeneity demonstrate that the proposed integrated methodology achieves accuracy competitive with full-precision federated models while generally outperforming existing federated binary learning approaches. Overall, FedBNN enables accurate binary inference in heterogeneous federated settings, with savings of up to 58 times in FLOPs and 32 times in memory over full-precision models, offering a practical balance between predictive performance and deployment efficiency on resource-constrained edge devices.

Sources

Related papers