Is Local SGD Better than Minibatch SGD?

Introduction

It is often important to leverage parallelism in order to tackle large scale stochastic optimization problems. A prime example is the task of minimizing the loss of machine learning models with millions or billions of parameters over enormous training sets.

One popular distributed approach is local stochastic gradient descent (SGD) , also known as “parallel SGD” or “Federated Averaging”Federated Averaging is a specialization of local SGD to the federated setting, where (a) data is assumed to be heterogenous (not i.i.d.) across workers, (b) only a handful of clients are used in each round, and (c) updates are combined with a weighted average to accommodate unbalanced datasets. , which is commonly applied to large scale convex and non-convex stochastic optimization problems, including in data center and “Federated Learning” settings . Local SGD uses $M$ parallel workers which, in each of $R$ rounds, independently execute $K$ steps of SGD starting from a common iterate, and then communicate and average their iterates to obtain the common iterate from which the next round begins. Overall, each machine computes $T=KR$ stochastic gradients and executes $KR$ SGD steps locally, for a total of $N=KRM$ overall stochastic gradients computed (and so $N=KRM$ samples used), with $R$ rounds of communication (every $K$ steps of computation).

Given the appeal and usage of local SGD, there is significant value in understanding its performance and limitations theoretically, and in comparing it to other alternatives and baselines that have the same computation and communication structure. That is, other methods that are distributed across $M$ machines and compute $K$ gradients per round of communication for $R$ rounds, for a total of $T=KR$ gradients per machine and $R$ communication steps. This structure can also be formalized through the graph oracle model of Woodworth et al. [29, see also Section 2].

So, how does local SGD compare to other algorithms with the same computation and communication structure? Is local SGD (or perhaps an accelerated variant) optimal in the same way that (accelerated) SGD is optimal in the sequential setting? Is it better than baselines?

A natural alternative and baseline is minibatch SGD – a simple method for which we have a complete and tight theoretical understanding. Within the same computation and communication structure, minibatch SGD can be implemented as follows: Each round, calculate the $K$ stochastic gradient estimates (at the current iterate) on each machine, and then average all $KM$ estimates to obtain a single gradient estimate. That is, we can implement minibatch SGD that takes $R$ stochastic gradient steps, with each step using a minibatch of size $KM$—this is the fair and correct minibatch SGD to compare to, and when we refer to “minibatch SGD” we refer to this implementation ($R$ steps with minibatch size $KM$).

Local SGD seems intuitively better than minibatch SGD, since even when the workers are not communicating, they are making progress towards the optimum. In particular, local SGD performs $K$ times more updates over the course of optimization, and can be thought of as computing gradients at less “stale” and more “updated” iterates. For this reason, it has been argued that local SGD is at least as good as minibatch SGD, especially in convex settings where averaging iterates cannot hurt you. But can we capture this advantage theoretically to understand how and when local SGD is better than minibatch SGD? Or even just establish that local SGD is at least as good?

A string of recent papers have attempted to analyze local SGD for convex objectives, [e.g. 23, 25, 13, 4]. However, a satisfying analysis has so far proven elusive. In fact, every analysis that we are aware of for local SGD in the general convex (or strongly convex) case with a typical noise scaling (e.g. as arising from supervised learning) not only does not improve over minibatch SGD, but is actually strictly dominated by minibatch SGD! But is this just a deficiency of these analyses, or is local SGD actually not better, and perhaps worse, than minibatch SGD? In this paper, we show that the answer to this question is “sometimes.” There is a regime in which local SGD indeed matches or improves upon minibatch SGD, but perhaps surprisingly, there is also a regime in which local SGD really is strictly worse than minibatch SGD.

In Section 3, we start with the special case of quadratic objectives and show that, at least in this case, local SGD is strictly better than minibatch SGD in the worst case, and that an accelerated variant is even minimax optimal.

We then turn to general convex objectives. In Section 4 we prove the first error upper bound on the performance of local SGD which is not dominated by minibatch SGD’s upper bound with a typical noise scaling. In doing so, we identify a regime (where $M$ is large and $K\gtrsim R$) in which local SGD performs strictly better than minibatch in the worst case. However, our upper bound does not show that local SGD is always as good or better than minibatch SGD. In Section 5, we show that this is not just a failure of our analysis. We prove a lower bound on the worst-case error of local SGD that is higher than the worst-case error of minibatch SGD in a certain regime! We demonstrate this behaviour empirically, using a logistic regression problem where local SGD indeed behaves much worse than mini-batch SGD in the theoretically-predicted problematic regime.

Thus, while local SGD is frequently better than minibatch SGD—and we can now see this both in theory and in practice [see experiments by e.g. 31, 15, 35]—our work identifies regimes in which users should be wary of using local SGD without considering alternatives like minibatch SGD, and might want to seek alternative methods that combine the best of both, and attain optimal performance in all regimes.

Preliminaries

We consider the stochastic convex optimization problem:

For simplicity, we consider initializing all algorithms at zero. Then, Local SGD with $M$ machines, $K$ stochastic gradients per round, and $R$ rounds of communication calculates its $t$th iterate on the $m$th machine for $t\in[KR]$ via

where $z_{t}^{m}\sim\mathcal{D}$ i.i.d., and $K\ |\ t$ refers to $K$ dividing $t$. For each $r\in[R]$, minibatch SGD calculates its $r$th iterate via

We also introduce another strawman baseline, which we will refer to as “thumb-twiddling” SGD. In thumb-twiddling SGD, each machine computes just one (rather than $K$) stochastic gradients per round of communication and “twiddles its thumbs” for the remaining $K-1$ computational steps, resulting in $R$ minibatch SGD steps, but with a minibatch size of only $M$ (instead of $KM$, i.e. as if we used $K=1$). This is a silly algorithm that is clearly strictly worse than minibatch SGD, and we would certainly expect any reasonable algorithm to beat it. But as we shall see, previous work has actually struggled to show that local SGD even matches, let alone beats, thumb-twiddling SGD. In fact, we will show in Section 5 that, in certain regimes, local SGD truly is worse than thumb-twiddling.

For a particular algorithm $\mathsf{A}$, we define its worst-case performance with respect to $\mathcal{F}(H,\lambda,B,\sigma^{2})$ as:

The worst-case performance of minibatch SGD for general convex objectives is tightly understood :

In order to know if an algorithm like local or minibatch SGD is “optimal” in the worst case requires understanding the minimax error, i.e. the best error that any algorithm with the requisite computation and communication structure can guarantee in the worst case. This requires formalizing the set of allowable algorithms. One possible formalization is the graph oracle model of Woodworth et al. which focuses on the dependence structure between different stochastic gradient computations resulting from the communication pattern. Using this method, Woodworth et al. prove lower bounds which are applicable to our setting. Minibatch SGD does not match these lower bounds (nor does accelerated minibatch SGD, see Cotter et al. ), but these lower bounds are not known to be tight, so the minimax complexity and minimax optimal algorithm are not yet known.

Table 1 summarizes the best existing analyses of local SGD that we are aware of that can be applied to our setting. We present the upper bounds as they would apply in our setting, and after optimizing over the stepsize and other parameters. A detailed derivation of these upper bounds from the explicitly-stated theorems in other papers is provided in Appendix A. As we can see from the table, in the natural scaling $H=\sigma^{2}$, every previous upper bound is strictly dominated by minibatch SGD. Worse, these upper bounds can even be worse than even thumb-twiddling SGD when $M\gg R$ (although they are sometimes better). In particular, the first term of each previous upper bound (in terms of $M,K,R$) is never better than $R^{-1}$ (the optimization term of minibatch and thumb-twiddling SGD), and can be much worse.

We should note that in an extremely low noise regime $\sigma^{2}\leq H^{2}B^{2}\min\{\frac{1}{M},\frac{K}{R}\}$, the bound of Khaled et al. can sometimes improve over minibatch SGD. However, this only happens when $KR$ steps of sequential SGD is better than minibatch SGD—i.e. when you are better off ignoring $M-1$ of the machines and just doing serial SGD on a single machine (such an approach would have error $\frac{HB^{2}}{KR}+\frac{\sigma B}{\sqrt{KR}}$). This is a trivial regime in which every update for any of these algorithms is essentially an exact gradient descent step, thus there is no need for parallelism in the first place. See Appendix A.3 for further details. The upper bound we develop in Section 4, in contrast, dominates their guarantee and shows an improvement over minibatch that cannot be achieved on a single machine (i.e. without leveraging any parallelism). Furthermore, this improvement can occur even in the natural scaling $H=\sigma^{2}$ and even when minibatch SGD is better than serial SGD on one machine.

We emphasize that Table 1 lists the guarantees specialized to our setting—some of the bounds are presented under slightly weaker assumptions, or with a more detailed dependence on the noise: Stich and Karimireddy , Haddadpour et al. analyze local SGD assuming not-quite-convexity; and Wang and Joshi , Dieuleveut and Patel derive guarantees under both multiplicative and additive bounds on the noise. Dieuleveut and Patel analyze local SGD with the additional assumption of a bounded third derivative, but even with this assumption do not improve over mini-batch SGD. Numerous works study local SGD in the non-convex setting [see e.g. 35, 30, 27, 25, 9]. Although their bounds would apply in our convex setting, due to the much weaker assumptions they are understandably much worse than minibatch SGD. There is also a large body of work studying the special case $R=1$, i.e. where the iterates are averaged just one time at the end . However, these analyses do not easily extend to multiple rounds, and the $R=1$ constraint can provably harm performance [see 21]. Finally, local SGD has been studied with heterogeneous data, i.e. where each machine receives stochastic gradients from different distributions—see Kairouz et al. [11, Sec. 3.2] a recent survey.

In this work, we focus on understanding the best achievable error for a given $M$, $K$, and $R$. However, one might also want to know to what extent it is possible to reduce communication without paying for it. Concretely, fix $T=KR$, and consider as a baseline an algorithm which computes $T$ stochastic gradients on each machine sequentially, but is allowed to communicate after every step. We can then ask to what extent we can compete against this baseline while using less communication. One way to do this is to use Local SGD, which reduces communcation by a factor of $K$. However, the amount by which we can reduce communcation using Local SGD is easily determined once we know the error of Local SGD for each fixed $K$. Therefore, this viewpoint of reducing communcation is essentially equivalent to the one we take.

Good News: Quadratic Objectives

As we have seen, existing analyses of local SGD are no better than that of minibatch SGD. In the special case where $F$ is quadratic, we will now show that not only is local SGD sometimes as good as minibatch SGD, but it is always as good as minibatch SGD, and sometimes better. In fact, an accelerated variant of local SGD is minimax optimal for quadratic objectives. More generally, we show that the local SGD anologue for a large family of serial first-order optimization algorithms enjoys an error guarantee which depends only on the product $KR$ and not on $K$ or $R$ individually. In particular, we consider the following family of linear update algorithms:

We say that a first-order optimization algorithm is a linear update algorithm if, for fixed linear functions $\mathcal{L}^{(t)}_{1},\mathcal{L}^{(t)}_{2}$, the algorithm generates its $t+1$st iterate according to

This family captures many standard first-order methods including SGD, which corresponds to the linear mappings $\mathcal{L}^{(t)}_{1}\left(x_{1},\dots,x_{t}\right)=x_{t}$ and $x_{t+1}=x_{t}-\eta_{t}\nabla f(x_{t};z_{t})$. Another notable algorithm in this class is AC-SA , an accelerated variant of SGD which also has linear updates. Some important non-examples, however, are adaptive gradient methods like AdaGrad —these have linear updates, but the linear functions are data-dependent.

For a linear update algorithm $\mathcal{A}$, we will use local-$\mathcal{A}$ to denote the local SGD analogue with $\mathcal{A}$ replacing SGD. That is, during each round of communication, each machine independently executes $K$ iterations of $\mathcal{A}$ and then the $M$ resulting iterates are averaged. For quadratic objectives, we show that this approach inherits the guarantee of $\mathcal{A}$ with the benefit of variance reduction:

We prove this in Appendix B by showing that the average iterate $\bar{x}_{t}$ is updated according to $\mathcal{A}$—even in the middle of rounds of communication when $\bar{x}_{t}$ is not explicitly computed. In particular, we first show that

Then, by the linearity of $\nabla F$ and $\mathcal{L}_{1}^{(t)}$, we prove

and its variance is reduced to $\frac{\sigma^{2}}{M}$. Therefore, $\mathcal{A}$’s guarantee carries over while still benefitting from the lower variance.

To rephrase Theorem 1, on quadratic objectives, local-$\mathcal{A}$ is in some sense equivalent to $KR$ iterations of $\mathcal{A}$ with the gradient variance reduced by a factor of $M$. Furthermore, this guarantee depends only on the product $KR$, and not on $K$ or $R$ individually. Thus, averaging the $T$th iterate of $M$ independent executions of $\mathcal{A}$, sometimes called “one-shot averaging,” enjoys the same error upper bound as $T$ iterations of size-$M$ minibatch-$\mathcal{A}$.

Nevertheless, it is important to highlight the boundaries of Theorem 1. Firstly, $\mathcal{A}$’s error guarantee $\epsilon(T,\sigma^{2})$ must not rely on any particular structure of the stochastic gradients themselves, as this structure might not hold for the implicit updates of local-$\mathcal{A}$. Furthermore, even if some structure of the stochastic gradients is maintained for local-$\mathcal{A}$, the particular iterates generated by local-$\mathcal{A}$ will generally vary with $K$ and $R$ (even holding $KR$ constant). Thus, Theorem 1 does not guarantee that local-$\mathcal{A}$ with two different values of $K$ and $R$ would perform the same on any particular instance. We have merely proven matching upper bounds on their worst-case performance.

We apply Theorem 1 to yield error upper bounds for local-SGD and local-AC-SA (based on the AC-SA algorithm of Ghadimi and Lan ) which is minimax optimal:

For any quadratic $(f,\mathcal{D})\in\mathcal{F}(H,\lambda=0,B,\sigma^{2})$, there are constants $c_{1}$ and $c_{2}$ such that local-SGD returns a point $\hat{x}$ such that

In particular, local-AC-SA is minimax optimal for quadratic objectives.

Comparing the bound above for local SGD with the bound for minibatch SGD (5), we see that the local SGD bound is strictly better, due to the first term scaling as $(KR)^{-1}$ as opposed to $R^{-1}$. We note that minibatch SGD can also be accelerated , leading to a bound with better dependence on $R$, but this is again outmatched by the bound for the (accelerated) local-AC-SA algorithm above. A similar, improved bound can also be proven when the objective is a strongly convex quadratic.

Local SGD and related methods have been previously analyzed for quadratic objectives, but in slightly different settings. Jain et al. study a similar setting and analyze our “minibatch SGD” for $M=1$ and fixed $KR$, but varying $K$ and $R$. They show that when $K$ is sufficiently small relative to $R$, then minibatch SGD can compete with $KR$ steps of serial SGD. They also show that for fixed $M>1$ and $bT$, when $b$ is sufficiently small then the average of $M$ independent runs of minibatch SGD with $T$ steps and minibatch size $b$ can compete with $T$ steps of minibatch SGD with minibatch size $Mb$. These results are qualitatively similar to ours, but they analyze a specific algorithm while we are able to provide a guarantee for a broader class of algorithms. Dieuleveut and Patel analyze local SGD on quadratic objectives and show a result analogous to our Theorem 1. However, their result only holds when $M$ is sufficiently small relative to $K$ and $R$. Finally, there is a literature on “one-shot-averaging” for quadratic objectives, which corresponds to an extreme where the outputs of an algorithm applied to several different training sets are averaged, [e.g. 33, 34]. These results also highlight similar phenomena, but they do not apply as broadly as Theorem 1 and they do not provide as much insight into local SGD specifically.

More Good News: General Convex Objectives

In this section, we present the first analysis of local SGD for general convex objectives that is not dominated by minibatch SGD. For the first time, we can identify a regime of $M$, $K$, and $R$ in which local SGD provably performs better than minibatch SGD in the worst case. Furthermore, our analysis dominates all previous upper bounds.

Let $(f,\mathcal{D})\in\mathcal{F}(H,\lambda,B,\sigma^{2})$. When $\lambda=0$, an appropriate average of the iterates of Local SGD with an optimally tuned constant stepsize satisfies for a universal constant $c$

If $\lambda>0$, then an appropriate average of the iterates of Local SGD with decaying stepsizes satisfies for a universal constant $c$

This is proven in Appendix C. We use a similar approach as Stich , who analyzes the behavior of the averaged iterate $\bar{x}_{t}=\frac{1}{M}\sum_{m=1}^{M}x_{t}^{m}$, even when it is not explicitly computed. They show, in particular, that the averaged iterate evolves almost according to size-$M$-minibatch SGD updates, up to a term proportional to the dispersion of the individual machines’ iterates $\frac{1}{M}\sum_{m=1}^{M}\|\bar{x}_{t}-x_{t}^{m}\|^{2}$. Stich bounds this with $O(\eta_{t}^{2}K^{2}\sigma^{2})$, but this bound is too pessimistic—in particular, it holds even if the gradients are replaced by arbitrary vectors of norm $\sigma$. In Lemma 5, we improve this bound to $O(\eta_{t}^{2}K\sigma^{2})$ which allows for our improved guarantee.In recent work, Stich and Karimireddy present a new analysis of local-SGD which, in the general convex case is of the form $\frac{MHB^{2}}{R}+\frac{\sigma B}{\sqrt{MKR}}$. As stated, this is strictly worse than minibatch SGD. However, we suspect that this bound should hold for any $1\leq M^{\prime}\leq M$ because, intuitively, having more machines should not hurt you. If this is true, then optimizing their bound over $M^{\prime}$ yields a similar result as Theorem 2. Our approach resembles that of Khaled et al. , which we became aware of in the process of preparing this manuscript, however our analysis is more refined. In particular, we optimize more carefully over the stepsize so that our analysis applies for any $M$, $K$, and $R$ (rather than just $M\leq KR$) and shows an improvement over minibatch SGD in a significantly broader regime, including when $\sigma^{2}\gg 0$ (see Appendix A.3 for additional details).

We now compare the upper bound from Theorem 2 with the guarantee of minibatch SGD. For clarity, and in order to highlight the role of $M$, $K$, and $R$ in the convergence rate, we will compare rates for general convex objectives when $H=B=\sigma^{2}=1$, and we will also ignore numerical constants and the logarithmic factor in Theorem 2. In this setting, the worst-case error of minibatch SGD is:

Our guarantee for local SGD from Theorem 2 reduces to:

These guarantees have matching statistical terms of $\frac{1}{\sqrt{MKR}}$, which cannot be improved by any first-order algorithm . Therefore, in the regime where the statistical term dominates both rates, i.e. $M^{3}K\lesssim R$ and $MK\lesssim R$, both algorithms will have similar worst-case performance. When we leave this noise-dominated regime, we see that local SGD’s guarantee $K^{-\frac{1}{3}}R^{-\frac{2}{3}}$ is better than minibatch SGD’s $R^{-1}$ when $K\gtrsim R$ and is worse when $K\lesssim R$. This makes sense intuitively: minibatch SGD benefits from computing very precise gradient estimates, but pays for it by taking fewer gradient steps; conversely, each local SGD update is much noisier, but local SGD is able to make $K$ times more updates.

This establishes that for general convex objectives in the large-$M$ and large-$K$ regime, local SGD will strictly outperform minibatch SGD. However, in the large-$M$ and small-$K$ regime, we are only comparing upper bounds, so it is not clear that local SGD will in fact perform worse than minibatch SGD. Nevertheless, it raises the question of whether this is the best we can hope for from local SGD. Is local SGD truly better than minibatch SGD in some regimes but worse in others? Or, should we believe the intuitive argument suggesting that local SGD is always at least as good as minibatch SGD?

Bad News: Minibatch SGD Can Outperform Local SGD

In Section 3, we saw that when the objective is quadratic, local SGD is strictly better than minibatch SGD, and enjoys an error guarantee that depends only on $KR$ and not $K$ or $R$ individually. In Section 4, we analyzed local SGD for general convex objectives and showed that local SGD sometimes outperforms minibatch SGD. However, we did not show that it always does, nor that it is always even competitive with minibatch SGD. We will now show that this is not simply a failure of our analysis—in a certain regime, local SGD really is inferior (in the worst-case) to minibatch SGD, and even to thumb-twiddling SGD. We show this by constructing a simple, smooth piecewise-quadratic objective in three dimensions, on which local SGD performs poorly. We define this hard instance $(f,\mathcal{D})\in\mathcal{F}(H,\lambda,B,\sigma^{2})$ as

For $0\leq\lambda\leq\frac{H}{16}$, there exists $(f,\mathcal{D})\in\mathcal{F}(H,\lambda,B,\sigma^{2})$ such that for any $K\geq 2$ and $M,R\geq 1$, local SGD initialized at with any fixed stepsize, will output a point $\hat{x}$ such that for a universal constant $c$

In order to compare this lower bound with Theorem 2 and with minibatch SGD, we again consider the general convex setting with $H=B=\sigma^{2}=1$. Then, the lower bound reduces to $K^{-\frac{2}{3}}R^{-\frac{2}{3}}+(MKR)^{-\frac{1}{2}}$. Comparing this to Theorem 2, we see that our upper bound is tight up to a factor of $K^{-\frac{1}{3}}$ in the optimization term. Furthermore, comparing this to the worst-case error of minibatch SGD (9), we see that local SGD is indeed worse than minibatch SGD in the worst case when $K$ is small enough relative to $R$. The cross-over point is somewhere between $K\leq\sqrt{R}$ and $K\leq R$; for smaller $K$, minibatch SGD is better than local SGD in the worst case, for larger $K$, local SGD is better in the worst case. Since the optimization terms of minibatch SGD and thumb-twiddling SGD are identical, this further indicates that local SGD is even outperformed by thumb-twiddling SGD in the small $K$ and large $M$ regime.

Finally, it is interesting to note that in the strongly convex case (where $\lambda>0$), the gap between local GD and minibatch SGD can be even more dramatic: In that case, the optimization term of minibatch SGD scales as $\exp(-R)$ (see Stich and references therein), while our theorem implies that local SGD cannot obtain a term better than $(KR)^{-2}$. This implies an exponentially worse dependence on $R$ in that term, and a worse bound as long as $R\gtrsim\log(K)$.

In order to prove Theorem 3 we constructed an artificial, but easily analyzable, situation where we could prove analytically that local SGD is worse than mini-batch. In Figure 1, we also demonstrate the behaviour empirically on a logistic regression task, by plotting the suboptimality of local SGD, minibatch SGD, and thumb-twiddling SGD iterates with optimally tuned stepsizes. As is predicted by Theorem 3, we see local SGD goes from performing worse than minibatch in the small $K=5$ regime, but improving relative to the other algorithms as $K$ increases to $40$ and then $200$, when local SGD is far superior to minibatch. For each fixed $K$, increasing $M$ causes thumb-twiddling SGD to improve relative to minibatch SGD, but does not have a significant effect on local SGD, which is consistent with introducing a bias which depends on $K$ but not on $M$. This highlights that the “problematic regime” for local SGD is where there are few iterations per round.

Future work

In this paper, we provided the first analysis of local SGD showing improvement over minibatch SGD in a natural setting, but also demonstrated that local SGD can sometimes be worse than minibatch SGD, and is certainly not optimal.

As can be seen from Table 1, our upper and lower bounds for local SGD are still not tight. The first term depends on $K^{1/3}$ versus $K^{2/3}$—we believe the correct behaviour might be in between, namely $\sqrt{K}$, matching the bias of $K$-step SGD. The exact worst case behaviour of local SGD is therefore not yet resolved.

But beyond obtaining a precise analysis of local SGD, our paper highlights a more important challenge: we see that local SGD is definitely not optimal, and does not even always improve over minibatch SGD. Can we suggest an optimal algorithm in this setting? Or at least a method that combines the advantages of both local SGD and minibatch SGD and enjoys guarantees that dominate both? Our work motivates developing such an algorithm, which might also have benefits in regimes where local SGD is already better than minibatch SGD.

To answer this question will require new upper bounds and perhaps also new lower bounds. Looking to the analysis of local AC-SA for quadratic objectives in Corollary 1, we might hope to design an algorithm which achieves error

for general convex objectives. That is, an algorithm which combines the optimization term for $KR$ steps of accelerated gradient descent with the optimal statistical term. If this were possible, it would match the lower bound of Woodworth et al. and therefore be optimal with respect to this communication structure.

This work is partially supported by NSF-CCF/BSF award 1718970/2016741, NSF-DMS 1547396, and a Google Faculty Research Award. BW is supported by a Google PhD Fellowship. Part of this work was done while NS was visiting Google. Work by SS was done while visiting TTIC.

References

Appendix A Comparisons Between Existing Local SGD Analyses and Minibatch SGD

In this section, we describe the derivation of the entries in Table 1 for the cases in which it is not obvious. In particular, these previous analyses were stated based on different assumptions (stronger as well as weaker) which need to be reconciled with ours. Since local SGD is often analyzed in the strongly convex setting (or with weaker assumptions that are implied by strong convexity), we will make use of the following fact: If an algorithm guarantees error at most $\epsilon(\lambda)$ when applied to a $\lambda$-strongly convex function, then we can apply the algorithm to $F(x)+\frac{\lambda}{2}\|x\|^{2}$ in order to ensure error $\epsilon(\lambda)+\frac{\lambda}{2}\|x^{*}\|^{2}$. This applies for any $\lambda>0$, so we can actually infer that the algorithm, in fact, guarantees error at most $\min_{\lambda>0}\epsilon(\lambda)+\frac{\lambda}{2}\|x^{*}\|^{2}$.

Since our purpose is to show that these analyses are dominated by minibatch SGD, the entries in the table are, in some sense, the most optimistic interpretation of the bounds stated in the paper. For example, if error $\epsilon_{1}(\lambda)+\epsilon_{2}(\lambda)$ is guaranteed for strongly convex functions, we actually enter $\frac{1}{2}\min_{\lambda>0}\epsilon_{1}(\lambda)+\frac{\lambda}{2}\|x^{*}\|^{2}+\frac{1}{2}\min_{\lambda>0}\epsilon_{2}(\lambda)+\frac{\lambda}{2}\|x^{*}\|^{2}$ into the table, which is a lower bound on the actual guarantee.

For reference, we restate the worst-case guarantee of minibatch SGD:

A.2 Stich and Karimireddy [25]

A.3 Khaled et al. [13]

The relevant analysis from Khaled et al. is given in their Corollary 2, which is their only analysis that upper bounds the error in terms of the objective function suboptimality and in the setting where each machine receives i.i.d. stochastic gradients. Their Corollary 2 states that when $M\leq KR$, the error is bounded byThere is a typo in their statement which omits the factor of $H$ ($L$ in their notation) from the numerator of the first term.

In the case where $H=B=\sigma^{2}=1$, it is clear that this is strictly worse than minibatch SGD since $\frac{M}{R}>\frac{1}{R}$. However, consider the case of arbitrary $H$, $B$ and $\sigma^{2}$ and suppose Khaled et al. ’s guarantee is less than $\frac{\sigma B}{\sqrt{KR}}$, in which case

Consequently, (20) is either greater than $\frac{\sigma B}{\sqrt{KR}}$ or greater than $\frac{HB^{2}}{R}$. This does not mean that their upper bound is worse than minibatch SGD. However, it is worse than minibatch SGD unless $\frac{\sigma B}{\sqrt{KR}}\leq\frac{HB^{2}}{R}$.

If we interrogate what this regime corresponds to, we see that it is actually a trivial regime where $KR$ steps of serial SGD, which achieves error $\frac{HB^{2}}{KR}+\frac{\sigma B}{\sqrt{KR}}\leq\frac{HB^{2}}{R}$, is actually better than minibatch SGD. That is, rather than implementing minibatch SGD distributed across the $M$ machines, we are actually better off just ignoring $M-1$ of the available machines and doing serial SGD. If this is really the right thing to do, then there was never any need for parallelism in the first place, and thus there is no reason to use local SGD, which performs no better than serial SGD in this case anyways.

Appendix B Proofs from Section 3

We will show that the average of the iterates at any particular time $\bar{x}_{t}=\frac{1}{M}\sum_{m=1}^{M}x_{t}^{m}$ evolves according to $\mathcal{A}$ with a lower variance stochastic gradient, even though this average iterate is not explicitly computed by the algorithm at every step. It is easily confirmed from (6) that

where we used that $\mathcal{L}^{(t)}_{2}$ is linear. We will now show that $\frac{1}{M}\sum_{m^{\prime}=1}^{M}\nabla f\left(\mathcal{L}^{(t)}_{1}\left(x_{1}^{m^{\prime}},\dots,x_{t}^{m^{\prime}}\right);z_{t}^{m^{\prime}}\right)$ is an unbiased estimate of $\nabla F\left(\mathcal{L}^{(t)}_{1}\left(\bar{x}_{1},\dots,\bar{x}_{t}\right)\right)$ with variance bounded by $\frac{\sigma^{2}}{M}$. Therefore, $\bar{x}_{t+1}$ is updated exactly according to $\mathcal{A}$ with a lower variance stochastic gradient.

By the linearity of $\mathcal{L}^{(t)}_{1}$ and $\nabla F$

It is easily confirmed that SGD and AC-SA are linear update algorithms, which allows us to apply Theorem 1. In addition, Simchowitz shows that any randomized algorithm that accesses an deterministic first order oracle at most $T$ times will have error at least $\frac{cHB^{2}}{T^{2}}$ in the worst case for an $H$-smooth, convex quadratic objective, for some universal constant $c$. Therefore, the first term of local-AC-SA’s guarantee cannot be improved. The second term of the guarantee also cannot be improved —in fact, this term cannot be improved even by an algorithm which is allowed to make $MKR$ sequential calls to a stochastic gradient oracle. ∎

Appendix C Proof of Theorem 2

This proof is nearly identical to the proof of Lemma 3.1 due to Stich , and we claim no technical innovation here. We include it in order to be self-contained.

We begin by analyzing the distance of $\bar{x}_{t+1}$ from the optimum. Below, expectations are taken over the all of the random variables $\left\{z_{t}^{m}\right\}$ which determine the iterates $\left\{x_{t}^{m}\right\}$.

For any vectors $v_{m}$, $\left\|\sum_{m=1}^{M}v_{m}\right\|^{2}\leq M\sum_{m=1}^{M}\left\|v_{m}\right\|^{2}$. In addition, for any point $x$ and $H$-smooth $F$, $\left\|\nabla F(x)\right\|^{2}\leq 2H(F(x)-F(x^{*}))$, thus

By the $\lambda$-strong convexity of $F$, we have that

Finally, using the fact that for any vectors $a,b$ and any $\gamma>0$, $2\left\langle a,b\right\rangle\leq\gamma\|a\|^{2}+\gamma^{-1}\|b\|^{2}$ we have

Combining these with (29), we conclude that for $\gamma=2H$

By the convexity of $F$ and the fact that $\eta_{t}\leq\frac{1}{4H}$, this implies

We will proceed to bound the final term in Lemma 1 more tightly than was done by Stich , which allows us to improve on their upper bound. To do so, we will use the following technical lemmas:

For any $H$-smooth and convex $F$, and any $x$, and $y$

This proof follows closely from . Define the $H$-smooth, convex functions

By setting the gradients of these convex functions equal to zero, it is clear that $x$ minimizes $F_{x}$ and $y$ minimizes $F_{y}$. For any $H$-smooth and convex $F$, for any $z$, $\left\|\nabla F(z)\right\|^{2}\leq 2H(F(z)-\min_{x}F(x))$, therefore,

This is the second claim of the Lemma, and combining these last two inequalities proves the first claim. ∎

Let $F$ be any $H$-smooth and $\lambda$-strongly convex function, and let $\eta\leq\frac{1}{H}$. Then for any $x,y$

This Lemma and its proof are essentially identical to [12, Lemma 6], we include it here in order to keep our results self-contained, and we are more explicit about the steps used.

where the inequality follows from Lemma 2. Since $\eta H\leq 1$, we further conclude that

Finally, by the $\lambda$-strong convexity of $F$

First, we note that $x_{t}^{1},\dots,x_{t}^{M}$ are identically distributed. Therefore,

Under the conditions of Lemma 1, with the additional condition that the sequence of stepsizes $\eta_{1},\eta_{2},\dots$ is non-increasing and $\eta_{t}\leq\frac{1}{H}$ for all $t$, for any $t$ and any $m$

If $\eta_{t}=\frac{2}{\lambda(a+t+1)}$, then it further satisfies

for all $t$ and $m\neq m^{\prime}$. In addition,

where for the final inequality we used Lemma 3 and the fact that the stepsizes are less than $\frac{1}{H}$,. Since the iterates are averaged every $K$ iterations, for each $t$, there must be a $t_{0}$ with $0\leq t-t_{0}\leq K-1$ such that $x_{t_{0}}^{m}=x_{t_{0}}^{m^{\prime}}$. Therefore, we can unroll the recurrence above to conclude that

In the special case $\eta_{t}=\frac{2}{\lambda\left(a+t+1\right)}$, we have

Next, we show that Local SGD is always at least as good as $KR$ steps of sequential SGD. To do so, we use the following result from Stich :

with $a,b>0$, there exists a sequence $0<\gamma_{t}\leq\frac{1}{d}$ and weights $w_{t}>0$ such that

We now argue that Local SGD is never worse than $KR$ steps of sequential SGD:

Let $(f,\mathcal{D})\in\mathcal{F}(H,\lambda,B,\sigma^{2})$. When $\lambda=0$, an appropriate average of the iterates of Local SGD with an optimally tuned constant stepsize satisfies for a universal constant $c$

In the case $\lambda>0$, then an appropriate average of the iterates of Local SGD with decreasing stepsize $\eta_{t}\asymp(\lambda t)^{-1}$ satisfies for a universal constant $c$

Define $T:=KR$ and consider the $(t+1)$st iterate on some machine $m$, $x_{t+1}^{m}$. If $t+1\mod K\neq 0$, then $x_{t+1}^{m}=x_{t}^{m}-\eta_{t}\nabla f(x_{t}^{m};z_{t}^{m})$. In this case, for $\eta_{t}\leq\frac{1}{2H}$

Here, for the first inequality we used the variance bound on the stochastic gradients; for the second inequality we used the $H$-smoothness and $\lambda$-strong convexity of $F$; and for the final inequality we used that $H\eta_{t}\leq\frac{1}{2}$ and rearranged.

If, on the other hand, $t+1\mod K=0$, then $x_{t+1}^{m}=\frac{1}{M}\sum_{m^{\prime}=1}^{M}x_{t}^{m^{\prime}}-\eta_{t}\nabla f(x_{t}^{m^{\prime}};z_{t}^{m^{\prime}})$. Since the local iterates on the different machines are identically distributed,

Where for the first inequality we used Jensen’s inequality, and for the final equality we used that the local iterates are identically distributed. From here, using the same computation as above, we conclude that in either case

Choose a constant learning rate $\eta_{t}=\eta=\min\left\{\frac{1}{2H},\frac{B}{\sigma\sqrt{T}}\right\}$ and define the averaged iterate

The stepsizes and weights are chosen as follows: If $KR\leq\frac{2H}{\lambda}$, then $\eta_{t}=\frac{1}{2H}$ and $w_{t}=(1-\lambda\eta)^{-t-1}$. If $KR>\frac{2H}{\lambda}$ and $t<KR/2$, then $\eta_{t}=\frac{1}{2H}$ and $w_{t}=0$. If $KR>\frac{2H}{\lambda}$ and $t\geq KR/2$, then $\eta_{t}=\frac{2}{4H+\lambda(t-KR/2)}$ and $w_{t}=(4H/\lambda+t-KR/2)^{2}$. This completes the proof. ∎

Finally, we prove our main analysis of Local SGD. Portions of the analysis of the strongly convex case follow closely the proof of [24, Lemma 3]. See 2

We will prove the first terms in the $\min$’s in Theorem in two parts, first for the convex case $\lambda=0$, then for the strongly convex case $\lambda>0$. Then, we conclude by invoking Lemma 7 showing that Local SGD is never worse than $KR$ steps of SGD on a single machine, which corresponds to the second terms in the $\min$’s in the Theorem statement.

By Lemma 1 and the first claim of Lemma 5, the mean iterate satisfies

Consider a fixed stepsize $\eta_{t}=\eta$ which will be chosen later, and consider the average of the iterates

For the strongly convex case, following Stich ’s proof of Lemma 6, we choose stepsizes according to the following set of cases: If $KR\leq\frac{2H}{\lambda}$, then $\eta_{t}=\frac{1}{4H}$ and $w_{t}=(1-\lambda\eta)^{-t-1}$. If $KR>\frac{2H}{\lambda}$ and $t\leq KR/2$, then $\eta_{t}=\frac{1}{4H}$ and $w_{t}=0$. If $KR>\frac{2H}{\lambda}$ and $t>KR/2$, then $\eta_{t}=\frac{2}{8H+\lambda(t-KR/2)}$ and $w_{t}=(8H/\lambda+t-KR/2)$. We note that in the second and third cases, the stepsize is either constant or equal to $\eta_{t}=\frac{2}{\lambda(a+t-KR/2)}$ (for $a=\frac{8H}{\lambda}$) within each individual round of communication.

By Lemma 1 and the first claim of Lemma 5, during the rounds of communication for which the stepsize is constant, we have the recurrence:

On the other hand, during the rounds of communication in which the stepsize is decreasing, we have by Lemma 1 and the second claim of Lemma 5 that:

Furthermore, during the rounds (i.e. when $t>KR$) where the stepsize is decreasing,

First, suppose $KR>\frac{2H}{\lambda}$, and consider the steps during which $\eta_{t}=\frac{1}{4H}$:

Now, consider the remaining steps. Rearranging, we have

So, since $\eta_{t}=\frac{2}{\lambda(a+t)}$ where $a=\frac{8H}{\lambda}-\frac{KR}{2}$ and $w_{t}=(a+t)$, we have

Finally, we recall (102), $KR>\frac{2H}{\lambda}$, and note that $W_{T}=\sum_{t=KR/2}^{KR}a+t\geq\frac{3K^{2}R^{2}}{8}+\frac{aKR}{2}=\frac{K^{2}R^{2}}{8}+\frac{4HKR}{\lambda}\geq\frac{8H^{2}}{\lambda^{2}}$ thus

This concludes the proof for the case $KR>\frac{2H}{\lambda}$.

If $KR\leq\frac{2H}{\lambda}$, we use the constant stepsize $\eta_{t}=\eta$ and weights $w_{t}=(1-\lambda\eta)^{-t-1}$. Rearranging (94) therefore gives

Finally, we note that $W_{T}\geq(1-\lambda\eta)^{-KR-1}$ so

We also observe that $2H\geq\lambda KR$ so with $\eta=\frac{1}{4H}\leq\frac{1}{2\lambda KR}$ we have

Appendix D Proofs from Section 5

Here, we will prove the lower bound in Theorem 3. Recall the objective and stochastic gradient estimator for the hard instance are defined by

Due to the structure of the objective (120), which decomposes as a sum over three terms which each depend only on a single coordinate, the local-SGD dynamics on each coordinate of the optimization variable are independent of each other. For this reason, we are able to analyze local-SGD on each coordinate separately.

Define the $2L$-smooth and $L$-strongly convex function

Define a stochastic gradient estimator for $g_{L}$ via

for $z\sim\textrm{Uniform}(\pm\sigma)$. Observe that the third coordinate of local-SGD on $F$ evolves exactly the same as local-SGD on the univariate function $g_{L}$. In the next three lemmas, we analyze the behavior of local-SGD on $g_{L}$:

Consider the $2$nd iterate of SGD with fixed stepsize $\eta$:

Define $y\coloneqq(1-L\eta)x_{0}-L\eta\left[x_{0}\right]_{+}$, then

Now, consider the third iterate of SGD, $x_{3}$:

Since $z\mapsto\left[z\right]_{+}$ is convex, by Jensen’s inequality

The idea of this proof is simple: $k$ steps of SGD initialized at some point $x_{0}$ is equivalent to doing two steps of SGD initialized at $x_{0}$ to get $x_{2}$, then doing two more steps initialized at $x_{2}$ to get $x_{4}$, and so forth until $k$ steps have been completed. The only minor complication is if $k$ is odd, in which case we start by doing three steps initialized at $x_{0}$ to get $x_{3}$ and continue in steps of two.

Let $K\geq 2$ and let $\hat{x}$ be the output of local-SGD$(K,R,M)$ on $F$ using a fixed stepsize $\eta\leq\frac{1}{2L}$ and initialized at zero. Then

Since each coordinate evolves independently when optimizing $F$ using local-SGD, we can ignore the first two coordinates and focus only on the third. Observe that using local-SGD$(K,R,M)$ on $F$ with a fixed stepsize $\eta$ and initialized at zero to obtain $\hat{x}_{3}$ is exactly equivalent to using local-SGD$(K,R,M)$ on $g_{L}$ with the same fixed stepsize $\eta$ and initialized at $-c$. The different initialization is due to the fact that the local-SGD dynamics do not change with the change of variables $x-c\rightarrow x$. Let $\bar{x}_{r}$ denote the averaged iterate of local-SGD$(K,R,M)$ initialized at $-c$ with stepsize $\eta$ after the $r$th round of communication and let $x_{r,k,m}$ denote its $k$th iterate during the $r$th round of communication on the $m$th machine. We will start by proving that when $\eta\leq\frac{1}{2L}$ and either $c\geq\frac{\eta\sigma}{8}$ or $\eta\geq\frac{2}{LRK}$ then

Repeatedly applying Lemma 9 shows that for each $r$

Again, we can repeatedly apply Lemma 9 to show

We now analyze the progress of SGD on the first two coordinates of $F$ in the following lemma:

Let $\hat{x}$ be the output of local-SGD$(K,R,M)$ on $F$ using a fixed stepsize $\eta$ and initialized at zero. Then with probability 1,

Since the stochastic gradient estimator has no noise along the first and second coordinates, and since the separate coordinates evolve independently, $\hat{x}_{1}$ is exactly the output of $KR$ steps of deterministic gradient descent with fixed stepsize $\eta$ on the univariate function $x\mapsto\frac{\mu}{2}\left(x-b\right)^{2}$. Similarly, $\hat{x}_{2}$ is the output of $KR$ steps of deterministic gradient descent with fixed stepsize $\eta$ on $x\mapsto\frac{H}{2}\left(x-b\right)^{2}$. Thus,

Combining Lemmas 10 and 11, we are ready to prove the theorem: See 3

Consider optimizing the objective $F$ defined in (120) using the stochastic gradient oracle (121) initialized at zero and using a fixed stepsize $\eta$. The variance of the stochastic gradient oracle is equal to $\sigma^{2}$. This function is $\max\left\{\mu,H,2L\right\}$-smooth, and $\min\left\{\mu,H,L\right\}$-strongly convex. We will be choosing $L=\frac{H}{4}$ and $\mu\in\left[\lambda,\frac{H}{16}\right]$ so that $F$ is $H$-smooth and $\lambda$-strongly convex. Finally, the objective $F$ is minimized at the point $x^{*}=[b,b,c]^{\top}$ and $F(x^{*})=0$. This point has norm $\left\|x^{*}\right\|=\sqrt{2b^{2}+c^{2}}$ we will choose $b=c=\frac{B}{\sqrt{3}}$ so that $\left\|x^{*}\right\|=B$.

By Lemma 10, the output of local-SGD$(K,R,M)$, $\hat{x}$ satisfies

By Lemma 11, the output of local-SGD$(K,R,M)$, $\hat{x}$ satisfies

Consider two cases: first, suppose that $\eta\not\in\left[\frac{1}{2\mu KR},\frac{2}{H}\right]$. Then,

Suppose instead that $\eta\in\left[\frac{1}{2\mu KR},\frac{2}{H}\right]$. Since $L=\frac{H}{4}$, $\eta\leq\frac{2}{H}\leq\frac{1}{2L}$. Similarly, since $\mu\leq\frac{H}{16}=\frac{L}{4}$, $\eta\geq\frac{1}{2\mu KR}\geq\frac{2}{LRK}$. Therefore, $\eta\in\left[\frac{1}{2\mu KR},\frac{2}{H}\right]$ implies

This statement holds for any $\mu\in\left[\lambda,\frac{H}{16}\right]$. Consider three cases: first, suppose $\mu=\left(\frac{H\sigma^{2}}{3072B^{2}K^{2}R^{2}}\right)^{1/3}\in\left[\lambda,\frac{H}{16}\right]$. Then

Consider next the case that $\left(\frac{H\sigma^{2}}{3072B^{2}K^{2}R^{2}}\right)^{1/3}>\frac{H}{16}$ $\implies$ $\frac{\sigma^{2}}{192B^{2}K^{2}R^{2}}>\frac{H^{2}}{256}$ and choose $\mu=\frac{H}{16}$. Then

Finally, consider the case that $\left(\frac{H\sigma^{2}}{3072B^{2}K^{2}R^{2}}\right)^{1/3}<\lambda$ and choose $\mu=\lambda$. Then,

Combining these cases completes the proof. ∎