A randomized primal distributed algorithm for partitioned and big-data non-convex optimization

TL;DR

This paper introduces a simple, randomized primal distributed algorithm for large-scale, partitioned, non-convex optimization problems in network settings, demonstrating convergence and effectiveness through theoretical analysis and simulations.

Contribution

It proposes a novel asynchronous, randomized primal algorithm for distributed non-convex optimization that converges to stationary points, suitable for big-data network applications.

Findings

Algorithm converges to stationary points in non-convex settings.

Effective in asynchronous gossip communication environments.

Numerical simulations confirm theoretical convergence results.

Abstract

In this paper we consider a distributed optimization scenario in which the aggregate objective function to minimize is partitioned, big-data and possibly non-convex. Specifically, we focus on a set-up in which the dimension of the decision variable depends on the network size as well as the number of local functions, but each local function handled by a node depends only on a (small) portion of the entire optimization variable. This problem set-up has been shown to appear in many interesting network application scenarios. As main paper contribution, we develop a simple, primal distributed algorithm to solve the optimization problem, based on a randomized descent approach, which works under asynchronous gossip communication. We prove that the proposed asynchronous algorithm is a proper, ad-hoc version of a coordinate descent method and thus converges to a stationary point. To show the effectiveness of the proposed algorithm, we also present numerical simulations on a non-convex quadratic program, which confirm the theoretical results.

Figures

Equations

$$x=[x_1^{\top },\dots ,x_N^{\top }{]}^{\top },$$

$$\underset{x{\in }^n}{\min }$$

$$\Vert {\nabla }_{x_j}{f}_i(x_{{\mathcal{N}}_i}+U_{ij}{s}_j)-{\nabla }_{x_j}{f}_i(x_{{\mathcal{N}}_i})\Vert \le L_{ij}\Vert s_j\Vert .$$

$$q_i(s_i;\bar{x})$$

$$=\sum _{j\in {\mathcal{N}}_i}{\nabla }_{x_i}{f}_j({\bar{x}}_{{\mathcal{N}}_j}{)}^{\top }{s}_i+\frac{1}{2}\Vert s_i{\Vert }_{Q_i(\bar{x})}^2+g_i({\bar{x}}_i+s_i)$$

$$d_i={\mathrm{argmin}}_{s_i}{q}_i(s_i;\bar{x})$$

$${\bar{x}}_i^{+}={\bar{x}}_i+d_i$$

$$\displaystyle\mathbf{prox}_{W,\varphi}(v):=\mathop{\rm argmin}_{x}\Big{\{}\varphi(x)+\frac{1}{2}\big{\|}x-v\big{\|}^{2}_{W^{-1}}\Big{\}},$$

$${\bar{x}}_i^{+}$$

$$\displaystyle\Pr\Big{(}V(x(t))=V^{\star}\Big{)}=1.$$

$$d_{i_t}={\mathrm{argmin}}_{s_i}{q}_{i_t}(s_i;x(t))$$

$$\begin{array}{rl}{x}_{i_t}(t+1)& =x_{i_t}(t)+d_{i_t}\\ x_j(t+1)& =x_j(t),\text{for all }j\ne i_t\end{array}$$

$$V(x(t+1))\le V(x(t))-\frac{L_{i_t}}{2}\Vert d_{i_t}{\Vert }^2.$$

$$\begin{array}{rl}V(\bar{x}+U_i{s}_i)& \le f(\bar{x})+{\nabla }_{x_i}f(\bar{x}{)}^{\top }{s}_i\\ & +\frac{L_i}{2}\Vert s_i{\Vert }^2+g_i({\bar{x}}_i+s_i)+{\sum }_{j\ne i}{g}_j({\bar{x}}_j),\end{array}$$

$$\begin{array}{rl}V(\bar{x}+U_i{s}_i)& \le f(\bar{x})+{\nabla }_{x_i}f(\bar{x}{)}^{\top }{s}_i\\ & +\frac{1}{2}\Vert s_i{\Vert }_{Q_i(\bar{x})}^2+g_i({\bar{x}}_i+s_i)+{\sum }_{j\ne i}{g}_j({\bar{x}}_j)\end{array}$$

$$V(\bar{x}+U_i{s}_i)\le q_i(s_i;\bar{x})+f(\bar{x})+{\sum }_{j\ne i}{g}_j({\bar{x}}_j).$$

$${\nabla }_{x_{i_t}}f(x(t))+Q_{i_t}(x(t))d_{i_t}+\tilde{\nabla }{g}_{i_t}(x_{i_t}(t)+d_{i_t})=0,$$

$$\begin{array}{rl}V(x(t+1))& \le V(x(t))+{\nabla }_{x_{i_t}}f(x(t){)}^{\top }{d}_{i_t}+\frac{1}{2}\Vert d_{i_t}{\Vert }_{Q_{i_t}(x(t))}^2\\ & +g_{i_t}(x_{i_t}(t)+d_{i_t})-g_{i_t}(x_{i_t}(t))\\ & \le V(x(t))+{\nabla }_{x_{i_t}}f(x(t){)}^{\top }{d}_i\\ & +\frac{1}{2}\Vert d_{i_t}{\Vert }_{Q_{i_t}(x(t))}^2+\tilde{\nabla }{g}_{i_t}(x_{i_t}(t)+d_{i_t}{)}^{\top }{d}_{i_t}\\ & \le V(x(t))-\frac{1}{2}\Vert d_{i_t}{\Vert }_{Q_{i_t}(x(t))}^2\\ & \le V(x(t))-\frac{L_i}{2}\Vert d_{i_t}{\Vert }^2\end{array}$$

$$\nabla f(x^{\star })+\tilde{\nabla }g(x^{\star })=0$$

$$\underset{x{\in }^n}{\min }$$

$$f_i(x_{{\mathcal{N}}_i}):=x_{{\mathcal{N}}_i}^{\top }{H}_i{x}_{{\mathcal{N}}_i}+r_i^{\top }{x}_{{\mathcal{N}}_i}$$

$$g_i(x_i):=I_{X_i}(x_i)=\{\begin{array}{ll}{x}_i& \text{ if }{\ell }_i\le x_i\le u_i\\ +\infty & \text{ otherwise.}\end{array}$$

Full text

I Introduction

In several network scenarios optimization problems arise in which an aggregate cost function, sum of local cost functions, needs to be minimized in a distributed way. A typical approach in distributed optimization is to develop algorithms in which the processors in the network reach consensus on a minimizer of the problem. However, when the dimension of the decision variable depends on the number of agents in the network the consensus approach gives rise to algorithms which scale badly with the network size. Enforcing consensus on the entire vector of decision variables is not necessary in many important applications, since the nodes are interested in computing only part of the decision vector, namely only some local variables of interest. In this paper we consider a partitioned problem set-up in which the aggregate function is the sum of local functions, each one depending only on a portion of the decision vector. For this set-up our goal is to design a distributed algorithm in which the nodes compute only a local portion of interest of the entire solution vector, so that the whole minimizer can be obtained by stacking together the local portions.

This partitioned set-up has been introduced in [1] where a distributed ADMM-based algorithm is proposed. In [2] some concrete motivating scenarios are described for the same set-up and a dual decomposition algorithm is proposed. In both the above references the algorithms are designed for a synchronous network with a fixed communication graph. In [3], an analogous problem formulation is considered within a parallel context. The authors propose a coordinate descent method and derive its convergence rate. In [4] the authors propose a distributed algorithm for a partitioned quadratic program under lossy communication. A distributed ADMM-based algorithm with applications in MPC is proposed in [5] to deal with an unconstrained optimization problem with local domains which is related to the set-up in this paper.

Usually, distributed approaches need a common clock (e.g., because a diminishing (time-varying) step-size is used). We want to avoid this limitation designing an asynchronous, event-triggered protocol based on local and independent timers, [6]. A Newton-Raphson consensus strategy is proposed in [7] to solve unconstrained, convex optimization problems under asynchronous, symmetric gossip communications. In [8] a self-triggered communication protocol is considered. Based on an error condition a distributed, continuous-time algorithm is developed. In [9] an asynchronous ADMM-based distributed method is proposed for a separable, constrained optimization problem with a convergence rate $O(1/t)$. A distributed, asynchronous algorithm for constrained optimization based on random projections is proposed in [10].

The asynchronous, distributed algorithm we design in this paper is based on a (randomized) coordinate descent method. In [11] the coordinate method for huge scale optimization has been introduced. This powerful approach has been extended to deal with (convex) composite objective functions and parallel scenarios, see [12, 13, 3]. In [14] a coordinate approach to solve linearly constrained problems has been proposed. Using a coordinate ADMM-based approach, in [15] a distributed, asynchronous algorithm is developed.

Regarding non-convex optimization problems, in [16], the authors extend the coordinate approach to large-scale non-convex optimization proving the rate of convergence of their algorithms. A parallel algorithm based on local strongly convex approximations is exploited in [17] to cope with non-convex optimization problems. The latter approach has been extended to a distributed context in [18]. In [19], the authors proposed an auction-based distributed algorithm for non-convex optimization.

As main paper contribution we propose an asynchronous, distributed algorithm to solve partitioned, big-data non-convex optimization problems. The proposed primal algorithm is based on local updates involving the minimization of a strongly convex, quadratic approximation of the objective function. Each node constructs this approximation by exchanging information only with neighboring nodes. The updates at each node are regulated by a local timer that triggers independently from the ones of the other nodes. We prove the convergence in probability of the distributed algorithm by showing that it is equivalent to a generalized coordinate descent method for the minimization of non-convex composite functions. The generalized coordinate descent algorithm extends the one proposed in [16] and thus represents a side interesting result.

The paper is organized as follows. In Section II we present the problem set-up. In Section III we propose our algorithm and prove its convergence in Section IV. Finally, in Section V we show some simulations.

Notation

Consider a vector $x\in^{n}$ partitioned in $N$ block-components as follows

[TABLE]

where, for all $i\in\{1,\ldots,N\}$, we have $x_{i}\in^{n_{i}}$ and $\sum_{i=1}^{N}n_{i}=n$. Moreover, consider a block decomposition of the $N\times N$ identity matrix $I=[U_{1},\ldots,U_{N}]$, where for all $i\in\{1,\ldots,N\}$ each $U_{i}\in^{n\times n_{i}}$. Then we can write $x_{i}=U_{i}^{\top}x$ and $x=\sum_{i=1}^{N}U_{i}x_{i}$. For a function $\varphi:^{n}\rightarrow$, we denote $\nabla_{x_{i}}\varphi(\bar{x})=U_{i}^{\top}\nabla\varphi(\bar{x})$ the “partial” gradient of $\varphi$ with respect to $x_{i}\in^{n_{i}}$.

II Optimization problem set-up

We consider a network of $N$ nodes which can interact according to a fixed, undirected communication graph $\mathcal{G}=(\{1,\ldots,N\},\mathcal{E})$, where $\mathcal{E}\subseteq\{1,\ldots,N\}\times\{1,\ldots,N\}$ is the set of edges. That is, the edge $(i,j)$ models the fact that node $i$ and $j$ can exchange information. We denote by $\mathcal{N}_{i}$ the set of neighbors of node $i$ in the fixed graph $\mathcal{G}$, i.e., $\mathcal{N}_{i}:=\left\{j\in\{1,\ldots,N\}\mid(i,j)\in\mathcal{E}\right\}$, and by $|\mathcal{N}_{i}|$ its cardinality. Here we assume that the graph contains also self-edges, so that $\mathcal{N}_{i}$ contains also $i$.

We want to stress that the fixed graph only models, for each node, the set of possible neighbors the node can communicate with. On top of this graph, we will consider an asynchronous communication protocol described later.

We start by a common set-up in distributed optimization, i.e., the minimization of a separable cost function composed by two contributions, i.e., $\min_{x\in^{n}}\>\>\sum_{i=1}^{N}f_{i}(x)+g_{i}(x)$, where $f_{i}:^{n}\to$ and $g_{i}:^{n}\to\cup\{+\infty\}$, with $N,n\in{\mathbb{N}}$. Usually this composite structure of the objective functions, is used to split the effective cost into a smooth part (modeling some local objective) and a (possibly) non-smooth one being a regularization term or a constraint.111A constraint $x\in\operatorname{\cap}_{i\in\{1,\ldots,N\}}X_{i}\subset^{n}$ is modeled by setting $g_{i}(x)=I_{X_{i}}(x)$, with $I_{X_{i}}(x)=0$ $\forall x\in X_{i}$ and $I_{X_{i}}(x)=+\infty$ otherwise.

In this paper we consider problems in which the composite function has a partitioned structure, that we next describe. Let the decision variable $x\in^{n}$ be partitioned as stated in (1), then the sub-vector $x_{i}\in^{n_{i}}$ with $n_{i}\ll n$, represents the relevant information at node $i$. Each local objective $f_{i}$ has a sparsity consistent with the interaction graph, namely, for $i\in\{1,\ldots,N\}$, the function $f_{i}$ depends only on the component of node $i$ and of its neighbors. To highlight this property we let $f_{i}:^{\sum_{j\in\mathcal{N}_{i}}n_{j}}\rightarrow$ and write $f_{i}(x_{\mathcal{N}_{i}})$. Also, each function $g_{i}$ depends only on the component $x_{i}$, i.e., $g_{i}:^{n_{i}}\rightarrow\cup\{+\infty\}$.

In light of the described structure, the problem we aim at solving in a distributed way can be written as

[TABLE]

where node $i$ knows only the functions $f_{i}$ and $g_{i}$. We call this problem partitioned (due to the structure of the functions $f_{i}$ and $g_{i}$) and big-data (since the dimension of the decision variable depends on the number of nodes).

Note that, in this partitioned scenario, network structure and objective function are inherently related. That is, nodes that share a variable are neighbors in the communication graph. As pointed out in the introduction this set-up appears in several interesting applications [2]. In the following assumptions we state the main properties of problem (2).

Assumption II.1**.**

For all $i\in\{1,\ldots,N\}$, $f_{i}$ is a smooth function of $x_{\mathcal{N}_{i}}$. In particular, $f_{i}$ has block-coordinate Lipschitz continuous gradient, i.e., for all $j\in\mathcal{N}_{i}$ there exists constants $L_{ij}>0$ such that for all $x_{\mathcal{N}_{i}}\in^{\sum_{\ell\in\mathcal{N}_{i}}n_{\ell}}$ and $s_{j}\in^{n_{j}}$ it holds

[TABLE]

where $U_{ij}$ is a suitable matrix such that $U_{ij}s_{j}$ is a vector in ${}^{\sum_{\ell\in\mathcal{N}_{i}}n_{\ell}}$ with $j$-th block-component equal to $s_{j}$ and all the other ones equal to zero. $\square$

In light of Assumption II.1, it is easy to show that the following lemma holds.

Lemma II.2**.**

Let Assumption II.1 hold, then the aggregate function $f(x):=\sum_{i=1}^{N}f_{i}(x_{\mathcal{N}_{i}})$ has block-coordinate Lipschitz continuous gradient. In particular, for all $i\in\{1,\ldots,N\}$, the partial gradient $\nabla_{x_{i}}f$ has Lipschitz constant given by $L_{i}:=\sum_{j\in\mathcal{N}_{i}}L_{ij}$.

Proof.

The proof follows straight by simply writing the norm of the aggregate cost $f$ and then bounding each term of its gradient by using its block Lipschitz constant. ∎

Remark II.3**.**

Note that one can assume directly that $\nabla_{x_{i}}f$ is Lipschitz continuous, but while the condition we impose can be checked in a distributed way, the weaker one needs a global knowledge of the cost $f$. $\square$

Assumption II.4**.**

For all $i\in\{1,\ldots,N\}$, the function $g_{i}$ is a proper, closed, proper, convex function. $\square$

We stress that we have not assumed any convexity condition on $f_{i}$, thus optimization problem (2) is non-convex in general. Finally, we state the following assumption which is quite standard for non-convex scenarios.

Assumption II.5**.**

The cost $V(x):=\sum_{i=1}^{N}f_{i}(x_{\mathcal{N}_{i}})+g_{i}(x_{i})$ of problem (2) is a coercive function. $\square$

Assumption II.5 guarantees that at least a local minimum for problem (2) exists.

Figure 1 visualizes the sparsity structure for a function partitioned according to a path graph of $N=4$ nodes. Each $i$-th column shows the variables on which $f_{i}$ depends, while along each $i$-th row it is possible to see in which functions a variable $x_{i}$ appears. It is worth noticing that the sparsity in the $i$-th row shows the consistency that needs to be maintained among neighboring nodes on variable $x_{i}$.

III Distributed optimization algorithm

In this section we present our asynchronous distributed algorithm.

In order to develop our algorithm, we need to introduce some technical tools: (i) the asynchronous communication protocol necessary to manage the overall behavior of the algorithm, and (ii) the local approximation model that each node will use to perform its local (descent) update.

We consider an asynchronous communication protocol where each node $i\in\{1,\ldots,N\}$ has its own concept of time defined by a local timer $\tau_{i}$, which randomly and independently of the other nodes triggers when to awake itself. The timers trigger according to exponential distributions with a common parameter. We denote $T_{i}$ a realization drawn by node $i$. Between two triggering events the node is in an idle mode, i.e., it continuously receives messages from neighboring nodes and updates some internal variables. When a trigger occurs, it switches into an awake mode in which it updates its local variable and transmits the updated information to its neighbors. A formal discussion on this protocol is given in [6].

The proposed distributed algorithm is based on local quadratic, strongly-convex approximations of the cost function that each node computes.

Formally, each node $i\in\{1,\ldots,N\}$ constructs the following local approximation of the entire cost function at a fixed $\bar{x}\in^{n}$ (neglecting the constant term $f(\bar{x})$ which does not affect the optimization),

[TABLE]

with $Q_{i}(x)\in^{n_{i}\times n_{i}}$ a symmetric, positive definite matrix satisfying the following assumption.

Assumption III.1**.**

For any $x\in^{n}$ and $i\in\{1,\ldots,N\}$ it holds that $Q_{i}(x)\succeq L_{i}I$. $\square$

Intuitively Assumption III.1 guarantees the strong convexity of $q_{i}$. The role of the Lipschitz constant $L_{i}$ in the bound will be clear in the analysis of the algorithm given in Section IV.

Informally, the asynchronous distributed optimization algorithms is as follows. A node $i$ takes care of modifying the variable $x_{i}$. We denote $\bar{x}_{i}$ the current state of node $i$, which is the estimated optimal value of the variable $x_{i}$. Consistently we denote $\bar{x}_{\mathcal{N}_{i}}$ the vector of states of nodes in $\mathcal{N}_{i}$.

When a node $i$ wakes up, it updates its state $\bar{x}_{i}$ by moving in the direction obtained from the minimization of its local approximation $q_{i}(s_{i};\bar{x})$, being $\bar{x}$ the current value of the decision variable. Then, it sends to each neighbor $j\in\mathcal{N}_{i}$ the updated $x_{i}$ and $\nabla_{x_{j}}f_{i}(\bar{x}_{\mathcal{N}_{i}})$. When in idle, node $i$ is in a listening mode. If an updated $\nabla_{x_{i}}f_{j}(\bar{x}_{\mathcal{N}_{j}})$ is received from a neighbor $j$ no computation is needed. If $\bar{x}_{j}$ is also received ($j$ was an awake node) the following happens. Node $i$ updates the partial gradients of its local function $f_{i}$ according to the new $\bar{x}_{j}$, and sends back the updated partial gradients to its neighbors. In order to highlight the difference between updated and old variables at node $i$ during the awake phase, we denote the updated ones with a “$+$” symbol, e.g., as ${\bar{x}_{i}}^{+}$.

We want to stress two important aspects of the idle/awake cycle. First, these two phases are regulated by local timers without the need of any central clock. Second, when in idle a node only receives messages and from time to time evaluates a partial gradient, which takes a negligible time compared to the computation performed in the awake phase.

The distributed algorithm is formally reported in the table below (from the perspective of node $i$).

We point out some aspects involving the local approximation (3) that each node uses in its local computations.

First, it is worth noting $q_{i}(s_{i};\bar{x})$ does not depend on the entire state $\bar{x}$, but only on $\bar{x}_{\mathcal{N}_{j}}$, $j\in\mathcal{N}_{i}$ and therefore is constructed by node $i$ by using only information from its neighbors. Moreover, node $i$ does not needed the expression of neighboring cost functions $f_{j}$ to build $q_{i}(s_{i};\bar{x})$, but only the gradients $\nabla_{x_{i}}f_{j}$. In some special cases (discussed in the following paragraph), $Q_{i}(x)$ could include second order information of $f_{j}$, $j\in\mathcal{N}_{i}$, i.e., $\nabla_{x_{i},x_{i}}^{2}f_{j}$, that should be sent together with the gradients.

Second, different choices for the weight matrix $Q_{i}(x)$ are allowed. By exploiting the block Lipschitz continuity of the gradient of $f$, a first simple choice is to set $Q_{i}(x):=L_{i}I$ for all $i\in\{1,\ldots,N\}$ and $x\in^{n}$. Motivated by existing works in the literature, e.g., [17], non diagonal choices for $Q_{i}(x)$ are reasonable: for instance, assuming $f\in\mathcal{C}^{2}$, one can select a second order approximation, i.e., set $Q_{i}(x):=\nabla^{2}_{x_{i},x_{i}}f(x)+\epsilon_{i}I$ for a sufficiently large $\epsilon_{i}>0$ for all $i\in\{1,\ldots,N\}$. As mentioned above this information can be constructed in a distributed manner.

Third and final, recalling the definition of the proximal operator $\mathbf{prox}_{\alpha,\varphi}:^{n}\rightarrow^{n}$ of a closed, proper, convex function $\varphi:^{n}\rightarrow\cup\{+\infty\}$ given by \mathbf{prox}_{\alpha,\varphi}(v):=\mathop{\rm argmin}_{x}\big{(}\varphi(x)+\frac{1}{2\alpha}\|x-v\|^{2}\big{)} with $\alpha>0$, we have that for $Q_{i}(x)=L_{i}I$ the update law described in (4)-(5), can be rephrased in term of proximal operators and, thus, leading to a distributed coordinate proximal gradient method. On this regard it is worth noting that our algorithm, with a general expression for $Q_{i}$, can be written in terms of a generalized, weighted version of the proximal operator as follows. Given a positive definite matrix $W\in^{n\times n}$, we define

[TABLE]

thus, the iteration (4)-(5) can be recast as

[TABLE]

IV Convergence analysis of the Partitioned Coordinate Descent distributed

algorithm

In this section we prove the convergence in probability of the proposed algorithm.

First, it is worth pointing out that being the algorithm asynchronous, for the analysis we need to carefully formalize the concept of algorithm iterations. We will use a nonnegative integer variable $t$ indexing a change in the whole state $\bar{x}=[\bar{x}_{1}^{\top}\ldots\bar{x}_{N}^{\top}]^{\top}$ of the distributed algorithm. In particular, each triggering will induce an iteration of the distributed optimization algorithm and will be indexed with $t$. We want to stress that this (integer) variable $t$ does not need to be known by the agents. That is, this timer is not a common clock and is only introduced for the sake of analysis.

Theorem IV.1**.**

Let Assumptions II.1, II.4, II.5 and III.1 hold true. Then, the Partitioned Coordinate Descent distributed algorithm generates a sequence $x(t):=[\bar{x}_{1}(t)^{\top},\ldots,\bar{x}_{N}(t)^{\top}]^{\top}$ (obtained stacking the nodes’ states) such that the random variable $V(x(t))$ converges almost surely, i.e., there exists a random variable $V^{\star}$ such that

[TABLE]

Moreover, any limit point $x^{\star}$ of $[\bar{x}_{1}(t)^{\top},\ldots,\bar{x}_{N}(t)^{\top}]^{\top}$ is a stationary point of problem (2) and, thus, satisfies its first order optimality condition, i.e., there exists a subgradient $\widetilde{\nabla}g(x^{\star})$ of $g$ at $x^{\star}$ such that $\nabla f(x^{\star})+\widetilde{\nabla}g(x^{\star})=0$. $\square$

IV-A Coordinate descent method for composite non-convex minimization

In this subsection we consider a more general composite optimization problem and prove a result that is instrumental to the convergence proof of our distributed algorithm. We introduce a generalization of the algorithm proposed in [20, 13, 16] based on the quadratic approximation introduced in (3). We present the algorithm for problem (2), but we want to stress that the algorithm can be applied to a general function $f:^{n}\rightarrow$ with block-Lipschitz continuous gradient. This will be clear from the analysis.

We consider a coordinate descent method based on selecting a random block-component, say $x_{i}$, of $x$ at each iteration and updating only $x_{i}$ through a suitable descent rule. The descent step is based on the quadratic approximation of the cost function given in (3). The coordinate descent method is formally summarized in the table below.

In the following we present results for the theoretical convergence of the generalized coordinate descent algorithm.

Lemma IV.2**.**

Let Assumption II.1, II.4, III.1 hold. Let $x(t)$ be the random sequence generated by Generalized Coordinate Descent Algorithm, then for all $t\geq 0$ it holds

[TABLE]

Proof.

From Assumption II.1 (Lipschitz continuity of $\nabla f$), we can write the well-known descent lemma (see [21, Proposition A.24]), for all $i\in\{1,\ldots,N\}$ and for all $\bar{x}\in^{n}$

[TABLE]

with $U_{i}$ introduced in the Notation paragraph.

Since $Q_{i}$ satisfies Assumption III.1, then we can generalize the above descent condition by introducing a uniform bound depending on the Lipschitz constant of block $i$, i.e.,

[TABLE]

Due the partitioned structure of $f$, the explicit expression of $\nabla_{x_{i}}f(x)$ actually depends only on $f_{j}$, $j\in\mathcal{N}_{i}$, thus the latter condition can be further rephrased as

[TABLE]

with $q_{i}(s_{i};\bar{x})$ defined as in (3).

Consider a descent direction $d_{i_{t}}$ computed as in (7), then $d_{i_{t}}$ satisfies the first order necessary condition of optimality for problem (7)

[TABLE]

where $\widetilde{\nabla}g_{i_{t}}\in^{m_{i_{t}}}$ is a particular subgradient of $g_{i_{t}}$.

Starting form equation (9) with the following identification $\bar{x}=x(t)$ and $\bar{x}+U_{i_{t}}d_{i_{t}}=x(t+1)$, and adding and subtracting the term $g_{i_{t}}(x_{i_{t}}(t))$ we obtain

[TABLE]

where we used the convexity of $g_{i_{t}}$, the optimality condition (10) and the uniform bound in Assumption III.1. ∎

Theorem IV.3**.**

Let Assumptions II.1, II.4, II.5 and III.1 hold true. Then, the Generalized Coordinate Descent Algorithm generates a sequence $x(t)$ such that the random variable $V(x(t))$ converges almost surely. Moreover, any limit point $x^{\star}$ of $x(t)$ is a stationary point of $V$ and, thus, satisfies the first order necessary condition for optimality for problem (2), i.e., there exists a subgradient $\widetilde{\nabla}g(x^{\star})$ of $g$ at $x^{\star}$ such that

[TABLE]

Proof.

The result is proven by following the same line as in [16, Theorem 1] where the generalized Lemma IV.2 is used in place of [16, Lemma 3]. ∎

IV-B Proof of Theorem IV.1

Our proof strategy is based on showing that the iterations of the asynchronous distributed algorithm can be written as the iterations of an ad-hoc version of the coordinate descent method for composite non-convex functions given in Section IV-A.

Timer model and uniform node extraction. Since the timers trigger independently according to the same exponential distribution, then from an external, global perspective, the induced awaking process of the nodes corresponds to the following: only one node per iteration wakes up randomly, uniformly and independently from previous iterations. Thus, each triggering, which induces an iteration of the distributed optimization algorithm and is indexed with $t$, corresponds to the (uniform) selection of a node in $\{1,\ldots,N\}$ that becomes awake. We denote $i_{t}$ the extracted node. Notice that node $i_{t}$ changes the value of its state $\bar{x}_{i_{t}}$ while all the other states are not changed by the algorithm.

State consistency (inductive argument). Next we show by induction that if all the nodes have a consistent and updated information before a node $i$ gets awake, then the same holds after the update. By consistent we mean that for a variable $x_{\ell}$, all the nodes in $\mathcal{N}_{\ell}$ have the same state $\bar{x}_{\ell}$. By updated we mean that each node $\ell$ has an updated value of the gradients $\nabla_{x_{\ell}}f_{j}$, $j\in\mathcal{N}_{\ell}$. First, node $i$ changes only its state $\bar{x}_{i}$ relative to the variable $x_{i}$. This variable is shared only with neighbors $j\in\mathcal{N}_{i}$, which receive the new state $\bar{x}_{i}$ after the update. As regards the gradients, the ones affected by the change of the variable $x_{i}$ are $\nabla_{x_{i}}f_{j}$, with $j\in\mathcal{N}_{i}$. Notice that these gradients are only used by nodes $k\in\mathcal{N}_{j}$. But after the broadcast performed by $i$, each idle $j\in\mathcal{N}_{i}$ receives the updated $\bar{x}_{i}$, updates the gradients, and sends them to its neighbors $k\in\mathcal{N}_{j}$. The variables and gradients for the rest of the nodes in the network are not changed by the update of node $i$.

Coordinate descent equivalence and convergence. Finally, we simply notice that, thanks to the consistency argument just shown, steps (4)-(5) correspond to steps (7)-(8). Thus, we have shown that our distributed algorithm implements the centralized coordinate method and therefore inherits its convergence properties. By invoking Theorem IV.3, the proof follows.

V Numerical simulations on a non-convex constrained quadratic program

In this section we present a numerical example showing the effectiveness of the proposed algorithm.

We consider an undirected connected Erdős-Rényi random graph $\mathcal{G}$, with parameter $0.2$, connecting $N=50$ nodes and we test the distributed algorithm on a partitioned non-convex constrained quadratic program in the form

[TABLE]

where each $x_{i}\in$ for all $i\in\{1,\ldots,N\}$ and each cost matrix $H_{i}\in^{|\mathcal{N}_{i}|\times|\mathcal{N}_{i}|}$ is only symmetric (not positive definite). We construct $H_{i}$ as the difference between a positive definite matrix $\tilde{H}_{i}\in^{|\mathcal{N}_{i}|\times|\mathcal{N}_{i}|}$ and a suitable scaled version of the identity matrix. Finally, each function $I_{X_{i}}$ denotes the indicator function of the segment $X_{i}=[-\ell_{i},u_{i}]$, i.e., we constrain each $x_{i}$ to lie into an interval. We set $\ell_{i}=-30$ and $u_{i}=20$ for all $i\in\{1,\ldots,N\}$.

Problem (11) fits our set-up described in Section II by defining

[TABLE]

and

[TABLE]

Moreover, we use the local approximation $q_{i}(s_{i},\bar{x})$ as in (3) with $Q_{i}=\frac{1}{\alpha_{i}}I$ with $\alpha_{i}=0.01$ for all $i\in\{1,\ldots,N\}$.

In Figure 2 we plot the evolution of two selected components of the decision variable $x$ at each iteration $t$ (defined as discussed in Section IV), i.e., $x_{i}(t)$, $i=14,48$. The horizontal dotted lines represent the centralized solution. Since the algorithm is asynchronous and based on a coordinate approach, we plot the rate of convergence with respect to the normalized iterations $t/N$ in order to show the effective behavior with respect to the global time.

In Figure 3 we show the difference, in logarithmic scale, between the cost $V(x(t))$ at each iteration $t$ and the value of $V$ attained at the limit point $x^{\star}$ of $x(t)$ (proven to be a stationary point).

VI Conclusions

In this paper we have proposed an asynchronous, distributed algorithm to solve partitioned, big-data non-convex optimization problems. The main idea is that each node updates its local variable by minimizing a suitable, local quadratic approximation of the cost, built via an information exchange with neighboring nodes. We prove the convergence of the distributed algorithm by showing that it corresponds to a proper instance of a coordinate descent method.

Acknowledgments

The authors would like to thank Angelo Coluccia e Massimo Frittelli for their help and suggestions.