SYSTEMS, METHODS, AND COMPUTER-READABLE MEDIA FOR PARALLEL STOCHASTIC GRADIENT DESCENT WITH LINEAR AND NON-LINEAR ACTIVATION FUNCTIONS

Abstract

Systems, methods, and computer-readable media are disclosed for parallel stochastic gradient descent using linear and non-linear activation functions. One method includes: receiving a set of input examples; receiving a global model; and learning a new global model based on the global model and the set of input examples by iteratively performing the following steps: computing a plurality of local models having a plurality of model parameters based on the global model and at least a portion of the set of input examples; computing, for each local model, a corresponding model combiner based on the global model and at least a portion of the set of input examples; and combining the plurality of local models into the new global model based on the current global model and the plurality of corresponding model combiners.

Description

TECHNICAL FIELD

Embodiments of the present disclosure relate generally to training machine learning models. More specifically, embodiments of the present disclosure relate to machine learning models that may be trained using parallel stochastic gradient descent algorithms with linear and non-linear activation functions.

INTRODUCTION

In Stochastic Gradient Descent (“SGD”), a machine learning model training system operates iteratively to determine values of the model parameters by finding a minimum of an objective function of parameters of the model. SGD is an effective method for many machine learning problems. SGD is an algorithm with few hyper-parameters, and SGD's convergence rates are well understood both theoretically and empirically. However, SGD performance scalability may be severely limited by its inherently sequential computation. SGD iteratively processes an input dataset, in which each iteration's computation depends on model parameters learned from a previous iteration.

Current approaches for parallelizing SGD allow for learning local models per thread, and then combining these models in ways that do not honor this inter-step dependence. For example, in current approaches to parallelize SGD, such as HOGWILD!, threads, in a race-like manner, update a shared global model without holding any locks. In another approach, such as parameter-server, each thread (or machine) may periodically send its model deltas to a server that applies the model deltas to a global model, even though the model deltas were computed on a stale model from previous updates.

While these algorithms in current approaches may be guaranteed to eventually converge, the current approaches need to carefully manage the communication staleness trade-off. For example, HOGWILD! communicates after processing every input example to achieve a bounded staleness. However, the resulting communication cost limits scalability even in a single machine on sparse datasets. As shown in experiments, even sparse datasets have frequent features that produce significant cache traffic. In other current approaches, such as ALLREDUCE, staleness causes a drop in accuracy on the same number of examples with respect to a sequential baseline.

Thus, there exists a need to provide a parallel SGD algorithm that allows threads to communicate less frequently, but also achieve a high-fidelity approximation to what the threads would have produced had they run sequentially.

SUMMARY OF THE DISCLOSURE

According to certain embodiments, systems, methods, and computer-readable media are disclosed for parallel stochastic gradient descent with linear and non-linear activation functions.

According to certain embodiments, computer-implemented methods for parallel stochastic gradient descent using linear and non-linear activation functions are disclosed. One method includes: receiving a set of input examples, the set of examples including a plurality of vectors of feature values and a corresponding label to learn; receiving a global model, the global model used to compute a plurality of local models based on the set of input examples; and learning a new global model based on the global model and the set of input examples by iteratively performing the following steps: computing a plurality of local models having a plurality of model parameters based on the global model and at least a portion of the set of input examples; computing, for each local model, a corresponding model combiner based on the global model and at least a portion of the set of input examples; and combining the plurality of local models into the new global model based on the current global model and the plurality of corresponding model combiners.

According to certain embodiments, systems for parallel stochastic gradient descent using linear and non-linear activation functions are disclosed. One system including: a data storage device that stores instructions for parallel stochastic gradient descent using linear and non-linear activation functions; and a processor configured to execute the instructions to perform a method including: receiving a set of input examples, the set of examples including a plurality of vectors of feature values and a corresponding label to learn; receiving a global model, the global model used to compute a plurality of local models based on the set of input examples; and learning a new global model based on the global model and the set of input examples by iteratively performing the following steps: computing a plurality of local models having a plurality of model parameters based on the global model and at least a portion of the set of input examples; computing, for each local model, a corresponding model combiner based on the global model and at least a portion of the set of input examples; and combining the plurality of local models into the new global model based on the current global model and the plurality of corresponding model combiners.

According to certain embodiments, non-transitory computer-readable media storing instructions that, when executed by a computer, cause the computer to perform a method for parallel stochastic gradient descent using linear and non-linear activation functions are disclosed. One computer-readable medium storing instructions that, when executed by a computer, cause the computer to perform the method including: receiving a set of input examples, the set of examples including a plurality of vectors of feature values and a corresponding label to learn; receiving a global model, the global model used to compute a plurality of local models based on the set of input examples; and learning a new global model based on the global model and the set of input examples by iteratively performing the following steps: computing a plurality of local models having a plurality of model parameters based on the global model and at least a portion of the set of input examples; computing, for each local model, a corresponding model combiner based on the global model and at least a portion of the set of input examples; and combining the plurality of local models into the new global model based on the current global model and the plurality of corresponding model combiners.

Additional objects and advantages of the disclosed embodiments will be set forth in part in the description that follows, and in part will be apparent from the description, or may be learned by practice of the disclosed embodiments. The objects and advantages of the disclosed embodiments will be realized and attained by means of the elements and combinations particularly pointed out in the appended claims.

It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the disclosed embodiments, as claimed.

BRIEF DESCRIPTION OF THE DRAWINGS

In the course of the detailed description to follow, reference will be made to the attached drawings. The drawings show different aspects of the present disclosure and, where appropriate, reference numerals illustrating like structures, components, materials and/or elements in different figures are labeled similarly. It is understood that various combinations of the structures, components, and/or elements, other than those specifically shown, are contemplated and are within the scope of the present disclosure.

Moreover, there are many embodiments of the present disclosure described and illustrated herein. The present disclosure is neither limited to any single aspect nor embodiment thereof, nor to any combinations and/or permutations of such aspects and/or embodiments. Moreover, each of the aspects of the present disclosure, and/or embodiments thereof, may be employed alone or in combination with one or more of the other aspects of the present disclosure and/or embodiments thereof. For the sake of brevity, certain permutations and combinations are not discussed and/or illustrated separately herein.

FIG. 1 depicts a convex error function for a two-dimensional feature space, according to embodiments of the present disclosure;

FIGS. 2A and 2B depict graphs that plot singular values of a model combiner, according to embodiments of the present disclosure;

FIGS. 3A-3F depict graphs showing differences between parallel SGD algorithms of the present disclosure (Async-SYMSGD and MR-SYMSGD) and HOGWILD! for various exemplary datasets;

FIGS. 4A-4F depict graphs showing differences between parallel SGD algorithms of the present disclosure (Async-SYMSGD and MR-SYMSGD) and HOGWILD! for various exemplary datasets;

FIG. 5 depicts a method for parallel stochastic gradient descent using linear and non-linear functions, according to embodiments of the present disclosure;

FIG. 6 depicts a method for a map-reduce version of parallel stochastic gradient descent using linear and non-linear functions, according to embodiments of the present disclosure;

FIG. 7 depicts a method for an asynchronous version of parallel stochastic gradient descent using linear and non-linear functions, according to embodiments of the present disclosure.

FIG. 8 depicts a high-level illustration of an exemplary computing device that may be used in accordance with the systems, methods, and computer-readable media disclosed herein, according to embodiments of the present disclosure; and

FIG. 9 depicts a high-level illustration of an exemplary computing system that may be used in accordance with the systems, methods, and computer-readable media disclosed herein, according to embodiments of the present disclosure.

Again, there are many embodiments described and illustrated herein. The present disclosure is neither limited to any single aspect nor embodiment thereof, nor to any combinations and/or permutations of such aspects and/or embodiments. Each of the aspects of the present disclosure, and/or embodiments thereof, may be employed alone or in combination with one or more of the other aspects of the present disclosure and/or embodiments thereof. For the sake of brevity, many of those combinations and permutations are not discussed separately herein.

DETAILED DESCRIPTION OF THE EMBODIMENTS

One skilled in the art will recognize that various implementations and embodiments of the present disclosure may be practiced in accordance with the specification. All of these implementations and embodiments are intended to be included within the scope of the present disclosure.

As used herein, the terms “comprises,” “comprising,” “have,” “having,” “include,” “including,” or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements, but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. The term “exemplary” is used in the sense of “example,” rather than “ideal.” Additionally, the term “or” is intended to mean an inclusive “or” rather than an exclusive “or.” That is, unless specified otherwise, or clear from the context, the phrase “X employs A or B” is intended to mean any of the natural inclusive permutations. For example, the phrase “X employs A or B” is satisfied by any of the following instances: X employs A; X employs B; or X employs both A and B. In addition, the articles “a” and “an” as used in this application and the appended claims should generally be construed to mean “one or more” unless specified otherwise or clear from the context to be directed to a singular form.

For the sake of brevity, conventional techniques related to systems and servers used to conduct methods and other functional aspects of the systems and servers (and the individual operating components of the systems) may not be described in detail herein. Furthermore, the connecting lines shown in the various figures contained herein are intended to represent exemplary functional relationships and/or physical couplings between the various elements. It should be noted that many alternative and/or additional functional relationships or physical connections may be present in an embodiment of the subject matter.

Reference will now be made in detail to the exemplary embodiments of the disclosure, examples of which are illustrated in the accompanying drawings. Wherever possible, the same reference numbers will be used throughout the drawings to refer to the same or like parts.

The present disclosure generally relates to, among other things, a parallel Stochastic Gradient Descent (“SGD”) algorithm that allows threads to communicate less frequently and achieve a high-fidelity approximation to what the threads would have produced had the threads run sequentially. A key aspect of the parallel SGD algorithm of the present disclosure is for each thread to generate a sound model combiner that precisely captures the first-order effects of a SGD computation starting from an arbitrary model. Periodically, the threads may update a global model with their local model while using a model combiner to account for changes in the global model that occurred in the interim.

While the parallel SGD algorithm may be generalized to different machine learning problems and on different parallel settings, such as distributed clusters and GPUs, the present disclosure describes techniques in the context of evaluation on linear learners on multi-core machines, which may be primarily motivated by the fact that this setting forms the core of machine learning presently. For example, some developers have trained over one (1) million models per month in 2016 on single-node installations. Likewise, a 2015 survey has shown almost 50% of Spark installations are single-node. As machines with terabytes of memory become commonplace, machine learning tasks on large datasets may be done efficiently on single machines without paying the inherent cost of distribution. Thus, the present disclosure discusses the parallel SGD algorithm being evaluated on linear learners on multi-core machines. However, the present disclosure may not be limited to such systems, and may be applicable to different parallel settings, such as distributed clusters and GPUs, as described in more detail below. A person of ordinary skill in the art may apply the techniques described herein to other environments and systems.

The present disclosure relates to a parallel SGD (sometimes referred to as Symbolic SGD or SYMGSD) that is fast, scales well on multiple cores, and achieves the same accuracy as a sequential SGD. When compared to optimized sequential baseline, the SYMGSD of the present disclosure may achieve a speedup on a multi-core system, such as, for example, from a 8.3 times speedup to a 11 times speedup on a 16 core system. Thus, a speedup on average is observed when compared to current approaches discussed above, such as, for example, a speedup of 2.25 times over HOGWILD!

In a parallel SGD algorithm of the present disclosure, a set of N input examples z_i=(x_i, y_i) may be given. x_i may be a vector of feature values (f), and y_i may be a label to learn. A convex cost function to minimize may be represented by

$\begin{array}{cc}C\left(w\right)=\frac{1}{N}\sum _{i=1}^NC_{z_i}\left(w,x_i,y_i\right)& \left(1\right)\end{array}$

Accordingly, an object of the present disclosure is to find

$\begin{array}{cc}{w}^{*}=\underset{w\in {ℝ}^f}{\arg \min }\frac{1}{N}\sum _{i=1}^NC_{z_i}\left(w,x_i,y_i\right)& \left(2\right)\end{array}$

The cost function may optionally include a regularization term. Gradients may be defined as

$G\stackrel{\Delta }{=}\frac{\partial C}{\partial w}\mathrm{and}G_{z_r}\stackrel{\Delta }{=}\frac{\partial C_{z_r}}{\partial w},$

and Hessian of the cost function may be defined as

$H\stackrel{\Delta }{=}\frac{\partial G}{\partial w}\mathrm{and}H_{z_r}\stackrel{\Delta }{=}\frac{\partial G_{z_r}}{\partial w}.$

At each step t, the parallel SGD may pick z_r=(x_r, y_r) uniformly randomly from the input dataset, and may update the current model w_t along the gradient G_zr, as represented by the equation:

w _t+1 =w _t−α_tG_zr(w_t, x_r, y_r)   (3)

α_t may represent a learning rate that determines a magnitude of the update along the gradient. As equation 3 shows, w_t+1 may be dependent on w_t, and this dependence may make parallelization of SGD across iterations difficult.

FIG. 1 depicts a convex error function for a two-dimensional feature space, according to embodiments of the present disclosure. As shown in FIG. 1, the difficulty of making parallelization of SGD across iterations depicted. For instance, a processor may perform SGD on a sequence of examples D₁ from a global model w_g to reach w₁. When processing a subsequent sequence D₂, a sequential SGD algorithm may necessarily start from w₁ to reach w_h. According to embodiments of the present disclosure, it may be desired to process D₁ and D₂ in parallel. However, the computation on D₂ may not start on w₁, which is known only after the computation on D₁ has completed.

As mentioned in the introduction above, current parallelization techniques, such as HOGWILD! and ALLREDUCE approach this problem by processing D₁ and D₂ starting from the same global model w_g, and respectively reaching the local models w₁ and w₂. Then, current parallelization techniques combine the local models w₁ and w₂ into a global model, but in an ad-hoc manner. For instance, ALLREDUCE computes a weighted average w_a (see, FIG. 1) of w₁ and w₂, where the per-feature weights are chosen so as to prefer the processor that has a larger update for that feature. However, the ALLREDUCE approached does not necessarily reach w_h. w_h being the model that a traditional sequential SGD would have produced. Alternatively, HOGWILD! attempts to avoid this staleness problem by frequently communicating after every input example (i.e., size of D₁ and D₂ is 1). However, a resulting communication cost hurts scalability particularly across multiple sockets. This is true even for sparse datasets due to the presence of frequently occurring features.

According to embodiments of the present disclosure, a parallel SGD (symbolic SGD/SYMSGD) may soundly combine local models to produce the same model as what a sequential SGD would have produced. Accordingly, as shown in FIG. 1, the parallel SGD of the present disclosure may provide a method to combine w₁ and w₂ into the global model w_h. The parallel SGD of the present disclosure may be required to adjust the computation of D₂ for the staleness w₁−w_g in the starting model.

In order to adjust the computation of D₂, a second processor may perform a computation from w_g+Δw, where Δw may be an unknown symbolic vector. This may allow for the second processor to both compute a local model (resulting from the concrete part) and a model combiner (resulting from the symbolic part) that accounts for changes in the initial state. Once both processors are done calculating, the second processor may find w_h by setting Δw to w₁−w_g, where w₁ is computed by the first processor. This parallelization approach of SGD may be extended to multiple processors where all processor produce a local model and a combiner (except for the first processor) and the local models are combined sequentially using the combiners.

A SGD computation of dataset D starting from w may be represented by S_D(w). Thus, for example, for local model w₁, w₁=S_D1(w_g), as shown in FIG. 1. To generate the model combiner, S_D(w+Δw), may be determined. Assuming that S_D is differentiable, a Taylor series expansion may be:

S _D(w+Δw)=S_D(w)+S′_D(w)·Δw+O(∥Δw∥₂²)   (4)

$M_D\stackrel{\Delta }{=}S_D^{\prime }=\frac{\partial S}{\partial w}$

may be defined as the model combined. In equation (4) above, the model combiner may capture a first order effect of how a Δw change in w_g may affect the SGD computation. For example, by using Δw=w₁−w_g in equation (4), the local models, as shown in FIG. 1, may be combined to generate w_h.

Further, when Δw is sufficiently small, the second order term may be neglected, and the model combiner may be used to combine local models with sufficient fidelity.

Model combiners may provide flexibility to design parallel SGD algorithms. As explain in more detail below, model combiners allow for a parallel SGD using map-reduce functionality and allow for a parallel SGD using asynchronous functionality. In model combiners that allow for a parallel SGD to use map-reduce functionality, for the map phase, each processor i ∈ [1, N] may start from the same global model w_g, and each processor may compute a local model S_Di(w_g) and a model combiner M_Di(w_g) in parallel. In a subsequent reduce phase, the local models may be combined by adjusting the input of processor i by w_i−1−w_g, as indicated by the equation below:

w _i =S _{D i} (w_g)+M_Di(w_g)·(w_i−1−w_g)   (5)

Machine learning algorithms, such as linear regression, linear regression with L2 regularization, and polynomial regression may have a linear update to the model parameters, but not necessarily linear on the input example). In such cases, the higher order terms in equation (4) may vanish. Accordingly, for such machine learning algorithms, model combiners may generate exactly the same model as a sequential SGD.

Specifically, a standard linear regression with square loss machine learning algorithm, the combiner matrix may be given by:

$\begin{array}{cc}{M}_D\left(w\right)=\prod _{i=n}^1\left(I-{\alpha }_i·x_i·x_i^T\right)& \left(6\right)\end{array}$

when computing on D=(x₁, y₁), . . . , (x_n, y_n).

Since the model combiner may be independent of w, the model combiner may be computed once and may be reused in subsequent phases provided that the learning rates do not change.

Further, for a logistic regression machine learning algorithm, which has a update rule:

w _i =w _i−1−α·(σ(x_i·w_i−1)−y_i)·x_i   (7)

where σ may be the sigmoid function, the model combiner may be given by:

$\begin{array}{cc}{M}_D\left(w\right)=\prod _{i=n}^1\left(I-{\alpha }_i·{\sigma }^{\prime }\left(x_i·w_{i-1}\right)·x_i·x_i^T\right)& \left(8\right)\end{array}$

where w₀=w.

The model combiner for logistic regression may be a model combiner generated for linear regression but with α scaled by σ′(x_i·w_i−1).

Table 1 provides model combiners for linear learners. When the SGD update function is not differentiable, using the Taylor expansion in equation (4) may result in errors at points of discontinuity. However, assuming bounded gradients, these errors may not affect the convergence of the parallel SGD (SYMSGD) of the present disclosure, as discussed above.

TABLE 1
		Model Combiner
Algorithm	SGD Update for z = (x,y)	Mz(w,x,y,α)
OLS	w − α(x · w − y)	I − α · x · xT
Logistic	w − α(σ(x · w) − y)	I − ασ′(x · w) · x ·
		xT
Perceptron	w + α(y · x · δy·x·w≤0)	I
Support	w − α(λw − y · x · δx·w>1)	(1 − αλ)I
Vector
Machine
(“SVM”)
Lasso	[max(0, ui ≙ wi − α(λ +	[δui>0 (δi = j −
	s(i)(y − w · x))xi]i	αs(i)xixj)ij

For linear learners of Table 1, λ>0 may be an additional hyper-parameter and δ_ϕ may be 1 when ϕ is true, else δ_ϕ may be 0. In a Lasso linear learner, the model w may include positive w₊ and negative w₋ features with s(i) denoting the sign of feature i. [v_i]_i may describe a vector with v_i as the ith element and [m_ij]_ij may represent a matrix with m_ij as the (i,j)th element.

A challenge in using model combiners, as described above, may be that the model combiners are large f×f matrices. Machine learning problems may involve learning over tens of thousands to billions of features. Thus, it may be impossible to represent the model combiner explicitly. As described below, mechanisms may address the problem.

Accordingly, in embodiments of the present disclosure, a model combiner matrix may be projected into a smaller dimension while maintaining its fidelity. While the projection may generate an unbiased estimate of the model combiner, the model combiner's variance may affect convergence. As discussed above regarding convergence, it may be shown that with appropriate bounds on this variance, convergence may be guaranteed.

In embodiments of the present disclosure, a combiner matrix M_D in a parallel SGD (SYMSGD) may be used and/or only used to be multiplied with a Δw. In order to avoid representing M_D explicitly, M_D·A may be maintained for a randomly generated f×k matrix A with k«f. Then, M_D·Δw may be estimated with M_D·A·A^T·Δw. When the estimation is unbiased, the following may be observed.

[m_ij]_ij may represent a matrix with m_ij as an element in the ith row and jth column. A=[a_ij]_ij may be a random f×k matrix with a_ij=d_ij/√{square root over (k)} where d_ij may be independently sampled from a random distribution D with E[D]=0 and Var[D]=1. Then, E[A·A^T]=I_f×f, which may be based on the proof as follows. If B=[b_ij]_ijA·A^T, then

$E\left[b_{\mathrm{ij}}\right]=\frac{1}{k}\sum _kE\left[a_{\mathrm{ik}}a_{\mathrm{jk}}\right].$

When i≠j, E[b_ij]=0 as a_ik and a_jk may be independent random variables with mean 0, and E[b_ij]=1 as the variance of a_ii is 1.

Thus, the model combination with equation (27), as discussed below, may become:

w_i≈S_Di(w_g)+M_Di(w_g)·A·A^T(w_i−1−w_g)   (9)

Equation (9) may allow for an efficient algorithm that computes a projected version of the combiner matrix, while still producing the same answer as the sequential SGD algorithm in expectation. Accordingly, the projection may incur a space and time overhead of O(z×k) where z may be a number of non-zeros in an example, x_i. The overhead may be acceptable for a small value of k. In exemplary embodiments of the present disclosure discussed in more detail below, k may be between values of 7 to 15 in various benchmarks and remain acceptable. Additionally, the overhead for such a small value k may be hidden by utilizing Single Instruction, Multiple Data (“SIMD”) hardware within a processor. For example, as discussed in more detail below, the parallel SGD of the present disclosure (SYMSGD) with one thread may be half as slow as the sequential SGD.

After learning a local model and a projected model combiner in each processor, the parallel SGD of the present disclosure (SYMSGD) may combine the resulting local models using the projected model combiners. Additionally, optimizations, as follows, may be employed to improve efficiency. Note, that a subset of the data, D_k, may include a subset of total number of features. Embodiments of the present disclosure may take advantage of this property, and may allocate and initialize A for these observed features.

An unbiased estimation, as discussed above, may only be useful when a variance of the approximation is acceptably small. The variance of the projection described above may be determined as follows. A trace of a matrix M, tr(M) may be the sum of the diagonal elements of the matrix. λ_i(M) may be the ith eigenvalue of M, and σ_i(M)=√{square root over (λ_i(M^T·M))} the ith singular value of M. M·σ_max(M) may be a maximum singular value of M. With v=M·A·A^T·Δw, then, the trace of a covariance matrix tr(((v)) may be bounded by equation (10), as proven in more detail below.

$\begin{array}{cc}\mathrm{tr}\left(ℂ\left(v\right)\right)\ge \frac{{\Delta w}_2^2}{k}\sum _i{\sigma }_i^2\left(M\right)\mathrm{tr}\left(ℂ\left(v\right)\right)\le \frac{{\Delta w}_2^2}{k}\left(\sum _i{\sigma }_i^2\left(M\right)+{\sigma }_{\max }^2\left(M\right)\right)& \left(10\right)\end{array}$

Accordingly, the covariance may be small when k, which is the dimension of the projected space, is large. However, increasing k may proportionally increase the overhead of the parallel SGD algorithm. Similarly, covariance may be small when the projection happens on a small Δw. With respect to equation (9) above, w_i−1 may be as close to w_g as possible, which may imply that processors may need to communicate frequently enough to ensure that their respective models may be roughly in-sync. Additionally, singular values of M may be as small as possible. Discussed in more detail below is an optimization that allows for the frequent communication and small values of M.

Variance and Covariance of

$\frac{1}{r}M·A·A^T·\Delta w.$

For simplicity below, w may be used instead of Δw, and r may be used instead of k for the size of the projected space. k may be used for summation indices. v=M·w may be estimated with

$\frac{1}{r}M·A·A^T·w,$

where A is a f×r matrix, where a_ij is a random variable with the following properties: E(a_ij)=0, E(a_ij²)=1, and E(a_ij⁴)=ρ=3. m_s^T may be some row of M. Its estimation in

$M·w\mathrm{is}v_s=\frac{1}{r}·m_s^T·A·A^T·w.$

From the above, E(v_s)=m_s^T·w. The notation ij=kl to is used to mean i=k Λ j=1, and the notation ij≠kl is used to mean its negation. m_s, m_t may be two rows of M, and the covariance of the resulting v_s and v_t is to be found.

$\begin{array}{cc}{r}^2·E\left(v_s,v_t\right)=r^2·E\left(\frac{1}{r^2}\sum _{i,j,k}m_{\mathrm{si}}a_{\mathrm{ij}}a_{\mathrm{kj}}w_k·\sum _{i^{\prime },j^{\prime },k^{\prime }}m_{{\mathrm{ti}}^{\prime }}a_{i^{\prime }j^{\prime }}a_{k^{\prime }j^{\prime }}w_{k^{\prime }}\right)=\sum _{i,j,k,i^{\prime },j^{\prime },k^{\prime }}m_{\mathrm{si}}m_{{\mathrm{ti}}^{\prime }}w_kw_{k^{\prime }}E\left(a_{\mathrm{ij}}a_{\mathrm{kj}}a_{i^{\prime }j^{\prime }}a_{k^{\prime }j^{\prime }}\right)=\sum _{i,j,k,i^{\prime },j^{\prime },k^{\prime }:\mathrm{ij}=\mathrm{kj}=i^{\prime }j^{\prime }=k^{\prime }j^{\prime }}m_{\mathrm{si}}m_{{\mathrm{ti}}^{\prime }}w_kw_{k^{\prime }}E\left(a_{\mathrm{ij}}a_{\mathrm{kj}}a_{i^{\prime }j^{\prime }}a_{k^{\prime }j^{\prime }}\right)+\sum _{i,j,k,i^{\prime },j^{\prime },k^{\prime }:\mathrm{ij}=\mathrm{kj}\ne i^{\prime }j^{\prime }=k^{\prime }j^{\prime }}m_{\mathrm{si}}m_{{\mathrm{ti}}^{\prime }}w_kw_{k^{\prime }}E\left(a_{\mathrm{ij}}a_{\mathrm{kj}}a_{i^{\prime }j^{\prime }}a_{k^{\prime }j^{\prime }}\right)+\sum _{i,j,k,i^{\prime },j^{\prime },k^{\prime }:\mathrm{ij}=i^{\prime }j^{\prime }\ne \mathrm{kj}=k^{\prime }j^{\prime }}m_{\mathrm{si}}m_{{\mathrm{ti}}^{\prime }}w_kw_{k^{\prime }}E\left(a_{\mathrm{ij}}a_{\mathrm{kj}}a_{i^{\prime }j^{\prime }}a_{k^{\prime }j^{\prime }}\right)+\sum _{i,j,k,i^{\prime },j^{\prime },k^{\prime }:\mathrm{ij}=k^{\prime }j^{\prime }\ne i^{\prime }j^{\prime }=\mathrm{kj}}m_{\mathrm{si}}m_{{\mathrm{ti}}^{\prime }}w_kw_{k^{\prime }}E\left(a_{\mathrm{ij}}a_{\mathrm{kj}}a_{i^{\prime }j^{\prime }}a_{k^{\prime }j^{\prime }}\right)\mathrm{as}\mathrm{terms}\mathrm{with}E\left(a_{\mathrm{ij}}\right)\mathrm{cancel}\mathrm{out}=\sum _{i,j}m_{\mathrm{si}}m_{\mathrm{ti}}w_iw_i\rho +\sum _{i,j,i^{\prime },j^{\prime }:\mathrm{ij}\ne i^{\prime }j^{\prime }}m_{\mathrm{si}}m_{{\mathrm{ti}}^{\prime }}w_iw_{i^{\prime }}+\sum _{i,j,k:i\ne k}m_{\mathrm{si}}m_{\mathrm{ti}}w_kw_k+\sum _{i,j,k:i\ne k}m_{\mathrm{si}}m_{\mathrm{tk}}w_kw_i\mathrm{as}E\left(a_{\mathrm{ij}}a_{\mathrm{kl}}\right)=1\mathrm{when}\mathrm{ij}\ne \mathrm{kl}=\rho \sum _{i,j}m_{\mathrm{si}}m_{\mathrm{ti}}w_i^2+\sum _{i,j,i^{\prime },j^{\prime }}m_{\mathrm{si}}m_{{\mathrm{ti}}^{\prime }}w_iw_i^{\prime }-\sum _{i,j,i^{\prime },j^{\prime }:\mathrm{ij}=i^{\prime }j^{\prime }}m_{\mathrm{si}}m_{{\mathrm{ti}}^{\prime }}w_iw_{i^{\prime }}+\sum _{i,j,k}m_{\mathrm{si}}m_{\mathrm{ti}}w_k^2-\sum _{i,j,k:i=k}m_{\mathrm{si}}m_{\mathrm{ti}}w_k^2+\sum _{i,j,k}m_{\mathrm{si}}m_{\mathrm{tk}}w_kw_i-\sum _{i,j,k:i=k}m_{\mathrm{si}}m_{\mathrm{tk}}w_kw_i=\left(\rho -3\right)\sum _{i,j}m_{\mathrm{si}}m_{\mathrm{ti}}w_i^2+\sum _{i,j,i^{\prime },j^{\prime }}m_{\mathrm{si}}m_{{\mathrm{ti}}^{\prime }}w_iw_{i^{\prime }}+\sum _{i,j,k}m_{\mathrm{si}}m_{\mathrm{ti}}w_k^2+\sum _{i,j,k}m_{\mathrm{si}}m_{\mathrm{tk}}w_kw_i=r^2\sum _{i,i^{\prime }}m_{\mathrm{si}}m_{{\mathrm{ti}}^{\prime }}w_iw_{i^{\prime }}+r\sum _{i,k}m_{\mathrm{si}}m_{\mathrm{ti}}w_k^2+r\sum _{i,k}m_{\mathrm{si}}m_{\mathrm{tk}}w_iw_k\mathrm{as}\rho =3\mathrm{and}j\in \left[1\dots k\right]=\left(r^2+r\right)\sum _{i,i^{\prime }}m_{\mathrm{si}}m_{{\mathrm{ti}}^{\prime }}w_iw_{i^{\prime }}+r·m_s^T·m_t\sum _kw_k^2& \left(11\right)\end{array}$

In other words:

$\begin{array}{cc}E\left(v_sv_t\right)=\left(1+\frac{1}{r}\right)\sum _{i,i^{\prime }}m_{\mathrm{si}}m_{{\mathrm{ti}}^{\prime }}w_iw_{i^{\prime }}+\frac{1}{r}·m_s^T·m_t\sum _kw_k^2& \left(12\right)\end{array}$

The covariance Cov(a,b)=E(a·b)−E(a)E(b). Using this:

$\begin{array}{cc}\mathrm{Cov}\left(v_s,v_t\right)=\left(1+\frac{1}{r}\right)\sum _{i,i^{\prime }}m_{\mathrm{si}}m_{{\mathrm{ti}}^{\prime }}w_iw_{i^{\prime }}+\frac{1}{r}·m_s^T·m_t\sum _kw_k^2-E\left(v_s\right)E\left(v_t\right)=\left(1+\frac{1}{r}\right)\sum _{i,i^{\prime }}m_{\mathrm{si}}m_{{\mathrm{ti}}^{\prime }}w_iw_{i^{\prime }}+\frac{1}{r}·m_s^T·m_t\sum _kw_k^2-E\left(v_s\right)E\left(v_t\right)=\left(1+\frac{1}{r}\right)E\left(v_s\right)E\left(v_t\right)+\frac{1}{r}·m_s^T·m_t\sum _kw_k^2-E\left(v_s\right)E\left(v_t\right)=\frac{1}{r}E\left(v_s\right)E\left(v_t\right)+\frac{1}{r}·m_s^T·m_t\sum _kw_k^2=\frac{1}{r}E\left(v_s\right)E\left(v_t\right)+\frac{1}{r}·{\left(M·M^T\right)}_{\mathrm{st}}{w}_2^2=\frac{1}{r}{\left(M·w\right)}_s{\left(M·w\right)}_t+\frac{1}{r}·{\left(M·M^T\right)}_{\mathrm{st}}{w}_2^2=\frac{1}{r}{\left(\left(M·w\right)·{\left(M·w\right)}^T\right)}_{\mathrm{st}}+\frac{1}{r}·{\left(M·M^T\right)}_{\mathrm{st}}{w}_2^2& \left(13\right)\end{array}$

(v) may be the covariance of v. That is, (v)_ij=Cov(v_i, v_j). So:

$\begin{array}{cc}ℂ\left(v\right)=\frac{1}{r}\left(M·w\right)·{\left(M·w\right)}^T+\frac{1}{r}\left(M·M^T\right){w}_2^2& \left(14\right)\end{array}$

Note that this computation may be used for matrix N=M−I as well since nothing was assumed about the matrix M from the beginning. Therefore,

$v^{\prime }=w+\frac{1}{r}N·A·A^T·w,ℂ\left(v^{\prime }\right)=\frac{1}{r}\left(N·w\right)·{\left(N·w\right)}^T+\frac{1}{r}\left(N·N^T\right){w}_2^2$

since w is a constant in v′ and (a+x)=(x) for any constant vector a and any probabilistic vector x.

As mentioned above, the trace of a covariance matrix tr((v)) may be bounded as shown by equation (10). (v) may be bounded by computing its trace since tr((v))=Σ_ivar(v_i), which is a summation of the variance of elements of v.

$\begin{array}{cc}\begin{array}{c}\mathrm{tr}\left(ℂ\left(\upsilon \right)\right)=\frac{1}{4}\mathrm{tr}\left(\left(M·w\right)·{\left(M·w\right)}^T\right)+\frac{1}{r}{w}_2^2\left(MM^T\right)\\ =\frac{1}{r}{M·w}_2^2+\frac{1}{r}{w}_2^2\left(\sum _i{\lambda }_i\left(M·M^T\right)\right)\\ =\frac{1}{r}{M·w}_2^2+\frac{1}{r}{w}_2^2\left(\sum _i{{\sigma }_i\left(M\right)}^2\right)\end{array}& \left(15\right)\end{array}$

where λ_iM·M^T is the ith largest eigenvalue of M·M^T, which is a square of the ith largest singular value of M, σ_i(M)².

Since ∥M·w∥₂²≤∥w∥₂²∥M∥₂²=∥w∥₂²σ_max(M)², tr((v)) may be bounded as follows:

$\begin{array}{cc}\mathrm{tr}\left(ℂ\left(\upsilon \right)\right)\le \frac{1}{r}\left({{\sigma }_{\max }\left(M\right)}^2\right)+\frac{1}{r}{w}_2^2\left(\sum _i{{\sigma }_i\left(M\right)}^2\right)& \left(16\right)\end{array}$

Thus:

$\begin{array}{cc}\frac{1}{r}{w}_2^2\left(\sum _i{{\sigma }_i\left(M\right)}^2\right)\le \mathrm{tr}\left(ℂ\left(\upsilon \right)\right)& \left(17\right)\end{array}$

Combining the two inequalities yields;

$\begin{array}{cc}\frac{1}{r}{w}_2^2\left(\sum _i{{\sigma }_i\left(M\right)}^2\right)\le \mathrm{tr}\left(ℂ\left(\upsilon \right)\right)\frac{1}{r}\left({{\sigma }_{\max }\left(M\right)}^2\right)+\frac{1}{r}{w}_2^2\left(\sum _i{{\sigma }_i\left(M\right)}^2\right)& \left(18\right)\end{array}$

Accordingly, the same bounds may be derived when N=M−I is used. Subtracting I from a model combiner results in a matrix with a small rank. Thus, most of its singular values may be zero. The model combiner may be assumed to be generated for a linear learner, and thus the model combiner may be of the form Π_i(I−αx_ix_i^T), where any non-linear scalar terms from the Hessian may be factored into α.

For a matrix M_a→b=Π_i=b^a(I−αx_ix_i^T), rank M_a→b≤b−a. Proof may be by induction. A base case may be when a=b and M_a→b=I. Thus, I=I=0, which may be a rank zero. For induction, assume that rank M_a→b−1−I≤b−a−1. Accordingly:

$\begin{array}{cc}\begin{array}{c}{M}_{a\to b}-I=\left(I-\alpha x_b·x_b^T\right)M_{a\to b-1}-I\\ =\left(M_{a\to b-1}-I\right)-\alpha x_b·\left(x_b^T·M_{a\to b-1}\right)\end{array}& \left(19\right)\end{array}$

The term αx_b·(x_b^T·M_a→b−1) may be a rank −1 matrix, and the term (M_a→b−1−I) may be of a rank b−a−1 by induction hypothesis. Since for any two matrices A and B, rank(A+B)≤rank(A)+rank(B)≤rank(M_a→b−1−I)+rank(−αx_b·x_b^T·(M_a→b−1))≤b−a−1+1=b−a.

Equation (43), as discussed below, suggests that when α_i is small, a model combiner M_D(w) may be dominated by the I term. From the equations above, the combiner matrix M_D(w) may be generated from n examples, M_D(w)−I may have at most n non-zero singular values. Because each processor may operate on a subset of data, it may be likely that n examples«f features. These observations may be used to lower a variance of dimensionality reduction by projecting the matrix N_D instead of M_D. This optimization allows for the scalability of the parallel SGD of the present disclosure (SYMSGD). With the optimization the model combiner update becomes”

w_i≈S_Di(w_g)+w_i−1−w_g+N_Di(w_g)·A·A^T·(w_i−1−w_g)   (20)

From the proof discussed above, approximation above may be guaranteed to be unbiased.

An important factor in controlling the singular values of N_Dk(w_g) may be a frequency of model combinations, which may be a tunable parameter in the parallel SGD of the present disclosure (SYMSGD). As shown below, with more communication, the smaller the singular values of N_Dk(w_g), the less variance (error) in equation (16).

As discussed below, convergence may be guaranteed when neglecting the higher order terms under certain general assumptions of the cost function, provided ∥Δw∥₂ is bound. For example, a sequence w₀, w₁, . . . , w_t may represent a sequence of weight vectors produced by a sequential SGD run. As shown in FIG. 1, this sequence may converge to a desired minimum w*. A parallel SGD according to embodiments of the present disclosure may also converge to w*. A process that processes example sequences D, starting with model w_t−Δw, which is Δw different from the “true” model w_t that a sequential SGD would have started with. The output of this processor may be as follows:

w _t+1 =S _D(w_i−Δw)+M_DΔw   (21)

where the model combiner after the projection by taking the I off may be given as:

M _D =I+(S′_D(w_i−Δw)−I)AA^T   (22)

Accordingly, applying Taylor's theorem, for some 0≤μ≤1:

$\begin{array}{cc}{S}_D\left(w_t\right)=S_D\left(w_t-\Delta w\right)+S_D^{\prime }\left(w_t-\Delta w\right)\Delta w+\frac{1}{2}\Delta w^TS_D^{″}\left(w_t-\mu \Delta w\right)\Delta w& \left(23\right)\end{array}$

Comparing equation (23) with equation (21) may show that the parallel SGD of the present disclosure may introduce two error terms as compared to a sequential SGD.

w _t+1 =S _D(w_t)+FR_D(w_t, Δw)+SR_D(w_t, Δw)   (24)

where a first-order error term FR may come due to a projection approximation:

FR _D(w_t, Δw)=(I−S′_D(w_t−Δw))(I−AA^T)   (25)

and where a second-order error term SR may come due to neglecting the higher-order terms in the Taylor expansion.

$\begin{array}{cc}{\mathrm{SR}}_D\left(w_t,\Delta w\right)=\frac{1}{2}\Delta w^TS_D^{″}\left(w_t-\mu \Delta w\right)\Delta w& \left(26\right)\end{array}$

To prove convergence the parallel SGD of the present disclosure (SYMSGD), SGD may be shown to be robust with respect to adding these error terms. The proof may follow along the same lines as the convergence proof of present SGD algorithms. Below are assumptions and proofs to prove convergence.

Assuming that convexity of a cost function is:

(w−w*).G(w)>0   (27)

for w≠w*, and assuming bounded gradients, for any input z=(X, y),

∥G₁(w)∥₂≤b_G∥w−w*∥_w   (28)

for some b_G≥0.

Bounds on a mean and second moment of FR, are as follows:

E _A(FR_D(w_t, Δw))=0   (29)

E _A(∥FR_D(w_t, Δw)∥₂²)≤b_FR∥w_t−w*∥₂²   (30)

for some b_FR≥0.

Bounds on SR are as follows:

∥SR_D(w_t, Δw)∥₂≤b_SR∥w_i−w*∥₂   (31)

for some b_FR≥0.

Convergence of a parallel SGD of the present disclosure follows if the following equation converges to 0:

h _t =∥w _t −w*∥ ₂ ²   (32)

A worst case where error terms are added every step of the parallel SGD may be assumed. As noted above, the worst case as the error bounds from equations (29)-(31) may be for arbitrary steps. Thus, the sequence h_t converges to 0 almost surely, as discussed in detail below.

P_t denotes all the random choices made by the algorithm at time t. For terseness, the following notation for the conditional expectation with respect to P_t may be used:

CE(x)=E(x|P_t)   (33)

A key technical challenge may be in showing that an infinite sum of a positive expected variations in h_t is bounded, which may be shown below. z=(x, y) may be an example processed at time t. The following short hand is used:

$\begin{array}{cc}{R}_z\left(w_t,\Delta w\right)={\mathrm{FR}}_z\left(w_t,\Delta w\right)+{\mathrm{SR}}_z\left(w_t,\Delta w\right)& \left(34\right)\\ \begin{array}{c}\mathrm{CE}\left(h_{t+1}-h_t\right)=-2{\gamma }_t\left(w_t-w^{*}\right)\mathrm{CE}\left(G_z\left(w_t\right)+R_z\left(w_t,\Delta w\right)\right)+{\gamma }_t^2\mathrm{CE}\left({G_z\left(w_t\right)+R_z\left(w_t,\Delta w\right)}_2^2\right)\\ =-2{\gamma }_t\left(w_t-w^{*}\right)\left(G\left(w_t\right)+\mathrm{CE}\left(R_z\left(w_t,\Delta w\right)\right)\right)+{\gamma }_t^2\mathrm{CE}\left({G_z\left(w_t\right)+R_z\left(w_t,\Delta w\right)}_2^2\right)\\ \le -2{\gamma }_t\left(w_t-w^{*}\right)\mathrm{CE}\left(R_z\left(w_t,\Delta w\right)\right)+\\ {\gamma }_t^2\mathrm{CE}\left({G_z\left(w_t\right)+R_z\left(w_t,\Delta w\right)}_2^2\right)\left(\mathrm{from}\mathrm{equation}\left(27\right)\right)\\ \le -2{\gamma }_tb_{\mathrm{SR}}{w_t-w^{*}}_2^2+\\ {\gamma }_t^2\mathrm{CE}\left({G_z\left(w_t\right)+R_z\left(w_t,\Delta w\right)}_2^2\right)\left(\mathrm{from}\mathrm{equations}\left(29\right)\text{-}\left(31\right)\right)\\ \le {\gamma }_t^2\mathrm{CE}\left({G_z\left(w_t\right)+R_z\left(w_t,\Delta w\right)}_2^2\right)\\ ={\gamma }_t^2\mathrm{CE}\left({G_z\left(w_t\right)}_2^2\right)+\mathrm{CE}\left({R_z\left(w_t,\Delta w\right)}_2^2\right)+2\mathrm{CE}\left(G_z\left(w_t\right)R_z\left(w_t,\Delta w\right)\right))\\ \le {\gamma }_t^2(\left(b_G+b_{\mathrm{FR}}+b_{\mathrm{SR}}\right){w_t-w^{*}}_2^2+2\mathrm{CE}\left({\mathrm{FR}}_z\left(w_t,\Delta w\right){\mathrm{SR}}_z\left(w_t,\Delta w\right)\right)+\\ 2\mathrm{CE}\left(G_z\left(w_t\right)R_z\left(w_t,\Delta w\right)\right))\left(\mathrm{from}\mathrm{equations}\left(28\right)\text{-}\left(31\right)\right)\\ \le {\gamma }_t^2\left(\left(b_G+b_{\mathrm{FR}}+b_{\mathrm{SR}}\right){w_t-w^{*}}_2^2+2\mathrm{CE}\left(G_z\left(w_t\right){\mathrm{SR}}_z\left(w_t,\Delta w\right)\right)\right)\\ \left(\mathrm{as}\mathrm{FR}\mathrm{has}a\mathrm{zero}\mathrm{mean}\left(\mathrm{equations}\left(29\right)\mathrm{and}\left(30\right)\right)\mathrm{and}G,\mathrm{SR}\mathrm{do}\mathrm{not}\mathrm{depend}\mathrm{on}A\right)\\ \le {\gamma }_t^2\left(\left(b_G+b_{\mathrm{FR}}+b_{\mathrm{SR}}+2b_Gb_{\mathrm{SR}}\right){w_t-w^{*}}_2^2\right)\left(\mathrm{from}\mathrm{equations}\left(28\right)\mathrm{and}\left(31\right)\right)\end{array}& \end{array}$

In other words, for B=b_G+b_FR+b_SR+2b_Gb_SR, the follow:

CE(h_t+1−(I+γ_t²B)h_t)≤0   (35)

Auxiliary sequences

${\mu }_t=\prod _{i=1}^t\frac{1}{1+{\gamma }_i^2B}$

and h′_t=μ_th_t may be defined. Σ_tγ_t²<∞, μ_t may be assumed to converge to a nonzero value. Since equation (35) above may imply CE(h′_t+1−h′_t)≤0, from quasi-martingale convergence theorem, h′_t, and thus, h_t may converge almost surely. Under an additional assumption that Σ_tγ_t=∞, this convergence may be 0.

The proof above relies on equations (29)-(31), which are proven below based on the following assumptions and proof. The discussion may be restricted to linear learners and that the model combiners are of the form M_z(w)=(I−αH_z(w)xx^T) for a scalar Hessian H_z(w). Assuming the parallel SGD (SYMSGD) synchronizes sufficiently enough so the Δw does not grow too large:

∥Δw∥₂≤min(1, b_Δw∥w_t−w*∥₂)   (36)

for some b_Δw>0.

Assuming, bounded Hessian:

|H_z(w)|≤b_H   (37)

for some b_H>0.

The model combiner M_D(w)=Π_i(I−αH_z(w)x_ix_i^T) may have bounded eigenvalues, which follows from induction on i using the bounded Hessian of equation (37) above.

Bounds on the mean and second moment of FR of equations (29) and (30) may be proven, as explained in detail below. The second moment follows from the above, as applied to M and M^T, as explained in detail below.

Bounds on SR, as shown in equation (31), may be proven as follows. For linear learners:

$\begin{array}{cc}{S}_z\left(w\right)=w-\gamma G_z\left(x,w,y\right)·x& \left(38\right)\\ \frac{\partial S_z\left(w\right)}{\partial w}=I-\gamma H_z\left(x,w,y\right){\mathrm{xx}}^T& \left(39\right)\\ \frac{{\partial }^2S_z\left(w\right)}{\partial w^2}=H_z^{\prime }\left(x,w,y\right)x\otimes x\otimes x& \left(40\right)\end{array}$

where H is a second derivative of a cost with respect to x·w, and ⊗ is a tensor outer product.

As to the equation (40) above, if the input is composed of a previous SGD phase, then:

$\begin{array}{cc}\frac{{\partial }^2S_z\left(S_D\left(w\right)\right)}{\partial w^2}=H_z^{\prime }\left(S_D\left(x\right)·w,y\right)x\otimes x\otimes {x\left(\frac{\partial S_D\left(w\right)}{\partial w}\right)}^{T_x}& \left(41\right)\end{array}$

For notational convenience, let M_b→aΠ_i=b^a(I−αx_ix_i^T).

By explicitly differentiating S′_n(w):

$\begin{array}{cc}\frac{\partial S_n^{\prime }\left(w\right)}{\partial w}=\left(\sum _i\left(-{\alpha }_jH_j^{\prime }\left(s_j\left(w\right)\right)\right)M_{n\to j+1}x_jx_j^TM_{j\to 1}\right)\otimes \left({S_j^{\prime }\left(w\right)}^Tx\right)& \left(42\right)\end{array}$

Each element of SR_z may obtained by Δw^TPΔw where P is an outer product of a row from the first term above and S′_j(w)^Tx. Using the above twice, each of these vectors may be shown to be bounded.

To generate a model combiner, D=(z₁, z₂, . . . , z_n) may be a sequence of input examples and D_i may represent a subsequence (z₁, . . . , z_i). The model combiner may be given by:

$\begin{array}{cc}{M}_D\left(w\right)=\prod _{i=n}^1(I-{\alpha }_i·H_{z_i}\left(S_{D_{i-1}}\left(w\right),x_i,y_i\right)& \left(43\right)\end{array}$

with S_D0(w)=w, based on:

S _D(w)=S_zn(S_zn−1( . . . (S_z0(w))))   (44)

which follows from equation (3) above and the chain rule.

FIGS. 2A and 2B depict graphs that plot singular values of a model combiner M_D(w), according to embodiments of the present disclosure. In particular, FIG. 2A shows the distribution of singular values of model combiners for an exemplary data set, such as Reuters Corpus Volume I (“RCV1”) dataset, for logistic regression with α=0.01, and FIG. 2B shows the distribution of singular values of model combiners for an exemplary data set, such as RCV1 dataset, for linear regression with α=0.001. Each of the different lines shown in the graphs may correspond to different block sizes.

As mentioned above, the graphs of FIGS. 2A and 2B plot the singular values of a model combiner M_D(w) for RCV1 after processing 64, 128, 256, and 512 examples for logistic and linear regression. As depicted in FIGS. 2A and 2B, the singular values may be close to one (1). However, the singular values of N_D(w)=M_D(w)−I may be roughly the same as those of M_D(w) minus 1, and consequently, may be small. Further, a smaller α (not shown), the closer the singular values of the model combiner M_D(w) may be to one (1), and the singular values of N_D(w) may be close to zero (0). Also as shown in FIGS. 2A and 2B, the singular values of model combiner M_D(w) may decrease as the numbers of examples increase, and therefore, the singular values of N_D(w) may increase. As a result, the more frequent the models may be combined, the less variance (and error) may be introduced.

Discussed below are implementations of various parallel SGD algorithms according to embodiments of the present disclosure (SYMSGD). As described above, a map-reduce style version of the parallel SGD algorithm according to embodiments of the present disclosure was referred to as map-reduce SYMSGD and/or MR-SYMSGD. In contrast to MR-SYMSGD, HOGWILD! asynchronously updates model parameters.

Because the map-reduce SYMSGD accord to embodiments of the present disclosure may require computing model combiners, map-reduce SYMSGD may do more work than HOGWILD! Thus, map-reduce SYMSGD may be a constant factor slower than HOGWILD!

However, even sparse datasets have a frequently used subset of features, which may be likely to show up in many input examples. The frequent used subset of features can cause scalability issues for HOGWILD! When cache-lines are invalidated across sockets, which happens often for these frequently accessed subset, HOGWILD! can incur large overheads, which limit HOGWILD!'s scalability.

A parallel SGD algorithm according to embodiments of the present disclosure may blend asynchronous updates of infrequent model parameters with the map-reduce SYMSGD style updates for the frequent model parameters. The parallel SGD algorithm that blends asynchronous updates with the map-reduce SYMSGD style updates may be referred to as asynchronous SYMSGD and/or Async-SYMSGD.

Because the frequently accessed subset of features may be much smaller than the infrequently accessed subset of features, Async-SYMSGD has low-overhead. However, because cache-lines may not be invalidated as often, Async-SYMSGD may scale to multiple sockets.

An average NFNZ ratio (shown in Table 2 below) may be an average number of frequent features in each input example divided by a number of non-zero features in that input example. Thus, a value of zero (0) may mean all features are infrequent, and a value of one (1) may mean all features are frequent. A frequent feature may be defined as whether a particular feature shows up in at least ten percent (10%) of the input examples. At runtime, Async-SYMSGD may sample one thousand (1000) input examples to find frequent features, may build a model combiner for that subset, and may asynchronously update those features not in that subset.

Equation (4) shows that an error in SYMSGD may be dependent on the norm of Δw. Accordingly, the smaller the norm of Δw, the less the error. To control the norm of Δw may be done by limiting a number of examples that each processor sees before the processor combines its local model with the global model. This parameter may be referred to as the block size. Larger block size may allow the parallel SGD of the present disclosure (SYMSGD) to communicate less often and improve overall running time, but the larger block size may suffer in accuracy due to a size of Δw. Conversely, lower values for block size may exhibit better convergence, but overhead of model combination may affect the performance.

Block size may be set to a constant value per benchmark throughout the execution of the parallel SGD of the present disclosure (SYMSGD). In an alternative embodiment, block size may be set to dynamically adjust when to communicate by measuring the norm of Δw

While the computational complexity of computing a model combiner O(k) (where k<15 in all experiments), a k×slowdown may not be seen. Each processor may consecutively store each of the k vectors in A so the parallel SGD of the present disclosure (SYMSGD) may exploit good cache locality in addition to SIMD units. FIGS. 3A-3F depict graphs showing differences between parallel SGD algorithms of the present disclosure (Async-SYMSGD and MR-SYMSGD) and HOGWILD! for various exemplary datasets, according to embodiments of the present disclosure. In particular, FIGS. 3A-3F show speedup of logistic regression training when using Async-SYMSGD, MR-SYMSGD, and HOGWILD! on a sixteen (16) core machine. As shown in FIGS. 3A-3F, Async-SYMSGD, MR-SYMSGD, and HOGWILD! with one (1) processor have nearly zero (0) difference even though SYMSGD may do k times more work than HOGWILD!

Further, SYMSGD may use a sparse projection to reduce the overhead of computing A. Each element of A may independently be chosen from

$\left\{\frac{1}{3},-\frac{1}{3},0\right\}$

with a probability of

$\left\{\frac{1}{6},\frac{1}{6},\frac{2}{3}\right\},$

respectively.

According to embodiments of the present disclosure, experiments were performed on a machine including two Intel Xeon E5-2630 v3 processors clocked at 2.4 GHz with 256 GB of Random Access Memory (“RAM”). The machine includes two sockets with 8 cores for each processor, which allowed for a study of the scalability of the parallel SDG algorithms of the present disclosure across multiple sockets. Hyper-threading and turbo boosting of the processors was disabled. Threads were pinned to cores in a compact way, which means that thread i+1 was placed as close as possible to thread i. The above described machine runs Windows 10, and implementations were compiled with Intel C/C++ compiler 16.0 and relied heavily on Open Multi-Processing (“OpenMP”) primitives for parallelization and Math Kernal Library (“MKL”) for efficient linear algebra computations. Additionally, to measure runtime, an average of five independent runs was used on an otherwise idle machine.

As mentioned above, FIGS. 3A-3F depict graphs showing differences between parallel SGD algorithms of the present disclosure (Async-SYMSGD and MR-SYMSGD) and HOGWILD! for various exemplary datasets, according to embodiments of the present disclosure. For each, ordinary least squares (“OLS”) regression and logistic regression were experimented with. (See, Table 1 above for the model combiners).

FIGS. 4A-4F depict graphs showing differences between parallel SGD algorithms of the present disclosure (Async-SYMSGD and MR-SYMSGD) and HOGWILD! for various exemplary datasets, according to embodiments of the present disclosure. In particular, FIGS. 4A-4F show speedup of least squares regression training when using Async-SYMSGD, MR-SYMSGD, and HOGWILD! on a sixteen (16) core machine.

Discussed below are results for logistic regression. To study the scalability of a parallel algorithm, it is important to compare the algorithms against an efficient baseline. Otherwise, it may not be empirically possible to differentiate between the scalability achieved from the parallelization of the inefficiencies and the scalability inherent in the algorithm. The datasets used in experiments herein are described in Table 2, which includes various statistics of each benchmark.

TABLE 2
							SYMSGD	SYMSGD
				Average			speedup over	speedup over
	Number of	Number of	Average	NFNZ	AUC	AUC	HOGWILD!	HOGWILD!
Dataset	Features	Examples	NNZ	Ratio	Logistic	Linear	Logistic	Linear
RCV1	47153	781265	74.71	0.219	0.9586	0.959	2.6	2.6
AdClick	3076	499980	969.38	0.947	0.7443	0.7654	2.99	2.94
Epsilon	2000	400000	2000	1.00	0.9586	0.959	2.55	2.45
URL	3231961	1677282	111.62	0.765	0.9991	0.9986	1.90	1.04
Criteo	1703961	1000000	33.32	0.530	0.7627	0.7633	2.05	1.91
Webspam	16609143	279999	3727.75	0.693	0.9992	0.9909	1.43	1.78

For each algorithm and benchmark, a parameter sweep was done over the learning rate, α, and α was picked which gave the best area under the curve (often referred to as simply the “AUC”) after 10 passes over the data. For Async-SYMSGD and MR-SYMSGD, α was then fixed and swept over block size and k, and the configuration which maintained sequential accuracy up to the fourth digit was picked.

The last two columns of Table 2 summarize the speedup of Async-SYMSGD over HOGWILD! for both logistic and linear regression. As shown in the experimental results, Async-SYMSGD may be, on average, 2.25× faster than HOGWILD! A reason is that Async-SYMSGD of the present disclosure may be able to scale to multiple sockets because cache-traffic from the frequent subset of each example causes HOGWILD! to suffer scalability when moving from 8 to 16 cores. FIGS. 3A-3F and 4A-4F show this phenomenon in greater detail. A point on these graphs (x-axis, y-axis) shows the speedup of Async-SYMSGD, MR-SYMSGD, and HOGWILD!, respectively, (y-axis) as a function of the number of threads (x-axis). In

Each benchmark indicates that HOGWILD! is slower on 16 threads than 8 (with the exception of the Webspam dataset where performance stays roughly constant). In contrast both Async-SYMSGD and MR-SYMSGD scale across sockets roughly linearly. Because Async-SYMSGD uses a model combiner only for those frequently accessed subset of features, Async-SYMSGD's overhead may be lower than MR-SYMSGD's. Thus, Async-SYMSGD may be consistently faster than MR-SYMSGD. The results are similar for linear regression with the exception of URL: Async-SYMSGD stops scaling at 8 threads, like HOGWILD!

FIGS. 5-7 depict exemplary methods for parallel stochastic gradient descent using linear and non-linear functions, according to embodiments of the present disclosure. While the methods are shown and described as being a series of acts that are performed in a sequence, it is to be understood and appreciated that the methods are not limited by the order of the sequence. For example, some acts may occur in a different order than what is described herein. In addition, an act may occur concurrently with another act. Further, in some embodiments, not all acts may be required to implement methods described herein.

Moreover, the acts described herein may be computer-executable instructions that may be implemented by one or more processors and/or stored on a non-transitory computer-readable medium or media. The computer-executable instructions may include a routine, a sub-routine, programs, a thread of execution, and/or the like. Still further, results of acts of the methods may be stored in a non-transitory computer-readable medium, displayed on a display device, and/or the like.

FIG. 5 depicts a method 500 for parallel stochastic gradient descent using linear and non-linear functions, according to embodiments of the present disclosure. Method 500 may begin at step 502 where a set of input examples may be received. The set of examples may include a plurality of vectors of feature values and a corresponding label to learn. A stochastic gradient descent algorithm may iteratively process the input dataset in which computation at each iteration may depend on model parameters learned from the previous iteration. At step 504, the method may receive a global model, the global model used to compute a plurality of local models based on the set of input examples. Periodically, the global model may be updated with the local models while using the model combiner to account for changes in the global model that occurred in the interim.

Upon receiving the set of input examples and the global model, a new global model may be learned based on the global model and the set of input examples by iteratively performing the following steps at step 506. Each global model may be dependent on a previous model, and may make parallelization of stochastic gradient descent across iterations difficult. Using model combiners with local models allows for the models to be combined into a new global model.

At step 508, a plurality of local models having a plurality of model parameters may be computed based on the global model and at least a portion of the set of input examples. The plurality of model parameters may be linearly updated based on a machine learning algorithm including one or more of linear regression, linear regression with L2 regularization, and polynomial regression. Additionally, and/or alternatively, the plurality of model parameters may be non-linearly updated based on a machine learning algorithm including logistic regression. At step 510 for each local model, a corresponding model combiner may be computed based on the global model and at least a portion of the set of input examples. Additionally, and/or alternatively, for each local model, a corresponding projected model combiner may be computed based on the global model and at least a portion of the set of input examples. The model combiners may be large f×f matrices. Machine learning problems may involve learning over tens of thousands to billions of features, and thus, a model combiner may not be explicitly represented. Accordingly, as discussed above, a projected model combiner may be used to project the model combiner matrix into a smaller dimension while maintaining its fidelity.

Then at step 512, the plurality of local models may be combined into the new global model based on the current global model and the corresponding plurality of model combiners and/or the corresponding plurality of projected model combiners.

FIG. 6 depicts a method 600 for a map-reduce version of parallel stochastic gradient descent using linear and non-linear functions, according to embodiments of the present disclosure.

Method 600 may begin at step 602 where a set of input examples may be received. The set of examples may include a plurality of vectors of feature values and a corresponding label to learn. A stochastic gradient descent algorithm may iteratively process the input dataset in which computation at each iteration may depend on model parameters learned from the previous iteration. At step 604, the method may receive a global model, the global model used to compute a plurality of local models based on the set of input examples. Periodically, the global model may be updated with the local models while using the model combiner to account for changes in the global model that occurred in the interim.

Upon receiving the set of input examples and the global model, a new global model may be learned based on the global model and the set of input examples by iteratively performing the following steps at step 606. Each global model may be dependent on a previous model, and may make parallelization of stochastic gradient descent across iterations difficult. Using model combiners with local models allows for the models to be combined into a new global model.

At step 608, during a map phase, a plurality of local models having a plurality of model parameters may be computed based on the global model and at least a portion of the set of input examples, and, for each local model, a corresponding model combiner based on the global model and at least a portion of the set of input examples. The plurality of model parameters may be linearly updated based on a machine learning algorithm including one or more of linear regression, linear regression with L2 regularization, and polynomial regression. Additionally, and/or alternatively, the plurality of model parameters may be non-linearly updated based on a machine learning algorithm including logistic regression. Additionally, and/or alternatively, for each local model, a corresponding projected model combiner may be computed based on the global model and at least a portion of the set of input examples. The model combiners may be large f×f matrices. Machine learning problems may involve learning over tens of thousands to billions of features, and thus, a model combiner may not be explicitly represented. Accordingly, as discussed above, a projected model combiner may be used to project the model combiner matrix into a smaller dimension while maintaining its fidelity.

Then at step 610, during a reduce phase, the plurality of local models may be combined into a new global model based on the current global model and the plurality of corresponding model combiners and/or the corresponding plurality of projected model combiners.

FIG. 7 depicts a method 700 for an asynchronous version of parallel stochastic gradient descent using linear and non-linear functions, according to embodiments of the present disclosure.

Method 700 may begin at step 702 where a set of input examples may be received. The set of examples may include a plurality of vectors of feature values and a corresponding label to learn. A stochastic gradient descent algorithm may iteratively process the input dataset in which computation at each iteration may depend on model parameters learned from the previous iteration. At step 704, the method may receive a global model, the global model used to compute a plurality of local models based on the set of input examples. Periodically, the global model may be updated with the local models while using the model combiner to account for changes in the global model that occurred in the interim. At step 706, the method may sample at least a portion of the set of input examples to determine and/or find frequent feature values. For each frequent feature value found, the map reduce version of the parallel stochastic gradient descent algorithm may be used. For each infrequent feature value, the features may be asynchronously updated.

For frequent features values, upon receiving the set of input examples and the global model, a new global model may be learned based on the global model and the set of input examples by iteratively performing the following steps at step 708. Each global model may be dependent on a previous model, and may make parallelization of stochastic gradient descent across iterations difficult. Using model combiners with local models allows for the models to be combined into a new global model.

At step 710, for each frequent feature value during a map phase, a plurality of local models having a plurality of model parameters may be computed based on the global model and at least a portion of the set of input examples, and, for each local model, a corresponding model combiner based on the global model and at least a portion of the set of input examples. The plurality of model parameters may be linearly updated based on a machine learning algorithm including one or more of linear regression, linear regression with L2 regularization, and polynomial regression. Additionally, and/or alternatively, the plurality of model parameters may be non-linearly updated based on a machine learning algorithm including logistic regression. Additionally, and/or alternatively, for each local model, a corresponding projected model combiner may be computed based on the global model and at least a portion of the set of input examples. The model combiners may be large f×f matrices. Machine learning problems may involve learning over tens of thousands to billions of features, and thus, a model combiner may not be explicitly represented. Accordingly, as discussed above, a projected model combiner may be used to project the model combiner matrix into a smaller dimension while maintaining its fidelity. Further, each infrequent feature may be updated asynchronously, as discussed above.

Then at step 712, for each frequent feature value during a reduce phase, the plurality of local models may be combined into a new global model based on the current global model and the plurality of corresponding model combiners and/or the corresponding plurality of projected model combiners. For each infrequent feature value asynchronously update the plurality of model parameters. A frequent feature value may be a particular feature that shows up in at least 10% of the set of input examples. Additionally, or alternatively, other frequency determinations may be used to determine a whether a feature value is a frequent feature value, such as 5%, 10%, 15%, 20%, 25%, etc.

FIG. 8 depicts a high-level illustration of an exemplary computing device 800 that may be used in accordance with the systems, methods, and computer-readable media disclosed herein, according to embodiments of the present disclosure. For example, the computing device 800 may be used in a system that performs parallel stochastic gradient descent using linear and non-linear activation functions, according to embodiments of the present disclosure. The computing device 800 may include at least one processor 802 that executes instructions that are stored in a memory 804. The instructions may be, for example, instructions for implementing functionality described as being carried out by one or more components discussed above or instructions for implementing one or more of the methods described above. The processor 802 may access the memory 804 by way of a system bus 806. In addition to storing executable instructions, the memory 804 may also store snapshots, event logs, and so forth.

The computing device 800 may additionally include a data store 808 that is accessible by the processor 802 by way of the system bus 806. The data store 808 may include executable instructions, data, examples, features, etc. The computing device 800 may also include an input interface 810 that allows external devices to communicate with the computing device 800. For instance, the input interface 810 may be used to receive instructions from an external computer device, from a user, etc. The computing device 800 also may include an output interface 812 that interfaces the computing device 800 with one or more external devices. For example, the computing device 800 may display text, images, etc. by way of the output interface 812.

It is contemplated that the external devices that communicate with the computing device 800 via the input interface 810 and the output interface 812 may be included in an environment that provides substantially any type of user interface with which a user can interact. Examples of user interface types include graphical user interfaces, natural user interfaces, and so forth. For example, a graphical user interface may accept input from a user employing input device(s) such as a keyboard, mouse, remote control, or the like and may provide output on an output device such as a display. Further, a natural user interface may enable a user to interact with the computing device 800 in a manner free from constraints imposed by input device such as keyboards, mice, remote controls, and the like. Rather, a natural user interface may rely on speech recognition, touch and stylus recognition, gesture recognition both on screen and adjacent to the screen, air gestures, head and eye tracking, voice and speech, vision, touch, gestures, machine intelligence, and so forth.

Additionally, while illustrated as a single system, it is to be understood that the computing device 800 may be a distributed system. Thus, for example, several devices may be in communication by way of a network connection and may collectively perform tasks described as being performed by the computing device 800.

Turning to FIG. 9, FIG. 9 depicts a high-level illustration of an exemplary computing system 900 that may be used in accordance with the systems, methods, and computer-readable media disclosed herein, according to embodiments of the present disclosure. For example, the computing system 900 may be or may include the computing device 800. Additionally, and/or alternatively, the computing device 800 may be or may include the computing system 900.

The computing system 900 may include a plurality of server computing devices, such as a server computing device 902 and a server computing device 904 (collectively referred to as server computing devices 902-904). The server computing device 902 may include at least one processor and a memory; the at least one processor executes instructions that are stored in the memory. The instructions may be, for example, instructions for implementing functionality described as being carried out by one or more components discussed above or instructions for implementing one or more of the methods described above. Similar to the server computing device 902, at least a subset of the server computing devices 902-904 other than the server computing device 902 each may respectively include at least one processor and a memory. Moreover, at least a subset of the server computing devices 902-904 may include respective data stores.

Processor(s) of one or more of the server computing devices 902-904 may be or may include the processor, such as processor 802. Further, a memory (or memories) of one or more of the server computing devices 902-904 can be or include the memory, such as memory 804. Moreover, a data store (or data stores) of one or more of the server computing devices 902-904 may be or may include the data store, such as data store 808.

The computing system 900 may further include various network nodes 906 that transport data between the server computing devices 902-904. Moreover, the network nodes 906 may transport data from the server computing devices 902-904 to external nodes (e.g., external to the computing system 900) by way of a network 908. The network nodes 902 may also transport data to the server computing devices 902-904 from the external nodes by way of the network 908. The network 908, for example, may be the Internet, a cellular network, or the like. The network nodes 906 may include switches, routers, load balancers, and so forth.

A fabric controller 910 of the computing system 900 may manage hardware resources of the server computing devices 902-904 (e.g., processors, memories, data stores, etc. of the server computing devices 902-904). The fabric controller 910 may further manage the network nodes 906. Moreover, the fabric controller 910 may manage creation, provisioning, de-provisioning, and supervising of managed runtime environments instantiated upon the server computing devices 902-904.

As used herein, the terms “component” and “system” are intended to encompass computer-readable data storage that is configured with computer-executable instructions that cause certain functionality to be performed when executed by a processor. The computer-executable instructions may include a routine, a function, or the like. It is also to be understood that a component or system may be localized on a single device or distributed across several devices.

Various functions described herein may be implemented in hardware, software, or any combination thereof. If implemented in software, the functions may be stored on and/or transmitted over as one or more instructions or code on a computer-readable medium. Computer-readable media may include computer-readable storage media. A computer-readable storage media may be any available storage media that may be accessed by a computer. By way of example, and not limitation, such computer-readable storage media can comprise RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to store desired program code in the form of instructions or data structures and that can be accessed by a computer. Disk and disc, as used herein, may include compact disc (“CD”), laser disc, optical disc, digital versatile disc (“DVD”), floppy disk, and Blu-ray disc (“BD”), where disks usually reproduce data magnetically and discs usually reproduce data optically with lasers. Further, a propagated signal is not included within the scope of computer-readable storage media. Computer-readable media may also include communication media including any medium that facilitates transfer of a computer program from one place to another. A connection, for instance, can be a communication medium. For example, if the software is transmitted from a website, server, or other remote source using a coaxial cable, fiber optic cable, twisted pair, digital subscriber line (“DSL”), or wireless technologies such as infrared, radio, and microwave, then the coaxial cable, fiber optic cable, twisted pair, DSL, or wireless technologies such as infrared, radio and microwave are included in the definition of communication medium. Combinations of the above may also be included within the scope of computer-readable media.

Alternatively, and/or additionally, the functionality described herein may be performed, at least in part, by one or more hardware logic components. For example, and without limitation, illustrative types of hardware logic components that may be used include Field-Programmable Gate Arrays (“FPGAs”), Application-Specific Integrated Circuits (“ASICs”), Application-Specific Standard Products (“ASSPs”), System-on-Chips (“SOCs”), Complex Programmable Logic Devices (“CPLDs”), etc.

What has been described above includes examples of one or more embodiments. It is, of course, not possible to describe every conceivable modification and alteration of the above devices or methodologies for purposes of describing the aforementioned aspects, but one of ordinary skill in the art can recognize that many further modifications and permutations of various aspects are possible. Accordingly, the described aspects are intended to embrace all such alterations, modifications, and variations that fall within the scope of the appended claims.

Claims

1. A computer-implemented method for parallel stochastic gradient descent using linear and non-linear activation functions, the method comprising: receiving a set of input examples, the set of examples including a plurality of vectors of feature values and a corresponding label to learn;receiving a global model, the global model used to compute a plurality of local models based on the set of input examples; andlearning a new global model based on the global model and the set of input examples by iteratively performing the following steps: computing a plurality of local models having a plurality of model parameters based on the global model and at least a portion of the set of input examples;computing, for each local model, a corresponding model combiner based on the global model and at least a portion of the set of input examples; andcombining the plurality of local models into the new global model based on the current global model and the plurality of corresponding model combiners.

2. The method according to claim 1, wherein the plurality of model parameters are linearly updated based on a machine learning algorithm including one or more of linear regression, linear regression with L2 regularization, polynomial regression, ordinary least squares (“OLS”), perceptron, support vector machine, (“SVM”), and lasso.

3. The method according to claim 1, wherein the plurality of model parameters is non-linearly updated based on a machine learning algorithm including logistic regression.

4. The method according to claim 1, wherein computing, for each local model, a corresponding model combiner includes: computing, for each local model, a corresponding projected model combiners based on the global model and at least a portion of the set of input examples.

5. The method according to claim 1, wherein learning the plurality of local models based on the global model and the set of input examples by iteratively performing the following steps includes: during a map phase, computing a plurality of local models having a plurality of model parameters based on the global model and at least a portion of the set of input examples, and computing, for each local model, a corresponding model combiner based on the global model and at least a portion of the set of input examples; andduring a reduce phase, combining the plurality of local models into a new global model based on the current global model and the plurality of corresponding model combiners.

6. The method according to claim 1, further comprising: sampling the set of input examples to determine frequent feature values,wherein learning the new global model based on the global model and the set of input examples includes: for each frequent feature value during a map phase, computing a plurality of local models having a plurality of model parameters based on the global model and at least a portion of the set of input examples, and computing, for each local model, a corresponding model combiner based on the global model and at least a portion of the set of input examples; andfor each frequent feature value during a reduce phase, combining the plurality of local models into a new global model based on the current global model and the plurality of corresponding model combiners.

7. The method according to claim 6, further comprising: for each infrequent feature value asynchronously update the plurality of model parameters.

8. A system for parallel stochastic gradient descent using linear and non-linear activation functions, the system including: a data storage device that stores instructions for parallel stochastic gradient descent using linear and non-linear activation functions; anda processor configured to execute the instructions to perform a method including: receiving a set of input examples, the set of examples including a plurality of vectors of feature values and a corresponding label to learn;receiving a global model, the global model used to compute a plurality of local models based on the set of input examples; andlearning a new global model based on the global model and the set of input examples by iteratively performing the following steps: computing a plurality of local models having a plurality of model parameters based on the global model and at least a portion of the set of input examples;computing, for each local model, a corresponding model combiner based on the global model and at least a portion of the set of input examples; andcombining the plurality of local models into the new global model based on the current global model and the plurality of corresponding model combiners.

9. The system according to claim 8, wherein the plurality of model parameters are linearly updated based on a machine learning algorithm including one or more of linear regression, linear regression with L2 regularization, polynomial regression, ordinary least squares (“OLS”), perceptron, support vector machine, (“SVM”), and lasso.

10. The system according to claim 8, wherein the plurality of model parameters is non-linearly updated based on a machine learning algorithm including logistic regression.

11. The system according to claim 8, wherein computing, for each local model, a corresponding model combiner includes: computing, for each local model, a corresponding projected model combiners based on the global model and at least a portion of the set of input examples.

12. The system according to claim 8, wherein learning the plurality of local models based on the global model and the set of input examples by iteratively performing the following steps includes: during a map phase, computing a plurality of local models having a plurality of model parameters based on the global model and at least a portion of the set of input examples, and computing, for each local model, a corresponding model combiner based on the global model and at least a portion of the set of input examples; andduring a reduce phase, combining the plurality of local models into a new global model based on the current global model and the plurality of corresponding model combiners. 13 The system according to claim 8, wherein the processor is further configured to execute the instructions to perform the method including:sampling the set of input examples to determine frequent feature values,wherein learning the new global model based on the global model and the set of input examples includes: for each frequent feature value during a map phase, computing a plurality of local models having a plurality of model parameters based on the global model and at least a portion of the set of input examples, and computing, for each local model, a corresponding model combiner based on the global model and at least a portion of the set of input examples; andfor each frequent feature value during a reduce phase, combining the plurality of local models into a new global model based on the current global model and the plurality of corresponding model combiners.

14. The system according to claim 12, wherein the processor is further configured to execute the instructions to perform the method including: for each infrequent feature value asynchronously update the plurality of model parameters.

15. A non-transitory computer-readable medium storing instructions that, when executed by a computer, cause the computer to perform a method for parallel stochastic gradient descent using linear and non-linear activation functions, the method including: receiving a set of input examples, the set of examples including a plurality of vectors of feature values and a corresponding label to learn;receiving a global model, the global model used to compute a plurality of local models based on the set of input examples; andlearning a new global model based on the global model and the set of input examples by iteratively performing the following steps: computing a plurality of local models having a plurality of model parameters based on the global model and at least a portion of the set of input examples;computing, for each local model, a corresponding model combiner based on the global model and at least a portion of the set of input examples; andcombining the plurality of local models into the new global model based on the current global model and the plurality of corresponding model combiners.

16. The computer-readable medium according to claim 15, wherein the plurality of model parameters are linearly updated based on a machine learning algorithm including one or more of linear regression, linear regression with L2 regularization, polynomial regression, ordinary least squares (“OLS”), perceptron, support vector machine, (“SVM”), and lasso.

17. The computer-readable medium according to claim 15, wherein the plurality of model parameters is non-linearly updated based on a machine learning algorithm including logistic regression.

18. The computer-readable medium according to claim 15, wherein computing, for each local model, a corresponding model combiner includes: computing, for each local model, a corresponding projected model combiners based on the global model and at least a portion of the set of input examples.

19. The computer-readable medium according to claim 15, wherein learning the plurality of local models based on the global model and the set of input examples by iteratively performing the following steps includes: during a map phase, computing a plurality of local models having a plurality of model parameters based on the global model and at least a portion of the set of input examples, and computing, for each local model, a corresponding model combiner based on the global model and at least a portion of the set of input examples; andduring a reduce phase, combining the plurality of local models into a new global model based on the current global model and the plurality of corresponding model combiners.

20. The computer-readable medium according to claim 15, wherein the instructions that, when executed by the computing system, cause the computing system to perform the method further including: sampling the set of input examples to determine frequent feature values,wherein learning the new global model based on the global model and the set of input examples includes: for each frequent feature value during a map phase, computing a plurality of local models having a plurality of model parameters based on the global model and at least a portion of the set of input examples, and computing, for each local model, a corresponding model combiner based on the global model and at least a portion of the set of input examples; andfor each frequent feature value during a reduce phase, combining the plurality of local models into a new global model based on the current global model and the plurality of corresponding model combiners.