"Short-Dot": Computing Large Linear Transforms Distributedly Using Coded Short Dot Products

Introduction

This work proposes a coding-theory inspired computation technique for speeding up computing linear transforms of high-dimensional data by distributing it across multiple processing units that compute shorter dot products. Our main focus is on addressing the “straggler effect,” i.e., the problem of delays caused by a few slow processors that bottleneck the entire computation. To address this problem, we provide techniques (building on ) that introduce redundancy in the computation by designing a novel error-correction mechanism that allows the size of individual dot products computed at each processor to be shorter than the length of the input. Shorter dot products offer advantages in computation, storage and communication in distributed linear transforms.

The problem of computing linear transforms of high-dimensional vectors is “the" critical step in several machine learning and signal processing applications. Dimensionality reduction techniques such as Principal Component Analysis (PCA), Linear Discriminant Analysis (LDA), taking random projections, require the computation of short and fat linear transforms on high-dimensional data. Linear transforms are the building blocks of solutions to various machine learning problems, e.g., regression and classification etc., and are also used in acquiring and pre-processing the data through Fourier transforms, wavelet transforms, filtering, etc. Fast and reliable computation of linear transforms are thus a necessity for low-latency inference . Due to saturation of Moore’s law, increasing speed of computing in a single processor is becoming difficult, forcing practitioners to adopt parallel processing to speed up computing for ever increasing data dimensions and sizes.

Classical approaches of computing linear transforms across parallel processors, e.g., Block-Striped Decomposition , Fox’s method , and Cannon’s method , rely on dividing the computational task equally among all available processorsStrassen’s algorithm and its generalizations offer a recursive approach to faster matrix multiplications over multiple processors, but they are often not preferred because of their high communication cost . without any redundant computation. The fusion node collects the outputs from each processors to complete the computation and thus has to wait for all the processors to finish. In almost all distributed systems, a few slow or faulty processors – called “stragglers” – are observed to delay the entire computation. This unpredictable latency in distributed systems is attributed to factors such as network latency, shared resources, maintenance activities, and power limitations. In order to combat with stragglers, cloud computing frameworks like Hadoop employ various straggler detection techniques and usually reset the task allotted to stragglers. Forward error-correction techniques offer an alternative approach to deal with this “straggler effect” by introducing redundancy in the computational tasks across different processors. The fusion node now requires outputs from only a subset of all the processors to successfully finish. In this context, the use of preliminary erasure codes dates back to the ideas of algorithmic fault tolerance . Recently optimized Repetition and Maximum Distance Separable (MDS) codes have been explored to speed up computations.

We consider the problem of computing $\bm{A}\bm{x}$ where $\bm{A}_{(M\times N)}$ is a given matrix and $\bm{x}_{(N\times 1)}$ is a vector that is input to the computation $(M\ll N)$. In contrast with , which also uses codes to compute linear transforms in parallel, we allow the size of individual dot products computed at each processor to be smaller than $N$, the length of the input.

Why might one be interested in computing short dot products while performing an overall large linear transform? One reason is straightforward: the computation time depends on the length of the dot-products computed. Processors are also inherently memory limited, which limits the size of dot products that can be computed. In some distributed and cloud computing systems, the computation time is dominated by the time taken to communicate $\bm{x}$ to the processors. In systems where multi-casting $\bm{x}$ is not possible or is inefficient, it may be faster to communicate a subset of the co-ordinates of $\bm{x}$ to each processor. In such systems, we anticipate that communicating shorter vectors, each formed by these subsets of coordinates of $\bm{x}$, is likely to result in substantial speedups over schemes that require the entire $\bm{x}$ vector (in particular when multi-casting is difficult).Another interesting example comes from recent work on designing processing units that exclusively compute dot-products using analog components . These devices are prone to errors and increased delays in convergence when designed for larger dot products. In Sections 4 and 6, we show both theoretically (under model assumptions inspired from that admit simplified expected time analysis while being a crude approximation of experimental observations) and experimentally that the speed-up using Short-Dot can be increased beyond that obtained using the strategy proposed in , in straggler-prone environments.

To summarize, our main contributions are:

To compute $\bm{A}\bm{x}$ for a given matrix $\bm{A}_{(M\times N)}$, we instead compute $\bm{F}\bm{x}$ where we construct $\bm{F}_{(P\times N)}$ (total no. of processors $P$ > Required no. of dot-products $M$) such that each $N$-length row of $\bm{F}$ has at most $N(P-K+M)/P$ non-zero elements. Because the locations of zeros in a row of $\bm{F}$ are known by design, this reduces the complexity of computing dot-products of rows of $\bm{F}$ with $\bm{x}$. Here $K$ parameterizes the resilience to stragglers: any $K$ of the $P$ dot products of rows of $\bm{F}$ with $\bm{x}$ are sufficient to recover $\bm{A}\bm{x}$, i.e., any $K$ rows of $\bm{F}$ can be linearly combined to generate the rows of $\bm{A}$.

We provide fundamental limits on the trade-off between the length of the dot-products and the straggler resilience (number of processors to wait for) for any such strategy in Section 3. This suggests a lower bound on the length of task allotted per processor. Our limits show that Short-Dot is near-optimal.

Assuming exponential tails of service-times at each server (used in ), we derive the expected computation time required by our strategy and compare it to uncoded parallel processing, repetition strategy and MDS coding (see Fig. 2) based linear computation. We also explicitly show a regime ($M=\frac{P}{\log P}$) where Short-Dot outperforms all its competing strategies in expected computation time, by a factor of $\frac{\log(P)}{\log(\log P)}$, that diverges to infinity for large $P$. In general, Short-Dot is found to be universally faster than all its competing strategies over the entire range of $M\leq P$. When $M$ is linear in $P$, Short-Dot offers speed-up by a factor of $\Omega(\log(P))$ over uncoded, parallel processing and repetition. When $M$ is sub-linear in $P$, Short-Dot out-performs repetition or MDS coding based linear computations by a factor of $\Omega\left(\frac{P}{M\log(P/M)}\right)$ .

We also provide experimental results showing that Short-Dot is faster than existing strategies.

In a concurrent work, in , Tandon et al. consider a coded computation problem similar to ours for the special case where $M$, the number of $N$-length dot-products to be computed, is $1$ and the given matrix $\bm{A}_{M\times N}$ (in this case just a single row vector) is $[1,1,\dots,1]_{1\times N}$. We note that for $M=1$, the gain of using coded strategies over replication-based strategies is bounded even as $N$ and $P\to\infty$ for $s=\Theta(N/P)$ . Our paper differs from in that we consider the more general case $M\geq 1$, and observe that the gains over replication can be unbounded with this scaling in the regime $s=\Theta(MN/P)$. For $M>1$, the number of operations per processor using our strategy is lower than an application of for the same worst-case straggler resilience. To see this, note that a straightforward extension of the strategy proposed in that encodes each row of $\bm{A}$ separately for $M(>1)$ rows would require $M$ dot-products of length $\frac{N(P-K+1)}{P}$ at each processor while using a “joint” encoding across rows, Short-Dot only requires a single dot-product of length $\frac{N(P-K+M)}{P}$ (note that $\frac{N(P-K+M)}{P}<M\times\frac{N(P-K+1)}{P}$) at each processor, while still requiring the same number of processors (any $K$ out of $P$) to finish. Further, we also provide a tighter converse for $M>1$ that proves that Short-Dot is near-optimal. It is worth noting that also introduces the notion of partial stragglers, which is outside the scope of our paper.

For multiple dot-products, an alternative repetition-based strategy is to compute $M$ dot products $P/M$ times in parallel at different processors. Now we only have to wait for at least one processor corresponding to each of the $M$ vectors to finish (see Fig. 2). Improving upon repetition, it is shown in that an $(P,M)$-MDS code allows constructing $P$ coded vectors such that any $M$ of $P$ dot-products can be used to reconstruct all the $M$ original vectors (see Fig. 2). This strategy is shown, both experimentally and theoretically, to perform better than repetition and uncoded strategies.

Can we go beyond MDS codes? MDS codes-based strategies require $N$-length dot-products to be computed on each processor. Short-Dot instead constructs $P$ vectors of sparsity $s$ (less than $N$), such that the dot product of $\bm{x}$ with any $K\ (\geq M)$ out of these $P$ short vectors is sufficient to compute the dot-product of $\bm{x}$ with all the $M$ given vectors (see Fig. 2). Compared to MDS Codes, Short-Dot is more flexible as it waits for some more processors (since $K\geq M$), but each processor computes a shorter dot product. Short-Dot also effectively reduces the communication cost since only a shorter portion of the input vector is to be communicated to each processor. We also propose Short-MDS, an extension of the MDS codes-based strategy in to create short dot-products of length $s$, through block partitioning, and compare it with Short-Dot. In regimes where $\frac{N}{s}$ is an integer, Short-MDS may be viewed as a special case of Short-Dot. But when $\frac{N}{s}$ is not an integer, Short-MDS has to wait for more processors in worst case than Short-Dot for the same sparsity $s$, as discussed in Remark 2 in Section 2.

Our coded parallelization strategy: Short-Dot

Given row vectors $\{\bm{a}_{1}^{T},\bm{a}_{2}^{T},\ldots,\bm{a}_{M}^{T}\}$, there exists a $P\times N$ matrix $\bm{F}$ such that a linear combination of any $K(>M)$ rows of the matrix is sufficient to generate the row vectors and each row of $\bm{F}$ has sparsity at most $s=\frac{N}{P}(P-K+M)$, provided $P$ divides $N$.

In the next lemma, we show how the row sparsity of $\bm{F}$ can be constrained to be at most $\frac{N}{P}(P-K+M)$ by appropriately choosing the appended vectors $\bm{z}_{1},\ldots,\bm{z}_{K-M}$.

Proof: We select a sparsity pattern that we want to enforce on $\bm{F}$ and then show that there exists a choice of the appended vectors $\bm{z}_{1},\ldots,\bm{z}_{K-M}$ such that the pattern can be enforced. Sparsity Pattern enforced on $\bm{F}$: This is illustrated in Fig. 4. First, we construct a $P\times P$ “unit block” with a cyclic structure of nonzero entries, where $(K-M)$ zeros in each row and column are arranged as shown in Fig. 4. Each row and column have at most $s_{c}=P-K+M$ non-zero entries. This unit block is replicated horizontally $N/P$ times to form an $P\times N$ matrix with at most $s_{c}$ non-zero entries in each column, and and at most $s=Ns_{r}/P$ non-zero entries in each row. We now show how choice of $\bm{z}_{1},\ldots,\bm{z}_{K-M}$ can enforce this pattern on $\bm{F}$.

Here $\bm{A}_{j}=[a_{1}(j)\ a_{2}(j)\ldots a_{M}(j)]^{T}$ is actually the $j$-th column of given matrix $\bm{A}$ and $\bm{z}=[z_{1}(j),\ \ldots\ z_{K-M}(j)]^{T}$ depends on the choice of the appended vectors. Thus,

From Lemmas 1 and 2, for a given $M\times N$ matrix $\bm{A}$, there always exists a $P\times N$ matrix $\bm{F}$ such that a linear combination of any $K$ columns of $\bm{F}$ is sufficient to generate our given vectors and each row of $\bm{F}$ has sparsity at most $s=\frac{N}{P}(P-K+M)$. This proves the theorem. $\blacksquare$

Remark 1: Relaxed conditions on matrix $\bm{B}$

It has been stated in Lemmas $1$ and $2$ that all square sub-matrices of $\bm{B}$ need to be invertible. A matrix with i.i.d. Gaussian entries can be shown to satisfy this property with probability $1$. In fact the condition on $\bm{B}$ in Lemmas $1$ and $2$ can be relaxed, as evident from the proof. For matrix $\bm{B}_{P\times K}$ we only need two conditions. (1) All $K\times K$ square sub-matrices are invertible. (2) All $(K-M)\times(K-M)$ square sub-matrices in the last $K-M$ columns of $\bm{B}$ are invertible. A Vandermonde Matrix satisfies both these properties and thus can be used for encoding in Short-Dot.

With this insight in mind, we now formally state our computation strategy:

Remark 2: Short-MDS - a special case of Short-Dot

An extension of the MDS codes-based strategy proposed in , that we call Short-MDS can be designed to achieve row-sparsity $s$. First block-partition the matrix of $N$ columns, into $\left\lceil{N/s}\right\rceil$ sub-matrices of size $M\times s$, and also divide the total processors $P$ equally into $\left\lceil{N/s}\right\rceil$ parts. Now, each sub-matrix can be encoded using a $(\frac{P}{\left\lceil{N/s}\right\rceil},M)$ MDS code. In the worst case, including all integer effects, this strategy requires $K=P-\left\lfloor{\frac{P}{\left\lceil{N/s}\right\rceil}}\right\rfloor+M$ processors to finish. In comparison, Short-Dot requires $K=P-\left\lfloor{\frac{Ps}{N}}\right\rfloor+M$ processors to finish. In the regime where, $s$ exactly divides $N$, Short-MDS can be viewed as a special case of Short-Dot, as both the expressions match. However, in the regime where $s$ does not exactly divide $N$, Short-MDS requires more processors to finish in the worst case than Short-Dot. Short-Dot is a generalized framework that can achieve a wider variety of pre-specified sparsity patterns as required by the application. In Table 1, we compare the lengths of the dot-products and straggler resilience $K$, i.e., the number of processors to wait for in worst case, for different strategies.

Limits on trade-off between the length of dot-products and parameter K

In this section, we derive fundamental trade-offs between the length of the dot-products computed at each individual processor and the number of processors to wait for, i.e., $K$, which parametrizes the resilience to stragglers. First we derive an information-theoretic limit in Theorem 2 that holds for any matrix $\bm{A}$, such that each column has at least one non-zero entryNote that choice of such a class of matrix $\bm{A}$ is reasonable, since if say the $j$-th column of $\bm{A}$ consists entirely of zeros, then the $j$-th column and its corresponding entry in unknown vector $\bm{x}$ can simply be omitted from the problem.. In Theorem 3, we show how this bound can be tightened further, so that in the limit of large number of columns of matrix $\bm{A}$, Short-Dot is near-optimal.

Let $\bm{A}_{M\times N}$ be any matrix such that each column has at least one non-zero element. For any matrix $\bm{F}_{P\times N}$ satisfying the property that the span of its any $K$ rows contains the span of the $M$ rows of $\bm{A}_{M\times N}$, the average sparsity $\bar{s}$ over the rows of $\bm{F}_{P\times N}$ must satisfy \bar{s}\geq\frac{N}{P}\big{(}P-K+1\big{)}.

Proof: We claim that $K$ is strictly greater than the maximum number of zeros that can occur in any column of the matrix $\bm{F}$. If not, suppose the $j$-th column of $\bm{F}$ has more than $K$ zeros. Then there exists a choice of $K$ rows of $\bm{F}$ such that any linear combination of these rows will always be at the $j$-th column index. However, since the $j$-th column of $\bm{A}$ has at least one non-zero entry, say at row $i$, it is not possible to generate the $i$-th row of $\bm{A}$ by linearly combining these chosen $K$ rows of $\bm{F}$. Thus,

Here the last line follows since maximum value is always greater than average. Note that if $\bar{s}$ is the average sparsity over the rows of $\bm{F}_{P\times N}$, then the average number of zeros over the columns of $\bm{F}_{P\times N}$ can be written as $\frac{(N-\bar{s})P}{N}$. Thus, from (4),

A slight re-arrangement establishes the lower bound in Theorem 2. $\blacksquare$ Recall that, Short-Dot achieves a column sparsity of at most $(P-K+M)$ while a hard lower bound is $(P-K+1)$ from this proof. The bound is tight for $M=1$. The bound on average row-sparsity s\geq\frac{N}{P}\big{(}P-K+1\big{)} is also tight only for $M=1$ (implicitly assuming $P$ divides $N$, since $P\ll N$). Now we tighten this bound further for $M>1$.

Let $M>1$. Then there exists a matrix $\bm{A}_{M\times N}$, such that any $\bm{F}_{P\times N}$ satisfying the property that any $K$ rows of $\bm{F}_{P\times N}$ can span all the rows of $\bm{A}_{M\times N}$, must also satisfy the following property:

The average sparsity over the rows of $\bm{F}_{P\times N}$ is lower bounded as

Moreover, if $N$ is sufficiently large, such that $M^{2}\binom{P}{K-M+1}=o(N)$, then the average sparsity over the rows of $\bm{F}_{P\times N}$ is lower bounded as

Note that the second term in the lower bound in (6) does not depend on $N$. Thus, if $N$ is sufficiently larger than $P$ and $M$, the second term in the lower bound becomes negligible compared to the first term, and the first term is precisely what Short-Dot can achieve. Thus, from this lower bound, we can conclude that when $N$ is large, Short-Dot is near optimal.

Before proceeding with the proof, we give a basic intuition on the proof technique. We basically divide the columns of $\bm{F}_{P\times N}$ into two groups, one with at most $(K-M)$ zeros, and other with more than $(K-M)$ zeros. Then we show that there exist matrices $\bm{A}_{M\times N}$ such that the number of columns in the latter group, i.e., with more than $(K-M)$ zeros is bounded, and this in turn bounds the average sparsity. Now we formally prove the theorem.

Proof: Let us denote the number of columns of $\bm{F}_{P\times N}$ with more than $(K-M)$ zeros as $\lambda$. We will show later in Lemma 3 that $\lambda<M\binom{P}{K-M+1}$. Now, compute the average number of zeros over the columns of $\bm{F}$. The columns of $\bm{F}$ can be divided into two groups : $\lambda$ columns with greater than $(K-M)$ zeros and $(N-\lambda)$ columns with at-most $(K-M)$ zeros. Recall from (3), that if $\bm{A}$ is chosen such that every column has at-least one non-zero entry, then the maximum number of zeros in any column of $\bm{F}$ is upper bounded by $(K-1)$. Thus, the group of $\lambda$ columns can have at-most $K-1$ zeros each. Thus,

If $\bar{s}$ is the average sparsity of each row of $\bm{F}$, then the average zeros of each column of $\bm{F}$ is given by $\frac{(N-\bar{s})P}{N}$. Thus,

After slight re-arrangement, the average sparsity of each row of $\bm{F}$ can be bounded as:

Thus, the first part of the theorem, i.e., (6) is proved. Using the condition that $M^{2}\binom{P}{K-M+1}=o(N)$ in (6), we can also obtain (7). Thus,

Thus, the theorem is proved. $\blacksquare$

Lemma 3: Let $M>1$. Then there exists a matrix $\bm{A}_{M\times N}$, such that any $\bm{F}_{P\times N}$ satisfying the property that any $K$ rows of $\bm{F}_{P\times N}$ can span all the rows of $\bm{A}_{M\times N}$, must also satisfy the following property: The number of columns $(\lambda)$ with more than $K-M$ zeros is upper bounded as $\lambda<M\binom{P}{K-M+1}$.

Proof: Assume, $\lambda\geq M\binom{P}{K-M+1}$. Now, a column with more than $(K-M)$ zeros will have at least $(K-M+1)$ zeros. There can be at most $\binom{P}{K-M+1}$ different patterns in which $(K-M+1)$ zeros can occur in a column of length $P$. Every column with more than $(K-M+1)$ zeros also has one of these $\binom{P}{K-M+1}$ column sparsity pattern, just with more zeros. From a pigeon-hole argument, at least one of these sparsity patterns of $(K-M+1)$ zeros will surely occur in $\frac{\lambda}{\binom{P}{K-M+1}}$ columns or more. Let us consider the sub-matrix of $\bm{F}$, of size $P\times\frac{\lambda}{\binom{P}{K-M+1}}$, consisting of only the columns of $\bm{F}$ having $(K-M+1)$ zeros in the same locations, i.e., with similar sparsity pattern. Any $K$ rows of this sub-matrix of $\bm{F}$ should generate all the rows of a corresponding $M\times\frac{\lambda}{\binom{P}{K-M+1}}$ sub-matrix of the given $\bm{A}$, consisting of the same columns of $\bm{A}$ as picked in this sub-matrix of $\bm{F}$.

There always exists a fully dense matrix $\bm{A}$ such any $M\times\frac{\lambda}{\binom{P}{K-M+1}}$ sub-matrix of $\bm{A}$ is full-rank, since $\bm{A}$ can be arbitrary. This sub-matrix of $\bm{A}$ is of rank $\min\{M,\frac{\lambda}{\binom{P}{K-M+1}}\}=M$(from assumption). Any $K$ rows of the sub-matrix of $\bm{F}$, should generate $M$ linearly independent rows of this sub-matrix of $\bm{A}$. But since the sub-matrix of $\bm{F}$ has $(K-M+1)$ rows consisting of all zeros, there is a choice of $K$ rows, such that all these zero rows are chosen, and we are only left with at most $M-1$ non-zero rows to generate $M$ linearly independent rows of $\bm{A}$. This is a contradiction. Thus, we must have $\lambda>M\binom{P}{K-M+1}$. $\blacksquare$

Analysis of expected computation time for exponential tail models

We now provide a probabilistic analysis of the computation time required by Short-Dot and compare it with uncoded parallel processing, repetition and MDS coding based linear computation scheme as shown in Fig. 5. We follow the shifted-exponential computation time model as described in . Although the shifted exponential distribution may only be a crude approximation of the delay of real systems, we use the shifted exponential model since it is analytically tractable and allows for a fair comparison with the strategy proposed in . We assume that the time required by a processor to compute a single dot-product of length $N$ be distributed as:

Here, $\mu(>0)$ is the “straggling parameter” that determines the unpredictable latency in computation time. Intuitively, the shifted exponential model states that for a task of size $N$, there is a minimum time offset proportional to $N$ such that the probability of completion of the task before that time is . The probability of task completion is maximum at the time-offset and then decays with an exponential tail after that. This nature of the model might be attributed to the fact that while a processor is most likely to finish its task of size $N$ at a time proportional to $N$, but an unpredictable latency due to queuing and various other factors causes an exponential tail. For an $s$ length dot product, we simply replace $N$ by $s$ in (12), as suggested in . The analysis of expected computation time requires closed form expressions of the $K$-th statistic which is simplistic for exponential tails. However a more thorough empirical study is necessary to establish any chosen model for straggling in a particular environment.

The expected computation time for Short-Dot is the expected value of the $K$-th order statistic of these $P$ iid exponential random variables, which is given by:

Here, (13) uses the fact that the expected value of the $K$-th statistic of $P$ iid exponential random variables with parameter $1$ is $\sum_{i=1}^{P}\frac{1}{i}-\sum_{i=1}^{P-K}\frac{1}{i}\approx\log(P)-\log(P-K)$ . The expected computation time in the RHS of (13) is minimized when $P-K=\Theta(M)$. This minimal expected time is $\mathcal{O}(\frac{MN}{P})$ for $M$ linear in $P$ and is $\mathcal{O}\left(\frac{MN\log(P/M)}{P}\right)$ for $M$ sub-linear in $P$.

A detailed analysis of the expected computation time for the competing strategies, i.e., uncoded strategy, repetition and MDS coding strategy is provided in the Appendix. Table 2 shows the order-sense expected computation time in the regimes where $M$ is linear and sub-linear in $P$.

Note that in the regime where $M$ is linear in $P$, Short-Dot outperforms Uncoded Strategy by a factor diverging to infinity for large $P$. Similarly, in the regime where $M$ is sub-linear in $P$, Short-Dot outperforms MDS coding strategy by a factor that diverges to infinity for large $P$. Thus Short-Dot universally outperforms all its competing strategies over the entire range of $M$.

Now we explicitly provide a regime, where the speed-ups from Short-Dot diverges to infinity for large $P$, in comparison to all three competing strategies - MDS Coding, Repetition or Uncoded strategies.

Suppose $M$ scales as $\frac{P}{\log{P}}$. Then, Short-Dot with $K=P-\frac{M}{2}$ has an expected computation time (scaled by $N$) as $\frac{{\rm I\kern-2.10002ptE}[T_{SD}]}{N}=O(\frac{\log(\log{P})}{\log{P}})$ that decays to as $P\to\infty$. In contrast, the expected computation time (scaled by $N$) for MDS coding, repetition and uncoded strategies scale as $\Omega(1)$ and thus do not decay to as $P\to\infty$.

Proof: For the proof of this theorem, we simply substitute the values of $M$ and $K$ in the expressions of expected computation time as follows. We let $M=\frac{P}{\log P}$ for all the strategies. For uncoded strategy, we thus obtain,

For MDS Coding based linear computation, we obtain,

Now, we consider the Short-Dot strategy with $K=P-\frac{M}{2}=P-\frac{P}{2\log{P}}$. Note that the inequality $K>M$ is satisfied for $\log{P}>\frac{3}{2}$. Now let us calculate the expected computation time for Short-Dot.

Thus, the speed-up offered by Short-Dot in this regime is $\frac{\log{P}}{\log(\log P)}$, and thus diverges to infinity for large $P$, as illustrated in Fig. 6.

Encoding and Decoding Complexity

Even though encoding is a pre-processing step (since $\bm{A}$ is assumed to be given in advance), we include a complexity analysis for the sake of completeness. Recall from Section 2 that we first choose an appropriate matrix $\bm{B}$ of dimension $P\times K$, such that every $K\times K$ square sub-matrix is invertible and all $(K-M)\times(K-M)$ sub-matrices in the last $(K-M)$ columns are invertible. Now, for each of the $N$ columns of the given matrix $\bm{A}$, we perform the following.

modulo𝑗1…𝑗𝐾𝑀1𝑃1\ \ \ \ U\leftarrow(\{(j-1),\ldots,(j+K-M-1)\}\mod P)+1 $\rhd$ The set of $(K-M)$ indices that are 0 for the $j$-th column of $\bm{F}$ Set \ \ \ \bm{B}^{U}\leftarrow\text{Rows of }\bm{B}\text{ indexed byU} Solve for $\bm{z}:\ \ \ \ \ (\bm{B}^{U}_{cols\ M+1:K})[\ \bm{z}\ ]=-\ \bm{B}^{U}_{cols\ 1:M}[\bm{A}_{j}]$ $\rhd$ $\bm{z}_{(K-M)\times 1}$ is a row vector. Set $\ \ \ \ \ \bm{F}_{j}=\bm{B}[\bm{A}_{j}^{T}\ |\bm{z}^{T}\ ]^{T}$ $\rhd$ $\bm{F}_{j}$ is a column vector ( $j$-th col of $\bm{F}$) For each of the $N$ columns, the encoding requires a matrix inversion of size $(K-M)\times(K-M)$ to solve a linear system of equations, a matrix-vector product of size $(K-M)\times M$ and another matrix vector product of size $P\times K$. The naive encoding complexity is therefore $\mathcal{O}(N((K-M)^{3}+(K-M)M+PK))$. Note that effectively there are only $N/P$ different column sparsity patterns for this particular design discussed in this paper. Thus, there are effectively $N/P$ unique $\bm{B}^{U}$s , and thus $N/P$ unique matrix inversions can suffice for all the $N$ columns, as sparsity pattern is repeated. Thus, the complexity can be reduced to $\mathcal{O}(\frac{N}{P}(K-M)^{3}+(K-M)MN+PKN)=\mathcal{O}(\frac{N}{P}(K-M)^{3}+2PKN)$

This is higher than MDS coding based linear computation that has an encoding complexity of $\mathcal{O}(NMP))$, but it is only a one-time cost that provides savings in online steps (as discussed earlier in this section).

The encoding complexity can be reduced further for special choices of the matrix $\bm{B}$. Let us choose $\bm{B}$ to be a Vandermonde matrix as given by

Here $U$ denotes a set of $(K-M)$ indices $\in\{1,2,\dots,P\}$. The matrix-vector product $\bm{B}^{U}_{cols\ 1:M}[\bm{A}_{j}]$ is equivalent to the evaluation of a polynomial of degree $(K-1)$ with the $K$ co-efficients as $[\bm{A}_{j}^{T}\bm{0}_{(K-M)\times 1}]$ at $(K-M)$ arbitrary points given by $\{h_{l}|l\in U\}$. Once this product is obtained, the linear system of equations reduces to the interpolation of the $(K-M)$ unknown co-efficients of a polynomial of degree $(K-M-1)$ (which is $\bm{z}$), from its value at $(K-M)$ arbitrary points as given by $\{h_{l}|l\in U\}$. Once $\bm{z}$ is obtained, we perform the following operation.

This step is equivalent to the evaluation of a polynomial of degree $(K-1)$ at $P$ points given by $\{h_{l}|l=1,2,\dots P\}$. Thus we decompose our encoding problem for each column of $\bm{A}$ into a bunch of polynomial evaluation and interpolation problems, all of degree less than $P$. Now, from , , we know that both the interpolation and the evaluation of a polynomial of degree less than $P$, at $P$ arbitrary points is $\mathcal{O}(P\log^{2}(P))$. Thus, the complexity of encoding is $\mathcal{O}(NP\log^{2}(P))$.

2 Decoding Complexity:

During decoding, we get $K$ dot-products from the first $K$ processors out of $P$. We then perform the following operations.

We solve a system of $K$ linear equations in $K$ variables and use only $M$ values of the obtained solution vector. Thus, effectively we do a single matrix inversion of size $K\times K$ followed by a matrix-vector product of size $K\times M$. The decoding complexity of Short-Dot is thus $\mathcal{O}(K^{3}+KM)$ which does not depend on $N$ when $M,K\ll N$. This is nearly the same as $\mathcal{O}(M^{3}+M^{2})$ complexity of MDS coding based linear computation.

Similar to encoding, using Vandermonde matrices can reduce the decoding complexity further. As already discussed, we choose the encoding matrix $\bm{B}$ as a Vandermonde matrix as described in (18). The decoding problem consists of solving a a system of $K$ linear equations in $K$ variables.

Here $V$ is a set of $K$ indices $\in\{1,2,\dots,P\}$. The problem of finding $\bm{w}$ is equivalent to the interpolation of the co-efficients of a polynomial of degree $(K-1)$, from its values at $K$ arbitrary points given by $\{h_{l}|l\in V\}$. Again, from , , the interpolation of a polynomial of degree $(K-1)$, at $K$ arbitrary points can be done in $\mathcal{O}(K\log^{2}(K))$, which thus becomes the decoding complexity.

Experimental Results

We perform experiments on computing clusters at CMU to test the computational time. We use HTCondor to schedule jobs simultaneously among the $P$ processors. We compare the time required to classify $10000$ handwritten digits of the MNIST database, assuming we are given a trained $1$-layer Neural Network. We separately trained the Neural network using training samples, to form a matrix of weights, denoted by $\bm{A}_{10\times 785}$. For testing, the multiplication of this given $10\times 785$ matrix, with the test data matrix $\bm{X}_{785\times 10000}$ is considered. The total number of processors was $20$.

Assuming that $\bm{A}_{10\times 785}$ is encoded into $\bm{F}_{20\times 785}$ in a pre-processing step, we store the rows of $\bm{F}$ in each processor apriori. Now portions of the data matrix $\bm{X}$ of size $s\times 10000$ are sent to each of the $P$ parallel processors as input. We also send a C-program to compute dot-products of length $s=\frac{N}{P}(P-K+M)$ with appropriate rows of $\bm{F}$ using command condor-submit. Each processor outputs the value of one dot-product. The computation time reported in Fig. 7 includes the total time required to communicate inputs to each processor, compute the dot-products in parallel, fetch the required outputs, decode and classify all the $10000$ test-images, based on $35$ experimental runs.

Key Observations: (See Table 3 for detailed results). Computation time varies based on nature of straggling, at the particular instant of the experimental run. Short-Dot outperforms both MDS and Uncoded, in mean computation time. Uncoded is faster than MDS since per-processor computation time for MDS is larger, and it increases the straggling, even though MDS waits for only for $10$ out of $20$ processors. However, note that Uncoded has more variability than both MDS and Short-Dot, and its maximum time observed during the experiment is much greater than both MDS and Short-Dot. The classification accuracy was $85.98\%$ on test data.

The experimental times are quite high due to some limitations of the experimental platform used. The time includes some overhead to start the cluster, and communicate data in the form of text files to all the processors, and also collect the output data files back from all the processors. The read time also depends on the size of file to be read. Currently, we are looking at performing these experiments in alternate distributed computing platforms, with better communication protocols.

Discussion

The major advantage of using Short-Dot codes over the MDS coding strategy in is that the length of the pre-stored vectors (rows of $\bm{F}$) as well as the communicated input (portions of $\bm{x}$) is shorter than $N$. It is thus applicable when processing units have limitations of memory, and it is not possible to pre-store the long vectors of length $N$. Short-dot also has advantages over in systems where the principle bottlenecks in computation time is in communicating the input $\bm{x}$ to all the processors, and it may not be feasible to broadcast (multicast) $\bm{x}$ to all processors at the same time. Thus, it is also useful in applications where communication costs are predominant over computation costs.

2 Errors instead of erasures:

While we focus on the problem of erasures in this paper, Short-Dot can also be used to correct errors. Consider the scenario when instead of straggling or failures, some processors return entirely faulty or garbage outputs, in a distributed system and we do not know which of the outputs are erroneous. We argue from coding theoretic arguments that Short-Dot codes designed to tolerate $(P-K)$ stragglers, can also correct $\lfloor\frac{(P-K)}{2}\rfloor$ errors. First observe that if the code can tolerate $(P-K)$ stragglers, then the Hamming Distance between any two code-words should at least be $(P-K+1)$. Hence, the number of errors that can be corrected is $\lfloor\frac{(\text{Hamming Distance -1})}{2}\rfloor$ which is $\lfloor\frac{(P-K)}{2}\rfloor$. The same result can also be derived by recasting the decoding problem as a sparse reconstruction problem, and borrowing ideas from standard compressive sensing literature which also yields a concrete, decoding algorithm. The problem reduces to an $l_{0}$ minimization problem, which can be relaxed into an $l_{1}$ minimization, or solved using alternate sparse reconstruction techniques, under certain constraints on the encoding matrix $\bm{B}$.

3 More dot-products than processors

While we have presented the case of $M<P$ here, Short-Dot easily generalizes to the case where $M\geq P$. The matrix can be divided horizontally into several chunks along the row dimension (shorter matrices) and Short-Dot can be applied on each of those chunks one after another. Moreover if rows with same sparsity pattern are grouped together and stored in the same processor initially, then the communication cost is also significantly reduced during the online computations, since only some elements of the unknown vector $\bm{x}$ are sent to a particular processor.

Acknowledgments: Systems on Nanoscale Information fabriCs (SONIC), one of the six SRC STARnet Centers, sponsored by MARCO and DARPA. We also acknowledge NSF Awards 1350314, 1464336 and 1553248. S Dutta also received Prabhu and Poonam Goel Graduate Fellowship.

References

Appendix

We now provide a probabilistic analysis of the computational time required by Short-Dot and compare it with uncoded parallel processing, repetition and MDS code based linear computation as shown in Fig. 5. We assume that the time required by a processor to compute a single dot-product follows an exponential distribution and is independent of other parallel processors.

Let us assume, the time required to compute a single dot-product of length $N$, follow the distribution:-

Here, $\mu(>0)$ is a straggling parameter, that determines the “unpredictable latency” in computation time. We also assume, that if the length of the dot-product is $s$ where $s$ is the sparsity of the vector, the probability distribution of the computational time varies as:-

Now we derive the expected computation time using our proposed strategy and compare it with existing strategies in the regimes where the number of dot-products $M$ is linear and sub-linear in $P$.

Table 2 shows the order-sense expected computation time in the regimes where $M$ is linear and sub-linear in $P$.

The computation time over each of the $P$ processors behaves as iid exponential random variables following the distribution:-

Now, the expected computation time is the expected value of the $K$-th order statistic of these $P$ iid exponential random variables, which is given by:-

Here we use the result (from ) that the $K-$ th order statistic of $P$ exponential random variables that are iid as $\sim\exp(-T)\ \forall\ T\ \geq 0$ is given by

For large $P$ and $K<P$, we can approximate the following:

Note that the expected computation time is minimized when $K=P-\Theta(M)$, and is given by:-

If $M=\Theta(P)$, the expected time is $\mathcal{O}(\frac{MN}{P})$. If $M=o(P)$, the expected time is $\mathcal{O}\left(\frac{MN\log(P/M)}{P}\right)$. Note that $s=\frac{(P-K+M)N}{P}$ is actually an upper bound on the length of each dot-product achieved using Short-Dot. Thus the expression obtained in (27) is an upper bound for the actual expected computation time. Thus we use $\mathcal{O}(.)$ instead of $\Theta(.)$.

2 Existing Strategies

For one single processor to compute all $M$ dot-products of length $N$, the computation time is distributed as

Thus, the expected computation time can be easily derived to be

Now, consider an uncoded strategy where the computation is simply divided into $P$ dot-products and sent to $P$ processors. We assume that each processor is sent only one dot-product at a time. We wait for all the processors to finish computation. Note that integer effects arise when $M$ does not exactly divide $P$. Some rows can be divided among $\left\lceil{\frac{P}{M}}\right\rceil$ processors, while the remaining are divided among $\left\lfloor{\frac{P}{M}}\right\rfloor$ processors. Let $m_{1}$ and $m_{2}$ denote the number of rows that get $\left\lceil{\frac{P}{M}}\right\rceil$ processors and $\left\lfloor{\frac{P}{M}}\right\rfloor$ processors respectively. Clearly the values can be obtained by solving:-

Now, we have two groups of exponential variables: one group consisting of $m_{1}\left\lceil{\frac{P}{M}}\right\rceil$ iid exponential random variables of task size $\frac{N}{\left\lceil{\frac{P}{M}}\right\rceil}$ , and another group consisting of $m_{2}\left\lfloor{\frac{P}{M}}\right\rfloor$ iid exponential random variables of task size $\frac{N}{\left\lfloor{\frac{P}{M}}\right\rfloor}$. The two groups are independent of each other. Note that we assume that $N$ is large compared to $P$ and is divisible by $P,\left\lfloor{\frac{P}{M}}\right\rfloor,\left\lfloor{\frac{P}{M}}\right\rfloor$, so that the integer effects with respect to $N$ do not appear and the plots can be scaled with respect to $N$ for ease of understanding.

The expected computation time is thus given by the expectation of the maximum of all these $P=m_{1}\left\lceil{\frac{P}{M}}\right\rceil+m_{2}\left\lfloor{\frac{P}{M}}\right\rfloor$ exponential random variables.

This expression is numerically computed using MATLAB and plotted in the plot of theoretical computation time in Fig. 5. When $M$ divides $P$ exactly, the expressions are simpler. The computation time for each processor is distributed as

The expected computation time is the maximum of $P$ such independent and identically distributed random variables, as given by:-

The expected time for this uncoded strategy is $\Theta\left(\frac{MN\log(P)}{P}\right)$ regardless of whether $M$ is linear or sub-linear in $P$. Our strategy Short-Dot thus offers a speed-up of $\Omega(\log(P))$ in expected computation time when $M$ is linear in $P$, as mentioned in (27), and thus outperforms by a factor that diverges to infinity for large $P$.

When a $(P,M)$ repetition strategy is used, we separate the matrix into $M$ rows and repeat each row $P/M$ times, so as to obtain a total of $P$ tasks. Note that integer effects arise when $M$ does not exactly divide $P$. Some rows are repeated $\left\lceil{\frac{P}{M}}\right\rceil$ times, while the remaining are repeated $\left\lfloor{\frac{P}{M}}\right\rfloor$ times. Let $m_{1}$ and $m_{2}$ denote the number of rows that are repeated $\left\lceil{\frac{P}{M}}\right\rceil$ times and $\left\lfloor{\frac{P}{M}}\right\rfloor$ times respectively. Clearly the values can be obtained by solving:-

Now, the minimum of $\left\lceil{\frac{P}{M}}\right\rceil$ (or similarly $\left\lfloor{\frac{P}{M}}\right\rfloor$ ) iid exponential random variables is also exponential with parameter scaled by $\left\lceil{\frac{P}{M}}\right\rceil$ (or similarly $\left\lfloor{\frac{P}{M}}\right\rfloor$ ). The expected computation time is thus given by the expectation of the maximum of $m_{1}$ independent exponential variables with parameter scaled by $\left\lceil{\frac{P}{M}}\right\rceil$ and $m_{2}$ independent exponential variables with parameter scaled by $\left\lfloor{\frac{P}{M}}\right\rfloor$.

This expression is computed using MATLAB in the plot of theoretical expected computation time (Fig. 5). When $M$ exactly divides $P$, the analysis is simpler, and the two types of exponential distributions are identical. Following an analysis similar to , it simplifies to the expectation of the maximum of $M$ iid exponential random variables, each of which is the minimum of $P/M$ iid exponential random variables.

When $M$ is linear in $P$, the expected computation time is $\Theta(\frac{MN}{P}\log(P))$ while our strategy achieves $\mathcal{O}(N)$ in this regime. When $M$ is sub-linear in $P$, the expected computation time is $\Theta(N)$ while Short-Dot achieves $\mathcal{O}\left(\frac{MN\log(P/M)}{P}\right)$ that offers speed-up by a factor diverging to infinity.

The matrix is separated into $M$ rows and coded into $P$ rows using a $(P,M)$ MDS code. Thus, each processor effectively computes a dot-product of length $N$. We have to wait for any $M$ processors to finish. Assuming the computation of each processor is independent, following an analysis similar to , we obtain that,

When $M$ is linear in $P$, the expected computation time is $\Theta(N)$ as compared to our strategy that achieves $\mathcal{O}(MN/P)$. However, in the regime where $M$ is sub-linear in $P$, the expected computation time is also $\Theta(N)$ while our strategy achieves $\mathcal{O}\left(\frac{MN\log(P/M)}{P}\right)$, and thus outperforms MDS codes by a factor that diverges to infinity for large $P$.