Learning to Sync at the Edge: Client-Side Adaptive Synchronization for Federated Learning

Learning to Sync at the Edge: Client-Side Adaptive Synchronization for Federated Learning Ebasa Temesgen, Ammar Ahmed, Nathan Lechamo† , Ali Anwar, Maria Gini

arXiv:2610.14268v1 [cs.DC] 9 Oct 2026

Department of Computer Science & Engineering, University of Minnesota, Minneapolis, MN, USA † Department of Computer Science, University of Texas at San Antonio, San Antonio, TX, USA {temes021, ahme0599, aanwar, gini}@umn.edu, nathan.lechamo@utsa.edu

Abstract—The scalability and performance of edge federated learning are fundamentally constrained by synchronization bottlenecks. Clients operate under heterogeneous compute, timevarying communication conditions, and, in some settings, privacy constraints, yet synchronization is often still handled with fixed schedules. However, synchronization decisions are often made outside the client, even though the client directly observes local progress, resource state, and communication conditions. We present a client-side reinforcement learning synchronization framework in which each client decides during training whether to upload, download, synchronize bidirectionally, or defer communication. The framework places a lightweight scheduler alongside the local model and formulates synchronization as a resource-aware control problem driven by local learning and system state. We study this framework on two representative edge workloads, spatiotemporal traffic forecasting and image classification. Across both settings, adaptive client-side synchronization improves the accuracy–cost trade-off, reducing system cost in traffic forecasting while maintaining competitive cost and improving final accuracy in image classification. We also consider privacy-constrained settings, where synchronization must account for not only latency and energy but also privacy expenditure. Overall, our results show that synchronization in edge federated learning is better treated as an adaptive clientside control problem than only as a server-side coordination mechanism. Index Terms—federated learning, reinforcement learning, communication scheduling

I. I NTRODUCTION Federated learning (FL) is appealing for edge computing because it keeps raw data on-device while allowing many resource-constrained clients to train a shared model collaboratively [1]. This is especially valuable in edge settings such as traffic sensing, mobility analytics, and distributed perception, where data are generated continuously across many devices and may be costly, sensitive, or impractical to move to a central location. By keeping data local, FL reduces repeated raw-data transfer while still enabling clients to benefit from shared learning. In practice, however, the limiting factor is often not local optimization itself, but synchronization. Edge clients rarely operate under stable conditions: wireless bandwidth drifts over time, devices differ in compute capability and energy budget, and local data streams evolve. In privacy-sensitive settings such as traffic and mobility data, communication can also expose sensitive model updates and metadata [2], [3]. Despite this, synchronization control is often handled at the server or as

Server

Server

Global Model

Global Model

Aggregation

Aggregation

Server-side control RL

RL

RL

Client 1

Client 2

Client n

Client 1

Client 2

Client n

Raw Input

Raw Input

Raw Input

Raw Input

Raw Input

Raw Input

(a) Server-side control

(b) Ours

Fig. 1. Server-side versus client-side communication control in federated learning. (a) Prior work typically adapts communication from the server. (b) Our approach places a lightweight scheduler at each client to make synchronization decisions from local state.

part of the training protocol, even though many of the signals that determine whether communication is useful are local to the client. A client may have made little local progress, may be operating under a degraded channel, or may be close to exhausting a privacy budget. Synchronizing in these states can add latency, energy use, and privacy exposure without proportional learning benefit. This paper studies a central systems question in edge federated learning: when should a client synchronize? Rather than treating synchronization as only a server-side coordination decision, we treat it as a decision-event made at the client. Prior approaches primarily adapt communication from the server, for example through aggregation timing, buffering, or client selection [4]–[6]. In contrast, our framework (shown in Figure 1) moves synchronization control to the client, where the decision can respond directly to local utility and resources. Learning-based client selection has also been studied using multi-agent PPO for dynamic client selection in vehicular federated learning [7]. Our focus is the synchronization action available to a client: skip communication, upload, download, or synchronize bidirectionally. This motivates viewing synchronization as a client-side control problem rather than only a server-side scheduling or aggregation problem. The value of synchronizing depends jointly on local learning progress, staleness, channel state, energy cost, privacy budget, and the future consequences of acting now versus waiting. A decision that saves cost in the current round may increase staleness

and reduce utility later, while immediate synchronization may improve coordination at the expense of time and energy. These delayed and coupled trade-offs are difficult to capture with a single hand-designed rule or fixed protocol, since simple threshold policies typically react to only one signal, such as model change, staleness, or bandwidth. We therefore introduce a lightweight reinforcement learning (RL) scheduler for this client-side decision process, as illustrated in Figure 1, and evaluate it against learning-based client schedulers and server-side communication-control schedulers. At each decision event, the scheduler observes client-side signals that reflect both learning status and system conditions, including indicators of model utility, communication cost, and client resource state. Using compact server-broadcast context such as model update freshness, rank, and recent synchronization rates further improves performance, while the action remains selected by the client scheduler. The scheduler then selects whether to upload, download, synchronize bidirectionally, or defer communication. This allows synchronization to respond to learning progress, device heterogeneity, and time-varying network conditions without changing the underlying federated training pipeline. In this way, communication becomes an adaptive systems-level mechanism rather than a static training parameter. We also consider settings in which synchronization cost is shaped not only by latency and energy, but also by privacy constraints. This motivates a privacy-aware formulation of client-side synchronization, in which communication decisions are made with awareness of both system cost and privacy considerations rather than treating privacy as a separate concern after the schedule has already been chosen. We examine our framework on two representative edge workloads: spatiotemporal traffic forecasting and image classification. These workloads differ substantially in data characteristics, learning dynamics, and operating conditions, allowing us to evaluate whether the same client-side synchronization mechanism can perform across distinct edge learning settings. This paper makes the following contributions: • We present a client-side adaptive synchronization RL framework for federated learning at the edge, in which each client decides when to synchronize with the server. • We formulate synchronization as a resource-aware control problem that combines task utility with communication latency, energy cost, device heterogeneity, and privacy constraints. • We evaluate the same framework on two representative edge workloads, traffic forecasting and image classification, against learning-based and server-side communication-control baselines. • We show the scheduler improves the accuracy–cost tradeoff across traffic forecasting and image classification. II. R ELATED W ORK Communication efficiency remains a central challenge in federated learning, especially under bandwidth constraints, heterogeneous devices, intermittent availability, and non-IID

TABLE I C OMMUNICATION - CONTROL MECHANISMS IN FEDERATED LEARNING . Method

Control point

Controller

Decision

FedAsync FedBuff Oort FedMarl SCAFFOLD FedProx Avdiukhin et al. [11] Ruan et al. [12] Ours

Aggregation Aggregation Participation Participation Optimization Optimization Protocol Participation Synchronization

Server Server Server Server Server/client Client-objective Server/system Server/system Client

Apply updates Buffer updates Select clients Schedule clients Correct drift Stabilize training Arbitrary comm. Availability Sync action

data. Prior work has addressed this challenge through several control points. Server-side asynchronous methods such as FedAsync [4] and FedBuff [5] control when received updates are applied or buffered. Client-selection methods such as Oort [6] and RL-based schedulers such as FedMarl [8] decide which clients should participate. Optimization methods such as SCAFFOLD [9] and FedProx [10] reduce the effect of statistical heterogeneity during local training. Other work relaxes rigid round-based execution through arbitrary communication patterns and flexible device participation [11], [12]. These methods improve federated learning under communication and heterogeneity constraints, but they primarily control aggregation, participation, protocol flexibility, or local optimization. In contrast, our work controls the synchronization action taken by an available client by deciding whether to skip communication, upload a local update, download the global model, or synchronize bidirectionally. Table I summarizes this distinction. Our scheduler is clientside, but the main distinction is the synchronization action space: the policy separates upload, download, bidirectional synchronization, and skipping. This lets each client react to local learning progress, model staleness, communication quality, energy cost, and privacy budget without changing the server aggregation rule. Federated learning is attractive for edge systems because it allows many distributed clients to learn collaboratively without moving raw data to a central server. However, keeping data local does not eliminate the cost of synchronization. Model updates still consume bandwidth and energy, and may require additional privacy protection. Prior FL systems [2], [13] study secure aggregation and differentially private updates, while resource-aware methods such as FedCS [14] account for client compute and wireless conditions. Our work uses these constraints at a different control point: we expose communication cost, energy cost, staleness, and privacy budget as local decision signals for client-side synchronization. These issues are especially relevant in traffic forecasting, where sensors generate continuous, spatially coupled streams under heterogeneous local conditions. Prior federated traffic systems include FCGCN [15], FedAGCN [16], and FedTFP [17]. These works focus primarily on federated forecasting quality, whereas our focus is the client-side synchro-

nization decision under changing bandwidth, energy, staleness, and privacy costs. III. S YSTEM OVERVIEW AND D ESIGN We consider an edge federated learning system with a central server and heterogeneous clients. Each client stores private data, trains a local task model, and runs a lightweight synchronization scheduler. The server maintains the global model and aggregates received updates, while the scheduler decides when communication is worth its latency, energy, and privacy cost. Our design separates task learning from synchronization control. The task model performs prediction or classification, while the scheduler controls only communication with the server. This separation lets the same scheduling mechanism support different task backbones. We use STAEFormer [18] for traffic forecasting and ResNet-18 [19] for image classification, but the scheduler itself is model-agnostic. Figure 2 shows the architecture. At each decision event, the scheduler observes local learning and system state and chooses whether to upload, download, synchronize bidirectionally, or defer communication. For our method, the server update rule is fixed so that improvements come from client-side synchronization rather than changing the aggregation rule. A. Event-Driven Workflow The system is simulated as an event-driven process. Each client evolves through five runtime states: unavailable, available-idle, local-training, uploading, and downloading. A priority queue of timestamped events advances the simulation in event time, including availability changes, local-training completion, scheduler decisions, communication completion, and server updates. Local training is scheduled automatically when a client is available, idle, and has no pending communication. Scheduler decisions are generated only for available idle clients, which prevents the policy from interrupting training or in-flight communication. Thus, the scheduler controls synchronization rather than local training. At a decision event, client m maintains a local model Wm trained on private data Dm . Upload transmits a protected model update, download refreshes the local model from the server, and the bidirectional action uploads, waits for the corresponding server update, and then downloads the updated global model. B. Server Aggregation For our client-side scheduler, we keep the server update rule fixed so that performance differences come from the synchronization policy rather than an aggregation algorithm. The server maintains a global model W (k) , where k indexes server update events. Because clients operate asynchronously, an update may be based on an older server version. Let bm,k be the server version last downloaded by client m before producing the update available at event k. We define loc um,k = Wm,k − W (bm,k ) ,

sm,k = k − bm,k ,

loc where Wm,k is the client model after local training and sm,k is the update staleness. Let ûm,k be the protected update after optional clipping and (k) Gaussian perturbation. At server event k, let Mup denote the set of client uploads applied at that event. The server step size is ηs , and α(sm,k ) denotes an optional staleness weight. The server applies X W (k+1) = W (k) + ηs ωm,k α(sm,k )ûm,k , (1) (k)

m∈Mup

where the data-size weight is ωm,k = P

|Dm | (k)

j∈Mup

|Dj |

.

If privacy is disabled, ûm,k = um,k . The server update rule is fixed within each configuration; the image experiments use ηs = 0.2. Thus, uploaded updates are applied directly, and staleness is handled by the client-side scheduler through its observation and reward rather than by a server-side staleness correction rule. C. Cost, Dynamics, and Privacy The scheduler evaluates communication against the conditions that a client experiences at the decision time. Following standard wireless cost models [20], [21], an update of ∆m bits up incurs sent at rate Rm ∆m up up up Em = Pm Tm , (2) Tm = up , Rm with analogous download costs. Effective rates vary with good, medium, and degraded channel regimes. Client computation is charged separately from communication. For a CPU client that processes nm (t) samples at frequency fm , with q cycles per sample and hardware coefficient κ, we use qnm (t) loc loc 2 Tm (t) = , Em (t) = κfm qnm (t). (3) fm For a GPU profile, a Roofline-style bound [22] accounts for both arithmetic throughput θm and memory bandwidth βm :   Fm Mm loc loc avg loc Tm,gpu = max , , Em,gpu = Pm Tm,gpu . θ m βm (4) This separation prevents communication savings from being conflated with faster client hardware. The event engine also models stable, cyclic, and bursty availability. Availability profiles and channel regimes jointly determine whether an action is feasible and how long it takes; future states are not revealed to the policy. Figure 3 summarizes the per-round sequence. The image experiments clip each upload to C. The server averages Bagg buffered uploads and adds Gaussian noise before release: uj , u ej = max(1, ∥uj ∥2 /C)   1 X σ2 C 2 u bk = u ej + N 0, 2 I . (5) Bagg Bagg j∈Bk

Server

Client M

Client 1

Environment state

edge devices

Global model W(k) current version

online

Action space at

channel compute energy

+ upload

Local model W1 Local data D1

upload û1

+ download

Sync. policy πθ (RL)

Skip

download Download

Local learning state

Async. aggregation fixed rule, Eq. (1)

Upload

Bidirectional

Global model W(k+1) loss

staleness

for download

ε budget

Fig. 2. System overview of the proposed client-side synchronization scheduler. Each client trains a local task model on private data and uses an RL policy to decide whether to skip, upload, download, or synchronize bidirectionally based on local learning state and environment conditions. The server maintains the global model and aggregates received client updates.

Round t

Decision

Local Training ,

Upload

Download

Server Processing

(if selected)

(if selected)

(if any)

,

,

,

++

Compute Costs

Round t+1

++

Communication Costs

TABLE II C LIENT OBSERVATION SUPPLIED TO THE SHARED POLICY. Group

Features

Comm. Learning Sync. Privacy

Availability, channel regime, transfer time and energy Loss, loss change, dirty flag, latest compute cost Upload/download age, local/server versions, staleness Spent/remaining budget and most recent increment

Fig. 3. Cost accounting at one client’s decision.

Here Bk indexes buffered uploads, including repeated client contributions. Gaussian RDP accounting [23] uses δ = 10−5 , composes noisy releases across episodes without subsampling amplification, and broadcasts spent/remaining budget to clients. Uploads exceeding εmax = 12 are masked. Reported ε values characterize this release accountant. IV. C LIENT-S IDE S YNCHRONIZATION P OLICY (m)

At decision event t, client m selects at ∈ {S, U, D, B}, denoting skip, upload, download, and bidirectional synchronization. All clients share one small policy, but evaluate it on their own observations. The observation contains four groups: (i) current availability, channel regime, and estimated transfer cost; (ii) local loss, loss change, and compute cost; (iii) dirty state, upload/download age, and server–client version gap; and (iv) spent and remaining privacy budget. The accuracyoriented policy may additionally use compact server broadcasts for freshness, buffer state, client rank, and recent synchronization rates, but action selection remains on the client. At each decision event, the scheduler receives a client-level observation composed of environment state and local client state, as shown in Figure 4. Table II lists the observation groups. The communication group represents environment state, capturing availability and channel-dependent communication cost. The learning, synchronization, and privacy groups represent local client state, capturing model progress, synchronization history, and privacy budget. Legal-action masking encodes the runtime constraints. Skip is always legal; upload requires uncommitted local progress, a

Async. Server Update

Client-Side RL Scheduler

Environment State

RL Policy (PPO)

Action mask

Selected Action

Local Learning State

Fig. 4. Observation and action-selection pipeline for the client-side RL scheduler.

satisfied minimum communication gap, and sufficient privacy budget; download requires a newer server version; and bidirectional synchronization requires a legal upload. The mask is applied both when sampling actions and when recomputing the learning loss. Consequently, the policy never learns from actions that the event engine could not execute. A. Staleness and Uncommitted Progress A useful communication decision must distinguish an old model from a model that contains new local information. Let τm (t) be the number of client decision events since the most recent upload, and let vtsrv and vtloc,m be the current server version and the newest server version incorporated by client m. Upload age and the server–client version gap are ( (m) 0, Iup,t = 1, τm (t + 1) = (m) τm (t) + 1, Iup,t = 0, (m)

νt

= max(vtsrv − vtloc,m , 0).

(6)

The first term measures how long the server has waited for this client; the second measures how far the client’s reference model trails the server. Staleness alone cannot reveal whether waiting withholds useful work. If tlast m is the last upload event, relative uncommitted progress is (tlast ) (t) ∥Wm − Wm m ∥2 (m) pt = , (tlast ) ∥Wm m ∥2 + η

η > 0.

(7)

We therefore use (m)

,

(m) (m) (m) cdirty,t = (1 − Iup,t )pt (1 + τm (t)).

Louvain

(m)

+ λE (E loc + Iup E up + Idn E dn ) (9)

Lclip (θ) = Et [min(ρt At , clip(ρt , 1 − ϵ, 1 + ϵ)At )] , πθ (at | ot ) . (10) ρt = πold (at | ot ) Generalized advantage estimation [25] assigns credit across later communication and learning events. The deployed actor has 20.4k parameters (0.081 MB in FP32), so its size is independent of the number of clients. For a finite rollout, the critic supplies the bootstrap needed to evaluate actions whose learning benefit arrives after the current communication event. With temporal-difference residual δt = rt +γVϕ (ot+1 )−Vϕ (ot ), truncated generalized advantage estimation computes At =

(γλGAE )j δt+j .

j=0

120 60 0

46

71

(11)

46 35

18

K1

K2

45

57

16

K3

21

46

32

K4

45 8

33

K5

Fig. 5. Client-size balance for five-way PeMSD7(M) partitioning (228 sensors) [30].

The value target is the observed discounted reward plus the final bootstrap, Gt =

where fixed reference scales normalize the terms. The dirtystate penalty grows when useful local progress is repeatedly withheld; the channel penalty discourages uploads below a (m) (m) target rate. The reward is rt = −Ct , making the control objective consistent with end-to-end resource cost rather than communication count alone. We optimize the shared actor and value function with masked Proximal Policy Optimization (PPO) [24]. For advantage estimate At , the actor maximizes

LX t −1

K-Means

165

= λℓ cℓ + λT (T loc + Iup T up + Idn T dn ) + λs cstale + λd cdirty + λp Iup εt + λc cchan ,

METIS

Node distribution (k=5)

(8)

Skipping remains inexpensive when little has changed, but becomes costly when fresh local progress is repeatedly withup held. An optional channel term cchan = Iup [Rmin /Rup − 1]+ discourages an avoidable upload over a degraded link. In private runs, an upload also incurs the accountant’s increment P (m) (m) (m) εt , subject to t Iup,t εt ≤ εmax m . These structured terms explain why the policy cannot optimize the task loss or byte count in isolation. The reward unifies task and systems objectives. With upload/download indicators Iup and Idn , we define Ct

1: Initialize server W , clients, event queue, actor πθ , critic Vϕ 2: for each PPO iteration do 3: rollout Γ ← ∅ 4: while |Γ| < Ts do 5: (m, o, M ) ← N EXT R EADY C LIENT() 6: sample a ∼ πθ (· | o, M ) 7: (o′ , C) ← A DVANCE E VENTS(m, a) 8: append (o, a, −C, o′ , M ) to Γ 9: end while 10: compute bootstrapped returns and GAE advantages 11: update θ with Eq. (10); fit Vϕ 12: end for

nodes

(m)

cstale,t = ατ τm (t) + αν νt

Algorithm 1 Event-driven client-side PPO

LX t −1

γ j rt+j + γ Lt Vϕ (ot+Lt ),

(12)

j=0

and the critic minimizes Et [(Vϕ (ot )−Gt )2 ]. Keeping actor and critic targets tied to event order is important: a costly upload can become valuable only after its server update affects later clients. Algorithm 1 shows how event simulation and policy learning interleave. A rollout contains decisions from whichever client becomes ready next, rather than a synchronous vector of one action per round. The value function is trained against bootstrapped returns, while the actor reuses the stored legalaction mask during every PPO epoch. This preserves the behavior policy’s support and prevents invalid actions from re-entering through loss recomputation. V. E VALUATION Workloads. The traffic workflow uses PeMS-08 measurements sampled every five minutes [26]. For client formation, we partition the traffic sensor graph using METIS [27] as it represents the spatial elements of our data. We compare METIS with two common alternatives, K-Means [28] and Louvain [29] community detection. In our setup, METIS produces more balanced clusters while preserving the graph structure of the road network. This is useful for federated traffic forecasting because extreme client-size imbalance can affect aggregation behavior, and communication load. Figure 5 shows the resulting partition-size comparison. We train federated STAEFormer (FedSTAE) on four clients, and evaluate 200 episodes. The image workflow uses a CIFAR-

PeMS08 30

Value

PPO objective PPO optimizer

γ = 0.99, GAE λ = 0.95, clip 0.2 LR 3×10−4 , 6 epochs, batch 64, entropy 0.006, value coefficient 0.5 B = 105 Hz; multipliers 1.5/1.0/0.45 with probabilities 0.35/0.45/0.20 Ptx = 1.5 W, Prx = 0.8 W; fm ∼ U (0.6, 1.0) GHz DP; C = 1, σ = 6, δ = 10−5 , εmax = 12 λloss = 0.35, λtime = 0.75, λene = 1.0 λstale = 0.08, λdirty = 0.18, λchan = 0.25, λpriv = 0.02 SGD, LR 0.02, momentum 0.9, weight decay 5× 10−4 , gradient clip 5.0

Channel Device Privacy Task weights System weights Local optimizer

Test Accuracy (%)

FedAsync FedBuff

Oort DQN

PPO

80 60 40 20 0

50

100

150

Episode

200

250

300

Fig. 6. Image-workload test-accuracy. PPO reaches the highest final accuracy; DQN converges more slowly under the same 256-decision rollout horizon.

10 [31] ResNet-18 with a 3 × 3 input convolution, no initial max-pooling, and a ten-class head. 20 clients receive a Dirichlet non-IID split with α = 0.3, and each run lasts 300 episodes. These workloads exercise the same action interface and policy architecture while changing the task model and utility signal. Comparisons and protocol. We compare with FedAsync, FedBuff, and Oort as representative server-side controls; DQN [32] as a client scheduler with the same observation, action space, and legal-action mask; and Always-sync as a fixed client-side policy. Each baseline uses its validationselected configuration on the same data split. Image results are means across completed runs; evaluation frequency and test-set coverage vary across runs. Traffic results report a validation-selected completed run, with an average over its evaluation horizon. Experiments use an RTX 4090 and 24 CPU threads. Table III reports the default scheduler and environment configuration. We report MAE/RMSE for traffic, accuracy for images, and latency, energy, bytes, and synchronization counts for system cost. VI. R ESULTS A. Task Quality and System Cost Table IV shows the clearest efficiency gain. PPO has the lowest MAE and RMSE while using 2,404 uploads. Relative to the least expensive non-PPO entry for each metric, it reduces latency by 43%, energy by 52%, and uploaded traffic by 63%.

Short horizon (t = 1) 22.41

MAE

Setting

15

23.46

100

20.77

15.37 6.21

0 FCGCN

METR-LA

MAE

TABLE III S CHEDULER AND ENVIRONMENT CONFIGURATION .

5.94

FedProx FedSTAE

Long horizon (t = 12) 82.94

60 30

32.64 15.16

0 FCGCN

29.42 14.83

10.04

FedGRU FedSTAE

Fig. 7. FedSTAE forecasting quality against representative federated baselines. Short and long horizons correspond to 5 and 60 minutes.

Its RMSE is 2.8% below DQN, the strongest baseline on that metric. DQN has better MAPE, illustrating that no policy dominates every prediction measure. The principal result is therefore a joint quality–cost improvement, not simply higher communication frequency. Table V tests the same control interface on image classification workload. PPO reaches 84.48% accuracy, a 4.17% relative improvement over Oort’s 81.10%, while latency and energy remain within 1.8% and 0.8% of Oort, respectively. FedBuff is the lowest-cost server baseline; PPO’s accuracy is 4.54% higher relative to FedBuff’s 80.81%. Always-sync incurs the most latency and energy and achieves 70.66% accuracy, 16.36% lower relative to PPO. DQN uploads slightly fewer bytes but achieves 62.09% accuracy, 26.50% lower relative to PPO. Figure 6 illustrates representative learning trajectories; its endpoints differ from the means in Table V. B. Forecasting Backbone Validation The synchronization result is meaningful only if its task model is a credible federated forecasting backbone. We therefore compare FedSTAE with FCGCN, FedProx, and FedGRU [33]. Figure 7 reports one-step (5-minute) and 12-step (60-minute) MAE on PeMS-08 and METR-LA [34], using a 60-minute input window. FedSTAE has the lowest MAE among the shown methods on both datasets and horizons. The gain is especially large at 12 steps on PeMS-08: 29.42 MAE versus 32.64 for FCGCN and 82.94 for FedGRU [17], [35]. This check rules out the interpretation that communication savings are measured around an intentionally weak traffic model. Table VI isolates model quality as the PeMS-08 partition count grows. FedSTAE remains substantially better than FedGRU from 2 to 16 clients. Its long-horizon RMSE varies only from 29.21 to 30.60, although MAE and MAPE gradually worsen as each client receives a smaller, more heterogeneous portion of the sensor graph. This task-level scaling result complements Table VIII(a), which measures scheduler latency rather than forecast error. C. Policy Ablations Table VII compares policy configurations. Accuracy is 11.72–14.65% lower relative to Full (85.31%). The stateremoval variants also disable bidirectional synchronization.

TABLE IV T RAFFIC FORECASTING ON P E MS-08 WITH FOUR CLIENTS OVER 200 EPISODES . T HE VALIDATION - SELECTED RUN IS AVERAGED OVER THE EVALUATION HORIZON ; LOWER IS BETTER FOR ERRORS AND COSTS . Method

MAE

RMSE

MAPE

Latency (s)

Energy (J)

Uploaded (GB)

Uploads

Downloads

Agg.

DQN FedAsync FedBuff Oort PPO

20.44 20.51 22.12 23.00 19.64

30.78 31.34 32.67 34.40 29.92

14.85 15.33 18.40 22.88 16.50

1.4×105 1.4×105 1.2×105 1.4×105 6.8×104

1.8×105 1.9×105 1.7×105 1.9×105 8.1×104

28.37 30.56 31.89 29.47 10.59

6,439 6,936 7,237 6,689 2,404

3,552 3,657 749 3,873 2,506

6,226 6,712 701 6,456 2,327

TABLE V I MAGE CLASSIFICATION : 20 CLIENTS , 300 EPISODES ; MEANS ACROSS RUNS . L OWER IS BETTER EXCEPT ACCURACY. Method

Accuracy

Latency/episode

Energy/episode

Uploaded/episode

Uploads

Downloads

FedAsync FedBuff Oort DQN Always-sync PPO

81.00% 80.81% 81.10% 62.09% 70.66% 84.48%

401.0 s 394.3 s 399.2 s 436.3 s 731.1 s 406.3 s

594.4 J 587.0 J 590.9 J 599.2 J 857.6 J 595.7 J

0.111 GB 0.111 GB 0.111 GB 0.103 GB 0.111 GB 0.111 GB

39,602 39,666 39,572 36,504 39,610 39,464

1,227 768 1,334 9,835 39,319 2,273

TABLE VI L ONG - HORIZON P E MS-08 FORECASTING AS CLIENT COUNT INCREASES . FedSTAE

Clients

MAE

RMSE

MAPE

MAE

RMSE

MAPE

2 4 6 8 16

58.58 66.39 61.39 60.01 56.86

78.26 86.94 82.94 79.96 75.31

61.54 82.34 75.23 83.41 76.01

18.78 19.10 19.12 19.93 20.30

29.21 29.71 29.42 30.60 30.50

16.06 15.79 16.49 17.28 18.42

TABLE VII S INGLE - RUN IMAGE - POLICY ABLATIONS AFTER 300 EPISODES . Variant

Acc. Latency Energy Uploaded

Full 85.31% w/o bidirectional 75.31% w/o bidirectional + learning state 73.75% w/o bidirectional + privacy state 74.06% w/o bidirectional + sync state 72.81%

400.1 s 356.0 s 351.8 s 356.8 s 355.3 s

588.9 J 528.7 J 521.6 J 529.7 J 527.0 J

0.111 GB 0.100 GB 0.099 GB 0.100 GB 0.100 GB

Relative to that reference (75.31%), removing learning, privacy, or synchronization state reduces accuracy by 2.07%, 1.66%, and 3.32%, respectively. Full also uses different reward and optimizer settings, so these comparisons do not isolate the effect of a single component. D. Privacy, Scale, and Overhead Figure 8 separates five policies with the same action interface. Unguided PPO uses only client observations; AccuracyGuided and Server-Guided PPO add client priors and compact server broadcasts. Cost-Gated and Privacy-Gated PPO increase communication and privacy pressure. We use Server-Guided PPO for the accuracy-oriented image comparison and CostGated PPO for the privacy and scale studies. Because a scalar reward selects only one multi-objective operating point, every reported configuration is chosen on held-out validation data rather than treated as universally best.

85

Test accuracy (%)

FedGRU

Cost-Gated PPO Privacy-Gated PPO

80

Unguided PPO Accuracy-Guided PPO

Server-Guided PPO

Higher accuracy

Lower latency

75

70 390

395

400

405

Latency per episode (s) Fig. 8. PPO variant trade-off across 300-episode runs. Accuracy is reevaluated on the full test set using each run’s validation-selected checkpoint; latency covers the full run. All five variants spend the same privacy budget (ε = 8.06), so privacy is not encoded. Shading indicates lower latency and higher accuracy as visual guides.

The gated configurations reduce latency by approximately 1.6–1.7% relative to Unguided PPO, at lower accuracy. ServerGuided PPO achieves the highest validation-selected test accuracy (84.29%), compared with Unguided PPO’s 74.47%. These results compare complete policy configurations rather than isolating the effect of guidance alone. Privacy expenditure is identical across the five PPO variants (ε = 8.06), and DQN spends ε = 7.73. The client-count sweep in Table VIII(a) increases the federation from 4 to 32 clients. Cost-Gated PPO remains the lowestlatency method at every point; its latency changes by only 0.8% from 4 to 32 clients, whereas the compared baselines are both higher and more variable. This supports the intended parameter sharing: additional clients do not enlarge the policy. Finally, Table VIII(b) shows that one policy decision takes

TABLE VIII S CALE AND SCHEDULER OVERHEAD . S CALABILITY REPORTS LATENCY / EPISODE ( S ). F ULL - MODEL SIZES IN ( B ) DIFFER FROM TRANSMITTED PAYLOADS . (a) Clients and latency Method FedAsync FedBuff Oort Cost-Gated PPO

(b) Deployment overhead

4

8

16

32

Component

Params

MB

Runtime

375.6 376.1 377.8 362.9

384.6 377.4 384.9 365.3

378.8 381.3 379.5 363.2

390.3 379.9 396.7 365.7

PPO STAEFormer ResNet-18

20.4k 1.22M 11.17M

0.081 9.79 44.70

0.194 ms 18.85 ms 33.67 ms

0.194 ms and 0.081 MB, much smaller than either task model. Scheduler inference is therefore negligible relative to local prediction and network transfer in this environment. VII. D ISCUSSION The experiments distinguish client-side synchronization from server-side aggregation. We leave Eq. (1) unchanged and obtain the reported trade-offs solely by changing whether a client uploads, downloads, does both, or waits. The matched gated and unguided runs show a modest latency–accuracy trade-off, with no reduction in aggregate-release privacy expenditure. Small server broadcasts provide context without moving the action back to the server. A. Why Separate Upload and Download? The action counts help explain the benefit of separating communication directions. In traffic forecasting, PPO uses 2,404 uploads and 2,506 downloads; it neither collapses to Always-sync nor treats every server refresh as requiring a local contribution. FedBuff performs only 749 downloads and 701 aggregations, but has 9.2% higher RMSE and nearly three times as many uploads as PPO. This comparison separates two forms of sparsity: reducing server aggregation alone does not ensure that clients send only useful updates, and reducing downloads too aggressively can leave local models behind the global state. The four-way action space lets the policy manage these effects independently. The image results expose a different operating regime. PPO’s upload count is close to the server-side baselines, but it uses far fewer downloads than Always-sync and reaches higher accuracy. Here, the value lies less in suppressing all communication than in choosing the direction and timing of synchronization. This difference across tasks is exactly why a fixed period is brittle: the traffic workload rewards a strongly cost-gated pattern, whereas the non-IID image workload benefits from a more accuracy-oriented schedule. B. Control Placement and Deployment The scheduler is client-executed but not client-isolated. A server may broadcast small coordination features with its model version, after which the client combines that context with signals unavailable at the server, such as current loss change, dirty progress, channel cost, and remaining privacy budget. The server does not issue the action. This division preserves local responsiveness while avoiding the assumption that a client can infer federation-wide freshness from local history alone.

A deployment would first select normalized cost weights from service-level goals, for example an energy ceiling or a target privacy budget, and train the shared policy against representative availability and channel traces. At runtime, each client constructs the observation only when idle, applies the hard feasibility mask, and executes one policy forward pass. The server needs no policy-specific aggregation rule. If resource distributions drift outside the training range, the safe fallback is to retain masking and use a conservative schedule while the policy is revalidated; the current experiments do not claim zero-shot robustness to arbitrary drift. C. Scope of Generalization The traffic and image experiments reuse the synchronization abstraction, observation groups, legal-action logic, and policy architecture. They do not reuse one set of learned weights across tasks. Each policy is trained for its workload because the meaning and scale of task utility differ between forecasting error and classification loss. The evidence therefore supports mechanism-level portability, not cross-workload policy transfer. This is still operationally useful: adding a task model does not require designing a new synchronization protocol, but it does require training and validating the controller for that task’s dynamics. VIII. L IMITATIONS Our evaluation is an emulated edge-federated setting rather than a live deployment. First, communication, availability, and energy are evaluated in an event-driven environment with calibrated analytical costs, not a geographically distributed device deployment. Second, privacy claims are conditional on the fixed clipping, aggregate-noise mechanism, accounting scope, and budget above; PPO schedules contributions but does not strengthen the underlying privacy guarantee. Third, the scale study stops at 32 clients. Trace-driven tests on physical edge devices, more seeds, and larger federations are necessary before making production-level latency, energy, or robustness claims. IX. C ONCLUSION Client-side synchronization turns communication from a fixed protocol choice into a resource-aware decision. Across traffic forecasting and image classification, the shared maskedPPO scheduler improves the measured quality–cost trade-off while retaining a fixed aggregation rule. It also incorporates explicit privacy-budget constraints and adds little local runtime or memory overhead.

R EFERENCES [1] B. McMahan, E. Moore, D. Ramage, S. Hampson, and B. A. y Arcas, “Communication-efficient learning of deep networks from decentralized data,” in Artificial Intelligence and Statistics. PMLR, 2017, pp. 1273– 1282. [2] K. Bonawitz, H. Eichner, W. Grieskamp, D. Huba, A. Ingerman, V. Ivanov, C. Kiddon, J. Konečnỳ, S. Mazzocchi, B. McMahan et al., “Towards federated learning at scale: System design,” in Proceedings of Machine learning and Systems, vol. 1, 2019, pp. 374–388. [3] Y.-A. De Montjoye, C. A. Hidalgo, M. Verleysen, and V. D. Blondel, “Unique in the crowd: The privacy bounds of human mobility,” Scientific Reports, vol. 3, no. 1, pp. 1–5, 2013. [4] C. Xie, S. Koyejo, and I. Gupta, “Asynchronous federated optimization,” arXiv preprint arXiv:1903.03934, 2019. [5] J. Nguyen, K. Malik, H. Zhan, A. Yousefpour, M. Rabbat, M. Malek, and D. Huba, “Federated learning with buffered asynchronous aggregation,” in International conference on artificial intelligence and statistics. PMLR, 2022, pp. 3581–3607. [6] F. Lai, X. Zhu, H. V. Madhyastha, and M. Chowdhury, “Oort: Efficient federated learning via guided participant selection,” in 15th {USENIX} Symposium on Operating Systems Design and Implementation ({OSDI} 21), 2021, pp. 19–35. [7] T. Yu, X. Wang, J. Hu, and J. Yang, “Multi-agent proximal policy optimization-based dynamic client selection for federated ai in 6goriented internet of vehicles,” IEEE Transactions on Vehicular Technology, 2024. [8] S. Q. Zhang, J. Lin, and Q. Zhang, “A multi-agent reinforcement learning approach for efficient client selection in federated learning,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 36, no. 8, 2022, pp. 9091–9099. [9] S. P. Karimireddy, S. Kale, M. Mohri, S. Reddi, S. Stich, and A. T. Suresh, “Scaffold: Stochastic controlled averaging for federated learning,” in International conference on machine learning. PMLR, 2020, pp. 5132–5143. [10] T. Li, A. K. Sahu, M. Zaheer, M. Sanjabi, A. Talwalkar, and V. Smith, “Federated optimization in heterogeneous networks,” in Proceedings of Machine Learning and Systems, vol. 2, 2020, pp. 429–450. [11] D. Avdiukhin and S. Kasiviswanathan, “Federated learning under arbitrary communication patterns,” in International Conference on Machine Learning. PMLR, 2021, pp. 425–435. [12] Y. Ruan, X. Zhang, S.-C. Liang, and C. Joe-Wong, “Towards flexible device participation in federated learning,” in International conference on artificial intelligence and statistics. PMLR, 2021, pp. 3403–3411. [13] R. C. Geyer, T. Klein, and M. Nabi, “Differentially private federated learning: A client level perspective,” arXiv preprint arXiv:1712.07557, 2017. [14] T. Nishio and R. Yonetani, “Client selection for federated learning with heterogeneous resources in mobile edge,” in ICC 2019-2019 IEEE international conference on communications (ICC). IEEE, 2019, pp. 1–7. [15] M. Xia, D. Jin, and J. Chen, “Short-term traffic flow prediction based on graph convolutional networks and federated learning,” IEEE Transactions on Intelligent Transportation Systems, vol. 24, no. 1, pp. 1191– 1203, 2022. [16] T. Qi, L. Chen, G. Li, Y. Li, and C. Wang, “FedAGCN: A traffic flow prediction framework based on federated learning and asynchronous graph convolutional network,” Applied Soft Computing, vol. 138, p. 110175, 2023. [17] J. Feng, C. Du, and Q. Mu, “Traffic flow prediction based on federated learning and spatio-temporal graph neural networks,” ISPRS International Journal of Geo-Information, vol. 13, no. 6, p. 210, 2024. [18] H. Liu, Z. Dong, R. Jiang, J. Deng, J. Deng, Q. Chen, and X. Song, “Spatio-temporal adaptive embedding makes vanilla transformer SOTA for traffic forecasting,” in Proceedings of the 32nd ACM International Conference on Information and Knowledge Management, 2023, pp. 4125–4129. [19] K. He, X. Zhang, S. Ren, and J. Sun, “Deep residual learning for image recognition,” in Proceedings of the IEEE conference on computer vision and pattern recognition, 2016, pp. 770–778. [20] H. Wang, X. Li, H. Ji, and H. Zhang, “Federated offloading scheme to minimize latency in mec-enabled vehicular networks,” in 2018 IEEE Globecom Workshops (GC Wkshps). IEEE, 2018, pp. 1–6.

[21] Y. Wu, J. Wu, L. Chen, J. Yan, and Y. Han, “Load balance guaranteed vehicle-to-vehicle computation offloading for min-max fairness in vanets,” IEEE Transactions on Intelligent Transportation Systems, vol. 23, no. 8, pp. 11 994–12 013, 2021. [22] S. Williams, A. Waterman, and D. Patterson, “Roofline: an insightful visual performance model for multicore architectures,” Communications of the ACM, vol. 52, no. 4, pp. 65–76, 2009. [23] I. Mironov, “Rényi differential privacy,” in 2017 IEEE 30th computer security foundations symposium (CSF). IEEE, 2017, pp. 263–275. [24] J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov, “Proximal policy optimization algorithms,” arXiv preprint arXiv:1707.06347, 2017. [25] J. Schulman, P. Moritz, S. Levine, M. Jordan, and P. Abbeel, “Highdimensional continuous control using generalized advantage estimation,” arXiv preprint arXiv:1506.02438, 2015. [26] C. Song, Y. Lin, S. Guo, and H. Wan, “Spatial-temporal synchronous graph convolutional networks: A new framework for spatial-temporal network data forecasting,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 34, no. 01, 2020, pp. 914–921. [27] G. Karypis and V. Kumar, “METIS: A software package for partitioning unstructured graphs, partitioning meshes, and computing fill-reducing orderings of sparse matrices,” https://github.com/KarypisLab/METIS, 1997. [28] J. A. Hartigan and M. A. Wong, “Algorithm as 136: A k-means clustering algorithm,” Applied Statistics, vol. 28, no. 1, pp. 100–108, 1979. [29] V. D. Blondel, J.-L. Guillaume, R. Lambiotte, and E. Lefebvre, “Fast unfolding of communities in large networks,” Journal of Statistical Mechanics: Theory and Experiment, vol. 2008, no. 10, p. P10008, 2008. [30] B. Yu, H. Yin, and Z. Zhu, “Spatio-temporal graph convolutional networks: A deep learning framework for traffic forecasting,” in Proceedings of the Twenty-Seventh International Joint Conference on Artificial Intelligence, 2018, pp. 3634–3640. [31] A. Krizhevsky, G. Hinton et al., “Learning multiple layers of features from tiny images,” 2009. [32] V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski, S. Petersen, C. Beattie, A. Sadik, I. Antonoglou, H. King, D. Kumaran, D. Wierstra, S. Legg, and D. Hassabis, “Human-level control through deep reinforcement learning,” Nature, vol. 518, no. 7540, pp. 529–533, 2015. [33] Y. Liu, J. Q. James, J. Kang, D. Niyato, and S. Zhang, “Privacypreserving traffic flow prediction: A federated learning approach,” IEEE Internet of Things Journal, vol. 7, no. 8, pp. 7751–7763, 2020. [34] Y. Li, R. Yu, C. Shahabi, and Y. Liu, “Diffusion convolutional recurrent neural network: Data-driven traffic forecasting,” in International Conference on Learning Representations, 2018. [35] Q. Liu, S. Sun, Y. Liang, X. Xu, M. Liu, M. Bilal, Y. Wang, X. Li, and Y. Zheng, “Refol: resource-efficient federated online learning for traffic flow forecasting,” IEEE Transactions on Intelligent Transportation Systems, vol. 26, no. 2, pp. 2777–2792, 2024.

Related documents

• Learning to Sync at the Edge: Client-Side Adaptive Synchronization for Federated Learning#1324869
• Reviving Stale Updates: Data-Free Knowledge Distillation for Asynchronous Federated Learning#1325050
• DAQSyn: A decentralized adaptive quantization-aware synchronous framework in heterogeneous on-device AI networks.#1347286
• Federated Learning for IoT: A Survey of Techniques, Challenges, and Applications#341899
• FUSE: Fairness-aware Update Screening against Byzantine Exploitation in $q$-Fair Federated Learning#1355193