Local SGD Converges Fast and Communicates Little

Introduction

Stochastic Gradient Descent (SGD) consists of iterations of the form

In this work we follow an orthogonal approach, still with the goal to increase the compute to communication ratio: Instead of increasing the mini-batch size, we reduce the communication frequency. Rather than keeping the sequences on different machines in sync, we allow them to evolve locally on each machine, independent from each other, and only average the sequences once in a while (local SGD). Such strategies have been explored widely in the literature, under various names.

An extreme instance of this concept is one-shot SGD where the local sequences are only exchanged once, after the local runs have converged. Zhang et al. show statistical convergence (see also ), but the analysis restricts the algorithm to at most one pass over the data, which is in general not enough for the training error to converge. More practical are schemes that perform more frequent averaging of the parallel sequences, as e.g. for perceptron training (iterative parameter mixing), see also , for the training of deep neural networks (model averaging) or in federated learning .

The question of how often communication rounds need to be initiated has eluded a concise theoretical answer so far. Whilst there is practical evidence, the theory does not even resolve the question whether averaging helps when optimizing convex functions. Concretely, whether running local SGD on $K$ workers is $K$ times faster than running just a single instance of SGD on one worker.On convex functions, the average of the $K$ local solutions can of course only decrease the objective value, but convexity does not imply that the averaged point is $K$ times better.

We fill this gap in the literature and provide a concise convergence analysis of local SGD. We show that averaging helps. Frequent synchronization of $K$ local sequences increases the convergence rate by a factor of $K$, i.e. a linear speedup can be attained. Thus, local SGD is as efficient as parallel mini-batch SGD in terms of computation, but the communication cost can be drastically reduced.

Our proof is simple and straightforward, and we imagine that—with slight modifications of the proof—the technique can also be used to analyze other variants of SGD that evolve sequences on different worker that are not perfectly synchronized. Although we do not yet provide convergence guarantees for the non-convex setting, we feel that the positive results presented here will spark further investigation of local SGD for this important application (see e.g. ).

2 Related Work

A parallel line of work reduces the communication cost by compressing the stochastic gradients before communication. For instance, by limiting the number of bits in the floating point representation , or random quantization . The ZipML framework applies this technique also to the data . Sparsification methods reduce the number of non-zero entries in the stochastic gradient . A very aggressive—and promising—sparsification method is to keep only very few coordinates of the stochastic gradient by considering only the coordinates with the largest magnitudes .

Allowing asynchronous updates provides an alternative solution to disguise the communication overhead to a certain amount , though alternative strategies might be better when high accuracy is desired . The analysis of Agarwal & Duchi shows that asynchronous SGD on convex functions can tolerated delays up to $O(\sqrt{T/K})$, which is identical to the maximal length of the local sequences in local SGD. Asynchronous SGD converges also for larger delays (see also ) but without linear speedup, a similar statement holds for local SGD (see discussion in Section 3). The current frameworks for the analysis of asynchronous SGD do not cover local SGD. A fundamental difference is that asynchronous SGD maintains a (almost) synchronized sequence and gradients are computed with respect this unique sequence (but just applied with delays), whereas each worker in local SGD evolves a different sequence and computes gradient with respect those iterates.

For the training of deep neural networks, Bijral et al. discuss a stochastic averaging schedule whereas Zhang et al. study local SGD with more frequent communication at the beginning of the optimization process. The elastic averaging technique is different to local SGD, as it uses the average of the iterates only to guide the local sequences but does not perform a hard reset after averaging. Among the first theoretical studies of local SGD in the non-convex setting are that did not establish a speedup, in contrast to two more recent analyses . Yu et al. show linear speedup of local SGD on non-convex functions for $H=O(T^{1/4}K^{-3/4})$, which is more restrictive than the constraint on $H$ in the convex setting. Lin et al. study empirically hierarchical variants of local SGD.

Local SGD with averaging in every step, i.e. $H=1$, is identical to mini-batch SGD. Dekel et al. show that batch sizes $b=T^{\delta}$, for $\delta\in(0,\tfrac{1}{2})$ are asymptotically optimal for mini-batch SGD, however they also note that this asymptotic bound might be crude for practical purposes. Similar considerations might also apply to the asymptotic upper bounds on the communication frequency $H$ derived here. Local SGD with averaging only at the end, i.e. $H=T$, is identical to one-shot SGD. Jain et al. give concise speedup results in terms of bias and variance for one-shot SGD with constant stepsizes for the optimization of quadratic least squares problems. In contrast, our upper bounds become loose when $H\to T$ and our results do not cover one-shot SGD.

Recently, Woodworth et al. provided a lower bound for parallel stochastic optimization (in the convex setting, and not for strongly convex functions as considered here). The bound is not known to be tight for local SGD.

3 Outline

We formally introduce local SGD in Section 2 and sketch the convergence proof in Section 3. In Section 4 show numerical results to illustrate the result. We analyze asynchronous local SGD in Section 5. The proof of the technical results, further discussion about the experimental setup and implementation guidelines are deferred to the appendix.

Local SGD

The algorithm local SGD (depicted in Algorithm 1) generates in parallel $K$ sequences $\{\mathbf{x}_{t}^{k}\}_{t=0}^{T}$ of iterates, $k\in[K]$. Here $K$ denotes the level of parallelization, i.e. the number of distinct parallel sequences and $T$ the number of steps (i.e. the total number of stochastic gradient evaluations is $TK$). Let $\mathcal{I}_{T}\subseteq[T]$ with $T\in\mathcal{I}_{T}$ denote a set of synchronization indices. Then local SGD evolves the sequences $\{\mathbf{x}_{t}^{k}\}_{t=0}^{T}$ in the following way:

where indices $i_{t}^{k}\sim_{\rm u.a.r.}[n]$ and $\{\eta_{t}\}_{t\geq 0}$ denotes a sequence of stepsizes. If $\mathcal{I}_{T}=[T]$ then the synchronization of the sequences is performed every iteration. In this case, (4) amounts to parallel or mini-batch SGD with mini-batch size $K$.For the ease of presentation, we assume here that each worker in local SGD only processes a mini-batch of size $b=1$. This can be done without loss of generality, as we discuss later in Remark 2.4. On the other extreme, if $\mathcal{I}_{T}=\{T\}$, the synchronization only happens at the end, which is known as one-shot averaging.

In order to measure the longest interval between subsequent synchronization steps, we introduce the gap of a set of integers.

The gap of a set $\mathcal{\mathcal{P}}:=\{p_{0},\dots,p_{t}\}$ of $t+1$ integers, $p_{i}\leq p_{i+1}$ for $i=0,\dots,t-1$, is defined as $\operatorname{gap}(\mathcal{P}):=\max_{i=1,\dots,t}(p_{i}-p_{i-1})$.

Before jumping to the convergence result, we first discuss an important observation.

Towards local SGD.

For local SGD such a simple argument is elusive. For instance, just capitalizing the convexity of the objective function $f$ is not enough: this will show that the averaged iterate of $K$ independent SGD sequences converges at rate \mathcal{O}\bigl{(}\frac{\sigma^{2}}{T}\bigr{)}, i.e. no speedup can be shown in this way.

This indicates that one has to show that local SGD decreases the variance $\sigma^{2}$ instead, similar as in parallel SGD. Suppose the different sequences $\mathbf{x}_{t}^{k}$ evolve close to each other. Then it is reasonable to assume that averaging the stochastic gradients $\nabla f_{i_{t}^{k}}(\mathbf{x}_{t}^{k})$ for all $k\in[K]$ can still yield a reduction in the variance by a factor of $K$—similar as in parallel SGD. Indeed, we will make this statement precise in the proof below.

2 Convergence Result and Discussion

where $\hat{\mathbf{x}}_{T}=\frac{1}{KS_{T}}\sum_{k=1}^{K}\sum_{t=0}^{T-1}w_{t}\mathbf{x}_{t}^{k}$, for $w_{t}=(a+t)^{2}$ and $S_{T}=\sum_{t=0}^{T-1}w_{t}\geq\frac{1}{3}T^{3}$.

We were not especially careful to optimize the constants (and the lower order terms) in (5), so we now state the asymptotic result.

Let $\hat{\mathbf{x}}_{T}$ be as defined as in Theorem 2.2, for parameter $a=\max\{16\kappa,H\}$. Then

So far, we assumed that each worker only computes a single stochastic gradient. In mini-batch local SGD, each worker computes a mini-batch of size $b$ in each iteration. This reduces the variance by a factor of $b$, and thus Theorem (2.2) gives the convergence rate of mini-batch local SGD when $\sigma^{2}$ is replaced by $\frac{\sigma^{2}}{b}$.

We now state some consequences of equation (6). For the ease of the exposition we omit the dependency on $L$, $\mu$, $\sigma^{2}$ and $G^{2}$ below, but depict the dependency on the local mini-batch size $b$.

For $T$ large enough and assuming $\sigma>0$, the very first term is dominating in (6) and local SGD converges at rate $O(1/(KTb))$. That is, local SGD achieves a linear speedup in both, the number of workers $K$ and the mini-batch size $b$.

It needs to hold $H=O(\sqrt{T/(Kb)})$ to get the linear speedup. This yields a reduction of the number of communication rounds by a factor $O(\sqrt{T/(Kb)})$ compared to parallel mini-batch SGD without hurting the convergence rate.

We have not optimized the result for extreme settings of $H$, $K$, $L$ or $\sigma$. For instance, we do not recover convergence for the one-shot averaging, i.e. the setting $H=T$ (though convergence for $H=o(T)$, but at a lower rate).

Zhang et al. empirically observe that more frequent communication at the beginning of the optimization can help to get faster time-to-accuracy (see also ). Indeed, when the number of total iterations $T$ is not known beforehand (as it e.g. depends on the target accuracy, cf. (6) and also Section 4 below), then increasing the communication frequency seems to be a good strategy to keep the communication low, why still respecting the constraint $H=O(\sqrt{T/(Kb)})$ for all $T$.

Proof Outline

We now give the outline of the proof. The proofs of the lemmas are given in Appendix A.

Inspired by the perturbed iterate framework of we first define a virtual sequence $\{\bar{\mathbf{x}}_{t}\}_{t\geq 0}$ in the following way:

where the sequences $\{\mathbf{x}_{t}^{k}\}_{t\geq 0}$ for $k\in[K]$ are the same as in (4). Notice that this sequence never has to be computed explicitly, it is just a tool that we use in the analysis. Further notice that $\bar{\mathbf{x}}_{t}=\mathbf{x}_{t}^{k}$ for $k\in[K]$ whenever $t\in\mathcal{I}_{T}$. Especially, when $\mathcal{I}_{T}=[T]$, then $\bar{\mathbf{x}}_{t}\equiv\mathbf{x}_{t}^{k}$ for every $k\in[K],t\in[T]$. It will be useful to define

Now the proof proceeds as follows: we show (i) that the virtual sequence $\{\bar{\mathbf{x}}_{t}\}_{t\geq 0}$ almost behaves like mini-batch SGD with batch size $K$ (Lemma 3.1 and 3.2), and (ii) the true iterates $\{\mathbf{x}_{t}^{k}\}_{t\geq 0,k\in[K]}$ do not deviate much from the virtual sequence (Lemma 3.3). These are the main ingredients in the proof. To obtain the rate we exploit a technical lemma from .

Let $\{\mathbf{x}_{t}\}_{t\geq 0}$ and $\{\bar{\mathbf{x}}_{t}\}_{t\geq 0}$ for $k\in[K]$ be defined as in (4) and (7) and let $f$ be $L$-smooth and $\mu$-strongly convex and $\eta_{t}\leq\frac{1}{4L}$. Then

Bounding the variance.

Bounding the deviation.

If $\operatorname{gap}(\mathcal{I}_{T})\leq H$ and sequence of decreasing positive stepsizes $\{\eta_{t}\}_{t\geq 0}$ satisfying $\eta_{t}\leq 2\eta_{t+H}$ for all $t\geq 0$, then

Optimal Averaging.

Similar as in we define a suitable averaging scheme for the iterates $\{\bar{\mathbf{x}}_{t}\}_{t\geq 0}$ to get the optimal convergence rate. In contrast to that use linearly increasing weights, we use quadratically increasing weights, as for instance .

Let $\{a_{t}\}_{t\geq 0}$, $a_{t}\geq 0$, $\{e_{t}\}_{t\geq 0}$, $e_{t}\geq 0$ be sequences satisfying

for $\eta_{t}=\frac{4}{\mu(a+t)}$ and constants $A>0$, $B,C\geq 0$, $\mu>0$, $a>1$. Then

for $w_{t}=(a+t)^{2}$ and $S_{T}:=\sum_{t=0}^{T-1}w_{t}=\frac{T}{6}\left(2T^{2}+6aT-3T+6a^{2}-6a+1\right)\geq\frac{1}{3}T^{3}$.

This is a reformulation of Lemma 3.3 in . ∎

Proof of Theorem 2.2.

Numerical Illustration

In this section we show some numerical experiments to illustrate the results of Theorem 2.2.

When Algorithm 1 is implemented in a distributed setting, there are two components that determine the wall-clock time: (i) the total number of gradient computations, $TK$, and (ii) the total time spend for communication. In each communication round $2(K-1)$ vectors need to be exchanged, and there will be $T/H$ communication rounds. Typically, the communication is more expensive than a single gradient computation. We will denote this ratio by a factor $\rho\geq 1$ (in practice, $\rho$ can be 10–100, or even larger on slow networks). The parameter $T$ depends on the desired accuracy $\epsilon>0$, and according to (6) we roughly have $T(\epsilon,H,K)\approx\frac{1}{K\epsilon}\left(\tfrac{1}{2}+\tfrac{1}{2}\sqrt{1+\epsilon(1+H+H^{2}K)}\right)$. Thus, the theoretical speedup $S(K)$ of local SGD on $K$ machines compared to SGD on one machine ($H=1$, $K=1$) is

Theoretical.

Examining (13), we see that (i) increasing $H$ can reduce negative scaling effects due to parallelization (second bracket in the denominator of (13)), and (ii) local SGD only shows linear scaling for $\epsilon\ll 1$ (i.e. $T$ large enough, in agreement with the theory). In Figure 3 we depict $S(K)$, once for $\epsilon=0$ in Figure 2(b), and for positive $\epsilon>0$ in Figure 2(a) under the assumption $\rho=25$. We see that for $\epsilon=0$ the largest values of $H$ give the best speedup, however, when only a few epochs need to be performed, then the optimal values of $H$ change with the number of workers $K$. We also see that for a small number of workers $H=1$ is never optimal. If $T$ is unknown, then these observations seem to indicate that the technique from , i.e. adaptively increasing $H$ over time seems to be a good strategy to get the best choice of $H$ when the time horizon is unknown.

Experimental.

Conclusion.

The restriction on $H$ imposed by theory is not severe for $T\to\infty$. Thus, for training that either requires many passes over the data or that is performed only on a small cluster, large values of $H$ are advisable. However, for smaller $T$ (few passes over the data), the $O(1/\sqrt{K})$ dependency shows significantly in the experiment. This has to be taken into account when deploying the algorithm on a massively parallel system, for instance through the technique mentioned in .

Asynchronous Local SGD

In this section we present asynchronous local SGD that does not require that the local sequences are synchronized. This does not only reduce communication bottlenecks, but by using load-balancing techniques the algorithm can optimally be tuned to heterogeneous settings (slower workers do less computation between synchronization, and faster workers do more). We will discuss this in more detail in Section C.

Asynchronous local SGD generates in parallel $K$ sequences $\{\mathbf{x}_{t}^{k}\}_{t=0}^{T}$ of iterates, $k\in[K]$. Similar as in Section 2 we introduce sets of synchronization indices, $\mathcal{I}_{t}^{k}\subseteq[T]$ with $T\in\mathcal{I}_{T}^{k}$ for $k\in[K]$. Note that the sets do not have to be equal for different workers. Each worker $k$ evolves locally a sequence $\mathbf{x}_{t}^{k}$ in the following way:

where $\bar{\bar{\mathbf{x}}}_{t+1}^{k}$ denotes the state of the aggregated variable at the time when worker $k$ reads the aggregated variable. To be precise, we use the notation

where $\mathcal{W}_{t}^{k,h}\subseteq[T]$ denotes all updates that have been written at the time the read takes place. The sets $\mathcal{W}_{t}^{k,h}$ are indexed by iteration $t$, worker $k$ that initiates the read and $h\in[K]$. Thus $\mathcal{W}_{t}^{k,h}$ denotes all updates of the local sequence $\{\mathbf{x}_{t}^{h}\}_{t\geq 0}$, that have been reported back to the server at the time worker $k$ reads (in iteration $t$). This notation is necessary, as we don’t necessarily have $\mathcal{W}_{t}^{k,h}=\mathcal{W}_{t}^{k^{\prime},h}$ for $k\neq k^{\prime}$. We have $\mathcal{W}_{t}^{k,h}\subseteq\mathcal{W}_{t^{\prime}}^{k,h}$ for $t^{\prime}\geq t$, as updates are not overwritten. When we cast synchronized local SGD in this notation, then it holds $\mathcal{W}_{t}^{k,h}=\mathcal{W}_{t}^{k^{\prime},h^{\prime}}$ for all $k,h,k^{\prime},h^{\prime}$, as all the writes and reads are synchronized.

Let $f$, $\sigma$, $G$ and $\kappa$ be as in Theorem 5.1 and sequences $\{\mathbf{x}_{t}^{k}\}_{t=0}^{T}$ for $k\in[K]$ generated according to (14) with $\operatorname{gap}(\mathcal{I}_{T}^{k})\leq H$ for $k\in K$ and for stepsizes $\eta_{t}=\frac{4}{\mu(a+t)}$ with shift parameter $a>\max\{16\kappa,H+\tau\}$ for delay $\tau>0$. If $\mathcal{W}_{t}^{k,h}\supseteq[t-\tau]$ for all $k,h\in[K]$, $t\in[T]$, then

where $\hat{\mathbf{x}}_{T}=\frac{1}{KS_{T}}\sum_{k=1}^{K}\sum_{t=0}^{T-1}w_{t}\mathbf{x}_{t}^{k}$, for $w_{t}=(a+t)^{2}$ and $S_{T}=\sum_{t=0}^{T-1}w_{t}\geq\frac{1}{3}T^{3}$.

Hence, for $T$ large enough and $(H+\tau)=O(\sqrt{T/K})$, asynchronous local SGD converges with rate O\bigl{(}\frac{G^{2}}{KT}\bigr{)}, the same rate as synchronous local SGD.

Conclusion

We prove convergence of synchronous and asynchronous local SGD and are the first to show that local SGD (for nontrivial values of $H$) attains theoretically linear speedup on strongly convex functions when parallelized among $K$ workers. We show that local SGD saves up to a factor of $O(T^{1/2})$ in global communication rounds compared to mini-batch SGD, while still converging at the same rate in terms of total stochastic gradient computations.

Deriving more concise convergence rates for local SGD could be an interesting future direction that could deepen our understanding of the scheme. For instance one could aim for a more fine grained analysis in terms of bias and variance terms (similar as e.g. in ), relaxing the assumptions (here we relied on the bounded gradient assumption), or investigating the data dependence (e.g. by considering data-depentent measures like e.g. gradient diversity ). There are also no apparent reasons that would limit the extension of the theory to non-convex objective functions; Lemma 3.3 does neither use the smoothness nor the strong convexity assumption, so this can be applied in the non-convex setting as well. We feel that the positive results shown here can motivate and spark further research on non-convex problems. Indeed, very recent work analyzes local SGD for non-convex optimization problems and shows convergence of SGD to a stationary point, though the restrictions on $H$ are stronger than here.

Acknowledgments

The author thanks Jean-Baptiste Cordonnier, Tao Lin and Kumar Kshitij Patel for spotting various typos in the first versions of this manuscript, as well as Martin Jaggi for his support.

References

Appendix A Missing Proofs for Synchronized Local SGD

In this section we provide the proofs for the three lemmas that were introduced in Section 3.

where we used the inequality $\lVert\sum_{i=1}^{K}\mathbf{a}_{i}\rVert^{2}\leq K\sum_{i=1}^{K}\left\lVert\mathbf{a}_{i}\right\rVert^{2}$ in (21). By $L$-smoothness,

To estimate the last term in (22) we use $2\left\langle\mathbf{a},\mathbf{b}\right\rangle\leq\gamma\left\lVert\mathbf{a}\right\rVert^{2}+\gamma^{-1}\left\lVert\mathbf{b}\right\rVert^{2}$, for $\gamma>0$. This gives

where we have again used (23) in the last inequality. By applying these three estimates to (22) we get

For $\eta_{t}\leq\frac{1}{4L}$ it holds \bigl{(}\eta_{t}L-\frac{1}{2}\bigr{)}\leq-\frac{1}{4}. By convexity of $a\left(f(\mathbf{x})-f^{\star}\right)+b\left\lVert\mathbf{x}-\mathbf{x}^{\star}\right\rVert^{2}$ for $a,b\geq 0$:

Finally, we can plug (30) back into (18). By taking expectation we get

By definition of $\mathbf{g}_{t}$ and $\bar{\mathbf{g}}_{t}$ we have

where we used $\operatorname{Var}(\sum_{k=1}^{K}X_{k})=\sum_{k=1}^{K}\operatorname{Var}(X_{k})$ for independent random variables. ∎

Appendix B Missing Proof for Asynchronous Local SGD

In this Section we prove Theorem 5.1. The proof follows closely the proof presented in Section 3. We again introduce the virtual sequence

as before. By the property $T\in\mathcal{I}_{T}^{k}$ for $k\in K$ we know that all workers will have written their updates when the algorithm terminates. This assumption is not very critical and could be relaxed, but it facilitates the (already quite heavy) notation in the proof.

Observe, that Lemmas 3.1 and 3.2 hold for the virtual sequence $\{\bar{\mathbf{x}}_{t}\}_{t=0}^{T}$. Hence, all we need is a refined version of Lemma 3.3 that bounds how far the local sequences can deviate from the virtual average.

If $\operatorname{gap}(\mathcal{I}^{k}_{T})\leq H$ and $\exists\tau>0$, s.t. $\mathcal{W}_{t}^{k,h}\supseteq[t-\tau]$ for all $k,h\in[K]$, $t\in[T]$, and sequence of decreasing positive stepsizes $\{\eta_{t}\}_{t\geq 0}$ satisfying $\eta_{t}\leq 2\eta_{t+H+\tau}$ for all $t\geq 0$, then

Here we use the notation $[s]=\{\}$ for $s<0$, such that $[t-\tau]$ is also defined for $t<\tau$.

As $\operatorname{gap}(\mathcal{I}^{k}_{T})\leq H$ there exists for every $k\in K$ a $t_{k}$, $t-t_{k}\leq H$, such that $\mathbf{x}_{t_{k}}^{k}=\bar{\bar{x}}_{t_{k}}^{k}$. Let $t_{0}:=\min\{t_{1},\dots,t_{K}\}$ and observe $t_{0}\geq t-H$. Let $t_{0}^{\prime}=\max\{t_{0}-\tau,0\}$. As $\mathcal{W}_{t}^{k,h}\supseteq[t-\tau]$ for all $k,h\in[K]$, $t\in[T]$, it holds

for each $k\in[K]$. In other words, all updates up to iteration $t_{0}^{\prime}$ have been written to the aggregated sequence.

Now, using $\eta_{t}\geq\eta_{t+1}$, and $t-t_{k}\leq H$, we conclude (as in (36))

and similarly, as $t-t_{0}^{\prime}\leq H+\tau$,

Finally, as $\frac{\eta_{t_{0}^{\prime}}}{\eta_{t}}\leq 2$, we can conclude

Now the proof of Theorem 5.1 follows immediately.

As in the proof of Theorem 2.2 we rely on Lemma 3.4 to derive the convergence rate. Again, we have $A=\frac{1}{2}$, $B=\frac{\sigma^{2}}{K}$, and $C=LG^{2}(H+\tau)^{2}$ (Lemma B.1). It is easy to see that the stepsizes satisfy the condition of Lemma B.1, as clearly $\frac{\eta_{t_{0}^{\prime}}}{\eta_{t}}\leq\frac{\eta_{t_{0}^{\prime}}}{\eta_{t_{0}^{\prime}+H+\tau}}=\frac{a+t+H+\tau}{a+t}\leq 2$, as $a\geq H+\tau$. ∎

Appendix C Comments on Implementation Issues

In Theorem 5 we do not prove convergence of the sequences $\{\mathbf{x}_{t}^{k}\}_{t\geq 0}$ of the iterates, but only convergence of a weighted average of all iterates. In practice, the last iterate might often be sufficient, but we like to remark that the weighted average of the iterates can easily be tracked on the fly with an auxiliary sequence $\{\mathbf{y}_{t}\}_{t>0}$, $\mathbf{y}_{0}=\mathbf{x}_{0}$, without storing all intermediate iterates, see Table 1 for some examples.

C.2 Asynchronous Local SGD

As for synchronous local SGD, the weighted averages of the iterates (if needed), can be tracked on each worker locally by a recursive formula as explained above.

A more important aspect that we do not have discussed yet, is that Algorithm 2 allows for an easy procedure to balance the load in heterogeneous settings. In our notation, we have always associated the local sequences $\{\mathbf{x}_{t}^{k}\}$ with a specific worker $k$. However, the computation of the sequences does not need to be tied to a specific worker. Thus, a fast worker $k$ that has advanced his local sequence too much already, can start computing updates for another sequence $k^{\prime}\neq k$, if worker $k^{\prime}$ is lagged behind. This was not possible in the synchronous model, as there all communications had to happen in sync. We demonstrate this principle in Table 2 below for two workers. Note that also the running averages can still be maintained.

Appendix D Details on Experiments

For each run, we initialize $\mathbf{x}_{0}=\mathbf{0}_{d}$ and measure the number of iterationsNote, that besides the randomness involved the stochastic gradient computations, the averaging steps of synchronous local SGD are deterministic. Hence, these results (convergence in terms if numbers of iterations) can be reproduced by just simulating local SGD by using virtual workers (which we did for large number of $K$). For completeness, we report that all experiments were run on an an Ubuntu 16.04 machine with a 24 cores processor Intel® Xeon® CPU E5-2680 v3 @ 2.50GHz. (and number of stochastic gradient evaluations) to reach the target accuracy $\epsilon\in\{0.005,0.0001\}$. As we prove convergence only for a special weighted sum of the iterates in Theorem 2.2 and not for standard criteria (last iterate or uniform average), we evaluate the function value for different weighted averages $\mathbf{y}_{t}=\frac{1}{\sum_{i=0}^{t}w_{i}}\sum_{i=0}^{t}w_{i}\mathbf{x}_{t}$, and consider the accuracy reached when one of the averages satisfies $f(\mathbf{y}_{t})-f^{\star}\leq\epsilon$, with $f^{\star}:=0.126433176216545$ (numerically determined). The precise formulas for the averages that we used are given in Table 1.

In Figures 4 and 5 we give additional results for mini-batch sizes $b\in\{1,16\}$.