Byzantine Robustness in Federated Learning

This direction is merged into another direction: byzantine attacks in federated learning. Its last version stays readable and citable here.

Version 1 of 119 papers19 conceptsfrozen 2026-10-04

Federated Learning (FL) allows a central server to train a global model by aggregating updates from thousands of decentralized clients. This process is built on a foundation of trust: the server assumes that while client data is private, the resulting model updates are honest.

However, this decentralization creates a massive security hole known as a Byzantine attack. In these scenarios, malicious participants submit "poisoned" updates designed to degrade the model’s performance or insert hidden backdoors. Because the server cannot inspect the raw data due to privacy constraints, it cannot easily distinguish between a "legitimate but unique" update (data heterogeneity) and a "maliciously crafted" one.

The Fragility of Simple Averaging

The standard way to combine updates is through simple averaging (FedAvg). This is mathematically elegant but numerically fragile. A single malicious update with a massive magnitude or a carefully calculated direction can pull the global average far away from the true gradient.

To counter this, researchers have moved toward Robust Aggregation. The goal is to design filters that can identify and exclude outliers without ever seeing the underlying data.

Filtering via Geometric and Statistical Signatures

One of the simplest yet most effective defenses is to constrain the "influence" of any single update. Shiyuan Zuo and colleagues proposed Fed-NGA, which normalizes client gradients before averaging. By forcing every update onto the same scale (a unit ball), the server prevents any single attacker from dominating the average with high-magnitude noise.

Other approaches treat the problem as a statistical inference task. In Bayesian Robust Aggregation for Federated Learning, Aleksandr Karakulev and his team treat client "honesty" as a latent variable. Instead of a hard "yes/no" filter, the server assigns a probability of honesty to each client and marginalizes over these weights, allowing the system to adaptively ignore suspicious contributors.

Distinguishing Malice from Diversity

A major challenge in robust FL is Data Heterogeneity. If one client has very different data from the rest (e.g., a user who only takes photos of cats in a world of dog photos), their honest update might look like an attack to a simple geometric filter.

To solve this, researchers are looking deeper into the content of the updates:

  • Model Inversion: Bo Zhao and others developed FedInv, which uses model inversion to reconstruct "dummy datasets" from the updates. By comparing the distribution of these dummy sets using Wasserstein distances, the server can spot updates that represent impossible or adversarial data distributions.
  • Contrastive Learning: FLGuard, introduced by Younghan Lee, uses self-supervised contrastive learning to cluster updates. Honest updates, even if diverse, tend to share certain structural features that poisoned updates lack, allowing the server to filter the "noise" of the attack from the "signal" of the data.

Peer Review and Consensus

If the server cannot be sure who to trust, it can delegate the verification to the clients themselves. Woocheol Kim and Hyuk Lim proposed FedCC, a "consensus confirmation" system. Before an update is accepted, a random group of peer clients validates it against their own local data. If the update is poisoned, it will likely fail this "peer review" and be rejected.

Surviving the Malicious Majority

Most defenses assume that at least 50% of the participants are honest. But what if the attackers outnumber the users?

MUDGUARD, developed by Rui Wang and colleagues, uses privacy-preserving clustering and model segmentation to isolate malicious majorities. Similarly, Hong Liu and the team behind LiD-FL propose a "list-decodable" approach. Instead of outputting one global model, the server maintains a small list of candidate models. As long as a small fraction of honest clients exists, at least one model in the list will remain uncorrupted, ensuring the system never completely fails.

By combining these geometric constraints, statistical weighting, and peer validation, the research community is moving toward a version of Federated Learning that is not just private, but fundamentally resilient to sabotage.

Papers in this version

History & citationVersion 1 · 2026-10-04

Merged into another direction · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_byzantine_robustness_in_federated_learni_a5199d4a,
  title = {Byzantine Robustness in Federated Learning},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/byzantine-robustness-in-federated-learning/rdr_a5199d4aaf0b42dd864962289fe3a3f1},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_byzantine_robustness_in_federated_learni_a5199d4a_v1,
  title = {Byzantine Robustness in Federated Learning},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/byzantine-robustness-in-federated-learning/rdr_a5199d4aaf0b42dd864962289fe3a3f1/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}