High-Performance Distributed ML at Scale through Parameter Server Consistency Models

by   Wei Dai, et al.
Carnegie Mellon University

As Machine Learning (ML) applications increase in data size and model complexity, practitioners turn to distributed clusters to satisfy the increased computational and memory demands. Unfortunately, effective use of clusters for ML requires considerable expertise in writing distributed code, while highly-abstracted frameworks like Hadoop have not, in practice, approached the performance seen in specialized ML implementations. The recent Parameter Server (PS) paradigm is a middle ground between these extremes, allowing easy conversion of single-machine parallel ML applications into distributed ones, while maintaining high throughput through relaxed "consistency models" that allow inconsistent parameter reads. However, due to insufficient theoretical study, it is not clear which of these consistency models can really ensure correct ML algorithm output; at the same time, there remain many theoretically-motivated but undiscovered opportunities to maximize computational throughput. Motivated by this challenge, we study both the theoretical guarantees and empirical behavior of iterative-convergent ML algorithms in existing PS consistency models. We then use the gleaned insights to improve a consistency model using an "eager" PS communication mechanism, and implement it as a new PS system that enables ML algorithms to reach their solution more quickly.


page 1

page 2

page 3

page 4


Consistent Bounded-Asynchronous Parameter Servers for Distributed ML

In distributed ML applications, shared parameters are usually replicated...

Strategies and Principles of Distributed Machine Learning on Big Data

The rise of Big Data has led to new demands for Machine Learning (ML) sy...

Towards Demystifying Serverless Machine Learning Training

The appeal of serverless (FaaS) has triggered a growing interest on how ...

LightLDA: Big Topic Models on Modest Compute Clusters

When building large-scale machine learning (ML) programs, such as big to...

Structure-Aware Dynamic Scheduler for Parallel Machine Learning

Training large machine learning (ML) models with many variables or param...

Tensor Relational Algebra for Machine Learning System Design

Machine learning (ML) systems have to support various tensor operations....

Learnability of Learning Performance and Its Application to Data Valuation

For most machine learning (ML) tasks, evaluating learning performance on...


The surging data volumes generated by internet activity and scientific research  [7] put tremendous pressure on Machine Learning (ML) methods to scale beyond the computation and memory of a single machine. On one hand, very large data sizes (Big Data) require too much time for complex ML models to process on a single machine [1, 8, 5, 6, 12], which necessitates distributed-parallel computation over an entire cluster of machines. A typical solution to this problem is data paralllelism, in which the data is partitioned and distributed across different machines, which train the (shared) ML model using their local data. In order to share the model across machines, practitioners have recently turned to a ”Parameter server” (PS) paradigm [1, 8, 5, 6, 12].

Many general-purpose Parameter Server (PS) systems [8, 5, 6] of ML computation provide a Distributed Shared Memory (DSM) solution to the Big Data and Big Model issues. DSM allows ML programmers to treat the entire cluster as a single memory pool, where every machine can read/write to any model parameter via a simple programming interface; this greatly simplifies the implementation of distributed ML programs, because programmers may treat a cluster like a “supercomputer” that can run thousands of computational threads, without worrying about low-level communication between machines. It should be noted that not all PS systems provide a DSM interface; some espouse an arguably less-convenient push/pull interface that requires users to explicitly decide which parts of the ML model need to be communicated [12].

At the same time, the iterative-convergent nature of ML programs presents unique opportunities and challenges that do not manifest in traditional database applications: for example, ML programs lend themselves well to stochastic subsampling or randomized algorithms, but at the same time exhibit complex dependencies or correlations between parameters that can make parallelization difficult [3, 11]. Recent works [16, 8, 9] have introduced relaxed consistency models to trade off between parameter read accuracy and read throughput, and show promising speedups over fully-consistent models; their success is underpinned by the error-tolerant nature of ML, that “plays nicely” with relaxed synchronization guarantees — and in turn, relaxed synchronization allows system designers to achieve higher read throughput, compared to fully-consistent models.

However, we still possess limited understanding of (1) how relaxed consistency affects ML algorithmconvergence rate and stability, and (2) what opportunities still exist for improving the performance of boththe ML algorithm (how much progress it makes per iteration), and the throughput of the PS system (howmany ML algorithm iterations can be executed per second). Recent works on PS have only focused on system optimizations in PS using various heuristics like async relaxation 

[4] and uneven updates propagation based on parameter values [12]. Our work instead starts from an ML-theoretic standpoint and provides principled insights to improve PS design. Concretely, we examine the theoretical and empirical behavior of PS consistency models from new angles, such as the distribution of stale reads and the impact of staleness on solution stability. We then apply the learnt insights to design more efficient consistency models and PS system that outperform previous work.

To study these issues, we formulate a new Value-Bounded Asynchronous Parallel (VAP) model, and show that it provides an ideal, gold-standard target in terms of theoretical behavior (high progress per ML algorithm iteration). However, VAP, of which the basic idea or principle is attempted in [14], can be problematic because bounding the value of in-transit updates amounts to tight synchronization. We propose Eager Stale Synchronous Parallel (ESSP), a variant of Stale Synchronous Parallel (SSP, a bounded-iteration model that is fundamentally different from VAP) introduced in [8]

, and formally and empirically show that ESSP is a practical and easily realizable scheme for parallelization. Specifically, we develop new variance bounds for both ESSP and VAP, and show that ESSP attains the same guarantees as VAP. These variance bounds provide a deeper characterization of convergence (particularly solution stability) under SSP and VAP, unlike existing PS theory that is focused only on expectation bounds 

[8]. We develop an efficient implementation of ESSP and shows that it outperforms SSP in convergence (both real time and per iteration) by reducing the average staleness, consistent with our theoretical results.

Consistency Models for Parameter Servers

A key idea for large-scale distributed ML is to carefully trade off parameter consistency for increased parameter read throughput (and thus faster algorithm execution), in a manner that guarantees the final output of an ML algorithm is still “correct” (meaning that it has reached a locally-optimal answer). This is possible because ML algorithms are iterative-convergent and error-tolerant: ML algorithms will converge to a local optimum even when there are errors in the algorithmic procedure itself (such as stochasticity in randomized methods).

In a distributed-parallel environment, multiple workers must simultaneously generate updates to shared global parameters. Hence, enforcing strong consistency (parameters updates are immediately reflected) quickly leads to frequent, time-consuming synchronization and thus very limited speed up from parallelization. One must therefore define a relaxed consistency model that enables low-synchronization parallelism while closely approximating the strong consistency of sequential execution. The insight is that, to an iterative-convergent ML algorithm, inconsistent parameter reads have essentially the same effect as errors due to the algorithmic procedure — implying that convergence to local optima can still happen even under inconsistent reads, provided the degree of inconsistency is carefully controlled. We now explain two possible PS consistency models, and the trade-offs they introduce.

The ideal but inefficient Value-bounded Asynchronous Parallel (VAP) model

We first introduce Value-bounded Asynchronous Parallel (VAP), an ideal model that directly approximates strong consistency (e.g. in the sequential setting) by bounding the difference in magnitude between the strongly consistent view of values (i.e. values under the single-thread model) and the actual parameter views on the workers. Formally, let represent all model parameters, and assume that each worker in the ML algorithm produces additive updates (, where is the update)111This is common in algorithms such as gradient descent ( being the gradient) and sampling methods.. Given workers, we say that an update is in transit if has been seen by or fewer workers — in other words, it is yet visible by all workers. Update is no longer in transit once seen by all workers. The VAP requires the following condition:

VAP condition:

Let be the updates from worker that are in transit, and . VAP requires that, whenever any worker performs a computation involving the model variables , the condition holds for a specified (time-varying) value bound parameter . In other words, the aggregated in-transit updates from all workers cannot be too large.

To analyze VAP, we must identify algorithmic properties common to ML algorithms. Broadly speaking, most ML algorithms are either optimization-based or sampling-based

. Within the former, many Big Data ML algorithms are stochastic gradient descent-based (SGD), because SGD allows each worker to operate on its own data partition (i.e. no need to transfer data between workers), while the algorithm parameters are globally shared (hence a PS is necessary). SGD’s popularity makes it a good choice for grounding our analysis — in later section, we show that VAP approximates strong consistency well in these senses: (1) SGD with VAP errors converges

in expectation to an optimum; (2) the parameter variance decreases in successive iterations, guaranteeing the quality and stability of the final result.

While being theoretically attractive, the VAP condition is too strong to be implemented efficiently in practice: before any worker can perform computation on , it must ensure that the in-transit updates from all other workers sum to at most component-wise due to the max-norm. This poses a chicken-and-egg conundrum: for a worker to ensure the VAP condition holds, it needs to know the updates from all other workers — which, in general, requires the same amount of communication as strong consistency, defeating the purpose of VAP. While it may be possible to relax the VAP condition for specific problem structures, in general, value-bounds are difficult to achieve for a generic PS.

Eager Stale Synchronous Parallel (ESSP)

In order to design a consistency model that is practically efficient while providing proper correctness guarantees, we consider an iteration-based consistency model called Stale Synchronous Parallel (SSP) [8], that lends itself to an efficient PS implementation. At a high level, SSP imposes bounds on clock, which represents some unit of work in an ML algorithm, akin to iteration. Given workers, SSP assigns each worker a clock that is initially zero. Then, each worker repeats the following operations: (1) perform computation using shared parameters stored in the PS, (2) make additive updates to the PS, and (3) advance its own clock by 1. The SSP model limits fast workers’ progress so that the clock difference between the fastest and slowest worker is , being a specified staleness parameter. This is achieved via:

SSP Condition (informal):

Let be the clock of the fastest workers. They may not make further progress until all other workers’ updates that were made at clocks at or before become visible.

We present the formal condition in the next section. Crucially, there are multiple update communication strategies that can meet the SSP condition. We present Eager SSP (ESSP) as a class of implementations that eagerly propagate the updates to reduce empirical staleness beyond required by SSP. ESSP does not provide new guarantees besides warranted by SSP, but we show that by reducing the average staleness ESSP achieves faster convergence theoretically and empirically.

Figure 1: Left: Empirical staleness distribution from matrix factorization. X-axis is (parameter age - local clock), y-axis is the normalized observation count. Note that on Bulk Synchronous Parallel (BSP) system such as Map-Reduce, the staleness is always . We use rank 100 for matrix factorization, and each clock is minibatch. The experiment is run on a 64 node cluster. Right: Communication and Computation breakdown for LDA. The lower part of the bars are computation, and the upper part is communication.

How can we show that ESSP reduces the staleness of parameter reads? While it is difficult to a priori predict the behavior of complex software such as a PS, we can still empirically measure the staleness of parameter reads during PS algorithm execution, from which we can draw conclusions about the PS’s behavior. Consider Figure 1 (left), which shows the distribution of parameter stalenesses observed in matrix factorization implemented on SSP and ESSP. Our measure of staleness is a “clock differential”: when a worker reads a parameter, that worker’s clock could be be behind (or ahead) of other workers, and clock differential simply measures this clock difference. Under SSP, the distribution of clock differentials is nearly uniform, because SSP “waits until the last minute” to update the local parameter cache. On the other hand, ESSP frequently updates the local parameter caches via its eager communication, which reduces the negative tail in clock differential distribution — this improved staleness profile is ESSP’s most salient advantage over SSP. In the sequel, we will show that better staleness profiles lead to faster ML algorithm convergence, by proving new, tighter convergence bounds based on average staleness and the staleness distributions (unlike the simpler worst-case bounds in [8]).

Our analyses and experiments show that ESSP combines the strengths of VAP and SSP: (1) ESSP achieves strong theoretical properties comparable to VAP; (2) ESSP can be efficiently implemented, with excellent empirical performance on two ML algorithms: matrix completion using SGD, and topic modeling using sampling. We also show that ESSP achieves higher throughput than SSP, thanks to system optimizations that exploit ESSP’s aggressive scheduling.

Theoretical Analysis

In this section, we theoretically analyze VAP and ESSP, and show how they affect ML algorithm convergence. For space reasons, all proofs are placed in the appendix. As explained earlier, we ground our analysis on ML algorithms in the stochastic gradient descent (SGD) family (due to its high popularity for Big Data), and prove the convergence of SGD under VAP and ESSP. We now explain SGD in the context of a matrix completion problem.

SGD for Low Rank Matrix Factorization

Matrix completion involves decomposing an matrix into two low rank matrices and such that , where is a user-specified rank. The problem is to predict those missing entries based on known entries by solving the following -penalized optimization problem:

where is the Frobenius norm and is the regularization parameter. The stochastic gradient updates for each observed entry are

where , are row and column of respectively, and

is the vector product.

. We absorb constants into the step-size . Since are being updated by each gradient, we put them in the parameter server to allow all works access them and make additive updates. The data are partitioned into worker nodes and stored locally.


We formally introduce the VAP computation model: given workers that produce updates at regular intervals which we call “clocks”, let be the update from worker at clock applied to the system state via . Consider the update sequence that orders the updates based on the global time-stamp they are generated. We can define “real-time sequence” as

assuming all workers start from the agreed-upon initial state . (Note that is different from the parameter server view as the updates from different workers can arrive the server in a different order due to network.) Let be the noisy view some worker sees when generating update , i.e., for some function . The VAP condition guarantees


where we require the value bound to shrink over time from the initial bound . Notice that is exactly the updates in transit w.r.t. worker . We make mild assumptions to avoid pathological cases.222To avoid pathological cases where a worker is delayed indefinitely, we assume that each worker’s updates are finitely apart in sequence . In other words, all workers generate updates with sufficient frequency. For SGD, we further assume that each worker updates its step-sizes sufficiently often that the local step-size for some bounded drift and thus is close to the global step size schedule .

Theorem 1.

(SGD under VAP, convergence in expectation) Given convex function such that components are also convex. We search for minimizer via gradient descent on each component with step-size close to such that the update is computed on noisy view . The VAP bound follows the decreasing described above. Under suitable conditions ( are -Lipschitz and bounded diameter ),

and thus as .

Theorem 1 implies that the worker’s noisy VAP view converges to the global optimum , as measured by , in expectation at the rate . The analysis is similar to [8], but we use the real-time sequence as our reference sequence and VAP condition instead of SSP. Loosely speaking, Theorem 1 shows that VAP execution is unbiased. We now present a new bound on the variance.

Theorem 2.

(SGD under VAP, bounded variance) Assuming , , and similar to theorem 1 above, and has bounded and invertible Hessian, defined at optimal point . Let ( is the sum of component-wise variance333), and is the gradient, then:


near the optima . The covariance uses inner product. and . .

is a random variable capturing the randomness of update

conditioned on (see appendix).

in general as the change in and average gradient are of the same direction. Theorem 2 implies that under VAP the variance decreases in successive iterations for sufficiently small , which can be controlled via VAP threshold . However, as we argued in the previous section, the VAP condition requires the same amount of synchronization as strong consistency, which makes it of little practical benefit. This motivates our following analysis of the SSP model.


We return to the index. Under the SSP worker at clock only has access to a noisy view of the system state ( is different from the noisy view in VAP ). Update is computed on the noisy view for some function . Assuming all workers start from the agreed-upon initial state , the SSP condition is:

SSP Bounded-Staleness (formal):

For a fixed staleness , the noisy state is equal to

for some which is some subset of updates in the window issued by all workers during clock to . The noisy view consists of (1) guaranteed pre-window updates for clock 1 to , and (2) best-effort updates indexed by .444In contrast to [8], we do not assume read-my-write. We introduce a clock-major index :

and analogously for and . We can now define a reference sequence (distinct from in VAP) which we informally refers to as the “true” sequence:


The sum loops over workers ( mod ) and clocks . Notice that this sequence is unrelated to the server view.

Theorem 3.

(SGD under SSP, convergence in expectation [8], Theorem 1) Given convex function with suitable conditions as in Theorem 1, we use gradient descent with updates generated from noisy view and . Then

and thus as .

Theorem 3 is the SSP-counterpart of Theorem 1. The analysis of Theorem 3 only uses the worst-case SSP bounds. However, in practice many updates are much less stale than the SSP bound. In Fig 1 (left) both implementations have small portion of updates with maximum staleness.

We now use moment statistics to further characterize the convergence. We begin by decomposing

. Let be the average of of the updates. We can write the noisy view as


where is a vector of random variables whose randomness lies in the network communication. Note that the decomposition in eq. 5 is always possible since iff for all updates in the 2 window. Using SSP we can bound and :

Lemma 4.

and .

Therefore and are well-defined. We now provide an exponential tail-bound characterizing convergence in finite steps.

Theorem 5.

(SGD under SSP, convergence in probability) Given convex function

such that components are also convex. We search for minimizer via gradient descent on each component under SSP with staleness and workers. Let with . Under suitable conditions ( are -Lipschitz and bounded divergence ), we have

where , and .

This means that converges to in probability with an exponential tail-bound. Also note that the convergence is faster for smaller and .

We need a few mild assumptions on the staleness in order to derive variance bound:

Assumption 1.

are i.i.d. random variable with well-defined mean and variance .

Assumption 2.

is independent of and .

Assumption 1 is satisfied by Lemma 4, while Assumption 2 is valid since are only influenced by the computational load and network bandwidth at each machine, which are themselves independent of the actual values of the computation ( and ). We now present an SSP variance bound.

Theorem 6.

(SGD under SSP, decreasing variance) Given the setup in Theorem 5 and assumption 1-3. Further assume that has bounded and invertible Hessian at optimum and is bounded. Let , then for near the optima such that and are small:


where the covariance uses inner product. represents high order (th) terms involving . is a random variable capturing the randomness of update conditioned on (see appendix).

As argued before, in general. Therefore the theorem implies that monotonically decreases over time when SGD is close to an optima.

Comparison of VAP and ESSP

From Theorem 2 and 6 we see that both VAP and (E)SSP achieves decreasing variance. However, VAP convergence is much more sensitive to its tuning parameter (the VAP threshold) than (E)SSP, whose tuning parameter is the staleness . This is evident from the term in Eq. 3, which is bounded by the VAP threshold. In contrast, (E)SSP’s variance only involves staleness in high order terms (Eq. 7), where is bounded by staleness. This implies that staleness-induced variance vanishes quickly in (E)SSP. The main reason for (E)SSP’s weak dependency on staleness because SGD’s step-size already tunes the update magnitude approaching optimum, and thus for the same number of missing updates (such as the window in SSP), their total magnitude is decreasing as well, which is conducive for lowering variance. VAP on the other hand, does not make use of the decreasing step-size and thus needs to directly rely on the VAP threshold, resulting in strong dependency on the threshold.

An intuitive analogy is that of postmen: VAP is like a postman who only ever delivers mail above a certain weight threshold . (E)SSP is like a postman who delivers mail late, but no later than days. Intuitively, the (E)SSP postman is more reliable than the VAP postman due to his regularity. The only way for the VAP postman to be reliable, is to decrease the weight threshold — this becomes important when the ML algorithm is approaching convergence, because the algorithm’s updates become diminishingly small. However, there are two drawbacks to decreasing : first, much like step-size tuning, it must be done at a carefully controlled rate — this requires either specific knowledge about the ML problem, or a sophisticated, automatic scheme (that may also be domain-specific). Second, as decreases, VAP produces more communication, which increases the running time of the distributed algorithm.

In contrast to VAP, ESSP does not suffer as much from these drawbacks, because: (1) SSP has a weaker theoretical dependency on its staleness threshold (than VAP does on its value-bound threshold), thus it is usually unnecessary to decrease the staleness as the ML algorithm approaches convergence; this is evidenced by the SSP paper [8], which achieved stable convergence even though they did not decrease staleness gradually during ML algorithm execution. (2) Because ESSP proactively pushes out fresh parameter values, the distribution of stale reads is usually close to zero-staleness, regardless of the actual staleness threshold used (see Figure 1) — hence, fine-grained tuning of the staleness threshold is rarely necessary under ESSP.

ESSPTable: An efficient ESSP System

Our theory suggests that the ESSP consistency model, with its aggressive parameter updates, should considerably outperform SSP. In order to verify this, we implemented ESSP inside a Parameter Server (PS), which we call ESSPTable.

PS Interface:

Each physical machine runs one ESSPTable process with three types of threads: 1) computation threads; 2) communication threads and 3) server threads. Each computation thread is regarded as a distinct worker by the system. The computation threads execute application logic and access the global parameters stored in ESSPTable through a key-value store interface—read a table-row via GET and write via INC. Once a computation thread completes a clock tick, it notifies the system via CLOCK, which increments the worker’s clock by 1. As required by the SSP consistency , a READ issued by a worker at clock is guaranteed to observe all updates generated in clock , where is the user-defined staleness threshold.

Ensuring Consistency Guarantees:

The ESSPTable client library caches locally accessed parameters. In case the parameter is too large to fit into client machine’s memory, cold parameters are evicted using an approximate Least-Recently-Used (LRU) policy. When a computation thread issues a GET request, it first checks the local cache for the requested parameters. If the requested parameter is not found in local cache, a read request is sent to the server.

Each parameter in the client local cache is associated with a clock ; means that all updates from all workers generated before clock have already been applied to this parameter. is compared with the worker’s clock . Only if , the requested parameter is returned to the worker.

Communication Protocol:

The updates generated by computation threads are coalesced since they are commutative and associative. These updates are sent to the server at the end of each clock tick.

The server sends updated parameters to the client through call-backs. When a client request a table-row for the first time, it registers a call-back on the server. This is the only time the client makes read request to the server. Subsequently, when a server table’s clock advances from getting the clock tick from all clients, it pushes out the table-rows to the respective registered clients. This differs from the SSPTable in [8] where the server passively sends out updates upon client’s read request (which happens each time a client’s local cache becomes too stale). The call-back mechanism exploits the fact that computation threads often revisit the same parameters in iterative-convergent algorithms, and thus the server can push out table-rows to registered clients without clients’ explicit request. Our server-push model causes more eager communication and thus lower empirical staleness than SSPTable in [8] as shown in Fig. 1 (left).

We empirically observed that the time needed to communicate the coalesced updates accumulated in one clock is usually less than the computation time. Thus computation threads usually observe parameters with staleness regardless of the user-specified staleness threshold . That relieves the burden of staleness tuning. Also, since the server pushes out updated parameters to registered clients in batches, it reduces the overall latency from sending each parameter separately upon clients’ requests (which is the case in SSPTable). This improvement is shown in our experiments.


We show that ESSP improves the speed and quality of convergence (versus SSP) for collapsed gibbs sampling in topic model and stochastic gradient descent (SGD) in matrix factorization. Furthermore, ESSP is robust against the staleness setting, relieving the user from worrying about an additional tuning parameter. The experimental setups are:

  • ML Models and algorithms: LDA topic modeling (using collapsed Gibbs sampling) and Matrix Factorization (stochastic gradient descent). Both algorithms are implemented using ESSPTable’s interface. For LDA we use 50% minibatch in each Clock() call, and we use log-likelihood as measure of training quality. For MF we use 1% and 10% minibatch in each Clock() and record the squared loss (instead of the -penalized objective) for convenient comparison with GraphLab (see appendix). The step size for MF is chosen to be large while the algorithm still converges with staleness 0.

  • Datasets Topic model: New York Times ( tokens, vocabularies, and topics). Matrix factorization: Netflix dataset ( by matrix with nonzeros.) We use rank .

  • Compute cluster Matrix factorization experiments were run on 64 nodes, each with 2 cores and 16GB RAM, connected via 1Gbps ethernet. LDA experiments were run on 8 nodes, each with 64 cores and 128GB memory, connected via 1Gbps ethernet.

Speed of Convergence: Figure 2 shows the objective over iteration and time for LDA and matrix factorization. In both cases ESSP converges faster or comparable to SSP with respect to iteration and run time. The speed up over iteration is due to the reduced staleness as shown in the staleness profile (Figure 1, left). This is consistent with the fact that in SSP, computation making use of fresh data makes more progress [8]. Also it is worth pointing out that staleness helps SSP substantially but much less so for ESSP because ESSP is less susceptible to staleness.

Robustness to Staleness: One important tuning knob in SGD-type of algorithms are the step size. Using step sizes that are too small leads to slow convergence, while step sizes that are too large cause divergence. The problem of stepsize tuning is aggravated in the distributed setting, where staleness could aggregate the updates in a non-deterministic manner, thus causing unpredictable performance (dependent on network congestion and the varying machine speeds). In the case of MF, SSP diverges under high staleness, as staleness effective increases the step size. However, ESSP is robust across all investigated staleness values due to the concentrated staleness profile (see Figure 1, left). Even when high SSP staleness does not produce divergence, the convergence is “shaky” due to the variance introduced by staleness. ESSP produces lower variance for all staleness settings, consistent with our theoretical analyses. This improvement largely reduced the need for user to tune the staleness parameter introduced in SSP.

System Opportunity. In addition to faster convergence per iteration, ESSP provides opportunities for system to optimize the communication. By sending updates preemptively, ESSP not only reduces the staleness but also reduces the chance of client threads being blocked to wait for updates. In some sense ESSP is a more “pipelined” version of SSP. Figure 1 (right) shows the breakdown of communication and compuation time for varying staleness. This contributes to the overall convergence per second in Figure 2, where ESSP has larger margin of speed gain over SSP than the convergence per iteration.

Figure 2: Experimental Results. The convergence speed per iteration and per second for LDA and MF.

Related Work and Discussion

Existing software that is tailored towards distributed (rather than merely single-machine parallel), scalable ML can be roughly grouped into two categories: general-purpose, programmable libraries or frameworks such as GraphLab [15] and Parameter Servers (PSes) [8, 14], or special-purpose solvers tailored to specific categories of ML applications: CCD++ [18] for Matrix Factorization, Fugue [9] for constrained MF, Vowpal Wabbit for regression/classification problems via stochastic optimization [10], and Yahoo LDA as well as Google plda for topic modeling [17].

The primary differences between the general-purpose frameworks (including this work) and the special-purpose solvers are (1) the former are user-programmable and can be extended to handle arbitrary ML applications, while the latter are non-programmable and restricted to predefined ML applications; (2) because the former must support arbitrary ML programs, their focus is on improving the “systems” code (notably, communication and synchronization protocols for model state) to increase the efficiency of all ML algorithms, particularly through the careful design of consistency models (graph consistency in GraphLab, and iteration/value-bounded consistency in Parameter Servers) — in contrast, the special-purpose systems combine both systems code improvements and algorithmic (i.e. mathematical) improvements tailor-made for their specific category of ML applications.

As a paper about general-purpose distributed ML, we focus on consistency models and systems code, and we deliberately use (relatively) simple algorithms for our benchmark applications, for two reasons: (1) to provide a fair comparison, we must match the code/algorithmic complexity of the benchmarks for other frameworks like GraphLab and SSP PS [8] (practically, this means our applications should use the same update equations); (2) a general-purpose ML framework should not depend on highly-specialized algorithmic techniques tailored only to specific ML categories. The crux is that general-purpose frameworks should democratize distributed ML in a way that special-purpose solvers cannot, by enabling those ML applications that have been under-served by the distributed ML research community to benefit from cluster computing. Since our benchmark applications are kept algorithmically simple, they are unlikely to beat the special-purpose solvers in running time — but we note that many algorithmic techniques featured in those solvers can be applied to our benchmark applications, by dint of the general-purpose nature of PS programming.

In [13], the authors propose and implement a PS consistency model that has similar theoretical guarantees to the ideal VAP model presented herein. However, we note that their implementation does not strictly enforce the conditions of their consistency model. Their implementation implicitly assumes zero latency for transmission over network, while in a real cluster, there could be arbitrarily long network delay. In their system, reads do not wait for delayed updates, so a worker may compute with highly inconsistent parameters in the case of congested network.

On the wider subject of Big Data, Hadoop [2] and Spark [19] are popular programming frameworks, which ML applications are sometimes developed on top of. To the best of our knowledge, there is no recent work showing that Hadoop or Spark have superior ML algorithm performance compared to frameworks designed for ML like GraphLab and PSes (let alone the special-purpose solvers mentioned earlier). The most salient difference is that Hadoop and Spark only feature strict consistency, and do not support flexible consistency models like graph- or bounded-consistency. On the positive side, Hadoop and Spark ensure program portability, reliability and fault tolerance at a level that GraphLab and PSes have yet to match.


  • [1] Amr Ahmed, Moahmed Aly, Joseph Gonzalez, Shravan Narayanamurthy, and Alexander J. Smola. Scalable inference in latent variable models. In WSDM, pages 123–132, 2012.
  • [2] Dhruba Borthakur. The hadoop distributed file system: Architecture and design. Hadoop Project Website, 11:21, 2007.
  • [3] Joseph K. Bradley, Aapo Kyrola, Danny Bickson, and Carlos Guestrin. Parallel coordinate descent for l1-regularized loss minimization. In International Conference on Machine Learning (ICML 2011), June 2011.
  • [4] Trishul Chilimbi, Yutaka Suzue, Johnson Apacible, and Karthik Kalyanaraman.

    Project adam: Building an efficient and scalable deep learning training system.

    In 11th USENIX Symposium on Operating Systems Design and Implementation (OSDI 14), pages 571–582, Broomfield, CO, October 2014. USENIX Association.
  • [5] James Cipar, Qirong Ho, Jin Kyu Kim, Seunghak Lee, Gregory R. Ganger, Garth Gibson, Kimberly Keeton, and Eric Xing. Solving the straggler problem with bounded staleness. In HotOS ’13. Usenix, 2013.
  • [6] Henggang Cui, James Cipar, Qirong Ho, Jin Kyu Kim, Seunghak Lee, Abhimanu Kumar, Jinliang Wei, Wei Dai, Gregory R. Ganger, Phillip B. Gibbons, Garth A. Gibson, and Eric P. Xing. Exploiting bounded staleness to speed up big data analytics. In 2014 USENIX Annual Technical Conference (USENIX ATC 14), pages 37–48, Philadelphia, PA, June 2014. USENIX Association.
  • [7] J Dean, G Corrado, R Monga, K Chen, M Devin, Q Le, M Mao, M Ranzato, A Senior, P Tucker, K Yang, and A Ng. Large scale distributed deep networks. In NIPS 2012, 2012.
  • [8] Q. Ho, J. Cipar, H. Cui, J.-K. Kim, S. Lee, P. B. Gibbons, G. Gibson, G. R. Ganger, and E. P. Xing. More effective distributed ml via a stale synchronous parallel parameter server. In NIPS, 2013.
  • [9] Abhimanu Kumar, Alex Beutel, Qirong Ho, and Eric P. Xing. Fugue: Slow-worker-agnostic distributed learning for big models on big data. Technical report.
  • [10] J Langford, L Li, and A Strehl. Vowpal wabbit online learning project, 2007.
  • [11] Seunghak Lee, Jin Kyu Kim, Xun Zheng, Qirong Ho, Garth A Gibson, and Eric P Xing. Primitives for dynamic big model parallelism. In Advances in Neural Information Processing Systems (NIPS), 2014.
  • [12] Mu Li, David G. Andersen, Jun Woo Park, Alexander J. Smola, Amr Ahmed, Vanja Josifovski, James Long, Eugene J. Shekita, and Bor-Yiing Su. Scaling distributed machine learning with the parameter server. In Operating Systems Design and Implementation (OSDI), 2014.
  • [13] Mu Li, Li Zhou Zichao Yang, Aaron Li Fei Xia, David G. Andersen, and Alexander Smola. Parameter server for distributed machine learning. NIPS workshop, 2013.
  • [14] Mu Li, Li Zhou, Zichao Yang, Aaron Li, Fei Xia, Dave Andersen, and Alex Smola. Parameter server for distributed machine learning, big learning workshop. In NIPS, 2013.
  • [15] Yucheng Low, Joseph Gonzalez, Aapo Kyrola, Danny Bickson, Carlos Guestrin, and Joseph M. Hellerstein. Graphlab: A new parallel framework for machine learning. In

    Conference on Uncertainty in Artificial Intelligence (UAI)

    , Catalina Island, California, July 2010.
  • [16] Feng Niu, Benjamin Recht, Christopher Ré, and Stephen J Wright. Hogwild!: A lock-free approach to parallelizing stochastic gradient descent. In NIPS, 2011.
  • [17] Yi Wang, Hongjie Bai, Matt Stanton, Wen-Yen Chen, and Edward Y. Chang. Plda: Parallel latent dirichlet allocation for large-scale applications. In Proceedings of the 5th International Conference on Algorithmic Aspects in Information and Management, AAIM ’09, pages 301–314, Berlin, Heidelberg, 2009. Springer-Verlag.
  • [18] Hsiang-Fu Yu, Cho-Jui Hsieh, Si Si, and Inderjit S Dhillon. Scalable coordinate descent approaches to parallel matrix factorization for recommender systems. In ICDM, pages 765–774, 2012.
  • [19] Matei Zaharia, N. M. Mosharaf Chowdhury, Michael Franklin, Scott Shenker, and Ion Stoica. Spark: Cluster computing with working sets. Technical Report UCB/EECS-2010-53, EECS Department, University of California, Berkeley, May 2010.


Theorem 1

(SGD under VAP, convergence in expectation) Given convex function such that components are also convex. We search for minimizer via gradient descent on each component with step-size close to such that the update is computed on noisy view . The VAP bound follows the decreasing described above. Under suitable conditions ( are -Lipschitz and bounded diameter ),

and thus as .


We will use real-time sequence defined by

( are convex)

where . From Lemma A.1 below we have

We now bound each term:

(Lipschitz assumption)
( is the finite clock drift in VAP)

where the clock drift comes from the fact that is not exactly in VAP.

Together, we have as desired.

Lemma A.1

For , and ,

where .


Divide both sides by gets the desired answer.

Lemma 4 and .


since is -Lipschitz. Therefore since .

If , then and the lemma holds trivially. For . . Thus . ∎

Theorem 5 (SGD under SSP, convergence in probability) Given convex function such that components are also convex. We search for minimizer via gradient descent on each component under SSP with staleness and workers. Let with . Under suitable conditions ( are -Lipschitz and bounded divergence ), we have

where , and .


From lemma A.1, substitute with we have

Where the last step uses the fact

(Lemma 4)

Dividing on both sides,