An Asynchronous Mini-Batch Algorithm for Regularized Stochastic Optimization

I Introduction

Many optimization problems that arise in machine learning, signal processing, and statistical estimation can be formulated as

regularized stochastic optimization (also referred to as stochastic composite optimization

) problems in which one jointly minimizes the expectation of a stochastic loss function plus a possibly nonsmooth regularization term. Examples include Tikhonov and elastic net regularization, Lasso, sparse logistic regression, and support vector machines

[1, 2, 3, 4, 5].

Stochastic approximation methods such as stochastic gradient descent were among the first algorithms developed for solving stochastic optimization problems

[6]. Recently, these methods have received significant attention due to their simplicity and effectiveness (see, e.g., [7, 8, 9, 10, 11, 12, 13]). In particular, Nemirovski et. al. [7] demonstrated that for nonsmooth stochastic convex optimization problems, a modified stochastic approximation method, the mirror descent, exhibits an unimprovable convergence rate

O (1 / \sqrt{T})

, where

T

is the number of iterations. Later, Lan [8] developed a mirror descent algorithm for stochastic composite convex problems which explicitly accounts for the smoothness of the loss function and achieves the optimal rate. A similar result for the dual averaging method was obtained by Xiao [9].

The methods for solving stochastic optimization problems cited above are inherently serial in the sense that the gradient computations take place on a single processor which has access to the whole dataset. However, it happens more and more often that one single computer is unable to store and handle the amounts of data that we encounter in practical problems. This has caused a strong interest in developing parallel optimization algorithms which are able to split the data and distribute the computation across multiple processors or multiple computer clusters (see, e.g., [14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] and references therein).

One simple and popular stochastic approximation method is mini-batching, where iterates are updated based on the average gradient with respect to multiple data points rather than based on gradients evaluated at a single data at a time. Recently, Dekel et. al. [32] proposed a parallel mini-batch algorithm for regularized stochastic optimization problems, in which multiple processors compute gradients in parallel using their own local data, and then aggregate the gradients up a spanning tree to obtain the averaged gradient. While this algorithm can achieve linear speedup in the number of processors, it has the drawback that the processors need to synchronize at each round and, hence, if one of them fails or is slower than the rest, then the entire algorithm runs at the pace of the slowest processor.

In this paper, we propose an asynchronous mini-batch algorithm for regularized stochastic optimization problems with smooth loss functions that eliminates the overhead associated with global synchronization. Our algorithm allows multiple processors to work at different rates, perform computations independently of each other, and update global decision variables using out-of-date gradients. A similar model of parallel asynchronous computation was applied to coordinate descent methods for deterministic optimization in [33, 34, 35] and mirror descent and dual averaging methods for stochastic optimization in [36]. In particular, Agarwal and Duchi [36] have analyzed the convergence of asynchronous mini-batch algorithms for smooth stochastic convex problems, and interestingly shown that bounded delays do not degrade the asymptotic convergence. However, they only considered the case where the regularization term is the indicator function of a compact convex set.

We extend the results of [36] to general regularization functions (like the $l_{1}$ norm, often used to promote sparsity), and establish a sharper expected-value type of convergence rate than the one given in [36]. Specifically, we make the following contributions:

For general convex regularization functions, we show that when the constraint set is closed and convex (but not necessarily bounded), the running average of the iterates generated by our algorithm with constant step-sizes converges at rate $O (1 / T)$ to a ball around the optimum. We derive an explicit expression that quantifies how the convergence rate and the residual error depends on loss function properties and algorithm parameters such as the constant step-size, the batch size, and the maximum delay bound $τ_{max}$ .
For general convex regularization functions and compact constraint sets, we prove that the running average of the iterates produced by our algorithm with a time-varying step-size converges to the true optimum (without residual error) at rate

$O (\frac{(τ_{max} + 1)^{2}}{T} + \frac{1}{\sqrt{T}}) .$

This result improves upon the previously known rate

$O (\frac{τ_{max}^{2} log T}{T} + \frac{τ_{max} + 1}{T} + \frac{1}{\sqrt{T}})$

for delayed stochastic mirror descent methods with time-varying step-sizes given in [36]. In this case, our algorithm enjoys near-linear speedup as long as the number of processors is $O (T^{1 / 4})$ .
When the regularization function is strongly convex and the constraint set is closed and convex, we establish that the iterates converge at rate

$O (\frac{(τ_{max} + 1)^{4}}{T^{2}} + \frac{1}{T}) .$

If the number of processors is of the order of $O (T^{1 / 4})$ , this rate is $O (1 / T)$ asymptotically in $T$ , which is the best known rate for strongly convex stochastic optimization problems in a serial setting.

The remainder of the paper is organized as follows. In Section II, we introduce the notation and review some preliminaries that are essential for the development of the results in this paper. In Section III, we formulate the problem and discuss our assumptions. The proposed asynchronous mini-batch algorithm and its main theoretical results are presented in Section IV. Computational experience is reported in Section V while Section VI concludes the paper.

Ii Notation and Preliminaries

Ii-a Notation

We let $N$ and $N_{0}$ denote the set of natural numbers and the set of natural numbers including zero, respectively. The inner product of two vectors $x, y \in R^{n}$ is denoted by $⟨ x, y ⟩$ . We assume that $R^{n}$ is endowed with a norm $∥ \cdot ∥$ , and use $∥ \cdot ∥_{*}$ to represent the corresponding dual norm, defined by

∥ y ∥_{*} = sup ∥ x ∥ \leq 1 ⟨ x, y ⟩ .

Ii-B Preliminaries

Next, we review the key definitions and results necessary for developing the main results of this paper. We start with the definition of a Bregman distance function, also referred to as a prox-function.

Definition 1

A function $ω : X \to R$ is called a distance generating function with modulus $μ_{ω} > 0$ with respect to norm $∥ \cdot ∥$ , if $ω$ is continuously differentiable and $μ_{ω}$ -strongly convex with respect to $∥ \cdot ∥$ over the set $X \subseteq R^{n}$ . That is, for all $x, y \in X$ ,

ω (y) \geq ω (x) + ⟨ \nabla ω (x), y - x ⟩ + \frac{μ_{ω}}{2} ∥ y - x ∥^{2} .

Every distance generating function introduces a corresponding Bregman distance function

D_{ω} (x, y) := ω (y) - ω (x) - ⟨ \nabla ω (x), y - x ⟩ .

For example, choosing $ω (x) = \frac{1}{2} ∥ x ∥_{2}^{2}$ , which is $1$ -strongly convex with respect to the $l_{2}$ -norm over any convex set $X$ , would result in $D_{ω} (x, y) = \frac{1}{2} ∥ x - y ∥_{2}^{2}$ . Another common example of distance generating functions is the entropy function

ω (x) = n \sum i = 1 x_{i} log x_{i},

which is $1$ -strongly convex with respect to the $l_{1}$ -norm over the standard simplex

Δ := {x \in R^{n} ∣ ∣ ∣ n \sum i = 1 x_{i} = 1, x \geq 0},

and its associated Bregman distance function is

D_{ω} (x, y) = n \sum i = 1 y_{i} log \frac{y_{i}}{x_{i}} .

The main motivation to use a generalized distance generating function, instead of the usual Euclidean distance function, is to design optimization algorithms that can take advantage of the geometry of the feasible set (see, e.g., [37, 7, 38, 39]).

Remark 1

The strong convexity of the distance generating function $ω$ always ensures that

D_{ω} (x, y) \geq \frac{μ_{ω}}{2} ∥ y - x ∥^{2}, \forall x, y \in X,

and $D_{ω} (x, y) = 0$ if and only if $x = y$ .

Remark 2

Throughout the paper, there is no loss of generality to assume that $μ_{ω} = 1$ . Indeed, if $μ_{ω} \neq 1$ , we can choose the scaled function $¯ ¯ ¯ ω (x) = \frac{1}{μ_{ω}} ω (x)$ , which has modulus ${¯ ¯ ¯ μ}_{ω} = 1$ , to generate the Bregman distance function.

The following definition introduces subgradients of proper convex functions.

Definition 2

For a convex function $Ψ : R^{n} \to R \cup {+ \infty}$ , a vector $s \in R^{n}$ is called a subgradient of $Ψ$ at $x \in R^{n}$ if

Ψ (y) \geq Ψ (x) + ⟨ s, y - x ⟩, \forall y \in R^{n} .

The set of all subgradients of $Ψ$ at $x$ is called the subdifferential of $Ψ$ at $x$ , and is denoted by $\partial Ψ (x)$ .

Iii Problem Setup

We consider stochastic convex optimization problems of the form

(1)

Here, $x \in R^{n}$ is the decision variable, $ξ$

is a random vector whose probability distribution

P

is supported on a set

Ξ \subseteq R^{m}

F (\cdot, ξ)

is convex and differentiable for each

ξ \in Ξ

, and

Ψ (x)

is a proper convex function that may be nonsmooth and extended real-valued. Let us define

f (x) := E_{ξ} [F (x, ξ)] = \int_{Ξ} F (x, ξ) d P (ξ) .

(2)

Note that the expectation function $f$ is convex, differentiable, and $\nabla f (x) = E_{ξ} [\nabla_{x} F (x, ξ)]$ [40]. We use $X^{⋆}$ to denote the set of optimal solutions of Problem (1) and $ϕ^{⋆}$ to denote the corresponding optimal value.

A difficulty when solving optimization problem (1) is that the distribution $P$ is often unknown, so the expectation (2) cannot be computed. This situation occurs frequently in data-driven applications such as machine learning. To support these applications, we do not assume knowledge of $f$ (or of $P$ ), only access to a stochastic oracle. Each time the oracle is queried with an $x \in R^{n}$ , it generates an independent and identically distributed (i.i.d.) sample $ξ$ from $P$ and returns $\nabla_{x} F (x, ξ)$ .

We also impose the following assumptions on Problem (1).

Assumption 1 (Existence of a minimum)

The optimal set $X^{⋆}$ is nonempty.

Assumption 2 (Lipschitz continuity of $F$ )

For each $ξ \in Ξ$ , the function $F (\cdot, ξ)$ has Lipschitz continuous gradient with constant $L$ . That is, for all $y, z \in R^{n}$ ,

∥ \nabla_{x} F (y, ξ) - \nabla_{x} F (z, ξ) ∥_{*} \leq L ∥ y - z ∥ .

Note that under Assumption 2, $\nabla f (x)$ is also Lipschitz continuous with the same constant $L$ [9].

Assumption 3 (Bounded gradient variance)

There exists a constant $σ \geq 0$ such that

E_{ξ} [∥ \nabla_{x} F (x, ξ) - \nabla f (x) ∥_{*}^{2}] \leq σ^{2}, \forall x \in R^{n} .

Assumption 4 (Closed effective domain of $Ψ$ )

The function $Ψ$ is simple and lower semi-continuous, and its effective domain, $d o m Ψ = {x \in R^{n} | Ψ (x) < + \infty}$ , is closed.

Possible choices of $Ψ$ include:

Unconstrained smooth minimization: $Ψ (x) = 0$ .
Constrained smooth minimization: $Ψ$ is the indicator function of a non-empty closed convex set $C \subseteq R^{n}$ , i.e.,

$Ψ (x) = I_{C} (x) :=$ ${\begin{matrix} 0, & i f x \in C, + \infty, & o t h e r w i s e . \end{matrix}$
$l_{1}$ -regularized minimization: $Ψ (x) = λ ∥ x ∥_{1}$ with $λ > 0$ .
Constrained $l_{1}$ -regularized minimization: In this case, $Ψ (x) = λ ∥ x ∥_{1} + I_{C} (x)$ with $λ > 0$ .

Several practical problems in machine learning, statistical applications, and signal processing satisfy Assumptions 1–4 (see, e.g., [2, 3, 4]). One such example is $l_{1}$ -regularized logistic regression for sparse binary classification. We are then given a large number of observations

{ξ_{j} = (a_{j}, b_{j}) | a_{j} \in R^{n}, b_{j} \in {- 1, + 1}, j = 1, \dots, m},

drawn i.i.d. from an unknown distribution $P$ , and want to solve the minimization problem (1) with

F (x, ξ) = log (1 + e x p (- b ⟨ a, x ⟩),

and $Ψ (x) = λ ∥ x ∥_{1}$ . The role of $l_{1}$ regularization is to produce sparse solutions.

One approach for solving Problem (1) is the serial mini-batch method based on the mirror descent scheme [32]. Given a point $x \in d o m Ψ$ , a single processor updates the decision variable $x$ by sampling $b$

i.i.d. random variables

ξ_{1}, \dots, ξ_{b}

from

P

, computing the averaged stochastic gradient

g_{a v e} = \frac{1}{b} b \sum i = 1 \nabla_{x} F (x, ξ_{i}),

and performing the composite mirror descent update

x \leftarrow a r g m i n z {⟨ g_{a v e}, z ⟩ + Ψ (z) + \frac{1}{γ} D_{ω} (x, z)},

where $γ$ is a positive step-size parameter. Under Assumptions 1–4 and choosing an appropriate step-size, this algorithm is guaranteed to converge to the optimum [32, Theorem 9]. However, in many emerging applications, such as large-scale machine learning and statistics, the size of dataset is so huge that it cannot fit on one machine. Hence, we need optimization algorithms that can be conveniently and efficiently executed in parallel on multiple processors.

Iv An Asynchronous Mini-Batch Algorithm

In this section, we will present an asynchronous mini-batch algorithm that exploits multiple processors to solve Problem (1). We characterize the iteration complexity and the convergence rate of the proposed algorithm, and show that these compare favourably with the state of the art.

Iv-a Description of Algorithm

We assume p processors have access to a shared memory for the decision variable $x$ . The processors may have different capabilities (in terms of processing power and access to data) and are able to update $x$ without the need for coordination or synchronization. Conceptually, the algorithm lets each processor run its own stochastic composite mirror descent process, repeating the following steps:

Read $x$ from the shared memory and load it into the local storage location $ˆ x$ ;
Sample $b$ i.i.d random variables $ξ_{1}, \dots, ξ_{b}$ from the distribution $P$ ;
Compute the averaged stochastic gradient vector

${ˆ g}_{a v e} = \frac{1}{b} b \sum i = 1 \nabla_{x} F (ˆ x, ξ_{i});$
Update current $x$ in the shared memory via

$x \leftarrow a r g m i n z {⟨ {ˆ g}_{a v e}, z ⟩ + Ψ (z) + \frac{1}{γ} D_{ω} (x, z)} .$

The algorithm can be implemented in many ways as depicted in Figure 1. One way is to consider the $p$ processors as peers that each execute the four-step algorithm independently of each other and only share the global memory for storing $x$ . In this case, each processor reads the decision vector twice in each round: once in the first step (before evaluating the averaged gradient), and once in the last step (before carrying out the minimization). To ensure correctness, Step 4 must be an atomic operation, where the executing processor puts a write lock on the global memory until it has written back the result of the minimization (cf. Figure 1, left). The algorithm can also be executed in a master-worker setting. In this case, each of the worker nodes retrieves $x$ from the master in Step 1 and returns the averaged gradient to the master in Step 3; the fourth step (carrying out the minimization) is executed by the master (cf. Figure 1, right)

Figure 1: Illustration of two conceptually different realizations of Algorithm 1: $(1)$ a shared memory implementation (left); $(2)$ a master-worker implementation (right). In the shared memory setting shown to the left, processor $P_{2}$ reads $x (2)$ from the shared memory and computes the averaged gradient vector $g_{a v e} (2) = \frac{1}{b} \sum_{i = 1}^{b} \nabla_{x} F (x (2), ξ_{i})$ . As the processors are being run without synchronization, $x (3)$ and $x (4)$ are written to the shared memory by other processors while $P_{2}$ is evaluating $g_{a v e} (2)$ . The figure shows a snapshot of the algorithm at time instance $k = 5$ , at which the shared memory is locked by $P_{2}$ to read the current $x$ , i.e. $x (4)$ , to update it using the out-of-date gradient $g_{a v e} (2)$ , and write $x (5)$ to the memory. In the master-worker setting illustrated to the right, workers evaluate averaged gradient vectors in parallel and send their computations to buffers on the master processor, which is the sole entity with access to the global memory. The master performs an update using (possibly) out-of-date gradients and passes the updated decision vector $x$ back to the workers.

Independently of how we choose to implement the algorithm, processors may work at different rates: while one processor updates the decision vector (in the shared memory setting) or send its averaged gradient to the master (in the master-worker setting), the others are generally busy computing averaged gradient vectors. The processors that perform gradient evaluations do not need to be aware of updates to the decision vector, but can continue to operate on stale information about $x$ . Therefore, unlike synchronous parallel mini-batch algorithms [32], there is no need for processors to wait for each other to finish the gradient computations. Moreover, the value $ˆ x$ at which the average of gradients is evaluated by a processor may differ from the value of $x$ to which the update is applied.

Algorithm 1 describes the $p$ asynchronous processes that run in parallel. To describe the progress of the overall optimization process, we introduce a counter $k$ that is incremented each time $x$ is updated. We let $d (k)$ denote the time at which $ˆ x$ used to compute the averaged gradient involved in the update of $x (k)$ was read from the shared memory. It is clear that $0 \leq d (k) \leq k$ for all $k \in N_{0}$ . The value

τ (k) := k - d (k)

can be viewed as the delay between reading and updating for processors and captures the staleness of the information used to compute the average of gradients for the k-th update. We assume that the delay is not too long, i.e., there is a nonnegative integer $τ_{max}$ such that

0 \leq τ (k) \leq τ_{max} .

The value of $τ_{max}$ is an indicator of the asynchronism in the algorithm and in the execution platform. In practice, $τ_{max}$ will depend on the number of parallel processors used in the algorithm [33, 34, 35]. Note that the cyclic-delay mini-batch algorithm [36], in which the processors are ordered and each updates the decision variable under a fixed schedule, is a special case of Algorithm 1 where $d (k) = k - p + 1$ , or, equivalently, $τ (k) = p - 1$ for all $k$ .

1: Inputs: positive step-sizes

{γ (k)}_{k \in N_{0}}

; batch size

b \in N

2: Initialization:

x (0) \in d o m Ψ

;

k = 0

3: repeat

4: receive inputs

ξ_{1}, \dots, ξ_{b}

sampled i.i.d. from distribution

P

;

	$g_{a v e} (d (k)) \leftarrow \frac{1}{b} b \sum i = 1 \nabla_{x} F (x (d (k)), ξ_{i});$
			(3)
	$k \leftarrow k + 1;$

5: until termination test satisfied

Algorithm 1 Asynchronous Mini-batch Algorithm (running on each processor)

Iv-B Convergence Rate for General Convex Regularization

The following theorem establishes convergence properties of Algorithm 1 when a constant step-size is used.

Theorem 1

Let Assumptions 1–4 hold. Assume also that for all $k \in N_{0}$ ,

γ (k) = γ \in (0, \frac{1}{L (τ_{max} + 1)^{2}}) .

(4)

Then, for every $T \in N$ and any optimizer $x^{⋆}$ of (1), we have

where $x_{a v e} (T)$ is the Cesáro average of the iterates, i.e.,

x_{a v e} (T) := \frac{1}{T} T \sum k = 1 x (k) .

Furthermore, $b$ is the batch size, the expectation is taken with respect to all random variables ${ξ_{i} (k) | i = 1, \dots, b, k = 0, \dots, T - 1}$ , and $c \in [1, b]$ is given by

c = {\begin{matrix} 1, & i f ∥ \cdot ∥_{*} = ∥ \cdot ∥_{2}, 2 {max}_{∥ x ∥ \leq 1} ω (x), & o t h e r w i s e . \end{matrix}

See Appendix -A.

Theorem 1 demonstrates that for any constant step-size $γ$ satisfying (4), the running average of iterates generated by Algorithm 1 will converge in expectation to a ball around the optimum at a rate of $O (1 / T)$ . The convergence rate and the residual error depend on the choice of $γ$ : decreasing $γ$ reduces the residual error, but it also results in a slower convergence. We now describe a possible strategy for selecting the constant step-size. Let $T_{ϵ}$ be the total number of iterations necessary to achieve $ϵ$ -optimal solution to Problem (1), that is, $E [ϕ (x_{a v e} (T))] - ϕ^{⋆} \leq ϵ$ when $T \geq T_{ϵ}$ . If we pick

γ = \frac{ϵ}{L ϵ (τ_{max} + 1)^{2} + c σ^{2} / b},

(5)

it follows from Theorem 1 that the corresponding $x_{a v e} (T)$ satisfies

where $ϵ_{0} = D_{ω} (x (0), x^{⋆})$ . This inequality tells us that if the first term on the right-hand side is less than $ϵ / 2$ , i.e., if

T \geq T_{ϵ} := 2 ϵ_{0} (\frac{L (τ_{max} + 1)^{2}}{ϵ} + \frac{c σ^{2}}{b ϵ^{2}}),

then $E [ϕ (x_{a v e} (T))] - ϕ^{⋆} \leq ϵ$ . Hence, the iteration complexity of Algorithm 1 with the step-size choice (5) is given by

O (\frac{L (τ_{max} + 1)^{2}}{ϵ} + \frac{c σ^{2}}{b ϵ^{2}}) .

(6)

As long as the maximum delay bound $τ_{max}$ is of the order $1 / \sqrt{ϵ}$ , the first term in (6) is asymptotically negligible, and hence the iteration complexity of Algorithm 1 is asymptotically $O (c σ^{2} / b ϵ^{2})$ , which is exactly the iteration complexity achieved by the mini-batch algorithm for solving stochastic convex optimization problems in a serial setting [32]. As discussed before, $τ_{max}$ is related to the number of processors used in the algorithm. Therefore, if the number of processors is of the order of $O (1 / \sqrt{ϵ})$ , parallelization does not appreciably degrade asymptotic convergence of Algorithm 1. Furthermore, as $p$ processors are being run in parallel, updates occur roughly $p$ times as quickly and in time scaling as $T / p$ , the processors may compute $T$ averaged gradient vectors (instead of $T / p$ vectors). This means that the near-linear speedup in the number of processors can be expected.

Remark 3

Another strategy for the selection of the constant step-size in Algorithm 1 is to use $γ$ that depends on the prior knowledge of the number of iterations to be performed. More precisely, assume that the number of iterations is fixed in advance, say equal to $T_{F}$ . By choosing $γ$ as

γ = \frac{1}{L (τ_{max} + 1)^{2} + α \sqrt{T_{F}}},

for some $α > 0$ , it follows from Theorem 1 that the running average of the iterates after $T_{F}$ iterations satisfies

E [ϕ (x_{a v e} (T_{F}))] - ϕ^{⋆} \leq

It is easy to verify that the optimal choice of $α$ , which minimizes the second term on the right-hand-side of the above inequality, is

α^{⋆} = \frac{σ \sqrt{c}}{\sqrt{2 b D_{ω} (x (0), x^{⋆})}} .

With this choice of $α$ , we then have

E [ϕ (x_{a v e} (T_{F}))] - ϕ^{⋆} \leq

In the case that $τ_{max} = 0$ , the preceding guaranteed bound reduces to the one obtained in [8, Theorem 1] for the serial stochastic mirror descent algorithm with constant step-sizes. Note that in order to implement Algorithm 1 with the optimal constant step-size policy, we need to estimate an upper bound on $D_{ω} (x (0), x^{⋆})$ , since $D_{ω} (x (0), x^{⋆})$ is usually unknown.

The following theorem characterizes the convergence of Algorithm 1 with a time-varying step-size sequence when $d o m Ψ$ is bounded in addition to being closed and convex.

Theorem 2

Suppose that Assumptions 1–4 hold. In addition, suppose that $d o m Ψ$ is compact and that $D_{ω} (\cdot, \cdot)$ is bounded on $d o m Ψ$ . Let

R^{2} = max x, y \in d o m Ψ D_{ω} (x, y) .

If ${γ (k)}_{k \in N_{0}}$ is set to $γ (k)^{- 1} = L (τ_{max} + 1)^{2} + α (k)$ with

α (k) = \frac{σ \sqrt{c} \sqrt{k + 1}}{R \sqrt{b}},

then the Cesáro average of the iterates generated by Algorithm 1 satisfies

for all $T \in N$ .

See Appendix -B.

The time-varying step-size $γ (k)$ , which ensures the convergence of the algorithm, consists of two terms: the time-varying term $η (k)$ should control the errors from stochastic gradient information while the role of the constant term ( $L (τ_{max} + 1)^{2}$ ) is to decrease the effects of asynchrony (bounded delays) on the convergence of the algorithm. According to Theorem 2, in the case that $τ_{max} = O (T^{1 / 4})$ , the delay becomes increasingly harmless as the algorithm progresses and the expected function value evaluated at $x_{a v e} (T)$ converges asymptotically at a rate $O (1 / \sqrt{T})$ , which is known to be the best achievable rate of the mirror descent method for nonsmooth stochastic convex optimization problems [7].

For the special case of the optimization problem (1) where $Ψ$ is restricted to be the indicator function of a compact convex set, Agarwal and Duchi [36, Theorem 2] showed that the convergence rate of the delayed stochastic mirror descent method with time-varying step-size is

O (\frac{L R^{2} + R G τ_{max}}{T} + \frac{σ R \sqrt{c}}{\sqrt{T b}} + \frac{L R^{2} G^{2} τ_{max}^{2} b log T}{c σ^{2} T}),

where $G$ is the maximum bound on $\sqrt{E [∥ \nabla_{x} F (x, ξ) ∥_{*}^{2}]}$ . Comparing with this result, instead of a asymptotic penalty of the form $O (τ_{max}^{2} log T / T)$ due to the delays, we have the penalty $O (τ_{max}^{2} / T)$ , which is much smaller for large $T$ . Therefore, not only do we extend the result of [36] to general regularization functions, but we also obtain a sharper guaranteed convergence rate than the one presented in [36].

Iv-C Convergence Rate for Strongly Convex Regularization

In this subsection, we restrict our attention to stochastic composite optimization problems with strongly convex regularization terms. Specifically, we assume that $Ψ$ is $μ_{Ψ}$ -strongly convex with respect to $∥ \cdot ∥$ , that is, for any $x, y \in d o m Ψ$ ,

Ψ (y) \geq Ψ (x) + ⟨ s, y - x ⟩ + \frac{μ_{Ψ}}{2} ∥ y - x ∥^{2}, \forall s \in \partial Ψ (x) .

Examples of the strongly convex function $Ψ$ include:

$l_{2}$ -regularization: $Ψ (x) = (ρ / 2) ∥ x ∥_{2}^{2}$ with $ρ > 0$ .
Elastic net regularization: $Ψ (x) = λ ∥ x ∥_{1} + (ρ / 2) ∥ x ∥_{2}^{2}$ with $λ > 0$ and $ρ > 0$ .

Remark 4

The strong convexity of $Ψ$ implies that Problem (1) has a unique minimizer $x^{⋆}$ [41, Corollary 11.16].

In order to derive the convergence rate of Algorithm 1 for solving (1) with a strongly convex regularization term, we need to assume that the Bregman distance function $D (x, y)$ used in the algorithm satisfies the next assumption.

Assumption 5 (Quadratic growth condition)

For all $x, y \in d o m Ψ$ , we have

D_{ω} (x, y) \leq \frac{Q}{2} ∥ x - y ∥^{2},

with $Q \geq μ_{ω}$ .

For example, if $ω (x) = \frac{1}{2} ∥ x ∥_{2}^{2}$ , then $D_{ω} (x, y) = \frac{1}{2} ∥ x - y ∥_{2}^{2}$ and $Q = 1$ . Note that Assumption 5 will automatically hold when the distance generating function $ω$ has Lipschitz continuous gradient with a constant $Q$ [12].

The associated convergence result now reads as follows.

Theorem 3

Suppose that the regularization function $Ψ$ is $μ_{Ψ}$ -strongly convex and that Assumptions 2–5 hold. If ${γ (k)}_{k \in N_{0}}$ is set to $γ (k)^{- 1} = 2 L (τ_{max} + 1)^{2} + β (k)$ with

β (k) = \frac{μ_{Ψ}}{3 Q} (k + τ_{max} + 1),

then the iterates produced by Algorithm 1 satisfies

E [∥ x (T)

- x^{⋆} ∥^{2}] \leq \frac{2 {(\frac{6 L Q}{μ_{Ψ}} + 1)}^{2} (τ_{max} + 1)^{4}}{(T + 1)^{2}} D_{ω} (x (0), x^{⋆}) + \frac{18 c σ^{2} Q^{2}}{b μ_{Ψ}^{2} (T + 1)},

for all $T \in N$ .

See Appendix -C.

An interesting point regarding Theorem 3 is that for solving stochastic composite optimization problems with strongly convex regularization functions, the maximum delay bound $τ_{max}$ can be as large as $O (T^{1 / 4})$ without affecting the asymptotic convergence rate of Algorithm 1. In this case, our asynchronous mini-batch algorithm converges asymptotically at a rate of $O (1 / T)$ , which matches the best known rate achievable in a serial setting.

V Experimental Results

We have developed a complete master-worker implementation of our algorithm in C/++ using the Massage Passing Interface libraries (OpenMPI). Although we argued in Section IV that Algorithm 1 can be implemented using atomic operations on shared-memory computing architectures, we have chosen the MPI implementation due to its flexibility in scaling the problem to distributed-memory environments.

We evaluated our algorithm on a document classification problem using the text categorization dataset rcv1 [42]. This dataset consists of $m \approx 800000$ documents, with $n \approx 50000$

unique stemmed tokens spanning 103 topics. Out of these topics, we decided to classify sports-related documents. To this end, we trained a sparse (binary) classifier by solving the following

l_{1}

-regularized logistic regression problem

	$m i n i m i z e x E_{{(a_{i}, b_{i})}} [log (1 + exp (- b_{i} ⟨ a_{i}, x ⟩))] + λ ∥ x ∥_{1}$
	$s u b j e c t t o ∥ x ∥_{2} \leq R .$

Here, $a_{i} \in R^{n}$ is the sparse vector of token weights assigned to each document, and $b_{i} \in {- 1, 1}$ indicates whether a selected document is sports-related, or not ( $b_{i}$ is $1$ if the document is about sport, $- 1$ otherwise). To evaluate scalability, we used both the training and test sets available when solving the optimization problem. We implemented Algorithm 1 with time-varying step-sizes, and used a batch size of 1000 documents. The regularization parameter was set to $λ = 0.01$ , and the algorithm was run until a fixed tolerance $ϵ$ was met.

Figure 2 presents the achieved relative speedup of the algorithm with respect to the number of workers used. The relative speedup of the algorithm on $p$ processors is defined as $S (p) = t_{1} / t_{p}$ , where $t_{1}$ and $t_{p}$ are the time it takes to run the corresponding algorithm (to $ϵ$ -accuracy) on 1 and $p$ processing units, respectively. We observe a near-linear relative speedup, consistent with our theoretical results. The timings are averaged over 10 Monte Carlo runs.

Figure 2: Speedup of Algorithm 1 with respect to the number of workers.

Vi Conclusions

We have proposed an asynchronous mini-batch algorithm that exploits multiple processors to solve regularized stochastic optimization problems with smooth loss functions. We have established that for closed and convex constraint sets, the iteration complexity of the algorithm with constant step-sizes is asymptotically $O (1 / ϵ^{2})$ . For compact constraint sets, we have proved that the running average of the iterates generated by our algorithm with time-varying step-size converges to the optimum at a rate $O (1 / \sqrt{T})$ . When the regularization function is strongly convex and the constraint set is closed and convex, the algorithm achieves the rate of the order $O (1 / T)$ . We have shown that the penalty in convergence rate of the algorithm due to asynchrony is asymptotically negligible and a near-linear speedup in the number of processors can be expected. Our computational experience confirmed the theory.

In this section, we prove the main results of the paper, namely, Theorems 1–3. We first state three key lemmas which are instrumental in our argument.

The following result establishes an important recursion for the iterates generated by Algorithm 1.

Lemma 1

Suppose Assumptions 1–4 hold. Then, the iterates ${x (k)}_{k \in N_{0}}$ generated by Algorithm 1 satisfy

$ϕ (x (k + 1)) - ϕ^{⋆} + \frac{1}{γ (k)} D_{ω} (x (k + 1), x^{⋆})$	$\leq \frac{1}{2 η (k)} ∥ ∥ e (d (k)) {∥ ∥}_{*}^{2}$

	$+ \frac{L (τ_{max} + 1)}{2} τ_{max} \sum j = 0 ∥ ∥ x (k - j) - x (k - j + 1) {∥ ∥}^{2}$
	$- \frac{1}{2} (\frac{1}{γ (k)} - η (k)) ∥ x (k + 1) - x (k) ∥^{2}$
	$- \frac{μ_{Ψ}}{2} ∥ ∥ x (k + 1) - x^{⋆}) {∥ ∥}^{2},$	(7)

where $x^{⋆} \in X^{⋆}$ , ${η (k)}$ is a sequence of strictly positive numbers, and $e (k) := \nabla f (x (k)) - g_{a v e} (k)$ is the error in the gradient estimate.

We start with the first-order optimality condition for the point $x (k + 1)$ in the minimization problem (3): there exists subgradient $s (k + 1) \in \partial Ψ (x (k + 1))$ such that for all $z \in d o m Ψ$ , we have

⟨ g_{a v e} (d (k)) + s (k + 1) + \frac{1}{γ (k)} \nabla_{(2)} D_{ω} (x (k), x (k + 1)), z - x (k + 1) ⟩ \geq 0,

where $\nabla_{(2)} D_{ω} (\cdot, \cdot)$ denotes the partial derivative of the Bregman distance function with respect to the second variable. Plugging the following equality

\nabla_{(2)} D_{ω} (x (k), x (k + 1)) = \nabla ω (x (k + 1)) - \nabla ω (x (k)),

into the previous inequality and re-arranging terms gives

		$\leq ⟨ g_{a v e} (d (k)) + s (k + 1), z - x (k + 1) ⟩$
		$= ⟨ g_{a v e} (d (k)), z - x (k + 1) ⟩$
		$+ ⟨ s (k + 1), z - x (k + 1) ⟩$
		$\leq ⟨ g_{a v e} (d (k)), z - x (k + 1) ⟩$
		$+ Ψ (z) - Ψ (x (k + 1)) - \frac{μ_{Ψ}}{2} ∥ ∥ z - x (k + 1) {∥ ∥}^{2},$		(8)

where the last inequality used

Ψ (z) \geq Ψ (x (k + 1)) + ⟨ s (k + 1), z - x (k + 1) ⟩ + \frac{μ_{Ψ}}{2} ∥ ∥ z - x (k + 1) {∥ ∥}^{2},

by the (strong) convexity of $Ψ$ . We now use the following well-known three point identity of the Bregman distance function [43] to rewrite the left-hand side of (8):

⟨ \nabla ω (a) - \nabla ω (b), c - b ⟩ = D_{ω} (a, b) - D_{ω} (a, c) + D_{ω} (b, c) .

From this relation, with $a = x (k)$ , $b = x (k + 1)$ , and $c = z$ , we have

⟨ \nabla ω (x (k))

- \nabla ω (x (k + 1)), z - x (k + 1) ⟩ = D_{ω} (x (k), x (k + 1)) - D_{ω} (x (k), z) + D_{ω} (x (k + 1), z) .

Substituting the preceding equality into (8) and re-arranging terms result in

	$Ψ (x (k + 1)) - Ψ (z) + \frac{1}{γ (k)} D_{ω} (x (k + 1), z)$	$\leq ⟨ g_{a v e} (d (k)), z - x (k + 1) ⟩ + \frac{1}{γ (k)} D_{ω} (x (k), z)$
		$- \frac{1}{γ (k)} D_{ω} (x (k), x (k + 1)) - \frac{μ_{Ψ}}{2} ∥ ∥ z - x (k + 1) {∥ ∥}^{2} .$

Since the distance generating function $ω (x)$ is $1$ -strongly convex, we have the lower bound

D_{ω} (x (k), x (k + 1)) \geq \frac{1}{2} ∥ x (k + 1) - x (k) ∥^{2},

which implies that

	$Ψ (x (k + 1)) - Ψ (z) + \frac{1}{γ (k)} D_{ω} (x (k + 1), z)$	$\leq ⟨ g_{a v e} (d (k)), z - x (k + 1) ⟩ + \frac{1}{γ (k)} D_{ω} (x (k), z)$
		$- \frac{1}{2 γ (k)} ∥ x (k + 1) - x (k) ∥^{2} - \frac{μ_{Ψ}}{2} ∥ ∥ z - x (k + 1) {∥ ∥}^{2} .$		(9)

The essential idea in the rest of the proof is to use convexity and smoothness of the expectation function $f$ to bound $f (x (k + 1) - f (z)$ for each $z \in d o m Ψ$ and each $k \in N_{0}$ . According to Assumption 2, $\nabla F (x, ξ)$ and, hence, $\nabla f (x)$ are Lipschitz continuous with the constant $L$ . By using the $L$ -Lipschitz continuity of $\nabla f$ and then the convexity of $f$ , we have

	$f (x (k + 1))$	$\leq f (x (d (k))) + ⟨ \nabla f (x (d (k))), x (k + 1) - x (d (k)) ⟩ + \frac{L}{2} ∥ x (k + 1) - x (d (k)) ∥^{2}$
		$\leq f (z) + ⟨ \nabla f (x (d (k))), x (k + 1) - z ⟩ + \frac{L}{2} ∥ ∥ x (k + 1) - x (d (k)) {∥ ∥}^{2},$		(10)

for any $z \in d o m Ψ$ . Combining inequalities (9) and (10), and recalling that $ϕ (x) = f (x) + Ψ (x)$ , we obtain

	$ϕ (x (k + 1)) - ϕ (z) + \frac{1}{γ (k)} D_{ω} (x (k + 1), z)$	$\leq ⟨ \nabla f (x (d (k))) - g_{a v e} (d (k)), x (k + 1) - z ⟩ + \frac{1}{γ (k)} D_{ω} (x (k), z)$
		$- \frac{1}{2 γ (k)} ∥ x (k + 1) - x (k) ∥^{2} - \frac{μ_{Ψ}}{2} ∥ ∥ z - x (k + 1) {∥ ∥}^{2}$
		$+ \frac{L}{2} ∥ x (k + 1) - x (d (k)) ∥^{2} .$

We now rewrite the above inequality in terms of the error $e (d (k)) = \nabla f (x (d (k))) - g_{a v e} (d (k))$ as follows:

$ϕ (x (k + 1)) - ϕ (z) + \frac{1}{γ (k)} D_{ω} (x (k + 1), z)$	$\leq ⟨ e (d (k)), x (k + 1) - z ⟩ + \frac{1}{γ (k)} D_{ω} (x (k), z)$
	$- \frac{1}{2 γ (k)} ∥ x (k + 1) - x (k) ∥^{2} - \frac{μ_{Ψ}}{2} ∥ ∥ z - x (k + 1) {∥ ∥}^{2}$
	$+ \frac{L}{2} ∥ x (k + 1) - x (d (k)) ∥^{2}$

	$+ ⟨ e (d (k)), x (k) - z ⟩ + \frac{1}{γ (k)} D_{ω} (x (k), z)$
	$- \frac{1}{2 γ (k)} ∥ x (k + 1) - x (k) ∥^{2} - \frac{μ_{Ψ}}{2} ∥ ∥ z - x (k + 1) {∥ ∥}^{2}$
	$+ \frac{L}{2} ∥ x (k + 1) - x (d (k)) ∥^{2}      U_{2} .$	(11)

We will seek upper bounds on the quantities $U_{1}$ and $U_{2}$ . Let ${η (k)}_{k \in N_{0}}$ be a sequence of positive numbers. For $U_{1}$ , we have

	$U_{1}$
		$\leq \frac{1}{2 η (k)} ∥ ∥ e (d (k)) {∥ ∥}_{*}^{2} + \frac{η (k)}{2} ∥ ∥ x (k + 1) - x (k) {∥ ∥}^{2},$		(12)

where the second inequality follows from the Fenchel-Young inequality applied to the conjugate pair $\frac{1}{2} ∥ \cdot ∥^{2}$ and $\frac{1}{2} ∥ \cdot ∥_{*}^{2}$ , i.e.,

We now turn to $U_{2}$ . It follows from definition $τ (k) = k - d (k)$ that

	$U_{2}$	$= (k - d (k) + 1)^{2} {∥ ∥ ∥ ∥ k - d (k) \sum j = 0 \frac{x (k - j) - x (k - j + 1)}{k - d (k) + 1} ∥ ∥ ∥ ∥}^{2}$
		$= (τ (k) + 1)^{2} {∥ ∥ ∥ ∥ τ (k) \sum j = 0 \frac{x (k - j) - x (k - j + 1)}{τ (k) + 1} ∥ ∥ ∥ ∥}^{2} .$

Then, by the convexity of the norm $∥ \cdot ∥$ , we conclude that

	$U_{2}$	$\leq (τ (k) + 1) τ (k) \sum j = 0 ∥ ∥ x (k - j) - x (k - j + 1) {∥ ∥}^{2}$
				(13)

where the last inequality comes from our assumption that $τ (k) \leq τ_{max}$ for all $k \in N_{0}$ . Substituting inequalities (12) and (13) into the bound (11) and simplifying yield

	$ϕ (x (k + 1)) - ϕ (z) + \frac{1}{γ (k)} D_{ω} (x (k + 1), z)$	$\leq \frac{1}{2 η (k)} ∥ ∥ e (d (k)) {∥ ∥}_{*}^{2}$
		$+ ⟨ e (d (k)), x (k) - z ⟩ + \frac{1}{γ (k)} D_{ω} (x (k), z)$
		$+ \frac{L (τ_{max} + 1)}{2} τ_{max} \sum j = 0 ∥ ∥ x (k - j) - x (k - j + 1) {∥ ∥}^{2}$
		$- \frac{1}{2} (\frac{1}{γ (k)} - η (k)) ∥ x (k + 1) - x (k) ∥^{2}$
		$- \frac{μ_{Ψ}}{2} ∥ ∥ z - x (k + 1) {∥ ∥}^{2} .$

Setting $z = x^{⋆}$ , where $x^{⋆} \in X^{⋆}$ , completes the proof.

The next result follows from Lemma 1 by taking summation of the relations in (7).

Lemma 2

Let Assumptions 1–4 hold. Assume also that ${γ (k)}_{k \in N_{0}}$ is set to

An Asynchronous Mini-Batch Algorithm for Regularized Stochastic Optimization

Authors

Local SGD Converges Fast and Communicates Little

Mini-Batch Stochastic ADMMs for Nonconvex Nonsmooth Optimization

Analysis and Implementation of an Asynchronous Optimization Algorithm for the Parameter Server

Asynchronous Distributed Optimization with Randomized Delays

Stochastic Optimization with Laggard Data Pipelines

Maiter: An Asynchronous Graph Processing Framework for Delta-based Accumulative Iterative Computation

Towards Practical Adam: Non-Convexity, Convergence Theory, and Mini-Batch Acceleration

I Introduction

Ii Notation and Preliminaries

Ii-a Notation

Ii-B Preliminaries

Definition 1

Remark 1

Remark 2

Definition 2

Iii Problem Setup

Assumption 1 (Existence of a minimum)

Assumption 2 (Lipschitz continuity of $F$ )

Assumption 3 (Bounded gradient variance)

Assumption 4 (Closed effective domain of $Ψ$ )

Iv An Asynchronous Mini-Batch Algorithm

Iv-a Description of Algorithm

Iv-B Convergence Rate for General Convex Regularization

Theorem 1

Remark 3

Theorem 2

Iv-C Convergence Rate for Strongly Convex Regularization

Remark 4

Assumption 5 (Quadratic growth condition)

Theorem 3

V Experimental Results

Vi Conclusions

Lemma 1

Lemma 2

An Asynchronous Mini-Batch Algorithm for Regularized Stochastic Optimization

Authors

Local SGD Converges Fast and Communicates Little

Mini-Batch Stochastic ADMMs for Nonconvex Nonsmooth Optimization

Analysis and Implementation of an Asynchronous Optimization Algorithm for the Parameter Server

Asynchronous Distributed Optimization with Randomized Delays

Stochastic Optimization with Laggard Data Pipelines

Maiter: An Asynchronous Graph Processing Framework for Delta-based Accumulative Iterative Computation

Towards Practical Adam: Non-Convexity, Convergence Theory, and Mini-Batch Acceleration

This week in AI

I Introduction

Ii Notation and Preliminaries

Ii-a Notation

Ii-B Preliminaries

Definition 1

Remark 1

Remark 2

Definition 2

Iii Problem Setup

Assumption 1 (Existence of a minimum)

Assumption 2 (Lipschitz continuity of F)

Assumption 3 (Bounded gradient variance)

Assumption 4 (Closed effective domain of Ψ)

Iv An Asynchronous Mini-Batch Algorithm

Iv-a Description of Algorithm

Iv-B Convergence Rate for General Convex Regularization

Theorem 1

Remark 3

Theorem 2

Iv-C Convergence Rate for Strongly Convex Regularization

Remark 4

Assumption 5 (Quadratic growth condition)

Theorem 3

V Experimental Results

Vi Conclusions

Lemma 1

Lemma 2

Assumption 2 (Lipschitz continuity of $F$ )

Assumption 4 (Closed effective domain of $Ψ$ )