Federated Edge Learning Framework

• Federated edge learning frameworks are distributed systems that perform local training on edge devices while exchanging model updates to preserve data privacy.
• They implement varying aggregation strategies including hierarchical, decentralized, and peer-to-peer methods to balance communication latency, resource constraints, and system scalability.
• These frameworks integrate communication scheduling, resource optimization, and security mechanisms to address heterogeneity, reduce costs, and ensure robust convergence.

A federated edge learning framework is a distributed learning system in which model training and aggregation are pushed toward edge devices, edge servers, or both, so that raw data remain local while model parameters, gradients, or aggregated states are exchanged across the edge infrastructure rather than centralized in a remote cloud. In the literature, the term spans client–edge–cloud hierarchies, edge-only decentralized overlays, cooperative multi-edge systems, and serverless edge-to-edge migration schemes, all of which retain the basic FL premise of collaborative optimization under data locality while re-specifying where aggregation, coordination, and systems control reside (Liu et al., 2019, Zhang et al., 2023, Zhang et al., 2022, Shi et al., 3 Mar 2026).

1. Architectural forms and system organization

The canonical hierarchical form is the client–edge–cloud architecture. In "Client-Edge-Cloud Hierarchical Federated Learning" the system comprises clients, multiple edge servers, and a cloud server; clients perform local updates, edge servers aggregate every $\kappa_1$ local steps, and the cloud aggregates every $\kappa_1\kappa_2$ local steps (Liu et al., 2019). HFEL similarly migrates partial model aggregation from the cloud to edge servers and then optimizes edge association and resource allocation for the resulting hierarchy (Luo et al., 2020). SHFL adopts the same three-tier structure but makes the two-level aggregation process explicitly security-aware, with client selection at the edge and secure global aggregation at the cloud (Tavallaie et al., 2024). HAF-Edge retains the hierarchical structure while allowing different model architectures across edge clusters, so that homogeneity is assumed within a cluster and heterogeneity is resolved at the cloud by selective layer-wise aggregation (Gao et al., 2024).

Other frameworks remove the cloud from the training loop altogether. EdgeFL is an edge-only lightweight decentralized FL framework in which aggregation happens at the peers themselves; registration nodes maintain an active peer list but do not aggregate models (Zhang et al., 2023). CFEL organizes devices into edge clusters and lets edge servers cooperate over a backhaul graph by decentralized consensus, so there is no cloud server in the training iterations (Zhang et al., 2022). EdgeFLow goes further by replacing the centralized server with sequential model migration between edge base stations; the model is updated at one cluster and then migrated to the next (Shi et al., 3 Mar 2026). CFLMEC places one MEC edge server at the network edge, partitions devices into SRs and LRs, and combines cellular uplink with D2D relay-style forwarding, so that local models can move from LRs to SRs and then from SRs to the edge server in a relay race manner (Wang et al., 2021).

A concise comparison of representative instantiations is useful.

Framework	Topology	Distinguishing mechanism
CFLMEC	devices–SR/LR–edge server	relay-race transmission with cellular and D2D reuse
HierFAVG	client–edge–cloud	partial aggregation at edge and cloud
HFEL	device–edge–cloud	joint edge association and resource allocation
EdgeFL	edge-only decentralized	no central server; registration-only coordination
CFEL	device–edge plus edge–edge graph	decentralized consensus among edge servers
SHFL	IoT–edge–cloud	poisoning-aware client selection and cloud weighting
HAF-Edge	IoT–edge–cloud	heterogeneous-model aggregation via MaxCommon
EdgeFLow	client clusters–edge base stations	sequential model migration without cloud

This suggests that federated edge learning is better understood as a design space over aggregation placement, topology, and systems constraints than as a single reference architecture.

2. Learning objectives and aggregation semantics

Across these systems, the underlying optimization target usually remains the standard FL objective. EdgeFL states it implicitly as

$\min_w F(w) = \sum_k p_k F_k(w),$

implemented through local SGD and decentralized averaging over peer-selected models (Zhang et al., 2023). CFLMEC writes the cooperative objective explicitly as

$$\arg\min_w F(w), \quad F(w)=\frac{1}{N}\sum_{m=1}^{M}\sum_{n=1}^{L_m} f_{mn}(w),$$

with local descent at device $k$ given by

$$W_k(t)=W_k(t-1)-\nu_k \nabla F_k\big(W_k(t-1)\big),$$

followed by weighted aggregation at SRs and then at the edge server (Wang et al., 2021).

In hierarchical client–edge–cloud systems, aggregation is nested. HierFAVG defines edge aggregation as

$$\boldsymbol{w}^{\ell}(k)=\frac{1}{|\mathcal D^{\ell}|}\sum_{i\in \mathcal C^{\ell}} |\mathcal D_i^{\ell}|\, \boldsymbol{w}_i^{\ell}(k),$$

and cloud aggregation as

$$\boldsymbol{w}(k)=\frac{1}{|\mathcal D|}\sum_{\ell=1}^{L} |\mathcal D^{\ell}|\, \boldsymbol{w}^{\ell}(k),$$

thereby separating high-frequency local synchronization from lower-frequency global synchronization (Liu et al., 2019). CFLMEC proves an analogous consistency property: the aggregated weight at an SR behaves like centralized gradient descent on the aggregated dataset, which formalizes the hierarchical LRs $\rightarrow$ SRs $\rightarrow$ edge server pathway (Wang et al., 2021).

A distinct extension appears in federated meta-learning. The platform-aided framework in "Real-Time Edge Intelligence in the Making" uses a MAML-style inner adaptation

$\kappa_1\kappa_2$0

and optimizes the meta-objective

$\kappa_1\kappa_2$1

so that a target edge node can adapt with one or a few gradient steps using only a small local dataset (Lin et al., 2020). In this formulation, a federated edge learning framework is not only a transport and aggregation substrate but also a mechanism for transferring good initializations across heterogeneous edge tasks.

A common misconception is that edge-oriented FL merely relocates a central server. The decentralized averaging in EdgeFL, the consensus updates in CFEL, and the sequential migration of EdgeFLow show that the aggregation operator itself may be centralized, hierarchical, peer-to-peer, or itinerant, while still serving the same global learning objective (Zhang et al., 2023, Zhang et al., 2022, Shi et al., 3 Mar 2026).

3. Communication, scheduling, and resource co-design

A defining property of federated edge learning frameworks is that communication control is treated as part of the learning system rather than as a fixed substrate. CFLMEC is explicit about this coupling. It assumes a shared spectrum with both cellular and D2D links, divides bandwidth into orthogonal sub-channels, allows reuse only between one cellular link and one D2D link, and optimizes time-average admitted data subject to SINR, queue, association, reuse, and power constraints (Wang et al., 2021). The per-sub-channel rate is written as

$\kappa_1\kappa_2$2

and the resource allocation problem is cast as maximizing admitted data over admission and scheduling variables, then solved by primal–dual decomposition with batch gradient descent on delayed state information (Wang et al., 2021).

HFEL frames the same issue as a global cost minimization problem over edge association, uplink bandwidth shares, and device CPU frequencies. The objective is a weighted sum of energy and delay,

$\kappa_1\kappa_2$3

under bandwidth, CPU-frequency, and association constraints (Luo et al., 2020). For fixed training groups, the per-edge resource allocation subproblem is convex; once those per-group costs are available, iterative transferring and exchanging adjustments yield a stable edge association strategy (Luo et al., 2020). The result is not just faster communication but explicit co-optimization of device–edge association and hierarchical training cost.

The beyond-5G MEC perspective formulates communication delay and compute delay directly at the device level: $\kappa_1\kappa_2$4 where $\kappa_1\kappa_2$5 is local data size, $\kappa_1\kappa_2$6 is computation capacity, $\kappa_1\kappa_2$7 is update size, $\kappa_1\kappa_2$8 is spectral efficiency, and $\kappa_1\kappa_2$9 is the number of allocated resource blocks (Jere et al., 2020). On that basis, the paper proposes an RL-based communication resource allocator and a greedy device-selection algorithm that maximizes the sum of data weights $\min_w F(w) = \sum_k p_k F_k(w),$0 under per-round deadline and edge-capacity constraints (Jere et al., 2020). This explicitly ties learner selection to channel state, update size, and edge processing limits.

An even more general optimization layer appears in GenQSGD, which studies an edge computing system with heterogeneous server and worker computation/communication capabilities and quantized message passing (Pinyoanuntapong et al., 2021). GenQSGD parameterizes FL by the number of global iterations, local iterations, mini-batch size, and step-size sequence, derives convergence bounds for arbitrary step-size schedules, and then minimizes energy subject to time and convergence error constraints. The time and energy models are defined over the full FL implementation process, not only over one round, which makes step-size design, batch size, quantization level, and synchronization frequency part of the systems optimization problem (Pinyoanuntapong et al., 2021).

Taken together, these works establish that in federated edge learning, the communication stack, scheduling policy, and local training schedule are co-determinants of convergence, latency, and throughput rather than external deployment details.

4. Decentralization, heterogeneity, and topology-aware learning

Several recent frameworks treat topology and heterogeneity as first-class modeling objects. EdgeFL is explicitly edge-only and decentralized: each peer pulls models from a randomly selected subset of active peers, controlled by a participation ratio $\min_w F(w) = \sum_k p_k F_k(w),$1, aggregates them locally, and continues training without a global server round (Zhang et al., 2023). Its life-cycle is minimalistic—Peer(config), peer.start(), peer.aggregation_func(), peer.unregister_peer()—and the framework reports four lines of code for integration into a PyTorch script (Zhang et al., 2023). This places configurability and deployability on the same footing as algorithm design.

CFEL formalizes a two-tier architecture in which devices communicate only with their own edge server and edge servers communicate over a connected graph $\min_w F(w) = \sum_k p_k F_k(w),$2 by gossip (Zhang et al., 2022). Its CE-FedAvg algorithm has three nested time scales: local SGD iterations, intra-cluster aggregation every $\min_w F(w) = \sum_k p_k F_k(w),$3 local steps, and inter-cluster consensus every $\min_w F(w) = \sum_k p_k F_k(w),$4 edge rounds with $\min_w F(w) = \sum_k p_k F_k(w),$5 gossip steps (Zhang et al., 2022). A key analytical contribution is the separation of heterogeneity into intra-cluster and inter-cluster components, with the global divergence decomposed as

$\min_w F(w) = \sum_k p_k F_k(w),$6

which shows how cluster formation and synchronization frequency jointly affect convergence (Zhang et al., 2022).

HAF-Edge addresses a different form of heterogeneity: heterogeneous model architectures across edge clusters (Gao et al., 2024). Clients attached to the same edge server share a model architecture, but different edges may use different depths such as 1NN, 3NN, or 5NN. Within an edge, aggregation is model-level; across edges, the cloud performs MaxCommon layer-wise aggregation on only the layers shared by the heterogeneous models, reconstructing per-architecture global models after aggregation (Gao et al., 2024). Edge aggregation after the first round is also data-quality-aware: local models with larger Euclidean distance from the previous global model receive larger weight, motivated by the empirical observation that more skewed non-IID local models tend to stay closer to the current global model (Gao et al., 2024).

EdgeFLow makes topology itself the global synchronization mechanism. The active base station at round $\min_w F(w) = \sum_k p_k F_k(w),$7 holds $\min_w F(w) = \sum_k p_k F_k(w),$8, distributes it to its local cluster, aggregates local updates, and then migrates $\min_w F(w) = \sum_k p_k F_k(w),$9 to the next base station in a fixed or random sequence (Shi et al., 3 Mar 2026). Its convergence bound is written in terms of a cluster-level heterogeneity term $$\arg\min_w F(w), \quad F(w)=\frac{1}{N}\sum_{m=1}^{M}\sum_{n=1}^{L_m} f_{mn}(w),$$0, not only per-client stochastic noise, which matches the clusterized edge architecture more naturally than standard client-server analysis (Shi et al., 3 Mar 2026).

These frameworks contradict the assumption that one global model, one server, and one communication pattern suffice for edge FL. The literature instead treats client drift, graph structure, mixed model sizes, and cluster composition as design variables that can materially alter convergence and deployment cost.

5. Security, privacy, and trustworthy aggregation

Raw-data locality is often presented as the security benefit of FL, but the literature distinguishes clearly between privacy by data locality and robustness or confidentiality of model exchange. EdgeFL states that raw data never leave the edge devices, but also notes that it does not implement secure aggregation, differential privacy, or encryption of model transfers, and that HTTP exchanges appear to be in clear text because no TLS is mentioned (Zhang et al., 2023). This is representative of a broad class of performance-oriented edge FL systems whose threat model stops at data non-centralization.

SHFL treats poisoning as a first-class systems threat in hierarchical edge networks (Tavallaie et al., 2024). At the edge level, it defines a trust metric

$$\arg\min_w F(w), \quad F(w)=\frac{1}{N}\sum_{m=1}^{M}\sum_{n=1}^{L_m} f_{mn}(w),$$1

sorts clients by this deviation, removes the estimated adversaries with the largest distances, and then randomly samples the training subset from the remaining trusted pool (Tavallaie et al., 2024). At the cloud level, it computes edge scores that combine processed data size and distance to the current global model, then solves a convex optimization problem to assign secure aggregation weights $$\arg\min_w F(w), \quad F(w)=\frac{1}{N}\sum_{m=1}^{M}\sum_{n=1}^{L_m} f_{mn}(w),$$2 before global aggregation (Tavallaie et al., 2024). This two-stage defense is specifically aimed at untargeted model and data poisoning in hierarchical edge FL.

The blockchain-based BFEL framework addresses decentralization and trust from a different angle (Kang et al., 2020). It introduces a hierarchical blockchain composed of model training subchains, a model trading subchain, and a public main chain. Proof-of-Verifying evaluates uploaded model updates on a benchmark test dataset, filters out low-quality or malicious updates, and records qualified updates on the appropriate subchain (Kang et al., 2020). BFEL then combines this with gradient compression, so security, auditing, and communication efficiency are handled within a single decentralized control plane (Kang et al., 2020).

Robustness against data and distribution shift also appears at the optimization level. The federated meta-learning framework extends its meta-objective with Wasserstein distributionally robust optimization and a robust surrogate loss, producing a robust FedML algorithm that meta-trains on both clean and adversarially perturbed data (Lin et al., 2020). This makes robustness part of the task-adaptation pipeline rather than a separate aggregation filter.

At the framework level, OmniFed exposes differential privacy, homomorphic encryption, and secure aggregation as configurable plugins alongside communication protocols and compression strategies (Tyagi et al., 23 Sep 2025). A plausible implication is that future federated edge learning frameworks will increasingly treat privacy, communication, and orchestration as co-equal extension points rather than as isolated add-ons.

6. Evaluation practice, deployment substrates, and design trade-offs

The systems literature evaluates federated edge learning frameworks not only by final accuracy but also by convergence rate, runtime, bandwidth, orchestration complexity, and infrastructure behavior. EdgeFL, for example, reports lower weights update latency and faster model evolution than PySyft, FATE, and PaddleFL on MNIST and CIFAR-10, while also emphasizing ease of integration through its four-line API (Zhang et al., 2023). OmniFed broadens this practice by comparing algorithms, compression schemes, and privacy modules across multiple models, and by measuring both accuracy and overhead in the same stack (Tyagi et al., 23 Sep 2025).

An important complementary direction is testbed realism. The Kubernetes-based edge-like evaluation framework deploys FL clients and server as Docker containers managed by a 43-node cluster comprising “computer” nodes, Raspberry Pi “edge” nodes, and “server” nodes, with Rook Ceph for persistent storage and Prometheus plus Grafana for CPU, memory, and network monitoring (Schwanck et al., 2024). It supports configurable data distributions, including balanced and unbalanced, IID and non-IID, pathological and Dirichlet splits, and records per-client accuracy, loss, and micro/macro/weighted F1 metrics alongside pod-level resource traces (Schwanck et al., 2024). This shifts evaluation from purely algorithmic simulation toward reproducible, infrastructure-aware benchmarking.

Energy and carbon accounting add a further axis of comparison. The analytical framework for distributed and federated edge learning models both communication and computation energy and maps them to carbon equivalent emissions (Savazzi et al., 2021). In the reported industrial setting, FL allows remarkable end-to-end energy savings of 30%-40% for wireless systems characterized by low bit/Joule efficiency of 50 kbit/Joule or lower, while consensus-driven FL further reduces emissions in mesh networks at 200 kbit/Joule (Savazzi et al., 2021). The same work also reports that all FL policies are slower to converge when local data are unevenly distributed, often 2x slower than CL, which makes environmental efficiency and learning loss an explicit trade-off rather than aligned objectives (Savazzi et al., 2021).

A recurring limitation is that many frameworks optimize one bottleneck while abstracting away others. CFLMEC centers throughput and spectrum scarcity under a single-edge MEC setting (Wang et al., 2021); HFEL assumes static devices and synchronous training (Luo et al., 2020); EdgeFL evaluates dynamic joins but not advanced security (Zhang et al., 2023); the Kubernetes testbed emphasizes experimentation and monitoring rather than fault-tolerant protocol design (Schwanck et al., 2024). This suggests that a mature federated edge learning framework will require simultaneous treatment of topology, heterogeneity, communication efficiency, robustness, deployability, and observability rather than excellence on only one axis.

Federated edge learning frameworks therefore occupy the intersection of distributed optimization, wireless and edge systems, and trustworthy ML infrastructure. The literature converges on several stable ideas: partial aggregation near data sources, topology-aware synchronization, explicit handling of device and model heterogeneity, configurable privacy and compression, and evaluation under real or realistic edge constraints. It diverges, however, on where coordination should live—cloud, edge hierarchy, peer graph, blockchain, or migrating model state—and on how aggressively communication and security should be co-optimized. That divergence is not a sign of immaturity so much as evidence that the term denotes a broad systems class whose concrete realization depends on whether the dominant constraint is latency, spectrum, adversarial robustness, hardware heterogeneity, software modularity, or environmental cost.