Original: O N
Revised: O N

Original: D ISTRIBUTED
Revised: D ISTRIBUTED

Original: A DAPTIVE
Revised: A DAPTIVE

Original: O
Revised: O

Original: PTIMIZATION
Revised: PTIMIZATION

Original: WITH
Revised: WITH

Original: G RADIENT
Revised: G RADIENT

Original: C OMPRESSION
Revised: C OMPRESSION

Original: Anonymous authors
Revised: Anonymous authors

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

Original: A BSTRACT
Revised: A BSTRACT

Original: We study C OMP -AMS, a distributed optimization framework based on gradient averaging and adaptive AMSGrad algorithm.
Revised: We study C OMP -AMS, a distributed optimization framework based on gradient averaging and adaptive AMSGrad algorithm.

Original: Gradient compression is applied to reduce the communication in the gradient transmission process, whose bias is corrected by the tool of error feedback.
Revised: Gradient compression is applied to reduce the communication in the gradient transmission process, whose bias is corrected by the tool of error feedback.

Original: Our convergence analysis of C OMPAMS shows that such gradient averaging strategy yields same convergence rate as standard AMSGrad, and also exhibits linear speedup effect w r t. the number of local workers.
Revised: Our convergence analysis of C OMPAMS shows that such gradient averaging strategy yields same convergence rate as standard AMSGrad, and also exhibits linear speedup effect w r t. the number of local workers.

Original: Compared with recently proposed protocols on distributed adaptive methods, C OMP -AMSis simple and convenient.
Revised: Compared with recently proposed protocols on distributed adaptive methods, C OMP -AMSis simple and convenient.

Original: Numerical experiments are conducted to justify the theoretical ﬁndings and demonstrate that the proposed method can achieve same test accuracy as full-gradient AMSGrad with substantial communication savings.
Revised: Numerical experiments are conducted to justify the theoretical ﬁndings, and demonstrate that the proposed method can achieve same test accuracy as full-gradient AMSGrad with substantial communication savings.

Original: With its simplicity and efﬁciency, C OMP -AMScan serve as a useful distributed training framework for adaptive methods
Revised: With its simplicity and efﬁciency, C OMP -AMScan serve as a useful distributed training framework for adaptive methods

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Deep neural network has achieved the state-of-the-art learning performance on numerous AI applications, e.g., computer vision (Goodfellow et al., 2014;
Revised: Deep neural network has achieved the state-of-the-art learning performance on numerous AI applications, e.g., computer vision (Goodfellow et al., 2014;

Original: He et al., 2016; Voulodimos et al., 2018),
Revised: He et al., 2016; Voulodimos et al., 2018),

Original: Natural Language Processing (Graves et al., 2013; Young et al., 2018; Zhang et al., 2018), Reinforcement Learning (Mnih et al., 2013; Silver et al., 2017) and recommendation systems (Covington et al., 2016; Wei et al., 2017).
Revised: Natural Language Processing (Graves et al., 2013; Young et al., 2018; Zhang et al., 2018), Reinforcement Learning (Mnih et al., 2013; Silver et al., 2017) and recommendation systems (Covington et al., 2016; Wei et al., 2017).

Original: With the increasing sheet size of data observations and growing complexity of deep neural networks, standard single-machine training procedures encounter at least two major challenges:
Revised: With the increasing sheet size of data observations and growing complexity of deep neural networks, standard single-machine training procedures encounter at least two major challenges:

Original: • Due to the limited computing power of a single-machine, processing the massive number of data samples takes a long time — training is too slow.
Revised: • Due to the limited computing power of a single-machine, processing the massive number of data samples takes a long time — training is too slow.

Original: Many real-world applications can not even afford spending that much time on training.
Revised: Many real-world applications can not even afford spending that much time on training.

Original: • In many scenarios, data are stored in multiple servers, possibly at different locations, due to the storage constraints (massive user behavior data, Internet images, etc.) or privacy
Revised: • In many scenarios, data are stored in multiple servers, possibly at different locations, due to the storage constraints (massive user behavior data, Internet images, etc.) or privacy

Original: reasons (Chang et al., 2018).
Revised: reasons (Chang et al., 2018).

Original: Hence, transmitting data among servers might be costly.
Revised: Hence, transmitting data among servers might be costly.

Original: Distributed learning framework (Dean et al., 2012) has been a common training strategy to tackle the above two issues.
Revised: Distributed learning framework (Dean et al., 2012) has been a common training strategy to tackle the above two issues.

Original: For example, in centralized distributed stochastic gradient descent (SGD) protocol, data are located at n local nodes, at which the gradients of  the  model are computed in parallel.
Revised: Consider the distributed optimization task where n workers jointly solve a large ﬁnite-sum optimization problem in the form of [Equation] where the non-convex function f i represents the average loss over the local data samples for worker i ∈ [ n ] , and θ ∈ R d the global model parameter.

Original:  In  each iteration, a central server aggregates the local gradients, updates the global model, and transmits back the updated model to the local nodes for subsequent gradient computation. 
Revised: X i is the data distribution on each local node. In the classical centralized distributed setting, in each iteration the central server uniformly randomly assigns the data to n local workers ( X i ’s are the same), at which the gradients of the model are computed in parallel. Then the central server aggregates the local gradients, updates the global model (e.g., by stochastic gradient descent (SGD)), and transmits back the updated model to the local nodes for subsequent gradient computation. The scenario where X i ’s are different gives rise to the recently proposed Federated Learning (FL) (McMahan et al., 2017) framework, which would not be the major focus of this work.

Original: As we can see, this setting naturally solves aforementioned issues: 1) We use n computing nodes to train the model, so the time per training epoch can be largely reduced; 2) There is no need to transmit the local data to central server.
Revised: As we can see, distributed training naturally solves aforementioned issues: 1) We use n computing nodes to train the model, so the time per training epoch can be largely reduced; 2) There is no need to transmit the local data to central server.

Original: Besides, distributed training also provides stronger error tolerance since the training process could continue even one local machine breaks down.
Revised: Besides, distributed training also provides stronger error tolerance since the training process could continue even one local machine breaks down.

Original: As a result of these advantages, there has been a surge of study and applications on distributed systems (Boyd et al., 2011; Nedic & Ozdaglar, 2009; Duchi et al., 2011; Goyal et al., 2017; Hong et al., 2017;
Revised: As a result of these advantages, there has been a surge of study and applications on distributed systems (Boyd et al., 2011; Nedic & Ozdaglar, 2009; Duchi et al., 2011; Goyal et al., 2017; Hong et al., 2017;

Original: Lu et al., 2019; Koloskova et al., 2019).
Revised: Lu et al., 2019; Koloskova et al., 2019).

Original: Gradient compression.
Revised: Gradient compression.

Original: Among many optimization strategies, SGD is still the most popular prototype in distributed training for its simplicity and effectiveness (Chilimbi et al., 2014; Agarwal et al., 2018; Mikami et al., 2018).
Revised: Among many optimization strategies, SGD is still the most popular prototype in distributed training for its simplicity and effectiveness (Chilimbi et al., 2014; Agarwal et al., 2018; Mikami et al., 2018).

Original: Yet, when the deep learning model is very large, the communication between local nodes and central server could be expensive, and the burdensome gradient transmission would slow down the whole training system.
Revised: Yet, when the deep learning model is very large, the communication between local nodes and central server could be expensive, and the burdensome gradient transmission would slow down the whole training system.

Original: Thus, reducing the communication cost in distributed
Revised: Thus, reducing the communication cost in distributed

Original: SGD has become an active topic, and an important ingredient of large-scale distributed systems (e.g., Seide et al.
Revised: SGD has become an active topic, and an important ingredient of large-scale distributed systems (e.g., Seide et al.

Original: Solutions based on quantization, sparsiﬁcation and other compression techniques of the local gradients are proposed, e.g., Alistarh et al.
Revised: Solutions based on quantization, sparsiﬁcation and other compression techniques of the local gradients are proposed, e.g., Alistarh et al.

Original: Wen et al.
Revised: Wen et al.

Original: ; Wangni et al.
Revised: ; Wangni et al.

Original: ; Stich et al.
Revised: ; Stich et al.

Original: ; Aji & Heaﬁeld (2017); Bernstein et al.
Revised: ; Aji & Heaﬁeld (2017); Bernstein et al.

Original: De Sa et al.
Revised: De Sa et al.

Original: Yang et al.
Revised: Yang et al.

Original: ; Ivkin et al.
Revised: ; Ivkin et al.

Original: However, it has been observed both theoretically and empirically (Stich et al., 2018; Ajalloeian & Stich, 2020), that directly updating with the compressed gradients usually brings non-negligible performance downgrade in terms of convergence speed and accuracy.
Revised: However, it has been observed both theoretically and empirically (Stich et al., 2018; Ajalloeian & Stich, 2020), that directly updating with the compressed gradients usually brings non-negligible performance downgrade in terms of convergence speed and accuracy.

Original: To tackle this problem, studies (e.g., Stich et al.
Revised: To tackle this problem, studies (e.g., Stich et al.

Original: ; Karimireddy et al.
Revised: ; Karimireddy et al.

Original: (2019)) show that the technique of error feedback can to a large extent remedy the issue of such gradient compression, achieving same convergence rate as full-gradient SGD.
Revised: (2019)) show that the technique of error feedback can to a large extent remedy the issue of such gradient compression, achieving same convergence rate as full-gradient SGD.

Original: Adaptive optimization.
Revised: Adaptive optimization.

Original: In recent years, adaptive optimization algorithms (e.g. AdaGrad (Duchi et al., 2010), Adam (Kingma & Ba, 2014) and AMSGrad (Reddi et al., 2018)) have become popular because of their superior empirical performance.
Revised: In recent years, adaptive optimization algorithms (e.g. AdaGrad (Duchi et al., 2010), Adam (Kingma & Ba, 2014) and AMSGrad (Reddi et al., 2018)) have become popular because of their superior empirical performance.

Original: These methods use different implicit learning rates for different coordinates that keep changing adaptively throughout the training process, based on the learning trajectory.
Revised: These methods use different implicit learning rates for different coordinates that keep changing adaptively throughout the training process, based on the learning trajectory.

Original: In many cases, adaptive methods have been shown to converge faster than SGD, sometimes with better generalization as well.
Revised: In many cases, adaptive methods have been shown to converge faster than SGD, sometimes with better generalization as well.

Original: However, the body of literature that extends adaptive methods to distributed training is still fairly limited.
Revised: However, the body of literature that extends adaptive methods to distributed training is still fairly limited.

Original: In particular, even the simple gradient averaging approach, though appearing standard, has not been analyzed for adaptive optimization algorithms.
Revised: In particular, even the simple gradient averaging approach, though appearing standard, has not been analyzed for adaptive optimization algorithms.

Original: Given that distributed SGD with compressed gradient averaging can match the performance of standard SGD, one natural question is: is it also true for adaptive methods?
Revised: Given that distributed SGD with compressed gradient averaging can match the performance of standard SGD, one natural question is: is it also true for adaptive methods?

Original: In this work, we try to ﬁll this gap formally, by analyzing C OMP -AMS, a distributed adaptive optimization framework using the gradient averaging protocol, with communication-efﬁcient gradient compression.
Revised: In this work, we try to ﬁll this gap formally, by analyzing C OMP -AMS, a distributed adaptive optimization framework using the gradient averaging protocol, with communication-efﬁcient gradient compression.

Original: 1. O UR C ONTRIBUTIONS
Revised: Our contributions.

Original: Speciﬁcally, we focus on a simple algorithm design leveraging the adaptivity of AMSGrad and the computational virtue of local gradient compression .
Revised: In this work, we study a simple algorithm design leveraging the adaptivity of AMSGrad and the computational virtue of local gradient compression .

Original: Our  contributions summarize as follows:
Revised: Our main contributions summarize as follows:

Original: • We consider C OMP -AMS, a synchronous distributed adaptive optimization framework based on global averaging with gradient compression, which is efﬁcient in both communication and memory as no local moment estimation is needed.
Revised: • We consider C OMP -AMS, a synchronous distributed adaptive optimization framework based on global averaging with gradient compression, which is efﬁcient in both communication and memory as no local moment estimation is needed.

Original: Our scheme is coupled with an error-feedback technique to reduce the bias implied by the compression step.
Revised: We consider the BlockSign and Top- k compressors, coupled with the error-feedback technique to compensate for the bias implied by the compression step for fast convergence.

Original: • We provide the convergence analysis of distributed C OMP -AMS (with n workers) in smooth non-convex optimization, where data heterogeneity is allowed.
Revised: • We provide the convergence analysis of distributed C OMP -AMS (with n workers) in smooth non-convex optimization.

Original: In the special case of n = 1 (single machine), similar to SGD, gradient compression with error feedback in adaptive method achieves same convergence rate
Revised: In the special case of n = 1 (single machine), similar to SGD, gradient compression with error feedback in adaptive method achieves same convergence rate

Original: O ( 1 √ T ) as the standard fullgradient counterpart.
Revised: O ( 1 √ T ) as the standard full-gradient counterpart.

Original: Also, we show that with a properly chosen learning rate, C OMPAMS achieves O ( 1 √ nT ) convergence, implying a linear speedup in terms of the number of local workers to attain O ( δ ) -stationary point.
Revised: Also, we show that with a properly chosen learning rate, C OMP -AMS achieves O ( 1 √ nT ) convergence, implying a linear speedup in terms of the number of local workers to attain O ( δ ) -stationary point.

Original: • We present numerical experiments on three tasks  to validate our theoretical ﬁndings, and show that C OMP -AMS has comparable performance with other distributed adaptive methods, and matches the accuracy of full-precision AMSGrad with substantially reduced communication cost.
Revised: • Experiments are conducted on various training tasks on image classiﬁcation and sentiment analysis to validate our theoretical ﬁndings on the linear speedup effect. Our results show that C OMP -AMS has comparable performance with other distributed adaptive methods, and matches the accuracy of full-precision AMSGrad with substantially reduced communication cost.

Original: Thus, it can serve as a convenient distributed training strategy in practice.
Revised: Thus, it can serve as a convenient distributed training strategy in practice.

Original:  R ELATED W ORK 2. D ISTRIBUTED SGD WITH C OMPRESSED G RADIENTS
Revised:  R ELATED W ORK 2. D ISTRIBUTED SGD WITH C OMPRESSED G RADIENTS

Original: Quantization.
Revised: Quantization.

Original: As we mentioned before, SGD is the most commonly adopted optimization method in distributed training of deep neural nets.
Revised: As we mentioned before, SGD is the most commonly adopted optimization method in distributed training of deep neural nets.

Original: To reduce the expensive communication in large-scale distributed systems, extensive works have considered various compression techniques applied to the gradient transaction procedure.
Revised: To reduce the expensive communication in large-scale distributed systems, extensive works have considered various compression techniques applied to the gradient transaction procedure.

Original: The ﬁrst strategy is quantization.
Revised: The ﬁrst strategy is quantization.

Original: Dettmers (2016) condenses 32-bit ﬂoating numbers into 8-bits when representing the gradients.
Revised: Dettmers (2016) condenses 32-bit ﬂoating numbers into 8-bits when representing the gradients.

Original: Seide et al.
Revised: Seide et al.

Original: ; Bernstein et al.
Revised: ; Bernstein et al.

Original: ; Karimireddy et al.
Revised: ; Karimireddy et al.

Original: ; Bernstein et al.
Revised: ; Bernstein et al.

Original: (2019) use the extreme 1-bit information (sign) of the gradients, combined with tricks like momentum, majority vote and memory.
Revised: (2019) use the extreme 1-bit information (sign) of the gradients, combined with tricks like momentum, majority vote and memory.

Original: Other quantization-based methods include QSGD (Alistarh et al., 2017; Wu et al., 2018; Zhang et al., 
Revised: Other quantization-based methods include QSGD (Alistarh et al., 2017; Wu et al., 2018; Zhang et al., 2017) and

Original: 2017) and LPC-SVRG (Yu et al., 2019b), leveraging unbiased stochastic quantization.
Revised: LPC-SVRG (Yu et al., 2019b), leveraging unbiased stochastic quantization.

Original: The saving in communication of quantization methods is moderate: for example, 8-bit quantization reduces the cost to 25% (compared with 32-bit full-precision).
Revised: The saving in communication of quantization methods is moderate: for example, 8-bit quantization reduces the cost to 25% (compared with 32-bit full-precision).

Original: Even in the extreme 1-bit case, the largest compression ratio is around 1 / 32 ≈ 3 .
Revised: Even in the extreme 1-bit case, the largest compression ratio is around 1 / 32 ≈ 3 .

Original: Sparsiﬁcation.
Revised: Sparsiﬁcation.

Original: Gradient sparsiﬁcation is another popular solution which may provide higher compression rate.
Revised: Gradient sparsiﬁcation is another popular solution which may provide higher compression rate.

Original: Instead of commuting the full gradient, each local worker only passes a few coordinates to the central server and zeros out the others.
Revised: Instead of commuting the full gradient, each local worker only passes a few coordinates to the central server and zeros out the others.

Original: Thus, we can more freely choose higher compression ratio (e.g., 1%, 0.1%), still achieving impressive performance in many applications (Lin et al., 2018).
Revised: Thus, we can more freely choose higher compression ratio (e.g., 1%, 0.1%), still achieving impressive performance in many applications (Lin et al., 2018).

Original: Stochastic sparsiﬁcation methods, including uniform and magnitude based sampling (Wangni et al., 2018), select coordinates based on some sampling probability, yielding unbiased gradient compressors with proper scaling.
Revised: Stochastic sparsiﬁcation methods, including uniform and magnitude based sampling (Wangni et al., 2018), select coordinates based on some sampling probability, yielding unbiased gradient compressors with proper scaling.

Original: Deterministic methods are simpler, e.g., Random- k , Top- k
Revised: Deterministic methods are simpler, e.g., Random- k , Top- k

Original: (Stich et al., 2018; Shi et al., 2019) (selecting k elements with largest magnitude), Deep Gradient Compression (Lin et al., 2018), but usually lead to biased gradient estimation.
Revised: (Stich et al., 2018; Shi et al., 2019) (selecting k elements with largest magnitude), Deep Gradient Compression (Lin et al., 2018), but usually lead to biased gradient estimation.

Original: In Ivkin et al.
Revised: In Ivkin et al.

Original: (2019), the central server identiﬁes heavy-hitters from the count-sketch (Charikar et al., 2002) of the local gradients, which can be regarded as a noisy variant of Top- k strategy.
Revised: (2019), the central server identiﬁes heavy-hitters from the count-sketch (Charikar et al., 2002) of the local gradients, which can be regarded as a noisy variant of Top- k strategy.

Original: More applications and analysis of compressed distributed SGD can be found in Jiang & Agrawal (2018);
Revised: More applications and analysis of compressed distributed SGD can be found in Jiang & Agrawal (2018);

Original: Shen et al.
Revised: Shen et al.

Original: Alistarh et al.
Revised: Alistarh et al.

Original: ; Basu et al.
Revised: ; Basu et al.

Original: ; Jiang et al.
Revised: ; Jiang et al.

Original: (2018), among others.
Revised: (2018), among others.

Original: Error Feedback (EF).
Revised: Error Feedback (EF).

Original: Biased gradient estimation, which is a consequence of many aforementioned methods (e.g., signSGD, Top- k ), undermines the model training, both theoretically and empirically, with slower convergence and worse generalization (Ajalloeian & Stich, 2020; Beznosikov et al., 2020).
Revised: Biased gradient estimation, which is a consequence of many aforementioned methods (e.g., signSGD, Top- k ), undermines the model training, both theoretically and empirically, with slower convergence and worse generalization (Ajalloeian & Stich, 2020; Beznosikov et al., 2020).

Original: The technique of error feedback is able to “correct for the bias” and ﬁx the convergence issues.
Revised: The technique of error feedback is able to “correct for the bias” and ﬁx the convergence issues.

Original: In this procedure, the difference between the true stochastic gradient and the compressed one is accumulated locally, which is then added back to the local gradients in later iterations.
Revised: In this procedure, the difference between the true stochastic gradient and the compressed one is accumulated locally, which is then added back to the local gradients in later iterations.

Original: Stich et al.
Revised: Stich et al.

Original: ; Karimireddy et al.
Revised: ; Karimireddy et al.

Original: (2019) prove the O ( 1 T ) and O ( 1 √ T ) convergence rate of EF-SGD in strongly convex and non-convex setting respectively, matching the rates of vanilla SGD (Nemirovski et al., 2009; Ghadimi & Lan, 2013).
Revised: (2019) prove the O ( 1 T ) and O ( 1 √ T ) convergence rate of EF-SGD in strongly convex and non-convex setting respectively, matching the rates of vanilla SGD (Nemirovski et al., 2009; Ghadimi & Lan, 2013).

Original: More works on the convergence rate of SGD with error feedback include (Zheng et al., 2019; Stich & Karimireddy, 2019), among other related papers.
Revised: More works on the convergence rate of SGD with error feedback include (Zheng et al., 2019; Stich & Karimireddy, 2019), among other related papers.

Original: 2. A DAPTIVE O PTIMIZATION
Revised: 2. A DAPTIVE O PTIMIZATION

Original: In each SGD update, all the gradient coordinates share the same learning rate.
Revised: In each SGD update, all the gradient coordinates share the same learning rate.

Original: This latter is either constant or decreasing through the iterations.
Revised: This latter is either constant or decreasing through the iterations.

Original: Adaptive optimization methods cast different learning rate on each dimension.
Revised: Adaptive optimization methods cast different learning rates on each dimension.

Original: For instance, AdaGrad, developed in Duchi et al.
Revised: For instance, AdaGrad, developed in Duchi et al.

Original: (2010), divides the gradient element-wisely by (cid:113)(cid:80)
Revised: (2010), divides the 1: Input : parameters β , β

Original: {+2 , (cid:15) , learning rate η t 2: Initialize: θ 1 ∈ R d , m 0 = 0 ∈ R d , v 0 = 
+}
Revised: {+2 , (cid:15) , learning rate η t 2: Initialize: θ 1 ∈ R d , m 0 = 0 ∈ R d , v 0 = 
+}

Revised: ∈ R d 3: for t = 1 , . . .

Revised: , T do 4:

Original: {+Compute stochastic gradient g t at θ t 5: m t = β 1 m t − 1 + (1 − β 1 ) g t 6: v t = β 2 v t − 
+}
Revised: {+Compute stochastic gradient g t at θ t 5: m t = β 1 m t − 1 + (1 − β 1 ) g t 6: v t = β 2 v t − 
+}

Revised: + (1 − β 2 ) g 2 t 7: ˆ v t

Revised: = max(ˆ v t − 1 , v t ) 8: θ t +1 =

Revised: θ t − η t m t √ ˆ v t + (cid:15) 9: end for gradient elementwise by (cid:113)(cid:80)

Original: Tt =1 g 2 t ∈ R d , where g t ∈ R
Revised: Tt =1 g 2 t ∈ R d , where g t ∈ R

Original: d is the gradient vector at time t and d is the model dimensionality.
Revised: d is the gradient vector at time t and d is the model dimensionality.

Original: Thus, it intrinsically assigns different learning rates to different coordinates throughout the training—elements with smaller previous gradient magnitude tend to move a larger step via larger learning rate.
Revised: Thus, it intrinsically assigns different learning rates to different coordinates throughout the training—elements with smaller previous gradient magnitudes tend to move a larger step via larger learning rate.

Original: Other adaptive methods include AdaDelta (Zeiler, 2012) and
Revised: Other adaptive methods include AdaDelta (Zeiler, 2012) and

Original: Adam (Kingma & Ba, 2014), which introduce momentum and moving average of second moment estimation into AdaGrad hence leading to better performances.
Revised: Adam (Kingma & Ba, 2014), which introduce momentum and moving average of second moment estimation into AdaGrad hence leading to better performances.

Original: AMSGrad (Reddi et al., 2018), and potential improvements as in Wang et al.
Revised: AMSGrad (Reddi et al., 2018), and potential improvements as in Wang et al.

Original: , ﬁx the potential convergence issue of Adam.
Revised: , ﬁx the potential convergence issue of Adam.

Original: In this paper, we will use AMSG RAD as the prototype, which is summarized in Algorithm 1.
Revised: In this paper, we will use AMSG RAD as the prototype, which is summarized in Algorithm 1.

Original: In general, adaptive optimization methods in many cases exhibit faster convergence than SGD.
Revised: In general, adaptive optimization methods in many cases exhibit faster convergence than SGD.

Original: Thus, they have been widely used in training deep learning models in language and computer vision appliAlgorithm 1 AMSG RAD − g − cations, e.g., Choi et al.
Revised: Thus, they have been widely used in training deep learning models in language and computer vision applications, e.g., Choi et al.

Original: ; You et al.
Revised: ; You et al.

Original: ; Zhang et al.
Revised: ; Zhang et al.

Original: In distributed setting, Nazari et al.
Revised: In distributed setting, Nazari et al.

Original: (2019) proposes a decentralized system in online optimization, but communication efﬁciency is not considered.
Revised: (2019) proposes a decentralized system in online optimization, but communication efﬁciency is not considered.

Original: Mostly relevant to our work, Chen et al.
Revised: Mostly relevant to our work, Chen et al.

Original: (2020) proposed a distributed training algorithm based on Adam, which requires every local node to store a local estimation of the moments of the gradient.
Revised: (2020) proposed a distributed training algorithm based on Adam, which requires every local node to store a local estimation of the moments of the gradient.

Original: Thus, one has to keep extra two more tensors of the model size on each local worker, which may be less feasible in terms of memory particularly with large models.
Revised: Thus, one has to keep extra two more tensors of the model size on each local worker, which may be less feasible in terms of memory particularly with large models.

Original: More recently, Tang et al.
Revised: More recently, Tang et al.

Original: (2021) proposes an Adam pre-conditioned momentum SGD method.
Revised: (2021) proposes an Adam pre-conditioned momentum SGD method.

Original: We will present more detailed comparisons to these works in Section 3.
Revised: We will present more detailed comparisons to these works in Section 3.

Original:  C OMMUNICATION -E FFICIENT A DAPTIVE O PTIMIZATION 
Revised:  C OMMUNICATION -E FFICIENT A DAPTIVE O PTIMIZATION 3. G RADIENT C OMPRESSORS

Original: Consider the distributed optimization task where n workers jointly solve a large ﬁnite-sum optimization problem in the form of

Original: [Equation]

Original: where the non-convex function f

Original: i represents the average loss (over the local data samples) for worker i ∈ [ n ] and θ the global model parameter taking value in Θ , a subset of R d .

Original: X i is the data distribution on each local node, which might be different.

Original: 3. G RADIENT C OMPRESSORS

Original: In this paper, we mainly consider deterministic q -deviate compressors deﬁned as below.
Revised: In this paper, we mainly consider deterministic q -deviate compressors deﬁned as below.

Original: Assumption 1.
Revised: Assumption 1.

Original: The gradient compressor C : R d (cid:55)→ R d is q -deviate: for ∀ x ∈ R d , ∃ 0 ≤ q <such that (cid:107)C ( x ) − x (cid:107) ≤ q (cid:107) x (cid:107) .
Revised: The gradient compressor C : R d (cid:55)→ R d is q -deviate: for ∀ x ∈ R d , ∃ 0 ≤ q <such that (cid:107)C ( x ) − x (cid:107) ≤ q (cid:107) x (cid:107) .

Original: Larger q indicates heavier compression, while smaller q implies better approximation of the true gradient.
Revised: Larger q indicates heavier compression, while smaller q implies better approximation of the true gradient.

Original: q = 0 implies C ( x ) = x , i.e., no compression.
Revised: q = 0 implies C ( x ) = x , i.e., no compression.

Original: In the following, we give two popular and efﬁcient q -deviate compressors that will be adopted in this paper.
Revised: In the following, we give two popular and efﬁcient q -deviate compressors that will be adopted in this paper.

Original: Deﬁnition 1 (Top- k ) .
Revised: Deﬁnition 1 (Top- k ) .

Original: For x ∈ R d , denote S as the size- k set of i ∈ [ d ] with largest k magnitude | x i | .
Revised: For x ∈ R d , denote S as the size- k set of i ∈ [ d ] with largest k magnitude | x i | .

Original: The Top- k compressor is deﬁned as C ( x ) i
Revised: The Top- k compressor is deﬁned as C ( x ) i

Original: = x i , if i ∈ S ; C ( x ) i = 0 otherwise.
Revised: = x i , if i ∈ S ; C ( x ) i = 0 otherwise.

Original: Deﬁnition 2 (Block-Sign) .
Revised: Deﬁnition 2 (Block-Sign) .

Original: For x ∈ R d , deﬁne M blocks indexed by B i , i = 1 , ..., M , with d i := |B i | .
Revised: For x ∈ R d , deﬁne M blocks indexed by B i , i = 1 , ..., M , with d i := |B i | .

Original: The Block-Sign compressor is deﬁned as C ( x ) =
Revised: The Block-Sign compressor is deﬁned as C ( x ) =

Original: [ sign ( x B 1 ) (cid:107) x B 1 (cid:107) 1 d, ..., sign ( x B M ) (cid:107) x  B M (cid:107) 1 d M ] .
Revised: [ sign ( x B 1 ) (cid:107) x [Equation] ] , where x B i is the sub-vector of x at indices B i .

Original: Remark 1.
Revised: Remark 1.

Original: It is well-known (Stich et al., 2018) that for Top- k , q 2 = 1 − kd .
Revised: It is well-known (Stich et al., 2018) that for Top- k , q 2 = 1 − kd .

Original: For Block-Sign , by Cauchy-Schwartz inequality we have q 2 = 1 − min
Revised: For Block-Sign , by Cauchy-Schwartz inequality we have q 2 = 1 − min

Original: i ∈
Revised: i ∈

Original: [ M ] 1 d i where M and d i are deﬁned in
Revised: [ M ] 1 d i where M and d i are deﬁned in

Original: Deﬁnition 2 (Zheng et al., 2019).
Revised: Deﬁnition 2 (Zheng et al., 2019).

Original: The intuition behind Top- k is that, it has been observed empirically that when training many deep models, most gradients are typically very small, and gradients with large magnitude contain most information.
Revised: The intuition behind Top- k is that, it has been observed empirically that when training many deep models, most gradients are typically very small, and gradients with large magnitude contain most information.

Original: The Block-Sign compressor is a simple extension of the 1-bit SIGN compressor (Seide et al., 2014; Bernstein et al., 2018), adapted to different gradient magnitude in different blocks, which, for neural nets, are usually set as the distinct network layers.
Revised: The Block-Sign compressor is a simple extension of the 1-bit SIGN compressor (Seide et al., 2014; Bernstein et al., 2018), adapted to different gradient magnitude in different blocks, which, for neural nets, are usually set as the distinct network layers.

Original: The scaling factor in Deﬁnitionis to preserve the (possibly very different) gradient magnitude in each layer.
Revised: The scaling factor in Deﬁnitionis to preserve the (possibly very different) gradient magnitude in each layer.

Original: In principle, Top- k would perform the best when the gradient is effectively sparse, while Block-Sign compressor is favorable by nature when most gradients have similar magnitude within each layer.
Revised: In principle, Top- k would perform the best when the gradient is effectively sparse, while Block-Sign compressor is favorable by nature when most gradients have similar magnitude within each layer.

Original: 3. C OMP -AMS: D ISTRIBUTED A DAPTIVE T RAINING BY G RADIENT A GGREGATION
Revised: 3. C OMP -AMS: D ISTRIBUTED A DAPTIVE T RAINING BY G RADIENT A GGREGATION

Original: We present in Algorithm 2 the proposed communication-efﬁcient distributed adaptive method in this paper, C OMP -AMS.
Revised: We present in Algorithm 2 the proposed communication-efﬁcient distributed adaptive method in this paper, C OMP -AMS.

Original: This framework can be regarded as an analogue to the standard synchronous distributed SGD: in each iteration, each local worker transmits to the central server the compressed stochastic gradient computed using local data.
Revised: This framework can be regarded as an analogue to the standard synchronous distributed SGD: in each iteration, each local worker transmits to the central server the compressed stochastic gradient computed using local data.

Original: Then the central server takes the average of local gradients, and performs an AMSGrad update.
Revised: Then the central server takes the average of local gradients, and performs an AMSGrad update.

Original: In Algorithm 2, line 7-8 depict the error feedbackoperation at local nodes.
Revised: In Algorithm 2, line 7-8 depict the error feedback

Original: e t,i is the accumulated error from gradient compression on the i -th worker up to time t − 1 . This residual is added back to g t,i to get the “corrected” gradient. In Section Input parameters
Revised: Compute stochastic gradient g t i θ t 7:

Original: , learning rate η

Original: [-Initialize : central server parameter θ Θ d ; e 1 ,i = 
 the error accumulator for each worker; m 0 = 0 , v 0 = 0 , ˆ v 0 =3: for t = 1 , . . .-]
Revised: [-Initialize : central server parameter θ Θ d ; e 1 ,i = 
 the error accumulator for each worker; m 0 = 0 , v 0 = 0 , ˆ v 0 =3: for t = 1 , . . .-]Compute ˜ g t,

Original: , T do 4: parallel for worker i∈ [ n ] do : 5: Receive model parameter θ t from central server 6: Compute stochastic gradient g t,i at θ t 7:
Revised: i

Original: Compute ˜ g t,i = C( g t,i + e t,i , k ) 8: Update the error e t +1 ,i = e t,i + g t,i − ˜
Revised: C g i e i

Original:  g t,i 9:
Revised: i g i 9:

Original: Send ˜ g t,i back to central server 10: end parallel 11:

Original: Central server do: 12: ¯ g [-t = 1 n (cid:80) ni =
-]
Revised: Central server do: 12: ¯ g [-t = 1 n (cid:80) ni =
-]i 13: m β m −

Original: ˜ g t,i 13: m t = β 1 m t − 1 +(1 −β 1 )¯ g t 14: v t = β2 v t − 1 + (1 − β2 )
Revised: + − g t 14: v t = β v t − 1 + (1 − β

Original: ¯ g 2 t 15: ˆ v t = max( v t , ˆ vt − 1 ) 16:
Revised: ¯ g 2 t 15: ˆ v t = max( v t , ˆ v − 1 ) 16:

Original: Update the global model θ t[-+
-]
Revised: Update the global model θ t[-+
-]

Original:  = 
Revised: 1 = θ t − η t m t √ ˆ v t + (cid:15) 17: end for operation at local nodes. e t,i is the accumulated error from gradient compression on the i -th worker up to time t − 1 . This residual is added back to g t,i to get the “corrected” gradient.

Original: θ t − η t m t √ ˆ v t + (cid:15) 17: end for & 5, we will show that error feedback, similar to the case of SGD, also brings good convergence behavior under gradient compression in distributed AMSGrad.
Revised: In Sectionand Section 5, we will show that error feedback, similar to the case of SGD, also brings good convergence behavior under gradient compression in distributed AMSGrad.

Original: Comparison with related methods.
Revised: Comparison with related methods.

Original: Next, we discuss the differences between C OMP -AMS and two recently proposed methods also trying to solve the distributed adaptive optimization problem.
Revised: Next, we discuss the differences between C OMP -AMS and two recently proposed methods also trying to solve the distributed adaptive optimization problem.

Original: Note that, the ﬁrst important difference is that these two methods both are based on the Adam optimizer, while we use AMSGrad as the prototype.
Revised: Note that, the ﬁrst important difference is that these two methods both are based on the Adam optimizer, while we use AMSGrad as the prototype.

Original: • Comparison with Chen et al.
Revised: Comparison with Chen et al.

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

Original: (2020) develops a quantized variant of Adam (Kingma & Ba , called “QAdam”.
Revised: (2020) develops a quantized variant of Adam (Kingma & Ba, 2014), called “QAdam”.

Original: In this method, each worker keeps a local copy of the moment estimates, commonly noted m and v , and compresses and transmits the ratio mv as a whole to the server.
Revised: In this method, each worker keeps a local copy of the moment estimates, commonly noted m and v , and compresses and transmits the ratio mv as a whole to the server.

Original: Thus, that method is very much like the compressed distributed SGD, with the exception that the ratio mv plays the role of the gradient vector g communication-wise.
Revised: Thus, that method is very much like the compressed distributed SGD, with the exception that the ratio mv plays the role of the gradient vector g communication-wise.

Original: Thus, two local moment estimators are additionally required, which have same size as the deep learning model.
Revised: Thus, two local moment estimators are additionally required, which have same size as the deep learning model.

Original: In our C OMP -AMS, the moment estimates m and v are kept and updated only at the central server, thus not introducing any extra variable (tensor) on local nodes during training (except for the error accumulator).
Revised: In our C OMP -AMS, the moment estimates m and v are kept and updated only at the central server, thus not introducing any extra variable (tensor) on local nodes during training (except for the error accumulator).

Original: Hence, C OMP -AMS is not only effective in communication reduction, but also efﬁcient in terms of memory (space), which is feasible when training large-scale learners like BERT and CTR prediction models, e.g. Devlin et al.
Revised: Hence, C OMP -AMS is not only effective in communication reduction, but also efﬁcient in terms of memory (space), which is feasible when training large-scale learners like BERT and CTR prediction models, e.g. Devlin et al.

Original: ; Zhao et al.
Revised: ; Zhao et al.

Original: (2020), to lower the hardware consumption happening in practice.
Revised: (2020), to lower the hardware consumption happening in practice.

Original: Comparison with Tang et al.
Revised: Comparison with Tang et al.

Original: The recent work (Tang et al., 2021) proposes “1BitAdam”.
Revised: The recent work (Tang et al., 2021) proposes “1BitAdam”.

Original: They ﬁrst run some warm-up training steps using standard Adam, and then store the second moment moving average v .
Revised: They ﬁrst run some warm-up training steps using standard Adam, and then store the second moment moving average v .

Original: Then, distributed Adam training starts with v frozen.
Revised: Then, distributed Adam training starts with v frozen.

Original: Thus, 1BitAdam is actually more like a distributed momentum SGD with some pre-conditioned coordinate-wise learning rates.
Revised: Thus, 1BitAdam is actually more like a distributed momentum SGD with some pre-conditioned coordinate-wise learning rates.

Original: The number of warm-up steps also needs to be carefully tuned, otherwise bad pre-conditioning may hurt the learning performance.
Revised: The number of warm-up steps also needs to be carefully tuned, otherwise bad pre-conditioning may hurt the learning performance.

Original: Our C OMP -AMS is simpler, as no pre-training is needed.
Revised: Our C OMP -AMS is simpler, as no pre-training is needed.

Original: Also, 1BitAdam requires extra tensors for m locally, while C OMP -AMS does not need additional local memory.
Revised: Also, 1BitAdam requires extra tensors for m locally, while C OMP -AMS does not need additional local memory.

Original:  C ONVERGENCE A NALYSIS
Revised:  C ONVERGENCE A NALYSIS

Original: For the convergence analysis of C OMP -AMS we will make following additional assumptions.
Revised: For the convergence analysis of C OMP -AMS we will make following additional assumptions.

Original: Assumption 2.
Revised: Assumption 2.

Original: (Smoothness)
Revised: (Smoothness)

Original: For ∀ i ∈ [ n ] , f i is L-smooth: (cid:107)∇ f i ( θ ) − ∇ f i ( ϑ ) (cid:107) ≤ L (cid:107) θ − ϑ (cid:107) .
Revised: For ∀ i ∈ [ n ] , f i is L-smooth: (cid:107)∇ f i ( θ ) − ∇ f i ( ϑ ) (cid:107) ≤ L (cid:107) θ − ϑ (cid:107) .

Original: Assumption 3.
Revised: Assumption 3.

Original: (Unbiased and bounded stochastic gradient)
Revised: (Unbiased and bounded stochastic gradient)

Original: For ∀ t > 0 , ∀ i ∈ [ n ] , the stochastic gradient is unbiased and uniformly bounded E t
Revised: For ∀ t > 0 , ∀ i ∈ [ n ] , the stochastic gradient is unbiased and uniformly bounded: E [ g t,i ]

Original: i = ∇ f i ( θ t ) t ≤ G .
Revised: = ∇ f i ( θ t ) and (cid:107) g t,i (cid:107) ≤ G .

Original: Assumption 4.
Revised: Assumption 4.

Original: (Bounded variance)
Revised: (Bounded variance)

Original: For ∀ t > 0 , ∀ i ∈ [ n ] : (i) the local variance of the stochastic gradient is bounded: E [ (cid:107) g t,i − ∇ f i ( θ t ) (cid:107) 2 ] < σ 2 ; (ii) the global variance is bounded by{+byn (cid:80) ni =
 (cid:107)∇ f [Equation]+}
Revised: For ∀ t > 0 , ∀ i ∈ [ n ] : (i) the local variance of the stochastic gradient is bounded: E [ (cid:107) g t,i − ∇ f i ( θ t ) (cid:107) 2 ] < σ 2 ; (ii) the global variance is bounded {+byn (cid:80) ni =
 (cid:107)∇ f [Equation]+}

Revised: [Equation]

Original: [Equation]
Revised: [Equation]

Revised: ) (cid:107)

Original:  In Assumption 3, the uniform bound on the stochastic gradient is common in the convergence analysis of adaptive methods, e.g., Reddi et al.
Revised: [Equation] ≤ [Equation] In Assumption 3, the uniform bound on the stochastic gradient is common in the convergence analysis of adaptive methods, e.g., Reddi et al.

Original: ; Zhou et al.
Revised: ; Zhou et al.

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

Original: The global variance bound σ 2 g in Assumption 4 characterizes the difference among local objective functions, which, is mainly caused by different local data distribution X i in (1).
Revised: The global variance bound σ 2 g in Assumption 4 characterizes the difference among local objective functions, which, is mainly caused by different local data distribution X i in (1).

Original: In classical distributed setting where all the workers can access the same dataset and local data are assigned randomly, σ 2 g ≡ 0 .
Revised: In classical distributed setting where all the workers can access the same dataset and local data are assigned randomly, σ 2 g ≡ 0 .

Original: The scenario where X i ’s are different gives rise to the recently proposed Federated Learning (FL) (McMahan et al., 2017) framework where local data can be non-i.i.d.

Original: While typical FL method with periodical model averaging is not the focus of this present paper, we consider the global variance in our analysis to shed some light on the impact of non-i.i.d.
Revised: While typical federated learning (FL) setting with σ 2 g > 0 is not the focus of this present paper, we consider the global variance in our analysis to shed some light on the impact of non-i.i.d.

Original: data distribution in the federated setting for broader interest and future investigation.
Revised: data distribution in the federated setting for broader interest and future investigation.

Original: We derive the following general convergence rate of C OMP -AMS in the distributed setting.
Revised: We derive the following general convergence rate of C OMP -AMS in the distributed setting.

Original: Theorem 1.
Revised: Theorem 1.

Original: Denote C 

Revised: Denote C

Original: = (cid:113) 4(1+ q 2 ) 

Revised: = (cid:113) 4(1+ q 2 )

Original: (1 − q 2 ) 2 G 2 + (cid:15) , C 1 = [Equation] 1 − q 2 , θ ∗ = arg min f ( θ ) .
Revised: (1 − q 2 ) 2 G 2 + (cid:15) , C 1 = β 1 1 − β 1 + 2 q 1 − q 2 , θ ∗ = arg min f ( θ ) deﬁned as (1).

Original: Under Assumption 1 toAssumption 4, with η t = η ≤ 
Revised: Under Assumption 1 to 4, with η t = η ≤ (cid:15)

Original: [Equation]
Revised: [Equation]

Original: 2 satisﬁes

Original: [Equation]
Revised: [Equation]

Original: The LHS of Theorem 1 is the expected squared norm of the gradient from a uniformly chosen iterate t ∈ [ T ] , which is a common convergence measure.
Revised: The LHS of Theorem 1 is the expected squared norm of the gradient from a uniformly chosen iterate t ∈ [ T ] , which is a common convergence measure in non-convex optimization.

Original: From Theorem 1, we see that the more compression we apply to the gradient vectors (i.e., larger q ), the larger the gradient magnitude is, i.e., the slower the algorithm converges.
Revised: From Theorem 1, we see that the more compression we apply to the gradient vectors (i.e., larger q ), the larger the gradient magnitude is, i.e., the slower the algorithm converges.

Original: This is intuitive as heavier compression loses more gradient information which would slower down the learner to ﬁnd a good solution.
Revised: This is intuitive as heavier compression loses more gradient information which would slower down the learner to ﬁnd a good solution.

Original: Note that, C OMP -AMS with n = 1 naturally reduces to the single-machine (sequential) AMSGrad (Algorithm 1) with compressed gradients instead of full-precision ones.
Revised: Note that, C OMP -AMS with n = 1 naturally reduces to the single-machine (sequential) AMSGrad (Algorithm 1) with compressed gradients instead of full-precision ones.

Original: The paper (Karimireddy et al., 2019) speciﬁcally analyzed this case for SGD, showing that  single-machine SGD with error feedback has the same convergence rate as vanilla SGD using full gradients.
Revised: Karimireddy et al. (2019) speciﬁcally analyzed this case for SGD, showing that compressed single-machine SGD with error feedback has the same convergence rate as vanilla SGD using full gradients.

Original: In alignment with the conclusion in Karimireddy et al.
Revised: In alignment with the conclusion in Karimireddy et al.

Original: (2019), for adaptive AMSGrad, we have a similar result.
Revised: (2019), for adaptive AMSGrad, we have a similar result.

Original: Corollary 1.
Revised: Corollary 1.

Original: When n = 1 , under Assumption 1 toAssumption 4, setting the stepsize as η = min {[Equation] √
Revised: When n = 1 , under Assumption 1 to 4, setting the stepsize as η = min {

Original: [Equation]
Revised: [Equation]

Original: L max {

Original: [Equation]

Original: [Equation]

Original: [Equation]

Original: } , Algorithm 2 satisﬁes:
Revised: , Algorithm 2 satisﬁes:

Original: [Equation]
Revised: [Equation]

Original: Corollary 1 states that with error feedback, single machine AMSGrad with biased compressed gradients can also match the convergence rate
Revised: Corollary 1 states that with error feedback, single machine AMSGrad with biased compressed gradients can also match the convergence rate

Original: O ( 1 √ T + dT ) of standard AMSGrad
Revised: O ( 1 √ T + dT ) of standard AMSGrad

Original: (Zhou et al., 2018) in non-convex optimization.
Revised: (Zhou et al., 2018) in non-convex optimization.

Original: It also achieves the same rate O ( 1 √ T ) of vanilla SGD (Karimireddy et al., 2019) when T is sufﬁciently large.
Revised: It also achieves the same rate O ( 1 √ T ) of vanilla SGD (Karimireddy et al., 2019) when T is sufﬁciently large.

Original: In other words, EF also ﬁxes the convergence issue of using compressed gradients in AMSGrad.
Revised: In other words, EF also ﬁxes the convergence issue of using compressed gradients in AMSGrad.

Original: Linear Speedup.
Revised: Linear Speedup.

Original: In Theorem 1, the convergence rate is derived assuming constant learning rate.
Revised: In Theorem 1, the convergence rate is derived assuming constant learning rate.

Original: By carefully choosing a decreasing learning rate dependent on the number of workers, we have the following simpliﬁed statement.
Revised: By carefully choosing a decreasing learning rate dependent on the number of workers, we have the following simpliﬁed statement.

Original: Corollary 2.
Revised: Corollary 2.

Original: Under the same setting as Theorem 1, set η = min {
Revised: Under the same setting as Theorem 1, set η = min {

Original: [Table]

Original: [Equation]
Revised: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: The
Revised: The

Original: C OMP -AMS iterates admit
Revised: C OMP -AMS iterates admit

Original: [Equation]
Revised: [Equation]

Original: In Corollary 2, we see that the global variance σ 2 g appears in the O ( 1 T ) term, which says that it asymptotically has no impact on the convergence.
Revised: In Corollary 2, we see that the global variance σ 2 g appears in the O ( 1 T ) term, which says that it asymptotically has no impact on the convergence.

Original: This matches the result of momentum SGD (Yu et al., 2019a).
Revised: This matches the result of momentum SGD (Yu et al., 2019a).

Original: When T ≥ O ( n 3 ) is sufﬁciently large, the third term in (2) vanishes, and the convergence rate becomes O ( 1 √ nT ) .
Revised: When T ≥ O ( n 3 ) is sufﬁciently large, the third term in (2) vanishes, and the convergence rate becomes O ( 1 √ nT ) .

Original: Therefore, to reach a O ( δ ) stationary point, one worker ( n = 1 ) needs T
Revised: Therefore, to reach a O ( δ ) stationary point, one worker ( n = 1 ) needs T

Original: = O ( 1 δ 2 ) iterations, while distributed training with n workers requires only T
Revised: = O ( 1 δ 2 ) iterations, while distributed training with n workers requires only T

Original: = O ( 1 Nδ 2 ) iterations, which is n times faster than single machine training.
Revised: = O ( 1 Nδ 2 ) iterations, which is n times faster than single machine training.

Original: That is, C OMP -AMS has a linear speedup in terms of the number of the local workers.
Revised: That is, C OMP -AMS has a linear speedup in terms of the number of the local workers.

Original: Such acceleration effect has also been reported for compressed SGD (Zheng et al., 2019; Jiang & Agrawal, 2018) and momentum SGD (Yu et al., 2019a) with error feedback.
Revised: Such acceleration effect has also been reported for compressed SGD (Zheng et al., 2019; Jiang & Agrawal, 2018) and momentum SGD (Yu et al., 2019a) with error feedback.

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: In this section, we provide numerical results on several real-world datasets.
Revised: In this section, we provide numerical results on several real-world datasets.

Original: Our main objective is to validate the theoretical results, and demonstrate that the proposed C OMP -AMS can approach the learning performance of full-precision AMSGrad with signiﬁcantly reduced communication costs.
Revised: Our main objective is to validate the theoretical results, and demonstrate that the proposed C OMP -AMS can approach the learning performance of full-precision AMSGrad with signiﬁcantly reduced communication costs.

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

Original: Our experiments are conducted on various image and text datasets.
Revised: Our experiments are conducted on various image and text datasets.

Original: The MNIST (LeCun et al., 1998) contains 60000 training samples of 28 × 18 gray-scale hand-written digits from 10 classes, and 10000 test samples.
Revised: The MNIST (LeCun et al., 1998) contains 60000 training samples of 28 × 18 gray-scale hand-written digits from 10 classes, and 10000 test samples.

Original: We train MNIST with a Convolutional Neural Network (CNN), which has two convolutional layers followed by two fully connected layers with ReLu activation.
Revised: We train MNIST with a Convolutional Neural Network (CNN), which has two convolutional layers followed by two fully connected layers with ReLu activation.

Original: Dropout is applied after the max-pooled convolutional layer with rate 0.5.
Revised: Dropout is applied after the max-pooled convolutional layer with rate 0.5.

Original: The CIFAR-10 dataset (Krizhevsky et al., 2009) consists of 50000 32 × 32 RGB natural images from 10 classes for training andimages for testing, which is trained by LeNet-5 (LeCun et al., 1998).
Revised: The CIFAR-10 dataset (Krizhevsky et al., 2009) consists of 50000 32 × 32 RGB natural images from 10 classes for training andimages for testing, which is trained by LeNet-5 (LeCun et al., 1998).

Original: Moreover, we also implement
Revised: Moreover, we also implement

Original: ResNet-18 (He et al., 2016) on this dataset.
Revised: ResNet-18 (He et al., 2016) on this dataset.

Original: The IMDB movie review (Maas et al., 2011) is a popular binary classiﬁcation dataset for sentiment analysis.
Revised: The IMDB movie review (Maas et al., 2011) is a popular binary classiﬁcation dataset for sentiment analysis.

Original: Each movie review is tokenized by topmost frequently appeared words and transformed into integer vectors, which is of maximal length 500.
Revised: Each movie review is tokenized by topmost frequently appeared words and transformed into integer vectors, which is of maximal length 500.

Original: We train an Long-Short Term Memory (LSTM) network with a 32-dimensional embedding layer and 64 LSTM cells, followed by two fully connected layers before output.
Revised: We train an Long-Short Term Memory (LSTM) network with a 32-dimensional embedding layer and 64 LSTM cells, followed by two fully connected layers before output.

Original: Cross-entropy loss is used for all the tasks.
Revised: Cross-entropy loss is used for all the tasks.

Original: In each training iteration, data sample are randomly assigned to the workers.
Revised: In each training iteration, data sample are randomly assigned to the workers.

Original: 5. G ENERAL E VALUATION AND C OMMUNICATION E FFICIENCY
Revised: 5. G ENERAL E VALUATION AND C OMMUNICATION E FFICIENCY

Original: We compare C OMP -AMS with full-precision distributed AMSGrad, QAdam (Chen et al., 2020) and 1BitAdam (Tang et al., 2021).
Revised: We compare C OMP -AMS with full-precision distributed AMSGrad, QAdam (Chen et al., 2020) and 1BitAdam (Tang et al., 2021).

Original: For C OMP -AMS, Top- k picks top 1% gradient coordinates (i.e., sparsity 0.01).
Revised: For C OMP -AMS, Top- k picks top 1% gradient coordinates (i.e., sparsity 0.01).

Original: QAdam and 1BitAdam both use 1-bit quantization to achieve high compression.
Revised: QAdam and 1BitAdam both use 1-bit quantization to achieve high compression.

Original: For MNIST and CIFAR-10, the local batch size on each worker is set to be 32.
Revised: For MNIST and CIFAR-10, the local batch size on each worker is set to be 32.

Original: For IMDB, the local batch size is 16.
Revised: For IMDB, the local batch size is 16.

Original: The hyper-parameters in C OMP -AMS are set as default β 1 = 0 .
Revised: The hyper-parameters in C OMP -AMS are set as default β 1 = 0 .

Original: 9 , β 2 = 0 .
Revised: 9 , β 2 = 0 .

Original: 999 and (cid:15) =
Revised: 999 and (cid:15) =

Original: 10 − 8 , which are also used for QAdam and 1BitAdam.
Revised: 10 − 8 , which are also used for QAdam and 1BitAdam.

Original: For 1BitAdam, the epochs for warm-up training is set to be 1 / 20 of the total epochs.
Revised: For 1BitAdam, the epochs for warm-up training is set to be 1 / 20 of the total epochs.

Original: For all methods, we tune the initial learning rate over a ﬁne grid and report the best results averaged over three independent runs.
Revised: For all methods, we tune the initial learning rate over a ﬁne grid and report the best results averaged over three independent runs.

Original: Our experiments are performed on a GPU cluster with NVIDIA Tesla V100 cards.
Revised: Our experiments are performed on a GPU cluster with NVIDIA Tesla V100 cards.

Original: The training loss and test accuracy on MNIST + CNN, CIFAR-10 + LeNet and IMDB + LSTM are reported in Figure 1.
Revised: The training loss and test accuracy on MNIST + CNN, CIFAR-10 + LeNet and IMDB + LSTM are reported in Figure 1.

Original: On CIFAR-10, we deploy a decreasing learning rate schedule which is divided by 10 at the 40-th and 80-th epoch, respectively.
Revised: On CIFAR-10, we deploy a decreasing learning rate schedule which is divided by 10 at the 40-th and 80-th epoch, respectively.

Original: We observe:
Revised: We observe:

Original: • On MNIST, all the methods can approach the training loss and test accuracy of fullprecision AMSGrad.
Revised: • On MNIST, all the methods can approach the training loss and test accuracy of fullprecision AMSGrad.

Original: The 1BitAdam seems slightly better, but the gap is very small.
Revised: The 1BitAdam seems slightly better, but the gap is very small.

Original: On CIFAR-10, C OMP -AMS with Block-Sign performs the best and matches AMSGrad in terms of test accuracy.
Revised: On CIFAR-10, C OMP -AMS with Block-Sign performs the best and matches AMSGrad in terms of test accuracy.

Original: • On IMDB, C OMP -AMS with Top- k has both the fastest convergence and best generalization.
Revised: • On IMDB, C OMP -AMS with Top- k has both the fastest convergence and best generalization.

Original: This is because the IMDB text data is sparse (with many padded zeros), where Top- k is expected to work better than sign.
Revised: This is because the IMDB text data is sparse (with many padded zeros), where Top- k is expected to work better than sign.

Original: The 1BitAdam converges slowly.
Revised: The 1BitAdam converges slowly.

Original: We believe one possible reason is that 1BitAdam is quite sensitive to the quality of the warm-up training.
Revised: We believe one possible reason is that 1BitAdam is quite sensitive to the quality of the warm-up training.

Original: For sparse text data, the estimation of second moment v is more unstable, making the strategy of freezing v by warm-up less effective.
Revised: For sparse text data, the estimation of second moment v is more unstable, making the strategy of freezing v by warm-up less effective.

Original: [Figure]
Revised: [Figure]

Original: Communication Efﬁciency.
Revised: Communication Efﬁciency.

Original: In Figure 2, we plot the training loss and test accuracy against the number of bits transmitted to the central server during the distributed training process, where we assume the full-precision gradient is represented using 32 bits.
Revised: In Figure 2, we plot the training loss and test accuracy against the number of bits transmitted to the central server during the distributed training process, where we assume the full-precision gradient is represented using 32 bits.

Original: As we can see, C OMP -AMS- Topk achieves around 100x communication reduction, to attain similar accuracy as the full-precision
Revised: As we can see, C OMP -AMS- Topk achieves around 100x communication reduction, to attain similar accuracy as the full-precision

Original: AMSGrad.
Revised: AMSGrad.

Original: The saving of Block-Sign is around 30x, but it gives slightly higher accuracy than Topk on MNIST and CIFAR-10.
Revised: The saving of Block-Sign is around 30x, but it gives slightly higher accuracy than Topk on MNIST and CIFAR-10.

Original: In all cases, C OMP -AMS can substantially reduce the communication cost compared with full-precision distributed AMSGrad, without losing accuracy.
Revised: In all cases, C OMP -AMS can substantially reduce the communication cost compared with full-precision distributed AMSGrad, without losing accuracy.

Original: Due to the space limitation, we provide more results on ResNet-18 in Appendix A
Revised: Due to the space limitation, we provide more results on ResNet-18 in Appendix A

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

Original: Corollary 2 reveals the linear speedup of C OMP -AMS in distributed training.
Revised: Corollary 2 reveals the linear speedup of C OMP -AMS in distributed training.

Original: In Figure 3, we present the training loss on MNIST and CIFAR-10 against the number of iterations, with varying number of workers n .
Revised: In Figure 3, we present the training loss on MNIST and CIFAR-10 against the number of iterations, with varying number of workers n .

Original: We use C OMP -AMS with Block-Sign on MNIST, and Top- k -0.01 on CIFAR.
Revised: We use C OMP -AMS with Block-Sign on MNIST, and Top- k -0.01 on CIFAR.

Original: As suggested by the theory, we use 5 × 10 − 4 √ n as the learning rate.
Revised: As suggested by the theory, we use 5 × 10 − 4 √ n as the learning rate.

Original: From Figure 3, we see the number of iterations to achieve a certain loss exhibits a strong linear relationship with n —it decreases by half whenever we double n , which justiﬁes the linear speedup of C OMP -AMS.
Revised: From Figure 3, we see the number of iterations to achieve a certain loss exhibits a strong linear relationship with n —it decreases by half whenever we double n , which justiﬁes the linear speedup of C OMP -AMS.

Original: 5. D ISCUSSION
Revised: 5. D ISCUSSION

Original: We provide a brief summary of our empirical observations.
Revised: We provide a brief summary of our empirical observations.

Original: The proposed C OMP -AMS is able to match the learning performance of full-gradient AMSGrad in all the experiments.
Revised: The proposed C OMP -AMS is able to match the learning performance of full-gradient AMSGrad in all the experiments.

Original: In particular, for data/model involving some sparsity structure, C OMP -AMS with the Top- k compressor could be more effective.
Revised: In particular, for data/model involving some sparsity structure, C OMP -AMS with the Top- k compressor could be more effective.

Original: Also, our results reveal that 1BitAdam with second moment pre-conditioning might have unstable performance on some tasks in practice.
Revised: Also, our results reveal that 1BitAdam with second moment pre-conditioning might have unstable performance on some tasks in practice.

Original: We would like to emphasize that, the primary goal of the experiments is to show that C OMP -AMS is able to match the performance of full-precision AMSGrad, but not to show that C OMP -AMS is “better than” other algorithms.
Revised: We would like to emphasize that, the primary goal of the experiments is to show that C OMP -AMS is able to match the performance of full-precision AMSGrad, but not to argue that C OMP -AMS is “better than” other algorithms.

Original: This is because, different methods use different underlying optimization algorithms (e.g., AMSGrad, Adam, momentum SGD).
Revised: This is because, different methods use different underlying optimization algorithms (e.g., AMSGrad, Adam, momentum SGD).

Original: Comparing C OMP -AMS with other distributed training methods would be largely affected by the comparison among these optimization protocols, which typically depends on the speciﬁc data and model in practice.
Revised: Comparing C OMP -AMS with other distributed training methods would be largely affected by the comparison among these optimization protocols, which typically depends on the speciﬁc data and model in practice.

Original: Our results says that: whenever one wants to use AMSGrad to train a deep neural network, he/she can simply employ the distributed C OMP -AMS scheme to gain a linear speedup in training time with learning performance as good as the full-precision training, taking little communication cost and memory consumption.
Revised: Our results says that: whenever one wants to use AMSGrad to train a deep neural network, he/she can simply employ the distributed C OMP -AMS scheme to gain a linear speedup in training time with learning performance as good as the full-precision training, taking little communication cost and memory consumption.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: In this paper, we study the simple, convenient, yet unexplored gradient averaging strategy for distributed adaptive optimization called C OMP -AMS.
Revised: In this paper, we study the simple, convenient, yet unexplored gradient averaging strategy for distributed adaptive optimization called C OMP -AMS.

Original: Top-
Revised: Top-

Original: k and Block-Sign compressor are incorporated for communication efﬁciency, whose biases are compensated by the error feedback strategy.
Revised: k and Block-Sign compressor are incorporated for communication efﬁciency, whose biases are compensated by the error feedback strategy.

Original: We develop the convergence rate of C OMP -AMS, and show that same as the case of SGD, for AMSGrad, compressed gradient averaging with error feedback matches the convergence of full-gradient
Revised: We develop the convergence rate of C OMP -AMS, and show that same as the case of SGD, for AMSGrad, compressed gradient averaging with error feedback matches the convergence of full-gradient

Original: AMSGrad, and linear speedup can be obtained in the distributed training.
Revised: AMSGrad, and linear speedup can be obtained in the distributed training.

Original: Numerical experiments are conducted to justify the theoretical ﬁndings, and demonstrate that C OMP -AMS provides comparable performance with other distributed adaptive methods, and achieves similar accuracy as full-precision
Revised: Numerical experiments are conducted to justify the theoretical ﬁndings, and demonstrate that C OMP -AMS provides comparable performance with other distributed adaptive methods, and achieves similar accuracy as full-precision

Original: AMSGrad with signiﬁcantly reduced communication overhead.
Revised: AMSGrad with signiﬁcantly reduced communication overhead.

Original: Given the simple architecture and hardware (memory) efﬁciency, we expect C OMP -AMS to serve as a useful distributed adaptive optimization framework in practice.
Revised: Given the simple architecture and hardware (memory) efﬁciency, we expect C OMP -AMS to serve as a useful distributed adaptive optimization framework in practice.

Original: A M ORE E XPERIMENTAL R ESULTS ON R ES N ET - 
Revised: A M ORE E XPERIMENTAL R ESULTS ON R ES N ET -

Original: In this section
Revised: In this section

Original: [Figure]
Revised: [Figure]

Original: we provide more experimental results on CIFAR-10 dataset, trained with ResNet18 (He et al., 2016).
Revised: we provide more experimental results on CIFAR-10 dataset, trained with ResNet18 (He et al., 2016).

Original: For reference, we also present the result of distributed SGD.
Revised: For reference, we also present the result of distributed SGD.

Original: As we can see from
Revised: As we can see from

Original: Figure 4, again C OMP -AMS can achieve similar accuracy as AMSGrad, and the Top- k compressor gives the best accuracy, with substantial communication reduction.
Revised: Figure 4, again C OMP -AMS can achieve similar accuracy as AMSGrad, and the Top- k compressor gives the best accuracy, with substantial communication reduction.

Original: Note that distributed SGD converges faster than adaptive methods, but the generalization error is slightly worse.
Revised: Note that distributed SGD converges faster than adaptive methods, but the generalization error is slightly worse.

Original: This experiment again conﬁrms that the proposed C OMP -AMS method can achieve satisfactory performance
Revised: This experiment again conﬁrms that the proposed C OMP -AMS method can achieve satisfactory performance

Original: [Figure]
Revised: [Figure]

Original: B P ROOF OF THE C ONVERGENCE R ESULTS B. P ROOF OF T HEOREM
Revised: B P ROOF OF THE C ONVERGENCE R ESULTS B. P ROOF OF T HEOREM

Original: Theorem.
Revised: Theorem.

Original: Denote C 

Revised: Denote C

Original: = (cid:113) 4(1+ q 2 ) 

Revised: = (cid:113) 4(1+ q 2 )

Original: (1 − q 2 ) 2 G 2 + (cid:15) , C 1 = β 1 1 − β 1 + 2 q 1 − q 2 .
Revised: (1 − q 2 ) 2 G 2 + (cid:15) , C 1 = β 1 1 − β 1 + 2 q 1 − q 2 .

Original: Under Assumption 1 to Assumption 4, with η t = η ≤ (cid:15)
Revised: Under Assumption 1 to Assumption 4, with η t = η ≤ (cid:15)

Original: [Equation]
Revised: [Equation]

Original: C
Revised: C

Original: [Equation]
Revised: [Equation]

Original: 2 L max { 2 L,C 2 } , for any T > 0 , C OMP -AMS satisﬁes
Revised: 2 L max { 2 L,C 2 } , for any T > 0 , C OMP -AMS satisﬁes

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: We ﬁrst clarify some notations.
Revised: We ﬁrst clarify some notations.

Original: At time t , let the full-precision gradient of the j -th worker be g t,j , the error accumulator be e t,j , and the compressed gradient be ˜ g t,j = C ( g t,j + e t,j ) .
Revised: At time t , let the full-precision gradient of the j -th worker be g t,j , the error accumulator be e t,j , and the compressed gradient be ˜ g t,j = C ( g t,j + e t,j ) .

Original: Denote ¯ g t = 1 n (cid:80) nj =1 g t,j , ˜ g t = 1 n (cid:80) nj
Revised: Denote ¯ g t = 1 n (cid:80) nj =1 g t,j , ˜ g t = 1 n (cid:80) nj

Original: =1 ˜ g t,j and ¯ e t = 1 n (cid:80) nj =1 e t,j .
Revised: =1 ˜ g t,j and ¯ e t = 1 n (cid:80) nj =1 e t,j .

Original: The second moment computed by the compressed gradients is denoted as v t = β 2 v t − 1 + (1 − β 2 )˜
Revised: The second moment computed by the compressed gradients is denoted as v t = β 2 v t − 1 + (1 − β 2 )˜

Original: g 2 t , and ˆ v t = max { ˆ v t − 1 , v t } .
Revised: g 2 t , and ˆ v t = max { ˆ v t − 1 , v t } .

Original: Also, the ﬁrst order moving average sequence
Revised: Also, the ﬁrst order moving average sequence

Original: [Equation]
Revised: [Equation]

Original: By construction we have m
Revised: By construction we have m

Original: [Equation]
Revised: [Equation]

Original: Denote the following auxiliary sequences,
Revised: Denote the following auxiliary sequences,

Original: [Equation]
Revised: [Equation]

Original: Then,
Revised: Then,

Original: [Equation]
Revised: [Equation]

Original: where (a) uses the fact that for every j ∈ [ n ] , ˜ g t,j + e t +1 ,j = g t,j + e t,j , and e t, 1 = 0 at initialization.
Revised: where (a) uses the fact that for every j ∈ [ n ] , ˜ g t,j + e t +1 ,j = g t,j + e t,j , and e t, 1 = 0 at initialization.

Original: Further deﬁne the virtual iterates:
Revised: Further deﬁne the virtual iterates:

Original: [Equation]
Revised: [Equation]

Original: which follows the recurrence:
Revised: which follows the recurrence:

Original: [Equation]
Revised: [Equation]

Original: When summing over t = 1 , ..., T
Revised: When summing over t = 1 , ..., T

Original: [Equation]
Revised: [Equation]

Original: the difference sequence D t satisﬁes the bounds of Lemma 5.
Revised: the difference sequence D t satisﬁes the bounds of Lemma 5.

Original: By Assumption 2 we have
Revised: By Assumption 2 we have

Original: [Equation]
Revised: [Equation]

Original: Taking expectation w.r.t.
Revised: Taking expectation w.r.t.

Original: the randomness at time t , we obtain
Revised: the randomness at time t , we obtain

Original: [Equation]
Revised: [Equation]

Original: Bounding term I.
Revised: Bounding term I.

Original: We have
Revised: We have

Original: [Equation]
Revised: [Equation]

Original: where we use Assumption 3, Lemma 4 and the fact that l 2 norm is no larger than l 1 norm.
Revised: where we use Assumption 3, Lemma 4 and the fact that l 2 norm is no larger than l 1 norm.

Original: Bounding term II.
Revised: Bounding term II.

Original: It holds that
Revised: It holds that

Original: [Equation]
Revised: [Equation]

Original: where C 1 := β 1 1 − β 1 + 2 q 1 − q 2 .
Revised: where C 1 := β 1 1 − β 1 + 2 q 1 − q 2 .

Original: The second inequality is because of smoothness of f ( θ ) , and the last inequality is due to Lemma 2, Assumption 3 and the property of norms.
Revised: The second inequality is because of smoothness of f ( θ ) , and the last inequality is due to Lemma 2, Assumption 3 and the property of norms.

Original: Bounding term III.
Revised: Bounding term III.

Original: This term can be bounded as follows:
Revised: This term can be bounded as follows:

Original: [Equation]
Revised: [Equation]

Original: where (a) follows from ∇ f ( θ t )
Revised: where (a) follows from ∇ f ( θ t )

Original: = 1 n (cid:80) nj =1 ∇ f j ( θ t ) and Assumption 4 that g t,j is unbiased of ∇ f j ( θ t ) and has bounded variance σ 2 .
Revised: = 1 n (cid:80) nj =1 ∇ f j ( θ t ) and Assumption 4 that g t,j is unbiased of ∇ f j ( θ t ) and has bounded variance σ 2 .

Original: Bounding term IV.
Revised: Bounding term IV.

Original: We have
Revised: We have

Original: [Equation]
Revised: [Equation]

Original: where (a) is due to Young’s inequality and (b) is based on Assumption 2.
Revised: where (a) is due to Young’s inequality and (b) is based on Assumption 2.

Original: Regarding the second term in (7), by Lemma 3 and Lemma 1, summing over t = 1 , ..., T we have
Revised: Regarding the second term in (7), by Lemma 3 and Lemma 1, summing over t = 1 , ..., T we have

Original: T
Revised: T

Original: [Equation]
Revised: [Equation]

Original: with C 2 :=
Revised: with C 2 :=

Original: [Equation]
Revised: [Equation]

Original: + 4 q 2 (1 − q 2 ) 2 .
Revised: + 4 q 2 (1 − q 2 ) 2 .

Original: Now integrating (4), (5), (6), (7) and (8) into (3), taking the telescoping summation over t = 1 , ..., T , we obtain
Revised: Now integrating (4), (5), (6), (7) and (8) into (3), taking the telescoping summation over t = 1 , ..., T , we obtain

Original: E [ f ( x T +1 ) − f ( x 1 )]
Revised: E [ f ( x T +1 ) − f ( x 1 )]

Original: [Equation]
Revised: [Equation]

Original: E [ (cid:107) D t (cid:107) 2 . with C 0 :
Revised: E [ (cid:107) D t (cid:107) 2 . with C 0 :

Original: = (cid:113) 4(1+ q 2 ) 

Revised: = (cid:113) 4(1+ q 2 )

Original: (1 − q 2 ) 2 G 2 + (cid:15) .
Revised: (1 − q 2 ) 2 G 2 + (cid:15) .

Original: Setting η ≤ (cid:15) 3 C 0 √ 2 L max { 2 L,C 2 } and choosing ρ = (cid:15) 3 C 0 , we obtain
Revised: Setting η ≤ (cid:15) 3 C 0 √ 2 L max { 2 L,C 2 } and choosing ρ = (cid:15) 3 C 0 , we obtain

Original: E [ f ( x T +1 ) − f ( x 1 )]
Revised: E [ f ( x T +1 ) − f ( x 1 )]

Original: [Equation]
Revised: [Equation]

Original: where the last inequality follows from Lemma 5.
Revised: where the last inequality follows from Lemma 5.

Original: Re-arranging terms
Revised: Re-arranging terms

Original: [Equation]
Revised: [Equation]

Original: we get that
Revised: we get that

Original: [Equation]
Revised: [Equation]

Original: where C 0 = (cid:113)

Original: [Equation]

Original: 1+ q

Original: [Equation]

Original: ) 3 (1 −

Original: [Equation] ) 2 G 2 + (cid:15) , C [Equation] = β 1 1 − β 1 + 2 q 1 − q 2 .
Revised: , where C 0 = (cid:113) 4(1+ q 2 ) 3 (1 − q 2 ) 2 G 2 + (cid:15) , C 1 = β 1 1 − β 1 + 2 q 1 − q 2 .

Original: The last inequality is because θ (cid:48) [-
-] = θ [Equation] θ ∗ := arg min θ f ( θ ) and the fact that C 2 ≤ C 1 .
Revised: The last inequality is because θ (cid:48) [-
-]1 = θ 1 , θ ∗ := arg min θ f ( θ ) and the fact that C 2 ≤ C 21 .

Original: This completes the proof.
Revised: This completes the proof

Original: Proofs of Corollary 2 and Corollary 1 follow naturally from the above.
Revised: [Equation]

Original: B. I NTERMEDIATE L EMMAS
Revised: B. I NTERMEDIATE L EMMAS

Original: Lemma 1.
Revised: Lemma 1.

Original: Under Assumption 1 to Assumption 4 we have:
Revised: Under Assumption 1 to Assumption 4 we have:

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: Firstly, the expected squared norm of average stochastic gradient can be bounded by
Revised: Firstly, the expected squared norm of average stochastic gradient can be bounded by

Original: [Equation]
Revised: [Equation]

Original: where we use Assumption 4 that g t,i is unbiased with bounded variance.
Revised: where we use Assumption 4 that g t,i is unbiased with bounded variance.

Original: Let ¯ g t,i denote the i -th coordinate of ¯ g t .
Revised: Let ¯ g t,i denote the i -th coordinate of ¯ g t .

Original: By the updating rule of C OMP -AMS
Revised: By the updating rule of C OMP -AMS

Original: [Equation]
Revised: [Equation]

Original: ≤ (
Revised: ≤ (

Revised: [Equation]

Revised: − β

Revised: [Equation]

Revised: t (cid:88)

Original: [Equation]
Revised: [Equation]

Original: β
Revised: β

Original: [Equation]
Revised: [Equation]

Revised: −

Original: t (cid:88) τ = β t
Revised: [Equation] (cid:107) [Equation] ≤

Original: [Equation]
Revised: [Equation]

Revised: n + (

Revised: [Equation]

Revised: − β

Original: [Equation]
Revised: [Equation]

Original: t (cid:88) 
Revised: t (cid:88) τ

Revised: = β t − τ

Revised: [Equation]

Revised: [ (cid:107)∇

Original: [Equation]
Revised: [Equation]

Original: where (a) is due to Cauchy-Schwartz inequality.
Revised: where (a) is due to Cauchy-Schwartz inequality.

Original: Summing over t = 1 , ..., T , we obtain
Revised: Summing over t = 1 , ..., T , we obtain

Original: [Equation]
Revised: [Equation]

Original: This completes the proof.
Revised: This completes the proof.

Original: Lemma 2.
Revised: Lemma 2.

Original: Under Assumption [Equation] we have for ∀ t and each local worker ∀ i ∈ [ n ] ,
Revised: Under Assumption 4, we have for ∀ t and each local worker ∀ i ∈ [ n ] ,

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: We start by using Assumption 1 and Young’s inequality to get
Revised: We start by using Assumption 1 and Young’s inequality to get

Original: [Equation]
Revised: [Equation]

Original: by choosing ρ = 1 − q 2 2 q 2 .
Revised: by choosing ρ = 1 − q 2 2 q 2 .

Original: Now by recursion and the initialization e 1 ,i =
Revised: Now by recursion and the initialization e [Equation] i =

Original: [Equation]
Revised: [Equation]

Original: we have
Revised: we have

Revised: [Equation]

Revised: θ

Original: [Equation]
Revised: [Equation]

Original: which proves the second argument.
Revised: which proves the second argument.

Original: Meanwhile, the absolute bound (cid:107) e t,i (cid:107) 2 ≤ [Equation] [Equation] G 2 follows directly from (9).
Revised: Meanwhile, the absolute bound (cid:107) e t,i (cid:107) 2 ≤ 4 q 2 (1 − q 2 ) 2 G 2 follows directly from (9).

Original: Lemma 3.
Revised: Lemma 3.

Original: For the moving average error sequence E t , it holds that
Revised: For the moving average error sequence E t , it holds that

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: Let ¯ e t,i be the j -th coordinate of ¯ e t .
Revised: Let ¯ e t,i be the j -th coordinate of ¯ e t .

Original: Denote K t,i := (cid:80) tτ
Revised: Denote K t,i := (cid:80) tτ

Original: =1 ( 1+ q 2 2 ) t − τ E
Revised: =1 ( 1+ q 2 2 ) t − τ E

Original: [ (cid:107)∇ f i ( θ τ ) (cid:107) 2 ] and
Revised: [ (cid:107)∇ f i ( θ τ ) (cid:107) 2 ] and

Original: K t,i = 0 , ∀ i ∈ [ n ] .
Revised: K t,i = 0 , ∀ i ∈ [ n ] .

Original: Using the same technique as in the proof of Lemma 1, we have
Revised: Using the same technique as in the proof of Lemma 1, we have

Original: E
Revised: [Equation] [Equation]

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

Original: (cid:88)
Revised: (cid:88)

Revised: [Equation]

Revised: [Equation]

Original: j
Revised: τ

Original: [Equation]
Revised: [Equation]

Original: E [( t(cid:88) τ =
Revised: t

Original: [Equation]
Revised: [Equation]

Original: β t − τ 
Revised: )( t (cid:88) τ =

Original: [Equation]
Revised: [Equation]

Original: ¯ e  τ
Revised: e 2 τ

Original: [Equation]
Revised: [Equation]

Original: j )
Revised: j )]

Original: [Equation]
Revised: [Equation]

Original: ] ( a ) ≤ (1 − β 1 ) 2 d (cid:88) 
Revised: (1 − β 1 ) t (cid:88) τ = β t −

Original: j =
Revised: [Equation]

Original: E [( t (cid:88) τ
Revised: E [ (cid:107) ¯ e

Original: = β t − τ)( t (cid:88) τ = β t − τ¯ e 2 τ,j )] ≤ (1 − β 1 ) t (cid:88) τ = β t − τ E [ (cid:107) ¯ e τ (cid:107) 2 ] ≤ (1 − β 1 ) t (cid:88) τ
Revised: [Equation]

Original: = β t − τ E [ 1 n n (cid:88) i = (cid:107)
Revised: (cid:107) 2 ] ≤ (1 − β 1 )

Original: [-e τ,i (cid:107) 2 ] ( b ) ≤ 4 q(1 − q 2 ) 
 σ 2 + 2 q 2 (1 − β 1 ) (1 − q 2 ) t (cid:88) τ = β t − τ(n n (cid:88) i =-]
Revised: [-e τ,i (cid:107) 2 ] ( b ) ≤ 4 q(1 − q 2 ) 
 σ 2 + 2 q 2 (1 − β 1 ) (1 − q 2 ) t (cid:88) τ = β t − τ(n n (cid:88) i =-][Equation]

Original: K τ,i ) , where (a) is due to Cauchy-Schwartz and (b) is a result of Lemma 2.
Revised: where (a) is due to Cauchy-Schwartz and (b) is a result of Lemma 2.

Original: Summing over t = 1 , ..., T and using the technique of geometric series summation leads to
Revised: Summing over t = 1 , ..., T and using the technique of geometric series summation leads to

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

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

Original: =
Revised: =

Original: [Equation]
Revised: [Equation]

Original: (n
Revised: (n

Original: [Equation]
Revised: [Equation]

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

Original: K
Revised: K

Original: [Equation]
Revised: [Equation]

Original: i )
Revised: i )

Original: [Equation]
Revised: [Equation]

Original: 4 Tq(
Revised: 4 Tq(

Original: [Equation]
Revised: [Equation]

Original: + 2 q(
Revised: + 2 q(

Original: [Equation]
Revised: [Equation]

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

Original: =
Revised: =

Original: (1 + q ) t − τ E
Revised: (1 + q ) t − τ E

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

Original: (cid:107)∇ f i ( θ τ ) (cid:107) 2 ] ≤
Revised: (cid:107)∇ f i ( θ τ ) (cid:107) 2 ] ≤

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

Original: 4 q(
Revised: 4 q(

Original: [Equation]
Revised: [Equation]

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

Original: E [ 1 n n (cid:88) i =
Revised: E [ 1 n n (cid:88) i =

Original: (cid:107)∇ f i ( θ t ) (cid:107) 2 ] (
Revised: (cid:107)∇ f i ( θ t ) (cid:107) 2 ] (

Original: [Equation]
Revised: [Equation]

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

Original: 4 q
Revised: 4 q

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

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

Original: E [ (cid:107) 1 n n (cid:88) i =
Revised: E [ (cid:107) 1 n n (cid:88) i =

Original: [Equation]
Revised: [Equation]

Original: f i (
Revised: f i (

Original: [Equation]
Revised: [Equation]

Original: t ) (cid:107) 2 + 1 n n (cid:88) i =
Revised: t ) (cid:107) 2 + 1 n n (cid:88) i =

Original: (cid:107)∇ f i ( θ t )
Revised: (cid:107)∇ f i ( θ t )

Original: [Equation]
Revised: [Equation]

Original: f (
Revised: f (

Original: [Equation]
Revised: [Equation]

Original: t
Revised: t

Original: [Equation]
Revised: [Equation]

Original: (cid:107) 2 ]
Revised: (cid:107) 2 ]

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

Original: 4 q
Revised: 4 q

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

Original: q 2 )
Revised: q 2 )

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

Original: [Equation]
Revised: [Equation]

Original: where (a) is derived by the variance decomposition and the last inequality holds due to Assumption 4.
Revised: where (a) is derived by the variance decomposition and the last inequality holds due to Assumption 4.

Original: The desired result is obtained.
Revised: The desired result is obtained.

Original: Lemma 4.
Revised: Lemma 4.

Original: It holds that ∀ t ∈ [ T ] , ∀ i ∈
Revised: It holds that ∀ t ∈ [ T ] , ∀ i ∈

Original: [ d ] , ˆ v t,i ≤ 4(1+ q 2 ) 3 (1 − q 2 ) 2 G 2 .
Revised: [ d ] , ˆ v t,i ≤ 4(1+ q 2 ) 3 (1 − q 2 ) 2 G 2 .

Original: Proof.
Revised: Proof.

Original: For any t , by Lemma 2 and Assumption 3 we have
Revised: For any t , by Lemma 2 and Assumption 3 we have

Original: [Equation]
Revised: [Equation]

Original: It’s then easy to show by the updating rule of ˆ v t ,
Revised: It’s then easy to show by the updating rule of ˆ v t ,

Original: [Equation]
Revised: [Equation]

Original: Lemma 5.
Revised: Lemma 5.

Original: Let D t :=
Revised: Let D t :=

Original: [Equation]
Revised: [Equation]

Original: be deﬁned as above.
Revised: be deﬁned as above.

Original: Then,
Revised: Then,

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: By the updating rule of C OMP -AMS, ˆ v t − 1 ≤ ˆ v t for ∀ t .
Revised: By the updating rule of C OMP -AMS, ˆ v t − 1 ≤ ˆ v t for ∀ t .

Original: Therefore, by the initialization ˆ v 0 = 0 , we have
Revised: Therefore, by the initialization ˆ v 0 = 0 , we have

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

Original: [Equation]
Revised: [Equation]

Original: For the sum of squared l 2 norm, note the fact that for a ≥ b > 0 , it holds that
Revised: For the sum of squared l 2 norm, note the fact that for a ≥ b > 0 , it holds that

Original: [Equation]
Revised: [Equation]

Original: Thus,
Revised: Thus,

Original: [Equation]
Revised: [Equation]

Original: which gives the desired result.
Revised: which gives the desired result.