Original: Q U AFL: F EDERATED A VERAGING M ADE A SYNCHRONOUS AND C OMMUNICATION -E FFICIENT Anonymous authors
Revised: Q U AFL: F EDERATED A VERAGING M ADE A SYNCHRONOUS AND C OMMUNICATION -E FFICIENT Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Federated Learning (FL) is an emerging paradigm to enable the large-scale distributed training of machine learning models, while still allowing individual nodes to maintain local data.
Revised: Federated Learning (FL) is an emerging paradigm to enable the large-scale distributed training of machine learning models, while still allowing individual nodes to maintain local data.

Original: In this work, we take steps towards addressing two of the main practical challenges when scaling federated optimization to large node counts: the need for tight synchronization between the central authority and individual computing nodes, and the large communication cost of transmissions between the central server and clients.
Revised: In this work, we take steps towards addressing two of the main practical challenges when scaling federated optimization to large node counts: the need for tight synchronization between the central authority and individual computing nodes, and the large communication cost of transmissions between the central server and clients.

Original: Specifically, we present a new variant of the classic federated averaging (FedAvg) algorithm, which supports both asynchronous communication and communication compression.
Revised: Specifically, we present a new variant of the classic federated averaging (FedAvg) algorithm, which supports both asynchronous communication and communication compression.

Original: We provide a new analysis technique showing that, in spite of these system relaxations, our algorithm can provide similar convergence to FedAvg in some parameter regimes.
Revised: We provide a new analysis technique showing that, in spite of these system relaxations, our algorithm can provide similar convergence to FedAvg in some parameter regimes.

Original: On the experimental side, we show that our algorithm ensures fast convergence for standard federated tasks.
Revised: On the experimental side, we show that our algorithm ensures fast convergence for standard federated tasks.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Federated learning (FL) (Koneˇcn ` y et al., 2016; McMahan et al., 2017) is a paradigm for large-scale distributed learning, in which multiple clients, orchestrated by a central authority, cooperate to jointly optimize a machine learning model given their local data.
Revised: Federated learning (FL) (Koneˇcn ` y et al., 2016; McMahan et al., 2017) is a paradigm for large-scale distributed learning, in which multiple clients, orchestrated by a central authority, cooperate to jointly optimize a machine learning model given their local data.

Original: The key promise is to enable joint training over distributed client data, often located on end devices which are computationally- and communication-limited, without the data leaving the client device.
Revised: The key promise is to enable joint training over distributed client data, often located on end devices which are computationally- and communication-limited, without the data leaving the client device.

Original: The basic optimization algorithm underlying the learning process is known as federated averaging (FedAvg) (McMahan et al., 2017), and works roughly by having a central authority periodically communicate a shared model to all clients; then, the clients optimize this model locally based on their data, and communicate the resulting models to a central authority, which incorporates these models, often via some form of averaging, after which it initiates the next iteration.
Revised: The basic optimization algorithm underlying the learning process is known as federated averaging (FedAvg) (McMahan et al., 2017), and works roughly by having a central authority periodically communicate a shared model to all clients; then, the clients optimize this model locally based on their data, and communicate the resulting models to a central authority, which incorporates these models, often via some form of averaging, after which it initiates the next iteration.

Original: This algorithmic blueprint has been shown to be effective in practice (Li et al., 2020), and has also motivated a rich line of research analyzing its convergence properties (Stich, 2018; Haddadpour & Mahdavi, 2019), as well as proposing improved variants (Reddi et al., 2020; Karimireddy et al., 2020; Li & Richtárik, 2021).
Revised: This algorithmic blueprint has been shown to be effective in practice (Li et al., 2020), and has also motivated a rich line of research analyzing its convergence properties (Stich, 2018; Haddadpour & Mahdavi, 2019), as well as proposing improved variants (Reddi et al., 2020; Karimireddy et al., 2020; Li & Richtárik, 2021).

Original: Despite its popularity, scaling federated learning runs into a number of practical challenges (Kairouz et al., 2021).
Revised: Scaling federated learning runs into a number of practical challenges (Kairouz et al., 2021).

Original: One natural bottleneck is synchronization between the server and the clients: as practical deployments may contain thousands of nodes, it is infeasible for the central server to orchestrate synchronous rounds among all participants.
Revised: One natural bottleneck is synchronization between the server and the clients: as practical deployments may contain thousands of nodes, it is infeasible for the central server to orchestrate synchronous rounds among all participants.

Original: A simple mitigating approach is node sampling , e.g. (Smith et al., 2017; Bonawitz et al., 2019; He et al., 2018), by which the server only communicates with a subset of the nodes in a round; another, more general, approach is asynchronous communication , e.g. (Wu et al., 2020; Nguyen et al., 2022), by which the server and the nodes may work with inconsistent versions of the shared model, avoiding the need for lock-step synchronization.
Revised: A simple mitigating approach is node sampling , e.g. (Smith et al., 2017; Bonawitz et al., 2019); another, more general one is asynchronous communication , e.g. (Wu et al., 2020; Nguyen et al., 2022b), by which the server and the nodes may work with inconsistent versions of the shared model.

Original: An orthogonal scalability barrierfor federated learning is the high communication cost of transmitting  updatesbetween the server and clients in every iteration (Kairouz et al., 2021): the burden of repeatedly transmitting parameter-heavy updates may overwhelm the bandwidth of communicationlimited clients.
Revised: An orthogonal scalability barrier is the high communication cost of transmitting parameter updates (Kairouz et al., 2021), which may overwhelm communication-limited clients.

Original: Several  approaches have been proposed to address thisbottleneck, by allowing the server and clients to apply communication-compression to the transmitted updates, e.g. (Jin et al., 2020; Jhunjhunwala et al., 2021; Li & Richtárik, 2021; Wang et al., 2022).
Revised: Several communication-compression approaches have been proposed to address this (Jin et al., 2020; Jhunjhunwala et al., 2021; Li & Richtárik, 2021; Wang et al., 2022).

Original: It is reasonable to assume that both these bottlenecks would need to be mitigated in practice: for instance, communication-reduction may not be as effective if the server has to wait for each of the clients to complete their local steps on a version of the model; yet, synchrony is assumed by most references with compressed communication.
Revised: It is reasonable to assume that both these bottlenecks would need to be mitigated in practice: for instance, communication-reduction may not be as effective if the server has to wait for each of the clients to complete their local steps on a version of the model; yet, synchrony is assumed by most references with compressed communication.

Original: Yet, removing synchrony completely may lead to divergence,especially given that local data is commonly assumed to be heterogenous.
Revised: Yet, removing synchrony completely may lead to divergence, given that local data is usually heterogenous.

Original: Thus, it is interesting to ask under which conditions asynchrony and communication compression, and heterogenous local data, can be jointly supported in federated learning.
Revised: Thus, it is interesting to ask if asynchrony and communication compression, and heterogenous local data, can be jointly supported.

Original: Contributions.
Revised: Contribution.

Original: In this paper, we take a step towards answering this question, and propose an algorithm for Qu antized A synchronous F ederated L earning called QuAFL, which is an extension of FedAvg, specifically adapted to support both asynchronous communication and communication compression.
Revised: In this paper, we address this by proposing an algorithm for Qu antized A synchronous F ederated L earning called QuAFL, which is an extension of FedAvg, specifically-adapted to support both asynchronous communication and communication compression.

Original: We provide arigorous theoretical analysis showing that the algorithm still converges, and, in some parameter regimes, can asymptotically match the  convergence of FedAvg despite compressed and asynchronous communication. Experimental results in a simulated environment with up to 300 nodes show that it can also lead to practical performance gains.
Revised: We provide a theoretical analysis of the algorithm’s convergence under compressed and asynchronous communication, and experimental results on up to 300 nodes showing that it can also lead to practical performance gains.

Original:  The general idea behind QuAFL is that we allow clients to perform their local steps independently of the round structure implemented by the server, and on a local, inconsistent version of the parameters, assuming a probabilistic scheduling model.
Revised: Overview. The main idea behind QuAFL is that we allow clients to perform their local steps independently of the round structure implemented by the server, and on a local, inconsistent version of the parameters, assuming a probabilistic scheduling model.

Original: Specifically, all clients receive a copy of the model when joining the computation, and start performing at most K ≥ 1 optimization steps on it based on their local data.
Revised: Specifically, all clients receive a copy of the model when joining the computation, and start performing at most K ≥ 1 optimization steps on it based on their local data.

Original: Independently, in each “logical round,” the server samples a set of s clients uniformly at random, and sends them a compressed copy of its current model.
Revised: Independently, in each “logical round,” the server samples a set of s clients uniformly at random, and sends them a compressed copy of its current model.

Original: Whenever receiving the server’s message, clients immediately respond with a compressed version of their current model, which may still be in the middle of the local optimization process, and therefore may not include recent server updates, nor the totality of the K local optimization steps.
Revised: Whenever receiving the server’s message, clients immediately respond with a compressed version of their current model, which may still be in the middle of the local optimization process, and therefore may not include recent server updates, nor the totality of the K local optimization steps.

Original: In fact, we even allow that, with some probability, some  clients do not take anylocal steps at all.
Revised: In fact, we even allow that, with some probability, some contacted clients do not take any steps at all.

Original: Clients carefully integrate the received server model into their next local iteration, while the server does the same with the  models it receives.
Revised: Clients carefully integrate the received server model into their next local iteration, while the server does the same with the client models it receives.

Original: The key missing piece regards quantization.
Revised: The key missing piece regards quantization.

Original: Applying a standard quantizers (Alistarh et al., 2017; Karimireddy et al., 2019), runs into the issue that the quantization error may be too large, as it is proportional to the norm of the (updated) model at the client.
Revised: Directly applying standard compressors on transmitted updates (Alistarh et al., 2017b; Karimireddy et al., 2019) runs into the issue that the quantization error may be too large, as it is proportional to the norm of the (updated) model at the client.

Original: Resolving this analytically would require either an unrealistic second-moment bound on the maximum gradient update, e.g. (Chen et al., 2021), orapplying variance-reduction techniques (Gorbunov et al., 2021), which may be complex in practice.
Revised: Resolving this analytically would require either an unrealistic second-moment bound on the maximum gradient update, e.g. (Chen et al., 2021), or variance-reduction techniques (Gorbunov et al., 2021), which may be complex in practice.

Original: We circumvent this issue differently, by leveraging arecent lattice-based quantizer (Davies et al., 2021), which has the property that the quantization error only depends on the difference between the quantized model and a carefully-chosen “reference point.
Revised: We circumvent this issue differently, by leveraging a lattice-based quantizer (Davies et al., 2021), which has the property that the quantization error only depends on the difference between the quantized model and a carefully-chosen “reference point.

Original: ” We instantiate this technique for the first time in the federated setting.
Revised: ” We instantiate this technique for the first time in the federated setting.

Original: To employ it successfully, we overcome non-trivial challenges in defining the right reference points for encoding and decoding, as well as the fact that this procedure has a non-zero probability of error.

Original: Our analysis technique relies on a new potential argument, which shows that the discrepancy between the client and server models is always bounded.
Revised: Our analysis technique relies on a new potential argument, which shows that the discrepancy between the client and server models is always bounded.

Original: This bound has dual usage: both to control the “noise” at different steps due to model inconsistency, but also to ensure that the local models are consistent enough to allow correct encoding and decoding via lattice quantization.
Revised: This bound serves to control the “noise” at different steps due to model inconsistency, but also to ensure that the local models are consistent enough to allow correct encoding and decoding via lattice quantization.

Original: The technique is complex yet modular, and should allow further analysis of more complex algorithmic variants (Karimireddy et al., 2020; Reddi et al., 2020).
Revised: The technique is complex yet modular, and should allow further analysis of more complex algorithmic variants.

Original: Our algorithm has strong convergence bounds, given the degree of relaxation in the system, and the fact that we consider local data to be heterogenenous.

Original: Specifically, in some parameter regimes, we can asymptotically match the best known bounds for the synchronous and full-communication FedAvg algorithm (Karimireddy et al., 2020), showing that asynchrony and quantization can be supported without significant impact of convergence.

Original: We validate our algorithm experimentally in the rigorous LEAF (Caldas et al., 2018) environment, on a series of standard tasks.
Revised: We validate our algorithm experimentally in the rigorous LEAF (Caldas et al., 2018) environment, on a series of standard tasks.

Original: Specifically, in practice, QuAFL can compress updates by more than 3 × without significant loss of convergence, and can withstand a large constant fraction of “slow” clients submitting infrequent updates.
Revised: Specifically, in practice, QuAFL can compress updates by more than 3 × without significant loss of convergence, and can withstand a large constant fraction of “slow” clients submitting infrequent updates.

Original: Moreover, in a setting where client computation setting are heterogenous, QuAFL provides end-to-end speedup, since the server can progress without waiting for all clients to complete their local computation.
Revised: Moreover, in a setting where client computation speeds are heterogenous, QuAFL provides end-to-end speedup, since the server can progress without waiting for all clients to complete their local computation.

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: The federated averaging (FedAvg) algorithm was introduced by McMahan et al.
Revised: The federated averaging (FedAvg) algorithm was introduced by McMahan et al.

Original: (2017), and
Revised: (2017), and

Original: Stich (2018) was among the first to consider its convergence rate in the homogeneous data setting.
Revised: Stich (2018) was among the first to consider its convergence rate in the homogeneous data setting.

Original: Here, we investigate whether one can jointly eliminate two of the main scalability bottlenecks of this algorithm, the synchrony between the server and client iterations, as well as the necessity of full-precision communication, with heterogeneous data distributions.
Revised: Here, we investigate whether one can jointly eliminate two of the main scalability bottlenecks of this algorithm, the synchrony between the server and client iterations, as well as the necessity of full-precision communication, with heterogeneous data distributions.

Original: Due to space constraints, we focus on prior work which seeks to mitigate these two constraints in the context of FL.
Revised: Due to space constraints, we focus on prior work which seeks to mitigate these two constraints in the context of FL.

Original: There is significant research into communication-compression federated averaging (Philippenko & Dieuleveut, 2020; Reisizadeh et al., 2020; Jin et al., 2020; Haddadpour et al., 2021).
Revised: There is significant research into communication-compression for FedAvg (Philippenko & Dieuleveut, 2020; Reisizadeh et al., 2020; Jin et al., 2020; Haddadpour et al., 2021).

Original: However, virtually all of this work considers synchronous iterations.
Revised: However, virtually all of this work considers synchronous iterations.

Original: Reisizadeh et al.
Revised: Reisizadeh et al.

Original: (2020) introduced FedPAQ, a variant of FedAvg which supports quantized communication via standard compressors, and provides strong convergence bounds, under the strong assumption of i.i.d.
Revised: introduced FedPAQ, a variant of FedAvg which supports quantized communication via standard compressors, and provides strong convergence bounds, under the strong assumption of i.i.d.

Original: client data.
Revised: client data.

Original: Jin et al.
Revised: Jin et al.

Original: (2020) examines the viability of a variant of the signSGD quantizer (Seide et al., 2014; Karimireddy et al., 2019) in the context of FedAvg, providing convergence guarantees; however, the rate guarantees have a polynomial dependence in the model dimension d , rendering them less practically meaningful.
Revised: (2020) examines the viability of a variant of the signSGD quantizer (Seide et al., 2014; Karimireddy et al., 2019) in the context of FedAvg, providing convergence guarantees; however, the rate guarantees have a polynomial dependence in the model dimension d , rendering them less practically meaningful.

Original: Haddadpour et al.
Revised: Haddadpour et al.

Original: (2021) proposed FedCOM, a family of federated optimization algorithms with communication-compression and convergence rates; yet, we note that, in order to prove convergence in the challenging heterogeneous-data setting, this reference requires non-trivial technical assumptions on the quantized gradients (Haddadpour et al., 2021, Assumption 5).
Revised: (2021) proposed FedCOM, a family of federated optimization algorithms with communicationcompression and convergence rates; yet, we note that, in order to prove convergence in the challenging heterogeneous-data setting, this reference requires non-trivial technical assumptions on the quantized gradients (Haddadpour et al., 2021, Assumption 5).

Original: Chen et al.
Revised: Chen et al.

Original: (2021) also considered update compression, but under convex losses, coupled with a rather strong secondmoment bound assumption on the gradients.
Revised: (2021) also considered update compression, but under convex losses, coupled with a rather strong second-moment bound assumption on the gradients.

Original: Finally, Jhunjhunwala et al.
Revised: Finally, Jhunjhunwala et al.

Original: (2021) examine adapting the degree of compression during the execution, proving convergence bounds for their scheme, under the non-standard i.i.d.
Revised: (2021) examine adapting the degree of compression during the execution, proving convergence bounds for their scheme, under the non-standard i.i.d.

Original: data sampling assumption.
Revised: data sampling assumption.

Original: We observe that each of these references requires at least one non-standard assumption for  convergence guarantees for FedAvg under communication compression.
Revised: We observe that each of these references requires at least one non-standard assumption for the convergence of FedAvg with compression.

Original: By contrast, our analysis works for general (non-convex) losses, under a standard non-i.i.d.
Revised: By contrast, our analysis works for general (non-convex) losses, under a standard non-i.i.d.

Original: data distribution, without relying on second-moment bounds on the gradients.
Revised: data distribution, without relying on second-moment bounds on the gradients.

Original: A complementary approach to reducing communication cost in the federated setting has been to investigate optimizers with faster convergence, e.g. (Mishchenko et al., 2019; Karimireddy et al., 2020), or adaptive optimizers (Reddi et al., 2020;
Revised: A complementary approach to reducing communication cost in FL has been to investigate optimizers with faster convergence, e.g. (Mishchenko et al., 2019; Karimireddy et al., 2020), or adaptive optimizers (Reddi et al., 2020;

Original: Tong et al., 2020).
Revised: Tong et al., 2020).

Original: Moreover, recent work has shown that these approaches can be compatible with communication-compression (Gorbunov et al., 2021; 
Revised: Tecent work has shown that these approaches can be compatible with communication-compression (Gorbunov et al., 2021; Li & Richtárik, 2021;

Original: Li & Richtárik, 2021; Wang et al., 2022).
Revised: Wang et al., 2022).

Original: Specifically, for non-convex losses, MARINA Gorbunov et al.
Revised: Specifically, for non-convex losses, MARINA Gorbunov et al.

Original: (2021) offers theoretical guarantees both in terms of convergence and bits transmitted.
Revised: (2021) offers theoretical guarantees both in terms of convergence and bits transmitted.

Original: However, MARINA is structured in synchronous rounds; moreover, it periodically (with some probability) has clients compute full gradients and transmit uncompressed model updates, and requiresfairly complex synchronization and variance-reduction to compensate for the extra noise due to quantization.
Revised: However, MARINA is structured in synchronous rounds; moreover, it periodically (with some probability) has clients compute full gradients and transmit uncompressed model updates, and requires complex synchronization and variance-reduction to compensate for the extra noise due to quantization.

Original: Recent work by Tyurin & Richtárik (2022) proposed a family of theoretical methods called DASHA, which combines the general structure of MARINA with Momentum Variance Reduction (MVR) methods (Cutkosky & Orabona, 2019), while relaxing the coupling between the server and the nodes and allowing fully-compressed updates.
Revised: Tyurin & Richtárik (2022) proposed a family of theoretical methods called DASHA, which combines the general structure of MARINA with Momentum Variance Reduction (MVR) methods (Cutkosky & Orabona, 2019), partially relaxing the coupling between the server and the workers and allowing compressed updates.

Original: In contrast to these works, we focus on obtaining a practical algorithm with good convergence bounds: we always transmit compressed, low-precision messages, and consider a notion of asynchronous communication which allows the server and nodes to make progress independently, in non-blocking fashion.
Revised: In contrast to these works, we focus on obtaining a practical algorithm with good convergence bounds: we always transmit compressed, low-precision messages, and consider a notion of asynchronous communication which allows the server and nodes to make progress independently, in non-blocking fashion.

Original: We focus on the classic, practical FedAvg algorithm, although our general algorithmic and analytic approach should generalize to more complex notions of local optimization.
Revised: We focus on the classic, practical FedAvg algorithm, although our general algorithmic and analytic approach should generalize to more complex notions of local optimization.

Original: Our approach extends ideas from the analysis of decentralized variants of SGD (Lian et al., 2017;
Revised: Our approach extends ideas from the analysis of decentralized variants of SGD (Lian et al., 2017;

Original: Tang et al., 2018; Nadiradze et al., 2021; Koloskova et al., 2019; Lu & De Sa, 2020), bringing them into the context of federated optimization.
Revised: Tang et al., 2018; Nadiradze et al., 2021; Koloskova et al., 2019; Lu & De Sa, 2020), bringing them into the context of federated optimization.

Original: Significant differences exist: notably, we introduce a novel potential argument, adapted to FL, and cannot rely on stronger assumptions available in the decentralized setting, e.g. a gradient second-moment bound (Lu & De Sa, 2020).
Revised: Significant differences exist: notably, we introduce a novel potential argument, adapted to FL, and cannot rely on stronger assumptions available in the decentralized setting, e.g. a gradient second-moment bound (Lu & De Sa, 2020).

Revised: The concurrent work of Koloskova et al.

Revised: (2022) provided sharper convergence bounds for asynchronous SGD in a model that is related to ours.

Revised: Specifically, this reference considers a setting with worst-case and average delay bounds on asynchrony, and proves convergence rates that are similar to ours in the case of a single sampled client at a time s .

Revised: By contrast, our work considers a different probabilistic model on the delays, related to that of Cannelli et al.

Revised: (2020) in which the worst-case delay may be unbounded.

Original:   T HE A LGORITHM 3. S YSTEM O VERVIEW
Revised: In addition, we allow the clients to be interrupted by the server during their local computation, which may lead to practical improvements in terms of waiting times and load-balancing. At the technical level, the two analysis techniques are different: in particular, their technique does not require a lower bound on the number of SGD steps w.r.t. the number of nodes n .  T HE A LGORITHM 3. S YSTEM O VERVIEW

Original: System Model.
Revised: System Model.

Original: We assume a distributed system with one coordinator and n client nodes, jointly minimizing a d -dimensional, differentiable function f : R d → R .
Revised: We assume a distributed system with one coordinator and n workers, jointly minimizing a d -dimensional, differentiable function f : R d → R .

Original: We consider the empirical risk minimization (ERM) setting, in which data samples are located at the n nodes.
Revised: We consider the empirical risk minimization (ERM) setting, in which data samples are located at the n nodes.

Original: Each agent i has a local function f i associated to its own local fraction of the data, i.e ∀ x ∈ R d : f ( x ) = (cid:80) ni
Revised: Each agent i has a local function f i associated to its own local fraction of the data, i.e ∀ x ∈ R d : f ( x ) = (cid:80) ni

Original: =

Revised: =

Original: f i ( x ) /n.
Revised: f i ( x ) /n.

Original: The goal is to converge on a model x ∗ which minimizes the empirical loss.
Revised: The goal is to converge on a model x ∗ which minimizes the empirical loss.

Original: Clients run a distributed variant of SGD, coordinated by the central node.
Revised: Clients run a distributed variant of SGD, coordinated by the central node.

Original: We will assume that each client i is able to obtain unbiased stochastic gradients (cid:101) g i of its own local function f
Revised: We will assume that each client i is able to obtain unbiased stochastic gradients (cid:101) g i of its own local function f

Original: i , i.e. E [ (cid:101) g
Revised: i , i.e. E [ (cid:101) g

Original: i ( x )]
Revised: i ( x )]

Original: = ∇ f i ( x ) .
Revised: = ∇ f i ( x ) .

Original: These stochastic gradients can be computed by each agent by sampling i.i.d.
Revised: These stochastic gradients can be computed by each agent by sampling i.i.d.

Original: from its own local distribution.
Revised: from its own local distribution.

Original: Our analysis will consider the case where each client distribution is distinct, but there is a bound on the maximum gradient discrepancy.
Revised: Our analysis will consider the case where each client distribution is distinct, but there is a bound on the maximum gradient discrepancy.

Original: We model client asynchrony as follows: between two consecutive interactions with the server, each client should perform a number of gradient steps on its local model.
Revised: We model client asynchrony as follows: between two consecutive interactions with the server, each client should perform a number of gradient steps on its local model.

Original: We treat the number of local steps at client i as a random variable H i , taking values in { 0 , 1 , 2 , . . .
Revised: We treat the number of local steps at client i as a random variable H i , taking values in { 0 , 1 , 2 , . . .

Original: , K } , where K is a bound on how many steps a client can take in isolation.
Revised: , K } , where K is a bound on how many steps a client can take in isolation.

Original: We emphasize the fact that H i can take the value 0 , meaning that the client may take no steps since last contacted.
Revised: We emphasize the fact that H i can take the value 0 , meaning that the client may take no steps since last contacted.

Original: Our only assumption regarding asynchrony is that the expected value of H , denoted by H , exists and is > 0 .
Revised: Our only assumption regarding asynchrony is that the expected value of H , denoted by H , exists and is > 0 .

Original: That is, we assume that, on average, each client makes non-trivial progress, and clients progress at similar rates. We note that step distributions H iat clients can be completely different, as long as their expectations match.
Revised: That is, we assume that, on average, each client makes non-zero progress, and clients progress at similar rates, although the individual step distributions H i can be completely different.

Original: 3. A LGORITHM D ESCRIPTION
Revised: 3. A LGORITHM D ESCRIPTION

Original: Overview.
Revised: Overview.

Original: Our algorithm starts from the standard pattern used by federated averaging (FedAvg): computation and communication are organized in logical “rounds,” where in each round the server transmits its current version of the model to either all, or a subset of clients.
Revised: Our algorithm starts from the standard pattern used by federated averaging (FedAvg): computation and communication are organized in logical “rounds,” where in each round the server transmits its current version of the model to either all, or a subset of clients.

Original: The clients should then take some number of local optimization steps on the received model, which is at most K ≥ 1 , and transmit the result to the server, which integrates these updates.
Revised: The clients should then take some number of local optimization steps on the received model, which is at most K ≥ 1 , and transmit the result to the server, which integrates these updates.

Original: Our algorithm will relax this pattern in two orthogonal ways, allowing for both quantized and asynchronous communication.
Revised: Our algorithm will relax this pattern in two orthogonal ways, allowing for both quantized and asynchronous communication.

Original: Quantized Communication.
Revised: Quantized Communication.

Original: The first relaxation is to only allow for compressed communication of the server model and of the client updates, via quantization.
Revised: The first relaxation is to only allow for compressed communication of the server model and of the client updates, via quantization.

Original: For this, we employ a carefullyparametrized version of the lattice-based quantization technique of Davies et al.
Revised: For this, we employ a carefullyparametrized version of the lattice-based quantization technique of Davies et al.

Original: (2021), whose analytical properties we describe in the analysis section.
Revised: (2021), whose analytical properties we describe in the analysis section.

Original: For practical purposes, this quantization technique presents an encoding function
Revised: For practical purposes, this quantization technique presents an encoding function

Original: Enc ( A ) , which encodes an arbitrary input A to its quantized representation.
Revised: Enc ( A ) , which encodes an arbitrary input A to its quantized representation.

Original: (We always communicate vectors via their quantized representations.)
Revised: (We always communicate vectors via their quantized representations.)

Original: To “read” an encoded message Enc ( A ) , a node must call the symmetric Dec ( B, Enc ( A )) function, which allows for the “decoding” of the input Enc ( A ) with respect to a reference point B , returning a quantized output Q ( A ) .
Revised: To “read” an encoded message Enc ( A ) , a node must call the symmetric Dec ( B, Enc ( A )) function, which allows for the “decoding” of the input Enc ( A ) with respect to a reference point B , returning a quantized output Q ( A ) .

Original: We formally specify the properties of the compression process in Section 4.
Revised: We formally specify the properties of the compression process in Section 4.

Original: Algorithm
Revised: Algorithm

Original: % Initial models X 

Revised: % Initial models X

Original: = X
Revised: = X

Original: 1 = X 

Revised: 1 = X

Original: = ...
Revised: = ...

Original: =
Revised: =

Original: X n = 

Revised: X n =

Original: d , number of local steps K % Encoding ( Enc ( A ) ) and decoding ( Dec ( B, Enc ( A )) ) functions, with common parametrization.
Revised: d , number of local steps K % Encoding ( Enc ( A ) ) and decoding ( Dec ( B, Enc ( A )) ) functions, with common parametrization.

Original: % At the Server :
Revised: % At the Server :

Original: [Table]
Revised: [Table]

Original: [Table] 
Revised: [Table] [Table] [Table] [Table]

Original: [Table] [Table] 
Revised: [Table] [Table] [Table]

Original: [Table] [Table][Table]
Revised: [Table] [Table]

Original: [Table][Table] [Table] [Table]
Revised: [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: Asynchronous Communication.
Revised: Asynchronous Communication.

Original: A key practical limitation of the FedAvg pattern isthe fact that the server and its clients have to communicate in synchronous, lock-step fashion: thus, the server must wait for the results of computation at a round before it can move to the next round.
Revised: A key practical limitation of the FedAvg pattern is that the server and its workers have to communicate in synchronous, lock-step fashion: thus, the server must wait for the results of computation at a round before it can move to the next round.

Original: In particular, this means that the server has to wait for the slowest client to complete its local steps before it can proceed.
Revised: In particular, this means that the server has to wait for the slowest client to complete its local steps before it can proceed.

Original: QuAFL relaxes this requirement by essentially allowing any contacted node i to immediately return (a quantized version of) its current version of the model to the server upon being contacted, even though the client might still not have completed all its K local optimization steps for the round.
Revised: QuAFL relaxes this requirement by essentially allowing any contacted node i to immediately return (a quantized version of) its current version of the model to the server upon being contacted, even though the client might still not have completed all its K local optimization steps for the round.

Original: More precisely, the client always records its “base” model at the end of the last interaction with the server into parameter X i , and sums up its gradient updates since the last interaction into the buffer (cid:101) h i .
Revised: More precisely, the client always records its “base” model at the end of the last interaction with the server into parameter X i , and sums up its gradient updates since the last interaction into the buffer (cid:101) h i .

Original: Upon being contacted, the client simply sends its current progress Y
Revised: Upon being contacted, the client simply sends its current progress Y

Original: i
Revised: i

Original: =
Revised: =

Original: X i − η (cid:101) h
Revised: X i − η (cid:101) h

Original: i to the server (excluding the local step for which computation was not finished due to interruption from the server) , where η is the learning rate, in quantized form.
Revised: i to the server (excluding the local step for which computation was not finished due to interruption from the server) , where η is the learning rate, in quantized form.

Original: It is possible that this progress is zero .
Revised: It is possible that this progress is zero .

Original: The client then decodes the quantized server model X t , using its old local model
Revised: The client then decodes the quantized server model X t , using its old local model

Original: X i as the decoding key.
Revised: X i as the decoding key.

Original: Finally, the client updates X i to include the server’s new information via  averaging.
Revised: Finally, the client updates X i to include the server’s new information via weighted averaging.

Original: It is then ready to restart its local update loop, upon this new model.
Revised: It is then ready to restart its local update loop, upon this new model.

Original: It is important to notice that the server interaction occurs asynchronously , and that it might occur either while the client is still performing local steps, or after the client has completed its K local steps, and is idle, waiting for server contact.
Revised: It is important to notice that the server interaction occurs asynchronously , and that it might occur either while the client is still performing local steps, or after the client has completed its K local steps, and is idle, waiting for server contact.

Original: In the former case, upon being contacted, immediately calls the server interaction function, without performing additional steps.
Revised: In the former case, upon being contacted, immediately calls the server interaction function, without performing additional steps.

Original: (In particular, we allow the number of completed local steps to be 0 .)
Revised: (In particular, we allow the number of completed local steps to be 0 .)

Original: Globally, the server contacts s random agents in each logical round, sends them a quantized version of the global model X t , then receives quantized versions of their progress, and then incorporates this into the global model which will be sent at the next round.
Revised: Globally, the server contacts s random agents in each logical round, sends them a quantized version of the global model X t , then receives quantized versions of their progress, and then incorporates this into the global model which will be sent at the next round.

Original: Discussion.
Revised: Discussion.

Original: As we will see in the experiments, the practical advantage of QuAFL is that the server does not have to wait for each of the contacted clients to complete their local optimization on the global model X t .
Revised: The practical advantage of QuAFL is that the server does not have to wait for each of the contacted clients to complete their local optimization on the global model X t .

Original: In addition, an important departure from FedAvg is the averaging between the server and client models.
Revised: In addition, an important departure from FedAvg is the averaging between the server and client models.

Original: Our formulation is important for fast convergence: as we show in Figure 3, other forms, such as just adopting the client average, lead to worse convergence.
Revised: Our formulation is important for fast convergence: as we show in Figure 4, other forms, such as just adopting the client average, lead to worse convergence.

Original: Our assumption on the expected local step count H > 0 can be restated as saying that clients do make some local progress on average between server interactions, although that is not always required.

Original: However, we will prove that, when H =

Original: Θ( K ) , asymptotic convergence is the same as FedAvg.

Original:  C ONVERGENCE A NALYSIS 4. A NALYTICAL A SSUMPTIONS
Revised:  C ONVERGENCE A NALYSIS 4. A NALYTICAL A SSUMPTIONS

Original: We begin by stating the assumptions we make in the theoretical analysis of our algorithm.
Revised: We begin by stating the assumptions we make in the theoretical analysis of our algorithm.

Original: Specifically, we assume the following for the global loss function f , the individual client losses f i , and the stochastic gradients (cid:101) g i :
Revised: Specifically, we assume the following for the global loss function f , the individual client losses f i , and the stochastic gradients (cid:101) g i :

Original: Uniform Lower Bound: There exists f ∗ ∈ R such that f ( x ) ≥ f ∗ for all x ∈ R d . 2.
Revised: Uniform Lower Bound: There exists f ∗ ∈ R such that f ( x ) ≥ f ∗ for all x ∈ R d . 2.

Original: Smooth Gradients :
Revised: Smooth Gradients :

Original: For any client i , the gradient ∇ f i ( x ) is L -Lipschitz continuous for some L > 0 ,
Revised: For any client i , the gradient ∇ f i ( x ) is L -Lipschitz continuous for some L > 0 ,

Original: i
Revised: i

Original: e. for all x, y ∈ R d :
Revised: e. for all x, y ∈ R d :

Original: [Equation]
Revised: [Equation]

Original: Bounded Variance : For any client i , the variance of the stochastic gradients is bounded by some σ 2 > 0 ,
Revised: Bounded Variance : For any client i , the variance of the stochastic gradients is bounded by some σ 2 > 0 ,

Original: i
Revised: i

Original: e. for all x ∈ R d :
Revised: e. for all x ∈ R d :

Original: [Equation]
Revised: [Equation]

Original: BoundedGradient Dissimilarity : There exist constants G 2 ≥ 0 and B 2 ≥ 1 , such that for all x∈ R d :
Revised: Bounded Dissimilarity : There exist constants G 2 ≥ 0 and B [Equation] x

Original: [Equation]
Revised: [Equation]

Original: All these assumptions are standard in the context of non-convex federated learning, e.g. (Karimireddy et al., 2020; Jin et al., 2020; Gorbunov et al., 2021). Specifically, the first three assumptions arefairly universal in distributedstochastic optimization over non-convex losses, whereas the fourth is a standard way of encoding the fact that there must be a bound on the amount of divergence between the local distributions at the nodes in order to allow for joint optimization.
Revised: The first three conditions are universal in distributed non-convex stochastic optimization, whereas the fourth encodes the fact that there must be a bound on the amount of divergence between the local distributions at the nodes in order to allow for joint optimization (Karimireddy et al., 2020; Jin et al., 2020; Gorbunov et al., 2021). In addition, we make the following assumption on the local progress performed by each node: Probabilistic Progress: The expected number of local steps taken by a client when contacted by the server is

Revised: H > 0 .

Original: Quantization Procedure.
Revised: Quantization Procedure.

Original: For completeness, we restate the formal guarantees of the quantization function (Davies et al., 2021) (Lemma 23):
Revised: Please recall the semantics of our quantization procedure from Section 3.2. In this context, the quantizer has the following guarantees (Davies et al., 2021) (Lemma 23):

Original: Lemma 4.1.
Revised: Lemma 4.1.

Original: (Lattice Quantization)
Revised: (Lattice Quantization)

Original: Fix parameters R and γ > 0 .
Revised: Fix parameters R and γ > 0 .

Original: There exists a quantization procedure defined by an encoding function Enc R,γ : R d → { 0 , 1 } ∗ and a decoding function
Revised: There exists a quantization procedure defined by an encoding function Enc R,γ : R d → { 0 , 1 } ∗ and a decoding function

Original: Dec R,γ = R d × { 0 , 1 } ∗ → R d such that, for any vector x ∈ R d which we are trying to quantize, and any vector y which is used by decoding, which we call the decoding key , if ∥ x − y ∥
Revised: Dec R,γ = R d × { 0 , 1 } ∗ → R d such that, for any vector x ∈ R d which we are trying to quantize, and any vector y which is used by decoding, which we call the decoding key , if ∥ x − y ∥

Original: ≤ R R d γ then with probability at least 1 − log log( ∥ x − y ∥ γ ) O
Revised: ≤ R R d γ then with probability at least 1 − log log( ∥ x − y ∥ γ ) O

Original: ( R − d ) , the function Q R,γ ( x ) =
Revised: ( R − d ) , the function Q R,γ ( x ) =

Original: Dec R,γ ( y, Enc R,γ ( x )) has the following properties:
Revised: Dec R,γ ( y, Enc R,γ ( x )) has the following properties:

Original: (Unbiased decoding) E [ Q R,γ ( x )]
Revised: (Unbiased decoding) E [ Q R,γ ( x )]

Original: =
Revised: =

Original: E [ Dec R,γ ( y, Enc R,γ ( x ))]
Revised: E [ Dec R,γ ( y, Enc R,γ ( x ))]

Original: = x ; 2.
Revised: = x ; 2.

Original: (Error bound)
Revised: (Error bound)

Original: ∥ Q R,γ ( x ) − x ∥ ≤ ( R 2 + 7) γ ; 3.
Revised: ∥ Q R,γ ( x ) − x ∥ ≤ ( R 2 + 7) γ ; 3.

Original: (Communication bound) O (cid:16) d log( Rγ ∥ x − y ∥ (cid:17) ) bits
Revised: (Communication bound) O (cid:16) d log( Rγ ∥ x − y ∥ (cid:17) ) bits

Original: are needed to send Enc
Revised: are needed to send Enc

Original: R,γ ( x 
Revised: R,γ ( x ) .

Original: Thus, our aim is to show that in our algorithm, local models of the clients stay close to the local model of the server, so that  we can successfully apply the above lemma to our setting. 4. M AIN R ESULTS
Revised: Roughly, our aim is to show that in our algorithm, local models of the clients stay close to the local model of the server, so that models are consistent, and we can successfully apply the quantizer.

Original: Let µ t =
Revised: Let µ t =

Original: ( X t + (cid:80) ni
Revised: ( X t + (cid:80) ni

Original: =1 X i ) /
Revised: =1 X i ) /

Original: ( n + 1) be the mean over all the node models in the system at a given t .
Revised: ( n + 1) be the mean over all the node models in the system at a given t .

Original: Our main result shows the following:
Revised: Our main result shows the following:

Original: Theorem 4.2.
Revised: Theorem 4.2.

Original: Assume the total number of  steps T ≥ Ω( n 3 ) , the learning rate η = n +1 sH √ T , and quantization parameters R = 2 + T 3 d and γ 2 =
Revised: Assume the total number of server steps T ≥ Ω( n 3 ) , the learning rate η = n +1 sH √ T , and quantization parameters R = 2 + T 3 d and γ 2 =

Original: [Equation]
Revised: [Equation]

Original: Let H > 0 be the expected number of local steps already performed by a client when interacting with the server.
Revised: Let H > 0 be the expected number of local steps already performed by a client when interacting with the server.

Original: Then, with probability at least 1 − O ( 1 T ) we have that Algorithm 1 converges at the following rate
Revised: Then, with probability at least 1 − O ( 1 T ) we have that Algorithm 1 converges at the following rate

Original: [Equation]
Revised: [Equation]

Original:  and uses O ( sT ( d log n + log T ))
Revised: n 3 KL 2 ( σ 2 + 2 KG 2 ) sH 3 T (cid:19) and uses O ( sT ( d log n + log T ))

Original: expected communication bits in total.
Revised: expected communication bits in total.

Original:  The result provides a trade-off between the convergence speed of the algorithm, the variance of the local distributions (given by σ and G ), the sampling set size s , and the average number of local steps H performed by a node when contacted by the server.
Revised: Discussion. The result provides a trade-off between the convergence speed of the algorithm, the variance of the local distributions (given by σ and G ), the sampling set size s , and the average number of local steps H performed by a node when contacted by the server.

Original: Intuitively, the first additive term appears to be asymptotically-optimal, as the server relies on progress from s clients, each having taken Hlocal gradient steps on average, and the objective is general non-convex. The second term essentially contains a “total upper bound” on variance in its numerator, divided by the total number of expected gradient steps in the denominator.
Revised: For constant s , H and K , this bound appears to be asymptotically-optimal.

Original: The third term contains similar “nuisance terms” to the second, with the addition of the n 3 factor, and also bounds the extra variance.
Revised: Specifically, the third term contains similar “nuisance factors” as the second term, with the addition of the n 3 factor, and also bounds the extra variance.

Original: Crucially, this larger term is divided by T , as opposed to √ T ; since T is our asymptotic parameter, it is common to assume that this extra term becomes negligible as T is large, e.g. (Lu & De Sa, 2020).
Revised: Crucially, this larger term is divided by T , as opposed to √ T ; since T is our asymptotic parameter, it is common to assume that this extra term becomes negligible as T is large, e.g. (Lu & De Sa, 2020).

Original: Under this convention, the first two terms essentially recover the  convergence bound provided by Karimireddy et al.
Revised: However, for super-constant s = ω ( n ) , there is no tangible benefit due to sampling over s clients. Intuitively, this is because of asynchrony: each client gets sampled on average every n/s steps, and therefore will work on a “stale” copy of the model that is n/s rounds old, which affects convergence speed. While this is a limitation of the analysis, from the practical perspective, this can be addressed by observing that, due to asynchrony, in terms of wall-clock time, we can think of the s interaction steps between the server and the clients as happening in parallel.

Original: (2020) for FedAvg if we assume that H = Θ( K ) and that s = Θ( n ) ; this reference also provided arguments showing that the dependency in σ and G should be inherent in the heterogenenous data setting that we consider (Karimireddy et al., 2020, Section 3.2).
Revised: Thus, again, in terms of wall-clocktime, it is reasonable to perform the substitution T → sT in the above rate calculation, which indeed suggests that our algorithm is able to obtain speedup with respect to the number of sampled clients s .

Original: In practice, it should be reasonable to assume that H =
Revised: In practice, it should be reasonable to assume that H =

Original: Θ( K ) , that is, that on average each client i will have completed its local steps on the old version of the model
Revised: Θ( K ) , that is, that on average each client i will have completed its local steps on the old version of the model

Original: X i when being contacted: otherwise, the sampling frequency of the server is too high, and prevents clients from making progress on their local optimization, and the server should simply decrease it.
Revised: X i when being contacted: otherwise, the sampling frequency of the server is too high, and prevents clients from making progress on their local optimization, and the server should simply decrease it.

Original: Convergence at the Server.
Revised: Convergence at the Server.

Original: Finally, we show that not only convergence at the server, as opposed to the convergence of the mean of the local models as in Theorem 4.2.
Revised: Finally, we show that not only convergence at the server, as opposed to the convergence of the mean of the local models as in Theorem 4.2.

Original: We get that:
Revised: We get that:

Original: Corollary 4.3.
Revised: Corollary 4.3.

Original: Assume the total number of steps T ≥ Ω( n 4 ) , the learning rate η = n +1 sH √ T , and quantization parameters R = 2 + T 3 d and γ 2 =η
Revised: Assume the total number of steps T ≥ Ω( n 4 ) , the learning rate η = n +1 sH √ T , and quantization parameters R = 2 + T 3 d and γ 2 =

Original: [Equation]
Revised: [Equation]

Original: (cid:17) .

Original: Let H > 0 be the expected number of local steps already performed by a client when interacting with the server.
Revised: Let H > 0 be the expected number of local steps already performed by a client when interacting with the server.

Original: Then, with probability at least 1 − O ( 1 T ) we have that Algorithm 1 converges at the following rate
Revised: Then, with probability at least 1 − O ( 1 T ) we have that Algorithm 1 converges at the following rate

Original: [Equation]
Revised: [Equation]

Original: This corollary yields a very similar bound to our main result, except for the larger dependency between
Revised: This corollary yields a very similar bound to our main result, except for the larger dependency between

Original: T and n , which is intuitively required due to the additional time required for the server to converge to a similar bound to the mean µ t .
Revised: T and n , which is intuitively required due to the additional time required for the server to converge to a similar bound to the mean µ t .

Original: The third term may be significant for large number of nodes n ; however, since it is divided by T (as opposed to √ T ) it can be seen as negligible for moderate n and large T .
Revised: The third term may be significant for large number of nodes n ; however, since it is divided by T (as opposed to √ T ) it can be seen as negligible for moderate n and large T .

Original: The fact that QuAFL can match some of the best known rates for FedAvg under some parameter settings may seem surprising, since our algorithm is asynchronous (in particular, nodes take steps on local, delayed versions of the server model) and also supports communication-compression.
Revised: The fact that QuAFL can match some of the best known rates for FedAvg under some parameter settings may seem surprising, since our algorithm is asynchronous (in particular, nodes take steps on local, delayed versions of the server model) and also supports communication-compression.

Original: 4. O VERVIEW OF THE A NALYSIS
Revised: 4. O VERVIEW OF THE A NALYSIS

Original: The complete analysis is fairly complex, and is provided in full in the Appendix.
Revised: The complete analysis is fairly complex, and is provided in full in the Appendix.

Original: Due to space constraints, we only provide an overview of the proofs, outlining the main intermediate results.
Revised: Due to space constraints, we only provide an overview of the proofs, outlining the main intermediate results.

Original: The first step in the proof is bounding the deviation between the local models and their mean.
Revised: The first step in the proof is bounding the deviation between the local models and their mean.

Original: For this, we introduce the potential function Φ t =
Revised: For this, we introduce the potential function Φ t =

Original: ∥
Revised: ∥

Original: X t − µ t ∥ 2 + (cid:80) ni
Revised: X t − µ t ∥ 2 + (cid:80) ni

Original: =

Revised: =

Original: ∥ X i − µ t ∥ 2 , and we use a load-balancing approach to show that this potential has the following supermartingale-type property:
Revised: ∥ X i − µ t ∥ 2 , and we use a load-balancing approach to show that this potential has the following supermartingale-type property:

Original: Lemma 4.4.
Revised: Lemma 4.4.

Original: For any time step t we have:
Revised: For any time step t we have:

Original: [Equation]
Revised: [Equation]

Original: The intuition behind this result is that potential Φ t will stay well-concentrated around its mean, except for influences from the variance due to local steps (second term) or quantization (third term).
Revised: The intuition behind this result is that potential Φ t will stay well-concentrated around its mean, except for influences from the variance due to local steps (second term) or quantization (third term).

Original: With this in place, the next lemma allows us to track the evolution of the average of the local models, with respect to local step and quantization variance:
Revised: With this in place, the next lemma allows us to track the evolution of the average of the local models, with respect to local step and quantization variance:

Original: Lemma 4.5.
Revised: Lemma 4.5.

Original: For any step t
Revised: For any step t

Original: [Equation]
Revised: [Equation]

Original: In both cases, the upper bound depends on the second moment of the nodes’ local progress (cid:80) i E (cid:13)(cid:13)(cid:13)(cid:101)
Revised: In both cases, the upper bound depends on the second moment of the nodes’ local progress (cid:80) i E (cid:13)(cid:13)(cid:13)(cid:101)

Original: h i (cid:13)(cid:13)(cid:13) 2 .
Revised: h i (cid:13)(cid:13)(cid:13) 2 .

Original: (This is due to the fact that the server contacts s clients, which are chosen uniformly at random.)
Revised: (This is due to the fact that the server contacts s clients, which are chosen uniformly at random.)

Original: Then, our main technical lemma uses properties (1), (2) and (3), to concentrate (cid:80) i E (cid:13)(cid:13)(cid:13)(cid:101)
Revised: Then, our main technical lemma uses properties (1), (2) and (3), to concentrate (cid:80) i E (cid:13)(cid:13)(cid:13)(cid:101)

Original: h
Revised: h

Original: i ( X it ) (cid:13)(cid:13)(cid:13) 2 around the true gradient E ∥∇ f ( µ t ) ∥ 2 , where the expectation is taken over the algorithm’s randomness.
Revised: i ( X it ) (cid:13)(cid:13)(cid:13) 2 around the true gradient E ∥∇ f ( µ t ) ∥ 2 , where the expectation is taken over the algorithm’s randomness.

Original: Lemma 4.6.
Revised: Lemma 4.6.

Original: For any step t , we have that
Revised: For any step t , we have that

Original: [Equation]
Revised: [Equation]

Original: We can then combine Lemmas 4.4 and 4.6 to get an upper bound on the potential with respect to E ∥∇ f ( µ t ) ∥ 2 .
Revised: We can then combine Lemmas 4.4 and 4.6 to get an upper bound on the potential with respect to E ∥∇ f ( µ t ) ∥ 2 .

Original: Summing over steps, we obtain the following:
Revised: Summing over steps, we obtain the following:

Original: Lemma 4.7.
Revised: Lemma 4.7.

Original: [Equation]
Revised: [Equation]

Original: Next, using the L -smoothness of the function f , implied by (1), we can show that
Revised: Next, using the L -smoothness of the function f , implied by (1), we can show that

Original: [Equation]
Revised: [Equation]

Original: Final argument.
Revised: Final argument.

Original: Using the above inequality, and given that E [
Revised: Using the above inequality, and given that E [

Original: [Equation]
Revised: [Equation]

Original: h i ( X it ) , we observe that the sum (cid:80) ni
Revised: we observe that the sum (cid:80) ni

Original: =1 E ⟨∇ f ( µ t ) , µ t +1 − µ t ⟩ can be concentrated around E ∥∇ f ( µ t ) ∥ 2 , in similar fashion as in Lemma 4.6.
Revised: =1 E ⟨∇ f ( µ t ) , µ t +1 − µ t ⟩ can be concentrated around E ∥∇ f ( µ t ) ∥ 2 , in similar fashion as in Lemma 4.6.

Original: Together with Lemma 4.5, this results in the following bound:
Revised: Together with Lemma 4. [Equation] this results in the following bound:

Original: [Equation]
Revised: [Equation]

Revised: [Figure]

Revised: [Figure]

Revised: [Figure]

Original:  For η = ( n + 1) / √ T , as stated in the Theorem, we can use Lemma 4 .
Revised: [Figure] [Figure] [Figure] For η = ( n + 1) / √ T , as stated in the Theorem, we can use Lemma 4 .

Original: 7 to cancel out the terms containing the potential Φ t (after summing up the inequality over T steps).
Revised: 7 to cancel out the terms containing the potential Φ t (after summing up the inequality over T steps).

Original: Replacing these terms, and modulo some additional term wrangling, we obtain the claimed convergence bound.[Figure] [Figure] [Figure]
Revised: Replacing these terms, and modulo some additional term wrangling, we obtain the claimed convergence bound.

Original: [Figure]

Original: [Table]

Original: Quantization Impact.
Revised: Quantization Impact.

Original: Finally, we address the correctness of the quantization technique.
Revised: Finally, we address the correctness of the quantization technique.

Original: We show that the quantization fails with negligible probability:
Revised: We show that the quantization fails with negligible probability:

Original: Lemma 4.8.
Revised: Lemma 4.8.

Original: Let T ≥ Ω( n 3 ) , then for quantization parameters
Revised: Let T ≥ Ω( n 3 ) , then for quantization parameters

Original: R = 2+ T 3 d and γ 2 =
Revised: R = 2+ T 3 d and γ 2 =

Original: [Equation]
Revised: [Equation]

Original: ) we have that the probability of quantization never failing during the entire run of the Algorithm 1 is at least 1 − O (cid:0) 1 T (cid:1) .
Revised: ) we have that the probability of quantization never failing during the entire run of the Algorithm 1 is at least 1 − O (cid:0) 1 T (cid:1) .

Original: Per Lemma 4.1, in order for the communication to fail with negligible probability, we need to show that whenever the server communicates with a client, the two norm of their local models is at most R R d γ .
Revised: Per Lemma 4.1, in order for the communication to fail with negligible probability, we need to show that whenever the server communicates with a client, the two norm of their local models is at most R R d γ .

Original: Hence, we need to use bound E
Revised: Hence, we need to use bound E

Original: [Φ( t )] .
Revised: [Φ( t )] .

Original: The only similar use of this technique was in Nadiradze et al.
Revised: The only similar use of this technique was in Nadiradze et al.

Original: (2021); however, the authors of this reference could benefit from assuming that the second-moment of the gradients was bounded.
Revised: (2021); however, the authors of this reference could benefit from assuming that the second-moment of the gradients was bounded.

Original: Since we make no such assumption here, we need to find a way to bound (cid:80) T − 1 t =

Revised: Since we make no such assumption here, we need to find a way to bound (cid:80) T − 1 t =

Original: E ∥∇ f ( µ t )
Revised: E ∥∇ f ( µ t )

Original: ∥ 2 .
Revised: ∥ 2 .

Original: Fortunately, our main result shows that the gradients are vanishing, so we can take the advantage of the convergence rate and plug it back into Lemma 4 . 7 .
Revised: Fortunately, our main result shows that the gradients are vanishing, so we can take the advantage of the convergence rate and plug it back into Lemma 4 . 7 .

Original: Similarly, due to the Property 3, Lemma 4.1, the number of the bits used by our algorithm, in one communication between the server and a client, depends on the two norm of the distance between their local models.
Revised: Similarly, due to the Property 3, Lemma 4.1, the number of the bits used by our algorithm, in one communication between the server and a client, depends on the two norm of the distance between their local models.

Original: Thus, we can use the bound on (cid:80) T − 1 t =

Revised: Thus, we can use the bound on (cid:80) T − 1 t =

Original: E ∥∇ f ( µ t ) ∥ 2 to show the following.
Revised: E ∥∇ f ( µ t ) ∥ 2 to show the following.

Original: Lemma 4.9.
Revised: Lemma 4.9.

Original: Let T ≥ Ω( n 3 ) , then for quantization parameters
Revised: Let T ≥ Ω( n 3 ) , then for quantization parameters

Original: R = 2+ T 3 d and γ 2 =

Original: [Equation]

Original: [Equation]

Original: [Equation] KG [Equation] ) we have that the expected number of bits used by Algorithm 1 in total is
Revised: R = 2+ T 3 d and γ 2 = η 2 ( R 2 +7) 2 ( σ 2 + 2 KG 2 + f ( µ 0 ) − f ∗ L ) we have that the expected number of bits used by Algorithm 1 in total is

Original: O ( sT ( d log( n ) + log( T )) .
Revised: O ( sT ( d log( n ) + log( T )) .

Original: We note that the communication cost per step is also asymptotically optimal, modulo the multiplicative log n and additive log T terms, required to ensure error probability 1 − O (1 /T ) .
Revised: We note that the communication cost per step is also asymptotically optimal, modulo the multiplicative log n and additive log T terms, required to ensure error probability 1 − O (1 /T ) .

Original:  E XPERIMENTAL R ESULTS
Revised:  E XPERIMENTAL R ESULTS

Original: Experimental Setup and Goals.
Revised: Experimental Setup and Goals.

Original: We implemented our algorithm in Pytorch in order to train neural networks for image classification tasks, specifically residual CNNs (He et al., 2016) on the
Revised: We implemented our algorithm in Pytorch in order to train neural networks for image classification tasks, specifically residual CNNs (He et al., 2016) on the

Original: MNIST (LeCun & Cortes, 2010), Fashion MNIST (Xiao et al., 2017), CIFAR-10 (Krizhevsky &
Revised: MNIST (LeCun & Cortes, 2010), Fashion MNIST (Xiao et al., 2017), CIFAR-10 (Krizhevsky &

Original: Hinton, 2009) and CelebA (Liu et al., 2015) datasets, in the rigorous FL setup of LEAF (Caldas et al., 2018).
Revised: Hinton, 2009) and CelebA (Liu et al., 2015) datasets, in the rigorous FL setup of LEAF (Caldas et al., 2018).

Original: The model and dataset details are presented in the Appendix.
Revised: Details are presented in the Appendix.

Original: We aim to validate our analysis relative to the impact of various parameters.
Revised: We aim to validate our analysis relative to the impact of various parameters.

Original: We omit error bars for readability, as we observed that the variance is very low.
Revised: We omit error bars, as we observed that the variance is very low.

Original: Specifically,some of the basic parameter we examine are n , s , and K , which have the same meaning as in our theoretical analysis.
Revised: Specifically, the parameters we examine are n , s , and K , which have the same meaning as in our theoretical analysis.

Original: Our experiments are described by ( n, s, K, b ) , where b is the number of bits for quantization.
Revised: Our experiments are described by ( n, s, K, b ) , where b is the number of bits for quantization.

Original: In addition, we define swt as the server waiting time between two consecutive calls, and the server interaction time, sit , as the amount of time that server needs to send and receive necessary data.
Revised: In addition, we define swt as the server waiting time between two consecutive calls, and the server interaction time, sit , as the amount of time that server needs to send and receive necessary data.

Original: We assume a server and n clients .
Revised: We assume a server and n clients .

Original: The training dataset is distributed among clients so that each has access to a fixed 1 /n partition of the training data.
Revised: The training dataset is distributed among clients so that each has access to a fixed 1 /n partition of the training data.

Original: We track the accuracy of the server’s model on an unseen validation dataset.
Revised: We track the accuracy of the server’s model on an unseen validation dataset.

Original: We measure loss and accuracy of the model with respect to simulation time and total gradient steps performed by clients .
Revised: We measure loss and accuracy of the model with respect to simulation time and total gradient steps performed by clients .

Original: In each round, the server chooses s clients uniformly at random.
Revised: In each round, the server chooses s clients uniformly at random.

Original: It then sends its model to those clients and asks for their current local models.
Revised: It then sends its model to those clients and receives their current local models.

Original: Each client will have taken a maximum of K local steps by the time it is contacted by the server.
Revised: Each client will have taken a maximum of K local steps by the time it is contacted by the server.

Original: We update the both client and server models following QuAFL, and then increase the server time by sit .
Revised: We update the both client and server models following QuAFL, and then increase the server time by sit .

Original: The server then waits for another interval of server waiting time (swt) to make its next call.
Revised: The server then waits for another interval of server waiting time (swt) to make its next call.

Original: All communication is compressed, as models get encoded in their source and decoded in their destination.
Revised: Unless otherwise stated, communication is compressed.

Original: We differentiate between two types of timing experiments: uniform timing experiments assume all clients take the same amount of time for a gradient step, while in non-uniform timing experimentswe differentiate clients to beeither fast or slow .
Revised: We differentiate between two types of timing experiments: uniform timing experiments assume all clients take the same amount of time for a gradient step; non-uniform timing experiments differentiate clients to be fast or slow .

Original: Specifically, the length of each client step is taken to be a random variable X ∼ exponential ( λ ) , where λ is 1 / 2 for fast clients and 1 / 8 for slow clients; the expected runtime E ( X ) would be 2 and 8 , respectively.
Revised: Specifically, the length of each client step is taken to be a random variable X ∼ exp ( λ ) , where λ is 1 / 2 for fast clients and 1 / 8 for slow clients; the expected runtime E ( X ) would be 2 and 8 , respectively.

Original: In eachtiming experiment, we assumed 30% of clients to be slow .
Revised: In each experiment, we assumed 30% of clients to be slow .

Original: In our first experiment, presented in Figure 1, we examine the impact of the number of  peers ssampled by the algorithm, when training ResNet18 on the CelebA dataset, wherewe assumed 30% of clients to be slow.
Revised: Figure 1 examines the impact of the number of sampled peers s when training ResNet18 on the CelebA dataset, where 30% of clients are slow.

Original: We first observe that convergence speed clearly follows the ordering of the number of peers s , confirming our analysis.
Revised: We first observe that convergence speed clearly follows the ordering of the number of peers s , confirming our analysis.

Original: Interestingly,the interaction and step timings in this experiment are set up so that there is a 27% probability that a slow client will not have taken any steps when interacting with the server.
Revised: Interestingly, timings in this experiment are set up so that there is a 27% probability that a slow client will not have taken any steps when interacting with the server.

Original: (We validated this proportion experimentally; this probability decreases as s increases.).
Revised: (This probability decreases as s increases.).

Original: Thus, this experiment also shows that QuAFL is indeed robust to such slow clients, although their proportion can impact convergence.
Revised: Thus, this experiment also shows that QuAFL is indeed robust to such slow clients, although their proportion can impact convergence.

Original: In our second experiment (Figure 2), we examine the impact of the number of quantization bits b on the convergence of the algorithm. Again, we observe that increasing the number of bits from 8 to 10 improves convergence; however, there isa clear staturationoccurring after 10 bits, after which the algorithm converges at the same rate as the full-precision baseline.
Revised: Figure 2 examines the impact of the number of quantization bits b , showing that increasing b from 8 to 10 improves convergence; however, there is clear staturation after 10 bits. In Figure 3 we examine the loss convergence of FedAvg and QuAFL versus simulated execution time , in a system with 20 clients, out of which 25% are slow. (The Baseline is a single slow node that performs an optimization step per round.)

Revised: Here, it is evident that QuAFL asynchrony allows it to provide a faster convergence in terms of wall-clock time, than its synchronous counterparts.

Original: Inour third experiment, provided in Figure 3, we examine the impact of different types of averaging on the convergence of the basic QuAFL pattern, on the CelebA dataset, with n = 100 clients.
Revised: In Figure 4, we examine the impact of different types of averaging on the convergence of the basic QuAFL pattern, on the CelebA dataset, with n = 100 clients.

Original: All variants execute in the same setup, with individually-tuned hyper-parameters.
Revised: All variants execute in the same setup, with individually-tuned hyper-parameters.

Original: We clearly observe that the variant where averaging is applied both at the server and at the client performs the best, whichindirectly validates ouralgorithmic choices. 
Revised: We clearly observe that the variant where averaging is applied both at the server and at the client performs the best, which validates our choices. In

Original: Finally, in Figure 4 we examine the validation accuracy ensured by FedAvg and QuAFLversus the simulated execution time , in a system with 20 clients, out of which 25% are slow.
Revised: Figure 5, we compare the convergence of QuAFL with the lattice quantizer, relative to QuAFL using the standard QSGD quantizer (Alistarh et al., 2017a).

Original: (The Baseline is a single slow node that  performs an optimization step per round.)
Revised: We note that using QSGD is not theoreticallyjustified, and in fact we had to perform careful tuning in order to obtain stable convergence for this variant. It is interesting that QuAFL appears to support this, albeit at the cost of slower convergence. Finally, in Figure 6, we compare QuAFL convergence relative to FedBuff, a state-of-the-art asynchronous FL protocol (Nguyen et al., 2022a), which performs buffering of client messages at the server, updating the server model as soon as s messages, with K local updates each, are in the server buffer. Since the timing model of FedBuff is different, we compare convergence in terms of total number of gradient steps taken by clients, without quantization.

Original: Here, it becomes evident thatthe asynchronous nature of QuAFL communication allows it to provide a faster convergence speed in terms of wall-clock time, than its synchronous counterpart.
Revised: We observe that QuAFL converges faster: our analysis suggests that this is because QuAFL takes into account partial progress by slow clients, whereas in FedBuff slow clients constantly contribute less significantly to the server updates.

Original: We present additional experimental results in the Appendix, specifically on higher node counts (up to 300 ),  as well as  other tasks.
Revised: We present additional experimental results in the Appendix, specifically on higher node counts (up to 300 ), full-convergence experiments, as well as across all other tasks.

Original:  C ONCLUSIONS AND L IMITATIONS
Revised:  C ONCLUSIONS AND L IMITATIONS

Original: We have provided the first variant of FedAvg which incorporates both asynchronous and compressed communication, and have shown that this algorithm can still provide good convergence guarantees.
Revised: We have provided the first variant of FedAvg which incorporates both asynchronous and compressed communication, and have shown that this algorithm can still provide good convergence guarantees.

Original: Our analysis should be extensible to more complex federated optimizers, such as gradient tracking, e.g. (Haddadpour et al., 2021), controlled averaging (Karimireddy et al., 2020), or variance-reduced variants (Gorbunov et al., 2021).
Revised: Our analysis should be extensible to more complex federated optimizers, such as gradient tracking, e.g. (Haddadpour et al., 2021), controlled averaging (Karimireddy et al., 2020), or variance-reduced variants (Gorbunov et al., 2021).

Original: Our work has the following limitations.
Revised: Our work has the following limitations.

Original: First, this version of the analysis requires the expected number of local steps H to be the same across all devices.

Original: We believe that this can be addressed either by modifying the objective, or by de-biasing via sampling.

Original: Second, our algorithm has an optimal convergence rate when H =
Revised: First, our algorithm has an optimal convergence rate when H =

Original: Θ( K ) , which we believe is natural due to asynchrony.
Revised: Θ( K ) , which we believe is natural due to asynchrony.

Original: Third, Assumption (3) does impose restrictions on the way data is distributed among the clients.
Revised: Second, this version of the analysis requires the expected number of local steps H to be the same across all devices.

Original: We believe that it is necessary for the convergence of our algorithm since we do not employ variance-reduction or weighted sampling techniques.
Revised: We believe that this can be addressed either by modifying the objective, or by de-biasing via sampling, and plan to investigate it in future work, together with validation on real-world deployments.

Original:  R EPRODUCIBILITY S TATEMENT
Revised:  R EPRODUCIBILITY S TATEMENT

Original: All the code required to reproduce our experimental setup and our experiments is available at https://anonymous.4open.science/r/QuAFL-Anonymous 
Revised: All the code required to reproduce our experimental setup and our experiments is available at https://anonymous.4open.science/r/QuAFL-Anonymous .

Original: 1 Introduction
Revised: 1 Introduction

Original: 2 Related Work 

Revised: 2 Related Work

Original: The Algorithm 3.
Revised: The Algorithm 3.

Original: System Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: System Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: Algorithm Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: Algorithm Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: 4 Convergence Analysis 4.
Revised: 4 Convergence Analysis 4.

Original: Analytical Assumptions . .
Revised: Analytical Assumptions . .

Original: Main Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: Main Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: Overview of the Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: Overview of the Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: 5 Experimental Results 6 Conclusions and Limitations 7 Reproducibility Statement
Revised: 5 Experimental Results 6 Conclusions and Limitations 7 Reproducibility Statement

Original: A Experimental setup
Revised: A Experimental setup

Original: A.1 Hyper-parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: A.1 Hyper-parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: A.2 Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: A.2 Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: A.3 Datasets and Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: A.3 Datasets and Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: A.4 Results on Fashion MNIST (FMNIST) . . . . . . . . . . . . . . . . . . . . . . . .
Revised: A.4 Results on Fashion MNIST (FMNIST) . . . . . . . . . . . . . . . . . . . . . . . .

Original: A.5 Results on CIFAR-10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: A.5 Results on CIFAR-10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: B The Complete Analysis
Revised: B The Complete Analysis

Original: B.1 Overview and Notation . .
Revised: B.1 Overview and Notation . .

Original: B.2 Properties of Local Steps
Revised: B.2 Properties of Local Steps

Original: B.3 Upper Bounding Potential Functions
Revised: B.3 Upper Bounding Potential Functions

Original: B.4 Convergence
Revised: B.4 Convergence

Original: A E XPERIMENTAL SETUP
Revised: A E XPERIMENTAL SETUP

Original: In this section, we describe our experimental setup in detail.
Revised: In this section, we describe our experimental setup in detail.

Original: We begin by defining the hyperparameters which control the behavior of QuAFL and FedAvg.
Revised: We begin by defining the hyperparameters which control the behavior of QuAFL and FedAvg.

Original: Then, we proceed by carefully describing the way in which we simulated each of the algorithms.
Revised: Then, we proceed by carefully describing the way in which we simulated each of the algorithms.

Original: Finally, we detail the datasets, tasks, and models used for our experiments.
Revised: Finally, we detail the datasets, tasks, and models used for our experiments.

Original: A. H YPER - PARAMETERS
Revised: A. H YPER - PARAMETERS

Original: We first define our hyper-parameters; in the later sections, we will examine their impact on algorithm behavior through ablation studies.
Revised: We first define our hyper-parameters; in the later sections, we will examine their impact on algorithm behavior through ablation studies.

Original: n : Number of the clients.
Revised: n : Number of the clients.

Original: s : Number of clients interacting with the server at each step.
Revised: s : Number of clients interacting with the server at each step.

Original: K :
Revised: K :

Original: In QuAFL , this is the maximum number of allowed local steps by each client between two server calls.
Revised: In QuAFL , this is the maximum number of allowed local steps by each client between two server calls.

Original: In FedAvg , this is the number of local steps performed by each client upon each server call.
Revised: In FedAvg , this is the number of local steps performed by each client upon each server call.

Original: b : Number of bits used to send a coordinate after quantization.
Revised: b : Number of bits used to send a coordinate after quantization.

Original: swt : Server waiting time, i.e. the amount of time that server waits between two consecutive calls.
Revised: swt : Server waiting time, i.e. the amount of time that server waits between two consecutive calls.

Original: sit : Server interaction time, i.e. the amount of time that server needs to send and receive necessary data (excluding computation time).
Revised: sit : Server interaction time, i.e. the amount of time that server needs to send and receive necessary data (excluding computation time).

Original: A. S IMULATION
Revised: A. S IMULATION

Original: We attempt to simulate a realistic FL deployment scenario, as follows.
Revised: We attempt to simulate a realistic FL deployment scenario, as follows.

Original: We assume a server and n clients , each of which initially has a model copy.
Revised: We assume a server and n clients , each of which initially has a model copy.

Original: The training dataset is distributed among the clients so that each of them has access to 1 /n of the training data.
Revised: The training dataset is distributed among the clients so that each of them has access to 1 /n of the training data.

Original: We track the performance of each algorithm by evaluating the server’s model, on an unseen validation dataset.
Revised: We track the performance of each algorithm by evaluating the server’s model, on an unseen validation dataset.

Original: We measure loss and accuracy of the model with respect to simulation time , server steps , and total local steps performed by clients .
Revised: We measure loss and accuracy of the model with respect to simulation time , server steps , and total local steps performed by clients .

Original: These setups so far were common between QuAFL and FedAvg.
Revised: These setups so far were common between QuAFL and FedAvg.

Original: In the following, we are going to describe their specifications and differences.
Revised: In the following, we are going to describe their specifications and differences.

Original: QuAFL:
Revised: QuAFL:

Original: Upon each server call, the server chooses s clients uniformly at random.
Revised: Upon each server call, the server chooses s clients uniformly at random.

Original: It then sends its model to those clients and asks for their current local models.
Revised: It then sends its model to those clients and asks for their current local models.

Original: (Recall that clients send their model immediately to the server.)
Revised: (Recall that clients send their model immediately to the server.)

Original: Each of the clients will have taken a maximum of K local steps by the time it is contacted by the server.
Revised: Each of the clients will have taken a maximum of K local steps by the time it is contacted by the server.

Original: The server then replaces its model with a carefully-computed average over the received models and its current model.
Revised: The server then replaces its model with a carefully-computed average over the received models and its current model.

Original: This process increases time on the server by the server interaction time (sit) .
Revised: This process increases time on the server by the server interaction time (sit) .

Original: The server then waits for another interval of server waiting time (swt) to make its next call.
Revised: The server then waits for another interval of server waiting time (swt) to make its next call.

Original: The s receiving clients replace their model with the weighted average between their current model and the received server’s model.
Revised: The s receiving clients replace their model with the weighted average between their current model and the received server’s model.

Original: Since each client performs local steps from its last interaction time until the current server time, nodes are effectively executing asynchronously.
Revised: Since each client performs local steps from its last interaction time until the current server time, nodes are effectively executing asynchronously.

Original: Moreover, note that communication is compressed, as all the models get encoded in their source and decoded in their destination.
Revised: Moreover, note that communication is compressed, as all the models get encoded in their source and decoded in their destination.

Original: Quantization: To have a lightweight but efficient communication between clients and the server, we use the well-known lattice quantization (Davies et al., 2021).
Revised: Quantization: To have a lightweight but efficient communication between clients and the server, we use the well-known lattice quantization (Davies et al., 2021).

Original: Using this method, we send b instead of 32 bits for each scalar dimension.
Revised: Using this method, we send b instead of 32 bits for each scalar dimension.

Original: Informally, each 32-bit number maps to one of the 2 b quantized levels and can be sent using b bits only.
Revised: Informally, each 32-bit number maps to one of the 2 b quantized levels and can be sent using b bits only.

Original: The encoded number can then be decoded to a sufficiently close number at the destination, following the quantization protocol.
Revised: The encoded number can then be decoded to a sufficiently close number at the destination, following the quantization protocol.

Original: FedAvg: In the beginning of each round, server chooses s clients randomly, and sends its current model to them.
Revised: FedAvg: In the beginning of each round, server chooses s clients randomly, and sends its current model to them.

Original: Each of those clients receives the model, uncompressed, and performs exactly K local steps using this model as the starting point, and then sends back the resulting model to the server.
Revised: Each of those clients receives the model, uncompressed, and performs exactly K local steps using this model as the starting point, and then sends back the resulting model to the server.

Original: The server then computes the average of the received models and adopts it as its model.
Revised: The server then computes the average of the received models and adopts it as its model.

Original: By this synchronous structure, in each round, the server must wait for the slowest client to complete its local steps plus an extra sit for the communication time.
Revised: By this synchronous structure, in each round, the server must wait for the slowest client to complete its local steps plus an extra sit for the communication time.

Original: After completing each round, the server starts the next call immediately, that means swt = 0 in FedAvg.
Revised: After completing each round, the server starts the next call immediately, that means swt = 0 in FedAvg.

Original: Timing Experiments.
Revised: Timing Experiments.

Original: We differentiate between two types of timing experiments.
Revised: We differentiate between two types of timing experiments.

Original: Uniform timing experiments, presented in the paper body, assume all clients take the same amount of time for a
Revised: Uniform timing experiments, presented in the paper body, assume all clients take the same amount of time for a

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: gradient step.
Revised: gradient step.

Original: However, in real-world setups, different devices may require different amounts of time to perform a single local step.
Revised: However, in real-world setups, different devices may require different amounts of time to perform a single local step.

Original: This is one of the main disadvantages of synchronous federated optimization algorithms.
Revised: This is one of the main disadvantages of synchronous federated optimization algorithms.

Original: To demonstrate how this fact affects the experiments, in our Non-uniform timing experiments we differentiate clients to be either fast or slow .
Revised: To demonstrate how this fact affects the experiments, in our Non-uniform timing experiments we differentiate clients to be either fast or slow .

Original: The length of each local step can be characterized as a memoryless time event.
Revised: The length of each local step can be characterized as a memoryless time event.

Original: Therefore, the length of each local step can be defined by a random variable X ∼ exponential ( λ ) .
Revised: Therefore, the length of each local step can be defined by a random variable X ∼ exponential ( λ ) .

Original: The parameter λ is 1 / 2 for fast clients and 1 / 8 for slow clients; the expected runtime E ( X ) would be 2 and 8 , respectively.
Revised: The parameter λ is 1 / 2 for fast clients and 1 / 8 for slow clients; the expected runtime E ( X ) would be 2 and 8 , respectively.

Original: In each timing experiment, we assumed only one fourth of clients to be slow .
Revised: In each timing experiment, we assumed only one fourth of clients to be slow .

Original: A. D ATASETS AND M ODELS
Revised: A. D ATASETS AND M ODELS

Original: We used Pytorch to manage the training process in our algorithm.
Revised: We used Pytorch to manage the training process in our algorithm.

Original: We have trained neural networks for image classification tasks on three well-known datasets, MNIST , Fashion MNIST , and CIFAR-10 .
Revised: We have trained neural networks for image classification tasks on three well-known datasets, MNIST , Fashion MNIST , and CIFAR-10 .

Original: For all the datasets, we used the default train/test split of the dataset for our training/validation dataset.
Revised: For all the datasets, we used the default train/test split of the dataset for our training/validation dataset.

Original: In the following, we describe the model architecture and the training hyper-parameters used to train on each of these datasets.
Revised: In the following, we describe the model architecture and the training hyper-parameters used to train on each of these datasets.

Original: MNIST:
Revised: MNIST:

Original: We used SGD optimizer with constant lr = 0 .
Revised: We used SGD optimizer with constant lr = 0 .

Original: 5 in all the training process.
Revised: 5 in all the training process.

Original: We used a two-layer MLP architecture with (784,32,10) nodes in its layers respectively.
Revised: We used a two-layer MLP architecture with (784,32,10) nodes in its layers respectively.

Original: We used batch size 128 in each client’s SGD step.
Revised: We used batch size 128 in each client’s SGD step.

Original: Fashion MNIST:
Revised: Fashion MNIST:

Original: Although this dataset has the same sample size and number of classes as MNIST , obtaining competitive performance on it requires a more complicated architecture.
Revised: Although this dataset has the same sample size and number of classes as MNIST , obtaining competitive performance on it requires a more complicated architecture.

Original: Therefore, we used a CNN model to train on this model and demonstrated the performance of our algorithm in a non-convex task.
Revised: Therefore, we used a CNN model to train on this model and demonstrated the performance of our algorithm in a non-convex task.

Original: To optimize the models, we used Adam optimizer with constant lr = 0 .
Revised: To optimize the models, we used Adam optimizer with constant lr = 0 .

Original: 001 and batch size 100.
Revised: 001 and batch size 100.

Original: CIFAR-10:
Revised: CIFAR-10:

Original: To load this dataset, we used data augmentation and normalization.
Revised: To load this dataset, we used data augmentation and normalization.

Original: For this task, we trained ResNet20 models.
Revised: For this task, we trained ResNet20 models.

Original: Moreover, the SGD optimizer with constant lr = 0 .
Revised: Moreover, the SGD optimizer with constant lr = 0 .

Original: 03 is used to in the training process.
Revised: 03 is used to in the training process.

Original: The batch size 64/200 is used for training/validation.
Revised: The batch size 64/200 is used for training/validation.

Original: A. R ESULTS ON F ASHION MNIST (FMNIST)
Revised: A. R ESULTS ON F ASHION MNIST (FMNIST)

Original: We begin by validating our earlier results, presented in the paper body, for the slightly more complex
Revised: We begin by validating our earlier results, presented in the paper body, for the slightly more complex

Original: FMNIST dataset, and on a convolutional model.
Revised: FMNIST dataset, and on a convolutional model.

Original: In Figures 5 and 6 we examine the impact of the parameters K and s , respectively, on the total number of interaction rounds at the server, to reach a certain training loss.
Revised: In Figures 7 and 8 we examine the impact of the parameters K and s , respectively, on the total number of interaction rounds at the server, to reach a certain training loss.

Original: As expected, we noticethat higher K and s improve the convergence behavior of the algorithm. In Figures 7 we examine
Revised: As expected, we notice

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: [Figure] 
Revised: [Figure] [Figure] [Figure]

Original: [Figure]
Revised: [Figure]

Revised: that higher K and s improve the convergence behavior of the algorithm.

Original:  the impact of the server waiting time on the convergence of the algorithm relative to the number of server rounds.
Revised: In Figures 9 we examine the impact of the server waiting time on the convergence of the algorithm relative to the number of server rounds.

Original: Again, we notice that a higher server waiting time improves convergence, as it allows the server to take advantage of additional local steps performed at the clients, as predicted by our analysis.
Revised: Again, we notice that a higher server waiting time improves convergence, as it allows the server to take advantage of additional local steps performed at the clients, as predicted by our analysis.

Original: (Higher swt means higher average number of steps completed H 
Revised: (Higher swt means higher average number of steps completed H .)

Original: [Figure] Next, we examine the convergence, again in terms of number of optimization “rounds” at the server, between the sequential Baseline, FedAvg, and QuAFL.
Revised: Next, we examine the convergence, again in terms of number of optimization “rounds” at the server, between the sequential Baseline, FedAvg, and QuAFL.

Original: As expected, the Baseline is faster to converge than FedAvg, which in turn is faster than QuAFL in this measure.
Revised: As expected, the Baseline is faster to converge than FedAvg, which in turn is faster than QuAFL in this measure.

Original: Specifically, the difference between
Revised: Specifically, the difference between

Original: QuAFL and the other algorithms comes because of the fact that, in our algorithm, nodes operate on old variants of the model at every step, which slows down convergence.
Revised: QuAFL and the other algorithms comes because of the fact that, in our algorithm, nodes operate on old variants of the model at every step, which slows down convergence.

Original: Next, we examine convergence in terms of actual time, in the heterogeneous setting in which 25% of the clients are slow.
Revised: Next, we examine convergence in terms of actual time, in the heterogeneous setting in which 25% of the clients are slow.

Original: In Figure 9, we observe the validation accuracy ensured by various algorithms relative to the simulated execution time, whereas in Figure 10 we observe the training loss versus the same metric.
Revised: In Figure 11, we observe the validation accuracy ensured by various algorithms relative to the simulated execution time, whereas in Figure 12 we observe the training loss versus the same metric.

Original: (We assume that, in Baseline , a single node acts as both the client and the server, and that this node is slow, i.e. has higher per-step times.)
Revised: (We assume that, in Baseline , a single node acts as both the client and the server, and that this node is slow, i.e. has higher per-step times.)

Original: To further support the robustness of our algorithm in regimes with large number of clients, we conducted an experiment with n = 300 clients and s = 30 peers interacting with the server at each step.
Revised: To further support the robustness of our algorithm in regimes with large number of clients, we conducted an experiment with n = 300 clients and s = 30 peers interacting with the server at each step.

Original: The validation accuracy and loss versus time regarding the mentioned experiment plotted in Figure 11 and Figure 12 respectively.
Revised: The validation accuracy and loss versus time regarding the mentioned experiment plotted in Figure 13 and Figure 14 respectively.

Original: We observe that, importantly, if time is taken into account rather than the number of server rounds, QuAFL can provide notable speedups in these metrics.
Revised: We observe that, importantly, if time is taken into account rather than the number of server rounds, QuAFL can provide notable [Figure] [Figure] [Figure]

Original:  This is specifically because of its asynchronous communication patters, which allow it to complete rounds faster, without having to always wait for the slow nodes to complete their local computation.
Revised: [Figure] speedups in these metrics. This is specifically because of its asynchronous communication patters, which allow it to complete rounds faster, without having to always wait for the slow nodes to complete their local computation.

Original: While this behaviour is simulated, we believe that this reflects the algorithm’s practical potential.
Revised: While this behaviour is simulated, we believe that this reflects the algorithm’s practical potential.

Revised: Finally, Figure 15 shows that all methods can reach the maximum accuracy for this dataset/model combination (for the SGD baseline, this occurs later), although QuAFL is the fastest to do so in terms of wall-clock time.

Revised: Our last experiment in Figure 16 examines whether naive QSGD quantization of the transmitted updates in FedBuff (Nguyen et al., 2022a) can converge at a good rate, relative to QuAFL at the same quantization ratio.

Revised: We find that this is not the case: first, we remark that, with careful tuning of the learning rate, FedBuff can indeed converge.

Revised: We believe that this is because of the specific application: the norm of the model and updates in DNNs tends to be small, and therefore the quantization error induced by direct QSGD stochastic quantization is also manageable.

Revised: However, we observe a clear loss of convergence for the FedBuff + QSGD algorithm in this case, relative to QuAFL, which we ascribe to the fact that we are essentially running a heuristic.

Original: A. R ESULTS ON CIFAR- 
Revised: A. R ESULTS ON CIFAR-

Original: We now present results for a standard image classification task on the CIFAR-10 dataset, using a
Revised: We now present results for a standard image classification task on the CIFAR-10 dataset, using a

Original: ResNet20 model (He et al., 2016).
Revised: ResNet20 model (He et al., 2016).

Original: Figures 13 and 14 show the decrease in training loss versus the number of server steps (or rounds) for different values of K and s respectively.
Revised: Figures 17 and 18 show the decrease in training loss versus the number of server steps (or rounds) for different values of K and s respectively.

Original: As our theory suggests, increasing K and s leads to an improvement in the convergence rate of the system.
Revised: As our theory suggests, increasing K and s leads to an improvement in the convergence rate of the system.

Original: Figure 15 demonstrates the impact of the number of quantization bits b , on the convergence behaviour of the algorithm.
Revised: Figure 19 demonstrates the impact of the number of quantization bits b , on the convergence behaviour of the algorithm.

Original: According to the definition of b , increasing the number of quantization bits improves the communication accuracy.
Revised: According to the definition of b , increasing the number of quantization bits improves the communication accuracy.

Original: Thus, as it can be seen in the graph, higher values of b enhance the convergence relative to the number of server [Figure] [Figure] [Figure]
Revised: Thus, as it can be seen in the graph, higher values of b enhance the convergence relative to the number of server steps.

Original: [Figure]

Original: [Figure] [Figure] steps. Finally, Figure 16 shows the impact of the server interaction frequency, again controlled via the timeout parameter swt 
Revised: Finally, Figure 20 shows the impact of the server interaction frequency, again controlled via the timeout parameter swt , on the algorithm’s convergence.

Original: [Figure]

Original: on the algorithm’s convergence.

Original: It is apparent that a very high interaction frequency can slow the algorithm down, by not allowing it to take advantage of the clients’ local steps.
Revised: It is apparent that a very high interaction frequency can slow the algorithm down, by not allowing it to take advantage of the clients’ local steps.

Original: In Figures 17 and [Figure] we examine the validation accuracy and loss [Figure]
Revised: In Figures 21 and 22, we examine the validation accuracy and loss, respectively, ensured by various algorithms versus the simulated execution time.

Original: respectively

Original: [Figure]

Original: ensured by various algorithms versus the simulated execution time.

Original: (As in the F-MNIST experiments, we assumed the Baseline to be a single slow node that performs an optimization step per round
Revised: (As in the F-MNIST experiments, we assumed the Baseline to be a single slow node that performs an optimization step per round.)

Original: [Figure] Again, the asynchronous nature of QuAFL provides a faster convergence rate than its synchronous counterparts; which can be clearly seen in the mentioned figures. 
Revised: Again, the asynchronous nature of QuAFL provides a faster convergence rate than its synchronous counterparts; which can be clearly seen in the mentioned figures. [Figure] [Figure]

Original: B T HE C OMPLETE A NALYSIS B. O VERVIEW AND N OTATION
Revised: B T HE C OMPLETE A NALYSIS B. O VERVIEW AND N OTATION

Original: Recall that X t denotes the model of the server at step t [Figure] and X i is the local model of client i after its last interaction with the server.
Revised: Recall that X t denotes the model of the server at step t , and X i is the local model of client i after its last interaction with the server.

Original: Also, (cid:101) h
Revised: Also, (cid:101) h

Original: i is the sum of local gradient steps for model X i since its last interaction with the server.
Revised: i is the sum of local gradient steps for model X i since its last interaction with the server.

Original: For the convergence analysis, local steps of the clients that are not selected by the server don’t have any effect on the server or other clients.
Revised: For the convergence analysis, local steps of the clients that are not selected by the server don’t have any effect on the server or other clients.

Original: Therefore we do not need to assume that clients are doing their local steps asynchronous, and we can assume that all clients run their local gradient steps after the server contacts them.
Revised: Therefore we do not need to assume that clients are doing their local steps asynchronous, and we can assume that all clients run their local gradient steps after the server contacts them.

Original: The only thing that we should consider is the randomness of the server selecting the clients, and the fact that the server can contact nodes before they have finished their K steps.
Revised: The only thing that we should consider is the randomness of the server selecting the clients, and the fact that the server can contact nodes before they have finished their K steps.

Original: For this purpose, we assume that their number of steps is a random number H it with mean H .
Revised: For this purpose, we assume that their number of steps is a random number H it with mean H .

Original: To show the analysis in this setting, we introduce new notations that consider the server round.
Revised: To show the analysis in this setting, we introduce new notations that consider the server round.

Original: To this end, we use X it as the value of X i when the server is running its t th iteration, And (cid:101) h i,t for the sum of local steps at this time.
Revised: To this end, we use X it as the value of X i when the server is running its t th iteration, And (cid:101) h i,t for the sum of local steps at this time.

Original: We show each local step q with a superscript.
Revised: We show each local step q with a superscript.

Original: Formally, we have (cid:101) h 

Revised: Formally, we have (cid:101) h

Original: i,t = 0 .
Revised: i,t = 0 .

Original: and for 1 ≤ q ≤ H it let: 
Revised: and for 1 ≤ q ≤ H it let: (cid:101) h qi,t = (cid:101) g

Original: [Equation]
Revised: i ( X it − q − 1 (cid:88) s = η (cid:101) h si,t ) , and (cid:101) h i,t = H it (cid:88) q = (cid:101) h qi,

Original: and
Revised: t

Original: [Equation] Further , for 1 ≤ q ≤ H it , let 
Revised: Further , for 1 ≤ q ≤ H it , let h q i,t = E [ (cid:101) g

Original: [Equation]
Revised: i ( X it − q − 1 (cid:88) s = η (cid:101) h si,t )] = ∇ f ( X it − q − 1 (cid:88) s =

Original:  be the expected value of (cid:101) h qi,t taken over the randomness of the stochastic gradient (cid:101) g i .
Revised: η (cid:101) h si,t ) be the expected value of (cid:101) h qi,t taken over the randomness of the stochastic gradient (cid:101) g i .

Original: Also, we have: h i [Equation] t =
Revised: Also, we have: h i,t =

Original: [Equation]

Original:  it [Equation] h [Equation]
Revised: H it (cid:88) q = h qi,t

Original: B. P ROPERTIES OF L OCAL S TEPS
Revised: B. P ROPERTIES OF L OCAL S TEPS

Original: Lemma B.1.
Revised: Lemma B.1.

Original: For any agent i and step t
Revised: For any agent i and step t

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Revised: [Equation]

Original: [Equation]
Revised: [Equation]

Original: the rest of the proof is done by induction, and assuming η < 1 4 LK 2 .
Revised: the rest of the proof is done by induction, and assuming η < 1 4 LK 2 .

Original: Lemma 4.6.
Revised: Lemma 4.6.

Original: For any step t , we have that
Revised: For any step t , we have that

Original: [Equation]
Revised: [Equation]

Original: E

Original: [Equation]

Original: Proof.
Revised: Proof.

Original: Using lemma B.
Revised: Using lemma B.

Original: [Equation]
Revised: [Equation]

Original: E ∥
Revised: h ] h h (cid:88) q =

Original: [Equation] ≤ nKσ [Equation]
Revised: E ∥ h qi,t ∥≤ nKσ 2 + n (cid:88) i = K(cid:32)

Original: n
Revised: σ

Original: [Equation]
Revised: K 2 + 8 L 2 E ∥ X it − µ t ∥ 2 + 4 E ∥∇ f i ( µ t ) ∥(cid:33) ≤ 2 nKσ 2 + n (cid:88) i = K(cid:32) 8 L 2 E ∥

Revised: X it − µ t ∥ 2 + 4 E ∥∇ f i ( µ t ) ∥(cid:33) ≤ 2 nKσ 2 + 8 L 2 K 2 E [Φ t ] + 4 nK 2 G 2 + 4 nK 2 B 2 E ∥∇ f ( µ t ) ∥ 2 .

Original: Lemma B.2.
Revised: Lemma B.2.

Original: For any local step 1 ≤ q , and agent 1 ≤ i ≤ n and step t
Revised: For any local step 1 ≤ q , and agent 1 ≤ i ≤ n and step t

Original: E ∥∇ [Equation]
Revised: E ∥∇ f i ( µ t ) − h qi,t ∥ 2 ≤ 4 L 2 η 2 q 2 σ 2 + 4 L 2 E ∥ X it − µ t ∥ 2 + 8 L 2 η 2 q 2 E ∥∇ f i ( µ t ) ∥ 2 .

Original: Proof.
Revised: Proof.

Original: E ∥∇ f [Equation] q − {+h qi,t ∥ 
+}
Revised: E ∥∇ f i ( µ t ) − {+h qi,t ∥ 
+}

Original: [Equation]
Revised: = E ∥∇ f i ( µ t ) − ∇ f i ( X it − q − 1 (cid:88) s = η (cid:101) h si,t ) ∥≤ L 2 E ∥ µ t − X

Original:  (cid:88) s=
Revised: it + q − 1 (cid:88) s

Original: E ∥ (cid:101) h si
Revised: = η (cid:101) h si,t ∥≤ 2 L 2 E ∥

Original: [Equation]
Revised: X it − µ t ∥ 2 + 2 L 2 η 2 E ∥ q − 1 (cid:88) s = (cid:101) h si,t ∥≤ 2 L 2 E ∥ X i t − µ t ∥ 2 + 2 L 2 η 2 q q − 1 (cid:88) s = E ∥ (cid:101)

Original: t ∥
Revised: h s i,t ∥

Original: Lemma (B.1 ) ≤ 2 L 2 E ∥
Revised: Lemma (B.1 ) ≤ 2 L 2 E ∥

Original: X 
Revised: X it − µ t ∥ 2 + 2 L 2 η 2 q 2 (cid:18) 2 σ 2 + 8 L 2 E ∥ X it − [Equation]

Original: [Equation]
Revised: [Equation]

Original: and the last inequality comes from η < 1 4 LK .
Revised: and the last inequality comes from η < 1 4 LK .

Original: Lemma B.3.
Revised: Lemma B.3.

Original: For any time step t n (cid:88) 
Revised: For any time step t n (cid:88) i =

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: n (cid:88)i =
Revised: n (cid:88)

Original: [Equation]
Revised: [Equation]

Original: Using Young’s inequality we can upper bound E ⟨∇ f ( µ t ) , ∇ f i ( µ t ) − h qi,t ⟩ by
Revised: Using Young’s inequality we can upper bound E ⟨∇ f ( µ t ) , ∇ f i [Equation] µ t [Equation]

Original: E ∥∇ f
Revised: − h qi,t ⟩ by

Original: [Equation]
Revised: [Equation]

Original: Plugging this in the above inequality we get:
Revised: Plugging this in the above inequality we get:

Original: [Equation]
Revised: [Equation]

Original: Where in the last step we used that E [ H it ]
Revised: Where in the last step we used that E [ H it ]

Original: = H , and (cid:80) ni
Revised: = H [Equation] and (cid:80) ni

Original: =

Revised: =

Original: f i ( x ) n = f ( x ) , for any vector x .
Revised: f i ( x ) n = f ( x ) , for any vector x [Equation]

Original: B. U PPER B OUNDING P OTENTIAL F UNCTIONS
Revised: B. U PPER B OUNDING P OTENTIAL F UNCTIONS

Original: We proceed by proving the lemma 4.4 which upper bounds the expected change in potential:
Revised: We proceed by proving the lemma 4.4 which upper bounds the expected change in potential:

Original: Lemma 4.4.
Revised: Lemma 4.4.

Original: For any time step t we have:
Revised: For any time step t we have:

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: First we bound change in potential ∆ t =
Revised: First we bound change in potential ∆ t =

Original: Φ t +1 − Φ t for some fixed time step t > 0 .
Revised: Φ t +1 − Φ t for some fixed time step t > 0 .

Original: For this, let ∆ St be the change in potential when set S of agents wake up.
Revised: For this, let ∆ St be the change in potential when set S of agents wake up.

Original: for i ∈ S define S it and S t as follows:
Revised: for i ∈ S define S it and S t as follows:

Original: [Equation]
Revised: [Equation]

Original: We have that:
Revised: We have that:

Original: [Equation]
Revised: [Equation]

Original: This gives us that for i ∈ S :
Revised: This gives us that for i ∈ S :

Original: [Equation]
Revised: [Equation]

Original: For k ̸∈ S we get that
Revised: For k ̸∈ S we get that

Original: [Equation]
Revised: [Equation]

Original: Hence:
Revised: Hence:

Original: [Equation]
Revised: [Equation]

Original: (cid:13)(cid:13)(cid:13)
Revised: 2 (cid:17) + (cid:13)(cid:13)(cid:13)(cid:80) i ∈ S X it + X t s ++ S t − (cid:80)

Original: [Equation]
Revised: j ∈ S S jt + S t n +− µ t (cid:13)(cid:13)(cid:13) 2 − (cid:13)(cid:13)(cid:13) X t − µ t (cid:13)(cid:13)(cid:13)+ (cid:88) k ̸∈ S (cid:16)(cid:13)(cid:13)(cid:13) X kt − (cid:80)

Original: Observe that: [Equation] After combining the above two equations [Equation]
Revised: j ∈ S S jt + S t n +− µ t (cid:13)(cid:13)(cid:13) 2 − (cid:13)(cid:13)(cid:13)

Original: we get that: ∆ [Table] jt [Table]
Revised: X kt − µ t (cid:13)(cid:13)(cid:13) 2 (cid:17) =

Original: t [Equation]
Revised: (cid:88) i

Original:  + [Equation] By simplifying the above, we get: ∆ [Equation]{+X t s +− µ t (cid:13) (cid:13) (cid:13) 
+}
Revised: ∈ S (cid:16)(cid:13) (cid:13) (cid:13) sX i t + {+X t s +− µ t (cid:13) (cid:13) (cid:13) 
+}

Original: =
Revised: + (cid:13) (cid:13) (cid:13)

Original: [Equation] + (cid:88) i ∈ 
Revised: S it + (cid:80) j ∈ S S

Original: [Equation]{+jt + S t n +(cid:13) (cid:13) (cid:13)+ 2 (cid:68) sX it + X t s +− µ t , S it − (cid:80) j ∈ S S jt + S t n +(cid:69) − (cid:13)(cid:13)(cid:13) X it − µ t (cid:13)(cid:13)(cid:13) 2 (cid:17) + (cid:16)(cid:13)(cid:13)(cid:13)(cid:80) i ∈ S X it + X t s +− µ t (cid:13)(cid:13)(cid:13) 
+}
Revised: {+jt + S t n +(cid:13) (cid:13) (cid:13)+ 2 (cid:68) sX it + X t s +− µ t , S it − (cid:80) j ∈ S S jt + S t n +(cid:69) − (cid:13)(cid:13)(cid:13) X it − µ t (cid:13)(cid:13)(cid:13) 2 (cid:17) + (cid:16)(cid:13)(cid:13)(cid:13)(cid:80) i ∈ S X it + X t s +− µ t (cid:13)(cid:13)(cid:13) 
+}

Original: it − (cid:80)j [Equation] (cid:88)
Revised: + (cid:13)(cid:13)(cid:13) S t − (cid:80)

Original: [Equation]
Revised: j ∈ S S

Original:  +(cid:13)(cid:13)(cid:13) S t − (cid:80) j ∈ S S jt +  S t [-n +(cid:13)(cid:13)(cid:13) 
-]
Revised: jt + S t n +(cid:13)(cid:13)(cid:13)+ 2 (cid:68)(cid:80) i ∈ S X it + X t s +− µ t , S t [-n +(cid:13)(cid:13)(cid:13) 
-]− (cid:80)

Original: + s +(cid:88) i ∈ S (cid:68) X 
Revised: j ∈ S S jt + S t n +(cid:69) − (cid:13)(cid:13)(cid:13) X t − µ t (cid:13)(cid:13)(cid:13) 2 (cid:17) + (cid:88) k ̸∈ S 2 (cid:68)

Original: it − µ t , S t (cid:69) + s +(cid:68) X  t − µ t ,  S t (cid:69) + (cid:88) k
Revised: X k t − µ t , − (cid:80) j ∈ S S jt + S t n +(cid:69) + (cid:88) k

Original: ̸∈ S (cid:13)(cid:13)(cid:13)(cid:80)
Revised: ̸∈ S (cid:13)(cid:13) (cid:13) (cid:80) j ∈ S S

Original: j ∈ S S jt + S t n +(cid:13)(cid:13)(cid:13)
Revised: jt + S t n +(cid:13)(cid:13) (cid:13) Observe that: n (cid:88) k = (cid:68) X kt − µ t , − (cid:80) j ∈ S S

Original: Let α be a parameter we will fix later: (cid:68) X it − µ t , S it (cid:69) Young ≤ α (cid:13)(cid:13)(cid:13)
Revised: jt + S t n +(cid:69) = 0 . After combining the above two equations, we get that: [Equation] By simplifying the above

Original: X it − µ t (cid:13)(cid:13)(cid:13) 2 + (cid:13)(cid:13)(cid:13) S it (cid:13)(cid:13)(cid:13)4 α 
Revised: [Equation] we get: [Equation] Let α be a parameter we will fix later:

Original:  Finally, we get that ∆ St ≤ − 1 s + 1 (cid:88)
Revised: [Equation] 4 α Finally, we get that [Equation]

Original: i ∈ S ∥
Revised: [Equation] jt

Original: X it − X t ∥ 2 + 2 (cid:88) i ∈ S (cid:13)(cid:13)(cid:13) S [-it (cid:13)(cid:13)(cid:13) 
-]
Revised: [Equation] s + 1) ( n + 1) [Equation] S [-it (cid:13)(cid:13)(cid:13) 
-]t

Original:  + 2 s ( s + 1) ( n + 1)(cid:88)
Revised: [Equation] + (cid:88) [Equation]

Original: j ∈ S  (cid:13)(cid:13)(cid:13) S
Revised: S [Equation] (cid:13)(cid:13)(cid:13) [Equation]

Original: [-jt (cid:13)(cid:13)(cid:13) 
-]
Revised: [-jt (cid:13)(cid:13)(cid:13) 
-]S [Equation] (cid:13)(cid:13) S it (cid:13) (cid:13)(cid:13)

Original: + 2 s ( s + 1)( n +1) 2 (cid:13)(cid:13)(cid:13)
Revised: [Equation] [Equation] ( s + 1) +

Original:  S t (cid:13)(cid:13)(cid:13)  + (cid:88) i ∈
Revised: [Equation] S t (cid:13)(cid:13)(cid:13) 2 + 2( s + 1) ( n + 1)(cid:88) j ∈ S (cid:13)(cid:13)(cid:13) S jt (cid:13)(cid:13)(cid:13) 2 + 2( s + 1) ( n + 1) 2 (cid:13)(cid:13)(cid:13) S t (cid:13)(cid:13)(cid:13) 2 + (cid:88) i ∈

Original: S 2 sα{+
 α+} s +(cid:13)(cid:13) (cid:13)
Revised: S {+
 α+} s + 1 (cid:13)(cid:13)(cid:13)

Original: X it {+− µ t ∥ 2 + (cid:88) i ∈ S (cid:13)(cid:13)(cid:13) S t (cid:13)(cid:13)(cid:13)2 α ( s + 1) + 
+}
Revised: X it {+− µ t ∥ 2 + (cid:88) i ∈ S (cid:13)(cid:13)(cid:13) S t (cid:13)(cid:13)(cid:13)2 α ( s + 1) + 
+}

Original: [Table]
Revised: α s + 1 (cid:13)(cid:13)(cid:13) X t − µ t ∥ 2 + (cid:13)(cid:13)(cid:13) S t (cid:13)(cid:13)(cid:13)2 α ( s + 1) + (cid:88) j ∈ S ( n − s )( s + 1) ( n + 1)(cid:13)(cid:13)(cid:13) S

Original: S jt (cid:13)(cid:13)(cid:13) 2 + ( n − s )( s + 1) ( n + 1)(cid:13)(cid:13)(cid:13)
Revised: jt (cid:13)(cid:13)(cid:13) 2 + ( n − s )( s + 1) ( n + 1)(cid:13)(cid:13)(cid:13)

Original: S t (cid:13)(cid:13)(cid:13)= −s +(cid:88) i ∈
Revised: S t (cid:13)(cid:13)(cid:13)= −s +(cid:88) i ∈

Original: S
Revised: S

Original: ∥
Revised: ∥

Original: X it − X t ∥ 2 + (2 + 2( s + 1) 2 ( n + 1) 2 + 1 2 α + ( n − s )( s + 1) ( n + 1))
Revised: X it − X t ∥ 2 + (2 + 2( s + 1) 2 ( n + 1) 2 + 1 2 α + ( n − s )( s + 1) ( n + 1))

Original: (cid:88) j ∈ S (cid:13)(cid:13)(cid:13) S
Revised: (cid:88) j ∈ S (cid:13)(cid:13)(cid:13) S

Original: jt (cid:13)(cid:13)(cid:13) 2 + (2 + 2( s + 1)( n + 1) 

Revised: jt (cid:13)(cid:13)(cid:13) 2 + (2 + 2( s + 1)( n + 1)

Original: + 2 α + ( n − s )
Revised: + 2 α + ( n − s )

Original: ( s + 1) ( n + 1))
Revised: ( s + 1) ( n + 1))

Original: (cid:13)(cid:13)(cid:13) S t (cid:13)(cid:13)(cid:13) 2 + (cid:88) i ∈
Revised: (cid:13)(cid:13)(cid:13) S t (cid:13)(cid:13)(cid:13) 2 + (cid:88) i ∈

Original: S 2 α (cid:13)(cid:13)(cid:13)
Revised: S 2 α (cid:13)(cid:13)(cid:13)

Original: X it − µ t (cid:13)(cid:13)(cid:13) 

Revised: X it − µ t (cid:13)(cid:13)(cid:13)

Original: + 2 α (cid:13)(cid:13)(cid:13)
Revised: + 2 α (cid:13)(cid:13)(cid:13)

Original: X t − µ t (cid:13)(cid:13)(cid:13)≤ −s +(cid:88) i ∈

Original: S

Original: ∥

Original: [-X it − X t ∥ 2 + (4 + 1 2 α ) (cid:88) i ∈ S (cid:13)(cid:13)(cid:13) S it (cid:13)(cid:13)(cid:13) 
-]
Revised: [-X it − X t ∥ 2 + (4 + 1 2 α ) (cid:88) i ∈ S (cid:13)(cid:13)(cid:13) S it (cid:13)(cid:13)(cid:13) 
-]

Original: + (4 + 1 2 α ) (cid:13)(cid:13)(cid:13) S t (cid:13)(cid:13)(cid:13) 2 + (cid:88) i ∈ S 2 α (cid:13)(cid:13)(cid:13)

Original: X it − µ t (cid:13)(cid:13)(cid:13)
Revised: X t − µ t (cid:13)(cid:13)(cid:13)

Original: [Equation]
Revised: [Equation]

Original: Using definitions of S it and S t
Revised: Using definitions of S it and S t

Original: [Equation]
Revised: [Equation]

Original: Cauchy-Schwarz inequality and properties of quantization we get that
Revised: Cauchy-Schwarz inequality and properties of quantization we get that

Original: [Equation]
Revised: [Equation]

Original: Next
Revised: Next

Original: [Equation]
Revised: [Equation]

Original: we plug this in the previous inequality:
Revised: we plug this in the previous inequality:

Original: [Equation]
Revised: [Equation]

Original: Next, we calculate probability of choosing the set S and upper bound ∆ t in expectation, for this we define E t as expectation conditioned on the entire history up to and including step t
Revised: Next [Equation] we calculate probability of choosing the set S and upper bound ∆ t in expectation, for this we define E t as expectation conditioned on the entire history up to and including step t

Original: [Equation]
Revised: [Equation]

Original: By setting α = 3 s − 1n (8 s +8) ≥ 18 n
Revised: 2 α (cid:0) n − 1 s − [Equation] (cid:0) [Equation]

Revised: (cid:13)(cid:13)(cid:13) X it

Revised: [Equation]

Revised: µ t (cid:13)(cid:13)(cid:13)

Original: [Equation]
Revised: [Equation]

Revised: [Equation]

Original:  we get that:
Revised: t [Equation] [Equation] By setting α = 3 s − 1 n (8 s +8) ≥ 18 n , we get that:

Original: [Equation]
Revised: [Equation]

Original: Next we remove the conditioning , and use the definitions of ∆ i and S it (for S it we also use upper bound which come from the properties of quantization)
Revised: Next we remove the conditioning , and use the definitions of ∆ i and S it (for S it we also use upper bound which come from the properties of quantization).

Original: [Equation]
Revised: [Equation]

Original: Lemma B.4.
Revised: Lemma B.4.

Original: For any time step t we have:
Revised: For any time step t we have:

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: By combining Lemma 4.4 and 4.6 we have:
Revised: By combining Lemma 4.4 and 4.6 we have:

Original: [Equation]
Revised: [Equation]

Original: Lemma B.5.
Revised: Lemma B.5.

Original: For the sum of potential functions in all T steps we have:T
Revised: For the sum of potential functions in all T steps we have:

Original: [Equation]
Revised: [Equation]

Revised: µ t )

Revised: ∥

Original: Proof.
Revised: Proof.

Original: [Equation] t [Equation]
Revised: T − 1 (cid:88) t =

Original: [Equation]
Revised: E [Φ t +1 ] ≤

Original: [Equation] [Equation] [Equation]
Revised: T − 1 (cid:88) t = (cid:18) (1 − 1 5 n ) E

Original:  + [-
 nsKη 2-] ( σ 2 +  2 KG 2) + 32 B [Equation]{+
+}
Revised: [Φ t ] + [-
 nsKη 2-]16 n ( R 2 + 7) 2 γ 2 + {+
+}

Original:  nsK 2 η 2 E ∥∇ f ( µ t ) ∥ [Equation] (cid:19) [Equation]
Revised: nsKη 2 ( σ 2 + 2 KG 2 ) + 32 B 2 nsK 2 η 2 E ∥∇ f ( µ t ) ∥ 2 (cid:19) ≤ (1 − 1 5 n )

Original: [Equation] 1 5 n [Equation] T 
Revised: T − 1 (cid:88) t =

Original: [Equation] t [Equation] E [Φ t ] + 16 Tn ( R 2 + 7) 2 γ 

Revised: E [Φ t ] + 16 Tn ( R 2 + 7) 2 γ

Original: + 16 TnsKη 2 ( σ 2 + 2 KG 2 )
Revised: + 16 TnsKη 2 ( σ 2 + 2 KG 2 )

Original: + 32 B 2 nsK 2 η
Revised: + 32 B 2 nsK 2 η

Original: T − 1 (cid:88) t =
Revised: T − 1 (cid:88) t =

Original: E ∥∇ f ( µ t ) ∥
Revised: E ∥∇ f ( µ t ) ∥

Original: T (cid:88) t =
Revised: T (cid:88) t =

Original: E [Φ t ] ≤ 5 n (cid:0) 

Revised: E [Φ t ] ≤ 5 n (cid:0)

Original: Tn ( R 2 + 7) 2 γ 2 + 16 TnsKη 2 ( σ 2 + 2 KG 2 )
Revised: Tn ( R 2 + 7) 2 γ 2 + 16 TnsKη 2 ( σ 2 + 2 KG 2 )

Original: + 32 B 2 nsK 2 η
Revised: + 32 B 2 nsK 2 η

Original: T − 1 (cid:88) t =
Revised: T − 1 (cid:88) t =

Original: E ∥∇ f ( µ t ) ∥ 2 (cid:1) =
Revised: E ∥∇ f ( µ t ) ∥ 2 (cid:1) =

Original: 80 Tn 2 ( R 2 + 7) 2 γ 2 + 80 Tn 2 sKη 2 ( σ 2 + 2 KG 2 ) + 160 B 2 n 2 sK 2 η
Revised: 80 Tn 2 ( R 2 + 7) 2 γ 2 + 80 Tn 2 sKη 2 ( σ 2 + 2 KG 2 ) + 160 B 2 n 2 sK 2 η

Original: T − 1 (cid:88) t =
Revised: T − 1 (cid:88) t =

Original: E ∥∇ f ( µ t ) ∥
Revised: E ∥∇ f ( µ t ) ∥

Original: Lemma 4.5.
Revised: Lemma 4.5.

Original: For any step t
Revised: For any step t

Original: [Equation] Proof. [Equation] − η (cid:88) i ∈ S (cid:101) h
Revised: E ∥ µ t +1 − µ t ∥ 2 ≤ 2 s 2 ηn ( n + 1)(cid:88)

Original: i,t + Q ( X t ) − X t s ++ s +(cid:88) i ∈ S ( Q ( X it − η (cid:101) h i,t ) − ( X it − η (cid:101) h i,t )) (cid:13)(cid:13)(cid:13)(cid:33) ≤ (cid:88) S (cid:0) ns (cid:1) ( n + 1)(cid:32) 2 sη 2 (cid:88) i∈ S E (cid:13) (cid:13)(cid:13)(cid:101) h i,t (cid:13) (cid:13)(cid:13) 2 + s + 1 E
Revised: i

Original: (cid:13) (cid:13)(cid:13) Q ( X t ) − X t (cid:13) (

Original: cid:13)(cid:13)+ s +(cid:88) i ∈ S E (cid:13)(cid:13)(cid:13) ( Q ( X it − η (cid:101) h i,t ) − ( X it − η (cid:101) h i,t ))
Revised: E (cid:13)(cid:13)(cid:13)(cid:101) h i,t (cid:13)(cid:13)(cid:13) 2 + ( n + 1) 2 ( R 2 + 7) 2 γ 2 .

Original: (cid:13)(cid:13)(cid:13)(cid:33) ≤ (cid:88)

Original: [-S (cid:0) ns (cid:1) ( n + 1)(cid:32) 2 sη 2 (cid:88) i ∈ S E (cid:13)(cid:13)(cid:13)(cid:101) h i,t (cid:13)(cid:13)(cid:13) 2 + 
 ( R 2 + 7) 2 γ(cid:33) = (cid:88)-]
Revised: [-S (cid:0) ns (cid:1) ( n + 1)(cid:32) 2 sη 2 (cid:88) i ∈ S E (cid:13)(cid:13)(cid:13)(cid:101) h i,t (cid:13)(cid:13)(cid:13) 2 + 
 ( R 2 + 7) 2 γ(cid:33) = (cid:88)-]Proof.

Original: i 2 sη 2 (cid:0) n − 1 s − 1 (cid:1) (cid:0) ns (cid:1) ( n + 1) 2 E (cid:13)(cid:13)(cid:13)(cid:101)

Original: [Equation]
Revised: [Equation]

Original: By plugging Lemma 4.6 in the above upper bound we get that:
Revised: By plugging Lemma 4.6 in the above upper bound we get that:

Original: Lemma B.6.
Revised: Lemma B.6.

Original: For any step t
Revised: For any step t

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: [Equation]
Revised: [Equation]

Original: B. C ONVERGENCE
Revised: B. C ONVERGENCE

Original: Theorem B.7.
Revised: Theorem B.7.

Original: For learning rate η = n +1 sH √ T , Algorithm 1 converges at rate:
Revised: For learning rate η = n +1 sH √ T , Algorithm 1 converges at rate:

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: Let E t denote expectation conditioned on the entire history up to and including step t .
Revised: Let E t denote expectation conditioned on the entire history up to and including step t .

Original: By
Revised: By

Original: L -smoothness we have that
Revised: L -smoothness we have that

Original: [Equation]
Revised: [Equation]

Original: First we look at E t ⟨∇ f ( µ t ) , µ t +1 − µ t ⟩ = ⟨∇ f ( µ t ) , E t [ µ t +1 − µ t ] ⟩ .
Revised: First we look at E t ⟨∇ f ( µ t ) , µ t +1 − µ t ⟩ = ⟨∇ f ( µ t ) , E t [ µ t +1 − µ t ] ⟩ .

Original: If set S is chosen at step t + 1 ,
Revised: If set S is chosen at step t + 1 ,

Original: We have that
Revised: We have that

Original: [Equation]
Revised: [Equation]

Original: Thus, in this case:
Revised: Thus, in this case:

Original: [Equation]
Revised: [Equation]

Original: Where we used unbiasedness of quantization and stochastic gradients.
Revised: Where we used unbiasedness of quantization and stochastic gradients.

Original: We would like to note that even though we do condition on the entire history up to and including step t and this includes conditioning on X it , the algorithm has not yet used (cid:101) h
Revised: We would like to note that even though we do condition on the entire history up to and including step t and this includes conditioning on X it , the algorithm has not yet used (cid:101) h

Original: i,t (it does not count towards computation of µ t ), thus we can safely use all properties of stochastic gradients.
Revised: i,t (it does not count towards computation of µ t ), thus we can safely use all properties of stochastic gradients.

Original: Hence, we can proceed by taking into the account that each set of agents S is chosen as initiator with probability 1 ( ns ) :
Revised: Hence, we can proceed by taking into the account that each set of agents S is chosen as initiator with probability 1 ( ns ) :

Original: [Equation]
Revised: [Equation]

Original: η n +(cid:88) i ∈ S h i,t = − sη n ( n [Equation]
Revised: and subsequently

Original: [Equation]
Revised: [Equation]

Original: n (cid:88) i = h i,t . and subsequently
Revised: Hence

Original: [Equation]
Revised: [Equation]

Original: Hence, we can rewrite (5) as:
Revised: we can rewrite (5) as:

Original: [Equation]
Revised: [Equation]

Original: Next, we remove the conditioning
Revised: Next, we remove the conditioning

Original: [Equation]
Revised: [Equation]

Original: This allows us to use Lemmas B.6 and B.3:
Revised: This allows us to use Lemmas B.6 and B.3:

Revised: [Equation]

Revised: +

Revised: [Equation]

Revised: η

Original: [Equation]
Revised: [Equation]

Revised: n

Revised: [Equation]

Revised: [Equation]

Revised: [Equation]

Revised: [Equation]

Revised: [Equation]

Revised: [Equation]

Revised: (cid:0)

Revised: [Equation]

Revised: ( n

Revised: [Equation]

Revised: [Equation]

Revised: [Equation]

Original: By simplifying the above inequality we get:
Revised: By simplifying the above inequality we get:

Original: [Equation]
Revised: [Equation]

Original: by summing the above inequality for t = 0 to t
Revised: by summing the above inequality for t = 0 to t

Original: = T − [Equation] we get that
Revised: = T − 1 , we get that

Original: [Equation]
Revised: [Equation]

Original: Further
Revised: Further

Original: [Equation]
Revised: [Equation]

Original: we use Lemma B.5:
Revised: we use Lemma B.5:

Original: [Equation]
Revised: [Equation]

Original: [Equation]
Revised: 4 sL 2 η 3 Kn ++ 2 s 2 Kη 2 L ( n + 1)(cid:1) ( σ 2 + 2 KG 2 ) + ( R 2 + 7) 2 γ 2 LT ( n + 1)+ (cid:0) − 3 ηsH 4( n + 1) + 8 B 2 L 2 η 3 sKn ++ 4 B 2 s 2 K 2 Lη( n + 1)(cid:1) T − 1 (cid:88) t = E ∥∇ f ( µ t ) ∥≤ 400 ηsnKL 2 T ( R 2 + 7) 2 γn ++ 404 Tns 2 K 2 L 2 η 3 ( σ 2 + 2 KG 2 ) n ++ 3 s 2 Kη 2 LT ( σ 2 + 2 KG 2 ) ( n + 1)+ ( R 2 + 7) 2 γ 2 LT ( n + 1)+ (cid:0) − 3 ηsH 4( n + 1) + 8 B 2 L 2 η 3 sKn ++ 4 B 2 s 2 K 2 Lη( n + 1)+ 800 B 2 ns 2 K 3 η 3 Ln +(cid:1) T − 1 (cid:88) t =

Original: by assuming η < 1 100 B √ nsk 2 L we get:
Revised: E ∥∇ f ( µ t ) ∥by assuming η < 1 100 B √ nsk 2 L we get:

Original: [Equation]
Revised: E [ f ( µ T )] − f ( µ 0 ) ≤ 400 ηsnKL 2 T ( R 2 + 7) 2 γn ++ + (3 s 2 Kη 2 LT ( n + 1) 2 + 404 Tns 2 K 2 L 2 ηn +)( σ 2 + 2 KG 2 ) + ( R 2 + 7) 2 γ 2 LT ( n + 1)+ − ηsH 2( n + 1) T − 1 (cid:88) t = E ∥∇ f ( µ t ) ∥

Original: Next, we regroup terms, multiply both sides by 2( n +1) ηsHT and use the fact that f ( µ T) ≥ f ∗ : T T − 1 (cid:88) t =
Revised: Next, we regroup terms, multiply both sides by 2( n +1) ηsHT and use the fact that f ( µ T

Original: [Equation]
Revised: [Equation]

Original: Finally

Revised: [Equation]

Original: [Equation]
Revised: [Equation]

Original:  we set η = n +1 sH √ T :
Revised: Finally, we set η = n +1 sH √ T :

Original: [Equation]
Revised: [Equation]

Original: Lemma B.8.
Revised: Lemma B.8.

Original: For quantization parameters ( R 2 + 7) 2 γ 2 = ( n +1) 2 s 2 H 2 T ( σ 2 + 2 KG 2 + f ( µ 0 ) − f ∗ L ) we have:
Revised: For quantization parameters ( R 2 + 7) [Equation] ) we have:

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: [Equation]

Original: [Equation]
Revised: [Equation]

Original: Lemma B
Revised: Lemma B

Original: [Equation]
Revised: [Equation]

Original: We have:
Revised: We have:

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: 5 s
Revised: 5 s

Original: [Equation]
Revised: [Equation]

Original: ≤ 5 s
Revised: ≤ 5 s

Revised: [Equation]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Original: [Equation]
Revised: [Equation]

Original:  E∥∇ f ( µ t ) ∥≤ 6 s
Revised: T [Equation] [Table] E

Revised: [Equation]

Revised: [Equation]

Revised: [Table]

Original: T − 1 (cid:88) t =
Revised: [Equation] [Table] [Equation] [Table]

Revised: [Equation]

Original: E [Φ t ] + 6 nTη 2 K ( σ 2 + 2 KG 2 ) + 12 B 2 nη 2 K
Revised: [Table] [Equation] [Table] [Equation]

Revised: [Table]

Original: T − 1 (cid:88) t =
Revised: [Equation] [Table] [Equation] [Table]

Revised: [Equation]

Original: [-E ∥∇ f ( µ t ) ∥≤ 6 s (cid:0) 80 Tn 2 ( R 2 + 7) 2 γ 
-]
Revised: [-E ∥∇ f ( µ t ) ∥≤ 6 s (cid:0) 80 Tn 2 ( R 2 + 7) 2 γ 
-][Table] [Equation] [Table] [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Original: + 80 Tn 2 sKη 2 ( σ 2 + 2 KG 2 )
Revised: [Equation] [Table] [Equation] [Table]

Original:  + 160 B 2 n 2 sK 2 η
Revised: sHη + 800 TnKL 2 ( R 2 + 7) 2 γ

Original: T − 1 (cid:88) t = E ∥∇ f ( µ t ) ∥ 2 (cid:1) +  6 nTη 2 K ( σ 2 + 2 KG 2 ){+1) + 
+}
Revised: H + + ( 6 TsKηL H ( n + {+1) + 
+}

Original: + 12 B 2 nη 2 K
Revised: TnsK 2 L 2 η

Original: T − 1 (cid:88) t = E ∥∇ f ( µ t ) ∥≤ 480 Tn 2 s ( R 2 + 7) 2 γ 2 + (480 Tn 2 s 2 Kη 2 + 6 nTη 2 K )( σ 2 + 2 KG 2 ) +(960 n 2 s 2 K 2 B 2 η 2  + 12 B 2 nη 2 K 2 ){+γ 
+}
Revised: H )( σ 2 + 2 KG 2 ) + 2 T ( R 2 + 7) 2 γ 2 L ( n + 1) sHη (cid:17) ≤ 480 Tn 2 s ( R 2 + 7) 2 {+γ 
+}

Original: T − 1 (cid:88) t = E ∥∇ f ( µ t ) ∥≤ 480 Tn 2 s ( R 2 + 7) 2 γ 2 + 

Revised: +

Original: Tn 2 s 2 Kη 2 ( σ 2 + 2 KG 2 ) + 1000 B 2 n 2 s 2 K 2 η 
Revised: Tn 2 s 2 Kη 2 ( σ 2 + 2 KG 2 ) + 2000 B 2 n 2 ( n + 1) sK 2 η ( f

Original: [-T − 1 (cid:88) t = E ∥∇ f ( µ t ) ∥≤ 480 Tn 2 s ( R 2 + 7) 2 γ 2 + 
-]
Revised: [-T − 1 (cid:88) t = E ∥∇ f ( µ t ) ∥≤ 480 Tn 2 s ( R 2 + 7) 2 γ 2 + 
-][Equation]

Original: Tn 2 s 2 Kη 2 ( σ 2 + 2 KG 2 )  + 1000 B 2 n 2 s 2 K 2 η 2 (cid:16) 2( n + 1)( f ( µ 0 )
Revised: µ 0 ) − f ∗ ) H + 800000 TB [Equation] n 3 s 2 K 3 η 2 L

Original: − f ∗ ) sHη + 800 TnKL 2 ( R 2 + 7) 2 γ
Revised: [Equation] R 2 + 7) 2 γ

Original: H +
Revised: H +

Original: [Equation]
Revised: [Equation]

Original: [Table]
Revised: (6000 TB [Equation] n

Original: [Equation]
Revised: [Equation]

Revised: K

Original: [Table] [Equation]
Revised: [Equation]

Original: [Table] [Equation] [Table]
Revised: η

Original: [Equation]
Revised: [Equation]

Original: [Table] [Equation] [Table]
Revised: L

Original: [Equation] [Table] [Equation] [Table]
Revised: H

Original: [Equation]
Revised: [Equation]

Original: [Table]
Revised: n + 1) + 808000 TB 2 n

Original: [Equation]
Revised: [Equation]

Original: [Table] [Equation] [Table]
Revised: K

Original: [Equation]
Revised: [Equation]

Original: [Table] [Equation] [Table] [Equation]
Revised: 4 L

Original: [Table] [Equation] [Table]
Revised: H )

Original: [Equation]
Revised: [Equation]

Original: [Table] [Equation] [Table]
Revised: σ

Original: [Equation]
Revised: [Equation]

Original: [Table] [Equation] [Table] [Equation]
Revised: KG 2 )

Original: [Table] [Equation] [Table] [Equation]
Revised: + 4000 TB 2 nsK 2 ηL

Original: [Table] [Equation] [Table] [Equation]
Revised: ( R 2 + 7) 2 γ

Original: [Table] [Equation] [Table]
Revised: H ≤ 1000 Tn 3 s ( R 2 + 7) 2 γ 2 + 4000 B 2 n 3 sK 2 ( n + 1) √

Original: [Equation] [Table] [Equation] [Table]
Revised: T ( f ( µ 0 ) − f

Original: [Equation]
Revised: [Equation]

Original: [Table]{++ 10000 Tn 3 ( n + 1) 
+}
Revised: {++ 10000 Tn 3 ( n + 1) 
+}

Original: [Equation] [Table] [Equation] [Table]
Revised: s 2 K

Original: [Equation] [Table] [Equation] [Table]
Revised: T ( σ 2 + 2 KG 2 ) ≤ 1000 Tn 3 s ( R 2 + 7) 2 γ 2 + 10000 B 2 n 3 s 2 K 2 LT ( R 2 + 7) 2 γ

Original: Lemma 4.8.
Revised: Lemma 4.8.

Original: Let T ≥ O ( n 3 ) , then for quantization parameters
Revised: Let T ≥ O ( n 3 ) , then for quantization parameters

Original: R = 2 + T 3 d and γ 2 = {+( n +1) 2 ( σ 2 +2 KG 
+}
Revised: R = 2 + T 3 d and γ 2 = {+( n +1) 2 ( σ 2 +2 KG 
+}

Original: [Equation]
Revised: + f ( µ 0 ) − f ∗ )

Original: we have that the probability of quantization never failing during the entire run of the Algorithm 1 is at least 1 − O (cid:0) 1 T (cid:1) .
Revised: s 2 H 2 T ( R 2 +7)we have that the probability of quantization never failing during the entire run of the Algorithm 1 is at least 1 − O (cid:0) 1 T (cid:1) .

Original: Proof.
Revised: Proof.

Original: Let L t be the event that quantization does not fail during step t .
Revised: Let L t be the event that quantization does not fail during step t .

Original: Our goal is to show that
Revised: Our goal is to show that

Original: Pr [ ∪ Tt =

Revised: Pr [ ∪ Tt =

Original: L t ] ≥ 1 − O (cid:0) 1 T (cid:1) .
Revised: L t ] ≥ 1 − O (cid:0) 1 T (cid:1) .

Original: In order to do this, we first prove that Pr [ ¬L t +1 |L 1 , L 2 , ..., L t ] ≤
Revised: In order to do this, we first prove that Pr [ ¬L t +1 |L 1 , L 2 , ..., L t ] ≤

Original: O (cid:0) 1 T 2 (cid:1) (O is with respect to T here).
Revised: O (cid:0) 1 T 2 (cid:1) (O is with respect to T here).

Original: We need need to lower bound probability that :
Revised: We need need to lower bound probability that :

Original: [Equation]
Revised: [Equation]

Original: We would like to point out that these conditions are necessary for decoding to succeed, we ignore encoding since it will be counted when someone will try to decode it.
Revised: We would like to point out that these conditions are necessary for decoding to succeed, we ignore encoding since it will be counted when someone will try to decode it.

Original: Since, R = 2 + T 3 d this means that ( R Rd ) 2 ≥ 2 2 T 3 ≥ T 30 , for large enough T .
Revised: Since, R = 2 + T 3 d this means that ( R Rd ) 2 ≥ 2 2 T 3 ≥ T 30 , for large enough T .

Original: Hence, it is suffices to upper bound the probability that (cid:80) i ∈ S
Revised: Hence, it is suffices to upper bound the probability that (cid:80) i ∈ S

Original: ∥
Revised: ∥

Original: X t − X i t ∥ 2 + 
Revised: X t − X it ∥ 2 + (cid:80)

Original: [Equation]
Revised: [Equation]

Original: i ∈ S
Revised: ∈ S

Original: ∥
Revised: ∥

Original: X t − ( X i t − η 
Revised: X t − ( X it − η (cid:101) h i,t

Original: [Equation]
Revised: [Equation]

Original: h i,t ) ∥ 2 ≥ T 30 γ 2 .
Revised: ∥ 2 ≥ T 30 γ 2 .

Original: To prove this, we have:
Revised: To prove this, we have:

Original: [Equation]
Revised: [Equation]

Original: ∥
Revised: Now, we use Markov’s inequality, and Lemma B.9:

Original: [Equation]
Revised: [Equation]

Original: Now, we use Markov’s inequality, and Lemma B.9:
Revised: Thus

Original: [Equation]
Revised: [Equation]

Original: Thus, the failure probability due to the models not being close enough for quantization to be applied is at most O (cid:0) 1 T 2 (cid:1) .
Revised: the failure probability due to the models not being close enough for quantization to be applied is at most O (cid:0) 1 T 2 (cid:1) .

Original: Conditioned on the event that ∥ X t − X it ∥ and ∥
Revised: Conditioned on the event that ∥ X t − X it ∥ and ∥

Original: X t − ( X it − η (cid:101) h
Revised: X t − ( X it − η (cid:101) h

Original: i,t ) ∥ are upper bounded by T 15 γ (This is what we actually lower bounded the probability for using Markov), we get that the probability of quantization algorithm failing is at most(cid:88)
Revised: i,t ) ∥ are upper bounded by T 15 γ (This is what we actually lower bounded the probability for using Markov), we get that the probability of quantization algorithm failing is at most

Original: [Equation]
Revised: [Equation]

Original: By the law of total probability (to remove conditioning) and the union bound we get that the total probability of failure, either due to not being able to apply quantization or by failure of quantization algorithm itself is at most O (cid:0) 1 T 2 (cid:1) .
Revised: By the law of total probability (to remove conditioning) and the union bound we get that the total probability of failure, either due to not being able to apply quantization or by failure of quantization algorithm itself is at most O (cid:0) 1 T 2 (cid:1) .

Original: Finally we use chain rule to get that
Revised: Finally we use chain rule to get that

Original: [Equation]
Revised: [Equation]

Original: Lemma 4.9.
Revised: Lemma 4.9.

Original: Let T ≥ O ( n 3 ) , then for quantization parameters
Revised: Let T ≥ O ( n 3 ) , then for quantization parameters

Original: R = 2+ T

Original: [Equation]

Original: d and γ 2 =

Original: [Equation]

Original: 2 ( σ

Original: [Equation]

Original: + 2 KG

Original: [Equation]

Original: +

Original: [Equation] − [Equation] ∗ L ) we have that the expected number of bits used by Algorithm 1 per communication is O ( d log( n ) + log( T )) .
Revised: R = 2+ T 3 d and γ 2 = η 2 ( R 2 +7) 2 ( σ 2 + 2 KG 2 + f ( µ 0 ) − f ∗ L ) we have that the expected number of bits used by Algorithm 1 per communication is O ( d log( n ) + log( T )) .

Original: Proof.
Revised: Proof.

Original: At step t + 1 , by Corollary 4.3, we know that the total number of bits used is at most(cid:88)
Revised: At step t + 1 , by Corollary 4. [Equation] we know that the total number of bits used is at most

Original: [Equation]
Revised: [Equation]

Original: By taking the randomness of agent interaction at step t + 1 into the account
Revised: By taking the randomness of agent interaction at step t + 1 into the account

Original: [Equation]
Revised: [Equation]

Original: we get that the expected number of bits used is at most:
Revised: we get that the expected number of bits used is at most:

Original: [Equation]
Revised: [Equation]

Original: Jensen
Revised: So the expected number of bits per communication in all rounds is at most:

Original: [Equation]
Revised: [Equation]

Original: So the expected number of bits per communication in all rounds is at most:
Revised: Next

Original: [Equation]
Revised: [Equation]

Original: Next, By Jensen inequality and Lemma B.9, We get that the expected number of bits used is at most,
Revised: By Jensen inequality and Lemma B. [Equation] We get that the expected number of bits used is at most,

Original: [Equation]
Revised: [Equation]

Revised: Jensen

Revised: [Equation]

Original: Theorem 4.2.
Revised: Theorem 4.2.

Original: Assume the total number of steps T ≥ Ω( n 3 ) , the learning rate η = n +1 sH √ T , and quantization parameters R = 2 + T 3 d and γ 2 =
Revised: Assume the total number of steps T ≥ Ω( n 3 ) , the learning rate η = n +1 sH √ T , and quantization parameters R = 2 + T 3 d and γ 2 =

Original: [Equation]
Revised: [Equation]

Original: Let H > 0 be the expected number of local steps already performed by a client when interacting with the server.
Revised: Let H > 0 be the expected number of local steps already performed by a client when interacting with the server.

Original: Then, with probability at least 1 − O ( 1 T ) we have that Algorithm 1 converges at the following rate
Revised: Then, with probability at least 1 − O ( 1 T ) we have that Algorithm 1 converges at the following rate

Original: [Equation]
Revised: [Equation]

Original: and uses O ( sT ( d log n + log T ))
Revised: and uses O ( sT ( d log n + log T ))

Original: expected communication bits in total.
Revised: expected communication bits in total.

Original: Proof.
Revised: Proof.

Original: The proof simply follows from combining Lemmas B.8, 4.8 and 
Revised: The proof simply follows from combining Lemmas B.8, 4.8 and 4.

Original: [Equation]

Original: Lemma B.10.
Revised: Lemma B.10.

Original: For the convergence of the server [Equation] we have:
Revised: For the convergence of the server, we have:

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: [Equation]

Original: ≤

Original: [Equation]

Original: (cid:0) 80 n

Original: [Equation]

Original: ( R

Original: [Equation]

Original: [Equation]

Original: γ

Original: [Equation]

Original: n

Original: [Equation]

Original: KG

Original: [Equation]
Revised: [Equation]

Original: 160 n

Original: [Equation]

Original: [Equation]

Original: n

Original: [Equation]

Original: n

Original: [Equation]

Original: ( R

Original: [Equation]

Original: [Equation]

Original: γ

Original: [Equation]

Original: 160 n

Original: [Equation]

Original: η

Original: [Equation]

Original: KG

Original: [Equation]

Original: [Equation]

Original: [Equation]

Original: Finally
Revised: Finally

Original: [Equation]
Revised: [Equation]

Original: the proof of Corollary 4.3 follows from combining Lemmas B [Equation] 10, 4.8 and [Equation]
Revised: the proof of Corollary 4.3 follows from combining Lemmas B.10, 4.8 and 4.