Communication Efficient Distributed Training with Distributed Lion

Authors: bo  liu
lemeng  wu
lizhang  chen
kaizhao  liang
jiaxu  zhu
meta  ai
chen  liang
raghuraman  krishnamoorthi
qiang  liu
Venue: NeurIPS_cc_2024_Conference
Published: 2024-05-15 21:19:44

Abstract: The Lion optimizer has been a promising competitor with the AdamW for training large AI models, with advantages in memory, computation, and sample efficiency. In this paper, we introduce Distributed Lion, an innovative adaptation of Lion for distributed training environments. Leveraging the sign operator in Lion, our Distributed Lion only requires to communicate binary or lower-precision vectors
between workers to the center server, significantly reducing the communication cost.  
Our theoretical analysis confirms Distributed Lion's convergence properties. Empirical results demonstrate its robustness across a range of tasks, worker counts, and batch sizes, on both vision and language problems. Notably, Distributed Lion attains comparable performance to standard Lion or AdamW optimizers applied on aggregated gradients, but with significantly reduced communication bandwidth. This feature is particularly advantageous for training large models. In addition, we also demonstrate that \mavolion{} presents a more favorable performance-bandwidth balance compared to existing efficient distributed methods such as deep gradient compression and ternary gradients.

Main paper: 
 introduction: 
 The pursuit of modern artificial intelligence hinges on the training of large-scale models like large language models [28] and large vision models (LVM) [20] . As the stakes -in terms of time, cost, and environmental impact -grow ever higher for training expansive AI systems, the hunt for efficient optimizers becomes critical.Recently, a new optimization named Lion (evolved sign momentum) [11] has been discovered with an evolutionary program. It was shown that it exhibits performance on par with the current state-ofthe-art AdamW [26] across a wide range of tasks, while reducing the memory cost and training time. T Q W O q f L y 8 o T C O t R K a E W J 1 E + A V a q / O 3 I c K z W K A 1 0 Z Y x i o W W 8 s / u f 1 M 4 g u v J y J N A M q y G R R l H E L E m u c i x U y S Q n w k S a Y S K Z v t c g A S 0 x A p 1 f T I T i z X 5 4 n n Z O G c 9 Z w b k 7 r z c t p H F W 0 h w 7 Q E X L Q O W q i a 9 R C b U T Q I 3 p G r + j N e D J e j H f j Y 1 J a M a Y 9 u + g P j M 8 f y r C b l g = = < / l a t e x i t > 1,t < l a t e x i t s h a 1 _ b a s e 6 4 = " P i / d j Y r U X r s m w o U q + Q M T U X M v v j Y = " > A A A C C n i c b V D L S s N A F J 3 U V 6 2 v q E s 3 o 0 V w I S U p o i 6 L b l x W s A 9 o Q p h M J n b o 5 M H M j V h C 1 m 7 8 F T c u F H H r F 7 j z b 5 y m X W j 1 w M D h n P u a 4 6 e C K 7 C s L 6 O y s L i 0 v F J d r a 2 t b 2 x u m d s 7 X Z V k k r I O T U Q i + z 5 R T P C Y d Y C D Y P 1 U M h L 5 g v X 8 0 e X E 7 9 0 x q X g S 3 8 A 4 Z W 5 E b m M e c k p A S 5 6 5 7 w C 7 h 3 J O r i 0 W A y l y J 2 A C i J c 3 j 6 E o P L N u N a w S + C + x Z 6 S O Z m h 7 5 q c T J D S L 9 C w q i F I D 2 0 r B z Y k E T g U r a k 6 m W E r o S G 8 b a B q T i C k 3 L 0 8 o 8 K F W A h w m U r 8 Y c K n + 7 M h J p N Q 4 8 n V l R G C o 5 r 2 J + J 8 3 y C A 8 d 3 M e p x m w m E 4 X h Z n A k O B J L j j g k l E Q Y 0 0 I l V z f i u m Q S E J B p 1 f T I d j z X / 5 L u s 2 G f d q w r 0 / q r Y t Z H F W 0 h w 7 Q E b L R G W q h K 9 R G H U T R A 3 p C L + j V e D S e j T f j f V p a M W Y 9 u + g X j I 9 v z D i b l w = = < / l a t e x i t > 2,t < l a t e x i t s h a 1 _ b a s e 6 4 = " A W a u K U o 0 y A X 4 1 + t L 4 E 0 3 H R O l u U I = " > A A A C C H i c b V D L S s N A F J 3 U V 6 2 v q E s X B o v g q i Q i Consider optimizing a loss function f D (x) on R d with a dataset D, the update rule of Lion is:i p Q q N G z v 7 w w J m l E h S Y c K 9 V 1 n U T 7 G Z a a E U 5 n Z S 9 V N M F k h A e 0 a 1 D g i C o / m 1 8 + Q + f G C V E / l u Y J j e b u 7 4 k M R 0 p N o 8 B 0 R l g P 1 X I t N / + r d V P d v / U z J p J U U 0 E W i / o p R z p G e Q w o Z J I S z a c G M J H M 3 I r I E E t M t A m r b E J w l 7 + 8 C q 3 L m n t d c x + v K v W 7 I o 4 S n M I Z V M G F G 6 j D A z S g C Q Q m 8 A y v 8 G Z l 1 o v 1 b n 0 s W t e s Y u Y E / s j 6 / A H x A p M 2 < / l a t e x i t > < l a t e x i t s h a 1 _ b a s e 6 4 = " p Q k 4 8 C k G g 1 q U M o v k G h B / n D t x F j I = " > A A A B + X i c b Z D L S s N A F I Z P v N Z 6 i 7 p 0 M 1 i E u i m J i L o s u n F Z w V 6 g C W Ui p Q q N G z v 7 w w J m l E h S Y c K 9 V 1 n U T 7 G Z a a E U 5 n Z S 9 V N M F k h A e 0 a 1 D g i C o / m 1 8 + Q + f G C V E / l u Y J j e b u 7 4 k M R 0 p N o 8 B 0 R l g P 1 X I t N / + r d V P d v / U z J p J U U 0 E W i / o p R z p G e Q w o Z J I S z a c G M J H M 3 I r I E E t M t A m r b E J w l 7 + 8 C q 3 L m n t d c x + v K v W 7 I o 4 S n M I Z V M G F G 6 j D A z S g C Q Q m 8 A y v 8 G Z l 1 o v 1 b n 0 s W t e s Y u Y E / s j 6 / A H x A p M 2 < / l a t e x i t > < l a t e x i t s h a 1 _ b a s e 6 4 = " s D 5 G B u W 0 c M U R T 7 L n 0 m D e f j 6 A O b M = " > A A A C C n i c b V C 7 T s M w F H X K q 5 R X g J E l U C E x o C o B B I w V L I x F o g + p i S L H c a h V x 4 n s G 0 Q V Z W b h V 1 g Y Q I i V L 2 D j b 3 D T D l A 4 k q W j c + 7 L J 0 g 5 U 2 D b X 0 Z l b n 5 h c a m 6 X F t Z X V v f M D e 3 O i r J J K F t k v B E 9 g K s K G e C t o E B p 7 1 U U h w H n H a D 4 e X Y 7 9 5 R q V g i b m C U U i / G t 4 J F j G D Q k m / u u k D v o Z y T a 4 s K w E X u h p Q D 9 v P j Q y g K 3 6 z b D b u E 9 Z c 4 U 1 J H U 7 R 8 8 9 M N E 5 L F e h b h W K m + Y 6 f g 5 V g C I 5 w W N T d T N M V k q L f 1 N R U 4 p s r L y x M K a 1 8 r o R U l U j 8 B V q n + 7 M h x r N Q o D n R l j G G g Z r 2 x + J / X= " > A A A C A 3 i c b V B N S 8 N A E N 3 4 W e t X 1 Z t e g k X w V B I R 9 V j U g 8 c K 9 g P a U j b b S b t 0 s w m 7 E z G E g B f / i h c P i n j 1 T 3 j z 3 7 h t c 9 D W B w O P 9 2 Z 2 d p 4 X C a 7 R c b 6 t h c W l 5 Z X V w l p x f W N z a 7 u 0 s 9 v Q Y a w Y 1 F k o Q t X y q A b B J d S R o 4 B W p I A G n o C m N 7 o a + 8 1 7 U J q H 8 g 6 T C L o B H U j u c 0 b R S L 3 S f g f h A S f v p C y h M k s 7 1 y C Q 9 j D r l c p O x Z n A n i d u T s o k R 6 1 X + u r 0 Q x Y H I J E J q n X b d S L s p l Q h Z w K y Y i f W E F E 2 o g N o G y p p A L q b T n Z n 9 p F R + r Y f K l M S 7 Y n 6 e y K l g d Z J 4 J n O g O J Q z 3 p j 8 T + v H a N / 0 U 2 5 j G I E y a a L / F j Y G N r j Q O w + V 8 B Q J I Z Q p r j 5 q 8 2 G V F G G J r a i C c G d P X m e N E 4 q 7 l n F v T 0 t V y / z O A r k g B y S Y + K S c 1 I l N 6 R G 6 o S R R / J M X s m b 9 W S 9 W O / W x 7 R 1 w c p n 9 s g f W J 8 / b G + Y q Q = = < / l a t e x i t > t low-precision orEQUATIONwhere m t plays the role of the momentum, ϵ is the learning rate, β 1 , β 2 ∈ [0, 1]2 are two momentum related coefficients, and λ ≥ 0 is the weight decay coefficient. Comparing Lion against AdamW, one observes that Lion only requires the storage of the first-order momentum term, which results in a more relaxed memory requirement.In this study, we tailor the Lion optimizer for distributed training. The Lion optimizer is particularly suitable for this context due to two main attributes: (1) its simple update mechanism that relies solely on first-order momentum, and (2) its use of the sign(•) function. We showcase the effective employment of the sign(•) function to streamline communication processes, leading to the development of a novel distributed training framework named Distributed Lion. Within the Distributed Lion framework, each participating worker independently adjusts the model parameters using a distinct instance of the Lion optimizer, thereby maintaining separate optimizer states. A distinctive feature of this framework is the mode of communication between workers and the central server, which is restricted to binary or low-precision vectors.Crucially, in this setup, workers convey updates rather than raw gradients to the central server. The server, in turn, aggregates these updates through either a straightforward averaging process (Distributed Lion-Avg) or a majority voting mechanism (Distributed Lion-MaVo). In the case of Distributed Lion-MaVo, the consolidated update is maintained as a binary vector, whereas for Distributed Lion-Avg, given the presence of n workers, each element of the update vector is encoded using log(n) bits. This approach markedly reduces the bandwidth requirements compared to traditional distributed training methods, which typically rely on high-precision floating-point vectors for communication. The bandwidth efficiencies achieved by our method are detailed in Table 1 . Our contributions are: 1) We introduce the Distributed Lion algorithm, a simple yet effective approach to extend Lion to distributed training, where all communications between workers and the server are done through binary or low-precision vectors (Section 2); 2) We provide theoretical analysis to ensure the convergence of Distributed Lion (Section 3); 3) Empirically, we demonstrate that on both vision and language modeling tasks, Distributed Lion achieves comparable performance against applying Lion and Adam with the synchronized gradients from all workers, while being significantly more communication efficient. In addition, we show that Distributed Lion achieves a better trade-off than existing efficient distributed training methods like deep gradient compression [24] and ternary gradients [36] (Section 5).Global Lion/AdamW 32d 32d TernGrad [36] 1.5d log(2n + 1)d DGC [24] (1 -η)32d  
the distributed lion: 
 We introduce the distributed learning problem and then our Distributed Lion framework.In distributed training, we aim to minimize the following learning objective:EQUATIONHere, N denotes the number of workers, {D i } are N datasets, 3 and x is the model parameter (e.g., the weights of a neural network). In the distributed learning setting, each worker i ∈ [n] will get its own dataset D i , and we assume there is a centralized server that all workers can communicate with. The simplest distributed training technique is to perform distributed gradient aggregation:EQUATIONHere, each local gradient g i is an unbiased estimation of the true gradient ∇ x F (x) when D i are i.i.d. drawn from the same underlying distribution. The server aggregates all local gradients into g server , and then applies an optimizer like Adam [19] on top of g server . However, the aggregation step requires communicating the full gradient vectors g i , which can be expensive for large models.Notation. Given a function f (x; ξ), the gradient ∇f (x; ξ) is taken with respect to variable x. We use ∥ • ∥, ∥ • ∥ 1 , and ∥ • ∥ ∞ to denote the ℓ 2 , ℓ 1 , and ℓ ∞ norm, respectively. ξ i,t is the sampled data at time t for the i-th worker and g i,t = ∇f (x t ; , ξ i,t ). We similarly denote z i,t as any variable z at time t from worker i.The main idea of Distributed Lion is to leverage the binary nature of the Lion's update for efficient communication. To enable that, we want the workers to only send the binary updates to the server. As a result, we let each worker keep tracks of its own optimizer state, i.e., the momentum m i,t . Then at each step, each worker i first computes:EQUATIONThen all workers send the δ i,t back to the server. The server receives the binary "updates" from all workers and then aggregates them. Here, we propose two simple ways for aggregation. Denote S t = N i=1 δ i,t , which is a vector of integers in {0, . . . N }. Define the aggregation as follows:EQUATIONInputs: Initial parameters x 0 ∈ R d , datasets {D 1 , . . . , D N }, loss function f , learning rate ϵ, hyper-parameters β 1 , β 2 ∈ [0, 1] (default to 0.9, 0.99) 4 , and the weight decay λ.Initialization: t = 0, ∀i, m i,0 = 0, and x i,0 = x 0 .while not convergent do Worker-side: Each worker i samples a batch ξ i,t ∈ D i , computes the following, and sends δ i,t to the server:if t > 0, x i,t ← x i,t-1 -ϵ ∆ t-1 + λx i,t-1 δ i,t ← sign β 1 m i,t + (1 -β 1 )∇ x f (x i,t ; ξ i,t ) m i,t+1 ← β 2 m i,t + (1 -β 2 )∇ x f (x i,t ; ξ i,t ).Server-side: The server computes the aggregated update ∆ t and broadcast it to all workers:∆ t = 1 N N i=1 δ i,t (Averaging) sign N i=1 δ i,t(Majority Vote) and t ← t + 1.So we simply average or take the majority vote from all {δ i,t }. Here, we denote binary vectors in magenta and low precision vectors in cyan. In the end, the server broadcasts ∆ t back to each worker i, and each worker performs x i,t+1 = x i,t -ϵ(∆ t + λx i,t ), where ϵ is the step size and λ is the weight decay coefficient.In both variants of Distributed Lion, the N workers only need to send the binary vectors δ i,t to the server. The server then sends the aggregated update ∆ t back to the workers, which is binary when using the majority vote aggregation, and an integer in {0, . . . , N } when using the averaging aggregation. Note that an integer in {0, . . . , N } can be represented by at most log(N ) bits. In practice, usually N ≪ 2 32 hence log(N ) < 32 and we still save the communication bandwidth even with the average aggregation, comparing against communicating with floating point numbers (Check Table 1 ). The full Distributed Lion algorithm is summarized in Algorithm 1. 
theoretical analysis: 
 We provide our theoretical analysis of the Distributed Lion algorithm, both with the averaging and the majority vote aggregation methods. In the following, we first describe that the distributed training problem can be viewed as a constrained optimization problem when Distributed Lion is used. We provide convergence results for Distributed Lion with both aggregation methods.Chen et al. [10] showed that the (global) Lion is a theoretically novel and principled approach for minimizing a general loss function f (x) while enforcing a box-constrained optimization problem: minEQUATIONwhere the constraint is introduced due to the use of the weight decay coefficient λ. Moreover, Chen et al. [10] showed that the Lion dynamics consists of two phases:1) [Phase 1] When the constraint is not satisfied, that is, x ̸ ∈ F, where F is the feasible setF def = {x : ∥λx∥ ∞ ≤ 1}, it exponentially decays the distance to F: ∃ α ∈ (0, 1), such that dist(x t+n , F) ≤ α n dist(x t , F).where n ≥ 0. Hence, x t converges to F rapidly and stays within F once it reaches it.2) [Phase 2] After λx t enters F, the dynamics minimizes the objective f (x) while being confined within the set F. This step is proved in [10] by constructing a Lyapunov function when sign(•) is treated as the sub-gradient of a convex function.In this section, we analyze the convergence of distributed Lion algorithms. Similar to the case of global Lion, we show that distributed Lion also solves the box constrained optimization (6) . Its dynamics also unfolds into two phases aligning with Lion's dynamics: Phase I shows rapid convergence to a feasible set F, while Phase II seeks to minize the objective f (x) within the feasible set F. Different from the Lyapunov approach used in Chen et al. [10] , the proof of our Phase II result is made by introducing a surrogate metric S(x) of constrained optimality, and providing upper bound of S(x t ) following the algorithm. Our analysis makes the following assumptions. Assumption 3.1 (Variance bound). D i is i.i.d. drawn from a common distribution π * , and the stochastic sample ξ i ∼ D i is i.i.d. and upon receiving query x ∈ R d , the stochastic gradient oracle gives us an independent unbiased estimate ∇f (x; ξ i ) from the i-th worker that has coordinate bounded variance:E ξ [∇f (x; ξ i )] = ∇f (x), E ξ ∥∇f (x; ξ i ) -∇f (x)∥ 2 ≤ σ 2 . Assumption 3.2 (Smooth and Differentiable f ). Function f (•) is differentiable and L-smooth. Assumption 3.3 (Bias Correction). Consider the sequence {m i t } t>0,i∈[N ] generated by Algorithm 1, E[ mi t ]/E[sign( mi t )] ≥ 0.Note that assumption 3.1 and 3.2 are standard in the analysis of stochastic optimization algorithms [8, 34] . When Assumption 3.1 holds, E∥ 1N N i=1 ∇f (x; ξ i ) -∇f (x)∥ 2 ≤ σ 2 /N . In distributed training setting, m 1,t , m 2,t , • • • , m N,t are i.i.d., so E[β 1 m i,t + (1 -β 1 )g i,t] and E[sign( mi t+1 )] don't depend on i. Assumption 3.3 evaluates the discrepancy between the expected value and the expected sign of a measure, positing that the expected values of mi t and sign(m i t ) ought to share the same sign. We now present our results. Similar to the case of global Lion, the dynamics of distributed lion can also be divided into two phases depending on if the constraint x ∈ F is satisfied.Phase I (x ̸ ∈ F) In line with the behavior observed in the global Lion, when the constraint is not satisfied, both variants of distributed Lion decrease the distance to the feasible set exponentially fast. Theorem 3.4 (Phase I). Assume f : R d → R is L-smooth, β 1 , β 2 ∈ (0, 1), and β 2 > β 1 , and ϵ, λ > 0. Let (x t ) t≥0 be generated by Algorithm 1. Define F = {x : ∥λx∥ ∞ ≤ 1}, and dist(x t , F) = inf z∈F ∥z -x t ∥ w.r.t. any norm ∥•∥. For any two non-negative integers s ≤ t, then ∀s ≤ t, we havedist(x t , F) ≤ (1 -ϵλ) t-s dist(x s , F).Hence, x t converges to F rapidly and stays within F once it arrived.Phase II (x ∈ F) Now, we present the main result of the analysis for Phase II in Theorems 3.6, 3.7, and 3.8. We start with introducing a surrogate metric that quantifies the optimality of the solution within Phase II: S(x) := ⟨∇f (x), sign(∇f (x)) + λx⟩.Let's delve into the implications of S(x) = 0. Proposition 3.5. Assume f is continuously differentiable, λ > 0, and ∥λx∥∞ ≤ 1. Then S(x) = 0 implies a KKT stationary condition of min x f (x) s.t. ∥λx∥ ∞ ≤ 1.This KKT score ( 7) is tailored to encompass the stationary solutions of the box constrained problem as described in (6) . Building on this, we then proceed to analyze the convergence for the majority vote, averaging, and global LION strategies throughout this section. Theorem 3.6 (Majority Vote). Assumptions 3.1, 3.2, and 3.3 hold, consider the Majority vote scheme in Algorithm 1 , β 1 , β 2 ∈ (0, 1), and β 2 > β 1 , and σ ≤ 2 √ dβ 1 β t 2 ∥∇f (x 0 )∥, 1 ≤ t ≤ T , and ϵ, λ > 0. Let (x t ) t≥0 be generated by Majority Vote, and it is in Phase II: ∥λx t ∥ ∞ ≤ 1 for all t.We haveEQUATIONwhereC = β 2 1 (1 -β 2 ) 1 1+β2 + (1 -β 1 ) 2 , and D = max{1, σ/ 2 √ dβ 1 β T 2 ∥∇f (x 0 )∥ }, ρ t [k] = 0 if E[sign( mi t+1 [k])] = 0, E[ mi t+1 [k]]/E[sign( mi t+1 [k])] otherwise, and ρ = max 1≤t≤T ∥ρ t ∥.The result above shows that 1T T t=1 E[S(x t )] decays with a rate of O( 1 T ϵ + 1 T (1-β2) + ϵ + 1 √ N). This rate is in fact on par with global Lion as we show in the following result. Theorem 3.7 (Global). Assumptions 3.1 and 3.2 hold, Consider the scheme in Algorithm (16) , with the same settings in Theorem 3.6, we haveEQUATION)Theorem 3.8 (Averaging). Assumptions 3.1 and 3.2 hold, consider the Averaging scheme in Algorithm 1 , with the same settings in Theorem 3.6, we haveEQUATIONThe Averaging method's convergence bound doesn't improve with more workers since  
related work: 
 In this section, we provide a summary of optimizers that use the sign function and existing literature on bandwidth-friendly distributed training.The sign operation is integral to optimization for several reasons. Primarily, it acts as a normalization mechanism by disregarding the magnitude of gradients, thereby equilibrating updates across different dimensions and potentially facilitating the avoidance of saddle points. Additionally, the binary nature of the sign function's output significantly reduces the memory footprint required for storing gradient updates. The concept of sign-based optimization dates back to RProp [30] and has seen renewed interest with the advent of SignSGD and its momentum-enhanced variant, Signum [4] . A more recent advancement is the generalized SignSGD algorithm introduced by [14] , which incorporates a preconditioner, making it a superset of SignSGD and akin to Adam in certain aspects. A noteworthy addition to sign-based optimizers is the Lion optimizer, which emerged from evolutionary program search, achieving performance comparable to Adam [19] and AdamW [26] for the first time. Lion distinguishes itself from Signum by employing a different convex combination for outputting local updates, a technique referred to as the double-β scheme, reminiscent of Nesterov's momentum update, and encapsulates Signum as a particular case. On the theoretical front, SignSGD and Signum have been shown to exhibit convergence rates comparable to traditional SGD [4] . Recent work by [34] has extended the theoretical understanding by providing a convergence theory that relaxes the requirements for bounded stochastic gradients and enlarged batch sizes. Additionally, Lion has demonstrated its capability in performing constrained optimization under the ℓ ∞ -norm constraint [10] .Distributed Training In addressing the communication constraints of distributed training, the research community has devised several innovative strategies, prominently featuring asynchronous Stochastic Gradient Descent (SGD), gradient quantization, and sparsification techniques. Asynchronous SGD offers a solution by enabling parameter updates immediately after back-propagation, bypassing the need for gradient synchronization, thereby expediting the training process [9, 40, 25] . Li et al. [21] utilizes sketch-based algorithms for lossless data compression [23] , achieving an asymptotically optimal compression ratio [22] . However, its applicability is limited to highly sparse gradients, making it orthogonal to our research. In the realm of gradient quantization, methods such as 1-bit SGD [33] , QSGD [2] , and TernGrad [36] are pivotal. These approaches compact the gradient data, substantially reducing the required communication bandwidth, with 1-bit SGD demonstrating a tenfold acceleration in speech applications and both QSGD and TernGrad confirming the feasibility of quantized training in maintaining convergence. Moreover, gradient sparsification further mitigates the communication load by transmitting only the most substantial gradients. Techniques like threshold quantization and Gradient Dropping [1] exemplify this, with Gradient Dropping notably achieving a 99 reduction in gradient exchange with minimal impact on performance metrics, such as a mere 0.3 loss in BLEU score for machine translation tasks. The recent Deep Gradient Compression (DGC) strategy [24] also contributes to this field by incorporating momentum correction and local gradient clipping among other methods to maintain accuracy while significantly reducing communication demands, albeit at the cost of increased computational overhead. Compared to gradient quantization methods, Distributed Lion uniquely leverages the binary nature of Lion's update and can be viewed as performing quantization on updates rather than the gradient. 
experiment: 
 In this section, we perform a thorough evaluation of the Distributed Lion algorithm, employing both the averaging and majority vote aggregation methods. The design of our experiments is aimed at addressing the following questions to ascertain the algorithm's efficacy and performance:(Q1) How does Mavolion perform in comparison to traditional global distributed training methods, which aggregate gradients from local workers to apply an optimizer to the collective gradient? (Q2) How does Mavolion measure up against established methodologies known for their communication efficiency in distributed training? (Q3) How does Distributed Lion scale on large vision or language problems?To address Q1 and Q2, we compare Distributed Lion with both the averaging and the majority vote methods, against established low-bandwidth distributed training techniques and the global distributed training methods. We consider the following baseline methods: 1) Global AdamW (G-AdamW), where we apply AdamW with the averaged gradients from all workers. 2) Global Lion (G-Lion), where we apply Lion with the averaged gradients from all workers. Note that Global AdamW and Global Lion serve as the performance and communication upper bounds. 3) Distributed Lion with Averaged Updates (D-Lion (Avg)), In contrast to the majority vote mechanism used in Distributed Lion, this variant averages the binary update vectors from all workers. While D-Lion (Avg) might offer improved performance in principle, it comes at the cost of non-binary communication from the server to the workers. 4) TernGrad [36] . The main idea is to tenarize the gradient into a vector of {-1, 0, 1}, which is similar to what Lion does. But this process is done on the gradient level instead of on the update level 5) Gradient Dropping (GradDrop) [1] . The main idea is to drop insignificant gradient entries and only transmit sparse gradient signals. 6) Deep Gradient Compression (DGC) [24] . DGC is built on top of the GradDrop, but additionally applies momentum correction, local gradient clipping, momentum factor masking, and warm-up training.Experiment Setup For GradDrop, DGC, and TernGrad, we choose the compression rate of 0.04 (note that 1/32 = 0.03125) to match the bandwidth of the D-Lion (MaVo). We conduct experiments on the CIFAR-10 dataset using a vision transformer (ViT) with 6 layers, 8 heads, and a hidden dimension of 512. This is because ViT has arguably become the most widely used architecture in computer vision, and we empirically found no additional gain in performance when using a larger ViT on CIFAR-10. In addition, to validate how Distributed Lion performs with different numbers of workers, we consider k ∈ {4, 8, 16, 32}, each worker at each step samples an i.i.d batch of size 32.We list the optimal hyperparameters selected for each method from Figure 2 in Table 4 . The learning rates are selected from {0.00005, 0.001, 0.005, 0.01} and the weight decays are selected from {0.0005, 0.001, 0.005}. For each experiment, we use a cosine learning rate scheduler and run for 200 epochs, and we ensure that in each epoch, each local worker sees the entire dataset once. Observation We plot the testing accuracy (Test Acc.) over epochs for different methods in Figure 2 , the best testing accuracy of different methods over the number of workers in Figure 3 , and the performance versus per-iteration bandwidth in Figure 4 when using k = 4 workers. From the above plots, we make the following observations.• Compared to global methods, D-Lion (MaVo) performs on par with G-Lion. D-Lion (Avg) performs slightly worse than G-Lion but is on par with G-Adamw (Figure 2 ).• Compared to established communication efficient methods, both D-Lion (MaVo) and D-Lion (Avg) outperform GradDrop, DGC and TernGrad by a large margin (Figure 2 ).• We observe that both D-Lion (MaVo) and D-Lion (Avg) exhibit strong performance while being 30x more communication efficient than global distributed training methods like G-AdamW. To broaden our comparison, we introduced two additional baseline methods: D-SIGNUM (Avg) and D-SIGNUM (MaVo). These baselines apply our proposed techniques to the SIGNUM framework instead of Lion. 5 We set β = 0.99 for D-SIGNUM. According to our results, depicted in Figure 4 , these SIGNUM-based methods do not perform as well as their Lion-based counterparts.• We notice that the overall performance of the same optimizer is worse as k is larger, this is consistent with the observation made in DGC [24] . We hypothesize that this may be due to the larger effective batch size resulting in smaller stochasticity, which is consistent with why D-Lion (MaVo) performs a bit better than G-Lion on CIFAR-10 (Figure 3 ).To answer Q3, we validate Distributed Lion on several large-scale setups including both vision and natural language processing tasks. Under this setting, we compare D-Lion (MaVo) and D-Lion (Avg) against G-AdamW and G-Lion. For the vision task, we tested ViT-S/16 [16] and ViT-B/16 on the ImageNet-1K [31] classification benchmark. For the natural language processing task, we perform both language pretraining and finetuning tasks. This is because Lion has shown good results on language modeling. For the language model pretraining task, we pretrain GPT2++ [29] (the GPT-2 model with modern training techniques adopted from the LLaMA model [35] ) on the OpenWebText [17] benchmark, for both 350M and 760M size models. For the language model finetuning task, we conduct few-shot finetuning of the LLaMA 7B model [35] and evaluate the models' downstream performance on standard downstream evaluation benchmarks [13, 37, 12, 27, 7, 32] .Experiment Setup For the ImageNet-1K benchmark, we train all methods for 300 epochs, using a global batch size of 4096 and data augmentations MixUp [39] of 0.5 and AutoAug [15] . When training ViT-S/16, we use a learning rate of 3e -3 for G-AdamW, with betas of (0.9, 0.999) and a weight decay of 0.1. For G-Lion, D-Lion (MaVo), and D-Lion (Avg), we use a learning rate of 3e -4 , betas of (0.9, 0.99), and a weight decay of 1.0. As for ViT-B/16, we use a learning rate of 1e -3 for G-AdamW, with betas of (0.9, 0.999) and a weight decay of 1.0, while for all Lion variants, we use a learning rate of 1e -4 , betas of (0.9, 0.99), and a weight decay of 10.0. For pretraining language models on the OpenWebText dataset, we build GPT2++ models using the original GPT2 model, but with modern training techniques from the LLaMA model, including using the Gated Linear Unit activation for the multilayer layer perceptron layers (MLPs) and the RMSNorm [38] instead of the LayerNorm [3] . Following the Chinchilla scaling law [18] , we trained the 350M model for 14,000 iterations and the 760M model for 30,000 iterations, both with 1,024 tokens. For G-AdamW, we use a learning rate of 3e -4 , betas of (0.95, 0.99), and a weight decay of 0.1. For all Lion variants, we use a learning rate of 9e -5 , betas of (0.9, 0.99), and a weight decay of 1.0. All the models are trained under a global batch size of 480. For the instruction finetuning task, we instruct finetune a LLaMA 7B model for 3 epochs with batch size 32. We use 2e -5 learning rate, betas of (0.9, 0.999), 0 weight decay for G-AdamW and 6e -6 , (0.9, 0.99) betas, 0.01 weight decay for all Lion variants. For all pretraining experiments, we use 4nodes × 8gpus = 32 workers. For instruction finetuning experiments, we use 4 workers per experiment. can maintain a performance similar to, or even better than, that of G-AdamW and G-Lion, on both large-scale vision and language tasks. We observe that D-Lion (Avg) outperforms D-Lion (MaVo) on ImageNet, and observe the opposite on language modeling and instruction finetuning. We hypothesize that these differences are due to the impact of global batch size. As a result, we recommend using D-Lion (Avg) / (MaVo) when the global batch size is large / small. 
conclusion and future work: 
 In this paper, we introduced Distributed Lion, a communication-efficient distributed training strategy that builds upon the Lion optimizer's binary update mechanism. Distributed Lion is designed to minimize communication overhead by allowing workers to independently manage their optimizer states and exchange only binary or low-precision update vectors with the server. We proposed two aggregation techniques within the Distributed Lion framework: average-based (Distributed Lion Avg) and majority vote-based (Distributed Lion MaVo) algorithms. We provide both theoretical and empirical results to demonstrate Distributed Lion's effectiveness, scalability, and efficiency. Notably, we show that Distributed Lion performs significantly better than existing communication-friendly methods. In the meantime, Distributed Lion demonstrates performance on par with strong global distributed training baselines, while being 32x more communication efficient. As our method is orthogonal to existing communication-efficient methods, an interesting future direction is to combine both techniques for further improvement. As a limitation, currently Distributed Lion (Avg / MaVo) performs inconsistently across different datasets and benchmarks, it will be an interesting future research direction to understand when and why one performs better than the other. 
acknowledgment: 
 The research is conducted in Statistics & AI group at UT Austin, which receives supports in part from NSF CAREER1846421, SenSE2037267, Office of Navy Research, and NSF AI Institute for Foundations of Machine Learning (IFML). 
 
 Appendix: In this section, we provide additional experiment details.We list the optimal hyperparameters selected for each method from Figure 2 in Table 4 . The learning rates are selected from {0.00005, 0.001, 0.005, 0.01} and the weight decays are selected from {0.0005, 0.001, 0.005}. This section is focusing on the proof of Lion dynamics, and will be organized into these folders:• Phase I:-Constraint enforcing: Discrete time We study phase I in this section. We show that when the constraint is not satisfied, both variants of distributed Lion decrease the distance to the feasible set exponentially fast.Theorem B.1 (Phase I). Assume f : R d → R is L-smooth, β 1 , β 2 ∈ (0, 1), and β 2 > β 1 , and ϵ, λ > 0, and 1 -ϵλ ∈ (0, 1). Let (x t ) t≥0 be generated by Algorithm 1. Define F = {x : ∥λx∥ ∞ ≤ 1}, and dist(x t , F) = inf z∈F ∥z -x t ∥ w.r.t. any norm ∥•∥.For any two non-negative integers s ≤ t, then ∀s ≤ t, we havedist(x t , F) ≤ (1 -ϵλ) t-s dist(x s , F).Proof. Recall Algorithm 1:δ i,t ← sign β 1 m i,t + (1 -β 1 )∇ x f (x t ; ξ i,t ) m i,t+1 ← β 2 m i,t + (1 -β 2 )∇ x f (x t ; ξ i,t ) ∆ t = 1 N N i=1 δ i,t (Averaging) sign N i=1 δ i,t(Majority Vote)x t+1 = x t -ϵ(∆ t + λx t )Rewrite the update into the following form:x t+1 = (1 -ϵλ)x t -ϵ∆ t ,Define w s→t = (1 -ϵλ) t-s . Unrolling this update yields,x t = (1 -w s→t )z s→t + w s→t x s , z s→t = t-1 k=s w k→t (-∆ t /λ) t-1 k=s w k→t .We have z s→t ∈ F since -∆ t /λ ∈ F. For any ϵ > 0, let xs ∈ F be the point satisfying ∥x s -x s ∥ ≤ dist(x s , F) + η. Hence, we havedist(x t , F) = inf z∈F ∥x t -z∥ ≤ ∥x t -(1 -w s→t )z s→t -w s→t xs )∥ = w s→t ∥x s -xs ∥ ≤ (1 -ϵλ) t-s (dist(x s , F) + η).As η → 0, we achieve the desired result.We study the convergence of Phase II in this section. We begin by defining a KKT score function to quantify stationary solutions for the box-constrained optimization problem discussed in Section B. E ξ [∇f (x; ξ i )] = ∇f (x), E ξ ∥∇f (x; ξ i ) -∇f (x)∥ 2 ≤ σ 2 .i t } t>0,i∈[N ] generated by Algorithm 1, E[ mi t ]/E[sign( mi t )] ≥ 0.Here we define the a KKT score function for box constrained problem (6):S(x) := ⟨∇f (x), sign(∇f (x)) + λx⟩.Proposition B.5. Assume f is continuously differentiable, λ > 0, and ∥λx∥ ∞ ≤ 1. Then S(x) = 0 implies a KKT stationary condition of min x f (x) s.t. ∥λx∥ ∞ ≤ 1.Proof. We will verify that S(x) = 0 coincides with the first order KKT conditions of the box constrained optimization problem (6) .Recall the box constrained problem in (6) , we can rewrite it into the following formulation:min x∈R d f (x) s.t. λx i -1 ≤ 0, -λx i -1 ≤ 0, ∀ i ∈ [d]. Let µ = (µ 1 , µ 2 , • • • , µ d ) ⊤ and μ = (μ 1 , μ2 , • • • , μd ) ⊤, then its first order KKT stationary condition can be written as:∂ xi f (x) + µ i λ -μi λ = 0 //Stationarity µ i (λx i -1) = 0, μi (-λx i -1) = 0 //Complementary slackness µ i ≥ 0, μi ≥ 0 //Dual feasibility λx i -1 ≤ 0, -λx i -1 ≤ 0 //Primal feasibility ∀ i ∈ {1, 2, • • • , d}.Expressing S(x) element-wisely, we obtain:S(x) = d k=1 S k (x), with S k (x) = ∂ x k f (x) • (sign(∂ x k f (x)) + λx k ) ,where x k denotes the k-th element of vector x. Since ∥λx∥ ∞ ≤ 1, we have S k (x) ≥ 0, becauseS k (x) = ∂ x k f (x) • (sign(∂ x k f (x)) + λx k ) = |∂ x k f (x)| + λ∂ x k f (x) • x k ≥ |∂ x k f (x)| -|∂ x k f (x)| • |λx k | = |∂ x k f (x)|(1 -|λx k |) ≥ 0 //since ∥λx∥ ∞ ≤ 1.Hence, if S(x) = 0, we have S k (x) = 0 for each component k. It means that we have eithersign(∂ x k f (x)) + λx k = 0 or ∂ x k f (x) = 0 for each coordinate k.There are two primary cases to consider for each k:• Case I: ∂ x k f (x) = 0.This suggests that we reach a stationary condition of f (x) w.r.t. coordinate x k , and the KKT condition is satisfied in this case with µ k = μk = 0.• Case II:sign(∂ x k f (x)) + λx k = 0, it follows that x k = -1 λ sign(∂ x k f (x)). -if sign(∂ x k f (x) = 1, then ∂ x k f (x) ≥ 0,and the KKT condition is satisfied withµ k = 0 and μk = ∂ x k f (x)/λ -if sign(∂ x k f (x)) = -1, then ∂ x k f (x) ≤ 0,and the KKT condition is satisfied with μk = 0 andµ k = ∂ x k f (x)/λ.It turns out the two cases above exactly covers the KKT stationary solution pair (x, µ, μ) of the box constrained problem in (6) .In conclusion, S(x) = 0 signifies reaching a stationary point of the bound-constrained optimization problem, as formulated in (6) , providing critical insights into the convergence behavior of the algorithm under consideration.Assume f : R d → R is L-smooth, and N is the number of workers, on the i-th worker, consider the following scheme based on the majority vote: g i t := ∇f (x t ; ξ i t ) m i t+1 = β 2 m i t + (1 -β 2 )g i t mi t+1 = β 1 m i t + (1 -β 1 )g i t x t+1 = x t -ϵ sign N i=1 sign( mi t+1 ) + λx t . //∥ ∞ ≤ 1.We haveEQUATIONρ t [k] = 0 if E[sign( mi t+1 [k])] = 0, E[ mi t+1 [k]]/E[sign( mi t+1 [k])] else.Proof. Following Theorem B.1 from phase 1, once we have ∥λx 0 ∥ ∞ ≤ 1, we stay within the constraint set with ∥λx t ∥ ≤ 1 for all subsequent time t ≥ 0.For notation, write Mt+1 = N i=1 sign( mi t+1 ). This yields x t+1 = x t -ϵsign( Mt+1 ) -ϵλx t . We haveEQUATIONwhere we used ∥x t+1 -x t ∥ 2 = ϵ 2 sign( Mt+1 ) + λx t 2 ≤ 4ϵ 2 d, because ∥λx t ∥ ∞ ≤ 1. By Assumption B.3, m1 t+1 , m2 t+1 , • • • , mN t+1 are i.i.d., so E[ mi t+1] and E[sign( mi t+1 )] don't depend on i. Hence we can defineR t+1 = E[ mi t+1 ]/E[sign( mi t+1 )],where the division operation is element wise, so R t+1 ∈ R d . By Assumption 3.3, R t is non-negative, one special case for the ratio R t is when E[sign( mit [k])] = 0, yet E[ mi t [k]] ̸ = 0, leading to R t [k] = +∞ for k ∈ [d]. In such instance, P ( mi t [k] > 0) = 1/2 derived from the equation E[sign( mi t [k])] = 2P ( mi t [k] > 0) -1 = 0, for k ∈ [d]. First, recognizing that E[sign( Mt [k])] = 0 is straightforward as we model it as a binomial distribution with success probability p = 1/2 for t > 0. This leads to the resultE∇f (x t )[k] sign(∇f (x t )[k]) -sign( Mt [k]) = E |∇f (x t )[k]|.Given that E[X] = arg min z E ∥X -z∥ 2 defines the expectation of a random variable X as the value z minimizes the expected euclidean distance to X, and the median X = arg min z E ∥X -z∥ 1 defines the median as the value z minimizing the expected absolute distance to X, for a R.V. X in R, recall our case where P ( mi t [k] > 0) = 1/2, which is equivalent to that the median is 0. From this, it follows thatE |∇f (x t )[k]| ≤ E[E ξ [ ∇f (x t ; ξ i t )[k] -∇f (x t )[k] 1 ]] ≤ E E ξ ∇f (x t ; ξ i t )[k] -∇f (x t )[k] 2 2 ≤ σ.To bound the last term in (12) ⟨∇f (x t ), sign(∇f (x t )) -sign( Mt+1 )⟩, we follow a structured approach. Here's an outline for bounding this term:To bound the last term in Equation (12) , ⟨∇f (x t ), sign(∇f (x t )) -sign( Mt+1 )⟩, we follow a structured approach: • For R t [k] < +∞, standard bounding techniques can be applied, potentially leveraging properties of R t to establish a finite upper bound.• For R t [k] = +∞, it's actually bounding ∥∇f (x t )∥. This can be bounded by the variance of the stochastic gradient g i t .4. Merge Cases with Finite ρ t Replacing R t : After separately proving bounds for each case of R t , the results are unified by substituting R t with a finite ρ t , where ρ t serves a similar purpose but ensures a manageable, finite adjustment.Case I (Finite R t+1 )The first step is to expand this inner product, we have E⟨∇f (x t ), sign(∇f (x t )) -sign( Mt+1 )⟩ = E⟨∇f (x t ), sign(∇f (x t )) -sign( 1 N Mt+1 )⟩ = E d k=1 ∇f (x t )[k] sign(∇f (x t )[k]) -sign( 1 N Mt+1 [k]) = 2E d k=1 R t+1 [k] ∇f (x t )[k]/R t+1 [k] - 1 N Mt+1 [k] = 2E d k=1 R t+1 [k] ∇f (x t )[k]/R t+1 [k] - 1 N N i=1 sign( mi t+1 [k]) . //(x t )[k]/R t+1 [k] and 1 N sign( mi t+1 [k]). ER t+1 [k] ∇f (x t )[k]/R t+1 [k] - 1 N N i=1 sign( mi t+1 [k]) = ER t+1 [k] ∇f (x t )[k]/R t+1 [k] - 1 N N i=1 mi t+1 [k]/R t+1 [k] + 1 N N i=1 mi t+1 [k]//R t+1 [k] - 1 N N i=1 sign( mi t+1 [k]) = ER t+1 [k] ∇f (x t )[k]/R t+1 [k] - 1 N N i=1 mi t+1 [k]/R t+1 [k] + R t+1 [k] 1 N N i=1 mi t+1 [k]/R t+1 [k] - 1 N N i=1 sign( mi t+1 [k]) = E ∇f (x t )[k] - 1 N N i=1 mi t+1 [k] + R t+1 [k] 1 N N i=1 mi t+1 [k]/R t+1 [k] - 1 N N i=1 sign( mi t+1 [k]) . The first term E ∇f (x t )[k] -1 N N i=1mi t+1 [k] doesn't depend on R t+1 , we can bound this term across d coordinates using Lemma B.10:E d k=1 ∇f (x t )[k] - 1 N N i=1 mi t+1 [k] ≤ √ dE ∇f (x t ) - 1 N N i=1 mi t+1 ≤ √ dE ∇f (x t ) - 1 N N i=1 β 1 m i t + (1 -β 1 )g i t ≤ √ dE 1 N N i=1 β 1 ∇f (x t ) -m i t + 1 N N i=1 (1 -β 1 ) ∇f (x t ) -g i t ≤ √ dβ 1 β t 2 ∥∇f (x 0 )∥ + 2Lϵ √ d 1 -β 2 + σ N (1 + β 2 ) + √ dσ(1 -β 1 ) √ N . //Lemma B.The second termER t+1 [k] 1 N N i=1 mi t+1 [k]/R t+1 [k] -1 N N i=1 sign( mi t+1 [k]) can be decoupled into the variance of 1 N N i=1 sign( mi t+1 [k]) and the variance of The variance of 11 N N i=1 mi t+1 [k]: E d k=1 R t+1 [k] 1 N N i=1 mi t+1 [k]/R t+1 [k] - 1 N N i=1 sign( mi t+1 [k]) = E d k=1 R t+1 [k] 1 N N i=1 mi t+1 [k]/R t+1 [k] -E mi t+1 [k]/R t+1 [k] + E mi t+1 [k]/R t+1 [k] - 1 N N i=1 sign( mi t+1 [k]) = E d k=1 R t+1 [k] 1 N N i=1 mi t+1 [k]/R t+1 [k] -E mi t+1 [k]/R t+1 [k] + Esign( mi t+1 [k]) - 1 N N i=1 sign( mi t+1 [k]) = E d k=1 R t+1 [k] 1 N N i=1 mi t+1 [k]/R t+1 [k] -E mi t+1 [k]/R t+1 [k] + R t+1 [k] Esign( mi t+1 [k]) - 1 N N i=1 sign( mi t+1 [k]) = E d k=1 1 N N i=1 mi t+1 [k] -E mi t+1 [k] + R t+1 [k] 1 N N i=1 sign( mi t+1 ) -Esign( mi t+1 ) ≤ E √ d 1 N N i=1 mi t+1 -E mi t+1 + ∥R t+1 ∥ 1 N N i=1 sign( mi t+1 ) -Esign( mi t+1 ) .N N i=1 mi t+1 [k] √ dE 1 N N i=1 mi t+1 -E mi t+1 ≤ √ d E 1 N N i=1 mi t+1 -E mi t+1 2 = √ d 1 N 2 N i=1 E mi t+1 -E mi t+1 2 ≤ Cdσ 2 N , //Lemma B.11whereC = β 2 1 (1 -β 2 ) 1 1+β2 + (1 -β 1 ) 2 .The variance of 1N N i=1 sign( mi t+1 [k]) ∥R t+1 ∥ E 1 N N i=1 sign( mi t+1 ) -Esign( mi t+1 ) ≤ E N i=1 sign( mi t+1 )/N -E[sign( mi t+1 )] 2 = ∥R t+1 ∥ 1 N 2 N i=1 E sign( mi t+1 ) -E[sign( mi t+1 )] 2 ≤ ∥R t+1 ∥ 1 N .//Lemma B.9In above, we have the bound of the last term in ( 12) ⟨∇f (x t ), sign(∇f (x t )) -sign( Mt+1 )⟩:E⟨∇f (x t ), sign(∇f (x t )) -sign( Mt+1 )⟩ ≤ 2E d k=1 ∇f (x t )[k] - 1 N N i=1 mi t+1 [k] + 2E d k=1 R t+1 [k] 1 N N i=1 mi t+1 [k]/R t+1 [k] - 1 N N i=1 sign( mi t+1 [k]) ≤ 2 √ dE ∇f (x t ) - 1 N N i=1 mi t+1 + 2E √ d 1 N N i=1 mi t+1 -E mi t+1 + 2 ∥R t+1 ∥ 1 N N i=1 sign( mi t+1 ) -Esign( mi t+1 ) ≤ 2 √ dβ 1 β t 2 ∥∇f (x 0 )∥ + 2Lϵ √ d 1 -β 2 + σ N (1 + β 2 ) + 2 √ dσ(1 -β 1 ) √ N + 2 Cdσ 2 N + 2 ∥R t+1 ∥ 1 N .Case II (Infinite R)From our discussion above, we know that P ( mit [k] > 0) = 1/2 since E[sign( mi t [k])] = 2P ( mi t [k] > 0) -1 = 0, where k ∈ [d]. For notion, write D = {j ∈ [d] | E[sign( mi t+1 [j])] = 0}.In this case, we haveEQUATION≤ σ.So, the inner product ⟨∇f (x t ), sign(∇f (x t )) -sign( Mt+1 )⟩ is still bounded. Hence we can merge both cases into a unified bound by simply replacing R t by ρ t :ρ t [k] = 0 if E[sign( mi t+1 [k])] = 0, E[ mi t+1 [k]]/E[sign( mi t+1 [k])] else.Adding one constant D ≥ 1 to make the bound in finite case adpative to infinite case:σ ≤ 2D √ dβ 1 β t 2 ∥∇f (x 0 )∥, ∀t, 1 ≤ t ≤ T.Hence,E j∈D ∇f (x t )[j] sign(∇f (x t )[j]) -sign( Mt [j]) ≤ 2D √ dβ 1 β t 2 ∥∇f (x 0 )∥ + 4Ldβ 1 ϵ 1 -β 2 + 2 √ dσ(1 + √ C) + 2 ∥ρ t+1 ∥ √ N .Finally, we have the bound for both cases:E⟨∇f (x t ), sign(∇f (x t )) -sign( Mt+1 )⟩ ≤ 2 √ dβ 1 β t 2 ∥∇f (x 0 )∥ + 2Lϵ √ d 1 -β 2 + σ N (1 + β 2 ) + 2 √ dσ(1 -β 1 ) √ N + 2 Cdσ 2 N + 2 ∥ρ t+1 ∥ 1 N ≤ 2D √ dβ 1 β t 2 ∥∇f (x 0 )∥ + 4Ldβ 1 ϵ 1 -β 2 + 2 √ dσ(1 + √ C) + 2 ∥ρ t+1 ∥ √ N .Then we havef (x t+1 ) -f (x t ) ≤ -ϵS(x t ) + 2Lϵ 2 d + ϵ⟨∇f (x t ), sign(∇f (x t )) -sign( Mt+1 )⟩ ≤ -ϵS(x t ) + 2Lϵ 2 d + ϵ 2D √ dβ 1 β t 2 ∥∇f (x 0 )∥ + 4Ldβ 1 ϵ 1 -β 2 + 2 √ dσ(1 + √ C) + 2 ∥ρ t+1 ∥ √ N ,Hence, a telescope yields1 T T t=1 ES(x t ) ≤ f (x 0 ) -f * T ϵ + 2Dβ 1 β 2 √ d∥∇f (x 0 )∥ T (1 -β 2 ) + 4β 1 Lϵd 1 -β 2 + 2 √ dσ(1 + √ C) + 2ρ √ N + 2Lϵd, where ρ = max 1≤t≤T ∥ρ t ∥. Lemma B.7. Let (X, Y ) is a joint random variable on R d × R d . For any constant a ∈ (0, +∞), we have E[⟨X, sign(X) -sign(Y )⟩] ≤ 2a √ dE∥X/a -Y ∥.Proof. Without loss of generality, set a = 1. Lemma B.9. Let X be a random variable in R, we haveE[⟨X, sign(X) -sign(Y )⟩] = E[∥X∥ 1 -⟨X, sign(Y )⟩] ≤ 2E[∥X -Y ∥ 1 ] //Lemma B.8 ≤ 2 √ dE[∥X -Y ∥] //E ∥sign(X) -E[sign(X)]∥ 2 < 1.Proof. The result is a direct derivation from Bernoulli distribution's variance,E ∥sign(X) -E[sign(X)]∥ 2 = E[sign(X) 2 ] -E[sign(X)] 2 < 1.Lemma B.10. Following the same setting in Theorem B.6, we have∥ 1 N N i=1 m i t -∇f (x t )∥ ≤ β t 2 ∥∇f (x 0 )∥ + 2Lε √ d 1 -β 2 + σ N (1 + β 2 ) .Proof. We use the notions:g i t := ∇f (x t ; ξ i t ), M t = 1 N N i=1 m i t , ε t := M t -∇f (x t ), g t = 1 N N i=1 g i t , δ t := g t -∇f (x t ), and s t = ∇f (x t-1 ) -∇f (x t ) ε t = M t -∇f (x t ) = β 2 M t-1 + (1 -β 2 )g t -∇f (x t ) = β 2 (M t-1 -∇f (x t-1 )) + (1 -β 2 )(g t -∇f (x t )) + β 2 (∇f (x t-1 ) -∇f (x t ) = β 2 ε t-1 + (1 -β 2 )δ t + β 2 s t .That isε t = β 2 ε t-1 + (1 -β 2 )δ t + β 2 s t .Under the L-smoothness assumption B.2:EQUATION)where ε is the step size. Using mathematical induction, we haveEQUATIONBy taking the norms of both sides of the above equation and using the strong bound 13 we obtain∥ε t ∥ ≤ β t 2 ∥ε 0 ∥ + 2L √ dϵ t i=1 β t-i+1 2 + (1 -β 2 )∥ t i=1 β t-i 2 δ t ∥.Taking expectations on both sides,E∥ε t ∥ ≤ β t 2 ∥ε 0 ∥ + 2L √ dε 1 -β 2 + (1 -β 2 )∥ t i=1 β t-i 2 δ t ∥.Note that r.v.s (δ i ) 1≤i≤t are mean zero, using B.11, we haveE t i=1 β t-i 2 δ i = E t i=1 β 2t-2i 2 σ 2 N ≤ σ N (1 -β 2 2 )Hence,E∥ε t ∥ ≤ β t 2 ∥ε 0 ∥ + 2L √ dε 1 -β 2 + σ N (1 + β 2 ) .Note that M 0 = 0 under our setting, so ε 0 = -∇f (x 0 ), we haveE∥ε t ∥ ≤ β t 2 ∥∇f (x 0 )∥ + 2L √ dε 1 -β 2 + σ N (1 + β 2 ) .Lemma B.11 (Cumulative error of stochastic gradient [4] ). Assume the same settings as in Theorem B.6. Define Y k := k l=1 α ℓ δ l where δ t := g t -∇f (x t ) with g t = N i=1 g i t and g i t := ∇f (x t ; ξ i t ) following the update in (11) , and {α ℓ : ℓ = 0, 1, . . .} is a deterministic sequence. Then Y k is a martingale, andE   k l=1 α l δ l 2   = 1 N k l=1 α 2 l σ 2 .Proof. We simply check the definition of martingales. First, we haveE[|Y k |] = E k l=1 α l δ l ≤ l |α l |E[|δ l |] //triangle inequality = l |α l |E[E[|δ l ||x l ]] //law of total probability ≤ l |α l |E[ E[δ 2 l |x l ]] //Jensen's inequality ≤ l |α l |σ < ∞ //Assumption B.3.Second, again using the law of total probability,E[Y k+1 |Y 1 , ..., Y k ] = E k+1 l=1 α l δ l α 1 δ 1 , ..., α k δ k = Y k + α k+1 E [δ k+1 |α 1 δ 1 , ..., α k δ k ] = Y k + α k+1 E [E [δ k+1 |x k+1 , α 1 δ 1 , ..., α k δ k ] |α 1 δ 1 , ..., α k δ k ] = Y k + α k+1 E [E [δ k+1 |x k+1 ] |α 1 δ 1 , ..., α k δ k ] = Y k .This completes the proof that it is a martingale. We now make use of the properties of martingale difference sequences to establish a variance bound on the martingale. As a direct result of Lemma B.11, we have the following. Lemma B.12. Under the same settings as in Theorem 3.6, we havek l=1 α l δ l ] 2 ] = k l=1 E[α 2 l δ 2 l ] + 2E mi t+1 -E[ mi t+1 ] 2 ≤ β 2 1 (1 -β 2 ) 1 1 + β 2 + (1 -β 1 ) 2 σ 2 .Proof.mi t+1 = β 1 m i t + (1 -β 1 )g i t = β 1 (1 -β 2 ) g i t-1 + β 2 g i t-2 + • • • + β t-1 2 g i 0 + (1 -β 1 )g i t . Note that β 2 1 (1 -β 2 ) 2 1 + β 2 2 + • • • + β 2(t-1) 2 + (1 -β 1 ) 2 = β 2 1 (1 -β 2 ) 2 1 -β 2t 2 1 -β 2 2 + (1 -β 1 ) 2 .By using lemma B.11, we haveE mi t+1 -E[ mi t+1 ] 2 ≤ β 2 1 (1 -β 2 ) 1 1 + β 2 + (1 -β 1 ) 2 σ 2 .Assume f : R d → R is L-smooth, N is the number of workers, on the i-th worker, consider the following scheme based on the averaging: g i t := ∇f (Chen et al. [11] suggests (β1 = 0.9, β2 = 0.99) based on empirical findings.Throughout this work, we assume {Di} consist of i.i.d data samples, ξi sampled from Di is i.i.d. though our method should be directly applicable to non-i.i.d data.Note that D-SIGNUM (Avg/MaVo) further subsumes D-SignSGD[5,6]. 


Decision: This paper considered a distributed version of the Lion optimizer, which reduces the communication cost. The authors provided theoretical analysis of this algorithm and showed empirical results on vision and language tasks. The reviewers unanimously recommended to accept this paper. I suggest the author incoporate the extra wall-clock time experiments and communication reduction experiments in the final version of the paper.

Reviews: review: paper_summary: paper_summary: This paper proposes Distributed Lion, a new variant of Lion optimizer for distributed training. The proposed algorithm only requires to communicate binary or lower-precision vectors between workers to the center server, significantly reducing the communication cost. The theoretical analysis proves the convergence of the proposed algorithms. The empirical results show that the proposed algorithms have comparable model performance on CV/NLP applications but with significantly less communication overhead compared to the baselines.
strength_weakness: strength_weakness: 1. According to Assumption 3.1, the convergence requires i.i.d. local datasets, while real-world distributed training typically uses non-i.i.d. local data.

2. In the empirical results, there seems to be no wall-clock time for training is reported. Note that the overall goal of communication reduction is to reduce the training time. Thus, it is important to report loss/acc vs. wall-clock time in the experiments.
questions: questions: 1. Is it possible to provide a convergence analysis based on non-i.i.d. data?

2. For the experiments, are the local dataset on each worker i.i.d. or non-i.i.d.?

3. Since the proposed algorithm can compress the communication to an extreme extend, I wonder whether it could also be applied to the federated learning scenario, where the local datasets are not only non-i.i.d., but also highly heterogeneous.

4. Is there any empirical results reporting wall-clock time of training?
limitations: limitations: The limitations are well discussed and addressed in this paper.
paper_summary: paper_summary: This paper extends the Lion optimizer to data parallel distributed training. Unlike optimizers like SGD and Adam, the binary update in Lion can be exploited to minimize the communication. They investigate two cost effective methods for the communication of  binary updates; averaging and majority vote. Experimental results show that both methods yield competitive results to global Lion and AdamW.
strength_weakness: strength_weakness: The proposed method is a trivial extension of Lion to data parallel distributed training, so the only interesting contribution seems to be the convergence analysis. 

The main contribution of this work is supposed to be the reduction of communication overhead, but there are no results showing the actual breakdown of the training time. Therefore, it is not possible to determine whether the reduction of communication volume is actually contributing to the reduction of the overall training time. Since the results seem to vary quite a bit for different models and datasets, such information is useful for determining whether the experiments are conducted for configurations that actually show a significant impact on the training time. There remains a possibility that the current method does not work as well for extremely large models trained with ZeRO 3 data parallelism, which is where the communication overhead really becomes a problem.
questions: questions: How different are the global binary updates between averaging and majority vote?
Are the results similar because they are similar or despite their large difference?
limitations: limitations: The limitations pointed out above are not explicitly stated in the paper.
paper_summary: paper_summary: Large-scale AI model training has increasingly higher requirements on time, cost and environmental impact, so it is crucial to develop efficient optimizers. As an emerging optimizer, Lion optimizer has advantages in memory, computation and sample efficiency compared with AdamW. Distributed Lion: The paper proposes Distributed Lion, which is an innovative adaptation of Lion optimizer in distributed training environment. Using symbolic operations in Lion, Distributed Lion only requires binary or low-precision vectors to be communicated between working nodes and central servers, significantly reducing communication costs.
strength_weakness: strength_weakness: 1. The actual updating on local worker parameters is gradients, while the communicated message is signs. While the theoretical analysis shows this updating can guarantee the convergence, the actual updating style looks like the quantization. The important baselines like QSGD and SignSGD are missed. 
2. The performance of Distributed Lion can be sensitive to hyperparameter choices, especially those related to communication and aggregation strategies.
3. The code is not provided. Thus the reproducibility of the experiments is weakened.
4. The experiment performance on the CIFAR-10 is very low. Considering that the well-known validation performance of CIFAR-10 can be achieved as 94%, the proposed results are around 90%. Why the performance decreases?
5. The important baseline SGD with momentum is not provided.
6. The convergence curves on training with ImageNet and OpenWebText are not provided. This makes it hard to identify the convergence speedup between different optimizers.
7. The wall-clock time is not provided. The quantization operation and the majority vote require extra time, it will be better to show this optimizer can reduce the real-world throughputs.
questions: questions: 1. How do you ensure that the hyper-parameters of different optimizers are set as a suitable combination for them? Suitable hyper-parameter settings can ensure the fair comparison.

If the above weaknesses and questions are addressed, I'm happy to raise the score.
limitations: limitations: Two minor points considering the realistic device constraints:
1. The experiment scalability is with 32 GPUs, which is not a large scale distributed training setting.
2. The training model is small-scale with less than 1B parameters.
paper_summary: paper_summary: The paper introduces Distributed Lion, a variant of the Lion optimizer, tailored for distributed training environments. Lion, known for its memory and computational efficiency, is adapted to reduce communication costs between workers and a central server. This is achieved by communicating binary or low-precision vectors rather than high-precision floating-point vectors. The paper presents theoretical convergence properties and empirical results that demonstrate Distributed Lion’s robustness and efficiency across various tasks, worker counts, and batch sizes. It shows comparable performance to standard Lion or AdamW optimizers but with significantly reduced communication bandwidth.
strength_weakness: strength_weakness: - Incompatible with Allreduce: after converting the gradients to binary or low-precision, Allreduce cannot be used for gradient synchronization. One of my concerns is about its communication efficiency in real-world distributed systems, especially training with a high number of workers.
- Computation Overhead: While the communication cost is reduced, the overhead of converting updates to binary or low-precision vectors and back might offset some of the gains in certain scenarios. It helps if the end-to-end training throughput comparison is reported.
questions: questions: What is the fundamental difference between distributed Lion and SIGNUM-like algorithms?
limitations: limitations: N/A

Comments: title: Thanks for the further explanations
Reply to Reviewer
Thanks for the responses
comment: I appreciate the further explanations, which clearly address my concerns. I'd like to increase my score as 5.
Thank you for providing the actual training time and its breakdown. I still feel that more emphasis should be put on the reduction of communication time for different model sizes, batch sizes, and including other modes of parallelism such as tensor, pipeline, and ZeRO. The communication in Int8 does reduce the volume by half, but this method has the potential to do much better. The effort to extend Lion to a distributed Lion using only data parallelism is minimal, so I feel that the paper should include more detailed studies on the actual reduction of communication time. I am sticking to my original score.
My major concern on wall-clock time comparison is well addressed. And I guess the non-iid settings and the federated learning settings worth another paper in the future. 

Thus, I will keep the positive score.
We thank the reviewer for your followups :)

**1. Why SIGNUM outperforms SGD Mom.**
This is in fact expected. So the sign() operator is not merely compressing the momentum information, it also **normalizes** the update. Take the Adam optimizer as an example, at the first step, Adam's update recovers the normalized gradient descent $ g / ||g|| $, and at each step, Adam's update is also roughly doing that. It is known that these kinds of **normalized gradient descent** perform well in practice. One reason is that it makes each entry of the parameter update at a similar pace (therefore similar to a second-order method), the other reason is that it can avoid saddle points (as the update norm is relatively constant). SIGNUM (and similarly Lion) also mimics what Adam does by having the sign operation (their update norm is a constant). Based on my personal experience, SGD Momentum works better for convolution-based networks. But for Transformer models, often Adam-like optimizers work better.

**2. Why the Optimizer State Communication (ms) is half less?**
As we mentioned in the common response, currently during our implementation, we are using the int8 all reduce instead of binary all reduce. This is because in practice all-reduce in PyTorch does not support low-bit all-reduce in a ring-based fashion, which is the default way to perform distributed training. Our current practical solution is packing and encoding our binary information into a low-bit tensor and then using an int8 tensor as a container to broadcast through the ring all reduce. This can still achieve a 2-4x compression, depending on the number of workers. 

On the other hand, we are looking forward to some core updates from the NCCL library or pytorch team to support more low-bit friendly operators or datatypes like fp4, and fp8 during communication, which could greatly help with low-bit communication algorithms. As a result, our current work mainly focuses on demonstrating the theoretical convergence and empirical performance of distributed Lion algorithms, rather than the practical aspects of implementation.
I appreciate for the efforts from authors. I have two follow-up questions:
- 1. Why does SIGNUM outperform SGD Mom? As a compression method, SGD Mom might be the upper bound of SIGNUM? Maybe the hyper-parameters of the SGD Mom are not well tuned?
- 2. Could you give some explanations about why the Optimizer State Communication (ms) of MaVo is half less than the baseline. Because the communication messages are signs, I suppose they should be less than original messages for 16x or 32x.