Nearly-optimal Robust Matrix Completion
Yeshwanth Cherapanamjeri, Kartik Gupta, Prateek Jain
Introduction
In this paper, we study the Robust Matrix Completion (RMC) problem where the goal is to recover an underlying low-rank matrix by observing a small number of sparsely corrupted entries from the matrix. Formally,
RMC is an important problem with several applications such as recommendation systems with outliers. Similarly, the problem is also heavily used to model PCA under gross outliers as well as erasures [JRVS11]. Finally, as we show later, an efficient solution to RMC enables faster solution for the robust PCA (RPCA) problem as well. The goal in RPCA is to find a low-rank matrix and sparse matrix by observing their sum, i.e., . State-of-the-art results for RPCA shows exact recovery of a rank-, -incoherent (see Assumption 1, Section 3) if at most fraction of the entries in each row/column of are corrupted [HKZ11, NUNS+14].
However, the existing state-of-the-art results for RMC with optimal fraction of corrupted entries, either require at least a constant fraction of the entries of to be observed [CJSC11, CLMW11] or require restrictive assumptions like support of corruptions being uniformly random [Li13]. [KLT14] also considers RMC problem but studies the noisy setting and do not provide exact recovery bounds. Moreover, most of the existing methods for RMC use convex relaxation for both low-rank and sparse components, and in general exhibit large time complexity ().
In this work, we attempt to answer the following open question (assuming ): Can RMC be solved exactly by using observations out of which fraction of the observed entries in each row/column are corrupted. Note that both (for uniformly random ) and values mentioned in the question above denote the information theoretic limits. Hence, the goal is to solve RMC for nearly-optimal number of samples and nearly-optimal fraction of corruptions.
Under standard assumptions on and for , we answer the above question in affirmative albeit with which is (ignoring log factors) larger than the optimal sample complexity (see Theorem 1). In particular, we propose a simple projected gradient (PGD) style method for RMC that alternately cleans up corrupted entries by hard-thresholding; our method’s computational complexity is also nearly optimal (). Our algorithm is based on projected gradient descent for estimating and alternating projection on set of sparse matrices for estimating . Note that projection is onto non-convex sets of low-rank matrices (for ) and sparse matrices (for ), hence standard convex analysis techniques cannot be used for our algorithm.
In a concurrent and independent work, [YPCC16] also studied the RMC problem and obtained similar results. They study an alternating minimization style algorithm while our algorithm is based on low-rank projected gradient descent. Moreover, our sample complexity, corruption complexity as well as time complexity differs along certain critical parameters: a) Sample complexity: Our sample complexity bound is dependent only logarithmically on , the condition number of the matrix (see Table 1). On the other hand, result of [YPCC16] depends quadratically on , which can be significantly large. However, our sample complexity bound depends logarithmically on the final error (defined as ); this implies that for typical finite precision computation, our sample complexity bound can be worse by a constant factor. b) Our result allows the fraction of corrupted entries to be information theoretic optimal (up to a constant) , while the result of [YPCC16] allows only fraction of corrupted entries. c) As a consequence of the sample complexity bounds, running time of the method by [YPCC16] depends quintically on . On the other hand, our algorithm has optimal sparsity (up to a constant factor) independent of and polylogarithmic dependence on for sample and running time complexities.
Several recent results [JN15, NUNS+14, JTK14, HW14, Blu11] show that under certain assumptions, projection onto non-convex sets indeed lead to provable algorithms with fast convergence to the global optima. However, as explained in Section 3, RMC presents unique set of challenges as we have to perform error analysis with the errors arising due to missing entries as well as sparse corruptions, both of which interact among themselves as well. In fact, our careful error analysis also enables us to improve results for the matrix completion as well as the RPCA problem.
Matrix Completion (MC): The goal of MC is to find rank- using . State-of-the-art result for MC uses nuclear norm minimization and requires under standard -incoherence assumption (see Section 3), but the method requires time in general. The best sample complexity result for a non-convex iterative method (with at most logarithmic dependence on the condition number of ) achieve exact recovery when and needs computational steps. In contrast, assuming , our method achieves nearly the same sample complexity of trace-norm but with nearly linear time algorithm (). See Table 1 for a detailed comparison of our result with the existing methods.
RPCA: Several recent results show that RPCA can be solved if -fraction of entries in each row and column of are corrupted [NUNS+14, HKZ11] where is assumed to be -incoherent. Moreover, St-NcRPCA algorithm [NUNS+14] can solve the problem in time . Corollary 2 shows that by sampling uniformly at random, we can solve the problem in time only. That is, we can recover without even observing the entire input matrix. Moreover, if the goal is to recover the sparse corruption as well, then we can obtain a two-pass (over the input matrix) algorithm that solves the RPCA problem exactly. St-NcRPCA algorithm requires passes over the data. Our method has significantly smaller space complexity as well.
Our empirical results on synthetic data demonstrates effectiveness of our method. We also apply our method to the foreground background separation problem; our method is an order of magnitude faster than the state-of-the-art method (St-NcRPCA) while achieving similar accuracy.
In summary, this paper’s main contributions are: (a) RMC: We propose a nearly linear time method that solves RMC with random entries and with optimal fraction of corruptions (). (b) Matrix Completion: Our result improves upon the existing linear time algorithm’s sample complexity by an factor, and time complexity by factor, although with an extra factor in both time and sample complexity. (c) RPCA: We present a nearly linear time () algorithm for RPCA under optimal fraction of corruptions, improving upon time complexity of the existing methods.
Paper Organization: We present our main algorithm in Section 2 and our main results in Section 3. We also present an overview of the proof in Section 3. Section 4 presents our empirical result. Due to lack of space, we present most of the proofs and useful lemmas in Appendix.
Algorithm
For the above problem, we propose a simple iterative algorithm that combines projected gradient descent (for ) with alternating projections (for ). In particular, we maintain iterates (with rank ) and sparse . is computed using gradient descent step for objective (3) and then projecting back onto the set of rank matrices. That is,
where denotes projection of onto the set of rank- matrices and can be computed efficiently using SVD of , . is computed by projecting the residual onto set of sparse matrices using a hard-thresholding operator, i.e.,
Unfortunately, just the above two simple iterations cannot handle problems where has poor condition number, as the intermediate errors can be significantly larger than the smallest singular values of , making recovery of the corresponding singular vectors challenging. To alleviate this issue, we propose an algorithm that proceeds in stages. In the -th stage, we project onto set of rank- matrices. Rank is monotonic w.r.t. . Under standard assumptions, we show that we can increase in a manner such that after each stage decreased by at least a constant factor. Hence, the number of stages is only logarithmic in the condition number of .
See Algorithm 1 (PG-RMC ) for a pseudo-code of the algorithm. We require an upper bound of the first singular value for our algorithm to work. Specifically, we require . Alternatively, we can also obtain an estimate of by using the thresholding technique from [YPCC16] although this requires an estimate of the number of corruptions in each row and column. We also use a simplified version of Algorithm 5 from [HW14] to form independent sets of samples for each iteration which is required for our theoretical analysis. Our algorithm has an “outer loop” (see Line 6) which sets rank of iterates appropriately (see Line 7). We then update and in the “inner loop” using (4), (5). We set threshold for the hard-thresholding operator using singular values of current gradient descent update (see Line 12). Note that, we divide uniformly into sets, where is an upper bound on the number of outer iterations and is the number of inner iterations. This division ensures independence across iterates that is critical to application of standard concentration bounds; such division is a standard technique in the matrix completion related literature [JN15, HW14, Rec11]. Also, is a tunable parameter which should be less than one and is smaller for “easier” problems.
Note that updating requires computational steps. Computation of requires computing SVD for projection , which can be computed in time time (ignoring factors); see [JMD10] for more details. Hence, the computational complexity of each step of the algorithm is linear in (assuming ). As we show in the next section, the algorithm exhibits geometric convergence rate under standard assumptions and hence the overall complexity is still nearly linear in (assuming is just a constant).
Rank based Stagewise algorithm: We also provide a rank-based stagewise algorithm (R-RMC) where the outer loop increments by one at each stage, i.e., the rank is in the -th stage. Our analysis extends for this algorithm as well, however, its time and sample complexity trades off a factor of from the complexity of PG-RMC with a factor of (rank of ). We provide the detailed algorithm in Appendix 5.3 due to lack of space (see Algorithm 3).
Analysis
We now present our analysis for both of our algorithms PG-RMC (Algorithm 1) and R-RMC (Algorithm 3). In general the problem of Robust PCA with Missing Entries (3) is harder than the standard Matrix Completion problem and hence is NP-hard [HMRW14]. Hence, we need to impose certain (by now standard) assumptions on , , and to ensure tractability of the problem:
Sparsity of , : We assume that at most fraction of the elements in each row and column of are non-zero for a small enough constant . Moreover, we assume that is independent of . Hence, also has at most fraction of the entries in expectation.
Assumptions 1, 2 are standard assumptions in the provable matrix completion literature [CR09, Rec11, JN15], while Assumptions 1, 3 are standard assumptions in the robust PCA (low-rank+sparse matrix recovery) literature [CSPW11, CLMW11, HKZ11]. Hence, our setting is a generalization of both the standard and popular problems and as we show later in the section, our result can be used to meaningfully improve the state-of-the-art for both these problems.
We first present our main result for Algorithm 1 under the assumptions given above.
Let Assumptions 1, 2 and 3 on , and hold respectively. Let , , and let the number of samples satisfy:
where is a global constant. Then, with probability at least , Algorithm 1 with , at most outer iterations and inner iterations, outputs a matrix such that:
Note that our number of samples increase with the desired accuracy . However, using argument similar to that of [JN15], we should be able to replace by which should modify the term to be where . We leave ironing out the details for future work.
Note that the number of samples matches information theoretic bound upto factor. Also, the number of allowed corruptions in also matches the known lower bounds (up to a constant factor) and cannot be improved upon information theoretically.
We now present our result for the rank based stagewise algorithm (Algorithm 3).
Under Assumptions 1, 2 and 3 on , and respectively and satisfying:
for a large enough constant , then Algorithm 3 with set to outputs a matrix such that: w.p. .
Notice that the sample complexity of Algorithm 3 has an additional multiplicative factor of when compared to that of Algorithm 1, but shaves off a factor of . Similarly, computational complexity of Algorithm 3 also trades off a factor for factor from the computational complexity of Algorithm 1.
Result for Matrix Completion: Note that for , the RMC problem with Assumptions 1,2 is exactly the same as the standard matrix completion problem and hence, we get the following result as a corollary of Theorem 1:
Suppose we observe and where Assumptions 1,2 hold for and . Also, let and . Then, w.p. , Algorithm 1 outputs s.t. .
Table 1 compares our sample and time complexity bounds for low-rank MC. Note that our sample complexity is nearly the same as that of nuclear-norm methods while the running time of our algorithm is significantly better than the existing results that have at most logarithmic dependence on the condition number of .
Result for Robust PCA: Consider the standard Robust PCA problem (RPCA), where the goal is to recover from . For RPCA as well, we can randomly sample entries from , where satisfies the assumption required by Theorem 1. This leads us to the following corollary:
Suppose we observe , where Assumptions 1, 3 hold for and . Generate by sampling each entry uniformly at random with probability , s.t., . Let . Then, w.p. , Algorithm 1 outputs s.t. .
Hence, using Theorem 1, we will still be able to recover but using only the sampled entries. Moreover, the running time of the algorithm is only , i.e., we are able to solve RPCA problem in time linear in . To the best of our knowledge, the existing state-of-the-art methods for RPCA require at least time to perform the same task [NUNS+14, GWL16]. Similarly, we don’t need to load the entire data matrix in memory, but we can just sample the matrix and work with the obtained sparse matrix with at most linear number of entries. Hence, our method significantly reduces both time and space complexity, and as demonstrated empirically in Section 4 can help scale our algorithm to very large data sets without losing accuracy.
We now provide an outline of our proof for Theorem 1 and motivate some of our proof techniques; the proof of Theorem 2 follows similarly. Recall that we assume that and define . Similarly, we define . Critically, (see Line 9 of Algorithm 1), i.e., is the set of iterates that we “could” obtain if entire was observed. Note that we cannot compute , it is introduced only to simplify our analysis.
We first re-write the projected gradient descent step for as described in (4):
That is, is obtained by rank- SVD of a perturbed version of : . As we perform entrywise thresholding to reduce , we need to bound . To this end, we use techniques from [JN15], [NUNS+14] that explicitly model singular vectors of and argue about the infinity norm error using a Taylor series expansion. However, in our case, such an error analysis requires analyzing the following key quantities ():
Note that in the case of standard RPCA which was analyzed in [NUNS+14], while in the case of standard MC which was considered in [JN15]. In contrast, in our case both and are non-zero. Moreover, is dependent on random variable . Hence, for , we will get cross terms between and that will also have dependent random variables which precludes application of standard Bernstein-style tail bounds. To this end, we use a technique similar to that of [EKYY13, JN15] to provide a careful combinatorial-style argument to bound the above given quantity. That is, we can provide the following key lemma:
Let , , and satisfy Assumptions 1, 2 and 3 respectively. Let be the singular value decomposition of . Furthermore, suppose that in the iteration of the stage, defined as satisfies , then we have:
w.p , where are defined in (6), are defined in (3.1).
Remark: We would like to note that even for the standard MC setting, i.e., when , we obtain better bound than that of [JN15] as we can bound directly rather than the weaker bound that [JN15] uses.
Now, using Lemmas 1 and 7 and by using a hard-thresholding argument we can bound (see Lemma 9) in the -th stage. Hence, after “inner” iterations, we can guarantee in the -th stage:
Moreover, by using sparsity of and the special structure of (See Lemma 7), we have: , where is a small constant.
Now, the outer iteration sets the next stage’s rank as: . Hence, using bound on and Weyl’s eigenvalue perturbation bound (Lemma 2), we have: and . Hence, after “outer” iterations, Algorithm 1 converges to an -approximate solution to .
Experiments
In this section we discuss the performance of Algorithm 1 on synthetic data and its use in foreground background separation. The goal of the section is two-fold: a) to demonstrate practicality and effectiveness of Algorithm 1 for the RMC problem, b) to show that Algorithm 1 indeed solves RPCA problem in significantly smaller time than that required by the existing state-of-the-art algorithm (St-NcRPCA [NUNS+14]). To this end, we use synthetic data as well as video datasets where the goal is to perform foreground-background separation [CLMW11].
We implemented our algorithm in MATLAB and the results for the synthetic data set were obtained by averaging over 20 runs. We obtained a matlab implementation of St-NcRPCA [NUNS+14] from the authors of [NUNS+14]. Note that if the sampling probability is , then our method is similar to St-NcRPCA; the key difference being how rank is selected in each stage. We also implemented the Alternating Minimzation based algorithm from [GWL16]. However, we found it to be an order of magnitude slower than Algorithm 1 on the foreground-background separation task. For example, on the escalator video, the algorithm did not converge in less than 150 seconds despite discounting for the expensive sorting operation in the truncation step. On the other hand, our algorithm finds the foreground in about 8 seconds.
Parameters. The algorithm has three main parameters: 1) threshold , 2) incoherence and 3) sampling probability (). In the experiments on synthetic data we observed that keeping speeds up the recovery while for background extraction keeping gives a better quality output. The value of for real world data sets was figured out using cross validation while for the synthetic data the same value was used as used in data generation. The sampling probability for the synthetic data could be kept as low as while for the real world data set we got good results for . Also, rather than splitting samples, we use entire set of observed entries to perform our updates (see Algorithm 1).
Figure 1 (a) plots recovery error () vs computational time for our PG-RMC method (with different sampling probabilities) as well as the St-NcRPCA algorithm. Note that even for very small values of sampling , we can achieve same recovery error using significantly small values. For example, our method with achieve error () in while St-NcRPCA method requires to achieve the same accuracy. Note that we do not compare against the convex relaxation based methods like IALM from [CLMW11], as [NUNS+14] shows that St-NcRPCA is significantly faster than IALM and several other convex relaxation solvers.
Figure 1 (b) plots time required to achieve different recovery errors () as the sampling probability increases. As expected, we observe a linear increase in the run-time with . Interestingly, for very small values of , we observe an increase in running time. In this regime, becomes very large (as doesn’t satisfy the sampling requirements). Hence, increase in the number of iterations () dominates the decrease in per iteration time complexity.
Figure 1 (c), (d) plots computation time required by our method (PG-RMC , Algorithm 1) versus rank and incoherence, respectively. As expected, as these two problem parameters increase, our method requires more time. Note that our run-time dependence on rank seems to be linear, while our existing results require time. This hints at the possibility of further improving the computational complexity analysis of our algorithm.
We also study phase transition for different values of sampling probability . Figure 3 (a) in Appendix 5.5 show a phase transition phenomenon where beyond the probability of recovery is almost while below it, it is almost .
Foreground-background separation. We also applied our technique to the problem of foreground-background separation. We use the usual method of stacking up the vectorized video frames to construct a matrix. The background, being static, will form the low rank component while the foreground can be considered to be the noise.
We applied our PG-RMC method (with varying ) to several videos. Figure 2 (a), (d) shows one frame each from two videos (a shopping center video, a restaurant video). Figure 2 (b), (d) shows the extracted background from the two videos by using our method (PG-RMC , Algorithm 1) with probability of sampling . Figure 2 (c), (f) compares objective function value for different values. Clearly, PG-RMC can recover the true background with as small as . We also observe an order of magnitude speedup (x) over St-NcRPCA [NUNS+14]. We present results on the video Escalator in Appendix 5.5.
Conclusion. In this work, we studied the Robust Matrix Completion problem. For this problem, we provide exact recovery of the low-rank matrix using nearly optimal number of observations as well as nearly optimal fraction of corruptions in the observed entries. Our RMC result is based on a simple and efficient PGD algorithm that has nearly linear time complexity as well. Our result improves state-of-the-art for the related Matrix Completion as well as Robust PCA problem. For Robust PCA, we provide first nearly linear time algorithm under standard assumptions.
Our sample complexity depends on , the desired accuracy in . Moreover, improving dependence of sample complexity on (from to ) also represents an important direction. Finally, similar to foreground background separation, we would like to explore more applications of RMC/RPCA.
References
Appendix
We divide this section into five parts. In the first part we prove some common lemmas. In the second part we give the convergence guarantee for PG-RMC . In the third part we give another algorithm which has a sample complexity of and prove its convergence guarantees. In the fourth part we prove a generalized form of lemma 1. In the fifth part we present some additional experiments.
For the sake of convenience in the following proofs, we will define some notations here.
We define and we consider the following equivalent update step for in the analysis:
The singular values of are denoted by where and we will let denote the singular values of where .
We will begin by restating some lemmas from previous work that we will use in our proofs.
First, we restate Weyl’s perturbation lemma from [Bha97], a key tool in our analysis:
This lemma establishes a bound on the spectral norm of a sparse matrix.
For any pair of unit vectors and , we have:
Lemma now follows by using . ∎
Now, we define a -mean random matrix with small higher moments values.
is a random matrix of size with each of its entries drawn independently satisfying the following moment conditions:
for and .
We now restate two useful lemmas from [JN15]:
Suppose satisfies Definition 1. Then, w.p. , we have:
Let be a matrix with . Suppose is obtained by sampling each element with probability . Then, the following matrix satisfies Defintion 1:
,
.
We now provide a lemma that bounds norm of an incoherent matrix with its operator norm.
Let . Then, . The lemma now follows by using definition of incoherence with the fact that . ∎
We now present a lemma that shows improvement in the error by using gradient descent on .
Let , , satisfy Assumptions 1,2,3 respectively. Also, let the following hold for the -th inner-iteration of any stage :
where and and are the and singular values of . Also, let and be the error terms defined also in (6). Then, the following holds w.p :
satisfies definition 1 with .
We now bound the spectral norm of as follows:
where follows from Lemma 3 and 4. follows by our assumptions on , , and . follows from our assumption on . ∎
In the following lemma, we prove that the value of the threshold computed using , where are defined in (6), closely tracks the threshold that we would have gotten had we had access to the true eigenvalues of , .
Let , , satisfy Assumptions 1,2,3 respectively. Also, let the following hold for the -th inner-iteration of any stage :
where and and are the and singular values of . Also, let and be the error terms defined also in (6). Then, the following holds w.p :
where and are defined in (6).
Using Weyl’s inequality (Lemma 2), we have: : and We now proceed to prove the lemma as follows:
where follows from Lemma 7 and the last inequality follows from the assumption that . ∎
Next, we show that the projected gradient descent update (6) leads to a better estimate of , i.e., we bound . Under the assumptions of the below given Lemma, the proof follows arguments similar to [NUNS+14] with additional challenge arises due to more involved error terms , .
Our proof proceeds by first symmetrizing our matrices by rectangular dilation. We first begin by noting some properties of symmetrized matrices used in the proof of the following lemma.
Let be a dimensional matrix with singular value decomposition . We denote its symmetrized version be . Then:
The eigenvalue decomposition of is given by where
We have
Let , where is any perturbation matrix that satisfies the following:
with
where is the singular value of . Also, let satisfy Assumption 1. Then, the following holds:
where and are the rank and incoherence of the matrix respectively.
Let . Let be the eigenvalues of with . Let be the corresponding eigenvectors of . Using Lemma 2 along with the assumption on , we have: .
Let be the eigen vector decomposition of . Let to be the eigen vector decomposition of . Then, using Remark 1 we have :
As and , we can apply the Taylor’s series expansion to get the following expression for :
Subtracting on both sides and taking operator norm, we get:
We separately bound the first and the second term of RHS. The first term can be bounded as follows:
where follows Remark 1, from Lemma 6 and follows from Claim 1 of Lemma 5.
We now bound second term of RHS of (10) which we again split in two parts. We first bound the terms with :
where follows from the second claim of Lemma 5 and noting that and follows from assumption on and using the fact that .
Summing up over all terms with , we get from 13 and 12:
Now, for terms corresponding to , we have:
where follows from assumption on in the lemma statement, follows from Claim 2 of Lemma 5.
It now remains to bound the terms, . Note from Remark 1.1 that . Now, we have the following cases for :
This leads to the following 4 cases for :
we get the bound on these terms in Lemma 15. Also, note from the Remark 1.2 that .
Now, summing up 15 over all and combining with 14 we get the required result. ∎
In the next lemma, we show that with the threshold chosen in the algorithm, we show an improvement in the estimation of by .
In the iterate of the stage, assume the following holds:
where and are the and singular values of , and are the and singular values of and, and are the rank and incoherence of the matrix respectively. Then we have
We first prove the first claim of the lemma. Consider an index pair .
where follows from the second assumption. Hence, we do not threshold any entry that is not corrupted by .
Now, we prove the second claim of the lemma. Consider an index entry . Here, we consider two cases:
The entry : Here the entry is thresholded. We know that from which we get
The entry : Here the entry is not thresholded. We know that from which we get
where follows from the second assumption along with the assumption about .
The above two cases prove the second statement of the lemma. ∎
The number of iteration in the inner loop of Algorithm 1 and Algorithm 3 satisfy:
w.p . Here is the highest singular value of , is it’s rank and is it’s incoherence.
where follows from Lemma 7. ∎
We will now prove Lemma 1 Proof of Lemma 1: Recall the definitions of , , and . Recall that From Lemma 4, we have that satisfies Definition 1. This implies that the matrix satisfies the conditions of Lemma 15. Now, we have and :
where follows from the application of Lemma 15 along with the incoherence assumption on . The other statements of the lemma can be proved in a similar manner by invocations of the different claims of Lemma 15.
2 Algorithm PG-RMC
Proof of Theorem 1: From Lemma 11 we know that . Consider the stage reached at the termination of the algorithm. We know from Lemma 12 that:
Combining this with Lemmas 2 and 7, we get:
When the while loop terminates, , which from 16, implies that . So we have:
We will now bound the number of iterations required for the PG-RMC to converge.
From claim 2 of Lemma 13, we have . By recursively applying this inequality, we get . We know that when the algorithm terminates, . Since, is an upper bound for , an upper bound for the number of iterations is . Also, note that an upper bound to this quantity is used to partition the samples provided to the algorithm. This happens with probability . This concludes the proof.
In the following lemma, we show that we make progress simultaneously in the estimation of both and by and . We make use of Lemmas 9 and 10 to show progress in the estimation of one affects the other alternatively. We also emphasize the roles of the following quantities in enabling us to prove our convergence result:
- We use Lemma 7 to bound this quanitity
The analysis of the following 4 quanitities is crucial to obtaining error bounds in norm
Let , , and satisfy Assumptions 1,2,3 respectively. Then, in the iteration of the stage of Algorithm 1, and satisfy:
with probability where is the number of iterations in the inner loop.
We prove the lemma by induction on both and .
Base Case: and We begin by first proving an upper bound on . We do this as follows:
where the last inequality follows from Cauchy-Schwartz and the incoherence of . This directly proves the third claim of the lemma for the base case. We also note that due to the thresholding step and the incoherence assumption on , we have:
where follows from Lemma 13. So the base case of induction is satisfied.
Induction over We first prove the inductive step over (for a fixed ). By inductive hypothesis we assume that:
.
with probability . Then by Lemma 9, we have:
where follows from our assumptions on and our inductive hypothesis on and follows from our assumption on and by noticing that . Recall that .
with probability . From Equations 19, 18 and 17, we have:
which by union bound holds with probability . Hence, using Lemma 10 and 8 we have:
.
which also holds with probability . This concludes the proof for induction over .
Induction Over Stages We now prove the induction over . Suppose the hypothesis holds for stage . At the end of stage , we have:
, and
.
with probability . From Lemmas 2 and 7 we get:
with probability . We know that which with 20 implies that .
where follows from Lemma 13. By union bound this holds with probability .
Now, from 8 and 10, we have through a similar series of arguments as above:
which holds with probability . ∎
Suppose at the beginning of the stage of algorithm 1:
with probability
Combining the three inequalities, we get:
Applying Lemma 7, we get the first claim of the lemma.
Again, combining the three inequalities, we get:
Another application of Lemma 7 gives the second claim. ∎
3 Algorithm R-RMC
Proof of Theorem 2: From Lemma 11 we know that .
Consider the stage reached at the termination of the algorithm. We know from Lemma 14 that:
Combining this with Lemmas 2 and 7, we get:
When the while loop terminates, , which from 22, implies that . So we have:
As in the case of the proof of Theorem 1, the following lemma shows that we simultaneously make progress in both the estimation of and by and respectively. Similar to Lemma 12, we make use of Lemmas 10 and 9 to show how improvement in estimation of one of the quantities affects the other and the other five terms, , , , and are analyzed the same way:
Let , , and satisfy Assumptions 1,2,3 respectively. Then, in the iteration of the stage of Algorithm 3, and satisfy:
with probability where is the number of iterations in the inner loop.
We prove the lemma by induction on both and .
Base Case: and We begin by first proving an upper bound on . We do this as follows:
where the last inequality follows from Cauchy-Schwartz and the incoherence of . This directly proves the third claim of the lemma for the base case. We also note that due to the thresholding step and the incoherence assumption on , we have:
So the base case of induction is satisfied.
Induction over We first prove the inductive step over (for a fixed ). By inductive hypothesis we assume that:
.
with probability .
where follows from our assumptions on and our inductive hypothesis on and follows from our assumption on and by noticing that . Recall that .
with probability . From Equations 25, 24 and 23, we have:
which by union bound holds with probability . Hence, using Lemma 10 and 8 we have:
.
which also holds with probability . This concludes the proof for induction over .
Induction Over Stages We now prove the induction over . Suppose the hypothesis holds for stage . At the end of stage , we have:
.
with probability .
with probability . We know that which with 26 implies that .
By union bound this holds with probability .
Now, from 8 and 10, we have through a similar series of arguments as above:
which holds with probability . ∎
4 Proof of a generalized form of Lemma 1
with probability .
Similar to [JN15], we will prove the statement for and it can be proved for by taking a union bound over all . For the sake of brevity, we will prove only the inequality:
The rest of the lemma follows by applying similar arguments to the appropriate quantities.
Let be a function used to index a single term in the expansion of . We express the term as follows:
We will now fix one such term and then bound the length of the following random vector:
Let be used to denote a tuple of integers used to index entries in a matrix. Let be used to denote the parity function computed on , i.e, if is divisible by and otherwise. This function indicates if the matrix in the expansion is transposed or not. We now introduce and which are defined as follows:
where if and 0 otherwise. We will subsequently write the random vector in terms of the individual entries of the matrices. The role of and is to ensure consistency in the terms used to describe . We will use to refer to .
With this notation in hand, we are ready to describe .
We now write the squared length of as follows:
We can see from the above equations that the entries used to represent are defined with respect to paths in a bipartite graph. In the following, we introduce notations to represent entire paths rather than just individual edges:
Let and
Calculating the moment expansion of for some number , we obtain:
We now show how to bound the above moment effectively. Notice that the moment is defined with respect to a collection of paths. We denote this collection by . For each such collection, we define a partition of the index set where and are in the same equivalence class if and . Additionally, each such that is in a separate equivalence class.
We bound the expression in (28) by partitioning all possible collections of paths based on the partitions defined by them in the above manner. We then proceed to bound the contribution of any one specific path to (28) following a particular partition , the number of paths satisfying that particular partition and finally, the total number of partitions. Since, is a matrix with mean, any equivalence class containing an index such that contains at least two elements.
We proceed to bound (28) by taking absolute values:
We now fix one particular partition and bound the contribution to (29) of all collections of paths that correspond to a valid partition .
We construct from a directed multigraph . The equivalence classes of form the vertex set of G, . There are 4 kinds of edges in where each type is indexed by a tuple where . We denote the edge sets corresponding to these 4 edge types by , , and respectively. An edge of type exists from equivalence class to equivalence class if there exists and such that , , and .
The summation in 29 can be written as follows:
where follows from the moment conditions on . and are the vertices in the graph corresponding to tuples such that and respectively and , .
We first consider an equivalence class such that there exists an index and . We form a spanning tree of all the nodes reachable from with as root. We then remove the nodes from the graph and repeat this procedure until we obtain a set of trees with roots such that . This happens because every node is reachable from some equivalence class which contains an index of the form . Also, each of these trees is disjoint in their vertex sets. Given this decomposition, we can factorize the above product as follows:
For a single connected component, we can compute the summation bottom up from the leaves. First, notice that:
Where the first two follow from the sparsity of . Every node in the tree with the exception of the root has a single incoming edge. For the root, , we have:
From the above two observations, we have:
where represents the number of vertices in the component which contain tuples such that for .
Now, we bound the probability that is too large. Choosing and applying the moment Markov inequality, we obtain:
Taking a union bound over all the possible , over values of from to and over the values of , we get the required result. ∎
5 Additional Experimental Results
We detail some additional experiments performed with Algorithm 1 in this section. The experiments were performed on synthetic data and real world data sets.
Foreground-background separation. We present results for one more real world data set in this section. We applied our PG-RMC method (with varying ) to the Escalator video. Figure 4 (a) shows one frame from the video. Figure 4 (b) shows the extracted background from the video by using our method (PG-RMC , Algorithm 1) with probability of sampling . Figure 4 (c) compares objective function value for different values.