On Maintaining Linear Convergence of Distributed Learning and Optimization under Limited Communication

TL;DR

This paper investigates how to maintain linear convergence in distributed optimization under limited communication by designing effective quantizers and analyzing the interplay between convergence, compression, and transmission rate.

Contribution

It introduces a method to design quantizers that preserve linear convergence in distributed algorithms and characterizes communication time as a function of transmission rate.

Findings

Quantizers can be designed to maintain linear convergence with minimal bits.

Communication time depends on the transmission rate and algorithm properties.

Co-design of learning algorithms and communication protocols is essential.

Abstract

In distributed optimization and machine learning, multiple nodes coordinate to solve large problems. To do this, the nodes need to compress important algorithm information to bits so that it can be communicated over a digital channel. The communication time of these algorithms follows a complex interplay between a) the algorithm's convergence properties, b) the compression scheme, and c) the transmission rate offered by the digital channel. We explore these relationships for a general class of linearly convergent distributed algorithms. In particular, we illustrate how to design quantizers for these algorithms that compress the communicated information to a few bits while still preserving the linear convergence. Moreover, we characterize the communication time of these algorithms as a function of the available transmission rate. We illustrate our results on learning algorithms using different communication structures, such as decentralized algorithms where a single master coordinates information from many workers and fully distributed algorithms where only neighbours in a communication graph can communicate. We conclude that a co-design of machine learning and communication protocols are mandatory to flourish machine learning over networks.

Figures

Equations

$${\mathbf{x}}^{k+1}=$$

$${\mathbf{c}}_i^{k+1}=$$

$${\mathbf{x}}_i^{k+1}=$$

$${\mathbf{c}}_i^{k+1}=$$

$${\mathbf{x}}^k=({\mathbf{x}}_1^k,\dots ,{\mathbf{x}}_N^k)\text{ and }{\mathbf{c}}^k=({\mathbf{c}}_1^k,\dots ,{\mathbf{c}}_N^k),$$

$$A(\mathbf{c},\mathbf{x})=(A_1({\mathbf{c}}_{{\mathcal{N}}_1},{\mathbf{x}}_1),\dots ,A_N({\mathbf{c}}_{{\mathcal{N}}_N},{\mathbf{x}}_N)).$$

$$||A(C(\mathbf{x}),\mathbf{x})-{\mathbf{x}}^{\star }||\le \sigma ||\mathbf{x}-{\mathbf{x}}^{\star }||,$$

$$||A({\mathbf{c}}_1,\mathbf{x})-A({\mathbf{c}}_2,\mathbf{x})||\le$$

$$||C({\mathbf{x}}_1)-C({\mathbf{x}}_2)|{|}_{\infty }\le$$

$$||{\mathbf{x}}^k-{\mathbf{x}}^{\star }||\le$$

$$||{\mathbf{c}}^k-{\mathbf{c}}^{\star }|{|}_{\infty }\le$$

$$\underset{\mathbf{z}\in {\mathbb{R}}^d}{\mathrm{minimize}}$$

$${\mathbf{x}}^{k+1}={\mathbf{x}}^k-\gamma \sum _{i=1}^N\nabla f_i({\mathbf{x}}^k).$$

$${\mathbf{x}}^{k+1}=$$

$${\mathbf{c}}_i^{k+1}=$$

$$||A(C(\mathbf{x}),\mathbf{x})-{\mathbf{x}}^{\star }|{|}_2\le \sigma ||\mathbf{x}-{\mathbf{x}}^{\star }|{|}_2,\text{ for all }\mathbf{x}\in {\mathbb{R}}^d,$$

$$\underset{c}{\mathrm{minimize}}$$

$$\bar{\mathbf{W}}\mathbf{c}=0$$

$${\mathbf{x}}_i^{k+1}=$$

$${\mathbf{c}}_i^{k+1}=$$

$$\gamma =\frac{2L\mu }{\mu {\lambda }_{\min }^{+}(\mathbf{W})+L{\lambda }_{\max }(\mathbf{W})}$$

$$||A(C(\mathbf{x}),\mathbf{x})-{\mathbf{x}}^{\star }|{|}_{\mathbf{M}}\le$$

$${\mathbf{x}}^{k+1}=$$

$${\mathbf{c}}_i^{k+1}=$$

$${\mathbf{q}}_i^{k+1}=$$

$$[{\text{quant}}_i(\mathbf{c},\mathbf{q},r,b){]}_j=$$

$$\{\begin{array}{ll}{\mathbf{q}}_j-r& \text{if }{\mathbf{q}}_j\le {\mathbf{c}}_j-r+\delta (r,b)\\ {\mathbf{q}}_j+r& \text{if }{\mathbf{q}}_j\ge {\mathbf{c}}_j+r-\delta (r,b)\\ {\mathbf{q}}_j-r+2\delta (r,b)\lfloor \frac{{\mathbf{c}}_j-{\mathbf{q}}_j+r+\delta (r,b)}{2\delta (r,b)}\rfloor & \text{otherwise.}\end{array}$$

$$||{\text{quant}}_i({\mathbf{c}}_i,{\mathbf{q}}_i,r,b)-{\mathbf{c}}_i|{|}_{\infty }\le$$

$$||{\mathbf{x}}^0-{\mathbf{x}}^{\star }|{|}^2\le (2/\mu )(F({\mathbf{x}}^0)-F({\mathbf{x}}^{\star }))\le (2/\mu )F({\mathbf{x}}^0)=:D,$$

$$||{\mathbf{x}}^0-{\mathbf{x}}^{\star }||\le ||{\mathbf{x}}^0-{\mathbf{x}}^1||+||{\mathbf{x}}^1-{\mathbf{x}}^{\star }||\le ||{\mathbf{x}}^0-{\mathbf{x}}^1||+\sigma ||{\mathbf{x}}^0-{\mathbf{x}}^{\star }||$$

$$r^k=\frac{K}{L_A}\alpha (b{)}^{k+1}D\text{ where }\alpha (b)=\frac{K}{2^b-1}+\sigma$$

$$\text{ and }K=\max \left\{1,\frac{2L_A{L}_C}{\sigma }\right\}.$$

$$||{\mathbf{x}}^k-{\mathbf{x}}^{\star }||\le$$

$$B_{ϵ}(b)=b{k}_{ϵ}(b).$$

$$\underset{\mathbf{x}\in {\mathbb{R}}^d}{\mathrm{minimize}}$$

Full text

I Introduction

Large-scale distributed computing systems are the cornerstone of recent advancements in many disciplines such as machine learning (ML), communication networks, and networked control. For example, efficient parallel processing has enabled analysis and optimization over big datasets. Similarly, spatially separated wireless networks with cheap and low-complexity sensor nodes (e.g., Internet of things, smart grids, and intra-body wireless sensor networks) are revolutionizing our infrastructures and societies. In these systems, multiple processors coordinate to solve large and often spatially separated computational problems. The computational burden of the individual processors is usually manageable, if not small, and based on elementary operations. Instead, the main complexity often lies in the coordination and communication among the processors. This problem is exacerbated in wireless networks where bandwidth-limited and faulty wireless links may further complicate the coordination and consequently become a bottleneck of the distributed computing system. One may implement a set of communication techniques (e.g., quantization, coding and modulation, and scheduling) to reliably exchange information bits among processors at the expense of a slower communication rate.

In an attempt to quantify this coordination challenge in distributed computing, [1] introduced the notion of communication complexity in 1970s. It measures the minimal number of transmitted bits required between multiple processors to compute a binary function whose inputs are distributed among them (in the minimax sense). More recent works have investigated communication complexity and communication-efficient algorithms in various systems, such as in networked control [2], distributed optimization [3, 4, 5, 6, 7, 8, 9, 10, 11], and equilibrium seeking in games [12, 13, 14]. Communication-efficiency has also gained a massive recent interest in the ML community, where parallel and distributed algorithms are becoming increasingly important in dealing with the huge data size [15, 16, 17, 18, 19]. In fact, when training many of the state-of-the art deep neural networks the communication time is starting to outweigh the computing time [16]. A main approach to address the communication complexity is to reduce the number of bits to represent the exchanged information vectors. Recent works have analyzed the possibility of updating based on the quantized gradients, both in deterministic [18, 14, 20] and stochastic [21, 22, 23, 24] settings.

The conventional wisdom, validated by empirical observations, is that there exists a precision-accuracy tradeoff: the fewer the number of bits the lower the accuracy of the final solution. Some recent studies, however, challenged that wisdom in the deterministic [25, 26, 20] and stochastic [27, 28] settings. In particular, these papers illustrate how the convergence rate can be preserved under limited data-rates by using adaptive quantization scheme that shrinks as the algorithm converges. This idea is, to the best of our knowledge, first presented in [3], which provides almost tight upper and lower bounds on the number of bits two nodes need to communicate to approximately solve a strongly convex optimization problem. All of the above adaptive quantization schemes are, however, designed for particular algorithms. It is one of the goals of this paper to illustrate how such adaptive quantization scheme can be designed for general distributed algorithms that converges linearly in any norm.

In the second part of this paper, we highlight that the design of the existing distributed optimization algorithms are often ignorant to some important objectives including end-to-end latency, required to solve an optimization problem. These factors become of paramount importance when we implement ML and distributed optimization algorithms over a network to support low-latency services, such as industrial automation and online gaming. We consider a set of mappings between some design parameters (the packet size, the reliability of the communication channel, and multiple access protocol) and the achievable transmission rate. We then characterize the aggregated latency required for the convergence of the distributed algorithm. We show a surprising result that reducing the number of bits per iteration (even if we can maintain the linear convergence rate) may not necessarily lead to the lowest latency for solving an optimization problem. In particular, in a contention-based resource allocation such as slotted-ALOHA [29], a high-dimensional ML problem may enjoy sending the fewest number of bits per iteration (to control the channel contention at an optimal level) even though it may not lead to the optimal convergence rate in terms of the number of iterations, whereas a high rate point-to-point network may enjoy a much higher value for the optimal number of bits.

The main contributions of this paper are as follows.

• •

Iteration complexity analysis: We considers general parallel/distributed algorithms that have a linear convergence rate in an arbitrary norm. For these algorithms, we develop an adaptive quantization that maintains the non-asymptotic and asymptotic linear convergence rate while communicating only few bits per iteration.

• •

Novel performance measure: In the second part of the paper, we introduce the novel notion of transmission time complexity of running a distributed optimization over a generic communication network. We consider abstract transmission rate functions that take as inputs the size of the payload (number of quantization bits) and overhead of each packet and the probability of package failure and quantify.

• •

Transmission time complexity analysis: We build on our iteration-complexity results and characterize the transmission time convergence of distributed algorithms for different communication channels, such as AWGN channels and multiple access channels. Our algorithm class/framework is generic enough to cover many ML algorithms of practical interest and with different communication protocols.

• •

Example use cases: We illustrate the usage of our algorithm to maintain convergence of distributed ML and optimization algorithms where i) a master node coordinates information received from many worker nodes and ii) where the nodes communicate over a communication graph with no central coordinator.

• •

Extensive experiments We show the implications of our theoretical convergence results on large dimensional data sets, including the MNIST.

This paper addresses the problem of communication complexity from the point of view of information and communication theory, which is still in its infancy. A conference version containing part of this work was presented in [20]. All of the work in Section III-C, IV, and V is appearing here for the first time. Moreover, the discussions and results in Section II and Section III have been largely improved. Moreover, the conference version did not include any proofs and almost all of the numerical results are new.

Notations. Normal font small letters $x$, bold font small letters ${\bf{x}}$, bold font capital letters ${\bf{X}}$, and calligraphic font $\mathcal{X}$ stand for scalars, vectors, matrices, and sets respectively. For a matrix ${\bf{X}}$, ${\bf{X}}_{ij}$ denotes its $(i,j)$-th entry. ${\bf{A}}\otimes{\bf{B}}$ is the Kronecker product ${\bf{A}}$ and ${\bf{B}}$ and $\texttt{Im}({\bf{A}})$ is the span of ${\bf{A}}$. We denote by $\lambda_{\min}^{+}({\bf{A}})$ and $\lambda_{\max}({\bf{A}})$, respectively, the smallest non-zero eigenvalue of ${\bf{A}}$ and the largest eigenvalue of matrix ${\bf{A}}$. We denote by $|\mathcal{L}|$ the cardinality of the set $\mathcal{L}$.

II Algorithm Model:

Communication and Linear Convergence

In this section, we start by introducing the abstract form of our distributed algorithms. We then provide two examples of algorithms in this form that are popular in distributed learning over networks.

II-A Distributed Iterative Algorithms

Consider a network of $N$ nodes that cooperatively solve a distributed computational problem involving some communication. In particular, we consider the following general algorithm framework

[TABLE]

where ${\bf{c}}^{k}=({\bf{c}}_{1}^{k},\ldots,{\bf{c}}_{N}^{k})$. The function $A:\mathbb{R}^{Nd}\times\mathcal{X}\rightarrow\mathcal{X}$ represents an algorithm update of the decision variable ${\bf{x}}\in\mathcal{X}$, where $\mathcal{X}$ is a subset of a finite dimensional Euclidean space. The function $C_{i}:\mathcal{X}\rightarrow\mathbb{R}^{d}$ picks out the relevant information ${\bf{c}}_{i}=C_{i}({\bf{x}})$ that node $i$ needs to communicate to run the algorithm.111To simplify the presentation we have assumed that ${\bf{c}}_{i}$ has the same dimension for all $i$. However, all the results in this paper also hold for ${\bf{c}}_{i}^{k}\in\mathbb{R}^{d_{i}}$ by replacing $d$ with $\max_{i}d_{i}$ followed by a zero padding. This general algorithmic framework covers many ML algorithms. One example is that a master server performs the algorithm update based on information computed and communicated from many servers; see the first example in Section II-B. The framework in Eq. (1) also covers distributed learning algorithms where the nodes communicate over a communication graph $(\mathcal{N},\mathcal{E})$ where $\mathcal{N}:=\{1,2,\cdots,N\}$ stands for the nodes and $\mathcal{E}\subset\mathcal{N}\times\mathcal{N}$ stands for the communication links. This can be captured by the following iterations

[TABLE]

where $\mathcal{N}_{i}:=\{j\in\mathcal{N}:(i,j)\in\mathcal{E}\}$ denotes the set of neighbors of node $i$, the function $A_{i}:\mathbb{R}^{d}\times\mathcal{X}_{i}\rightarrow\mathcal{X}_{i}$ is the local algorithm update at node $i$, and $C_{i}:\mathcal{X}_{i}\rightarrow\mathbb{R}^{d}$ is the information that node $i$ communicates to its neighbors. To express the algorithm in the form of Eq. (1) we set

[TABLE]

and define the function $A:\mathbb{R}^{Nd}\times\mathcal{X}\rightarrow\mathcal{X}$, $\mathcal{X}=\prod_{i=1}^{N}\mathcal{X}_{i}$, resulting in

[TABLE]

The focus of this paper are algorithms in the form of Eq. (1) that have linear convergence rates, which we define as follows.

Definition 1**.**

We say that the algorithm in the form of Eq. (1) is $\sigma$-linear convergent in the norm $||\cdot||$ if:

1. a)

The function ${\bf{x}}\mapsto A(C({\bf{x}}),{\bf{x}})$ is $\sigma$-pseudo contractive on $\mathcal{X}$, i.e., there exists ${\bf{x}}^{\star}\in\mathcal{X}$ such that

[TABLE]

for all ${\bf{x}}\in\mathcal{X}$. 2. b)

There exist $L_{C}$ and $L_{A}$ such that

[TABLE]

for all ${\bf{x}}_{1},{\bf{x}}_{2},{\bf{x}}\in\mathcal{X}$ and ${\bf{c}}_{1},{\bf{c}}_{2}\in\mathbb{R}^{Nd}$.

Note that this definition implies that the algorithm converges linearly in both ${\bf{c}}$ and ${\bf{x}}$ to some fixed points ${\bf{x}}^{\star}\in\mathcal{X}$ and ${\bf{c}}^{\star}\in\mathbb{R}^{Nd}$. In particular, we have

[TABLE]

Definition 1-b) is a smoothness condition on the mapping between the algorithm iterations ${\bf{x}}$ and the communication variables ${\bf{c}}$. This is needed when considering quantized communication because quantization creates a noise that affects the algorithm performance. We use $L_{\infty}$-norm to measure the distance between communication variables because our quantization (given in Section III) is a rectangular grid where distances are measured in the $L_{\infty}$-norm (Manhattan distance).

Many parallel and distributed algorithms can be expressed in this form and have $\sigma$-linear convergence under certain conditions [30]. For example, algorithms for learning Equilibriums in games [31, 32, 14], coordination algorithms in communication networks [33, 34, 35], and distributed optimization algorithms [36, 37, 38]. Below, we give two concrete examples of distributed learning algorithms in this form.

II-B Application: Distributed Learning and Optimization

Consider the following optimization problem

[TABLE]

where $N$ nodes wish to learn a parameter ${\bf{z}}\in\mathbb{R}^{d}$ by minimizing the sum of local loss functions $f_{i}:\mathbb{R}^{d}\rightarrow\mathbb{R}$ based on the private data locally available at node $i$. We make the following assumption.

Assumption 1**.**

For $i{=}1,{\ldots},N$, $f_{i}(\cdot)$ is $\mu$-strongly convex and has $L$-Lipschitz continuous gradient.

Below, we illustrate two typical algorithms, covered by our model in Eq. (1), that use different communication structures.

II-B1 Decentralized Learning

This problem is typically solved using the decentralized gradient update

[TABLE]

To perform this update some communication is needed. The most common communication protocols are a) the nodes broadcast their gradients, then the nodes perform the gradient update locally, b) the nodes communicate their gradients to a master node that performs the gradient update. In either case, this algorithm is captured by the model in Eq. (1) as follows

[TABLE]

This algorithm is linearly convergent, following the standard analysis of gradient descent.

Proposition 1** ([39]).**

Let $A(\cdot)$ and $C(\cdot)$ be the functions defined in Eq. (5) and ${\bf{x}}^{\star}$ be the optimal solution to the optimization problem in Eq. (4). Then

[TABLE]

where $\sigma\in[0,1)$ if $\gamma$ is small enough. For example, $\sigma=1-2/(\kappa+1)$ if $\gamma=2/[N(\mu+L)]$, where $\kappa=L/\mu$. It can also be verified that Eq. (3a) and Eq. (3b) hold with $L_{A}=\gamma N\sqrt{d}$ and $L_{C}=L$.

Borrowing terminology from Communication and Information Theory, the communication channel from the master node to the workers is called a broadcast channel, whereas the reverse is called a multiple-access channel (MAC) [40]. Generally speaking, the main bottleneck in this two-way communication system (between workers and master node) is the MAC channel where there is a risk of co-channel interference if multiple workers simultaneously send their information messages. In the case of strong interference, also called collision, the information messages might not be decodable at the master node and the workers should re-transmit their messages, consuming much energy if they are battery-powered. These challenges are exacerbated in wireless networks due to random channel attenuation and background noise [41]. Consequently, state-of-the-art communication technologies need additional coordination and advanced coding techniques in the MAC channel. In the algorithm in Eq. (5), we focus on the communication from the worker nodes to the master node (the MAC channel) and do not specially formulate how the master node broadcasts ${\bf{x}}^{k}$ and assume zero latency (a conventional ideal broadcast channel). However, our framework can easily be adjusted to include the latency due to the broadcast channel of the master.

II-B2 Distributed Learning over a Network: Dual Decomposition

Distributed algorithms where the nodes cooperatively solve the problem in Eq. (4) over a connected communication network $(\mathcal{N},\mathcal{E})$ can also be modelled in the form of Eq. (1), e.g., using dual decomposition [38], ADMM [36], or distributed consensus gradient methods [37]. All of these algorithms have linear convergence rate under Assumption 1. We illustrate this for the distributed dual decomposition. Suppose that the nodes communicate over an undirected graph and let ${\bf{W}}\in\mathbb{R}^{N\times N}$ denote the Laplacian matrix of that graph, i.e., ${\bf{W}}_{ij}=-1$ if $(i,j)\in\mathcal{E}$, ${\bf{W}}_{ij}=|\mathcal{N}_{i}|$ if $i=j$, and ${\bf{W}}_{ij}=0$ otherwise. We can then write the problem in Eq. (4) equivalently as

[TABLE]

where $\bar{{\bf{W}}}={\bf{W}}\otimes{\bf{I}}$, ${\bf{c}}=({\bf{c}}_{1},\ldots,{\bf{c}}_{N})$, and ${\bf{c}}_{i}$ is a local copy node $i$ has of the variable ${\bf{z}}$. The constraint $\bar{{\bf{W}}}{\bf{c}}={\bf{0}}$ ensures the consensus between all the local copies ${\bf{c}}_{i}$ for $i=1,\ldots,N$, provided that the network is connected. We obtain a distributed algorithm by considering the dual of the problem in Eq. (6), we illustrate the details of algorithm derivation in Appendix. The algorithm reduces to the following steps. Initialize ${\bf{x}}_{i}^{0}={\bf{0}}$ and ${\bf{c}}_{i}^{0}=\text{argmin}_{{\bf{c}}_{i}}~{}f_{i}({\bf{c}}_{i})$ and for $k\in\mathbb{N}$

[TABLE]

Note that here ${\bf{x}}_{i}$ are the dual variables and ${\bf{c}}_{i}$ are primal problem variables. The algorithm is in the form of Eq. (2) which is a special case of our algorithm framework in Eq. (1). It is also linear convergent as presented in the following theorem, proved in Appendix E.

Proposition 2**.**

If we set $\mathcal{X}:=\texttt{Im}({\bf{W}}\otimes{\bf{I}})$ then $A({\bf{c}},{\bf{x}})\in\mathcal{X}$ for any ${\bf{c}}\in\mathbb{R}^{d}$ and ${\bf{x}}\in\mathcal{X}$. Moreover, if we choose

[TABLE]

then for all ${\bf{x}}\in\mathcal{X}$ we have

[TABLE]

where $\sigma=1-2/(\kappa({{\bf{W}}})+1)$, $\kappa({{\bf{W}}})=\lambda_{\max}({\bf{W}})L/(\mu\lambda_{\min}^{+}({\bf{W}}))$, $||\cdot||_{{\bf{M}}}$ is a norm on $\mathcal{X}$, and ${\bf{x}}^{\star}$ is the unique fixed point of $A(C({\bf{x}}),{\bf{x}})$ in $\mathcal{X}$. There exist constants $L_{A}$ and $L_{C}$ such that Eq. (3a) and Eq. (3b) hold true. See Appendix E for $L_{A}$, $L_{C}$, and the definition of $||\cdot||_{{\bf{M}}}$.

The proposition shows that the distributed algorithm in Eq. (7) over the communication graph $(\mathcal{N},\mathcal{E})$ is indeed contractive. Note that the contractivity parameter $\sigma$ depends on the spectral properties of the graph via $\kappa({{\bf{W}}})$. For example, for a complete graphs, we have $\lambda_{\max}({\bf{W}})=\lambda_{\min}^{+}({\bf{W}})=N$ meaning that $\kappa({{\bf{W}}})=L/\mu$, which is the condition number of the convex problem in Eq. (6). In other words, for complete graphs the algorithm in Eq. (7) has the same convergence rate as the decentralized algorithm in Eq. (5). For general graphs, the convergence rate becomes slower as $\lambda_{\max}({\bf{W}})/\lambda_{\min}^{+}({\bf{W}})$ grows. Note that since the graph is connected, $\lambda_{\min}^{+}({\bf{W}})$ is the second smallest eigenvalue of the graph Laplacian matrix (also known as the algebraic connectivity of the graph), which is often used to characterize connectivity or propagation times in networks [42, Appendix B].

III Maintaining Convergence Under Limited Communication

In this section, we illustrate how we can limit the communication of algorithms with $\sigma$-linear convergence rate (Definition 1) to a few bits per iteration while still maintaining the linear convergence rate. We first illustrate how we quantize the communication in the algorithm (Section III-A) and then provide our main convergence results (Section III-B).

III-A Limited Communication Algorithms

We consider the following $b$-bit (per dimension) quantized version of the algorithms in the form of Eq. (1). We initialize by setting ${\bf{x}}^{0}\in\mathcal{X}$ and ${\bf{q}}_{i}^{0}={\bf{c}}_{i}^{0}=C_{i}({\bf{x}}_{i}^{0})$ for $i=1,\ldots,N$ and then do the following iterations for $k\in\mathbb{N}$:

[TABLE]

where ${\bf{q}}=({\bf{q}}_{1},\ldots,{\bf{q}}_{N})$. The steps in Eq. (9a) and Eq. (9b) are essentially the same as the original unquantized algorithm in Eq. (1). The main difference is in the quantization step in Eq. (9c). The variable ${\bf{q}}_{i}^{k+1}$ denotes a $b$-bit (per dimension) quantization of ${\bf{c}}_{i}^{k+1}$. The quantization is done by using the quantization function $\texttt{quant}_{i}({\bf{c}}_{i},{\bf{q}}_{i},r,b)$ that projects the point ${\bf{c}}_{i}$ to the closest point on the grid illustrated in Figure 1, which can be represented by $db$-bits. The grid is centered at ${\bf{q}}_{i}^{k}$, which is available to the receiver from the previous iteration. The grid has the width $2r^{k}$ and therefore $r^{k}$ controls the accuracy of the quantization. We will show how we can control the accuracy $r^{k}$ so that its decrease will follow the convergence of the algorithm. This allows us to maintain the convergence rate of the algorithms even though we use only $b$ bits to quantize and communicate per iteration. We can formally define the quantization as follows:

Definition 2**.**

Let $\texttt{quant}_{i}:\mathbb{R}^{d}\times\mathbb{R}^{d}\times\mathbb{R}_{+}\times\mathbb{N}\rightarrow\mathbb{R}^{d}$ be the quantization function defined component-wise as follows, where $\delta(r,b):=r/(2^{b}-1)$,

[TABLE]

The following result connects the number of quantization bits $b$ and the precision of the quantization.

Lemma 1**.**

Let ${\bf{q}}_{i}\in\mathbb{R}^{d}$ be given for some $i=1,\ldots,N$. Then for all ${\bf{c}}_{i}\in\mathbb{R}^{d}$, such that $||{\bf{c}}_{i}-{\bf{q}}_{i}||_{\infty}\leq r$ we have

[TABLE]

III-B Main Result: Maintaining the Linear Convergence

We now illustrate our main results. We first provide few assumptions on what information must be available a priori to running the algorithm so that the quantization can be performed.

Assumption 2**.**

The algorithm is $A(C({\bf{x}}),{\bf{x}})$ is $\sigma$-linear (Definition 1) and the following information is available before running the algorithm: a) The parameter $\sigma$; b) The initialization of the quantization variable ${\bf{q}}_{i}^{0}$  for $i=1,\ldots,N$; c) A bound $D$ such that either i) $||{\bf{x}}^{1}-{\bf{x}}^{0}||\leq(1-\sigma)D$ or ii) $||{\bf{x}}^{0}-{\bf{x}}^{\star}||\leq D$.

That is, we assume that the parameters $\sigma$, $D$, and the initialization ${\bf{q}}_{i}^{0}$, for $i=1,\ldots,N$, are known before running the algorithm. The convergence rate $\sigma$ can often be computed easily in advance, e.g., similarly as we did in Theorem 1 and 2 in Section II-B. Prior knowledge of ${\bf{q}}_{i}^{0}$ is also reasonable since setting its value is part of initializing the algorithm. To obtain the prior knowledge of $D$, we note that it suffices to find any upper bound on either $||{\bf{x}}^{1}-{\bf{x}}^{0}||$ or $||{\bf{x}}^{0}-{\bf{x}}^{\star}||$. In optimization we can often use the problem structure to bound $||{\bf{x}}^{0}-{\bf{x}}^{\star}||$. For example, the optimization problem in Eq. (4) is $N\mu$-strongly convex so from [39, Theorem 2.1.8] we have

[TABLE]

where the final inequality can be obtained if $F({\bf{x}})\geq 0$ for all ${\bf{x}}$, which is usually the case in ML. The function value $F({\bf{x}}^{0})$ is often easily available, e.g., in logistic regression $F({\bf{x}}^{0})=\log(2)$ if ${\bf{x}}^{0}={\bf{0}}$, see Section VI. Similarly, if the algorithm projects the iterates to a compact set, which is often done in constrained optimization, then the diameter of that set gives us the bound $D$. Moreover, bounding $||{\bf{x}}^{1}-{\bf{x}}^{0}||$ only requires us, at worst, to do some initial coordinations. We note that c-i) implies c-ii) since no quantization is done at the first iteration so we have

[TABLE]

implying that $||{\bf{x}}^{0}-{\bf{x}}^{\star}||\leq 1/(1-\sigma)||{\bf{x}}^{0}-{\bf{x}}^{1}||$.

We obtain the following linear convergence rate result for the quantized algorithm.

Theorem 1**.**

Consider the quantized algorithm in Eq. (9) and suppose that Assumption 2 holds. Set

[TABLE]

*Then the following holds:

[TABLE]

For any $\epsilon>0$ we have

[TABLE]

Proof.

A proof is presented in Appendix A. ∎

Theorem 1 states that we can maintain a linear convergence of the algorithms in Definition 1 with communicating only a fixed number of bits, $bd$, per iteration. This is possible by adaptively squeezing the grid size based on the local geometry of the optimization landscape, using the designed contraction factor $\sigma$, as well as $L_{A}$ and $L_{C}$; see Figure 1. Parameter $\alpha(b)$ plays an important role in the performance of our distributed optimization with quantized information exchange. It is the decrease rate of the grid size (see Eq. (11)), the convergence rate of the limited communication algorithm (see Eq. (13)). In both cases, we need $\alpha(b)<1$ to ensure the convergence of the limited communication algorithm. It is easy to show that there is a critical $b=b_{c}$ for which $\alpha(b_{c})<1$. For any $b>b_{c}$, $\alpha(b)$ converges exponentially to $\sigma$, the convergence rate of the original unquantized algorithm. Part b) of the theorem provides a bound on the total number of bits needed to find a given solution accuracy, for a given number of bits per iteration $b$. In particular, we need to run up to $k_{\epsilon}(b)$ iterations to obtain $\epsilon$-accurate solution for any arbitrary accuracy $\epsilon>0$.

Besides the number of iterations, we can measure the total number of bits needed to ensure any $\epsilon>0$ accuracy.

Corollary 1**.**

Define $B_{\epsilon}(b)$ as the total number of communicated bits (per dimension) needed to ensure an $\epsilon$-solution using the bound in Eq. (14), provided that we communicate $b$ bits per iteration. We have

[TABLE]

Note that for given desired solution accuracy $\epsilon>0$, we can easily minimize $B_{\epsilon}(b)$ since it has only one variable $b$. That is, we can find optimal quantization that ensures convergence using the fewest bits. We explore this further in the numerical experiments in Sections V and VI.

III-C Decentralized Optimization and Comparison to [3]

We now illustrate how Theorem 1 can be used to provide a dimension dependent upper bound on the decentralized optimization algorithms in Section II-B1. This result generalizes the upper bound in [3]. The work in [3] considers the constrained optimization problem

[TABLE]

in a network of the two nodes $i=1,2$. The objective functions $\{f_{i}\}_{i}$, maintained by node $i$, are strongly-convex and smooth. The paper studied the following question: how many bits do the two nodes need to communicate to reach an $\epsilon$ accurate solution to the optimization problem in Eq. (16)? To answer this question, the authors of [3] first provide a lower bound showing that to find an $\epsilon$-accurate solution, all algorithms need to communicate at least

[TABLE]

The authors also show that an $\epsilon$-accurate solution can be achieved with an algorithm that communicates222Recall that $\kappa=L/\mu$ is the condition number of the optimization problem. In [3] $\kappa$ does not show up in the upper bound. However, a thorough inspection of the proof reveals this dependence on $\kappa$.

[TABLE]

The upper bound is tight, except for factor $\kappa\log(d\kappa)$. The algorithm that is used to achieve this upper bound is a projected gradient method with a quantization similar to Eq. (9).

Our results can generalize this upper bound to a multiple nodes. In the following discussion, we assume that each node can communicate to every other node. We first consider the unconstrained case of Section II-B1.

Corollary 2**.**

*Consider the quantized algorithm in Eq. (9) with $A(\cdot)$ and $C_{i}(\cdot)$ from Eq. (5), $\gamma=2/(N(\mu+L))$, $K$ from Eq. (12), $r^{k}$ from Eq. (11), $b=\lceil\log_{2}(24(\kappa+1)\sqrt{d})\rceil$, and $\kappa=L/\mu\geq 2$. For any $\epsilon>0$, we find $x_{\epsilon}$ such that $||x_{\epsilon}-x^{\star}||\leq\epsilon$ after the algorithm has communicated333The condition number $\kappa$ my be replaced by any upper bound on $\kappa$. Hence, the assumption $\kappa=L/\mu\geq 2$ does not restrict the results, in this case we may replace $\kappa$ with its upper bound $2$. *

[TABLE]

Proof.

A proof is presented in Appendix B. ∎

This corollary shows that the quantized version of the unconstrained decentralized gradient method archives a similar upper bound as the projected gradient method in [3] (see Eq. (18)), even for $N>2$. The only difference is that the $\log(d)$ factor in Eq. (18) has been replaced with $\log(D)$. The bound $D$ does not always depend on the dimension $d$, e.g., the upper bound in Eq. (10).

We can generalize the two-node optimization algorithm [3] to a network as

[TABLE]

The optimization algorithm we use is projected gradient method, which we write in our algorithm framework by setting

[TABLE]

for $i=1,\ldots,N$. Note that for any ${\bf{x}}^{0}\in[0,1]^{d}$ we satisfy Assumption 2 with $D=\sqrt{d}$, since $||{\bf{z}}-{\bf{y}}||_{2}\leq\sqrt{d}$ for any ${\bf{z}},{\bf{y}}\in[0,1]^{d}$. The quantized version of this algorithm leads to the following result.

Corollary 3**.**

Consider the quantized algorithm in Eq. (9) with $A(\cdot)$ and $C_{i}(\cdot)$ from Eq. (5), $K$ from Eq. (12), $r^{k}$ from Eq. (11), $\gamma=1/(NL)$, $b=\lceil\log_{2}(24(\kappa+1)\sqrt{d})\rceil$, and $\kappa=L/\mu\geq 2$. For any $\epsilon>0$, we find ${\bf{x}}_{\epsilon}$ such that $\|{\bf{x}}_{\epsilon}-{\bf{x}}^{\star}\|\leq\epsilon$ after the algorithm has communicated

[TABLE]

Proof.

A proof is presented in Appendix B. ∎

This corollary illustrates that we can use the results developed in this paper to extend the upper bound in [3] to multi-nodes. The upper bound almost matches the lower in Eq. (17), within a $\log(\kappa d)\kappa$ factor. The linear dependence on the condition number $\kappa$ is an artifact of the gradient method and cannot be improved unless we use another optimization algorithm, e.g., accelerated gradient method or a conjugate gradient method. Improving the $\log(\kappa d)$ factor might be possible.

IV Transmission-time Complexity

Although quantization (lossy compression) saves communication resources, it may fail in characterizing the actual cost of running distributed algorithms. This is because, from the engineering perspective, the tangible costs are usually the latency (time needed to run the algorithm) or energy consumption. In the following, we focus on the latency and characterize the transmission-time convergence of running the distributed algorithms from the previous section. We introduce the transmission time model that we use in subsection IV-A. We provide convergence rate results in terms of transmission time with and without communication errors in subsections IV-B and IV-C, respectively.

IV-A Transmission-Time Model

To perform an iteration of the quantized algorithms in Eq. (9) each node needs to communicate a package of

[TABLE]

In particular, $db$ bits are used to transmit the quantized message ${\bf{q}}_{i}^{k}$, $b$ per dimension. The remaining $\theta$ bits model all protocol overheads, including packet headers (source and destination IDs), parity bits for channel coding, and scheduling overheads [43]. These overheads, among other purposes, are added to realize reliable communications over an unreliable communication link and to regulate the data transmissions of multiple nodes. We discuss the overhead in more detail in Section V.

To characterize the transmission time of running the algorithms we need to define the transmission rate. To simplify the discussion we let the transmission rate be the same for each communication link.444This is without loss of generality, since we only need to consider the transmission rate of slowest communication link. The transmission rate is denoted by the function

[TABLE]

where $p\in(0,1)$ is the probability that each $n$-bit communication package fails in transmission. We discuss specific forms of the rate function $R(n,p)$ in Section V. To quantify the transmission time per iteration, we introduce the delay function $\Delta(n,p)$. In particular, the time needed to perform 1 iteration of the algorithm is denoted by

[TABLE]

and performing $k$ iterations takes

[TABLE]

If we let ${\bf{x}}_{i}(t)$ be the decision of node $i$ after $t$ transmission seconds then

[TABLE]

We now explore the algorithm convergence in terms of transmission time.

IV-B Error-free Transmission

We start by considering an error-free communication, i.e., when $p=0$. In this case, we drop the variable $p$ from the notation $R(\cdot)$ and $\Delta(\cdot)$. We get the following transmission-time convergence.

Theorem 2**.**

Consider the quantized algorithm in Eq. (9). Suppose that Assumption 2 holds and that the parameters $r^{k}$, $\alpha(b)$, and $K$ are chosen as in Eq. (11) and Eq. (12) in Theorem 1. Then we have the following convergence in terms of transmission time $t$

[TABLE]

Moreover, for any $\epsilon>0$ following holds:

[TABLE]

where

[TABLE]

with $k_{\epsilon}(b)$ defined in Eq. (14).

Proof.

This result is obtained by using Eq. (22) in Theorem 1. ∎

Eq. (25) provides us with an upper bound on the convergence of ${\bf{x}}(t)$ to fixed point ${\bf{x}}^{\star}$ in terms of transmission time. The algorithm converges linearly in terms of transmission time with the rate

[TABLE]

Unlike the convergence rate in Eq. (13) of Theorem 1, a finer quantization (larger $b$) does not necessarily ensure a faster convergence rate anymore. This is because the convergence rate $\rho(b,\theta)$ for the transmission time captures the tradeoff between spending more time to send large packets with more information (larger $b$) at the cost of doing fewer iterations per second or spending less time per iteration (by sending a packet with less information) but achieving more iterations per seconds. Even though $\rho(b,\theta)$ seems complicated, it is easily optimized numerically since it is a function of only 2 variables.

Eq. (27) is an upper bound on the transmission time (in seconds) needed to reach an $\epsilon$-accurate solution. In comparison to Theorem 1, the transmission-time needed to find an $\epsilon$-optimal solution is the iteration count $k_{\epsilon}(b)$ multiplied by the nonlinear delay function $\Delta(n)$. We will see in Section V how the nonlinearities in $\Delta(n)$ affect the transmission rate.

IV-C Faulty Transmission

We now consider the transmission time convergence in the presence of message failures, i.e., $p>0$. In particular, each transmitted message from node $i$ to node $j$ fails with probability $p$. We assume that the success of the transmissions are independent events across time and among different transmitter-receiver pairs.

To perform the algorithm in Eq. (9) a successful communication of each message ${\bf{q}}_{i}^{k}$ is required. In case of messages failures, the nodes need to re-transmit their messages until success. We let $m_{k}$ denote the number of re-transmissions of messages at iteration $k$. This means that the communication time of one iteration (cf. Eq. (21) and Eq. (22)) is $m_{i}\Delta(n,p)$ seconds and performing $k$ iterations takes

[TABLE]

We consider two chooses of $m_{i}$:

Communicate until success: $m_{i}$ is the number of communication rounds until every message has bee succesfully received. 2. 2)

Constant communication rounds: $m_{i}=m$, where $m$ is a predefined constant independent of $i$.

The communication scheme 1) is easily realizable in decentralized and parallel computing where a master node handles the coordination, like in the application in Section II-B1. However, in fully distributed algorithms in networks it is unrealistic that a single node can know when every communication has been successfully received. In this case, we can go for alternative 2) and let each node communicate a fixed number of times. We now study these two cases separately.

IV-C1 Communicate until success

From our results in Section III-B and Theorem 1, to find an $\epsilon>0$ accurate solution with $b$-bit resolution per dimension we need $k_{\epsilon}(b)$ iterations. In terms of transmission time that translates to

[TABLE]

Here $m_{k}$ are realizations of the random variable $M$ indicating the number of communication rounds needed until success at iteration $k$. To formally define $M$ we first define the set $\mathcal{L}$ of all communication links (sender-receiver pairs) used in the algorithm. Then

[TABLE]

where $S_{l}$ is a random variable indicating the number of times the communication in link $l$ is transmitted until it is successfully received. It is easily verified that $S_{l}$ follows a geometric distribution and that $P\left[S_{l}=m\right]=p^{m-1}(1-p)$ and $P\left[S_{l}\leq m\right]=1-p^{m}$. With this in mind, we can derive the following bound on the expected transmission-time needed to ensure $\epsilon$-accuracy.

Theorem 3** (Communicate until success).**

Consider the quantized algorithm in Eq. (9). Suppose that Assumption 2 holds and that the parameters $r^{k}$, $\alpha(b)$, and $K$ are chosen as in Eq. (11) and Eq. (12) in Theorem 1. Then for any $\epsilon>0$ we have

[TABLE]

where $T_{\epsilon}(b,\theta,p)$ is the random variable defined in Eq. (30). We have the following bounds on $T_{\epsilon}(b,\theta,p)$

[TABLE]

where

[TABLE]

Proof.

A proof is presented in Appendix C. ∎

The theorem tells us that the expected transmission time needed to obtain an $\epsilon$-accurate solution is bounded by

[TABLE]

This bounds consists of three multiplicity terms. The first term $k_{\epsilon}(b)$ comes from the iteration count in Theorem 1, for the number of iterations needed to find an $\epsilon$-solution. The second term is the nonlinear delay function $\Delta(b{+}\theta,p)$ accounting for the achievable communication rate. The final term accounts for the re-transmitting the messages until success. This means that the transmission time follows nonlinear relationship between $b$, $\theta$, and $p$. This relationship can easily be optimized numerically if we know the delay function $\Delta(\cdot)$, since there are only three free variables. We explore this in Section V. The third term also depends logarithmically on the number of communication links $|\mathcal{L}|$. In a network with $N$ nodes, the number of communication links is bounded as $|\mathcal{L}|\leq N^{2}$. This means that $\log(|\mathcal{L}|)\leq\log(N^{2})=2\log(N)$.

IV-C2 Fixed Number of Communication Rounds

Consider now communication scheme 2), where each node broadcast constant number of times, i.e. $m_{k}=m$ is a constant. In this case, with some probability, a message will be dropped meaning that the quantized algorithm in Section III is not guaranteed terminate successfully (we discuss how we can relax this assumption after the theorem). However, we can make the probability that the algorithm terminates successfully (finds an $\epsilon$-solution) as high as we want by increasing $m$. We illustrate this now.

Theorem 4** (Fixed number of communication rounds).**

Consider the quantized algorithm in Eq. (9). Suppose that Assumption 2 holds and that the parameters $r^{k}$, $\alpha(b)$, and $K$ are chosen as in Eq. (11) and (12) in Theorem 1. Let $\epsilon>0$ and $\delta\in[0,1)$. Suppose that each node transmits its message

[TABLE]

Then with with probability $\delta$ following holds:

[TABLE]

where $T_{\epsilon}^{\delta}(b,\theta,p)=k_{\epsilon}(b)\times\Delta(b+\theta,p)\times m_{\epsilon}^{\delta}(b,p).$

Proof.

A proof is presented in Appendix D. ∎

The theorem provides the transmission time needed to successfully compute an $\epsilon$-solution with $\delta$ probability. The upper bound is similar to the bound in Theorem 3, except the final multiplicity factor has been replaced by $m_{\epsilon}^{\delta}$. In particular, as we increase $\delta$ to $1$, the increase in the transmission time is proportional to $\mathcal{O}(1/(1-\delta))$. The transmission time linearly grows with $|\mathcal{L}|$, meaning that it can grow quadratically with number of nodes in the worst case when then communication network is a complete graph (every node communicate to every other node). As before, the convergence rate is easily optimized since it has only few parameters.

Remark 1**.**

*The algorithms considered in this paper are synchronous meaning that we require every communication to successfully terminate at every iteration. This is only an artifact of the theoretical analysis, in particular of Theorem 1. However, we may be able to extend Theorem 1 to handle asynchronous communications with delays at the cost of a slower convergence rate. In particular, if a message is delayed then we center the communicated grid at the last received ${\bf{q}}_{i}$ and use the associated grid. But the grid size should be delicately controlled (intuitively decreasing slower) so that the old grid still captures the new communicated information. This leads to slower convergence which has been traded-off for more robustness to asynchronous communications. We will leave a detailed implementation of these ideas as future work. *

V Interplay Between Distributed Algorithms

and Communication Protocol

In this section, we build on the results of the previous section to explore the interplay between communication protocols and distributed algorithms. We first introduce three abstract rate functions, $R(n,p)$, modeling various communication protocols. Afterward, we characterize the relationship between $bd$, $\theta$ $p$ and then provide numerical illustrations.

V-A Transmission Rate Models

Information and communication theory has a rich literature on rate functions in various communication settings [40, 29, 44, 45]. The shape of $R(n,p)$ typically depends on 1) the network setting, 2) communication channel, and 3) protocol overheads such as packet headers (source and destination IDs), parity bits for channel coding, and scheduling overheads in the MAC layer. Most realizations of the transmission rate function have a shape resembling one of the following three cases.

• •

Case 1 (constant): $R(n,p)=C$ for some constant positive $C$ for all $n$ and $p$.

• •

Case 2 (saturating): $R(n,p)$ for some constant $p>0$ is a non-decreasing function of $n$ that saturates for large $n$. The saturation is slower for smaller $p$.

• •

Case 3 (bell-shape): $R(n,p)$ for some constant $p>0$ increases with $n$ up to some critical $n^{c}$ and gradually decreases to zero afterward.

Case 1 models the fundamental rate upper-bound, which has been the basis for the design of many communication protocols. The seminal works of Shannon showed that for any fixed $p>0$ there exist codes such that $R(n,p)$ converges $C$ as $n$ grows large [40]. However, these results have two fundamental drawbacks. Firstly, the codes constructed by Shannon cannot be realized in practice. Secondly and more importantly, the result of Shannon requires $n$ to grow to infinity meaning that the latency (the time it takes to deliver a single packet) may grow to infinity. This is clearly not feasible for iterative algorithms where the updates of each iteration depends on the results of previous iterations. Case 2 extends Case 1 by looking at finite $n$ [45]. In particular, we can model the achievable rate as [45]

[TABLE]

where $P(n,p)$ is a penalty on the transmission-rate that is decreasing with $n$ and increasing with $p$. Polyanskiy et. al. [45] showed that the maximal achievable rate in the finite packet length regime is

[TABLE]

where $V$ is the so-called channel dispersion, and $Q(\cdot)$ is the Q-function. To give a concrete example, an additive white Gaussian noise (AWGN) channel with average signal-to-noise-ratio of $\kappa=1$ [46] has

[TABLE]

Although this approach substantially extends Case 1, this rate function is known for a handful of network settings. In practice, various communication standards may have specific limitations on the transmission power and MAC layer protocol and use various approaches to handle incoming interference from unintended transmitters. Consequently, the rate function for most practical communication networks are either unknown or is very different from the upper-bounds provided by Case 1 and Case 2, especially for multiple access channels. Case 3 models the rate function of a multiple access channel, regulated by contention-based protocols such as slotted-ALOHA and carrier-sense-multiple-access (CSMA) [29, 44]. The rationale behind this model is that increasing the offered network load (e.g., by increasing $n$) improves the rate up a certain point at which the network becomes congested. Further increase of the offered load only increases the collision among packets, leading to a drastic drop of the successful packet reception. The contention-based protocols are heavily used in most modern standards for wireless local area networks, such as IEEE 802.11 family, due to their easy implementation and inherent distributed coordination [29]. Fig. 2(a) illustrates our three example rate models.

V-B The Relationship between $bd$, $\theta$, and $p$

In communication systems, there are internal relationships between the number of payload bits $bd$, overhead bits $\theta$, and reliability $p$. For example, $bd$ and $\theta$ might be related by an affine function $\theta=A(db)+B$, where $A$ and $B$ are some constants, modeling various overheads and packet headers such as channel coding, source and destination IDs, and scheduling overheads [43]. The constant $A$ models the channel coding overhead (to ensure a reliable communication over an unreliable channel) for linear codes. In a more generic class of codes, our affine $\theta$ is a first-order approximation of the overheads required to send $bd$ bits [47]. Moreover, there exist a non-zero packet failure probability $p$, which is usually a non-linear function of $b$ and $\theta$. The exact expression depends on the transmission scheme and channel model [47], as we illustrate below. Parameter $B$ can also model the background traffic, which a node will send in parallel to running the algorithm.

V-C Illustrative Examples

We now illustrate the impact of different rate functions $R(n,p)$ on the transmission-time convergence. For illustration purposes, consider Theorem 3 with $K=1$, $D=1$, $\epsilon=0.1$, $\sigma=0.9$, $|\mathcal{L}|=20$, $d=1$, and $\theta=0$, for the three cases of $R(n,p)$ in Subsection V-A. We consider the following rate functions in bits per seconds

[TABLE]

and an AWGN channel with signal-to-noise-ratio of 1, leading to $C=\log(2)$ and $V=1.5$ as explained in the last subsection.

Fig. 2(a) illustrates our three rate models, and Fig. 2(b) shows the impact of $b$ on the transmission-time upper bound $\texttt{UB}_{\epsilon}(b,0,p)$. In Case 1, where the effects of packet size are ignored, it is the best to use a very small $b$, the optimal choice is $b=5$. In Case 2, where larger packet sizes can achieve higher rates, the optimal $b$ becomes much larger, i.e., $b\approx 40$ and $b\approx 20$, respectively, for $p=0.01$ and $p=0.05$. In Case 3, where sending very large packets by all the nodes may overload the channel (congestion), the optimal value for $b$ reduces. Commered to Case 1, channel congestion and reduced rate of Case 3 lead to have a higher penalty after optimal $b$, indicated by a sharper increase in $\texttt{UB}_{\epsilon}(b,0,p)$. Fig. 2(c) demonstrates the effect of $p$ on the transmission-time convergence for rate mode $R_{2}(n,p)$. The blue solid curve shows the optimal convergence rate $\texttt{UB}_{\epsilon}(b,0,p)$ for each $p$ by optimizing over $b$. The results indicate on the importance of optimal $b$ on the convergence time. Interestingly, there is a delicate trade-off between having $p$ too small or too big, which we explore in the next section.

VI Numerical Experiments

We test our result by training a logistic regression model on two data sets: a) SP-data [48] and b) MNIST [49]. The SP-data has dimension $d=61$ and consists of $24,075$ points from smart phone sensors used to classify whether the person carrying the phone is moving (walking, running, or dancing) or not (sitting or standing). We use random $m=10,000$ to train our model and the rest for validation. The MNIST has dimension $d=785$ and consists of pictures of handwritten digits. It has 10 labels, $m=60,000$ samples for training and $10,000$ samples for validation. We have trained a multiclass logistic regression using one-vs-rest approach.

We consider logistic regression with $l_{2}$ regularization [50]

[TABLE]

where $\rho>0$ is a regularization parameter, ${\bf{v}}_{i}\in\mathbb{R}^{d}$ the explanatory feature vector, and $y_{i}\in\{-1,1\}$ the binary output outcome. Note that $F({\bf{z}})$ is $\rho$-strongly convex and has $\rho+V$ Lipschitz continuous gradients, where $V$ can be computed by using that for each data point $i$ the gradient of $\log\left(1+\exp(-y_{i}\cdot{\bf{z}}^{\mbox{\scriptsize T}}{\bf{v}}_{i})\right)$ is $V_{i}$-Lipschitz continuous where $V_{i}=\|{\bf{v}}_{i}\|_{2}^{2}/4$. Note that from Eq. (10), if ${\bf{z}}^{0}={\bf{0}}$ then we have $||{\bf{z}}^{0}-{\bf{z}}^{\star}||\leq\sqrt{(2/\rho)\log(2)}=:D.$ The problem has a unique optimizer ${\bf{z}}^{\star}$, provided that $\rho>0$. With ${\bf{z}}^{\star}$ the logistic classifier outputs the label $y=\texttt{sign}({\bf{z}}^{\star\rm{T}}{\bf{v}})$ for the new data ${\bf{v}}$. We use $\rho=350$ for the SP-data and $\rho=1$ for MNIST, giving $99\%$ and $80\%$ accuracy on the test data, respectively.

VI-A Communication Complexity

We use the quantized version of the decentralized algorithm (Figs. 4 and 4) and the distributed algorithm (Fig. 6) in Section II-B. In both cases there are $N=20$ nodes and we split the data equally among them. Unless otherwise mentioned, we choose the parameters according to Theorems 1 and 3, e.g., for the SP-data $\gamma=2/(\mu+L)\approx 6\times 10^{-5}$, $\sigma\approx 0.98$, and $K\approx 15.8$. We compare the results to the algorithm without quantizing (but using double precision floating points, 64 bits per dimension). Fig. 2(b) illustrates the convergence of the decentralized algorithm on the SP-data, indicating that our approach can maintain the convergence of unquantized algorithm ($b=64$) by just $b=14$ or $16$. This means that the quantized version of the algorithm reduces the communicated bits by $75\%$ without slowing down the convergence speed. Fig. 3(b) depicts the convergence on the MNIST data, whose sample dimension is 13 times larger than that of the SP-data. Again, when we communicate $b=14$ or $b=16$ bits per dimension we get almost the same convergence as the unquantized algorithm, suggesting that the results of the paper scale well with the dimension.

This convergence can be improved further if we use smaller $\alpha$ than suggested in Theorem 1 and smaller $\gamma$ than suggested in Proposition 1. These choices are usually fine in practice since the theorems are generally conservative and derived to capture the worst case behaviour. By setting $\gamma=2\times 10^{-4}$ and $\alpha=0.92$, Fig. 2(c) shows that $b=12$ guarantees the same convergence rate as the non-quantized algorithm. More interestingly, our approach allows for an extreme quantization, like $b=2$. With $b=2$ we need to communicate only $800$ bits per dimension after $400$ iterations to reach $\epsilon=10^{-12}$ accuracy. To reach the same accuracy without quantizing we need about $300$ iterations so about $19200$ bits per dimension. This means that our approach reaches the same solution accuracy with $96\%$ less communications overhead. Note that when $\alpha$ is smaller than suggested in Theorem 1 then it can happen that the grid in Fig. 1 decreases to quickly, so the communicated message ${\bf{c}}_{i}^{k}$ falls outside of the grid. This did not happen for $\alpha=0.92$ but may happen smaller $\alpha$. In practice, when the grid decreases too fast ($\alpha$ too small) then the nodes could send a distress signal (requiring an additional bit) indicating that they need to increase the grid. We leave such studies for future work.

Fig. 4 depicts the total number of bits/dimension needed to reach $\epsilon=10^{-12}$ when varying $b$. The figure compares the algorithms when the parameters are selected as in Figure 3(a) (case 1, red curve), Figure 3(c) (case 2, yellow curve), and when no quantization is done (dashed and dotted lines) using 64 bit floating points. We also plot the upper bound in Eq. (15) (blue curve) on the total number of bits needed to achieve $\epsilon$-accuracy. The results show that the upper bound is almost tight. The quantized algorithms always use fewer bits to reach the $\epsilon$ accuracy. The optimal $b$ are $b=14$ and $b=2$ for the red curve and yellow curve, respectively, communicating only $25\%$ and $4\%$ of the bits needed if there is no quantization. Note that the red curve has a different shape than the yellow curve because in Theorem 1 $\alpha$ is varies depending on $b$, whereas $\alpha=0.92$ is fixed for the yellow curve.

Fig. 6 shows the convergence of the quantized version of the distributed algorithm in Eq. (7) where the nodes communicate over a graph with $\alpha=0.99$ and $\gamma=0.7$. The communication graph is shown in Fig. 5(a). It is randomly generated by distributing the nodes randomly in the box $[0,1]\times[0,1]$ and creating an edge between nodes if the distance between them is less than $0.3$. The results are similar as before, with $b=12$ bits/dimension we get almost the same convergence rate as without quantizing. To achieve $\epsilon=10^{-6}$ accuracy with $b=2$ the quantized algorithm communicates $3466$ bits/dimension during $1733$ iterations but the non-quantized algorithm communicates $71808$ bits during $1122$ iterations. This means that we reduce the communication by $95\%$ to get the $\epsilon$ accuracy compared to the non-quanitzed algorithm. We use $\alpha=0.98$

VI-B Transmission Time Complexity

We now explore the transmission time complexity of the logistic regression algorithm from the previous section using rate functions of Case 3 and Case 2, as illustrated in Section V-A. In these simulations we do not consider the overhead bits, i.e., we set $\theta=0$.

Fig. 5(c) illustrates the convergence on the SP-data as a function of transmission time when the rate function follows

[TABLE]

for some positive constants Max_Rate and $A$. The constant $A$ captures the level of channel congestion. Larger $A$ implies that the channel get congested faster (with smaller n). In a slotted-ALOHA or CSMA protocol with $n$ nodes, for example, $A$ is inversely linearly proportional to $n$ [29, 44]. 555In particular, with the common assumption of Poisson packet arrival for every node and i.i.d. traffics, the additivity of the Poisson distribution implies that we can model the network of $n$ nodes by one virtual node having aggregated arrival of $n$ time [29]. The constant Max_Rate is the maximum rate, it is achieved by setting $n=A$. We set $\texttt{Max\_Rate}=10^{12}$ and $A=50$, $100$, and $200$ and $b=10$ and $14$. From the previous subsection we know that $b=14$ is the optimal quantization size if we want to minimize the total number of communicated bits needed to reach an $\epsilon$-accurate solution. However, Fig. 5(c) illustrates that as $A$ increases (the channel contention level increases), the network enjoys smaller $b$. In particular, for $A=50$, it takes roughly twice the transmission time to reach the same solution accuracy with $b=10$ as compared to $b=14$. On the other hand, when $A=200$, it takes roughly twice the transmission time to reach the same solution accuracy with $b=14$ as compared to $b=10$. In general, the optimal $b$ decreases as $A$ increases.

Fig. 5(d) illustrates the convergence for the Case 2 transmission-rate function $R_{2}(\cdot)$ given in Section V-C. We explore how the problem dimension $d$ affects the transmission time convergence. To see the affects of $d$, we run logistic regression on a synthetic data set with tuneable $d$: set $y_{i}=1$ and ${\bf{v}}_{i}={\bf{1}}+{\bf{n}}_{i}\in\mathbb{R}^{d}$ with probability $0.5$ and $y_{i}=-1$ and ${\bf{v}}_{i}=-{\bf{1}}+{\bf{n}}_{i}\in\mathbb{R}^{d}$ otherwise where ${\bf{n}}_{i}\in\mathbb{R}^{d}$ are i.i.d. Gaussian variables with zero mean and variance $1$. We use $\alpha=0.98$ and $b=2$. The figure illustrates the scaled transmission time needed to reach $\epsilon=10^{-6}$ accuracy as a function of $p$. In particular, if $\bar{T}_{\epsilon}(p,d)$ is the transmission time until we find an $\epsilon$ accuracy then the scaled transmission time is $\bar{T}_{\epsilon}(p,d)/\min_{p\in[0,1]}\bar{T}_{\epsilon}(p,d)$. The results show that for small dimensions, $d=1$, $5$, and $10$, there is a delicate trade-off between having $p$ too small or too big, however, as $d$ increases it becomes better to choose small $p$. This means that in the small packet region ($d$ is small) it is good to trade-off packet reliability for quicker messages. However, as the packet size increases (with growing $d$) and $R_{2}(\cdot)$ saturates it becomes better to spend more time to communicating more reliable packets. This can in parts been explained by the fact that when we use large packets $R_{2}(\cdot)$ approximates the Shannon capacity and we efficiently achieve more reliable communication.

VII Conclusions

We investigated the convergence of distributed algorithms under limited communication. We proved that a simple quantization scheme that maps a real-valued vector to a constant number of bits can maintain the linear convergence rate of unquantized algorithms. We exemplified our results on two classes of communication graphs: i) decentralized one where a single master coordinates information from workers, and ii) fully distributed one where nodes coordinate over a communication graph. We numerically illustrated our theoretical convergence results in distributed learning on test data including MNIST. Our quantization can reduced the communicated overhead (in terms of bits) by $95\%$ in some cases to reach a predefined solution accruacy, compared to using floating points. Future work includes exploring adaptive quantization schemes for more general classes of algorithm, including accelerated optimization algorithms and algorithms with sub-linear converge rates.

Appendix A Proof of Theorem 1

Eq. (13): We prove by mathematical induction that $||{\bf{x}}^{k}-{\bf{x}}^{\star}||\leq\alpha(b)^{k}D$ and$||{\bf{c}}^{k}-{\bf{q}}^{k}||_{\infty}\leq\tau r^{k-1}$, where $\tau=1/(\lfloor 2^{b}\rfloor-1)$. For $k=0$ we have $||{\bf{x}}^{0}-{\bf{x}}^{\star}||\leq D$ by Assumption 2-c) and $||{\bf{c}}^{0}-{\bf{q}}^{0}||=0\leq\tau r^{-1}$ since ${\bf{q}}^{0}={\bf{c}}^{0}$. Suppose that the result holds for some integer $k\geq 0$. Then by the triangle inequality and Eq. (3a) we have

[TABLE]

where we have used that $A({\bf{c}},{\bf{x}})$ is $L_{A}$-Lipschitz continuous in ${\bf{c}}$ and that $A(C({\bf{x}}),{\bf{x}})$ is $\sigma$-pseudo-contraction in ${\bf{x}}$. We also have by the triangle inequality and Eq. (3b) that

[TABLE]

Therefore, from Lemma 1, $||{\bf{c}}^{k+1}-{\bf{q}}^{k+1}||_{\infty}\leq\tau r^{k}$.

Prove of Eq. (14): By using the inequality $1+t\leq\exp(t)$ for all $t\in\mathbb{R}$ we have that

[TABLE]

Hence, the result follows by part a) by rearranging $\exp(-(1-\alpha(b))k)D\leq\epsilon$.

Appendix B Proof of Corollary 2 and 3

Corollary 2: From Proposition 1 and Theorem 1 we have $\sigma=(\kappa-1)/(\kappa+1)$, $L_{A}=2\sqrt{d}/(\mu+L)$, $L_{C}=L$ and

[TABLE]

since $L/(\mu+L)\leq 1$ and $\kappa\geq 2$. Therefore, using that $2^{b}-1\geq 2^{b-1}$, we have $\alpha(b)\leq 1-({2}/{\kappa+1})+{24\sqrt{d}}/{2^{b}},$ or by rearranging

[TABLE]

where we have used that $b=\lceil\log_{2}(24\sqrt{d}(\kappa+1))\rceil$. Eq. (14) in Theorem 1 now yields

[TABLE]

Corollary 3: From [39], the algorithm is $\sigma$-linear with

[TABLE]

We also have $L_{A}=\sqrt{d}/L$, $L_{C}=L$ meaning that $K\leq 2\sqrt{2d}$,

[TABLE]

and

[TABLE]

since $b=\left\lceil\log_{2}(16\kappa\sqrt{2d})\right\rceil$. Eq. (14) now yields

[TABLE]

Appendix C Proof of Theorem 3

Let $M$ be the random variable defined in Eq. (31). Since $m_{i}$ are all realizations of $M$ we have $E[T_{\epsilon}(b,\theta,p)]=\Delta(b,\theta,p)\times k_{\epsilon}(b)\times E[M].$ To finish the prove we derive the inequality

[TABLE]

Recall that $P\left[S_{l}=m\right]=p^{m-1}(1-p)$ and $P\left[S_{l}\leq m\right]=1-p^{m}$. Using that the communications are independent across links $\mathcal{L}$ we have $P(M\leq m)=(1-p^{m})^{|\mathcal{L}|}.$ This means that

[TABLE]

The last sum can be bounded by integral as follows

[TABLE]

where $h(z)=1-p^{z}$ and we have used that $(1-h(z)^{|\mathcal{L}|})\geq 0$ is decreasing in $z$. Using that $h^{\prime}(z)/(1-h(z))=-\log(p)$, integration by substitution gives

[TABLE]

The result now follows from the fact that

[TABLE]

Appendix D Proof of Theorem 4

Using the independence of failure events in all links $\mathcal{L}$ we have $P(M\leq m)=(1-p^{m})^{|\mathcal{L}|}.$ From Theorem 1, we find an $\epsilon$-accurate solution after $k\geq k_{\epsilon}(b)$ successful iterations. Therefore, we just have to ensure that the communication of the first $k$ iterations is successful. In particular, we need

[TABLE]

where $k=k_{\epsilon}(b)$. By rearranging we get that

[TABLE]

Using that $\log(y+1)\geq y/(y+1)$ for all $y>-1$ we have

[TABLE]

where the last inequality is due to $\delta^{1/(|\mathcal{L}|k)}\leq 1$. To finish the proof, we should show that

[TABLE]

This inequality can be derived by using the following variant of Bernoulli’s inequality: $(1+x)^{r}\leq 1+rx$ for all $r\in[0,1]$ and $x\geq-1$. By applying the change of variables $\delta=1+x$ and $r=1/(|\mathcal{L}|k)$ and rearranging we obtain the result.

Appendix E Proof of Proposition 2

The algorithm in Eq. (7) in Section II-B2 is a variant of dual decomposition and is similar to the algorithm [38]. To derive the algorithm we reformulate the optimization problem in Eq. (4) in consensus form as follows:

[TABLE]

where $\bar{{\bf{W}}}={\bf{W}}\otimes{\bf{I}}$ and ${\bf{A}}=\sqrt{\bar{{\bf{W}}}}$ is the matrix square root of $\bar{{\bf{W}}}$, i.e., ${\bf{A}}^{\mbox{\scriptsize T}}{\bf{A}}=\bar{{\bf{W}}}$, obtained by eigenvalue decomposition.666$\bar{{\bf{W}}}$ and ${\bf{A}}$ have the same null-space so the constraints $\bar{{\bf{W}}}{\bf{x}}={\bf{0}}$ and ${\bf{A}}{\bf{x}}={\bf{0}}$ are equivalent. In particular, since $\bar{{\bf{W}}}$ is symmetric and semi-positive-definite we can write ${\bf{A}}=\sqrt{\boldsymbol{\Lambda}}{\bf{Q}}$ where $\bar{{\bf{W}}}={\bf{Q}}^{\mbox{\scriptsize T}}\boldsymbol{\Lambda}{\bf{Q}}$ and the columns of ${\bf{Q}}$ are the normalized eigenvectors of $\bar{{\bf{W}}}$, and $\boldsymbol{\Lambda}$ is a diagonal matrix where the diagonal elements are the eigenvalues of $\bar{{\bf{W}}}$ in descending order, i.e.,

[TABLE]

Note that because the last $d$ diagonal elements of $\boldsymbol{\Lambda}$ are zero the last $d$ rows of a ${\bf{A}}$ are zero. Define $\bar{{\bf{A}}}\in\mathbb{R}^{d(N-1)\times d}$ as the non-zero rows of ${\bf{A}}$. $\bar{{\bf{A}}}$ has full row rank since the eigenvectors are linearly independent, so the square matrix $\bar{{\bf{A}}}\bar{{\bf{A}}}^{\mbox{\scriptsize T}}$ is non-singular. We show that the algorithm function ${\bf{x}}\mapsto A(C({\bf{x}}),{\bf{x}})$ is contractive on $\mathcal{X}:=\texttt{Im}(\bar{{\bf{W}}})$ in the following norm.

Lemma 2**.**

Define ${\bf{M}}:=(\bar{{\bf{A}}}\bar{{\bf{A}}}^{\mbox{\scriptsize T}})^{-1}\bar{{\bf{A}}}$. Then $||{\bf{x}}||_{{\bf{M}}}:=||{\bf{M}}{\bf{x}}||_{2}$ is a norm on $\mathcal{X}$.777Note that $||\cdot||_{{\bf{M}}}$ is not a norm on all of $\mathbb{R}^{Nd}$. Moreover, if we define $M_{1}=||{\bf{M}}||_{2}$ and $M_{2}=||{\bf{A}}^{\mbox{\scriptsize T}}||_{2}$ then $||{\bf{x}}||_{{\bf{M}}}\leq M_{1}||{\bf{x}}||_{2}$ and $||{\bf{x}}||_{2}\leq M_{2}||{\bf{x}}||_{{\bf{M}}}$, for all ${\bf{x}}\in\mathcal{X}$.

Proof.

To prove that $||{\bf{x}}||_{{\bf{M}}}$ is a norm on $\mathcal{X}$, we need to show that following holds for all ${\bf{x}},{\bf{y}}\in\mathcal{X}$ [51, Definition 5.1.1]: (1a) $||{\bf{x}}||_{{\bf{M}}}\geq 0$, (1b) $||{\bf{x}}||_{{\bf{M}}}=0$ if and only if ${\bf{x}}=0$, (2) $||c{\bf{x}}||_{{\bf{M}}}=c||{\bf{x}}||_{{\bf{M}}}$ for any positive scalar $c$, and (3) $||{\bf{x}}+{\bf{y}}||_{{\bf{M}}}\leq||{\bf{x}}||_{{\bf{M}}}+||{\bf{y}}||_{{\bf{M}}}$.

Conditions (1a), (2), and (3) follow directly from the fact that $||\cdot||_{2}$ is a norm. To show that (1b) holds true note that if ${\bf{x}}\in\mathcal{X}=\texttt{Im}(\bar{{\bf{W}}})$ then there exists ${\bf{z}}\in\mathbb{R}^{dN}$ such that ${\bf{x}}=\bar{{\bf{W}}}{\bf{z}}$. Moreover, by using that $\bar{{\bf{W}}}={\bf{A}}^{\mbox{\scriptsize T}}{\bf{A}}$ and the definition of $\bar{{\bf{A}}}$ we also have that ${\bf{x}}=\bar{{\bf{A}}}^{\mbox{\scriptsize T}}\bar{{\bf{A}}}{\bf{z}}$ and $||{\bf{x}}||_{{\bf{M}}}=\bar{{\bf{A}}}{\bf{z}}$. Therefore, if ${\bf{x}}\neq{\bf{0}}$ then $||{\bf{x}}||_{{\bf{M}}}=||\bar{{\bf{A}}}{\bf{z}}||_{2}\neq 0$, since $\bar{{\bf{A}}}{\bf{z}}={\bf{0}}$ implies that ${\bf{x}}={\bf{0}}$, which proves that condition (1b) holds true.

The inequality $||{\bf{x}}||_{{\bf{M}}}\leq M_{1}||{\bf{x}}||_{2}$ follows directly from the definition of the norm $||\cdot||_{{\bf{M}}}$. The inequality $||{\bf{x}}||_{2}\leq M_{2}||{\bf{x}}||_{{\bf{M}}}$ can be obtained similarly by noting that ${\bf{x}}={\bf{A}}^{\mbox{\scriptsize T}}{\bf{M}}{\bf{x}}$. ∎

To prove the contraction, we show that the algorithm is a standard dual decomposition algorithm after some change of variables. The dual function of the problem in Eq. (36) is

[TABLE]

where ${\bf{c}}({\bf{x}})=\text{argmin}_{{\bf{c}}}~{}F({\bf{c}})+\langle{\bf{x}},{\bf{c}}\rangle.$ The dual gradient is $\nabla D({\bf{v}})={\bf{A}}{\bf{c}}({\bf{A}}^{\mbox{\scriptsize T}}{\bf{v}})$ and the dual function can be maximized by the gradient method

[TABLE]

By doing the change of variables ${\bf{x}}={\bf{A}}^{\mbox{\scriptsize T}}{\bf{v}}$ and multiplying the ${\bf{v}}$-update by ${\bf{A}}^{\mbox{\scriptsize T}}$ the gradient method can be written on the following form

[TABLE]

which is the same as the algorithm in Eq. (7) in Section 2.2.2. Note that if ${\bf{v}}^{0}\in\mathcal{V}:=\texttt{Im}({\bf{A}})$ and ${\bf{x}}^{0}\in\mathcal{X}$ then all the iterates are in $\mathcal{V}$ and $\mathcal{X}$, respectively, i.e., ${\bf{v}}^{k}\in\mathcal{V}$ and ${\bf{x}}^{k}\in\mathcal{X}$ for all $k\in\mathbb{N}$. We can go from ${\bf{x}}={\bf{A}}^{\mbox{\scriptsize T}}{\bf{v}}\in\mathcal{X}$ to ${\bf{v}}\in\mathcal{V}$ by the transform ${\bf{v}}={\bf{M}}{\bf{x}}=(\bar{{\bf{A}}}\bar{{\bf{A}}}^{\mbox{\scriptsize T}})^{-1}\bar{{\bf{A}}}{\bf{x}}.$ We now conclude the prove by showing that the function

[TABLE]

is a contraction in the 2-norm and that ${\bf{x}}\mapsto A(C({\bf{x}}),{\bf{x}})$ is a contraction on $\mathcal{X}$ in the norm $||\cdot||_{{\bf{M}}}$.

Lemma 3**.**

Suppose that the step-size is chosen as

[TABLE]

Then for all ${\bf{v}}\in\mathcal{V}$ and ${\bf{x}}\in\mathcal{X}$ we have

[TABLE]

where $G(\cdot)$ is as defined in Eq. (37) and

[TABLE]

and ${\bf{v}}^{\star}$ is a maximizer of the dual function $D(\cdot)$ and ${\bf{x}}^{\star}={\bf{A}}^{\mbox{\scriptsize T}}{\bf{v}}^{\star}$. In particular, if we choose $\gamma=2L\mu/(\mu\lambda_{\min}^{+}({\bf{W}})+L\lambda_{\max}({\bf{W}}))$ then for any ${\bf{v}}\in\mathcal{V}$ we have

[TABLE]

where $\sigma=1-2/(\kappa+1)$ and $\kappa=\lambda_{\max}({\bf{W}})L/(\mu\lambda_{\min}^{+}({\bf{W}}))$.

Proof.

The iterative algorithm defined by $G(\cdot)$ is a gradient ascent for the concave dual function $D(\cdot)$, which is $\lambda_{\min}^{+}({\bf{W}})/L$-strongly concave and $\lambda_{\max}({\bf{W}})/\mu$-smooth (we show this in Lemma 4 below). Therefore, by standard results in convex optimization, $G(\cdot)$ is contractive on $\mathcal{V}$ with the contractivity parameter $\sigma_{\gamma}$, see e.g. [39, Theorem 2.1.15]. To prove that $A(C({\bf{x}}),{\bf{x}})$ is a contraction on $\mathcal{X}$, take ${\bf{x}}\in\mathcal{X}$ and ${\bf{M}}{\bf{x}}\in\mathcal{V}$. Then by setting ${\bf{x}}^{+}=A(C({\bf{x}}),{\bf{x}})$ and ${\bf{v}}^{+}=G({\bf{v}})$, we have

[TABLE]

which yields the results. ∎

Lemma 4**.**

$D(\cdot)$* is a) $\lambda_{\min}^{+}({\bf{W}})/L$-strongly concave on the set $\mathcal{V}$ and $\lambda_{\max}({\bf{W}})/\mu$-smooth.*

Proof.

We can write $D({\bf{v}})=-F^{*}(-{\bf{A}}^{\mbox{\scriptsize T}}{\bf{v}})$ and $\nabla D({\bf{v}})={\bf{A}}\nabla F^{*}(-{\bf{A}}^{\mbox{\scriptsize T}}{\bf{v}})$ where $F^{*}(\cdot)$ is the convex conjugate of $F(\cdot)$. To prove the strongly concavity we use that $F^{*}(\cdot)$ is $1/L$-strongly convex since $F(\cdot)$ is $L$-smooth, see [52, Proposition 12.60]. Take ${\bf{v}}_{1},{\bf{v}}_{2}\in\mathcal{V}$, then

[TABLE]

where we have used that ${\bf{y}}_{1},{\bf{y}}_{2}\in\mathcal{V}$ and $\lambda_{\min}^{+}({\bf{A}}{\bf{A}}^{\mbox{\scriptsize T}})=\lambda_{\min}^{+}({\bf{W}})$ to get the last inequality.

To prove the smoothness of $D(\cdot)$ we use that $F^{*}(\cdot)$ is $1/\mu$-strongly convex. Take some ${\bf{v}}_{1},{\bf{v}}_{2}$, then

[TABLE]

which concludes the proof. ∎