acceptodds
Under review as a conference paper at ICLR 2027

Decoupling Federated Learning to address Utility-driven asynchrony

Abstract

Federated learning (FL) enables scalable collaborative training through a server that establishes a fixed communication structure and governs the aggregation of parameters sent by the clients. Efficient FL is marred by exogenous factors such as stragglers, network delays, and staleness, and endogenous factors such as local distribution shifts. These factors introduce arbitrary client availability and changes in the aggregation mechanism – unobservable to the server. In fact, the effect of such phenomenon is only observed in the clients' utility. Clients must be allowed to drive learning according to their local utility. This does not happen at present because client and the server depend on each other for updates leading to a coupling completely driven by the server. In this paper, we enable utility-driven FL, where the clients can communicate based on “how their local utility changes with time?” instead of a pre-determined communication structure. We leverage dynamic-programming to develop a novel framework that decouples client-server communication dependency and design \uafl where client can drive learning based on their own utility. Empirically and theoretically, we show that convergence can be achieved in spite of no predetermined communication structure and in the presence of staleness, client churn, gradient magnitude variance, and angular misalignment. In particular, without prior knowledge of the endogenous/exogenous factors present in the dataset, \uafl outperforms standard methods, carefully designed for specific (endogenous/exogenous) factors on standard benchmarks and realistic datasets by upto .

Primary area:
optimization
Keywords:
federated learning, distribution shift, asynchronous FL

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_37FROpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies asynchronous federated learning in the presence of both exogenous factors (stragglers, network delays, staleness) and endogenous factors (local distribution shifts). The authors argue that existing FL methods rely on a server-determined communication structure. They propose to “decouple” client and server updates: clients and the server run on independent clocks and interact only through two buffers, a client pool read by the server and a server pool read by the clients. Each side is formulated as a dynamic programming problem, and a discrete-time HJB equation is derived for each.

Critical strengths
  1. The problem is relevant and under-explored. Linking client participation to the evolution of local utility, and treating exogenous and endogenous asynchrony within a single framework, is a meaningful perspective for practical FL deployments (e.g., the hospital and energy-grid examples in the introduction).

  2. The algorithm is simple and easy to implement on top of existing buffered asynchronous FL, with moderate memory overhead.

  3. Motivating the asynchronous update rules from a dynamic programming / HJB perspective is an interesting attempt at a unified view. The decomposition of the communication error into interpretable components (staleness, churn, magnitude variance, angular misalignment) is intuitive.

Critical weaknesses
  1. The central claim of utility-driven communication is not reflected in the algorithm. The paper claims that clients can decide when to communicate based on how their local utility changes, but, as far as I can tell, Algorithms 1–2 contain no step that measures utility or uses the utility-deterioration condition of Section 3; the only client-side condition is the size of the server pool. In the experiments, participation follows an external schedule shared by all baselines (in the endogenous setting, clients with larger shifts even participate less often), so any utility-driven pattern is a property of the environment rather than a contribution of UAsyncFL.

  2. The novelty of the proposed approach compared to existing asynchronous FL methods, as well as the source of performance improvement, remains unclear. Running clients and servers on independent clocks and introducing server-side buffering are already standard features in asynchronous approaches such as FedAsync and FedBuff, while a server pool of size one essentially reduces to the client pulling the latest global model. In UAsyncFL, decisions regarding when to aggregate (threshold C), how to weight (uniformly), and how far to go (α) are still controlled by the server, making it unclear in what sense control has been transferred to the client.

Questions for authors

See weakness.

1 comment

Thank you for identifying the gap between the participation rule motivated in Section 3 and the procedure in Algorithms 1–2.

W1: Who decides when to communicate? Your observation that the participation pattern is a property of the environment is accurate and therefore, we do not want to measure the utility or assume any control of the communication pattern in our theory. The clients can communicate arbitrarily, the server only observes the client pool. Similarly, the client only observes the server pool and server can communicate arbitrarily. Depending on when client sends parameters, statistics calculated from the client pool change. In summary, server does not dictate when the client can communicate and the client do not dictate when server can communicate.

In the experiments, we prescribe arrival opportunities so that all methods face the same schedule for testing purposes. The rotation experiment makes clients with larger shifts participate less often, a difficult case for a server learning from their updates. We will clarify in the abstract and §3 that we evaluate learning under these arrivals. A client policy that measures utility and triggers reconnection remains untested.

W2: What is new relative to FedAsync and FedBuff? Note that independent clocks and buffering are established features of asynchronous FL. With a server pool of size one, a client pulls the latest global model. Eq. (2) identifies the difficulty, even with independent clocks, each side’s objective depends on the other side’s evolving parameters. This leads to a coupling that forces heterogeneity to be known beforehand such as in fedAsync to ensure that in the presence of staleness, FedAsync can compensate for it.

UAsyncFL claims something different, in our approach, all knowledge about heterogeneity (any type of heterogeneity that results in a bounded communication error) is obtained by looking at how local information (jvp at the client side and change in the server parameters at the server side) changes over communication rounds and how can we regularize for this change. The ability to mathematically perform such updates through the HJB-driven formalism is the core contributions of this work and UAsyncFL is effective in improving results over both FedBuff and FedAsync.

Table 4 compares the corrections under the same endogenous non-IID CIFAR-10 schedule. Notably, accuracy reaches 73.14% with both corrections, but removing the client JVP reduces accuracy to 72.01% (−1.13 percentage points), and removing server momentum reduces it to 69.60% (−3.54 points). With both removed, accuracy is 68.45%, compared with 68.70% for FedBuff.

Reviewer_ZKELOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposes UAsyncFL, a federated learning framework for utility-driven asynchrony. The method decouples client and server clocks using client/server pools, allowing clients to communicate according to local utility changes rather than a fixed server schedule. A dynamic-programming/HJB formulation motivates a buffered server update with momentum-like correction and a client-side JVP correction. The paper provides a nonconvex convergence analysis under bounded staleness, churn, gradient variance, and angular misalignment, and reports strong empirical gains over multiple baselines.

Critical strengths
  • Relevant problem. The paper targets an important limitation of FL: client utility and availability can evolve over time, while most protocols remain server-scheduled.
  • Interesting framework. Decoupling client/server clocks through pools is a plausible and practical way to support client-driven asynchronous FL.
  • Strong empirical results. UAsyncFL consistently improves over several relevant baselines, especially on CIFAR-100 and FMoW.
  • Useful ablations. The component and sensitivity studies show that both the server correction and client-side JVP term contribute to performance.
Critical weaknesses
  • Theory is not fully convincing. The HJB-to-algorithm derivation relies on informal approximations, dropped Taylor terms, and heuristic substitutions.
  • Utility-driven mechanism is only partially demonstrated. Synthetic experiments use rotation-based participation intervals rather than clients directly measuring local utility degradation.
  • Baseline fairness is unclear. It is not obvious whether all baselines are equally tuned or matched in total client updates, communication, and wall-clock budget.
  • Claims are overstated. The method is described as handling arbitrary asynchrony, but the theory requires bounded staleness, bounded gradients, and well-posedness conditions.
  • Presentation needs polish. The paper contains many typos, inconsistent notation/naming, and unclear explanations.
Questions for authors
  1. Why do larger rotation angles, interpreted as larger utility shifts, lead to longer rather than shorter participation intervals?
  2. Were baselines tuned with comparable effort to UAsyncFL?
  3. Are all methods matched in total client updates, server aggregations, and communication budget?
  4. How exactly is the JVP correction computed and what tensors are stored in the pools?
  5. Does UAsyncFL use actual measured utility degradation in any experiment, especially on FMoW?
1 comment

We appreciate your questions about how the update follows from the theory and what the experiments establish.

W1: Approximations in the HJB derivation. The HJB derivation uses a first-order Taylor expansion of each value function for small changes in pool state. This derivation is precisely done in propositions 1, 2 and 3. In the implementation on the client side, we use the finite difference approximation to approximate the Jacobian vector product terms. On the server side, the cost function cannot be calculated, therefore, we replace the JVP on the cost with the difference in the server parameters directly as is done in other federated learning methods where the cost is not evaluated at the server.

W2 / Q1 / Q5: Rotation intervals and measured utility. None of our experiments uses measured utility degradation to trigger communication. More explanation on this in the common response. In the rotation experiment, we assign longer intervals to clients with larger shifts to test how the methods perform when the most shifted clients contribute least often, which is an adversarial scenario. FMoW uses the FedDrift temporal partitions. Clients train on the current partition and evaluate on the next one. That accuracy measures adaptation and does not set the participation schedule.

W3 / Q2 / Q3: Baseline tuning and matched budgets. Within each regime, methods share the data split, underlying participation schedule, model family, and training horizon. (cf. Table A1 reports the final settings) Indeed, they are tuned for their own hyperparamter grids. We also report in Tables A2–A4 about UAsyncFL sensitivity on endogenous CIFAR-10 across six thresholds, nine JVP weights, and five momentum settings. The available records do not establish equal tuning effort across methods.

The synthetic runs use 100 scheduling rounds, two local epochs, and batch size 64. FedAvg caps participation at five clients per round. UAsyncFL aggregates once five distinct clients have pending updates. A round count therefore does not specify how many uploads or aggregations occurred. The four-step, five-client FMoW preset implies 20 uploads and four UAsyncFL aggregations over a full run. Figure A1 reports elapsed time for the endogenous non-IID CIFAR runs. We do not have measured per-method communication totals.

W4: Scope of the convergence guarantee. Notably, Theorem 1 bounds the effect of communication error under typical assumptions in FL settings, i.e., A1–A3: smooth losses, bounded stochastic gradients, the sampling and pool conditions in A2, and bounded communication error. The analysis assumes client-side convergence and show that if the communication error has a worst case bound, server side will converge. This convergence result is agnostic to the type of heterogeneity. In Lemma 1, we further use ideas of staleness, churn, gradient magnitude variation, and angular misalignment to show how the communication error bound looks like in the presence of these standard sources of heterogeneity.

Q4: JVP computation and stored tensors. Client ii computes ⟨∇θiLB,Δsi⟩\langle\nabla_{\theta_i}L_B,\Delta s_i\rangle, where Δsi\Delta s_i is the change between the two global models it most recently downloaded. The client adds this scalar, weighted by λ\lambda, to its minibatch loss. Backpropagation gives the correction without forming a Jacobian matrix. On the first download, the client uses the base loss.

The server buffers one pending model state per client up to threshold CC and keeps the published state and a momentum copy. Each client stores up to two downloaded states. Pool entries contain model states only.

W5: Presentation and notation. We will use one method name throughout and define the pool states and client correction at first use.

Thank you for pressing us to clarify what the participation experiments measure.

Reviewer_UH2oOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This manuscript proposes an asynchronous federated learning (FL) algorithm that circumvents common challenges in conventional FL such as slow clients, stale updates, delays, etc. The proposed method reformulates the communication structure in FL by maintaining separate client and server model pools, allowing participating entities to independently access the required models at their own time-step based on a notion of utility.

Critical strengths
  • The manuscript addresses a relevant problem of efficiency reduction due to sychronization requirements in standard FL.
  • The proposed method of maintaining client and server pools is an interesting approach to addressing asynchronous and heterogeneous clients (although there are some memory concerns with this approach as mentioned later).
Critical weaknesses
  • A major weakness of the proposed method is the memory requirement. The client and server pools c(t)\mathbf{c}^{(t)} and s(ti)\mathbf{s}^{(t_i)} are also not defined anywhere. Are these parameters saved for all time-steps. If these pools are recursively updated, how would straggling clients access older memory? If older state memory needs to be stored, this memory can be prohibitively large in practice especially of there is resource heterogeneity among clients. In any case, the memory management model seems underspecified, and ambiguous.

  • In the presence of all history, asynchronous FL is intuitively straightforward, since the server or any of the clients can always access the most relevant/timely model based on their clock. The key challenge would be to do so with minimal memory requirements, and the paper doesn't clarify if they achieve this.

Questions for authors

There are several notational and definition issues with key quantities, and functions used throughout the paper, making them ambiguous and hard to interpret from the main text:

  • The quantities ℓ(θ(t),θ(ti);ξ)\ell(\mathbf{\theta}^{(t)}, \mathbf{\theta}^{(t_i)}; \xi) and fi(θ(t),θ(ti))f_i(\mathbf{\theta}^{(t)}, \mathbf{\theta}^{(t_i)}) are not defined anywhere. How should these quantities be interpretted, and how is the loss computed on two different parameters θ(t)\mathbf{\theta}^{(t)} and θ(ti)\mathbf{\theta}^{(t_i)}? The notation of ℓ(⋅)\ell(\cdot) also differs across equations, e.g. (2), around line 166, etc.

  • The function ff (without the subscript ii) is not defined before it is used in line 167. I believe it should be the average of all client cost functions, but for completeness, it should be defined mathematically somewhere. Similarly, it would help to have a precise definition of the value functions vπ(t,c(t))v_{\pi}(t, c^{(t)}) and vπi(t,s(ti))v_{\pi_i}(t, s^{(t_i)}).

  • Why are the policies (or parameter sets), for example π(t)\pi^{(t)}, indexed by tt (or tit_i)? Near line 176-179, they seem to include all parameters from 11 to TT (or TiT_i).

  • It would be clarifying to know the definition of J(ti,j)\mathbf{J}^{(t_i,j)} in the "Client Update" equation (lines 208-210) before it is introduced. This seems to be mentioned only much later in the appendix in Lemma 2.

  • In Eq. (A19), the outer ∇θi\nabla_{\mathbf{\theta}_i} in the second term of (A16) seems to be dropped? Also, should gi(j)\mathbf{g}_i^{(j)} have a ∇\nabla in its definition?

  • Some sentences seem to have grammatical errors or typos, or are incomplete:

    • "We refer to this as utility-driven asynchrony where different clients and server operate at different time scales calculating ff tt and tit_i to coincide, hence coupled."
    • "The server memory and client memory act as the “pseudo-coupling” that explicit synchronization at immense benefits."
    • There are several others, and a thorough proof-reading would help clarify a lot of similar sentences in the manuscript.
2 comments
AuthorsOpenReview ↗

Response UH2o

Thank you for your comments, we give point to point responses to your questions below.

W1 / Q1 (b) -- the pools are not defined. Thank you for your question. The pools are defined as a random variable in line 170 in the paper. These random variables are instantiated in practice with a client and server memory of size K. For any server or client, at any time instant, only K parameters at max are available in the pool and therefore the pool memory is constant at O[K]. In Appendix A1.2, Figure A6 reports peak CPU and GPU memory across all methods, and UAsyncFL sits below FedDrift, FedTKM and CA2FL, which maintain richer persistent state.

W2 -- "with all history, asynchronous FL is straightforward; the challenge is minimal memory." We agree with this, however, our memory requirements are capped at O[K].

Q1 (a) -- how is the loss computed on two different parameters? Addressed in the new paragraph after Eq. (2): the client objective depends on both the server and the client parameters and the server objective depends on both the client and the server parameters. We just explicitly indicate these dependencies in these definitions, so as to indicate the point that there is an implicit coupling in federated learning. Making the dependence explicit is what exposes the coupling that we are trying to address as part of the paper. Furthermore, we use the cross entropy loss function for the experiments.

Q1 (c) -- the notation differs across equations. Corrected; the signatures are now consistent between Eq. (1), Eq. (2) and the decoupled problem.

Q2 (a) -- f without subscript is used at line 167 before definition. In Eq. (2), fif_i averages the local loss over client ii's current data, and the server averages fif_i over participating clients. In the decoupled formulation, f(θ,c)f(\theta,c) is the instantaneous server objective given client-pool state cc.

Q2 (b) -- precise definitions of the value functions. The value functions are exactly the definitions inside braces at line 167, we have now indicated this explicitly and added an explanation in Eq. (3). Eq. (3) now defines each value function as its expected cost from the current stage to the end of its horizon. For the server this starts at tt in state c(t)c^{(t)} and ends at TT. For client ii it starts at tit_i in state s(ti)s^{(t_i)} and ends at TiT_i.

Q3 -- why are the policies indexed by t (or t_i)? Server side policy is indexed by server side time t and client side policies are indexed by client side time t_i. The time index on π(t)\pi(t) or πi(ti)\pi_i(t_i) identifies the remaining tail of the corresponding policy.

Q4 -- J definition. This is the first term in the inner product within the Hamiltonian, we have made this description clear in the revision.

Eq. A19 This is a typo, we have fixed this in the revision. Eq. (A19) omits the gradient in the definition of gi(j)g_i^{(j)} and the outer derivative on the correction. In the code, gB=∇θiLB(θi)g_B=\nabla_{\theta_i}L_B(\theta_i) and viv_i is the difference between the last two global states client ii received. Holding viv_i fixed, the client adds λ⟨gB,vi⟩\lambda\langle g_B,v_i\rangle to the minibatch loss. Differentiating that loss gives Adam the gradient gB+λ(∇θi2LB)vig_B+\lambda(\nabla^2_{\theta_i}L_B)v_i. We will show both derivatives in A19 and use the same notation in the main client update.

Q5 (b) -- should sigma carry a square root? It already does. Assumption 4(iii) bounds the squared quantity, E[(||grad l_i|| - ||grad f||)^2] <= sigma_mag^2, so sigma_mag is a deviation and is directly commensurate with g_M sqrt(2(1 - delta_min)) in the bound. The bound is therefore correct as printed; what was loose was the label, which read "magnitude variance" while the symbol denotes a deviation. Renamed to magnitude deviation in the revision, with the relation to the variance stated explicitly.

Q6 -- grammar and typos. Both quoted sentences are rewritten and the manuscript has been proof-read throughout.

I thank the authors for their response and clarifications. However, my primary concerns remain and are listed below. Hence, I maintain my score of 2.

  • The rebuttal validates my concerns about memory requirements. In fact, it is a bit misleading to say that the memory is O(K)O(K) for KK past models. If I understand correctly, there are the past KK models from the server, and past KK models from each client. Thus the total memory footprint would be O(Kd+KNd)O(Kd + KNd), for (say) NN clients and dd model parameters. Even if K=1K=1, this is a very large requirement for typical FL scenarios, where the number of clients can be of the order of 100100 or 10001000. The method seems highly impractical under such requirements. The notation is confusing, since KK is used to denote both, the number of clients and the number of past models saved. Are these the same? Why?

  • I am still confused about the 2-parameter notation of f(⋅)f(\cdot) and l(⋅)l(\cdot). I don't understand why the client implicitly depends on the server model; it is simply initialized at the server model. The notation is quite unconventional. Also, in the revised text, the authors say that "the dependency is made explicit in Eq. (1)", but I don't see this dependency between the client and server models, and the loss, anywhere in Eq. (1).

Also, some sentences seem incomplete in the revised text, such as around eq. (3).

Comments on the paper

2 comments
AuthorsOpenReview ↗

the need for utility

We thank all three reviewers. We first address the point raised in common across all reviewers. Utility is never measured and this is by design.

Reviewer 37FR observes that Algorithms 1-2 contain no step evaluating the utility-deterioration condition of Section 3, and Reviewer ZKEL asks whether any experiment uses measured degradation. The utility is never measured directly. It is our contention that the server cannot observe changes at the client directly and the effect of these changes shows up through the parameters that are being exchanged between the server and the client.

In this paper, use these parameters, we construct the Jacobian vector products, that allow the models to locally observe these changes. We use the estimate of the Jacobian at the client and the server to measure this effect and adapt the client and server respectively.

AuthorsOpenReview ↗

Uploaded New Draft

We thank all reviewers for their suggestion. We have revised the paper according to these comments and have now uploaded a revised draft.

We hope that this new draft clarifies many of the issues that were found during the review.

Thank you everyone for your time.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.