Sparsified SGD with Memory

1 Introduction

Stochastic Gradient Descent (SGD) [28] and variants thereof (e.g. [9, 15]

) are among the most popular optimization algorithms in machine- and deep-learning

[5]. SGD consists of iterations of the form

x_{t + 1}

:= x_{t} - η_{t} g_{t},

(1)

for iterates $x_{t}, x_{t + 1} \in R^{d}$ , stepsize (or learning rate) $η_{t} > 0$ , and stochastic gradient $g_{t}$ with the property $E [g_{t}] = \nabla f (x_{t})$

, for a loss function

f : R^{d} \to R

. SGD addresses the computational bottleneck of full gradient descent, as the stochastic gradients can in general be computed much more efficiently than a full gradient

\nabla f (x_{t})

. However, note that in general both

g_{t}

and

\nabla f (x_{t})

are densevectors¹¹1 Note that the stochastic gradients

g_{t}

are dense vectors for the setting of training neural networks. The

g_{t}

themselves can be sparse for generalized linear models under the additional assumption that the data is sparse. of size

d

, i.e. SGD does not address the communication bottleneck of gradient descent, which occurs as a roadblock both in distributed as well as parallel training. In the setting of distributed training, communicating the stochastic gradients to the other workers is a major limiting factor for many large scale (deep) learning applications, see e.g. [32, 3, 43, 20]. The same bottleneck can also appear for parallel training, e.g. in the increasingly common setting of a single multi-core machine or device, where locking and bandwidth of memory write operations for the common shared parameter

x_{t}

often forms the main bottleneck, see e.g. [24, 13, 17].

A remedy to address these issues seems to enforce applying smaller and more efficient updates $comp (g_{t})$ instead of $g_{t}$ , where $comp : R^{d} \to R^{d}$ generates a compression of the gradient, such as by lossy quantization or sparsification. We discuss different schemes below. However, too aggressive compression can hurt the performance, unless it is implemented in a clever way: 1Bit-SGD [32, 36] combines gradient quantization with an error compensation technique, which is a memory or feedback mechanism. We in this work leverage this key mechanism but apply it within more the more general setting of SGD. We will now sketch how the algorithm uses feedback of to correct for errors accumulated in previous iterations. Roughly speaking, the method keeps track of a memory vector $m$ which contains the sum of the information that has been suppressed thus far, i.e. $m_{t + 1} := m_{t} + g_{t} - comp (g_{t})$ , and injects this information back in the next iteration, by transmitting $comp (m_{t + 1} + g_{t + 1})$ instead of only $comp (g_{t + 1})$ . Note that updates of this kind are not unbiased (even if $comp (g_{t + 1})$ would be) and there is also no control over the delay after which the single coordinates are applied. These are some (technical) reasons why there exists no theoretical analysis of this scheme up to now.

In this paper we give a concise convergence rate analysis for SGD with memory and $k$ -compression operators²²2See Definition 2.1., such as (but not limited to) top- $k$ sparsification. Our analysis also supports ultra-sparsification operators for which $k < 1$ , i.e. where less than one coordinate of the stochastic gradient is applied on average in (1). We not only provide the first convergence result of this method, but the result also shows that the method converges at the same rate as vanilla SGD.

1.1 Related Work

There are several ways to reduce the communication in SGD. For instance by simply increasing the amount of computation before communication, i.e. by using large mini-batches (see e.g. [42, 11]), or by designing communication-efficient schemes [44]. These approaches are a bit orthogonal to the methods we consider in this paper, which focus on quantization or sparsification of the gradient.

Several papers consider approaches that limit the number of bits to represent floating point numbers [12, 23, 30]. Recent work proposes adaptive tuning of the compression ratio [7]

. Unbiased quantization operators not only limit the number of bits, but quantize the stochastic gradients in such a way that they are still unbiased estimators of the gradient

[3, 40]. The ZipML framework also applies this technique to the data [43]. Sparsification methods reduce the number of non-zero entries in the stochastic gradient [3, 39].

A very aggressive sparsification method is to keep only very few coordinates of the stochastic gradient by considering only the coordinates with the largest magnitudes [8, 1]. In contrast to the unbiased schemes it is clear that such methods can only work by using some kind of error accumulation or feedback procedure, similar to the one the we have already discussed [32, 36], as otherwise certain coordinates could simply never be updated. However, in certain applications no feedback mechanism is needed [37]. Also more elaborate sparsification schemes have been introduced [20].

Asynchronous updates provide an alternative solution to disguise the communication overhead to a certain amount [18]. However, those methods usually rely on a sparsity assumption on the updates [24, 30], which is not realistic e.g. in deep learning. We like to advocate that combining gradient sparsification with those asynchronous schemes seems to be a promising approach, as it combines the best of both worlds. Other scenarios that could profit from sparsification are heterogeneous systems or specialized hardware, e.g. accelerators [10, 43].

Convergence proofs for SGD [28] typically rely on averaging the iterates [29, 26, 22], though convergence of the last iterate can also be proven [33]. For our convergence proof we rely on averaging techniques that give more weight to more recent iterates [16, 33, 27], as well as the perturbed iterate framework from Mania et al. [21] and techniques from [17, 35].

Simultaneous to our work, [4, 38] at NIPS 2018 propose related schemes. We will update this discussion once they become available. Another simultaneous analysis of [41]

at ICML 2018 is restricted to unbiased gradient compression. This scheme also critically relies on an error compensation technique, but in contrast to our work the analysis is restricted to quadratic functions and the scheme introduces two additional hyperparameters that control the feedback mechanism.

1.2 Contributions

We consider finite-sum convex optimization problems $f : R^{d} \to R$ of the form

f (x)

= \frac{1}{n} n \sum i = 1 f_{i} (x),

x^{⋆}

:= a r g m i n x \in R^{d} f (x),

f^{⋆}

:= f (x^{⋆}),

(2)

where each $f_{i}$ is $L$ -smooth³³3 $f_{i} (y) \leq f_{i} (x) + ⟨ \nabla f_{i} (x), y - x ⟩ + \frac{L}{2} {∥ y - x ∥}^{2}$ , $\forall x, y \in R^{d}$ , $i \in [n]$ . and $f$ is $μ$ -strongly convex⁴⁴4, $\forall x, y \in R^{d}$ .. We consider a sequential sparsified SGD algorithm with error accumulation technique and prove convergence for $k$ -compression operators, $0 < k \leq d$ (for instance the sparsification operators top- $k$ or random- $k$ ). For appropriately chosen stepsizes and an averaged iterate ${¯ x}_{T}$ after $T$ steps we show convergence

E f ({¯ x}_{T}) - f^{⋆} = O (\frac{G^{2}}{μ T}) + O ⎛ ⎜ ⎝ \frac{\frac{d^{2}}{k^{2}} G^{2} κ}{μ T^{2}} ⎞ ⎟ ⎠ + O ⎛ ⎜ ⎝ \frac{\frac{d^{3}}{k^{3}} G^{2}}{μ T^{3}} ⎞ ⎟ ⎠,

(3)

for $κ = \frac{L}{μ}$ and $G^{2} \geq E {∥ \nabla f_{i} (x_{t}) ∥}_{i}^{2}$ . Not only is this, to the best of our knowledge, the first convergence result for sparsified SGD with memory, but the result also shows that for $T = Ω (\frac{d}{k} \sqrt{κ})$ the first term is dominating and the convergence rate is the same as for vanilla SGD.

We introduce the method formally in Section 2 and show a sketch of the convergence proof in Section 3. In Section 4 we include a few numerical experiments for illustrative purposes. The experiments highlight that top- $k$ sparsification yields a very effective compression method and does not hurt convergence. Our multi-core simulations demonstrate that SGD with memory scales better than asynchronous SGD thanks to the enforced sparsity of the updates. It also drastically decreases the communication cost without sacrificing the rate of convergence. We like to stress that the effectiveness of SGD variants with sparsification techniques has already been demonstrated in practice [8, 1, 20, 36, 32].

Although we do not yet provide convergence guarantees for parallel and asynchronous variants of the scheme, this is the main application of this method. For instance, we like to highlight that asynchronous SGD schemes [24, 2] could profit from the gradient sparsification. To demonstrate this use-case, we include in Section 4 a set of experiments for a multi-core implementation.

2 SGD with Memory

In this section we present the sparse SGD algorithm with memory. First we introduce the sparsification operators that we use to drastically reduce the communication cost in comparison with vanilla SGD.

2.1 Compression and Sparsification Operators

We consider compression operators that satisfy the following contraction property:

Definition 2.1 ( $k$ -contraction).

For a parameter $0 < k \leq d$ , a $k$ -contraction operator is a (possibly randomized) operator $comp : R^{d} \to R^{d}$ that satisfies the contraction property

E {∥ x - c o m p (x) ∥}^{2} \leq (1 - \frac{k}{d}) {∥ x ∥}^{2}, \forall x \in R^{d} .

(4)

The contraction property is sufficient to obtain all mathematical results that are derived in this paper. However, note that (4) does not imply that $comp (x)$ is a necessarily sparse vector. Also dense vectors can satisfy (4). One of the main goals of this work is to derive communication efficient schemes, thus we are particularly interested in operators that also ensure that $comp (x)$ can be encoded much more efficiently than the original $x$ .

The following two operators are examples of $k$ -sparsification operators, that is contraction operators with the additional property of being $k$ -sparse vectors:

Definition 2.2.

For a parameter $1 \leq k \leq d$ , the operators ${top}_{k} : R^{d} \to R^{d}$ and ${rand}_{k} : R^{d} \times Ω_{k} \to R^{d}$ , where $Ω_{k} = (\frac{[d]}{k})$ denotes the set of all $k$ element subsets of $[d]$ , are defined for $x \in R^{d}$ as

({top}_{k} (x))_{i}

:= {\begin{matrix} (x)_{π (i)}, & if i \leq k, 0 & otherwise, \end{matrix}

({rand}_{k} (x, ω))_{i}

:= {\begin{matrix} (x)_{i}, & if i \in ω, 0 & otherwise, \end{matrix}

(5)

where $π$ is a permutation of $[d]$ such that for $i = 1, \dots, d - 1$ . We abbreviate ${rand}_{k} (x)$ whenever the second argument is chosen uniformly at random, $ω \sim_{u . a . r .} Ω_{k}$ .

It is easy to see that both operators satisfy Definition 2.1 of being a $k$ -contraction. For completeness the proof is included in Appendix A.1.

We note that our setting is more general than simply measuring sparsity in terms of the cardinality, i.e. the non-zero elements of vectors in $R^{d}$ . Instead, Definition 2.1 can also be considered for quantization or e.g. floating point representation of each entry of the vector. In this setting we would for instance measure sparsity in terms of the number of bits that are needed to encode the vector.

Remark 2.3 (Ultra-sparsification).

We like to highlight that many other operators do satisfy Definition 2.1, not only the two examples given in Definition 2.2

. As a notable variant is to pick a random coordinate of a vector with probability

\frac{k}{d}

, for

0 < k \leq 1

, property (4) holds even if

k < 1

. I.e. it suffices to transmit on average less than one coordinate per iteration (this would then correspond to a mini-batch update).

2.2 Variance Blow-up for Unbiased Updates

Before introducing SGD with memory we first discuss a motivating example. Consider the following variant of SGD, where $(d - k)$ random coordinates of the stochastic gradient are dropped:

x_{t + 1}

:= x_{t} - η_{t} g_{t},

g_{t}

:= \frac{d}{k} \cdot {rand}_{k} (\nabla f_{i} (x_{t})),

(6)

where $i \sim_{u . a . r} [n]$ . It is important to note that the update is unbiased, i.e. $E g_{t} = \nabla f (x)$ . For carefully chosen stepsizes $η_{t}$ this algorithm converges at rate $O (\frac{σ^{2}}{t})$ on strongly convex and smooth functions $f$ , where $σ^{2}$

is an upper bound on the variance, see for instance

[45]. We have

σ^{2} = E {∥ ∥ \frac{d}{} k {rand}_{k} (\nabla f_{i} (x)) - \nabla f (x) ∥ ∥}_{k}^{2} \leq E {∥ ∥ \frac{d}{k} {rand}_{k} (\nabla f_{i} (x)) ∥ ∥}_{k}^{2} \leq \frac{d}{k} E_{i} {∥ \nabla f_{i} (x) ∥}_{i}^{2} \leq \frac{d}{k} G^{2}

where we used the variance decomposition $E {∥ X - E X ∥}^{2} = E {∥ X ∥}^{2} - {∥ E X ∥}^{2}$ and the standard assumption $E_{i} {∥ \nabla f_{i} (x) ∥}_{i}^{2} \leq G^{2}$ . Hence, when $k$ is small this algorithm requires $d$ times more iterations to achieve the same error guarantee as vanilla SGD with $k = d$ .

It is well known that by using mini-batches the variance of the gradient estimator can be reduced. If we consider in (6) the estimator $g_{t} := \frac{d}{k} \cdot {rand}_{k} (\frac{1}{τ} \sum_{i \in I_{τ}} \nabla f_{i} (x_{t}))$ for $τ = ⌈ \frac{k}{d} ⌉$ , and $I_{τ} \sim_{u . a . r .} (\frac{[n]}{k})$ instead, we have

σ^{2} = E {∥ g_{t} - \nabla f (x_{t}) ∥}_{t}^{2} \leq E {∥ ∥ \frac{d}{k} \cdot {rand}_{k} (\frac{1}{τ} \sum_{i \in I_{τ}} \nabla f_{i} (x_{t})) ∥ ∥}_{k}^{2} \leq \frac{d}{k τ} E_{i} {∥ \nabla f_{i} (x_{t}) ∥}_{i}^{2} \leq G^{2} .

(7)

This shows that, when using mini-batches of appropriate size, the sparsification of the gradient does not hurt convergence. However, by increasing the mini-batch size, we increase the computation by a factor of $\frac{d}{k}$ .

These two observations seem to indicate that the factor $\frac{d}{k}$ is inevitably lost, either by increased number of iterations or increased computation. However, this is no longer true when the information in (6) is not dropped, but kept in memory. To illustrate this, assume $k = 1$ and that index $i$ has not been selected by the ${rand}_{1}$ operator in iterations $t = t_{0}, \dots, t_{s - 1}$ , but is selected in iteration $t_{s}$ . Then the memory $m_{t_{s}} \in R^{d}$ contains this past information $(m_{t_{s}})_{i} = \sum_{t = t_{0}}^{t_{s - 1}} (\nabla f_{i_{t}} (x_{t}))_{i}$ . Intuitively, we would expect that the variance of this estimator is now reduced by a factor of $s$ compared to the naïve estimator in (6), similar to the mini-batch update in (7). Indeed, SGD with memory converges at the same rate as vanilla SGD, as we will demonstrate below.

2.3 SGD with Memory: Algorithm and Convergence Results

We consider the following algorithm for parameter $0 < k \leq d$ , using a compression operator ${comp}_{k} : R^{d} \to R^{d}$ which is a $k$ -contraction (Definition 2.1)

x_{t + 1}

:= x_{t} - g_{t},

g_{t}

:= {comp}_{k} (m_{t} + η_{t} \nabla f_{i_{t}} (x_{t})),

m_{t + 1}

(8)

where $i_{t} \sim_{u . a . r .} [n]$ , $m_{0} := 0$ and ${η_{t}}_{t \geq 0}$ denotes a sequence of stepsizes. The pseudocode is given in Algorithm 1. Note that the gradients get multiplied with the stepsize $η_{t}$ at the timestep $t$ when they put into memory, and not when they are (partially) retrieved from the memory.

We state the precise convergence result for Algorithm 1 in Theorem 2.4 below. In Remark 2.6 we give a simplified statement in big- $O$ notation for a specific choice of the stepsizes $η_{t}$ .

1:Initialize variables

x_{0}

and

m_{0} = 0

2:for

t

0 \dots T - 1

3: Sample

i_{t}

uniformly in

[n]

g_{t} \leftarrow {comp}_{k} (m_{t} + η_{t} \nabla f_{i_{t}} (x_{t}))

x_{t + 1} \leftarrow x_{t} - g_{t}

m_{t + 1} \leftarrow m_{t} + η_{t} \nabla f_{i_{t}} (x_{t}) - g_{t}

7:end for

Algorithm 1 Mem-SGD

1:Initialize shared variable

x

2:and

m_{0}^{w} = 0

\forall w \in [W]

3:parallel for

w

1 \dots W

4: for

t

0 \dots T - 1

5: Sample

i_{t}^{w}

uniformly in

[n]

g_{t}^{w} \leftarrow {comp}_{k} (m_{t}^{w} + η_{t} \nabla f_{i_{t}^{w}} (x))

x \leftarrow x - g_{t}^{w}

▹

shared memory

m_{t + 1}^{w} \leftarrow m_{t}^{w} + η_{t} \nabla f_{i_{t}^{w}} (x) - g_{t}^{w}

9: end for

10:end parallel for

Algorithm 2 Parallel-Mem-SGD

Figure 1: Left: The Mem-SGD algorithm. Right: Implementation for multi-core experiments.

Theorem 2.4.

Let $f_{i}$ be $L$ -smooth, $f$ be $μ$ -strongly convex, $0 < k \leq d$ , for $t = 0, \dots, T - 1$ , where ${x_{t}}_{t \geq 0}$ are generated according to (8) for stepsizes $η_{t} = \frac{8}{μ (a + t)}$ and shift parameter $a > 1$ . Then for $α > 4$ such that $\frac{(α + 1) \frac{d}{k} + ρ}{ρ + 1} \leq a$ , with $ρ := \frac{4 α}{(α - 4) (α + 1)^{2}}$ , it holds

(9)

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

Remark 2.5 (Choice of the shift $a$ ).

Theorem 2.4 says that for any shift $a > 1$ there is a parameter $α (a) > 4$ such that (9) holds. However, for the choice $a = O (1)$ one has to set $α$ such that $\frac{α}{α - 4} = Ω (\frac{d}{k})$ and the last term in (9) will be of order $O (\frac{d^{3}}{k^{3} T^{2}})$ , thus requiring $T = Ω (\frac{d^{1.5}}{k^{1.5}})$ steps to yield convergence. For $α \geq 5$ we have $\frac{α}{α - 4} = O (1)$ and the last term is only of order $O (\frac{d^{2}}{k^{2} T^{2}})$ instead. However, this requires typically a large shift. Observe $\frac{(α + 1) \frac{d}{k} + ρ}{ρ + 1} \leq 1 + (α + 1) \frac{d}{k} \leq (α + 2) \frac{d}{k}$ , i.e. setting $a = (α + 2) \frac{d}{k}$ is enough. We like to stress that in general it is not advisable to set $a ≫ (α + 2) \frac{d}{k}$ as the first two terms in (9) depend on $a$ . In practice, it often suffices to set $a = \frac{d}{k}$ , as we will discuss in Section 4.

Remark 2.6.

As discussed in Remark 2.5 above, setting $α = 5$ and $a = (α + 2) \frac{d}{k}$ is feasible. With this choice, equation (9) simplifies to

E f ({¯ x}_{T}) - f^{⋆} \leq O (\frac{G^{2}}{μ T}) + O ⎛ ⎜ ⎝ \frac{\frac{d^{2}}{k^{2}} G^{2} κ}{μ T^{2}} ⎞ ⎟ ⎠ + O ⎛ ⎜ ⎝ \frac{\frac{d^{3}}{k^{3}} G^{2}}{μ T^{3}} ⎞ ⎟ ⎠,

(10)

for $κ = \frac{L}{μ}$ . To estimate the second term in (9) we used the property for $μ$ -strongly convex $f$ , as derived in [27, Lemma 2]. We observe that for $T = Ω (\frac{d}{k} κ^{1 / 2})$ the first term is dominating, and Algorithm 1 converges at rate $O (\frac{G^{2}}{μ T})$ , the same rate as vanilla SGD [16].

3 Proof Outline

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

Perturbed iterate analysis.

Inspired by the perturbed iterate framework in [21] and [17] we first define a virtual sequence ${{~ x}_{t}}_{t \geq 0}$ in the following way:

{~ x}_{0}

= x_{0},

{~ x}_{t + 1} = {~ x}_{t} - η_{t} \nabla f_{i_{t}} (x_{t}),

(11)

where the sequences ${x_{t}}_{t \geq 0}, {η_{t}}_{t \geq 0}$ and ${i_{t}}_{t \geq 0}$ are the same as in (8). Notice that

{~ x}_{t} - x_{t} = (x_{0} - \sum_{j = 0}^{t - 1} η_{j} \nabla f_{i_{j}} (x_{j})) - (x_{0} - \sum_{j = 0}^{t - 1} g_{j}) = m_{t} .

(12)

Lemma 3.1.

Let ${x_{t}}_{t \geq 0}$ and ${{~ x}_{t}}_{t \geq 0}$ be defines as in (8) and (11) and let $f_{i}$ be $L$ -smooth and $f$ be $μ$ -strongly convex with . Then

E {∥ {~ x}_{t + 1} - x^{⋆} ∥}_{t + 1}^{2} \leq (1 - \frac{η_{t} μ}{2}) E {∥ {~ x}_{t} - x^{⋆} ∥}_{t}^{2} + η_{t}^{2} G^{2} - η_{t} e_{t} + η_{t} (μ + 2 L) E {∥ m_{t} ∥}_{t}^{2},

(13)

where $e_{t} := E f (x_{t}) - f^{⋆}$ .

Bounding the memory.

From equation (13) it becomes clear that we should derive an upper bound on $E {∥ m_{t} ∥}_{t}^{2}$ . For this we will use the contraction property (4) of the compression operators.

Lemma 3.2.

Let ${x_{t}}_{t \geq 0}$ as defined in (8) for $0 < k \leq d$ , and stepsizes $η_{t} = \frac{8}{μ (a + t)}$ with $a$ , $α > 4$ , as in Theorem 2.4. Then

E {∥ m_{t} ∥}_{t}^{2} \leq η_{t}^{2} \frac{4 α}{α - 4} \frac{d^{2}}{k^{2}} G^{2} .

(14)

Optimal averaging.

Similar as discussed in [16, 33, 27] we have to define a suitable averaging scheme for the iterates ${x_{t}}_{t \geq 0}$ to get the optimal convergence rate. In contrast to [16] that use linearly increasing weights, we use quadratically increasing weights, as for instance [33, 35].

Lemma 3.3.

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

a_{t + 1} \leq (1 - \frac{μ η_{t}}{2}) a_{t} + η_{t}^{2} A + η_{t}^{3} B - η_{t} e_{t},

(15)

for $η_{t} = \frac{8}{μ (a + t)}$ and constants $A, B \geq 0$ , $μ > 0$ , $a > 1$ . Then

\frac{1}{S_{T}} T - 1 \sum t = 0 w_{t} e_{t} \leq \frac{μ a^{3}}{8 S_{T}} a_{0} + \frac{4 T (T + 2 a)}{μ S_{T}} A + \frac{64 T}{μ^{2} S_{T}} B,

(16)

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

Proof of Theorem 2.4.

The proof of the theorem immediately follows from the three lemmas that we have presented in this section and convexity of $f$ , i.e. we have $E f ({¯ x}_{T}) - f^{⋆} \leq \frac{1}{S_{T}} \sum_{t = 0}^{T - 1} w_{t} e_{t}$ in (16), for constants $A = G^{2}$ and $B = (μ + 2 L) \frac{4 α}{α - 4} \frac{d^{2}}{k^{2}} G^{2}$ . $□$

4 Experiments

We present numerical experiments to illustrate the excellent convergence properties and communication efficiency of Mem-SGD. As the usefulness of SGD with sparsification techniques has already been shown in practical applications [8, 1, 20, 36, 32] we focus here on a few particular aspects. First, we verify the impact of the initial learning rate that did come up in the statement of Theorem 2.4. We then compare our method with QSGD [3] which decreases the communication cost in SGD by using random quantization operators, but without memory. Finally, we show the performance of the parallel SGD depicted in Algorithm 2 in a multi-core setting with shared memory and compare the speed-up to asynchronous Hogwild! [24].

4.1 Experimental Setup

Models.

The experiments focus on the performance of Mem-SGD

applied to logistic regression. The associated objective function is

\frac{1}{n} \sum_{i = 1}^{n} log (1 + exp (- b_{i} a_{i}^{⊤} x)) + \frac{λ}{2} ∥ x ∥^{2}

, where

a_{i} \in R^{d}

and

b_{i} \in {- 1, + 1}

are the data samples, and we employ a standard

L 2

-regularizer. The regularization parameter is set to

λ = 1 / n

for both datasets following [31].

Datasets.

We consider a dense dataset, epsilon [34], as well as a sparse dataset, RCV1 [19] where we train on the larger test set. Statistics on the datasets are listed in Table 1 below:

	$n$	$d$	density
epsilon	400’000	2’000	100%
RCV1-test	677’399	47’236	0.15%

Table 1: Datasets statistics.

	parameter	value
epsilon	$γ$	2
epsilon	$a$	$d / k$
RCV1-test	$γ$	2
RCV1-test	$a$	$10 d / k$

Table 2: Learning rate

η_{t} = γ / (λ (t + a))

Implementation.

We use Python3 and the numpy library [14]. Our code is open-source and publicly available at: github.com/epfml/sparsifiedSGD. We emphasize that our high level implementation is not optimized for speed per iteration but for readability and simplicity. We only report convergence per iteration and relative speedups, but not wall-clock time because unequal efforts have been made to speed up the different implementations. Plots additionally show the baseline computed with the standard optimizer LogisticSGD of scikit-learn [25]. Experiments were run on an Ubuntu 16.04 machine with a 24 cores processor Intel® Xeon® CPU E5-2680 v3 @ 2.50GHz.

4.2 Verifying the Theory

We study the convergence of the method using the stepsizes $η_{t} = γ / (λ (t + a))$ and hyperparameters $γ$ and $a$ set as in Table 2. We compute the final estimate $¯ x$ as a weighted average of all iterates $x_{t}$ with weights $w_{t} = (t + a)^{2}$ as indicated by Theorem 2.4. The results are depicted in Figure 2. We use $k \in {1, 2, 3}$ for epsilon and $k \in {10, 20, 30}$ for RCV1 to increase the difference with large number of features. The ${top}_{k}$ variant consistently outperforms ${rand}_{k}$ and sometimes outperforms vanilla SGD, which is surprising and might come from feature characteristics of the datasets. We also evaluate the impact of the delay $a$ in the learning rate: setting it to $1$ instead of order $O (d / k)$ dramatically hurts the memory and requires time to recover from the high initial learning rate (labeled “without delay” in Figure 2).

Figure 2: Convergence of Mem-SGD using different sparsification operators compared to full SGD with theoretical learning rates (parameters in Table 2).

We experimentally verified the convergence properties of Mem-SGD for different sparsification operators and stepsizes but we want to further evaluate its fundamental benefits in terms of sparsity enforcement and reduction of the communication bottleneck. The gain in communication cost of SGD with memory is very high for dense datasets—using the ${top}_{1}$ strategy on epsilon dataset improves the amount of communication by $10^{3}$ compared to SGD. For the sparse dataset, SGD can readily use the given sparsity of the gradients. Nevertheless, the improvement for ${top}_{10}$ on RCV1 is of approximately an order of magnitude.

4.3 Comparison with QSGD

Now we compare Mem-SGD with the QSGD compression scheme [3] which reduces communication cost by random quantization. The accuracy (and the compression ratio) in QSGD is controlled by a parameter $s$ , corresponding to the number of quantization levels. Ideally, we would like to set the quantization precision in QSGD such that the number of bits transmitted by QSGD and Mem-SGD are identical and compare their convergence properties. However, even for the lowest precision, QSGD needs to send the sign and index of $O (\sqrt{d})$ coordinates. It is therefore not possible to reach the compression level of sparsification operators such as top- $k$ or random- $k$ , that only transmit a constant number of bits per iteration (up to logarithmic factors).⁵⁵5Encoding the indices of the top- $k$ or random- $k$ elements can be done with additional $O (k log d)$ bits. Note that $log d \leq 32 \leq \sqrt{d}$ for both our examples. Hence, we did not enforce this condition and resorted to pick reasonable levels of quantization in QSGD ( $s = 2^{b}$ with $b \in {2, 4, 8}$ ). Note that $b$ -bits stands for the number of bits used to encode $s = 2^{b}$ levels but the actual number of bits transmitted in QSGD can be reduced using Elias coding. As a fair comparison in practice, we chose a standard learning rate $γ_{0} / (1 + γ_{0} λ t)^{- 1}$ [6], tuned the hyperparameter $γ_{0}$ on a subset of each dataset (see Appendix B). Figure 3 shows that Mem-SGD with ${top}_{1}$ on epsilon and RCV1 converges as fast as QSGD in term of iterations for 8 and 4-bits. As shown in the bottom of Figure 3, we are transmitting two orders of magnitude fewer bits with the ${top}_{1}$ sparsifier concluding that sparsification offers a much more aggressive and performant strategy than quantization.

Figure 3: Mem-SGD and QSGD convergence comparison. *Top row:* convergence in number of iterations. *Bottom row:*
cumulated size of the communicated gradients during training. We display 10 points per epoch and remove the point at 0MB for clarity.

4.4 Multicore experiment

We implement a parallelized version of Mem-SGD, as depicted in Algorithm 2. The enforced sparsity allows us to do the update in shared memory using a lock-free mechanism as in [24]. For this experiment we evaluate the final iterate $x_{T}$ instead of the weighted average ${¯ x}_{T}$ above, and we also investigate constant learning rate, which turns out to work well in practice for epsilon. We use constant $η_{t} \equiv 0.05$ for epsilon and reuse the parameters from Table 2 for RCV1.

Figure 4: Multicore CPU time speed up comparison between Mem-SGD and lock-free SGD.

Figure 4 shows the speed-up obtained when increasing the number of cores. We see that the speed-up is almost linear up to 10 cores. This is especially remarkable for the dense epsilon dataset, as the dense gradient updates would usually imply many update conflicts for classic SGD and Hogwild! [24] (i.e. hurting convergence because of gradients computed on stale iterates) or require the use of locking (i.e. hurting speed). We did not use atomic updates of the parameter in the shared memory, allowing some workers to overwrite the progress of others which might contribute to the slowdown for a higher number of workers. The experiment is run on a single machine, hence no inter-node communication is used. The colored area depicts the best and worst results of 3 independent runs for each dataset.

Our method consistently scales better than vanilla parallel SGD with $k = d$ (this scheme can be seen as a naïve implementation of Hogwild!) on a non sparse problem (i.e. logistic regression on dense dataset). In this asynchronous setup, SGD with memory computes gradients on stale iterates that differ only by a few coordinates. It encounters fewer inconsistent read/write operations than lock free asynchronous SGD and exhibits better scaling properties. The ${top}_{k}$ operator performs better than ${rand}_{k}$ in the sequential setup, but this is not the case in the parallel setup. A reason for this could be that due to the deterministic nature of the ${top}_{k}$ operator the cores are more prone to update the same set of coordinates, and more collisions appear.

5 Conclusion

We provide the first concise convergence analysis of sparsified SGD [36, 32, 8, 1]. This extremely communication-efficient variant of SGD enforces sparsity of the applied updates by only updating a constant number of coordinates in every iteration. This way, the method overcomes the communication bottleneck of SGD, while still enjoying the same convergence rate in terms of stochastic gradient computations.

Our experiments verify the drastic reduction in communication cost by demonstrating that Mem-SGD requires one to two orders of magnitude less bits to be communicated than QSGD [3] while converging to the same accuracy. The experiments show an advantage for the top- $k$ sparsification over random sparsification in the serial setting, but not in the multi-core shared memory implementation. There, both schemes are on par, and show much better scaling than a simple shared memory implementation that just writes the dense updates in lock-free asynchronous fashion (like Hogwild! [24]).

Despite the fact that our analysis does not yet comprise the parallel and distributed setting, we feel that those are the domains where sparsified SGD might have the largest impact. It has already been shown in practice that gradient sparsification can be efficiently applied to bandwidth memory limited systems such as multi-GPU training for neural networks [8, 1, 20, 36, 32]. By enforcing sparsity, the scheme is not only communication efficient, it also becomes more eligible for asynchronous implementations, as limiting sparsity assumptions can be revoked.

Acknowledgments

We would like to thank Dan Alistarh for insightful discussions in the early stages of this project and Frederik Künstner for his useful comments on the various drafts of this manuscript.

References

[1] Alham Fikri Aji and Kenneth Heafield. Sparse communication for distributed gradient descent. In
Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing
, pages 440–445. Association for Computational Linguistics, 2017.
[2] Dan Alistarh, Christopher De Sa, and Nikola Konstantinov. The convergence of stochastic gradient descent in asynchronous shared memory. arXiv, March 2018.
[3] Dan Alistarh, Demjan Grubic, Jerry Li, Ryota Tomioka, and Milan Vojnovic. QSGD: Communication-efficient SGD via gradient quantization and encoding. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, NIPS - Advances in Neural Information Processing Systems 30, pages 1709–1720. Curran Associates, Inc., 2017.
[4] Dan Alistarh, Torsten Hoefler, Mikael Johansson, Nikola Konstantinov, Sarit Khirirat, and Cedric Renggli. The convergence of sparsified gradient methods. In NIPS 2018, to appear, 2018.
[5] Léon Bottou. Large-scale machine learning with stochastic gradient descent. In Yves Lechevallier and Gilbert Saporta, editors, Proceedings of COMPSTAT’2010, pages 177–186, Heidelberg, 2010. Physica-Verlag HD.
[6] Leon Bottou. Stochastic Gradient Descent Tricks, volume 7700, page 430–445. Springer, January 2012.
[7] Chia-Yu Chen, Jungwook Choi, Daniel Brand, Ankur Agrawal, Wei Zhang, and Kailash Gopalakrishnan. Adacomp : Adaptive residual gradient compression for data-parallel distributed training. In Sheila A. McIlraith and Kilian Q. Weinberger, editors,
Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence, New Orleans, Louisiana, USA, February 2-7, 2018
. AAAI Press, 2018.
[8] Nikoli Dryden, Sam Ade Jacobs, Tim Moon, and Brian Van Essen. Communication quantization for data-parallel training of deep neural networks. In Proceedings of the Workshop on Machine Learning in High Performance Computing Environments, MLHPC ’16, pages 1–8, Piscataway, NJ, USA, 2016. IEEE Press.
[9] John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. JMLR, 12:2121–2159, August 2011.
[10] Celestine Dünner, Thomas Parnell, and Martin Jaggi. Efficient use of limited-memory accelerators for linear learning on heterogeneous systems. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, NIPS - Advances in Neural Information Processing Systems 30, pages 4258–4267. Curran Associates, Inc., 2017.
[11] Priya Goyal, Piotr Dollár, Ross B. Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: training ImageNet in 1 hour. CoRR, abs/1706.02677, 2017.
[12] Suyog Gupta, Ankur Agrawal, Kailash Gopalakrishnan, and Pritish Narayanan. Deep learning with limited numerical precision. In Proceedings of the 32Nd International Conference on International Conference on Machine Learning - Volume 37, ICML’15, pages 1737–1746. JMLR.org, 2015.
[13] Cho-Jui Hsieh, Hsiang-Fu Yu, and Inderjit Dhillon. Passcode: Parallel asynchronous stochastic dual co-ordinate descent. In International Conference on Machine Learning, pages 2370–2379, 2015.
[14] Eric Jones, Travis Oliphant, Pearu Peterson, et al. SciPy: Open source scientific tools for Python, 2001–.
[15] Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014.
[16] Simon Lacoste-Julien, Mark W. Schmidt, and Francis R. Bach. A simpler approach to obtaining an $o (1 / t)$ convergence rate for the projected stochastic subgradient method. CoRR, abs/1212.2002, 2012.
[17] Rémi Leblond, Fabian Pedregosa, and Simon Lacoste-Julien. ASAGA: Asynchronous parallel SAGA. In Aarti Singh and Jerry Zhu, editors, Proceedings of the 20th International Conference on Artificial Intelligence and Statistics, volume 54 of Proceedings of Machine Learning Research, pages 46–54, Fort Lauderdale, FL, USA, 20–22 Apr 2017. PMLR.
[18] Rémi Leblond, Fabian Pedregosa, and Simon Lacoste-Julien. Improved asynchronous parallel optimization analysis for stochastic incremental methods. arXiv.org, January 2018.
[19] David D. Lewis, Yiming Yang, Tony G. Rose, and Fan Li. RCV1: A new benchmark collection for text categorization research. Journal of Machine Learning Research, 5:361–397, 2004.
[20] Yujun Lin, Song Han, Huizi Mao, Yu Wang, and Bill Dally. Deep gradient compression: Reducing the communication bandwidth for distributed training. In ICLR 2018 - International Conference on Learning Representations, 2018.
[21] Horia Mania, Xinghao Pan, Dimitris Papailiopoulos, Benjamin Recht, Kannan Ramchandran, and Michael I. Jordan. Perturbed iterate analysis for asynchronous stochastic optimization. SIAM Journal on Optimization, 27(4):2202–2229, 2017.
[22] Eric Moulines and Francis R. Bach.
Non-asymptotic analysis of stochastic approximation algorithms for machine learning.
In J. Shawe-Taylor, R. S. Zemel, P. L. Bartlett, F. Pereira, and K. Q. Weinberger, editors, NIPS - Advances in Neural Information Processing Systems 24, pages 451–459. Curran Associates, Inc., 2011.
[23] Taesik Na, Jong Hwan Ko, Jaeha Kung, and Saibal Mukhopadhyay.
On-chip training of recurrent neural networks with limited numerical precision.
2017 International Joint Conference on Neural Networks (IJCNN), pages 3716–3723, 2009.
[24] Feng Niu, Benjamin Recht, Christopher Re, and Stephen J. Wright. HOGWILD!: A lock-free approach to parallelizing stochastic gradient descent. In NIPS - Proceedings of the 24th International Conference on Neural Information Processing Systems, NIPS’11, pages 693–701, USA, 2011. Curran Associates Inc.
[25] Fabian Pedregosa, Gaël Varoquaux, Alexandre Gramfort, Vincent Michel, Bertrand Thirion, Olivier Grisel, Mathieu Blondel, Peter Prettenhofer, Ron Weiss, Vincent Dubourg, et al. Scikit-learn: Machine learning in python. Journal of machine learning research, 12(Oct):2825–2830, 2011.
[26] Boris T. Polyak and Anatoli B. Juditsky. Acceleration of stochastic approximation by averaging. SIAM Journal on Control and Optimization, 30(4):838–855, 1992.
[27] Alexander Rakhlin, Ohad Shamir, and Karthik Sridharan. Making gradient descent optimal for strongly convex stochastic optimization. In Proceedings of the 29th International Coference on International Conference on Machine Learning, ICML’12, pages 1571–1578, USA, 2012. Omnipress.
[28] Herbert Robbins and Sutton Monro. A Stochastic Approximation Method. The Annals of Mathematical Statistics, 22(3):400–407, September 1951.
[29] David Ruppert. Efficient estimations from a slowly convergent Robbins-Monro process. Technical report, Cornell University Operations Research and Industrial Engineering, 1988.
[30] Christopher De Sa, Ce Zhang, Kunle Olukotun, and Christopher Ré. Taming the wild: A unified analysis of HOGWILD!-style algorithms. In NIPS - Proceedings of the 28th International Conference on Neural Information Processing Systems, NIPS’15, pages 2674–2682, Cambridge, MA, USA, 2015. MIT Press.
[31] Mark Schmidt, Nicolas Le Roux, and Francis Bach. Minimizing finite sums with the stochastic average gradient. Math. Program., 162(1-2):83–112, March 2017.
[32] Frank Seide, Hao Fu, Jasha Droppo, Gang Li, and Dong Yu. 1-bit stochastic gradient descent and its application to data-parallel distributed training of speech DNNs. In Haizhou Li, Helen M. Meng, Bin Ma, Engsiong Chng, and Lei Xie, editors, INTERSPEECH, pages 1058–1062. ISCA, 2014.
[33] Ohad Shamir and Tong Zhang. Stochastic gradient descent for non-smooth optimization: Convergence results and optimal averaging schemes. In Sanjoy Dasgupta and David McAllester, editors, Proceedings of the 30th International Conference on Machine Learning, volume 28 of Proceedings of Machine Learning Research, pages 71–79, Atlanta, Georgia, USA, 17–19 Jun 2013. PMLR.
[34] Soren Sonnenburg, Vojtvech Franc, E Yom-Tov, and M Sebag. Pascal large scale learning challenge. 10:1937–1953, 01 2008.
[35] Sebastian U. Stich. Local SGD Converges Fast and Communicates Little. ArXiv, abs/1805.09767, May 2018.
[36] Nikko Strom. Scalable distributed DNN training using commodity GPU cloud computing. In INTERSPEECH, pages 1488–1492. ISCA, 2015.
[37] Xu Sun, Xuancheng Ren, Shuming Ma, and Houfeng Wang. meProp: Sparsified back propagation for accelerated deep learning with reduced overfitting. In Doina Precup and Yee Whye Teh, editors, Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pages 3299–3308, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR.
[38] Hanlin Tang, Shaoduo Gan, Ce Zhang, and Ji Liu. Communication compression for decentralized training. In NIPS 2018, and arXiv 1803.06443, 2018.
[39] Jianqiao Wangni, Jialei Wang, Ji Liu, and Tong Zhang. Gradient sparsification for communication-efficient distributed optimization. In NIPS 2018, and arXiv 1710.09854, 2018.
[40] Wei Wen, Cong Xu, Feng Yan, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Terngrad: Ternary gradients to reduce communication in distributed deep learning. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, NIPS - Advances in Neural Information Processing Systems 30, pages 1509–1519. Curran Associates, Inc., 2017.
[41] Jiaxiang Wu, Weidong Huang, Junzhou Huang, and Tong Zhang. Error Compensated Quantized SGD and its Applications to Large-scale Distributed Optimization. In ICML 2018 - Proceedings of the 35th International Conference on Machine Learning, pages 5321–5329, July 2018.
[42] Yang You, Igor Gitman, and Boris Ginsburg. Scaling SGD batch size to 32k for ImageNet training. CoRR, abs/1708.03888, 2017.
[43] Hantian Zhang, Jerry Li, Kaan Kara, Dan Alistarh, Ji Liu, and Ce Zhang. ZipML: Training linear models with end-to-end low precision, and a little bit of deep learning. In Doina Precup and Yee Whye Teh, editors, Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pages 4035–4043, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR.
[44] Yuchen Zhang, Martin J Wainwright, and John C Duchi. Communication-efficient algorithms for statistical optimization. In F. Pereira, C. J. C. Burges, L. Bottou, and K. Q. Weinberger, editors, NIPS - Advances in Neural Information Processing Systems 25, pages 1502–1510. Curran Associates, Inc., 2012.
[45] Peilin Zhao and Tong Zhang. Stochastic optimization with importance sampling for regularized loss minimization. In Francis Bach and David Blei, editors, Proceedings of the 32nd International Conference on Machine Learning, volume 37 of Proceedings of Machine Learning Research, pages 1–9, Lille, France, 07–09 Jul 2015. PMLR.

Appendix A Proofs

a.1 Useful facts

Lemma A.1.

For $x \in R^{d}$ , $1 \leq k \leq d$ , and operator ${comp}_{k} \in {{top}_{k}, {rand}_{k}}$ it holds

(17)

Proof.

From the definition of the operators, for all $x$ in $R^{d}$ we have

(18)

and we apply the expectation

E_{ω} {∥ x - {rand}_{k} (x) ∥}_{k}^{2} = \frac{1}{| Ω_{k} |} \sum ω \in Ω_{k} d \sum i = 1 x_{i}^{2} I {i \notin ω} = d \sum i = 1 x_{i}^{2} \sum ω \in Ω_{k} \frac{I {i \notin ω}}{| Ω_{k} |} = (1 - \frac{k}{d}) {∥ x ∥}^{2}

(19)

which concludes the proof. ∎

Lemma A.2.

Let $η_{t} = \frac{1}{c + t}$ , for $c \geq 1$ . Then $η_{t}^{2} (1 - \frac{2}{c}) \leq η_{t + 1}^{2}$ .

Proof.

Observe

η_{t}^{2} (1 - \frac{2}{c})

= \frac{c - 2}{c (c + t)^{2}} \leq \frac{c - 2}{(c + t + 1)^{2} (c - 2)} = η_{t + 1}^{2} .

(20)

where the inequality follows from

(c + t + 1)^{2} (c - 2)

= c (c + t)^{2} + (c - 2) (1 + 2 (t + c)) - 2 (c + t)^{2}      = - 2 t^{2} - 2 c t - 4 t - 3 c - 2 \leq 0

(21)

∎

a.2 Proof of the Main Theorem

Proof of Lemma 3.1.

Using the update equation (11) we have

(22)

And by applying expectation

E_{i_{t}} {∥ {~ x}_{t + 1} - x^{⋆} ∥}_{t + 1}^{2} \leq {∥ {~ x}_{t} - x^{⋆} ∥}_{t}^{2} + η_{t}^{2} G^{2} - 2 η_{t} ⟨ x_{t} - x^{⋆}, \nabla f (x_{t}) ⟩ + 2 η_{t} ⟨ x_{t} - {~ x}_{t}, \nabla f (x_{t}) ⟩ .

(23)

To upper bound the third term, we use the same estimates as in [17, Appendix C.3]: By strong convexity, for $x, y \in R^{d}$ , hence

- ⟨ x_{t} - x^{⋆}, \nabla f (x_{t}) ⟩ \leq - (f (x_{t}) - f^{⋆}) - \frac{μ}{2} {∥ x_{t} - x^{⋆} ∥}_{t}^{2}

(24)

and with ${∥ a + b ∥}^{2} \leq 2 {∥ a ∥}^{2} + 2 {∥ b ∥}^{2}$ we further have

- {∥ x_{t} - x^{⋆} ∥}_{t}^{2} \leq {∥ x_{t} - {~ x}_{t} ∥}_{t}^{2} - \frac{1}{2} {∥ {~ x}_{t} - x^{⋆} ∥}_{t}^{2} .

(25)

Putting these two estimates together, we can bound (23) as follows:

E_{i_{t}} {∥ {~ x}_{t + 1} - x^{⋆} ∥}_{t + 1}^{2} \leq (1 - \frac{η_{t} μ}{2}) {∥ {~ x}_{t} - x^{⋆} ∥}_{t}^{2} + η_{t}^{2} G^{2} - 2 η_{t} e_{t} + η_{t} μ {∥ x_{t} - {~ x}_{t} ∥}_{t}^{2} + 2 η_{t} ⟨ x_{t} - {~ x}_{t}, \nabla f (x_{t}) ⟩,

(26)

where $e_{t} = E f (x_{t}) - f^{⋆}$ . We now estimate the last term. As each $f_{i}$ is $L$ -smooth also $f$ is $L$ -smooth, i.e. satisfies $f (x) - f (y) - ⟨ \nabla f (y), x - y ⟩ \geq \frac{1}{2 L} {∥ \nabla f (y) - \nabla f (x) ∥}^{2}$ . Together with $2 ⟨ a, b ⟩ \leq γ {∥ a ∥}^{2} + γ^{- 1} {∥ b ∥}^{2}$ we have

$⟨ x_{t} - {~ x}_{t}, \nabla f (x_{t}) ⟩$		(27)
	$= L {∥ x_{t} - {~ x}_{t} ∥}_{t}^{2} + \frac{1}{4 L} {∥ \nabla f (x_{t}) - \nabla f (x^{⋆}) ∥}_{t}^{2}$	(28)
		(29)

Combining with (26) we have

E_{i_{t}} {∥ {~ x}_{t + 1} - x^{⋆} ∥}_{t + 1}^{2} \leq (1 - \frac{η_{t} μ}{2}) {∥ {~ x}_{t} - x^{⋆} ∥}_{t}^{2} + η_{t}^{2} G^{2} - η_{t} e_{t} + η_{t} (μ + 2 L) {∥ x_{t} - {~ x}_{t} ∥}_{t}^{2},

(30)

and the claim follows with (12). ∎

Proof of Lemma 3.2.

First, observe that by Lemma A.1 and ${∥ a + b ∥}^{2} \leq (1 + γ) {∥ a ∥}^{2} + (1 + γ^{- 1}) {∥ b ∥}^{2}$ for $γ > 0$ we have

$E {∥ m_{t + 1} ∥}_{t + 1}^{2}$	$\leq (1 - \frac{k}{d}) {∥ m_{t} + η_{t} \nabla f_{i_{t}} (x_{t}) ∥}_{t}^{2}$	(31)
	$\leq (1 - \frac{k}{d}) ((1 + \frac{k}{2 d}) E {∥ m_{t} ∥}_{t}^{2} + (1 + \frac{2 d}{k}) η_{t}^{2} E {∥ \nabla f_{i_{t}} (x_{t}) ∥}_{i_{t}}^{2})$	(32)
		(33)

On the other hand, from ${∥ ∥ \sum_{i = 1}^{s} a_{i} ∥ ∥}_{i}^{2} \leq s \sum_{i = 1}^{s} {∥ a_{i} ∥}_{i}^{2}$ we also have

E {∥ m_{t + 1} ∥}_{t + 1}^{2} \leq (t + 1) t \sum i = 0 η_{t}^{2} G^{2} .

(34)

Now the claim follows from Lemma A.3 just below with $A = \frac{8 G^{2}}{μ}$ . ∎

Lemma A.3.

Let $A \geq 0$ , $d \geq k \geq 1$ , ${h_{t}}_{t \geq 0}$ , $h_{t} \geq 0$ be a sequence satisfying

h_{0}

= 0,

h_{t + 1} \leq min {(1 - \frac{k}{2 d}) h_{t} + \frac{2 d}{} k η_{t}^{2} A, (t + 1) t \sum i = 0 η_{i}^{2} A},

(35)

for a sequence $η_{t} = \frac{1}{a + t}$ with $a \geq \frac{(α + 1) \frac{d}{k} + ρ + 1}{ρ + 1} > 1$ , for $α > 4$ , $ρ := \frac{4 α}{(α - 4) (α + 1)^{2}}$ . Then

h_{t} \leq \frac{4 α}{α - 4} η_{t}^{2} \frac{d^{2}}{k^{2}} A,

(36)

for $t \geq 0$ .

Proof.

The claim holds for $t = 0$ .

Large $t$ .

Let $t_{0} = max {⌈ α \frac{d}{k} - a ⌉, 0}$ , i.e. $η_{t_{0}} \leq \frac{k}{α d}$ . (Note that for any $a \geq α \frac{k}{d}$ it holds $t_{0} = 0$ .) Suppose the claim holds for $t \leq t_{0}$ . Observe,

η_{t}^{2} (1 - \frac{2 k}{α d}) \leq η_{t + 1}^{2},

(37)

for $t \geq t_{0}$ . This follows from Lemma A.2 with $c = \frac{α d}{k}$ . By induction,

	$h_{t + 1}$	$\leq (1 - \frac{k}{2 d}) \frac{4 α}{α - 4} η_{t}^{2} \frac{d^{2}}{k^{2}} A + \frac{2 d}{k} η_{t}^{2} A$		(38)
		$= η_{t}^{2} (1 - \frac{2 k}{α d})      \leq η_{t + 1}^{2} \frac{4 α}{α - 4} \frac{d^{2}}{k^{2}} A,$		(39)

where we used $t \geq t_{0}$ (and the observation just above) for the last inequality.

Small $t$ .

Assume $t_{0} \geq 1$ , otherwise the claim follows from the part above. We have

h_{t}

\leq t t - 1 \sum i = 0 η_{i}^{2} A \leq \frac{t}{a - 1} A,

(40)

where we used

t - 1 \sum t = 0 η_{t}^{2}

\leq \infty \sum t = 0 \frac{1}{(a + t)^{2}} \leq \int_{a - 1}^{\infty} \frac{1}{x^{2}} d x = \frac{1}{a - 1},

(41)

for $a > 1$ . For $t \leq t_{0}$ we have

η_{t}^{2} \frac{d^{2}}{k^{2}}

\geq η_{t_{0}}^{2} \frac{d^{2}}{k^{2}} = \frac{1}{(a + t_{0})^{2}} \frac{d^{2}}{k^{2}} \geq \frac{1}{{(\frac{α d}{k} + 1)}^{2}} \frac{d^{2}}{k}

Sparsified SGD with Memory

Authors

Related Research

Escaping Saddle Points with Compressed SGD

Error Compensated Quantized SGD and its Applications to Large-scale Distributed Optimization

Sparse Communication for Training Deep Networks

On the Convergence of Memory-Based Distributed SGD

ErrorCompensatedX: error compensation for variance reduced algorithms

rTop-k: A Statistical Estimation Approach to Distributed SGD

NUQSGD: Provably Communication-efficient Data-parallel SGD via Nonuniform Quantization

Code Repositories

sparsifiedSGD

This week in AI

1 Introduction

1.1 Related Work

1.2 Contributions

2 SGD with Memory

2.1 Compression and Sparsification Operators

Definition 2.1 (k-contraction).

Definition 2.2.

Remark 2.3 (Ultra-sparsification).

2.2 Variance Blow-up for Unbiased Updates

2.3 SGD with Memory: Algorithm and Convergence Results

Theorem 2.4.

Remark 2.5 (Choice of the shift a).

Remark 2.6.

3 Proof Outline

Perturbed iterate analysis.

Lemma 3.1.

Bounding the memory.

Lemma 3.2.

Optimal averaging.

Lemma 3.3.

Proof of Theorem 2.4.

4 Experiments

4.1 Experimental Setup

Models.

Datasets.

Implementation.

4.2 Verifying the Theory

4.3 Comparison with QSGD

4.4 Multicore experiment

5 Conclusion

Acknowledgments

References

Appendix A Proofs

a.1 Useful facts

Lemma A.1.

Proof.

Lemma A.2.

Proof.

a.2 Proof of the Main Theorem

Proof of Lemma 3.1.

Proof of Lemma 3.2.

Lemma A.3.

Proof.

Large t.

Small t.

Definition 2.1 ( $k$ -contraction).

Remark 2.5 (Choice of the shift $a$ ).

Large $t$ .

Small $t$ .