Federated Learning

Federated Learning in Edge Computing

Overview

Federated Learning (FL) is a decentralized learning framework that enables multiple devices—such as smartphones, IoT sensors, or edge gateways—to collaboratively train a shared machine learning model without transmitting their raw data. Each device computes model updates locally and sends only these updates (not the actual data) to an aggregator.

When combined with Edge Computing (EC), which brings computational power closer to data sources, FL enables real-time, privacy-aware learning across distributed infrastructures. This is particularly useful in applications involving sensitive data, limited bandwidth, or regulatory constraints such as GDPR and HIPAA [1].

Background

Traditional machine learning depends on aggregating data in a centralized server or cloud, which can be inefficient or unsafe for edge-based environments. Federated Learning addresses this by performing training on-device.

In each FL round:

1. The central server initializes a global model.
2. Selected clients download the model and train it on their local datasets.
3. Clients send back their updated model parameters.
4. The server aggregates these updates to improve the global model.
5. The process continues iteratively until convergence.

Mathematically, the goal is to minimize a global loss function F(w), defined as the weighted average of local loss functions Fₖ(w) across all participating clients. The formula is:

F(w) = Σ (λₖ * Fₖ(w)) for k = 1 to N

where: - Fₖ(w) is the loss function of client k, - λₖ = nₖ / n is the weight proportional to the client’s dataset size, - nₖ is the number of data points on client k, and - n is the total number of data points across all clients [3].

Architectures

FL can follow several system architectures:

In the **centralized architecture**, a single server manages the learning lifecycle. It distributes models, receives client updates, and performs aggregation. This setup is simple but suffers from scalability limitations and a single point of failure [1].

The **decentralized architecture** removes the server. Clients communicate directly using peer-to-peer or blockchain mechanisms. Although this improves robustness and decentralization, it increases coordination overhead and system complexity [2].

In **hierarchical FL**, intermediate edge servers are introduced between clients and the cloud. Local edge servers collect updates from their associated devices and forward aggregated updates to the cloud server. This improves scalability and reduces communication latency, especially in distributed systems like smart cities or factories [1][3].

Aggregation Algorithms

The core task of the server is to combine the clients’ model updates into a unified global model. The most basic approach is **Federated Averaging (FedAvg)**.

In FedAvg, each device performs local training and sends back updated weights. The server computes a weighted average of all submitted models to form the next version of the global model.

The update rule is:

Global model (next round) = Σ (λₖ * wₖ) for k = 1 to K

where: - wₖ is the locally trained model of client k, - λₖ is the client’s weight (usually based on data volume), - K is the number of clients participating in that round [3].

When data is non-IID, FedAvg struggles with stability. To address this, **FedProx** modifies the local objective function by adding a proximity term that penalizes large deviations from the global model.

Local objective in FedProx: Fₖ(w) = Expected loss over client data + ρ * ||wₖ - w_C||²

where: - wₖ is the local model, - w_C is the global model sent by the server, - ρ is a regularization parameter that controls the strength of the penalty [3].

During training, each client updates its model using a modified SGD rule that includes the gradient of this penalty term.

Communication Efficiency

Edge devices are often resource-constrained. FL minimizes communication costs using several optimization techniques:

- **Gradient quantization**: Converts floating-point updates to lower-bit formats. - **Sparsification**: Sends only the top-k most important model updates. - **Client sampling**: Randomly selects a fraction of clients to participate per round. - **Local update batching**: Devices train over multiple local epochs before sending updates.

These strategies allow FL to operate efficiently even with limited connectivity.

Federated Learning vs Traditional Machine Learning

Feature	Federated Learning	Traditional ML
Data Location	Remains on device	Sent to central server
Privacy Risk	Lower	Higher
Communication Overhead	Low (only updates shared)	High (raw data transfer)
Latency	Lower (local inference)	Higher (cloud round-trip)
Scalability	Medium to high	Limited by central compute

Privacy and Security

Although FL inherently improves privacy by keeping data local, it is still vulnerable to security threats such as: - Gradient inversion attacks (reconstructing private data from updates), - Model poisoning (malicious updates to corrupt the global model), and - Backdoor attacks (trigger-based model manipulation).

To address these, FL integrates several defense mechanisms:

• • Differential Privacy (DP)**: Introduces random noise into model updates, making it statistically improbable to infer any individual’s data. A computation A is (ε, δ)-differentially private if:

P(A(D) ∈ S) ≤ exp(ε) * P(A(D′) ∈ S) + δ

where: - D and D′ are datasets differing by one user, - ε is the privacy budget, and - δ is the probability of failure [4].

• • Secure Aggregation**: Uses cryptographic techniques to ensure the server sees only the aggregated result, not individual updates.

• • Homomorphic Encryption**: Allows servers to perform aggregation on encrypted updates. For example, in additive encryption schemes:

Enc(a) + Enc(b) = Enc(a + b)

This ensures data remains encrypted throughout computation [4].

Applications

Federated Learning is applicable across diverse domains where privacy and decentralization are critical.

In **healthcare**, hospitals collaborate on AI models for diagnosis (e.g., cancer detection, pandemic tracking) without sharing sensitive medical data. FL enables legal and ethical cooperation while improving model generalization [1].

• • Autonomous vehicles** use FL to build shared perception and navigation models. Cars learn locally from driving conditions and contribute only model updates, not raw camera feeds or GPS coordinates.

• • Smart cities** deploy FL to train predictive models using data from traffic lights, pollution sensors, and surveillance systems—without centralizing citizen data [1][4].

In **mobile devices**, FL powers personalized services such as next-word prediction, speech recognition, and activity tracking, all while preserving user privacy.

• • Industrial IoT** applications use FL to train predictive maintenance models and optimize energy usage based on localized sensor data without exposing proprietary processes.

Challenges

While FL offers clear advantages, several barriers remain:

• • Scalability** is hindered by device heterogeneity, dropout, and asynchronous updates. Solutions include hierarchical aggregation and adaptive scheduling algorithms.

• • Data heterogeneity** is a core challenge—clients may have very different data types and distributions. Personalized FL techniques aim to address this through client-specific model tuning.

• • Security risks** like poisoning, inference attacks, and Sybil attacks demand robust aggregation schemes, anomaly detection, and secure hardware environments.

• • Incentivization** is also critical. Clients expend computational resources, so fair reward systems (e.g., token-based models) are needed to encourage participation.

• • Interoperability** across device platforms, networks, and frameworks remains an engineering challenge, necessitating standards for FL APIs, data formats, and deployment protocols.

References

1. Abreha, H.G., Hayajneh, M., & Serhani, M.A. (2022). Federated Learning in Edge Computing: A Systematic Survey. Sensors, 22(2), 450.
2. Lyu, L., Yu, H., & Yang, Q. (2020). Threats to Federated Learning: A Survey. arXiv preprint arXiv:2003.02133.
3. Li, T., Sahu, A.K., Talwalkar, A., & Smith, V. (2020). Federated Learning: Challenges, Methods, and Future Directions. IEEE Signal Processing Magazine, 37(3), 50–60.
4. Kairouz, P., et al. (2019). Advances and Open Problems in Federated Learning. arXiv preprint arXiv:1912.04977.