DASFL: Dynamic Adaptive Split Federated Learning for Heterogeneous Clients

1 Introduction

With the rapid deployment of deep neural networks on edge intelligence applications, collaborative model training under strict privacy and resource constraints has become a fundamental challenge [Kairouz et al., 2021; Liu et al., 2024]. In practice, data are generated and retained on geographically distributed edge devices with highly heterogeneous and time-varying computation capabilities and communication bandwidths, such as in mobile perception [Gecer and Garbinato, 2024], smart surveillance [Uzzaman, 2025], and Internet of Vehicles (IoV) [Jamil et al., 2022]. Federated learning (FL) [McMahan et al., 2017; Li et al., 2020] enables privacy-preserving collaborative training by keeping raw data on device. However, FL requires all clients to repeatedly train the full model, which becomes increasingly impractical as modern deep networks grow in depth and complexity. Under heterogeneous and time-varying system conditions, computation-limited clients frequently become stragglers, severely degrading training efficiency. Split learning (SL) [Gupta and Raskar, 2018; Vepakomma et al., 2018; Lin et al., 2024a] alleviates this issue by partitioning a model across the client-server boundary, allowing clients to offload deep computation to the server. Despite reduced client-side computation, SL typically relies on sequential client updates, limiting scalability in multi-client settings.

∗Corresponding author

Split federated learning (SFL) [Thapa et al., 2022] combines the advantages of FL and SL by enabling parallel multiclient training while offloading part of the model computation to the server. A critical design choice in SFL is the selection of the split layer [Wu et al., 2023; Hu et al., 2025], which governs both the distribution of computation and the representation level of exchanged smashed data (i.e., intermediate activations). Shallow splits incur high communication overhead due to large low-level feature maps [Dachille et al., 2025], whereas deeper splits reduce communication cost at the expense of increased client-side computation, directly affecting end-to-end training latency and system efficiency. Beyond efficiency, split layer selection also shapes learning behavior by exposing the server to different representation spaces [Joshi et al., 2022], leading to distinct optimization trajectories and generalization properties. Importantly, system heterogeneity is often coupled with data heterogeneity, as devices with different resource profiles typically collect data from diverse and skewed distributions. Under such non-IID settings, split layer choices induce distinct inductive biases and convergence behaviors [Arafeh et al., 2025], making learning performance highly sensitive to how computation is partitioned.

Despite these impacts, existing SFL methods predominantly rely on static split configurations. Uniform split strategies implicitly assume homogeneous client capabilities [Thapa et al., 2022; Chopra et al., 2021], while heterogeneous but fixed splits [Zhang et al., 2024; Zhu et al., 2024; Shen et al., 2023] fail to adapt to time-varying computation and communication conditions. As a result, static split decisions lead to inefficient and suboptimal training in dynamic edge environments, motivating dynamic split layer selection as a natural solution for improving system efficiency. However, dynamic split selection introduces a largely overlooked challenge: structural heterogeneity. As clients adopt different split layers over time, they update different subsets of model parameters, causing local updates to become misaligned in the parameter space. This breaks the assumptions of conventional federated aggregation methods and can severely harm learning stability and accuracy, especially under non-IID data distributions [Zhu et al., 2021].

These observations reveal two tightly coupled challenges in dynamic SFL: (i) how to adapt split decisions to heterogeneous and time-varying resources to improve training efficiency, and (ii) how to robustly aggregate structurally heterogeneous updates under non-IID data to preserve model accuracy and convergence.

To address these challenges, we propose Dynamic Adaptive Split Federated Learning (DASFL), a unified framework for efficient SFL under dynamic resource heterogeneity and non-IID data distributions. For Challenge (i), we propose a resource-aware dynamic split layer selection strategy, which enables each client to adaptively select its split layer at every communication round based on instantaneous computation and communication conditions. This strategy minimizes per-round training latency and mitigates straggler effects. For Challenge (ii), We propose an adaptive masked federated aggregation mechanism that robustly aggregates client updates, mitigating aggregation interference caused by non-IID data and heterogeneous local models. Extensive experiments on multiple models and datasets demonstrate that DASFL consistently outperforms SFL baselines in both accuracy and end-to-end training latency.

Our main contributions are summarized as follows:

• We propose a resource-aware dynamic split layer selection strategy that enables clients to adapt split decisions to heterogeneous and time-varying computation and bandwidth resources, significantly improving training efficiency in SFL.
• We design an adaptive mask-based aggregation mechanism that supports robust aggregation under non-IID data distributions and split-induced structural heterogeneity, by selectively aggregating informative clientside updates while suppressing misaligned parameters.
• We develop a unified DASFL framework that tightly couples dynamic system-aware split adaptation with learning-aware aggregation, achieving stable convergence and superior accuracy-efficiency trade-offs under realistic edge heterogeneity.

2 RelatedWork

Existing SFL approaches primarily aim to improve scalability, communication efficiency, and privacy preservation, while typically adopting a fixed split layer across all clients and communication rounds. SplitFed [Thapa et al., 2022] extends classical SL by incorporating federated averaging for both client-side and server-side sub-models, enabling parallel training while maintaining global model consistency. Subsequent efforts improve SFL from several directions, including efficient parallelization and gradient reduction [Lin et al., 2024b], privacy-preserving activation sharing [Ma et al., 2023], communication compression [Oh et al., 2025], and hierarchical edge-assisted training [Khan et al., 2023; Fan et al., 2025]. communication-privacy trade-off in [Zhang et al., 2023]. Despite these advances, most existing SFL methods rely on static split configurations and implicitly assume homogeneous system resources, limiting their applicability in dynamic and resource-constrained environments.

Heterogeneity is a fundamental challenge in SFL, encompassing both system heterogeneity due to diverse device capabilities and statistical heterogeneity arising from non-IID data distributions [Kairouz et al., 2021]. From a theoretical perspective, the convergence behavior of SFL under heterogeneous data distributions has been formally analyzed in [Han et al., 2024; Lin et al., 2025b], providing important insights into the stability of SFL optimization. To address system heterogeneity in SFL, AdaptSFL [Lin et al., 2025a] allows clients with different capabilities to adopt different split layers, while EdgeSplit [Zhang et al., 2024] and ESFL [Zhu et al., 2024] optimize model partitioning and resource allocation through joint optimization formulations. From the aggregation perspective, sparse or selective update mechanisms have been explored to reduce communication and suppress noisy updates, such as Deep Gradient Compression [Lin et al., 2018] and FedMask [Li et al., 2021].While most existing approaches consider client heterogeneity, they typically assume static resource conditions and aligned model structures, overlooking the non-stationary nature of computation and communication resources in practical edge environments.

3 Methodology

We propose Dynamic Adaptive Split Federated Learning (DASFL), a unified framework that enables efficient and robust SFL under dynamic system heterogeneity and non-IID data distributions. DASFL consists of three tightly coupled components: (1) Resource-aware dynamic split layer selection, where each client adaptively chooses its split layer at every round based on instantaneous computation and communication resources; (2) Split learning under structurally heterogeneous local models, where clients and the main server collaboratively train different subsets of model parameters according to the selected split layers; and (3) Adaptive masked federated aggregation, tightly integrated with the split learning process, where informative client-side updates are selectively aggregated on the federated server. The overall training procedure is summarized in Figure 1 and Algorithm 1.

3.1 ProblemDefinition

We consider split federated learning (SFL) with heterogeneous clients K = {1, . . . ,K} under non-IID data. Client k owns a private dataset Dk and never shares raw data. We adopt a dual-server architecture with a Main Server (MS) executing SL on the server-side sub-model, and a Federated Server (FS) aggregating masked client-side updates. Given a candidate split layer l ∈ L, the model is partitioned into f (l) c (·; θc) and f (l) s (·; θs). At round t, client k selects ltk ∈ L, inducing structural heterogeneity where clients update different parameter subsets. We aim to optimize θ = {θc, θs} by minimizing the aggregated empirical risk:

Dynamic split ltk affects which layers participate in SFL and aggregation at each round, but not the objective itself.

3.2 Resource-aware Dynamic Split Layer Selection

Dynamic system heterogeneity makes a fixed split point suboptimal: a shallow split reduces client computation but increases smashed-data traffic, while a deep split does the opposite. To adapt to time-varying resources, DASFL performs per-round, per-client split-point selection. Specifically, each client estimates the round latency of every candidate split layer by combining (i) client-side training compute time determined by the partitioned sub-model and its instantaneous compute capability, and (ii) communication time including smashed-data exchange with the MS and masked-update with the FS. The client then selects the split layer that minimizes the estimated latency in Eq. (6), enabling decentralized adaptation without extra coordination.

Resource State Model. Each client k has maximum compute capacity C max k and uplink budget Bmax k . At round t, its effective compute is

where ρcpu k,t ∈ [0, 1] is CPU utilization, and available uplink bandwidth is bk,t ≤ Bmax k .

Computation Time Estimation. Let MACFP c (l) be the MACs for one forward pass of f (l) c . We approximate persample training cost as

with γ ≈ 2. Let nk be the number of samples processed per round by client k (e.g., nk = E·batch size). Then

We omit MS computation time, assuming it is stable and dominated by edge-side latency.

Communication Time Estimation. In SFL, communication includes SL smashed-data exchange between client and MS and masked-update upload and client-model broadcast between client and FS.

For split layer l, SL requires bidirectional transfer of smashed data and gradients, modeled as 2Sizeact(l) per round. FS-side aggregation traffic is denoted by Sizeparam(l), representing the actual per-round upload+download volume (dense zero-masked tensor or sparse index-value pairs with index overhead). Using the uplink-dominant approximation with effective bandwidth bk,t, we estimate

Dynamic Split Layer Selection. By jointly considering computation and communication costs, client k selects its split layer at round t by minimizing the estimated latency:

where β1 and β2 are weighting coefficients that balance computation and communication overheads. This lightweight decision rule enables each client to adapt its split layer to heterogeneous and time-varying resource conditions without introducing additional learning or coordination overhead. We set β1 = β2 = 1 by default.

3.3 Split Learning Training and Adaptive Masked Federated Aggregation

We describe the training and aggregation procedure of DASFL under dynamically selected split layers, which naturally induce structurally heterogeneous local models across clients.

Algorithm 1 DASFL Under One Federated Round

Input: Client set K; candidate split layer set L; initial clientside and server-side parameters θt-1 c , θt-1 s

Output: Updated θtc , θts

• 1: for all clients k ∈ K in parallel do
• 2: Sense instantaneous resources and select split layer ltk using Eq. (6)
• 3: Client→MS (SL FP): perform client-side FP up to layer ltk and compute smashed data atk
• 4: Transmit atk to the MS
• 5: end for
• 6: for all received atk from clients k ∈ K do
• 7: MS-side SL: perform server-side FP and BP
• 8: MS→Client (SL BP): return ∇atk to client k
• 9: end for
• 10: for all clients k ∈ K in parallel do
• 11: Complete BP on the client-side sub-model and update local client-side parameters
• 12: Compute local client-side update ∆θtk (w.r.t. θt-1 c )
• 13: Generate maskmtk using Eqs. (7)-(8)
• 14: Obtain masked update ˜ ∆θtk using Eq. (9)
• 15: Client→FS: upload ˜ ∆θtk
• 16: end for
• 17: FS aggregation: update client-side global parameters θtc using Eq. (10)
• 18: MS aggregation: synchronize server-side parameters θts on the MS (FedAvg over shared server-side layers)
• 19: FS→Clients: broadcast updated client-side parameters θtc to all clients

Split Learning under Structurally Heterogeneous Local Models. At communication round t, client k selects a split layer ltk and performs SL collaboratively with the MS, which hosts the server-side sub-model. Specifically, client k executes FP on its local sub-model up to layer ltk to compute the smashed data atk = f (ltk ) c (x; θc), and transmits them to the MS. Upon receiving atk , the MS completes the remaining forward propagation using the server-side sub-model, computes the training loss ˆ y = f (ltk ) s (atk ; θs), and performs backward propagation. The gradient ∇atk with respect to the smashed data is then returned to client k. Client k completes backpropagation through its client-side sub-model and updates the corresponding local parameters. Since different clients may select different split layers at each round, only a subset of the global model parameters is updated by each client, resulting in structurally heterogeneous local models.

Adaptive Masked Local Updates. To address non-IID data distributions and structural heterogeneity induced by dynamic split layers, each client generates adaptive masked local updates before federated aggregation. At round t, client k computes its local update ∆θtc,k = θtc,k - θt-1 c . Let Ltk denote the set of effective layers updated by client k and Nℓ the number of parameters in layer ℓ ∈ Ltk . Given a base keep ratio α, we allocate the update budget evenly across effective layers to avoid large layers dominating the retained updates and to ensure that each effective layer contributes to aggregation. The per-layer budget is

Accordingly, smaller layers have higher effective keep ratios, while larger layers are more aggressively subsampled. This design prioritizes balanced cross-layer participation rather than proportional per-layer retention. To avoid extreme imbalance, the layer-specific keep ratio rℓ = Kℓ/Nℓ is clipped to [rmin, rmax]. For each layer, a quantile-based threshold εtℓ is determined such that approximately a fraction rℓ of parameters is retained. The resulting binary mask is constructed as

and the masked local update is given by

Eq. (9) is the only operation that applies masking to the update values, i.e., unselected entries are set to zero (or omitted under sparse transmission).

Masked Federated Aggregation. After local training and adaptive masking, clients upload their masked client-side updates ˜ ∆θtc,k to the federated server (FS) for global aggregation. Since different clients may update different subsets of parameters due to dynamic split layers, the FS performs coordinate-wise normalized aggregation: each parameter is averaged only over clients that actually updated it in the current round. Recall that ˜ ∆θtc,k,i = mtk,i∆θtc,k,i ; thus mtk,i in the denominator only counts effective contributors for coordinate i. Concretely, the FS updates each client-side parameter θtc,i by

where wk is proportional to the local dataset size of client k, and ε is a small constant for numerical stability. Note that mtk,i in the denominator does not apply a second masking to the update. Instead, it identifies the set of effective contributors for coordinate i in round t so that the update is normalized by the total weight of clients that participated in updating that coordinate. Client-side parameters not updated by any client (i.e., ∑Kk=1 mtk,i = 0) remain unchanged.

When sparse upload is adopted, the binary mask mtk need not be transmitted explicitly. Client k uploads index-value pairs for the retained coordinates

S tk = {i : mtk,i = 1}. The FS reconstructs ∑k mtk,iwk in Eq. (10) by accumulating weights over received indices, making the aggregation exactly consistent with the sparsified communication protocol.

3.4 Convergence Analysis

We further provide a convergence analysis (Appendix A) showing that DASFL admits a standard stationarity guarantee under smoothness, with additional error terms that depend on the masking ratio and the update coverage under dynamic split.

4 Experiments

4.1 Experiment Settings

Models and Datasets. We evaluate DASFL on three representative models and datasets: LeNet [LeCun et al., 1998] on Fashion-MNIST [Xiao et al., 2017], ResNet-18 on CIFAR-10, and ResNet-50 on CIFAR-100 [He et al., 2016; Krizhevsky et al., 2009]. These configurations cover lightweight to deep architectures and varying task complexity.

Baselines. We compare DASFL with representative methods from federated learning, split learning, and heterogeneity-aware split federated learning. (1) FL [McMahan et al., 2017]: standard federated learning with full-model local training and FedAvg aggregation. (2) SL [Gupta and Raskar, 2018]: split learning with a fixed split layer and sequential client updates. (3) SFL [Thapa et al., 2022]: parallel split learning with federated aggregation. For SL and SFL, we evaluate a shallow split (l = s) that minimizes client-side computation, and a middle split (l = m) that balances computation and communication costs. We further compare with heterogeneous SFL methods. (4) EdgeSplit [Zhang et al., 2024], (5) ESFL [Zhu et al., 2024], and (6) AdaptSFL [Lin et al., 2025a].

Metrics. We report average test accuracy to evaluate learning performance and round latency to measure system efficiency. The per-round completion time is defined as the makespan T round = maxk∈Kt (T comp k,t +T comm k,t ). In addition, we report the average per-client computation and communication times Tcomp = 1 T ∑Tt=1 1 |Kt | ∑k∈Kt T comp k,t and Tcomm = 1 T ∑Tt=1 1 |Kt | ∑k∈Kt T comm k,t . These averages characterize typical client costs and are not intended to sum to T round .

Data Heterogeneity. We evaluate both IID and non-IID data distributions across clients. Non-IID partitions are generated using a Dirichlet distribution [Hsu et al., 2019], with α = 0.5 and α = 0.1 representing moderate and severe data heterogeneity, respectively.

System Heterogeneity. We emulate heterogeneous and time-varying edge environments by modeling client-side computation and uplink bandwidth variability. Clients exhibit diverse compute and network capabilities, and their resource availability fluctuates over training rounds to reflect realistic background workloads and wireless dynamics. We consider heterogeneous clients with diverse computation and communication capabilities. Specifically, clients are grouped into three computation tiers (low, medium, and high) and two network conditions (poor and good), capturing practical deviceand network-level heterogeneity. Detailed resource models are provided in Appendix B.

Split Layer Configuration. We fix the candidate split layer set L across all methods to ensure fair comparison. For ResNet-18, candidate split layers are defined at the outputs of the four main residual stages: L = {conv2 x, conv3 x, conv4 x, conv5 x}, which correspond to increasing client-side model depths and progressively higher-level feature representations. This design provides a representative spectrum of computationcommunication trade-offs. For static SL and SFL baselines, we consider two commonly used configurations: a shallow split (l=s) at conv2 x, which minimizes client-side computation, and a middle split (l=m) at conv4 x, which balances computation and communication costs. The candidate split layer configurations for other models (LeNet and ResNet-50), together with their corresponding computation cost (MACs) and activation size profiling results, are provided in Appendix B. All split point profiles are obtained offline and used as lookup tables during training.

Parameter Settings. We consider a federated setting with 20 clients and a participation rate of 0.5 per round. Each selected client performs one local epoch before aggregation. Standard optimizers and learning rates are used for different models. Full hyperparameter settings and profiling details are provided in Appendix B.

4.2 Performance Analysis

Accuracy under Data Heterogeneity. Table 1 reports the final test accuracy under IID and non-IID data distributions. Overall, DASFL consistently outperforms all baselines across all model-dataset pairs. The performance gap becomes more pronounced as data heterogeneity increases. Under highly non-IID settings (Dirichlet α = 0.1), DASFL achieves up to 5.2-16.4 percentage points higher accuracy than staticsplit SFL and AdaptSFL, demonstrating strong robustness to severe data skew. In contrast, methods with fixed split configurations suffer from degraded convergence, as a single split layer cannot simultaneously accommodate heterogeneous clients and evolving system conditions.

Training Efficiency and Latency. Table 2 summarizes the training latency in terms of computation, communication, and per-round latency. Conventional FL incurs prohibitively high computation cost for deep models, while SL and static-split SFL exhibit strong sensitivity to the chosen split layer. Shallow splits amplify communication overhead, whereas deeper splits increase client-side computation and straggler effects. By dynamically adapting split layers to instantaneous resource conditions, DASFL achieves the lowest or near-lowest per-round latency in most settings, and is particularly advantageous for deeper models where FL becomes computeprohibitive, reducing round latency by up to 19.1-30.9% compared with static SFL baselines.

Dynamic Split Layer Behavior. Figure 2 shows that DASFL converges not to a fixed split layer, but to a resourceconditioned adaptation pattern. Figure 2(a) shows that split choices form structured regions in the CPU-bandwidth space: deeper splits are selected under favorable resource conditions, while shallower splits are preferred when computation or communication becomes constrained. Thus, similar resource conditions tend to induce similar split decisions. Figure 2(b) shows that no single split persistently dominates over rounds. The observed variation therefore reflects structured adaptation to heterogeneous and time-varying resources, rather than unstructured oscillation.

4.3 Ablation Study

We conduct ablation studies on ResNet-18 to analyze the individual contributions of adaptive masked aggregation and resource-aware dynamic split layer selection. The results are summarized in Table 3.

Impact of adaptive masked aggregation. We first fix the dynamic split layer selection mechanism and replace the proposed adaptive masked aggregation with three alternative aggregation strategies, denoted as DASFL-a. Full uploads both client-side and server-side sub-model parameters to the federated server, where a complete model is reconstructed and aggregated. Com aggregates only the common client-side parameters shared across all clients. Layer-wise performs layerlevel aggregation on client-side sub-models.

As shown in Table 3, all three variants result in inferior accuracy-latency trade-offs compared to DASFL, particularly under non-IID data distributions. The Full variant suffers from excessive communication overhead, leading to the largest per-round latency. In contrast, Comand Layer-wise reduce communication cost but fail to properly aggregate structurally heterogeneous updates, which significantly degrades accuracy under α = 0.5 and α = 0.1. These results show that conventional aggregation schemes are inadequate when dynamic split selection induces structural heterogeneity, highlighting the necessity of adaptive masked aggregation.

Impact of dynamic split layer selection. We next retain the adaptive masked aggregation mechanism and ablate the split layer selection strategy, denoted as DASFL-d. Uni enforces a unified split layer across all clients and rounds, while Random randomly selects a split layer at each round without considering system resources. Both variants underperform the full DASFL model. Specifically, Uni lacks the flexibility to accommodate heterogeneous and time-varying computation and communication resources, leading to suboptimal accuracy and latency. Random introduces uncoordinated split decisions, which destabilize training and yield inferior accuracy-efficiency trade-offs. In contrast, DASFL consistently achieves higher accuracy with lower per-round latency, demonstrating that resource-aware dynamic split layer selection is essential for robust and efficient SFL.

4.4 Hyperparameter Analysis

We analyze the sensitivity of DASFL to two key hyperparameters: the keep ratio rℓ used in adaptive masked aggregation and the weighting coefficients (β1, β2) controlling dynamic split layer selection.

Effect of keep ratio rℓ. Figure 3(a) shows the final test accuracy under different rℓ values for IID and non-IID data distributions. Under the IID setting (α = 10), model performance remains stable across a wide range of rℓ, indicating that parameter masking does not degrade accuracy when data are homogeneous. In contrast, under non-IID settings, accuracy becomes more sensitive to rℓ. Very small keep ratios lead to noticeable performance degradation, while moderate values consistently achieve higher accuracy. This trend is especially pronounced under extreme non-IID data (α = 0.1), where intermediate rℓ yields the best performance, highlighting the importance of balancing sparsity and information retention. Figure 3(b) reports the corresponding system latency. As rℓ increases, communication latency grows monotonically due to the larger volume of uploaded parameters, while computation latency slightly decreases. As a result, the overall round latency increases with larger rℓ, revealing a clear accuracy-efficiency trade-off. These results indicate that moderate keep ratios provide a favorable balance between robustness to data heterogeneity and system efficiency, and are adopted in subsequent experiments.

Effect of weight configurations (β1, β2). We further study the impact of the weighting coefficients (β1, β2) in Eq. (6), which balance computation and communication costs during dynamic split layer selection. Five representative configurations are evaluated: (3, 1), (2, 1), (1, 1), (1, 2), and (1, 3). As shown in Figure 4(a), increasing β1 relative to β2 biases split layer selection toward shallower client-side models, reducing computation latency but increasing communication latency due to larger smashed data transmission. Conversely, larger β2 favors deeper split layers, lowering communication latency at the cost of higher client-side computation. Among all configurations, (β1, β2) = (1, 1) achieves the lowest overall round latency, indicating a well-balanced tradeoff. Figure 4(b) further illustrates the distribution of selected split layers under different (β1, β2) settings. Larger β1 leads to more frequent selection of early layers (e.g., conv2 x), whereas larger β2 shifts selections toward deeper layers (e.g., conv4 x and conv5 x). This behavior confirms that the proposed split selection mechanism effectively adapts to different resource-weighting preferences and explains the observed latency trends. Accordingly, we adopt β1 = β2 = 1 as the default configuration.

Limitations. DASFL is currently evaluated on image classification benchmarks with moderate-scale clients under a controlled resource simulator. Its advantage may diminish when client resources are nearly homogeneous or static, where a fixed split may already suffice. Moreover, the current resource model does not fully capture continuous fluctuations in real deployments, which we leave to future work.

5 Conclusion

This paper presented Dynamic Adaptive Split Federated Learning (DASFL), a unified framework for efficient and robust split federated learning under heterogeneous, timevarying resources and non-IID data. DASFL integrates resource-aware dynamic split layer selection with adaptive masked federated aggregation, enabling clients to adapt partitioning to instantaneous conditions while maintaining stable optimization under split-induced structural heterogeneity. Extensive experiments across multiple model-dataset pairs show that DASFL consistently achieves higher accuracy and lower training latency than FL, SL, static-split SFL, and recent heterogeneity-aware baselines, especially under severe data and resource heterogeneity. Overall, effective SFL in realistic edge environments requires not only dynamic split selection but also aggregation mechanisms tailored to structural heterogeneity. DASFL provides a practical foundation for adaptive, resource-aware federated learning in edge intelligence systems.

Acknowledgements

This work was supported by the National Natural Science Foundation of China (U22B2038, 62532002, 62192784, U23A20319).