Asynchronous Parallel Stochastic Quasi-Newton Methods

Abstract

Although first-order stochastic algorithms, such as stochastic gradient descent, have been the main force to scale up machine learning models, such as deep neural nets, the second-order quasi-Newton methods start to draw attention due to their effectiveness in dealing with ill-conditioned optimization problems. The L-BFGS method is one of the most widely used quasi-Newton methods. We propose an asynchronous parallel algorithm for stochastic quasi-Newton (AsySQN) method. Unlike prior attempts, which parallelize only the calculation for gradient or the two-loop recursion of L-BFGS, our algorithm is the first one that truly parallelizes L-BFGS with a convergence guarantee. Adopting the variance reduction technique, a prior stochastic L-BFGS, which has not been designed for parallel computing, reaches a linear convergence rate. We prove that our asynchronous parallel scheme maintains the same linear convergence rate but achieves significant speedup. Empirical evaluations in both simulations and benchmark datasets demonstrate the speedup in comparison with the non-parallel stochastic L-BFGS, as well as the better performance than first-order methods in solving ill-conditioned problems.

1. Introduction

With the immense growth of data in modern life, developing parallel or distributed optimization algorithms has become a well-established strategy in machine learning, such as the widely used stochastic gradient descent (SGD) algorithm and its variants [1, 2, 3, 4, 5, 6, 7]. Because gradient-based algorithms have deficiencies (e.g., zigzagging) with ill-conditioned optimization problems (elongated curvature), second-order algorithms that utilize curvature information have drawn research attention. The most well-known second-order algorithm is a set of quasi-Newton methods, particularly the Broyden-Fletcher-Goldfarb-Shanno (BFGS) method and its limited memory version (L-BFGS) [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]. Second-order methods have several advantages over first-order methods, such as fast rate of local convergence (typically superlinear) [21], and affine invariance (not sensitive to the choice of coordinates).

Stochastic algorithms have been extensively studied and substantially improved the scalability of machine learning models. Particularly, stochastic first-order methods have been a big success for which convergence is guaranteed when assuming the expectation of stochastic gradient is the true gradient. In contrast, second-order algorithms cannot directly use stochastic sampling techniques without losing the curvature information. Several schemes have been proposed to develop stochastic versions of quasi-Newton methods. Stochastic quasi-Newton method (SQN) [22] uses independent large batches for updating Hessian inverse. Stochastic block BFGS [23] calculates subsampled Hessian-matrix product instead of Hessian-vector product to preserve more curvature information. These methods achieve a sub-linear convergence rate in the strongly convex setting. Using the variance reduction (VR) technique proposed in [24], the convergence rate can be lifted up to linear in the latest attempts [25, 23]. Later, acceleration strategies [26] are combined with VR, non-uniform mini-batch subsampling, momentum calculation to derive a fast and practical stochastic algorithm. Another line of stochastic quasi-Newton studies tries to focus on solving self-concordant functions, which requires more on the shape or property of objective functions, can reach a linear convergence rate. Stochastic adaptive quasi-Newton methods for self-concordant functions have been proposed in [27], where the step size can be computed analytically, using only local information, and adapts itself to the local curvature. [28] gives a global convergence rate for a stochastic variant of the BFGS method combined with stochastic gradient descent. Other researchers use randomized BFGS [19] as a variant of stochastic block BFGS and prove the linear convergence rate under self-concordant functions. However, so far all these stochastic methods have not been designed for parallel computing.

Parallel quasi-Newton methods have been explored in several directions: map-reduce (vector-free L-BFGS) [29] has been used to parallelize the two-loop recursion (See more discussion in Section 2) in a deterministic way; the distributed L-BFGS [35] is focused on the implementation of L-BFGS over high performance computing cluster (HPCC) platform, e.g. how to distribute data such that a full gradient or the two-loop recursion can be calculated fast. As a successful trial to create both stochastic and parallel algorithms, multi-batch L-BFGS [30] uses map-reduce to compute both gradients and updating rules for L-BFGS. The idea of using overlapping sets to evaluate curvature information helps if a node failure is encountered. However, the size of overlapping is large, reshuffling and redistributing data among nodes may need costly communications. Progressive batching L-BFGS [31] gradually increases the batch size instead of using the full batch in the multi-batch scheme to improve the computational efficiency. Another line of work explores the decentralized quasi-Newton methods (Decentralized BFGS) [32, 33]. Taking physical network structure into consideration, the nodes communicate only with their neighbors and perform local computations. Recently, the distributed averaged quasi-Newton methods and the adaptive distributed variants (DAve-QN) have been implemented in [34], which can be very efficient for low dimensional problems because that they need to read and write the whole Hessian matrix during updating. Notice that in the analysis of DAve-QN method, they have a strong requirement for condition number of the objective functions in Lemma 2 of [34], which is hard to satisfied in most real datasets. However, when dealing with machine learning problems under big datasets, or considering the possibility of node failures, deterministic algorithms like the decentralized ones perform no better than stochastic ones.

1.1. Contributions

In this paper, we prepare an asynchronous parallel regime of SQN method with the VR technique, which we call AsySQN. The comparison of our method against existing methods is illustrated in Table 1. AsySQN aims to design a stochastic and parallel process for every step during calculating the search directions. To the best of our knowledge, this is the first effort in implementing the SQN methods in an asynchronous parallel way instead of directly using some local acceleration techniques. The basic idea of asynchronous has been explored by first-order methods, but it is not straightforward to apply to stochastic quasi-Newton methods, and not even clear if such a procedure converges. We provide a theoretical guarantee of a linear convergence rate for the proposed algorithm. Notice that even though there is another commonly used way of lifting the convergence rate, by exploring the self-concordant functions, we choose to use the VR technique so that we can have more general objective functions when conducting experiments. In addition, we remove the requirement of gradients sparsity in previous methods [2, 6]. Although we focus on the L-BFGS method, the proposed framework can be applied to other quasi-Newton methods including BFGS, DFP, and the Broyden family [36]. In our empirical evaluation, we show that the proposed algorithm is more computational efficient than its non-parallel counterpart. Additional experiments are conducted to show that AsySQN maintains the property of a quasi-Newton method that is to obtain a solution with high precision faster on ill-conditioned problems than first-order methods without zigzagging.

Table 1:

The comparison of various quasi-Newton methods in terms of their stochastic, parallel, asynchronous frameworks, convergence rates, and if they use a variance reduction technique and limited memory update of BFGS method to make it work well for high dimensional problem. Here, our algorithm AsySQN is designed for paralleling the whole L-BFGS method in shared memory.

QN methods	Stochastic	Parallel	Asy	VR	High dimensional	Convergence
[22]	✓				✓	sublinear
[25]	✓			✓	✓	linear
[23]	✓			✓	✓	linear
[26]	✓			✓	✓	linear
[29]		parallel two-loop recursion			✓	–
[30]	✓	map reduce for gradient			✓	sublinear
[31]	✓	map reduce for gradient		✓	✓	linear
[32, 33]		parallel calculation for gradient	✓			–
[34]		parallel calculation for Hessian	✓			superlinear
AsySQN	✓	parallel model for L-BFGS	✓	✓	✓	linear

1.2. Notations

The Euclidean norm of vector x is denoted by ∥x∥₂, and without loss of generality, we omit the subscript 2 and use ∥x∥. We use x* to denote the global optimal solution of Eq.(2). For simplicity, we also use f* to be the corresponding optimal value f(x*). The notation E[·] means taking the expectation in terms of all random variables, and I denotes the identity matrix. The condition number of a matrix A is defined by $\kappa (A)=\frac{{\sigma }_{max}(A)}{{\sigma }_{min}(A)}$, where σ_max(A) and σ_min(A) denote, respectively, the largest and the smallest singular values of A. For square matrices A and B of the same size, A ⪯ B, iff B − A is positive semidefinite. Given two numbers $a\in \mathbb{Z}$ (integers), $b\in {\mathbb{Z}}^{+}$ (positive intergers), mod(a, b) = 0, if there exists an integer k satisfying a = kb.

2. Algorithm

In this paper, we consider the following finite-sum problem :

$$f(x)≔\frac{1}{n}\sum _{i=1}^{n}f(x;z_i)\stackrel{def}{=}\frac{1}{n}\sum _{i=1}^n{f}_i(x),$$ (1)

Algorithm 1 AsySQN

$$\begin{array}{cc}\hfill & 1:\mathrm{Input}:\text{Initial}{w}_0\in R^d,\text{step size}\eta \in R^{+},\text{subsample size}\hfill \\ \hfill & b,b_h,\text{parameter}m,L,M,\text{and threads number}P.\hfill \\ \hfill & 2:\text{Initialize}{H}_0=I\hfill \\ \hfill & 3:\text{Initialize parameter}x\text{in shared memory}\hfill \\ \hfill & 4:\mathbf{for}k=0,1,2,\dots \mathbf{do}\hfill \\ \hfill & 5:w_{k,}{\mu }_k=ScheduleUpdate(x,k,m)(\text{Algorithm 2})\hfill \\ \hfill & 6:\mathbf{for}p=0,1,\dots P-1,\mathbf{parallel}\mathbf{do}\hfill \\ \hfill & 7:\mathbf{for}t=0\mathbf{to}L-1\mathbf{do}\hfill \\ \hfill & 8:\text{Sample}{S}_{p,kL+t}\in \{1,2,..,n\}\hfill \\ \hfill & 9:\text{Read}x\text{from shared memory as}{x}_{p,kL+t}\hfill \\ \hfill & 10:\text{Compute}{g}_1=\nabla f_{S_{p,kL+t}}(x_{p,kL+t})\hfill \\ \hfill & 11:\text{Compute}{g}_2=\nabla f_{S_{p,kL+t}}(x_k)\hfill \\ \hfill & 12:\text{Calculate the variance-reduced gradient:}\hfill \\ \hfill & v_{p,kL+t}=g_1-g_2+{\mu }_k\hfill \\ \hfill & 13:\mathbf{if}k\le 1\mathbf{then}\hfill \\ \hfill & 14:x_{p,kL+t+1}=x_{p,kL+t}-\eta v_{p,kL+t}\hfill \\ \hfill & 15:\mathbf{else}\hfill \\ \hfill & 16:x_{p,kL+t+1}=x_{p,kL+t}-\eta H_k{v}_{p,kL+t}\hfill \\ \hfill & 17:\text{where the search direction}p=-H_k{v}_{p,kL+t}\hfill \\ \hfill & \text{is computed by the}Two\text{-}loop\text{-}recursion(v_{p,kL+t},s_i,y_i,\forall i=\hfill \\ \hfill & k-M,\cdots ,k-1)(\text{Algorithm 3})\hfill \\ \hfill & 18:\mathbf{end}\mathbf{if}\hfill \\ \hfill & 19:\text{Write}{x}_{p,kL+t+1}\text{to}x\text{in shared memory}\hfill \\ \hfill & 20:\mathbf{end}\mathbf{for}\hfill \\ \hfill & 21:\mathbf{end}\mathbf{for}\hfill \\ \hfill & 22:\text{Sample}{T}_k\in \{1,2,..,n\}\hfill \\ \hfill & 23:x_k=\frac{1}{LP}{\sum }_{p=0}^{P-1}{\sum }_{i=kL}^{kL+L-1}{x}_{p,i}\hfill \\ \hfill & 24:s_k=x_k-x_{k-1}\hfill \\ \hfill & 25:\text{Option I:}{y}_k=\nabla f_{T_k}(x_k)-\nabla f_{T_k}(x_{k-1})\hfill \\ \hfill & 26:\text{Option II:}{y}_k={\nabla }^2{f}_{T_k}(x_k)s_k\hfill \\ \hfill & 27:\mathbf{end}\mathbf{for}\hfill \end{array}$$

where $\{z_i{\}}_{i=1}^n$ denote the training examples, $f:{\mathbb{R}}^d\to \mathbb{R}$ is a loss function that is parametrized by x which is to be determined in the optimization process, and f_i is the loss occurred on z_i. Most machine learning models (with model parameter x) can be obtained by solving the following minimization problem:

$$\underset{x\in {\mathbb{R}}^d}{\text{min}}f(x)=\frac{1}{n}\sum _{i=1}^n{f}_i(x).$$ (2)

We aim to find an ϵ–approximate solution, x, if x satisfies:

$$E[f(x)]-f(x^{\ast })\le ϵ,$$ (3)

where f(x*) is the global minimum if exists and x* is an optimal solution, ϵ is the targeted accuracy, and E[f(x)] means to take the expectation of f(x). We require a high precision solution, e.g., ϵ = 10⁻³⁰.

2.1. Review of the stochastic quasi-Newton method

According to the classical L-BFGS methods [36], given the current and last iterates x_k and x_k−1 and their corresponding gradients, we define the correction pairs:

$$s_k=x_k-x_{k-1},y_k=\nabla f_k-\nabla f_{k-1},$$ (4)

Algorithm 2 Schedule-update (x, k, m)
$$\begin{array}{cc}\hfill & 1:\mathrm{Input}:x,k,m.\hfill \\ \hfill & 2:\mathrm{Output}:w_k,{\mu }_k\hfill \\ \hfill & 3:\mathbf{if}\text{mod}(k,m)==0\mathbf{then}\hfill \\ \hfill & 4:w_k=x\hfill \\ \hfill & 5:{\mu }_k=\nabla f(x)\hfill \\ \hfill & 6:\mathbf{end}\mathbf{if}\hfill \end{array}$$

Algorithm 3 Two-loop-recursion (v, si, yi, ∀i = 1, ··· , M)

$$\begin{array}{cc}\hfill & 1:\mathrm{Input}:v,s_i,y_i\text{where}i=1,\cdots ,M.\hfill \\ \hfill & 2:\mathrm{Output}:p\hfill \\ \hfill & 3:\text{Initialize}p=-v\hfill \\ \hfill & 4:\mathbf{for}i=M,\dots ,1\mathbf{do}\hfill \\ \hfill & 5:{\alpha }_i=\frac{s_i\cdot p}{s_i\cdot y_i}\hfill \\ \hfill & 6:p=p-{\alpha }_i\cdot y_i\hfill \\ \hfill & 7:\mathbf{end}\mathbf{for}\hfill \\ \hfill & 8:p=(\frac{s_{k-1}\cdot y_{k-1}}{y_{k-1}\cdot y_{k-1}})p\hfill \\ \hfill & 9:\mathbf{for}i=1,\dots ,M\mathbf{do}\hfill \\ \hfill & 10:\beta =\frac{y_i\cdot p}{s_i\cdot y_i}\hfill \\ \hfill & 11:p=p+({\alpha }_i-\beta )\cdot s_i\hfill \\ \hfill & 12:\mathbf{end}\mathbf{for}\hfill \end{array}$$

and define ${\rho }_k=\frac{1}{y_k^T{s}_k}$, $V_k=I-{\rho }_k{y}_k{s}_k^T$. Then the new Hessian inverse matrix can be uniquely updated based on the last estimate H_k−1:

$$H_k=(I-{\rho }_k{s}_k{y}_k^T)H_{k-1}(I-{\rho }_k{y}_k{s}_k^T)+{\rho }_k{s}_k{s}_k^T=V_k^T{H}_{k-1}{V}_k+{\rho }_k{s}_k{s}_k^T.$$ (5)

When datasets are high dimensional, i.e. d > 0 is a large number, and the Hessian and Hessian inverse matrices are d × d and maybe dense, storing and directly updating H_k might be computationally prohibitive. Instead of exploring fully dense matrices, limited-memory methods only save the latest information (say, the recent M) of correction pairs {s_k, y_k} to arrive a Hessian inverse approximation. Given the initial guess H₀ , which is usually set to an identity matrix, the new Hessian inverse at the k-th iteration can actually be approximated by repeated application of the formula (5),

$$\begin{gathered} H_k=(V_k^T\cdot V_{k-1}^T\cdots \cdot \cdot V_{k-M+1}^T)H_{k-M}(V_{k-M+1}\cdot V_{k-M+2}\cdots \cdot \cdot V_k) \\ +{\rho }_{k-M+1}(V_k^T\cdot V_{k-1}^T\cdots \cdot \cdot V_{k-M}^T)s_{k-M+1} \\ \cdot s_{k-M+1}^T(V_{k-M}\cdot V_{k-M+1}\cdots \cdot \cdot V_k) \\ +\dots \\ +{\rho }_k{s}_k{s}_k^T. \end{gathered}$$ (6)

Based on this updating rule, a two-loop recursion procedure has been derived: the first for-loop multiplying all the left-hand side vectors and the second for-loop multiplying the right-hand side ones. In practice, if ν denotes the current variance-reduced gradient, we directly calculate Hessian-vector product H · ν to find the search direction rather than actually computing and storing H. Details are referred to Algorithm 3.

2.2. The proposed quasi-Newton scheme

Algorithm 1 outlines the main steps of our AsySQN method where k indexes the epochs, p indexes the processors, and t indexes the iterations in each epoch within each processor. Following the same sampling strategy in [22], we use two separate subsets S and T of data to estimate the gradient ∇f_S (Lines 8-11) and the Hessian inverse H_T (Lines 22-24), respectively. At each iteration in an epoch, S is used to update the gradient whereas the Hessian inverse is updated at each epoch using a subsample T. In order to better preserve the curvature information, the size of subsample T should be relatively large, whereas the subsample S should be smaller to reduce the overall computation.

The algorithm requires several pre-defined parameters: step size η, limited memory size M, integers m and L, the number of threads P and batch size ∣S∣ = b, and ∣T∣ = b_h. We need the parameter m because we only compute the full gradient of the objective function at the iterate x_k every $m=\frac{n}{b\times L\times P}$ epochs, which will help reduce the computational cost. Algorithm 1 can be split into hierarchically two parts: an inner loop (iteration) and an outer loop (epoch). The inner loop runs asynchronous parallel processes where each thread updates x concurrently and the epoch loop includes the L inner loops and an update on the curvature information.

In our implementation, at the k-th epoch, the vector s_k (Line 24) is the difference between the two iterates obtained before and after L (parallel) inner iterations, where x_k (Line 23) can be the average or the latest iterate in every L iterations. The vector y_k represents the difference between two gradients computed at x_k and x_k−1 using the T_k data subsample: y_k = ∇f_Tk(x_k)−∇f_Tk(x_k−1). By the mid-point theorem, there exists a ξ ∈ [x_k−1, x_k], such that y_k = ∇²f_Tk(ξ)·s_k. The two options (Line 25 and Line 26) of computing y_k are both frequently used in quasi-Newton methods. In our numerical experiments, we run both options for comparisons to show that option II (Line 26) is more stable when the length of s_k, ∥s_k∥, becomes small.

Stochastic gradient descent methods are generally difficult in achieving a solution of high precision, but they can reduce the objective function quickly in the beginning. Thus, a desirable way is to quickly find the optimal interval using a first-order (gradient-based) method and then switch to a second-order method. In practice, we take a warm start by the SVRG (not shown in Algorithm 1), and after certain iterations of quick descending, we then switch to the SQN method to efficiently get a more accurate optimal value.

2.3. The proposed asynchronous parallel quasi-Newton

We propose a multi-threaded process in which each thread makes stochastic updates to a centrally stored vector x (stored in a shared memory) without waiting, which is similar to the processes used in the asynchronous stochastic gradient descent (AsySGD) [2, 37], asynchronous stochastic coordinate descent (AsySCD) [38, 39] and asynchronous SVRG (AsySVRG) [6, 40]. In multi-threaded process, there are P threads, and each thread reads the latest x from the shared memory, calculates the next iterate concurrently, and then write the iterate into the shared memory.

We use an example in Figure 1 to illustrate the process of this parallel algorithm. At the beginning of each epoch, the initial x₀ (for notational convenience) is the current x_k from the shared memory. When a thread finishes computing the next iterate, it will immediately write x into the shared memory. Using the modern memory techniques, there are locks to guarantee that each time only one thread can write to the shared memory. Let us use a global timer t that records any time when the shared memory is updated. In an asynchronous algorithm, when one thread is updating x to x_t, another thread may still use an old state x_D(t) to compute the search direction and update x. Let D(t) ∈ [t] be the particular state of x for a thread when the shared memory (x) is updated at time t. Specifically, let D′(t) ∈ [t] be the state of x that has been used to update x to x_t. We assume that the maximum delay among processes is bounded by τ, that is t − D(t) ⩽ τ. When Thread p ∈ {1, …, P} updates x to x_t, within this thread, the actual state of x that has been used to calculate the search direction is D′(t). Hence, we have x_t = x_t−1 − ηH(x_D′(t))ν(x_D′(t)), where the delay within Thread p is ν = t–D′(t), obviously ν ⩽ τ. Considering that the maximum number of iterations in each epoch is L, we have 0 ⩽ τ ⩽ L < m.

Figure 1:

The key asynchronous parallel steps have been identified as follows: 1. Subsample S; 2. Read x from the shared memory; 3. Compute stochastic gradients g₁, g₂, and ν; 4. Compute the two-loop recursion and update x; 5. Write x to the shared memory; 6. Subsample T and update correction pairs. Before these steps, there is another step that computes the full gradient for all threads, i.e., 0. Calculate full gradient. Here we show the asynchronous parallel updating of the threads where t is a global timer in the epoch, recording the times that x has been updated. For example, at t = 2, Thread 2 updates x to x₂ in the shared memory while Thread 1 and Thread 3 are in the middle of calculation using x₁ and x₀ respectively; hence the current x index for Thread 1 is 1 which we denote as D(t) for Thread 1, and similarly D(t) = 0 for Thread 2, the maximum delay τ = t − D(t) is 2. For Thread 2, the delayed searching direction H(x_D′(2))ν(x_D′(2)) is used to update x₁ to x₂, where $D_2^{\prime }=0$; therefore the delay ν = 2. Similar analysis can be applied to each state of x.

In summary, we design an asynchronous parallel stochastic quasi-Newton method, named AsySQN, to improve the computational efficiency. In our experiments (Section 5), AsySQN shows obvious speedup compared with the original stochastic quasi-Newton methods SQN-VR due to the asynchronous parallel setting. Meanwhile, it still enjoys the advantages of common second-order methods: stability and accuracy. Furthermore, in some machine learning problems, it is not easy to do data normalization or even need more transformation to change the ill-conditioning behavior of objective function. In this case, AsySQN can perform better than AsySVRG or other first-order algorithms.

3. Preliminaries

3.1. Definitions

Each epoch consists of m iterations, at the beginning of each epoch, suppose that the ScheduleUpdate rule is triggered after each m steps, and for brevity, we use w_k to denote the iterations chosen at the k-th epoch.

At the (k + 1) − th epoch t − th iteration:

The updating formula is: x_t+1 = x_t − ηH_tν_t, where step size $\eta \in {\mathbb{R}}^{+}$ determines how long should moves on, here we do not require diminishing way to guarantee convergence rate;

Stochastic Variance-Reduced gradient: u_t = ∇f_it(x_t) − ∇f_it(w_k) + ∇f(w_k), where i_t is randomly chosen from a subset in S ⊆ {1, .., n}. Easily, we get the expectation of stochastic Variance-Reduced gradient: E[u_t] = ∇f(x_t);

The delayed stochastic Variance-Reduced (VR) gradient used in asynchronous setting: ν_t = ∇f_it(x_D(t) − ∇f_it(w_k) + ∇f(w_k). As the full gradient has been computed before, the gradient was estimated at w_k whereas the current iteration should be x_D(t) due to the delay. Taking expectation of the delayed gradient, we get: E[ν_t] = ∇f(x_D(t)).

3.2. Assumptions

We make the same assumptions as non-asynchronous version of the SQN method that also uses VR technique [25].

Assumption 1. The loss function f_i is μ–strongly convex, that is,

$$f_i(y)\ge f_i(x)+<\nabla f_i(x),y-x>+\frac{\mu }{2}\Vert y-x{\Vert }^2,\forall x,y.$$

Assumption 2. The loss function f_i has l–Lipschitz continuous gradients:

$$\Vert \nabla f_i(x)-\nabla f_i(y)\Vert \le l\Vert x-y\Vert ,\forall x,y.$$

Since the average of loss function f_i over i preserves the continuity and convexity, objective function f also satisfies these two hypotheses, then we can easily derive the following lemmas.

Lemma 3.1. Suppose that Assumption 1 and 2 hold. The Hessian matrix will be bounded by two positive constants μ and l such that

$$\mu I\underset{¯}{\prec }{B}_k\underset{¯}{\prec }lI.$$

The second-order information of the objective function f is bounded by μ and l : μI ≤ ∇² f ≤ lI, therefore all Hessian matrices B share the same bounds and generally we have the condition number of the objective function: $\kappa (B)=\frac{l}{\mu }\ge 1$.

Lemma 3.2. Suppose that Assumption 1 and 2 hold. Let H_k be the Hessian inverse matrix. Then for all k ≥ 1, there exist constants 0 < μ₁ < μ₂ such that H_k satisfies

$${\mu }_{1}I\underset{¯}{\prec }{H}_k\underset{¯}{\prec }{\mu }_{2}I,$$

where ${\mu }_1=\frac{1}{(d+M)l}$, ${\mu }_2=\frac{((d+M)l{)}^{d+M-1}}{{\mu }^{d+M}}$, l is the Lipschitz constant, M is the limited memory size, d is the length of x.

Proof can be referenced from [25]. Similarly, all generated Hessian inverse matrices have the same following condition number: $\kappa (H)=\frac{{\mu }_2}{{\mu }_1}=(d+M{)}^{d+M}(\kappa (B){)}^{d+M}$. Obviously, the ill-conditioning degree of Hessian inverse will surely be amplified. For large scale datasets, the shape of objective function can be extreme ill-conditioned. Thus, how to achieve a fair performance in this ill-conditioned situation deserves our attention. As a second-order method, our AsySQN still enjoys fast convergence rate in ill-conditioned situation (see the main theorem 4.6 and Corrollary 4.6.1). We also do extensive experiments showing this property in our simulation numerical analysis.

4. Convergence Analysis

In the asynchronous parallel setting, all working nodes read and update without synchronization. This will cause delayed updates for some other threads. Hence, the stochastic variance-reduced gradients may not be computed using the latest iterate of x. Here, we use gradient ν_t defined above, then each thread uses each its own ν_t to update x_t+1 = x_t − ηH_tν_t.

Lemma 4.1. In one epoch, the delay of parameter x reading from the shared memory can be bounded by:

$$E[\Vert x_t-x_{D(t)}\Vert ]\le \eta {\mu }_2\sum _{j=D(t)}^{t-1}E[\Vert v_j\Vert ].$$

Proof. From Lemma 3.2 and updating formula x_t+1 = x_t − ηH_tν_t,

$$\begin{gathered} E[\Vert x_t-x_{D(t)}\Vert ]\le \sum _{j=D(t)}^{t-1}E[\Vert x_{j+1}-x_j\Vert ] \\ =\sum _{j=D(t)}^{t-1}\eta E[\Vert H_t{v}_t\Vert ] \\ \le \eta {\mu }_2\sum _{j=D(t)}^{t-1}E[\Vert v_j\Vert ]. \end{gathered}$$

□

Lemma 4.2. Suppose that Assumption 2 holds, the delay in the stochastic VR gradient of the objective function f :

$$E[\Vert u_t-v_t\Vert ]\le l\eta {\mu }_2\sum _{j=D(t)}^{t-1}E[\Vert v_j\Vert ].$$

Proof. From Assumption 2, Lemma 3.2 and 4.1,

$$\begin{gathered} E[\Vert u_t-v_t\Vert ]=E[\Vert \nabla f(x_t)-\nabla f(x_{D(t)})\Vert ] \\ \le lE[\Vert x_t-x_{D(t)}\Vert ] \\ \le l\eta {\mu }_2\sum _{j=D(t)}^{t-1}E[\Vert v_j\Vert ]. \end{gathered}$$

□

Lemma 4.3. Suppose that Assumption 1 holds, denote w* to be the unique minimizer of objective function f. Then for any x, we have

$$\Vert \nabla f(x){\Vert }^2\ge 2\mu (f(x)-f(w^{\ast }))$$

Proof. From Assumption 1,

$$\begin{gathered} f(w^{\ast })\ge f(x)+\nabla f(x{)}^T(w^{\ast }-x)+\frac{\mu }{2}\Vert w^{\ast }-x{\Vert }^2 \\ \ge f(x)+\underset{\xi }{\text{min}}(\nabla f(x{)}^T\xi +\frac{\mu }{2}\Vert \xi {\Vert }^2) \\ =f(x)-\frac{1}{2\mu }\Vert \nabla f(x){\Vert }^2. \end{gathered}$$

Letting ξ = w* − x, when $\xi =-\frac{\nabla f(x)}{\mu }$, the quadratic function can achieve its minimum. □

Lemma 4.4. Suppose that Assumptions 1 and 2 hold. Let f* be the optimal value of Eq.(2). Considering the stochastic variance-reduced gradient, we have:

$$E[\Vert u_t{\Vert }^2]\le 4lE[f(x_t)-f^{\ast }+f(w_k)-f^{\ast }].$$

Proof reference [24].

Theorem 4.5. Suppose that Assumptions 1 and 2 hold, the gradient delay in an epoch can be measured in the following way:

$$\sum _{t=km}^{km+m-1}E[\Vert v_t{\Vert }^2]\le \frac{2}{1-2l^2{\eta }^2{\mu }_2^2{\tau }^2}\sum _{t=km}^{km+m-1}E[\Vert u_t{\Vert }^2].$$

Proof.

$$\begin{gathered} E[\Vert v_t{\Vert }^2]\le 2E[\Vert v_t-u_t{\Vert }^2]+2E[\Vert u_t{\Vert }^2] \\ \le 2l^2{\eta }^2{\mu }_2^2\tau \sum _{j=D(t)}^{t-1}E[\Vert v_j{\Vert }^2]+2E[\Vert u_t{\Vert }^2] \end{gathered}$$

Summing from t = km to t = km + m − 1, we get

$$\begin{gathered} \sum _{t=km}^{km+m-1}E[\Vert v_t{\Vert }^2]\le \sum _{t=km}^{km+m-1}2l^2{\eta }^2{\mu }_2^2\tau \sum _{j=D(t)}^{t-1}E[\Vert v_j{\Vert }^2]+2\sum _{t=km}^{km+m-1}E[\Vert u_t{\Vert }^2] \\ \le 2l^2{\eta }^2{\mu }_2^2{\tau }^2\sum _{t=km}^{km+m-1}E[\Vert v_t{\Vert }^2]+2\sum _{t=km}^{km+m-1}E[\Vert u_t{\Vert }^2] \end{gathered}$$

By rearranging, we get the inequality above. □

Theorem 4.6 (Main theorem). Suppose that Assumptions 1 and 2 hold, step size η and epoch size m are chosen such that the following condition holds:

$$0<\theta ≔\frac{1+C}{1+m\eta \mu {\mu }_1-C}<1,$$

where $C=\frac{4m{l}^2{\eta }^2{\mu }_2^2(l\eta {\mu }_1\tau +1)}{1-2l^2{\eta }^2{\mu }_2^2{\tau }^2}$. Then for all k ≥ 0, we have

$$E[f(w_{k+1})-f^{\ast }]\le \theta E[f(w_k)-f^{\ast }].$$

Proof. Let’s start from the Lipschitz continuous condition:

$$\begin{gathered} f(x_{t+1})\le f(x_t)+\nabla f(x_t)(x_{t+1}-x_t)+\frac{l}{2}\Vert x_{t+1}-x_t{\Vert }^2 \\ =f(x_t)-\eta H_r\nabla f(x_t)v_t+\frac{l{\eta }^2{H}_r^2}{2}\Vert v_t{\Vert }^2 \\ \le f(x_t)-\eta {\mu }_1\nabla f(x_t)v_t+\frac{l{\eta }^2{\mu }_2^2}{2}\Vert v_t{\Vert }^2 \end{gathered}$$

Taking expectation at both hands,

$$E[f(x_{t+1})]\le E[f(x_t)]-\eta {\mu }_{1}E[u_t]E[v_t]+\frac{l{\eta }^2{\mu }_2^2}{2}E[\Vert v_t{\Vert }^2]$$

Given $ab=\frac{(a+b{)}^2-(a-b{)}^2}{4}$, we can derive: $-ab=\frac{1}{2}(a-b{)}^2-\frac{1}{2}{a}^2-\frac{1}{2}{b}^2$. Thus,

$$\begin{gathered} -E[u_t]E[v_t] \\ =\frac{1}{2}(E[u_t]-E[v_t]{)}^2-\frac{1}{2}(E[u_t]{)}^2-\frac{1}{2}(E[v_t]{)}^2 \\ =\frac{1}{2}(\nabla f(x_t)-\nabla f(x_{D(t)}){)}^2-\frac{1}{2}(\nabla f(x_t){)}^2-\frac{1}{2}(\nabla f(x_{D(t)}){)}^2 \\ \le \frac{l^2}{2}\Vert x_t-x_{D(t)}{\Vert }^2-\mu (f(x_t)-f^{\ast })-\mu (f(x_{D(t)})-f^{\ast }) \\ =\frac{l^2{\eta }^2{\mu }_2^2}{2}\sum _{j=D(t)}^{t-1}E[\Vert v_j{\Vert }^2]-\mu (f(x_t)-f^{\ast })-\mu (f(x_{D(t)})-f^{\ast }) \end{gathered}$$

The first inequality comes from Lipschitz continuous condition and Lemma 4.3.

Substituting this in the inequality above, we get the following result:

$$\begin{gathered} E[f(x_{t+1})] \\ \le E[f(x_t)]+\eta {\mu }_1(\frac{l^2{\eta }^2{\mu }_2^2}{2}\sum _{j=D(t)}^{t-1}E[\Vert v_j{\Vert }^2]-\mu (f(x_t)-f^{\ast }) \\ -\mu (f(x_{D(t)})-f^{\ast }))+\frac{l{\eta }^2{\mu }_2^2}{2}E[\Vert v_t{\Vert }^2] \\ \le E[f(x_t)]+\frac{l^2{\eta }^3{\mu }_2^2{\mu }_1}{2}\sum _{j=D(t)}^{t-1}E[\Vert v_j{\Vert }^2]-\eta \mu {\mu }_{1}E[f(x_t)-f^{\ast }] \\ -\eta \mu {\mu }_{1}E[f(x_{D(t)})-f^{\ast }]+\frac{l{\eta }^2{\mu }_2^2}{2}E[\Vert v_t{\Vert }^2] \\ \le E[f(x_t)]+\frac{l^2{\eta }^3{\mu }_2^2{\mu }_1}{2}\sum _{j=D(t)}^{t-1}E[\Vert v_j{\Vert }^2]-\eta \mu {\mu }_{1}E[f(x_t)-f^{\ast }] \\ +\frac{l{\eta }^2{\mu }_2^2}{2}E[\Vert v_t{\Vert }^2] \end{gathered}$$

The last inequality comes from the fact that f* = minf(x), f(x_D(t)) − f* ≥ 0.

Summing from t = km to t = km + m − 1, we get

$$\begin{gathered} \sum _{t=km}^{km+m-1}E[f(x_{t+1})-f(x_t)] \\ \le \frac{l^2{\eta }^3{\mu }_2^2{\mu }_1}{2}\sum _{t=km}^{km+m-1}\sum _{j=D(t)}^{t-1}E[\Vert v_j{\Vert }^2]+\frac{l{\eta }^2{\mu }_2^2}{2}\sum _{t=km}^{km+m-1}E[\Vert v_t{\Vert }^2] \\ -\eta \mu {\mu }_1\sum _{t=km}^{km+m-1}E[f(x_t)-f^{\ast }] \\ \le \frac{l^2{\eta }^3{\mu }_2^2{\mu }_1\tau }{2}\sum _{t=km}^{km+m-1}E[\Vert v_t{\Vert }^2]+\frac{l{\eta }^2{\mu }_2^2}{2}\sum _{t=km}^{km+m-1}E[\Vert v_t{\Vert }^2] \\ -\eta \mu {\mu }_{1}mE[f(w_{k+1})-f^{\ast }] \\ =\frac{l{\eta }^2{\mu }_2^2(l\eta {\mu }_1\tau +1)}{2}\sum _{t=km}^{km+m-1}E[\Vert v_t{\Vert }^2]-\eta \mu {\mu }_{1}mE[f(w_{k+1})-f^{\ast }] \\ \le \frac{l{\eta }^2{\mu }_2^2(l\eta {\mu }_1\tau +1)}{2}\cdot \frac{2}{1-2l^2{\eta }^2{\mu }_2^2{\tau }^2}\sum _{t=km}^{km+m-1}E[\Vert u_t{\Vert }^2] \\ -\eta \mu {\mu }_{1}mE[f(w_{k+1})-f^{\ast }] \\ =\frac{l{\eta }^2{\mu }_2^2(l\eta {\mu }_1\tau +1)}{1-2l^2{\eta }^2{\mu }_2^2{\tau }^2}\sum _{t=km}^{km+m-1}E[\Vert u_t{\Vert }^2]-\eta \mu {\mu }_{1}mE[f(w_{k+1})-f^{\ast }] \\ \le \frac{l{\eta }^2{\mu }_2^2(l\eta {\mu }_1\tau +1)}{1-2l^2{\eta }^2{\mu }_2^2{\tau }^2}\sum _{t=km}^{km+m-1}4lE[f(x_t)-f^{\ast }+f(w_k)-f^{\ast }] \\ -\eta \mu {\mu }_{1}mE[f(w_{k+1})-f^{\ast }] \\ \le (\frac{4m{l}^2{\eta }^2{\mu }_2^2(l\eta {\mu }_1\tau +1)}{1-2l^2{\eta }^2{\mu }_2^2{\tau }^2}-m\eta \mu {\mu }_1)E[f(w_{k+1})-f^{\ast }] \\ +\frac{4l^2{\eta }^2{\mu }_2^2(l\eta {\mu }_1\tau +1)}{1-2l^2{\eta }^2{\mu }_2^2{\tau }^2}E[f(w_k)-f^{\ast }] \end{gathered}$$ (7)

The second inequality uses the assumption that we have a delay τ in one epoch iteration. The third inequality uses the results of Theorem 4.5, hence all delayed stochastic VR gradients can be bounded by the stochastic VR gradients. The fourth inequality holds for Lemma 4.4. In the epoch-based setting,

$$\begin{gathered} \sum _{t=km}^{km+m-1}E[f(x_{t+1})-f(x_t)]=E[f(x_{(k+1)m})-f(x_{km})] \\ =E[f(w_{k+1})-f(w_k)]. \end{gathered}$$

Thus the above inequality gives

$$\begin{gathered} E[f(w_{k+1})-f^{\ast }] \\ \le E[f(w_k)-f^{\ast }]+\frac{4l^2{\eta }^2{\mu }_2^2(l\eta {\mu }_1\tau +1)}{1-2l^2{\eta }^2{\mu }_2^2{\tau }^2}\sum _{t=km}^{km+m-1}E[f(w_k)-f^{\ast }] \\ -(m\eta \mu {\mu }_1-\frac{4m{l}^2{\eta }^2{\mu }_2^2(l\eta {\mu }_1\tau +1)}{1-2l^2{\eta }^2{\mu }_2^2{\tau }^2})E[f(w_{k+1})-f^{\ast }]. \end{gathered}$$

By rearranging the above gives

$$\begin{gathered} (1+m\eta \mu {\mu }_1-\frac{4m{l}^2{\eta }^2{\mu }_2^2(l\eta {\mu }_1\tau +1)}{1-2l^2{\eta }^2{\mu }_2^2{\tau }^2})E[f(w_{k+1})-f^{\ast }] \\ \le (1+\frac{4m{l}^2{\eta }^2{\mu }_2^2(l\eta {\mu }_1\tau +1)}{1-2l^2{\eta }^2{\mu }_2^2{\tau }^2})E[f(w_k)-f^{\ast }]. \end{gathered}$$

Hence, we get the following result:

$$E[f(w_{k+1}-f^{\ast })]\le \theta E[f(w_k-f^{\ast })],$$

where $\theta =\frac{1+C}{1+m\eta \mu {\mu }_1-C}$, $C=\frac{4m{l}^2{\eta }^2{\mu }_2^2(l\eta {\mu }_1\tau +1)}{1-2l^2{\eta }^2{\mu }_2^2{\tau }^2}$. □

From Theorem 4.6 we can see that η, τ should satisfy condition $1-2l^2{\eta }^2{\mu }_2^2{\tau }^2>0$ to ensure the result holds. Therefore, we reach an upper bound of the step size: $\eta <\frac{1}{\sqrt{2}l{\mu }_2\tau }$. By substituting the result of Lemma 3.2, we can easily derive $l{\mu }_2\tau =l\frac{((d+M)l{)}^{d+M-1}}{{\mu }^{d+M}}\tau =(d+M{)}^{d+M-1}(\frac{1}{\mu }{)}^{d+M}\tau >1$.

To ensure that $\theta =\frac{1+C}{1+m\eta \mu {\mu }_1-C}\in (0,1)$, we require mημμ₁ > 2C, where C > 0, and this requirement can be written equivalently in the following way:

$$(1-2l^2{\eta }^2{\mu }_2^2{\tau }^2)m\eta \mu {\mu }_1>8m{l}^2{\eta }^2{\mu }_2^2(l\eta {\mu }_1\tau +1).$$

We can treat the above inequality as quadratic equation with respect to step size η,

$$2l^2{\mu }_1{\mu }_2^2\tau (4l+\mu \tau ){\eta }^2+8l^2{\mu }_2^2\eta -\mu {\mu }_1<0,$$

and it can be checked that when $\eta \in (0,\frac{\sqrt{16l^2{\mu }_2^2+2{\mu }_1^2\mu \tau (4l+\mu \tau )}-4l{\mu }_2}{2l{\mu }_1{\mu }_2\tau (4l+\mu \tau )})$, the inequality will be satisfied. Noticing that this range falls into the previous restriction $\eta <\frac{1}{\sqrt{2}l{\mu }_2\tau }$, then we get a more accurate bound of step size to ensure the convergence rate θ falls in range (0, 1). For simplicity, we set the step size parameter $\eta =\frac{1}{2l{\mu }_{2}m}$, it is easy to check that the quadractic inequality above will be certainly satisfied.

Corollary 4.6.1. Suppose that the conditions in Theorem 4.6 hold and for simplicity we set parameters as step size $\eta =\frac{1}{2l{\mu }_{2}m}$ and the maximum delay parameter τ = L < m. If m > 8κ(B)κ(H) + 4κ(B), then the Asynchronous parallel SQN will have the following convergence rate:

$$E[f(w_{k+1})-f^{\ast }]\le \frac{(m+2)\kappa (B)\kappa (H)+\kappa (B)}{(m-2)\kappa (B)\kappa (H)-\kappa (B)+\frac{m}{2}}E[f(w_k)-f^{\ast }].$$

Proof. We first check that when $\eta =\frac{1}{2l{\mu }_{2}m}$,

$$\begin{gathered} C=\frac{4m{l}^2{\eta }^2{\mu }_2^2(l\eta {\mu }_1\tau +1)}{1-2l^2{\eta }^2{\mu }_2^2{\tau }^2} \\ =\frac{\frac{{\mu }_1}{2{\mu }_2}\frac{L}{m}+1}{m(1-\frac{1}{2}(\frac{L}{m}{)}^2)} \\ <\frac{\frac{1}{\kappa (H)}+2}{m}. \end{gathered}$$

Then we get a simplified C, which is still positive. The convergence rate will correspondingly become:

$$\begin{gathered} \theta =\frac{1+C}{1+m\eta \mu {\mu }_1-C} \\ <\frac{1+\frac{\frac{1}{\kappa (H)}+2}{m}}{1+\frac{1}{2\kappa (B)\kappa (H)}-\frac{\frac{1}{\kappa (H)}+2}{m}} \\ =\frac{(m+2)\kappa (B)\kappa (H)+\kappa (B)}{(m-2)\kappa (B)\kappa (H)-\kappa (B)+\frac{m}{2}}. \end{gathered}$$

When m > 2, θ > 0 can be guaranteed. Further, to ensure convergence rate θ < 1, m > 8κ(B)κ(H) + 4κ(B). □

Remark 4.7 (Step size). As the step size η diminishing to 0, C → 0, and θ → 1, which means the convergence rate becomes slower as the step size getting smaller. Decayed step size makes it easier to converge, however it is not the best choice for majority algorithms, and we use constant step size here.

It is well known that the deterministic quasi-Newton methods (e.g. L-BFGS) enjoy a superlinear convergence rate, while the stochastic version of quasi-Newton methods (including L-BFGS) will have a sublinear convergence rate in strongly convex optimization as a sacrifice; with the help of variance reduction technique, SQN-VR reaches a linear convergence rate. Compared with the original SQN-VR, even equipped with asynchronous setting, our method still achieves a linear convergence rate. The delay parameter τ in asynchronous setting affects the linear speed θ and more details are given as follows.

Remark 4.8 (Asynchronous delay). If we assume that the delay parameter τ diminishes to 0, the convergence rate corresponds to the stochastic parallel one. SQN-VR [25] reaches a linear convergence rate, which is the upper bound since sequential algorithms have no delay in updating. Further, for synchronous parallel SQN, the convergence rate will not be changed. However, once the delay is introduced by asynchronous, the convergence rate will certainly be impaired, even not converge. Our main theorem has proved that even with asynchronous updating scheme, the convergence rate still can reach linear. In the worst asynchronous case, i.e. the delay is maximized to be epoch size, Corollary 4.6.1 shows the linear convergence rate.

Remark 4.9 (Affine invariance). It is known that second-order methods have the property that independent of linear scaling, which is not true for gradient descent as it owns a rate with exponential relationship with condition number. For stochastic quasi-Newton methds, the convergence rate in references [22, 25] did not show that SQN keeps the affine invariance. In our analysis, Theorem 4.6 shows that $\theta =O(\frac{1+C}{1+\frac{1}{\kappa (B)}-C})$, where $C=O(\frac{1}{\kappa (H)})$ when fixing all other parameters, specifically m, d, M, τ. In the later Corollary 4.6.1 analysis, when m is chosen large enough than 8κ(B)κ(H)+4κ(B), the linear convergence rate $\theta \approx \frac{m}{m+m∕2}=\frac{2}{3}$. Then we get the conclusion that θ doesn’t depend on the condition number, our theoretical result verifies the affine invariance together with empirical study.

Remark 4.10 (Limitation on subsample T). During the stochastic Hessian inverse construction, if the subsample T goes to zero, no more curvature information will be captured, SQN will degrade to first-order gradient descent method; if T goes to the entire data n, SQN has the whole costly Hessian inverse approximation, then SQN will not be so efficient. As a balance, subsample T should be chosen as a moderately large, independent subset of data. In our experiments, we choose the size of T to be 10 times the size of subsample S.

5. Empirical Study

In this section, we compare the performance of our designed algorithm AsySQN with the state-of-the-art SQN-VR method [25] and distributed quasi-Newton method named DAve-QN [34] to show the enhancement raised by asynchronous parallel setting. More formally, we also make comparisons with classical stochastic gradient descent (SGD) [1] and stochastic variance-reduced gradient method (SVRG) [24] and their asynchronous versions [2, 6] to give some insights of first-order gradient methods and second-order quasi-Newton methods. We employ a machine with 32GB main memory and 8 Intel Xeon CPU E5-2667 v3 @ 3.2 GHz processors. The experiments have been performed on both synthetic and real-world datasets, with different numbers of data points and dimensions.

Datapass analysis.

We use the number of times the whole dataset will be visited, or called datapass, as performance measure of the convergence speed. This is because it is independent of the actual implementation of the algorithms, and has been a well-established convention in the literature on both stochastic first-order and second-order methods[24, 4, 41, 22, 25, 23].

For each epoch, the SVRG and AsySVRG algorithms visit the whole dataset twice (datapass = 2): one for updating parameter x and the other is for calculating average gradient. For SQN-VR and AsySQN, each epoch will take $2+\frac{b_H}{b\times L\times P}$ datapasses, where P is the number of threads. The extra datapass of AsySQN is introduced by Hessian-vector product calculations.

Speedup analysis.

We compare stochastic quasi-Newton methods (SQN-VR) and its asynchronous parallel version (AsySQN) in terms of speedup to show the advantage of taking asynchronous parallel strategy. Here we consider the stopping criteria: f(w) − f* < ϵ, where f* has been calculated before, we require high-precision optimum as error ϵ = 10⁻³⁰. The speedup results for simulation and real datasets are shown in Figures 4 and 6, respectively.

Figure 4:

Comparisons of different asynchronous algorithms in 20-D and 200-D simulation datasets.

Figure 6:

Datapasses and speedup of logistic regression with Real_sim dataset (a)(d) , MNIST dataset (b)(e) and SVM with RCV1 dataset (c)(f).

As we require no more on sparsity and Hessian matrix is always dense, lock has been added when updating parameter x in shared memory, that is the reason why we have extra waiting time and have not reached the ideal linear speedup. However, obvious speedup still can be captured. Also, we compare with the lock-version of asynchronous first-order methods for fairness.

CPU time analysis.

We also include the real clock time when making comparisons within second-order methods, as shown in Figures 5 and 7. The stopping criteria and precision settings are the same with speedup analysis.

Figure 5:

CPU time of SQN-VR, its asynchronous version AsySQN, and distributed DAve-QN in 20-D and 200-D simulation datasets.

Figure 7:

CPU time of logistic regression with Real_sim dataset (a), MNIST dataset (b) and SVM with RCV1 dataset (c).

Experiment setup.

We conduct two simulations (moderate-dimensional I and high-dimensional II under ill-conditioning case) using synthetic datasets and three real datasets (Real_sim, MNIST, RCV1) evaluations to show the comparisons of our methods against competitors. For all our experiments, the batch size b is set to be 5, 10, 20, 50 and the Hessian batch size b_H is set to be 10b. The limited memory size M = 10 in both SQN-VR and AsySQN. After testing experiments in SQN-VR, we select P × L as roughly a preferable constant for each dataset, which means a smaller L is preferred when more threads are used. For all the algorithms, a constant step size is chosen via grid search. All experiments are initialized randomly except simulation I since we want to check the trace of algorithms in simulation I, see Figure 3. All experiments are performed with 8 cores in the parallel setting.

Figure 3:

Explore the results in ill-conditioning (same setting as Figure 2 (b)), demonstrates the stability of AsySQN. AsySQN can still quickly drop down to the optimum even though with little perturbation due to the asynchronous updates; while the AsySVRG methods have obvious jumping compared with SVRG due to the asynchronous setting.

5.1. Experiments using synthetic datasets

In order to explore some properties of our algorithm, simulation I and simulation II are performed for the least square problem:

$$\underset{x\in {\mathbb{R}}^d}{\text{min}}\frac{1}{n}\sum _{i=1}^n(y_i-z_i^{T}x{)}^2.$$ (8)

The goal of simulation I is to study that under what circumstance our designed algorithm AsySQN will be preferred compared with first-order methods (AsySGD and AsySVRG). Various degrees of ill-conditioning least square problems are generated in the following procedures: z₁ and z₂ are two features generated uniformly from the interval [0, 1]. We then label y = a × z₁ + b × z₂ + ϵ, where ϵ satisfies normal distribution with mean 0 and standard deviation 1. To control the degree of ill-conditioning, we use four different settings of (a, b) pairs: (0.1, 10), (1, 10), (1, 5) and (1, 1), which correspond to extreme ill-conditioned, ill-conditioned, moderate ill-conditioned and well-behaved least squared problems, respectively.

From Figure 2, we can see in extreme ill-conditioned case, AsySQN performs significantly better than first-order methods, it could achieve high precision solutions in short datapasses, where AsySVRG and AsySGD can barely solve the problem. In (moderate) ill-conditioned cases, AsySGD still performs bad, AsySVRG and AsySQN can linearly go to the optimum while AsySQN is faster in terms of datapasses. Even in well-behaved optimization, AsySQN is still comparable with AsySVRG. From (a)-(d), we can clearly conclude that the performance of AsySQN is more stable and verifies the affine invariance property.

Figure 2:

Under various degrees of ill-conditioning least square problems: (a) extreme ill- conditioning; (b) ill-conditioning; (c) moderate ill-conditioning; (d) well-behaved.

To see the details, we plot the trace of AsySQN and AsySVRG respectively¹. Figure 3 carefully explores the results showing in Figure 2(b), in ill-conditioning optimization, how the trace information reveal the performance difference. We first study the well-known first-order method, SVRG, and its corresponding asynchronous version AsySVRG in Figure 3(a). It is clear to see that asynchronous setting results in wild jumps around the global minimum. However, second-order methods are well-known to be stable and we can see stochastic second-order method performs much more stable than SVRG in Figure 3(b). And even equipped with an asynchronous setting, AsySQN still exhibits good performance in terms of stability of convergence to the global optimal as shown in Figures 3(c,d). In Figure 3(d), the side-by-side comparison between AsySVRG and AsySQN, AsySVRG has wild jumping around the global minimum. In other words, AsySQN avoids the jumping which is a hard burden for lending asynchronous implementation directly to first-order methods. Hence, we conclude that AsySQN outperforms AsySVRG under ill-conditioned circumstance.

In practice, it is appealing to solve machine learning problems over high dimensional datasets. Simulation II is performed where the dimensions of ill-conditioned simulation datasets are (10⁴, 20) and (10⁴, 200), respectively. AsySGD and AsySVRG are hard to quickly achieve a high precision solution, they cost almost 200 datapasses to approximate the optimal value within a precision of 10⁻⁴. DAve-QN method relies highly on the condition number of objective functions and it performs bad in our ill-conditioned simulations, which confirms their theoretical analysis. In contrast, AsySQN can achieve the high precision solution (10⁻³⁰) within finite datapasses, showing better performance with ill-conditioned datasets. Further, AsySQN has an obvious speedup compared with synchronous SQN-VR methods in dealing with high dimensional data. See Figure 4. We also include the speedup of AsySVRG as a reference. When the number of threads is 1, it is actually the original non-parallel version of stochastic L-BFGS method (SQN-VR in our experiment). The CPU time comparisons within second-order methods: the base line method SQN-VR, our designed method AsySQN, and the-state-of-the-art distributed quasi-Newton method DAve-QN, are shown in Figure 5. AsySQN costs the least amount of time to reach a high precision solution, and shows obvious speedup compared with SQN-VR. In summary, we can get the conclusion that our designed algorithm scales very well with the problem size, and actually improve the speedup in dealing with high dimensional optimization problems.

5.2. Experiments using real-world datasets

Three datasets have been used for real-dataset evaluations: Real_sim, MNIST and RCV1, which can be downloaded from the LibSVM website².

We have conducted experiments on logistic regression as in Eq.(9) with real_sim dataset (with 72, 309 data points of 20, 958 feature dimension, or 72, 309 × 20, 958) and MNIST dataset (60, 000 × 780):

$$\underset{x\in {\mathbb{R}}^d}{\text{min}}\frac{1}{n}\sum _{i=1}^n(log(1+exp(y_i{z}_i^{T}x))+\lambda \Vert x{\Vert }^2);$$ (9)

and then we perform our algorithm on SVM as in Eq.(10) with RCV1 dataset (677, 399 × 47, 236):

$$\underset{x\in {\mathbb{R}}^d}{\text{min}}\frac{1}{n}\sum _{i=1}^n(max(0,1-y_i(z_i^{T}x))+\lambda \Vert x{\Vert }^2);$$ (10)

where $z_i\in {\mathbb{R}}^d$, and y_i is the corresponding label. In our experiments, we set the regularizer λ = 10⁻³.

Notice that we perform stochastic algorithms: AsySGD, AsySVRG, AsySQN and SQN-VR on all these real-datasets, while conducting DAve-QN method only on the smallest dataset, MNIST. This is because DAve-QN method needs to store and calculate hessian matrix (not uses limited memory version of BFGS method). Real_sim and RCV1 have a large number of features, so it is hard to fulfill DAve-QN method on these two datasets. DAve-QN performs better in terms of CPU time over MNIST dataset. However, MNIST dataset has a moderate data size and is regular, that is, it doesn’t have heterogeneity among features.

Figures 6 and 7 plot the comparisons of the methods mentioned above. By studying the convergence rate with respect to effective datapasses, AsySQN outperforms AsySVRG and AsySGD in all these real datasets. When the number of threads equals to 1, it is the original stochastic L-BFGS with VR method. With the increasing number of threads, the speedup will first show an ideal linear rate and ascend to a peak due to the asynchronous parallel within threads. When the number of threads reaches some marginal value, here in our experiments, the marginal value is particular 6, the speedup will descend. This is because the high cost of communication between multiple threads, the overhead of lock, and the resource contention, thus the growth curve of speedup is not as ideal as simulation plots. It may come down to the fact mentioned in earlier research [42] that benchmark downloaded from Lib-SVM has been row normalized. Hence AsySQN hasn’t shown great advantage over AsySVRG but is still comparable in well-behaved case, which corresponds to the results of the simulation datasets above. In terms of speedup, we still plot AsySVRG as a reference: for first-order methods, locked AsySVRG reaches around 3 times speedup using 8 cores compared with SVRG [6]; second-order method AsySQN, which requires more communications, can reach almost the same speedup with 8 cores. And we would recommend 6 cores in practice. In conclusion, our designed algorithm works well in real datasets.

6. Conclusion

We have proposed a stochastic quasi-Newton method in an asynchronous parallel environment, which can be applied to solve large dense optimization with high accuracy. Compared with prior work on second-order methods, our algorithm represents the first effort in implementing the stochastic version in asynchronous parallel way and provides theoretical guarantee that a linear rate of convergence can be reached in the strongly convex setting. The experimental results demonstrate that our parallel version can effectively accelerate stochastic L-BFGS algorithm. For ill-conditioned problems, our algorithm carries the effectiveness of second-order methods and converges much faster than the best first-order methods such as AsySVRG. The theoretical proof of convergence rate can be used as framework in the asynchronous setting of stochastic second-order methods. In our future work, we may extend the algorithm and analysis to solve non-strongly convex or even non-convex loss functions.