HOGWILD!: A Lock-Free Approach to Parallelizing Stochastic Gradient Descent

Introduction

With its small memory footprint, robustness against noise, and rapid learning rates, Stochastic Gradient Descent (SGD) has proved to be well suited to data-intensive machine learning tasks . However, SGD’s scalability is limited by its inherently sequential nature; it is difficult to parallelize. Nevertheless, the recent emergence of inexpensive multicore processors and mammoth, web-scale data sets has motivated researchers to develop several clever parallelization schemes for SGD . As many large data sets are currently pre-processed in a MapReduce-like parallel-processing framework, much of the recent work on parallel SGD has focused naturally on MapReduce implementations. MapReduce is a powerful tool developed at Google for extracting information from huge logs (e.g., “find all the urls from a 100TB of Web data”) that was designed to ensure fault tolerance and to simplify the maintenance and programming of large clusters of machines . But MapReduce is not ideally suited for online, numerically intensive data analysis. Iterative computation is difficult to express in MapReduce, and the overhead to ensure fault tolerance can result in dismal throughput. Indeed, even Google researchers themselves suggest that other systems, for example Dremel, are more appropriate than MapReduce for data analysis tasks .

For some data sets, the sheer size of the data dictates that one use a cluster of machines. However, there are a host of problems in which, after appropriate preprocessing, the data necessary for statistical analysis may consist of a few terabytes or less. For such problems, one can use a single inexpensive work station as opposed to a hundred thousand dollar cluster. Multicore systems have significant performance advantages, including (1) low latency and high throughput shared main memory (a processor in such a system can write and read the shared physical memory at over 12GB/s with latency in the tens of nanoseconds); and (2) high bandwidth off multiple disks (a thousand-dollar RAID can pump data into main memory at over 1GB/s). In contrast, a typical MapReduce setup will read incoming data at rates less than tens of MB/s due to frequent checkpointing for fault tolerance. The high rates achievable by multicore systems move the bottlenecks in parallel computation to synchronization (or locking) amongst the processors . Thus, to enable scalable data analysis on a multicore machine, any performant solution must minimize the overhead of locking.

In this work, we propose a simple strategy for eliminating the overhead associated with locking: run SGD in parallel without locks, a strategy that we call Hogwild!. In Hogwild!, processors are allowed equal access to shared memory and are able to update individual components of memory at will. Such a lock-free scheme might appear doomed to fail as processors could overwrite each other’s progress. However, when the data access is sparse, meaning that individual SGD steps only modify a small part of the decision variable, we show that memory overwrites are rare and that they introduce barely any error into the computation when they do occur. We demonstrate both theoretically and experimentally a near linear speedup with the number of processors on commonly occurring sparse learning problems.

In Section 2, we formalize a notion of sparsity that is sufficient to guarantee such a speedup and provide canonical examples of sparse machine learning problems in classification, collaborative filtering, and graph cuts. Our notion of sparsity allows us to provide theoretical guarantees of linear speedups in Section 4. As a by-product of our analysis, we also derive rates of convergence for algorithms with constant stepsizes. We demonstrate that robust $1/k$ convergence rates are possible with constant stepsize schemes that implement an exponential back-off in the constant over time. This result is interesting in of itself and shows that one need not settle for $1/\sqrt{k}$ rates to ensure robustness in SGD algorithms.

In practice, we find that computational performance of a lock-free procedure exceeds even our theoretical guarantees. We experimentally compare lock-free SGD to several recently proposed methods. We show that all methods that propose memory locking are significantly slower than their respective lock-free counterparts on a variety of machine learning applications.

Sparse Separable Cost Functions

Here $e$ denotes a small subset of $\{1,\ldots,n\}$ and $x_{e}$ denotes the values of the vector $x$ on the coordinates indexed by $e$. The key observation that underlies our lock-free approach is that the natural cost functions associated with many machine learning problems of interest are sparse in the sense that $|E|$ and $n$ are both very large but each individual $f_{e}$ acts only on a very small number of components of $x$. That is, each subvector $x_{e}$ contains just a few components of $x$.

The cost function (2.1) induces a hypergraph $G=(V,E)$ whose nodes are the individual components of $x$. Each subvector $x_{e}$ induces an edge in the graph $e\in E$ consisting of some subset of nodes. A few examples illustrate this concept.

and we know a priori that the examples $z_{\alpha}$ are very sparse (see for example ). To write this cost function in the form of (2.1), let $e_{\alpha}$ denote the components which are non-zero in $z_{\alpha}$ and let $d_{u}$ denote the number of training examples which are non-zero in component $u$ ($u=1,2,\dotsc,n$). Then we can rewrite (2.2) as

Each term in the sum (2.3) depends only on the components of $x$ indexed by the set $e_{\alpha}$.

Matrix Completion.

In the matrix completion problem, we are provided entries of a low-rank, $n_{r}\times n_{c}$ matrix $\bm{Z}$ from the index set $E$. Such problems arise in collaborative filtering, Euclidean distance estimation, and clustering . Our goal is to reconstruct $\bm{Z}$ from this sparse sampling of data. A popular heuristic recovers the estimate of $\bm{Z}$ as a product $\bm{L}\bm{R}^{*}$ of factors obtained from the following minimization:

where $\bm{L}$ is $n_{r}\times r$, $\bm{R}$ is $n_{c}\times r$ and $\bm{L}_{u}$ (resp. $\bm{R}_{v})$ denotes the $u$th (resp. $v$th) row of $\bm{L}$ (resp. $\bm{R}$) . To put this problem in sparse form, i.e., as (2.1), we write (2.4) as

where $E_{u-}=\{v~{}:~{}(u,v)\in E\}$ and $E_{-v}=\{u~{}:~{}(u,v)\in E\}$.

Graph Cuts.

In all three of the preceding examples, the number of components involved in a particular term $f_{e}$ is a small fraction of the total number of entries. We formalize this notion by defining the following statistics of the hypergraph $G$:

The quantity $\Omega$ simply quantifies the size of the hyper edges. $\rho$ determines the maximum fraction of edges that intersect any given edge. $\Delta$ determines the maximum fraction of edges that intersect any variable. $\rho$ is a measure of the sparsity of the hypergraph, while $\Delta$ measures the node-regularity. For our examples, we can make the following observations about $\rho$ and $\Delta$.

Sparse SVM. $\Delta$ is simply the maximum frequency that any feature appears in an example, while $\rho$ measures how clustered the hypergraph is. If some features are very common across the data set, then $\rho$ will be close to one.

Matrix Completion. If we assume that the provided examples are sampled uniformly at random and we see more than $n_{c}\log(n_{c})$ of them, then $\Delta\approx\tfrac{\log(n_{r})}{n_{r}}$ and $\rho\approx\tfrac{2\log(n_{r})}{n_{r}}$. This follows from a coupon collector argument .

Graph Cuts. $\Delta$ is the maximum degree divided by $|E|$, and $\rho$ is at most $2\Delta$.

We now describe a simple protocol that achieves a linear speedup in the number of processors when $\Omega$, $\Delta$, and $\rho$ are relatively small.

The Hogwild! Algorithm

Here we discuss the parallel processing setup. We assume a shared memory model with $p$ processors. The decision variable $x$ is accessible to all processors. Each processor can read $x$, and can contribute an update vector to $x$. The vector $x$ is stored in shared memory, and we assume that the componentwise addition operation is atomic, that is

can be performed atomically by any processor for a scalar $a$ and $v\in\{1,\ldots,n\}$. This operation does not require a separate locking structure on most modern hardware: such an operation is a single atomic instruction on GPUs and DSPs, and it can be implemented via a compare-and-exchange operation on a general purpose multicore processor like the Intel Nehalem. In contrast, the operation of updating many components at once requires an auxiliary locking structure.

Here, $G_{e}$ is equal to zero on the components in ${\neg e}$. Using a sparse representation, we can calculate $G_{e}(x)$, only knowing the values of $x$ in the components indexed by $e$. Note that as a consequence of the uniform random sampling of $e$ from $E$, we have

In Algorithm 1, each processor samples an term $e\in E$ uniformly at random, computes the gradient of $f_{e}$ at $x_{e}$, and then writes

In what follows, we provide conditions under which this asynchronous, incremental gradient algorithm converges. Moreover, we show that if the hypergraph induced by $f$ is isotropic and sparse, then this algorithm converges in nearly the same number of gradient steps as its serial counterpart. Since we are running in parallel and without locks, this means that we get a nearly linear speedup in terms of the number of processors.

Fast Rates for Lock-Free Parallelism

We now turn to our theoretical analysis of Hogwild! protocols. To make the analysis tractable, we assume that we update with the following “with replacement” procedure: each processor samples an edge $e$ uniformly at random and computes a subgradient of $f_{e}$ at the current value of the decision variable. Then it chooses an $v\in e$ uniformly at random and updates

Note that the stepsize is a factor $|e|$ larger than the step in (3.1). Also note that this update is completely equivalent to

This notation will be more convenient for the subsequent analysis.

This with replacement scheme assumes that a gradient is computed and then only one of its components is used to update the decision variable. Such a scheme is computationally wasteful as the rest of the components of the gradient carry information for decreasing the cost. Consequently, in practice and in our experiments, we perform a modification of this procedure. We partition out the edges without replacement to all of the processors at the beginning of each epoch. The processors then perform full updates of all of the components of each edge in their respective queues. However, we emphasize again that we do not implement any locking mechanisms on any of the variables. We do not analyze this “without replacement” procedure because no one has achieved tractable analyses for SGD in any without replacement sampling models. Indeed, to our knowledge, all analysis of without-replacement sampling yields rates that are comparable to a standard subgradient descent algorithm which takes steps along the full gradient of (2.1) (see, for example ). That is, these analyses suggest that without-replacement sampling should require a factor of $|E|$ more steps than with-replacement sampling. In practice, this worst case behavior is never observed. In fact, it is conventional wisdom in machine learning that without-replacement sampling in stochastic gradient descent actually outperforms the with-replacement variants on which all of the analysis is based.

To state our theoretical results, we must describe several quantities that important in the analysis of our parallel stochastic gradient descent scheme. We follow the notation and assumptions of Nemirovski et al . To simplify the analysis, we will assume that each $f_{e}$ in (2.1) is a convex function. We assume Lipschitz continuous differentiability of $f$ with Lipschitz constant $L$:

We also assume $f$ is strongly convex with modulus $c$. By this we mean that

When $f$ is strongly convex, there exists a unique minimizer $x_{\star}$ and we denote $f_{\star}=f(x_{\star})$. We additionally assume that there exists a constant $M$ such that

We assume throughout that $\gamma c<1$. (Indeed, when $\gamma c>1$, even the ordinary gradient descent algorithms will diverge.)

Our main results are summarized by the following

Suppose in Algorithm 1 that the lag between when a gradient is computed and when it is used in step $j$ — namely, $j-k(j)$ — is always less than or equal to $\tau$, and $\gamma$ is defined to be

for some $\epsilon>0$ and $\vartheta\in(0,1)$. Define $D_{0}:=\|x_{0}-x_{\star}\|^{2}$ and let $k$ be an integer satisfying

In the case that $\tau=0$, this reduces to precisely the rate achieved by the serial SGD protocol. A similar rate is achieved if $\tau=o(n^{1/4})$ as $\rho$ and $\Delta$ are typically both $o(1/n)$. In our setting, $\tau$ is proportional to the number of processors, and hence as long as the number of processors is less $n^{1/4}$, we get nearly the same recursion as in the linear rate.

Note that up to the $\log(1/\epsilon)$ term in (4.6), our analysis nearly provides a $1/k$ rate of convergence for a constant stepsize SGD scheme, both in the serial and parallel cases. Moreover, note that our rate of convergence is fairly robust to error in the value of $c$; we pay linearly for our underestimate of the curvature of $f$. In contrast, Nemirovski et al demonstrate that when the stepsize is inversely proportional to the iteration counter, an overestimate of $c$ can result in exponential slow-down ! We now turn to demonstrating that we can eliminate the log term from (4.6) by a slightly more complicated protocol where the stepsize is slowly decreased after a large number of iterations.

Robust 1/k1𝑘1/k rates.

Suppose we run Algorithm 1 for a fixed number of gradient updates $K$ with stepsize $\gamma<1/c$. Then, we wait for the threads to coalesce, reduce $\gamma$ by a constant factor $\beta\in(0,1)$, and run for $\beta^{-1}K$ iterations. In some sense, this piecewise constant stepsize protocol approximates a $1/k$ diminishing stepsize. The main difference with the following analysis from previous work is that our stepsizes are always less than $1/c$ in contrast to beginning with very large stepsizes. Always working with small stepsizes allows us to avoid the possible exponential slow-downs that occur with standard diminishing stepsize schemes.

To be precise, suppose $a_{k}$ is any sequence of real numbers satisfying

where $a_{\infty}$ is some non-negative function of $\gamma$ satisfying

and $c_{r}$ and $B$ are constants. This recursion underlies many convergence proofs for SGD where $a_{k}$ denotes the distance to the optimal solution after $k$ iterations. We will derive appropriate constants for Hogwild! in the Appendix. We will also discuss below what these constants are for standard stochastic gradient descent algorithms.

Factoring out the dependence on $\gamma$ will be useful in what follows. Unwrapping (5.1) we have

Suppose we want this quantity to be less than $\epsilon$. It is sufficient that both terms are less than $\epsilon/2$. For the second term, this means that it is sufficient to set

By (5.2), we should pick $\gamma=\frac{\epsilon\vartheta}{2B}$ for $\vartheta\in(0,1]$. Combining this with (5.3) tells us that after

iterations we will have $a_{k}\leq\epsilon$. This right off the bat almost gives us a $1/k$ rate, modulo the $\log(1/\epsilon)$ factor.

To eliminate the log factor, we can implement a backoff scheme where we reduce the stepsize by a constant factor after several iterations. This backoff scheme will have two phases: the first phase will consist of converging to the ball about $x_{\star}$ of squared radius less than $\frac{2B}{c_{r}}$ at an exponential rate. Then we will converge to $x_{\star}$ by shrinking the stepsize.

To calculate the number of iterates required to get inside a ball of squared radius $\frac{2B}{c_{r}}$, suppose the initial stepsize is chosen as $\gamma=\frac{\vartheta}{c_{r}}$ ($0<\vartheta<1$). This choice of stepsize guarantees that the $a_{k}$ converge to $a_{\infty}$. We use the parameter $\vartheta$ to demonstrate that we do not suffer much for underestimating the optimal stepsize (i.e., $\vartheta=1$) in our algorithms. Using (5.3) we find that

iterations are sufficient to converge to this ball. Note that this is a linear rate of convergence.

Now assume that $a_{0}<\frac{2\vartheta B}{c_{r}}$. Let’s reduce the stepsize by a factor of $\beta$ each epoch. This reduces the achieved $\epsilon$ by a factor of $\beta$. Thus, after $\log_{\beta}(a_{0}/\epsilon)$ epochs, we will be at accuracy $\epsilon$. The total number of iterations required is then the sum of terms with the form (5.3), with $a_{0}$ set to be the radius achieved by the previous epoch and $\epsilon$ set to be $\beta$ times this $a_{0}$. Hence, for epoch number $\nu$, the initial distance is $\beta^{\nu-1}a_{0}$ and the final radius is $\beta^{\nu}$. Summing over all of the epochs (except for the initial phase) gives

This expression is minimized by selecting a backoff parameter $\approx 0.37$. Also, note that when we reduce the stepsize by $\beta$, we need to run for $\beta^{-1}$ more iterations.

Combining (5.4) and (5.5), we estimate a total number of iterations equal to

are sufficient to guarantee that $a_{k}\leq\epsilon$.

Rearranging terms, the following two expressions give $\epsilon$ in terms of all of the algorithm parameters:

Let us compare the results of this constant step-size protocol to one where the stepsize at iteration $k$ is set to be $\gamma_{0}/k$ for some initial step size $\gamma$ for the standard (serial) incremental gradient algorithm applied to (2.1). Nemirovski et al show that the expected squared distance to the optimal solution, $a_{k}$, satisfies

We can put this recursion in the form (5.1) by setting $\gamma_{k}=\gamma$, $c_{r}=2c$, $B=\tfrac{M^{2}}{4c}$, and $a_{\infty}=\tfrac{\gamma M^{2}}{4c}$.

The authors of demonstrate that a large step size: $\gamma_{k}=\tfrac{\Theta}{2ck}$ with $\Theta>1$ yields a bound

On the other hand, a constant step size protocol achieves

This bound is obtained by plugging the algorithm parameters into (5.6) and letting $D_{0}=2a_{0}$.

Note that both bounds have asymptotically the same dependence on $M$, $c$, and $k$. The expression

is minimized when $\beta\approx 0.37$ and is equal to $1.34$. The expression

is minimized when $\Theta=2$ and is equal to $1$ at this minimum. So the leading constant is slightly worse in the constant stepsize protocol when all of the parameters are set optimally. However, if $D_{0}\geq M^{2}/c^{2}$, the $1/k$ protocol has error proportional to $D_{0}$, but our constant stepsize protocol still has only a logarithmic dependence on the initial distance. Moreover, the constant stepsize scheme is much more robust to overestimates of the curvature parameter $c$. For the $1/k$ protocols, if one overestimates the curvature (corresponding to a small value of $\Theta$), one can get arbitrarily slow rates of convergence. An simple, one dimensional example in shows that $\Theta=0.2$ can yield a convergence rate of $k^{-1/5}$. In our scheme, $\vartheta=0.2$ simply increases the number of iterations by a factor of $5$.

The proposed fix in for the sensitivity to curvature estimates results in asymptotically slower convergence rates of $1/\sqrt{k}$. It is important to note that we need not settle for these slower rates and can still achieve robust convergence at $1/k$ rates.

2 Parallel Implementation of a Backoff Scheme

The scheme described about results in a $1/k$ rate of convergence for Hogwild! with the only synchronization overhead occurring at the end of each “round” or “epoch” of iteration. When implementing a backoff scheme for Hogwild!, the processors have to agree on when to reduce the stepsize. One simple scheme for this is to run all of the processors for a fixed number of iterations, wait for all of the threads to complete, and then globally reduce the stepsize in a master thread. We note that one can eliminate the need for the threads to coalesce by sending out-of-band messages to the processors to signal when to reduce $\gamma$. This complicates the theoretical analysis as there may be times when different processors are running with different stepsizes, but in practice could allow one to avoid synchronization costs. We do not implement this scheme, and so do not analyze this idea further.

Related Work

Most schemes for parallelizing stochastic gradient descent are variants of ideas presented in the seminal text by Bertsekas and Tsitsiklis . For instance, in this text, they describe using stale gradient updates computed across many computers in a master-worker setting and describe settings where different processors control access to particular components of the decision variable. They prove global convergence of these approaches, but do not provide rates of convergence (This is one way in which our work extends this prior research). These authors also show that SGD convergence is robust to a variety of models of delay in computation and communication in .

We also note that constant stepsize protocols with backoff procedures are canonical in SGD practice, but perhaps not in theory. Some theoretical work which has at least demonstrated convergence of these protocols can be found in . These works do not establish the $1/k$ rates which we provided above.

Recently, a variety of parallel schemes have been proposed in a variety of contexts. In MapReduce settings, Zinkevich et al proposed running many instances of stochastic gradient descent on different machines and averaging their output . Though the authors claim this method can reduce both the variance of their estimate and the overall bias, we show in our experiments that for the sorts of problems we are concerned with, this method does not outperform a serial scheme.

Schemes involving the averaging of gradients via a distributed protocol have also been proposed by several authors . While these methods do achieve linear speedups, they are difficult to implement efficiently on multicore machines as they require massive communication overhead. Distributed averaging of gradients requires message passing between the cores, and the cores need to synchronize frequently in order to compute reasonable gradient averages.

The work most closely related to our own is a round-robin scheme proposed by Langford et al . In this scheme, the processors are ordered and each update the decision variable in order. When the time required to lock memory for writing is dwarfed by the gradient computation time, this method results in a linear speedup, as the errors induced by the lag in the gradients are not too severe. However, we note that in many applications of interest in machine learning, gradient computation time is incredibly fast, and we now demonstrate that in a variety of applications, Hogwild! outperforms such a round-robin approach by an order of magnitude.

Experiments

We ran numerical experiments on a variety of machine learning tasks, and compared against a round-robin approach proposed in and implemented in Vowpal Wabbit . We refer to this approach as RR. To be as fair as possible to prior art, we hand coded RR to be nearly identical to the Hogwild! approach, with the only difference being the schedule for how the gradients are updated. One notable change in RR from the Vowpal Wabbit software release is that we optimized RR’s locking and signaling mechanisms to use spinlocks and busy waits (there is no need for generic signaling to implement round robin). We verified that this optimization results in nearly an order of magnitude increase in wall clock time for all problems that we discuss.

We also compare against a model which we call AIG which can be seen as a middle ground between RR and Hogwild!. AIG runs a protocol identical to Hogwild! except that it locks all of the variables in $e$ in before and after the for loop on line 4 of Algorithm 1. Our experiments demonstrate that even this fine-grained locking induces undesirable slow-downs.

All of the experiments were coded in C++ are run on an identical configuration: a dual Xeon X650 CPUs (6 cores each x 2 hyperthreading) machine with 24GB of RAM and a software RAID-0 over 7 2TB Seagate Constellation 7200RPM disks. The kernel is Linux 2.6.18-128. We never use more than 2GB of memory. All training data is stored on a seven-disk raid 0. We implemented a custom file scanner to demonstrate the speed of reading data sets of disk into small shared memory. This allows us to read data from the raid at a rate of nearly 1GB/s.

All of the experiments use a constant stepsize $\gamma$ which is diminished by a factor $\beta$ at the end of each pass over the training set. We run all experiments for 20 such passes, even though less epochs are often sufficient for convergence. We show results for the largest value of the learning rate $\gamma$ which converges and we use $\beta=0.9$ throughout. We note that the results look the same across a large range of $(\gamma,\beta)$ pairs and that all three parallelization schemes achieve train and test errors within a few percent of one another. We present experiments on the classes of problems described in Section 2.

Sparse SVM. We tested our sparse SVM implementation on the Reuters RCV1 data set on the binary text classification task CCAT . There are 804,414 examples split into 23,149 training and 781,265 test examples, and there are 47,236 features. We swapped the training set and the test set for our experiments to demonstrate the scalability of the parallel multicore algorithms. In this example, $\rho=0.44$ and $\Delta=1.0$—large values that suggest a bad case for Hogwild!. Nevertheless, in Figure 3(a), we see that Hogwild! is able to achieve a factor of 3 speedup with while RR gets worse as more threads are added. Indeed, for fast gradients, RR is worse than a serial implementation.

For this data set, we also implemented the approach in which runs multiple SGD runs in parallel and averages their output. In Figure 5(b), we display at the train error of the ensemble average across parallel threads at the end of each pass over the data. We note that the threads only communicate at the very end of the computation, but we want to demonstrate the effect of parallelization on train error. Each of the parallel threads touches every data example in each pass. Thus, the $10$ thread run does $10$x more gradient computations than the serial version. Here, the error is the same whether we run in serial or with ten instances. We conclude that on this problem, there is no advantage to running in parallel with this averaging scheme.

Matrix Completion. We ran Hogwild! on three very large matrix completion problems. The Netflix Prize data set has 17,770 rows, 480,189 columns, and 100,198,805 revealed entries. The KDD Cup 2011 (task 2) data set has 624,961 rows, 1,000,990, columns and 252,800,275 revealed entries. We also synthesized a low-rank matrix with rank $10$, 1e7 rows and columns, and 2e9 revealed entries. We refer to this instance as “Jumbo.” In this synthetic example, $\rho$ and $\Delta$ are both around 1e-7. These values contrast sharply with the real data sets where $\rho$ and $\Delta$ are both on the order of 1e-3.

Figure 5(a) shows the speedups for these three data sets using Hogwild!. Note that the Jumbo and KDD examples do not fit in our allotted memory, but even when reading data off disk, Hogwild! attains a near linear speedup. The Jumbo problem takes just over two and a half hours to complete. Speedup graphs comparing Hogwild! to AIG and RR on the three matrix completion experiments are provided in Figure 4. Similar to the other experiments with quickly computable gradients, RR does not show any improvement over a serial approach. In fact, with 10 threads, RR is 12% slower than serial on KDD Cup and 62% slower on Netflix. In fact, it is too slow to complete the Jumbo experiment in any reasonable amount of time, while the 10-way parallel Hogwild! implementation solves this problem in under three hours.

Graph Cuts. Our first cut problem was a standard image segmentation by graph cuts problem popular in computer vision. We computed a two-way cut of the abdomen data set . This data set consists of a volumetric scan of a human abdomen, and the goal is to segment the image into organs. The image has $512\times 512\times 551$ voxels, and the associated graph is 6-connected with maximum capacity 10. Both $\rho$ and $\Delta$ are equal to 9.2e-4 We see that Hogwild! speeds up the cut problem by more than a factor of 4 with 10 threads, while RR is twice as slow as the serial version.

Our second graph cut problem sought a mulit-way cut to determine entity recognition in a large database of web data. We created a data set of clean entity lists from the DBLife website and of entity mentions from the DBLife Web Crawl . The data set consists of 18,167 entities and 180,110 mentions and similarities given by string similarity. In this problem each stochastic gradient step must compute a Euclidean projection onto a simplex of dimension 18,167. As a result, the individual stochastic gradient steps are quite slow. Nonetheless, the problem is still very sparse with $\rho$=8.6e-3 and $\Delta$=4.2e-3. Consequently, in Figure 3, we see the that Hogwild! achieves a ninefold speedup with 10 cores. Since the gradients are slow, RR is able to achieve a parallel speedup for this problem, however the speedup with ten processors is only by a factor of 5. That is, even in this case where the gradient computations are very slow, Hogwild! outperforms a round-robin scheme.

What if the gradients are slow? As we saw with the DBLIFE data set, the RR method does get a nearly linear speedup when the gradient computation is slow. This raises the question whether RR ever outperforms Hogwild! for slow gradients. To answer this question, we ran the RCV1 experiment again and introduced an artificial delay at the end of each gradient computation to simulate a slow gradient. In Figure 5(c), we plot the wall clock time required to solve the SVM problem as we vary the delay for both the RR and Hogwild! approaches.

Notice that Hogwild! achieves a greater decrease in computation time across the board. The speedups for both methods are the same when the delay is few milliseconds. That is, if a gradient takes longer than one millisecond to compute, RR is on par with Hogwild! (but not better). At this rate, one is only able to compute about a million stochastic gradients per hour, so the gradient computations must be very labor intensive in order for the RR method to be competitive.

Conclusions

Our proposed Hogwild! algorithm takes advantage of sparsity in machine learning problems to enable near linear speedups on a variety of applications. Empirically, our implementations outperform our theoretical analysis. For instance, $\rho$ is quite large in the RCV1 SVM problem, yet we still obtain significant speedups. Moreover, our algorithms allow parallel speedup even when the gradients are computationally intensive.

Our Hogwild! schemes can be generalized to problems where some of the variables occur quite frequently as well. We could choose to not update certain variables that would be in particularly high contention. For instance, we might want to add a bias term to our Support Vector Machine, and we could still run a Hogwild! scheme, updating the bias only every thousand iterations or so.

For future work, it would be of interest to enumerate structures that allow for parallel gradient computations with no collisions at all. That is, it may be possible to bias the SGD iterations to completely avoid memory contention between processors. For example, recent work proposed a biased ordering of the stochastic gradients in matrix completion problems that completely avoids memory contention between processors . An investigation into how to generalize this approach to other structures and problems would enable even faster computation of machine learning problems.

Acknowledgements

BR is generously supported by ONR award N00014-11-1-0723 and NSF award CCF-1139953. CR is generously supported by the Air Force Research Laboratory (AFRL) under prime contract no. FA8750-09-C-0181, the NSF CAREER award under IIS-1054009, ONR award N000141210041, and gifts or research awards from Google, LogicBlox, and Johnson Controls, Inc. SJW is generously supported by NSF awards DMS-0914524 and DMS-0906818 and DOE award DE-SC0002283. Any opinions, findings, and conclusion or recommendations expressed in this work are those of the authors and do not necessarily reflect the views of any of the above sponsors including DARPA, AFRL, or the US government.

References

Appendix A Analysis of Hogwild!

It follows by rearrangement of (4.3) that

In particular, by setting $x^{\prime}=x_{\star}$ (the minimizer) we have

We will make use of these identities frequently in what follows.

We start with the update formula (4.1). Recall that $k(j)$ is the state of the decision variable’s counter when the update to $x_{j}$ was read. We have

By subtracting $x_{\star}$ from both sides, taking norms, we have

where we recall that $\Omega=\max_{e\in E}|e|$. Here, in several places, we used the useful identity: for any function $\zeta$ of $x_{1},\ldots,x_{j}$ and any $i\leq j$, we have

We will perform many similar calculations throughout, so, before proceeding, we denote

to be the tuple of all edges and vertices selected in updates $1$ through $i$. Note that $x_{l}$ depends on $e_{[l-1]}$ but not on $e_{j}$ or $v_{j}$ for any $j\geq l$. We next consider the three expectation terms in this expression.

Let’s first bound the third expectation term in (A.3). Since $x_{k(j)}$ is independent of $e_{j}$ we have

where $\nabla f$ denotes an element of $\partial f$. It follows from (A.2) that

The first expectation can be treated similarly:

where the final inequality is from (A.1). Moreover, we can estimate the difference between $f(x_{j})$ and $f(x_{k(j)})$ as

which follows because $f_{e}$ is convex. By combining (A.5) and (A.6), we obtain

We turn now to the second expectation term in (A.3). We have

where $\rho$ is defined by (2.6). Here, the third line follows from our definition of the gradient update. The fourth line is tautological: only the edges where $e_{i}$ and $e_{j}$ intersect nontrivially factor into the sum. The subsequent inequality is Cauchy-Schwarz, and the following line follows from (4.4).

By substituting (A.4), (A.7), and (A.8) into (A.3), we obtain the following bound:

To complete the argument, we need to bound the remaining expectation in (A.9). We expand out the expression multiplied by $c\gamma$ in (A.9) to find

Let $e_{[\neg i]}$ denote the set of all sampled edges and vertices except for $e_{i}$ and $v_{i}$. Since $e_{i}$ and $v_{i}$ are both independent of $x_{k(j)}$, we can proceed to bound

where $\Delta$ is defined in (2.6). The first inequality is Cauchy-Schwartz. The next inequality is Jensen. The second to last inequality follows from our definition of $x_{j}$, and the final inequality is Jensen again.

Plugging the last two expressions into (A.9), we obtain

Here we use the fact that $c\gamma<1$ to get a simplified form for $Q$. This recursion only involves constants involved with the structure of $f$, and the nonnegative sequence $a_{j}$. To complete the analysis, we will perform a linearization to put this recursion in a more manageable form.

To find the steady state, we must solve the equation

Note that for $\rho$ and $\Delta$ sufficiently small, $C(\tau,\rho,\Delta,\Omega)\approx 1$.

Since the square root is concave, we can linearize (A.10) about the fixed point $a_{\infty}$ to yield

To summarize, we have shown that the sequence $a_{j}$ of squared distances satisfies

with $a_{\infty}\leq C(\tau,\rho,\Delta,\Omega)\frac{M^{2}\gamma}{2c}$. In the case that $\tau=0$ (the serial case), $C(\tau,\rho,\Delta,\Omega)=\Omega$ and $\delta(\tau,\rho,\Delta,\Omega)=0$. Note that if $\tau$ is non-zero, but $\rho$ and $\Delta$ are $o(1/n)$ and $o(1/\sqrt{n})$ respectively, then as long as $\tau=o(n^{1/4})$, $C(\tau,\rho,\Delta,\Omega)=O(1)$. In our setting, $\tau$ is proportional to the number of processors, and hence as long as the number of processors is less $n^{1/4}$, we get nearly the same recursion as in the linear rate.

In the next section, we show that (A.13) is sufficient to yield a $1/k$ convergence rate. Since we can run $p$ times faster in our parallel setting, we get a linear speedup.

A.2 Proof of Proposition 4.1: Final Steps

Setting $x^{\prime}=x_{\star}$ gives $f(x)-f(x_{\star})\leq\frac{L}{2}\|x-x_{\star}\|^{2}$. Hence,

for all $k$. To ensure the left hand side is less than $\epsilon$, it suffices to guarantee that $a_{k}\leq\epsilon/L$.

To complete the proof of Proposition 4.1, we use the results of Section 4. We wish to achieve a target accuracy of $\epsilon/L$. To apply (5.3), choose $a_{\infty}$ as in (A.12) and the values

By (A.12), we have $a_{\infty}\leq\gamma B$.

Choose $\gamma$ satisfying (4.5). With this choice, we automatically have

because $(1+\sqrt{1+x})^{2}\leq 4+2x$ for all $x\geq 0$. Substituting this value of $\gamma$ into (5.3), we see that

iterations suffice to achieve $a_{k}\leq\epsilon/L$. Now observe that

Here,the second to last inequality follows because

for all $x\geq 0$. Plugging this bound into (A.14) completes the proof.