Non-convex Robust PCA
Praneeth Netrapalli, U N Niranjan, Sujay Sanghavi, Animashree Anandkumar, Prateek Jain
Keywords:
Robust PCA, matrix decomposition, non-convex methods, alternating projections.
Introduction
Principal component analysis (PCA) is a common procedure for preprocessing and denoising, where a low rank approximation to the input matrix (such as the covariance matrix) is carried out. Although PCA is simple to implement via eigen-decomposition, it is sensitive to the presence of outliers, since it attempts to “force fit” the outliers to the low rank approximation. To overcome this, the notion of robust PCA is employed, where the goal is to remove sparse corruptions from an input matrix and obtain a low rank approximation. Robust PCA has been employed in a wide range of applications, including background modeling [LHGT04], 3d reconstruction [MZYM11], robust topic modeling [Shi13], and community detection [CSX12], and so on.
Concretely, robust PCA refers to the following problem: given an input matrix , the goal is to decompose it into sparse and low rank matrices. The seminal works of [CSPW11, CLMW11] showed that this problem can be provably solved via convex relaxation methods, under some natural conditions on the low rank and sparse components. While the theory is elegant, in practice, convex techniques are expensive to run on a large scale and have poor convergence rates. Concretely, for decomposing an matrix, say with , the best specialized implementations (typically first-order methods) have a per-iteration complexity of , and require number of iterations to achieve an error of . In contrast, the usual PCA, which carries out a rank- approximation of the input matrix, has complexity per iteration – drastically smaller when is much smaller than . Moreover, PCA requires exponentially fewer iterations for convergence: an accuracy is achieved with only iterations (assuming constant gap in singular values).
In this paper, we design a non-convex algorithm which is “best of both the worlds” and bridges the gap between (the usual) PCA and convex methods for robust PCA. Our method has low computational complexity similar to PCA (i.e. scaling costs and convergence rates), and at the same time, has provable global convergence guarantees, similar to the convex methods. Proving global convergence for non-convex methods is an exciting recent development in machine learning. Non-convex alternating minimization techniques have recently shown success in many settings such as matrix completion [Kes12, JNS13, Har13], phase retrieval [NJS13], dictionary learning [AAJ+13], tensor decompositions for unsupervised learning [AGH+12], and so on. Our current work on the analysis of non-convex methods for robust PCA is an important addition to this growing list.
We propose a simple intuitive algorithm for robust PCA with low per-iteration cost and a fast convergence rate. We prove tight guarantees for recovery of sparse and low rank components, which match those for the convex methods. In the process, we derive novel matrix perturbation bounds, when subject to sparse perturbations. Our experiments reveal significant gains in terms of speed-ups over the convex relaxation techniques, especially as we scale the size of the input matrices.
Our method consists of simple alternating (non-convex) projections onto low-rank and sparse matrices. For an matrix, our method has a running time of , where is the rank of the low rank component. Thus, our method has a linear convergence rate, i.e. it requires iterations to achieve an error of , where is the rank of the low rank component . When the rank is small, this nearly matches the complexity of PCA, (which is ).
We prove recovery of the sparse and low rank components under a set of requirements which are tight and match those for the convex techniques (up to constant factors). In particular, under the deterministic sparsity model, where each row and each column of the sparse matrix has at most fraction of non-zeros, we require that , where is the incoherence factor (see Section 3).
In addition to strong theoretical guarantees, in practice, our method enjoys significant advantages over the state-of-art solver for (1), viz., the inexact augmented Lagrange multiplier (IALM) method [CLMW11]. Our method outperforms IALM in all instances, as we vary the sparsity levels, incoherence, and rank, in terms of running time to achieve a fixed level of accuracy. In addition, on a real dataset involving the standard task of foreground-background separation [CLMW11], our method is significantly faster and provides visually better separation.
2 Related Work
Guaranteed methods for robust PCA have received a lot of attention in the past few years, starting from the seminal works of [CSPW11, CLMW11], where they showed recovery of an incoherent low rank matrix through the following convex relaxation method:
[CSPW11] and [CLMW11] consider two different models of sparsity for . Chandrasekaran et al. [CSPW11] consider a deterministic sparsity model, where each row and column of the matrix, , has at most fraction of non-zero entries. For guaranteed recovery, they require , where is the incoherence level of , and is its rank. Hsu et al. [HKZ11] improve upon this result to obtain guarantees for an optimal sparsity level of . This matches the requirements of our non-convex method for exact recovery. Note that when the rank , this allows for a constant fraction of corrupted entries. Candès et al. [CLMW11] consider a different model with random sparsity and additional incoherence constraints, viz., they require . Note that our assumption of incoherence, viz., , only yields . The additional assumption enables [CLMW11] to prove exact recovery with a constant fraction of corrupted entries, even when is nearly full-rank. We note that removing the condition for robust PCA would imply solving the planted clique problem when the clique size is less than [Che13]. Thus, our recovery guarantees are tight upto constants without these additional assumptions.
A number of works have considered modified models under the robust PCA framework, e.g. [ANW12, XCS12]. For instance, Agarwal et al. [ANW12] relax the incoherence assumption to a weaker “diffusivity” assumption, which bounds the magnitude of the entries in the low rank part, but incurs an additional approximation error. Xu et al.[XCS12] impose special sparsity structure where a column can either be non-zero or fully zero.
In terms of state-of-art specialized solvers, [CLMW11] implements the in-exact augmented Lagrangian multipliers (IALM) method and provides guidelines for parameter tuning. Other related methods such as multi-block alternating directions method of multipliers (ADMM) have also been considered for robust PCA, e.g. [WHML13]. Recently, a multi-step multi-block stochastic ADMM method was analyzed for this problem [SAJ14], and this requires iterations to achieve an error of . In addition, the convergence rate is tight in terms of scaling with respect to problem size and sparsity and rank parameters, under random noise models.
There is only one other work which considers a non-convex method for robust PCA [KC12]. However, their result holds only for significantly more restrictive settings and does not cover the deterministic sparsity assumption that we study. Moreover, the projection step in their method can have an arbitrarily large rank, so the running time is still , which is the same as the convex methods. In contrast, we have an improved running time of .
Algorithm
In this section, we present our algorithm for the robust PCA problem. The robust PCA problem can be formulated as the following optimization problem: find s.t. is the desired reconstruction error and
lies in the set of low-rank matrices,
A natural algorithm for the above problem is to iteratively project onto the set of sparse matrices to update , and then to project onto the set of low-rank matrices to update . Alternatively, one can view the problem as that of finding a matrix in the intersection of the following two sets: a) set of rank- matrices, b) \mathcal{S}_{M}=\{M-S,\ where is a sparse matrix. Note that these projections can be done efficiently, even though the sets are non-convex. Hard thresholding (HT) is employed for projections on to sparse matrices, and singular value decomposition (SVD) is used for projections on to low rank matrices. Rank- case: We first describe our algorithm for the special case when is rank 1. Our algorithm performs an initial hard thresholding to remove very large entries from input . Note that if we performed the projection on to rank- matrices without the initial hard thresholding, we would not make any progress since it is subject to large perturbations. We alternate between computing the rank- projection of , and performing hard thresholding on to remove entries exceeding a certain threshold. This threshold is gradually decreased as the iterations proceed, and the algorithm is run for a certain number of iterations (which depends on the desired reconstruction error). General rank case: When has rank , a naive extension of our algorithm consists of alternating projections on to rank- matrices and sparse matrices. However, such a method has poor performance on ill-conditioned matrices. This is because after the initial thresholding of the input matrix , the sparse corruptions in the residual are of the order of the top singular value (with the choice of threshold as specified in the algorithm). When the lower singular values are much smaller, the corresponding singular vectors are subject to relatively large perturbations and thus, we cannot make progress in improving the reconstruction error. To alleviate the dependence on the condition number, we propose an algorithm that proceeds in stages. In the stage, the algorithm alternates between rank- projections and hard thresholding for a certain number of iterations. We run the algorithm for stages, where is the rank of . Intuitively, through this procedure, we recover the lower singular values only after the input matrix is sufficiently denoised, i.e. sparse corruptions at the desired level have been removed. Figure 1 shows a pictorial representation of the alternating projections in different stages.
Parameters: As can be seen, the only real parameter to the algorithm is , used in thresholding, which represents “spikiness” of . That is if the user expects to be “spiky” and the sparse part to be heavily diffused, then higher value of can be provided. In our implementation, we found that selecting aggressively helped speed up recovery of our algorithm. In particular, we selected .
Complexity: The complexity of each iteration within a single stage is , since it involves calculating the rank- approximationNote that we only require a rank- approximation of the matrix rather than the actual singular vectors. Thus, the computational complexity has no dependence on the gap between the singular values. of an matrix (done e.g. via vanilla PCA). The number of iterations in each stage is and there are at most stages. Thus the overall complexity of the entire algorithm is then . This is drastically lower than the best known bound of on the number of iterations required by convex methods, and just a factor away from the complexity of vanilla PCA.
Analysis
In this section, we present our main result on the correctness of AltProj. We assume the following conditions:
is -incoherent, i.e., if is the SVD of , then and , , where and denote the rows of and respectively.
Each row and column of have at most fraction of non-zero entries such that .
Note that in general, it is not possible to have a unique recovery of low-rank and sparse components. For example, if the input matrix is both sparse and low rank, then there is no unique decomposition (e.g. ). The above conditions ensure uniqueness of the matrix decomposition problem.
Additionally, we set the parameter in Algorithm 1 be set as .
We now establish that our proposed algorithm recovers the low rank and sparse components under the above conditions.
Under conditions , and , and choice of as above, the outputs and of Algorithm 1 satisfy:
Remark (tight recovery conditions): Our result is tight up to constants, in terms of allowable sparsity level under the deterministic sparsity model. In other words, if we exceed the sparsity limit imposed in S1, it is possible to construct instances where there is no unique decompositionFor instance, consider the matrix which has copies of the all ones matrix, each of size , placed across the diagonal. We see that this matrix has rank and is incoherent with parameter . Note that a fraction of sparse perturbations suffice to erase one of these blocks making it impossible to recover the matrix.. Our conditions L1, L2 and S1 also match the conditions required by the convex method for recovery, as established in [HKZ11]. Remark (convergence rate): Our method has a linear rate of convergence, i.e. to achieve an error of , and hence we provide a strongly polynomial method for robust PCA. In contrast, the best known bound for convex methods for robust PCA is iterations to converge to an -approximate solution.
Under conditions , and , and choice of as in Theorem 1, when the noise ,the outputs of Algorithm 1 satisfy:
We now present the key steps in the proof of Theorem 1. A detailed proof is provided in the appendix.
Step I: Reduce to the symmetric case, while maintaining incoherence of and sparsity of . Using standard symmetrization arguments, we can reduce the problem to the symmetric case, where all the matrices involved are symmetric. See appendix for details on this step.
Step II: Show decay in after projection onto the set of rank- matrices. The -th iterate of the -th stage is given by . Hence, is obtained by using the top principal components of a perturbation of given by . The key step in our analysis is to show that when an incoherent and low-rank is perturbed by a sparse matrix , then is small and is much smaller than . The following lemma formalizes the intuition; see the appendix for a detailed proof.
Let be symmetric and satisfy the assumptions of Theorem 1 and let and be the iterates of the stage of Algorithm 1. Let be the eigenvalues of , s.t., . Then, the following holds:
Moreover, the outputs and of Algorithm 1 satisfy:
Step III: Show decay in after projection onto the set of sparse matrices. We next show that if is much smaller than then the iterate also has a much smaller error (w.r.t. ) than . The above given lemma formally provides the error bound.
Experiments
We now present an empirical study of our AltProj method. The goal of this study is two-fold: a) establish that our method indeed recovers the low-rank and sparse part exactly, without significant parameter tuning, b) demonstrate that AltProj is significantly faster than Conv-RPCA (see (1)); we solve Conv-RPCA using the IALM method [CLMW11], a state-of-the-art solver [LCM10]. We implemented our method in Matlab and used a Matlab implementation of the IALM method by [LCM10].
We consider both synthetic experiments and experiments on real data involving the problem of foreground-background separation in a video. Each of our results for synthetic datasets is averaged over runs.
Parameter Setting: Our pseudo-code (Algorithm 1) prescribes the threshold in Step 4, which depends on the knowledge of the singular values of the low rank component . Instead, in the experiments, we set the threshold at the -th step of -th stage as . For synthetic experiments, we employ the used for data generation, and for real-world datasets, we tune through cross-validation. We found that the above thresholding provides exact recovery while speeding up the computation significantly. We would also like to note that [CLMW11] sets the regularization parameter in Conv-RPCA (1) as (assuming ). However, we found that for problems with large incoherence such a parameter setting does not provide exact recovery. Instead, we set in our experiments.
There are three key problem parameters for RPCA with a fixed matrix size: a) sparsity of , b) incoherence of , c) rank of . We investigate performance of both AltProj and IALM by varying each of the three parameters while fixing the others. In our plots (see Figure 2), we report computational time required by each of the two methods for decomposing into up to a relative error () of . Figure 2 shows that AltProj scales significantly better than IALM for increasingly dense . We attribute this observation to the fact that as increases, the problem is “harder” and the intermediate iterates of IALM have ranks significantly larger than . Our intuition is confirmed by Figure 2 (b), which shows that when density () of is then the intermediate iterates of IALM can be of rank over while the rank of is only . We observe a similar trend for the other parameters, i.e., AltProj scales significantly better than IALM with increasing incoherence parameter (Figure 2 (c)) and increasing rank (Figure 2 (d)). See Appendix C for additional plots.
Real-world datasets: Next, we apply our method to the problem of foreground-background (F-B) separation in a video [LHGT04]. The observed matrix is formed by vectorizing each frame and stacking them column-wise. Intuitively, the background in a video is the static part and hence forms a low-rank component while the foreground is a dynamic but sparse perturbation.
Here, we used two benchmark datasets named Escalator and Restaurant dataset. The Escalator dataset has frames at a resolution of . We first applied the standard PCA method for extracting low-rank part. Figure 3 (b) shows the extracted background from the video. There are several artifacts (shadows of people near the escalator) that are not desirable. In contrast, both IALM and AltProj obtain significantly better F-B separation (see Figure 3(c), (d)). Interestingly, AltProj removes the steps of the escalator which are moving and arguably are part of the dynamic foreground, while IALM keeps the steps in the background part. Also, our method is significantly faster, i.e., our method, which takes is about times faster than IALM, which takes .
Restaurant dataset: Figure 4 shows the comparison of AltProj and IALM on a subset of the “Restaurant” dataset where we consider the last frames at a resolution of . AltProj was around times faster than IALM. Moreover, visually, the background extraction seems to be of better quality (for example, notice the blur near top corner counter in the IALM solution). Plot(b) shows the PCA solution and that also suffers from a similar blur at the top corner of the image, while the background frame extracted by AltProj does not have any noticeable artifacts.
Conclusion
In this work, we proposed a non-convex method for robust PCA, which consists of alternating projections on to low rank and sparse matrices. We established global convergence of our method under conditions which match those for convex methods. At the same time, our method has much faster running times, and has superior experimental performance. This work opens up a number of interesting questions for future investigation. While we match the convex methods, under the deterministic sparsity model, studying the random sparsity model is of interest. Our noisy recovery results assume deterministic noise; improving the results under random noise needs to be investigated. There are many decomposition problems beyond the robust PCA setting, e.g. structured sparsity models, robust tensor PCA problem, and so on. It is interesting to see if we can establish global convergence for non-convex methods in these settings.
Acknowledgements
AA and UN would like to acknowledge NSF grant CCF-1219234, ONR N00014-14-1-0665, and Microsoft faculty fellowship. SS would like to acknowledge NSF grants 1302435, 0954059, 1017525 and DTRA grant HDTRA1-13-1-0024. PJ would like to acknowledge Nikhil Srivastava and Deeparnab Chakrabarty for several insightful discussions during the course of the project.
References
Appendix A Proof of Theorem 1
We will start with some preliminary lemmas. The first lemma is the well known Weyl’s inequality in the matrix setting[Bha97].
Suppose be an matrix. Let and be the eigenvalues of and respectively such that and . Then we have:
The following lemma is the Davis-Kahan theorem[Bha97], specialized for rank- matrices.
Suppose . Let be a rank- matrix with unit spectral norm. Suppose further that . Then, we have:
where and are the top eigenvalue eigenvector pair of .
As outlined in Section 3.1 (and formalized in the proof of Theorem 1), it is sufficient to prove the correctness of Algorithm 1 for the case of symmetric matrices. So, most of the lemmas we prove in this section assume that the matrices are symmetric.
Let be unit vectors such that . Then, using , we have:
where the last inequality follows from the fact that has at most non-zeros per row and per column. ∎
We prove the lemma using mathematical induction.
Base Case (): This is just a restatement of the incoherence of .
In what follows, we prove a number of lemmas concerning the structure of and . The following lemma shows that the threshold in (2) is close to that with replaced by .
Let be symmetric and satisfy the assumptions of Theorem 1 and let be the iterate of the stage of Algorithm 1. Let be the eigenvalues of , such that and be the eigenvalues of such that . Recall that . Suppose further that
, and
.
Note that . Now, using Lemmas 2 and 4, we have:
where . That is, . Similarly, . So we have:
where the last inequality follows from the bound . ∎
Assume the notation of Lemma 6. Also, let be the iterates of stage of Algorithm 1 and be the iterates of the same stage. Also, recall that and . Suppose further that
, and
.
Let be the eigenvalue decomposition of . Also, recall that . Then, for every eigenvector of , we have
Note that we used Lemmas 2 and 4 to guarantee the existence of . Hence,
We now bound the two terms on the right hand side above.
where we denote to be the SVD of . Let be the eigenvalue decomposition of . Note that . Recall that, . Also note that,
Now, we will bound the term of :
where follows from Lemma 5 and the incoherence of . Now, similar to (8), we have:
Using the above bound, and the assumption on :
where we used Lemma 4 and the assumption on . ∎
We used the following technical lemma in the proof of Lemma 7.
Assume the notation of Lemma 7. Suppose further that
, and
.
The result follows by using the bound on . ∎
The following lemma bounds the support of and , using an assumption on .
.
, and
We first prove the first conclusion. Recall that,
where is as defined in Algorithm 1 and are the eigenvalues of such that .
We now prove the second conclusion. We consider the following two cases:
: Here, . Hence, .
: In this case, and . So we have, . The last inequality above follows from Lemma 6.
We are now ready to prove Lemma 1. In fact, we prove the following stronger version.
Recall that in the stage, the update is given by: and is given by: . Also, recall that and .
We prove the lemma by induction on both and . For the base case ( and ), we first note that the first inequality on is trivially satisfied. Due to the thresholding step (step in Algorithm 1) and the incoherence assumption on , we have:
So the base case of induction is satisfied.
We first do the inductive step over (for a fixed ). By inductive hypothesis we assume that: a) , b) . Then by Lemma 7, we have:
, and
.
This finishes the induction over . Note that we show a stronger bound than necessary on .
We now do the induction over . Suppose the hypothesis holds for stage . Let denote the number of iterations in each stage. We first obtain a lower bound on . Since
we see that . So, at the end of stage , we have:
, and
.
Lemmas 4 and 2 tell us that . We will now consider two cases:
Algorithm 1 terminates: This means that which then implies that . So we have:
This proves the statement about . A similar argument proves the claim on . The claim on follows since .
Algorithm 1 continues to stage : This means that which then implies that . So we have:
Similarly for .
Using Lemma 1, it suffices to show that the general case can be reduced to the case of symmetric matrices. We will now outline this reduction.
Recall that we are given an matrix where is the true low-rank matrix and the sparse error matrix. Wlog, let and suppose , for some . We then consider the symmetric matrices
and . A simple calculation shows that is incoherent with parameter and satisfies the sparsity condition (S1) with parameter . Moreover the iterates of AltProj with input have similar expressions as in (41) in terms of the corresponding iterates with input . This means that it suffices to obtain the same guarantees for Algorithm 1 for the symmetric case. Lemma 1 does precisely this, proving the theorem. ∎
Appendix B Proof of Theorem 2
In this section, we prove Theorem 2. The roadmap of the proofs in this section is essentially the same as that in Appendix A.
In what follows, we prove a number of lemmas concerning the structure of and . The first lemma is a generalization of Lemma 6 and shows that the threshold in (2) is close to that with replaced by .
Let be symmetric and satisfy the assumptions of Theorem 2 and let be the iterate of the stage of Algorithm 1. Let be the eigenvalues of , such that and be the eigenvalues of such that . Recall that . Suppose further that
, and
.
Note that . Now, using Lemmas 2 and 4, we have:
where . That is, . Similarly, . So we have:
where the last inequality follows from the bound and the assumption on . ∎
Assume the notation of Lemma 6. Also, let be the iterates of stage of Algorithm 1 and be the iterates of the same stage. Also, recall that and . Suppose further that
, and
.
Let be the eigenvalue decomposition of . Also, recall that . Then, for every eigenvector of , we have
Note that we used Lemmas 2 and 4 to guarantee the existence of . Hence,
We now bound the two terms on the right hand side above.
For the first term, we again use triangle inequality to obtain
where we denote to be the SVD of . Let be the eigenvalue decomposition of . Note that . Recall that, . Also note that,
Coming to the second term of (44), we have:
Using an expansion along the lines of (46), we see that
A similar argument as in (49) gives us the following bound on the last term in (44):
Next, we analyze . This can again be bounded by four quantities:
where follows from Lemma 5 and the incoherence of . Now, similar to (46), we have:
where follows from Lemma 12 and the bound on .
Coming to the second term of (54), we have
where follows from Lemma 5 and incoherence of . Proceeding along the lines of (56), we obtain:
Plugging the above inequality along with (57) and (59) into (54) gives us:
Using the above bound, and the assumption on :
where follows from Lemma 4, and follows from the assumption on . ∎
We used the following technical lemma in the proof of Lemma 11.
Assume the notation of Lemma 11. Suppose further that
, and
.
Using the bound on and recalling the assumption that
The following lemma bounds the support of and , using an assumption on .
.
, and
We first prove the first conclusion. Recall that,
where is as defined in Algorithm 1 and are the eigenvalues of such that .
We now prove the second conclusion. We consider the following two cases:
: Here, . Hence, .
: In this case, and . So we have, . The last inequality above follows from Lemma 6.
The following lemma is a generalization of Lemma 1.
Let be symmetric and satisfy the assumptions of Theorem 2 and let and be the iterates of the stage of Algorithm 1. Let be the eigenvalues of , s.t., . Then, the following holds:
Moreover, the outputs and of Algorithm 1 satisfy:
Recall that in the stage, the update is given by: and is given by: . Also, recall that and .
We prove the lemma by induction on both and . For the base case ( and ), we first note that the first inequality on is trivially satisfied. Due to the thresholding step (step in Algorithm 1) and the incoherence assumption on , we have:
So the base case of induction is satisfied.
We first do the inductive step over (for a fixed ). By inductive hypothesis we assume that: a) , b) . Then by Lemma 11, we have:
, and
.
This finishes the induction over . Note that we show a stronger bound than necessary on .
We now do the induction over . Suppose the hypothesis holds for stage . Let denote the number of iterations in each stage. We first obtain a lower bound on . Since
we see that . So, at the end of stage , we have:
, and
.
Lemmas 4 and 2 tell us that . We will now consider two cases:
Algorithm 1 terminates: This means that which then implies that . So we have:
This proves the statement about . A similar argument proves the claim on . The claim on follows since .
Algorithm 1 continues to stage : This means that which then implies that . So we have:
Similarly for .
Using Lemma 14, it suffices to show that the general case can be reduced to the case of symmetric matrices. We will now outline this reduction.
Recall that we are given an matrix where is the true low-rank matrix, dense corruption matrix and the sparse error matrix. Wlog, let and suppose , for some . We then consider the symmetric matrices
and . A simple calculation shows that is incoherent with parameter , satisfies the assumption of Theorem 2 and satisfies the sparsity condition (S1) with parameter . Moreover the iterates of AltProj with input have similar expressions as in (102) in terms of the corresponding iterates with input . This means that it suffices to obtain the same guarantees for Algorithm 1 for the symmetric case. Lemma 14 does precisely this, proving the theorem. ∎
Appendix C Additional experimental results
Extending Figure 2, the plots in Figure 5 illustrate the point that soft thresholding, i.e., the convex relaxation approach, leads to intermediate solutions with high ranks. Figures 5 (a)-(b) show the variation of the maximum rank of the intermediate low-rank solutions of IALM with rank and incoherence respectively; the results are averaged over 5 runs of the algorithm; we note that as the problem becomes harder, the maximum intermediate rank via soft thresholding (convex approach) increases, and this leads to higher running times. As an example of this phenomenon, Figure 5 (c) shows the rank of the intermediate iterates of IALM for a particular run with ; here, while the rank of the final output is , intermediate iterates have a rank as high as . We run our synthetic simulations on a machine with Intel Dual 8-core Xeon (E5-2650) 2.0GHz CPU with 192GB RAM.
Real-world datasets:
We provide some additional results concerning foreground-background separation in videos The datasets are available at http://perception.i2r.a-star.edu.sg/bk_model/bk_index.html. We compare NcRPCA with IALM, and also with the low-rank solution obtained using vanilla PCA; we report the solutions obtained by NcRPCA and IALM methods for decomposing into up to a relative error () of . We report the rank and the sparsity of the solutions obtained by the two methods along with the computational time. As mentioned before, the observed matrix is formed by vectorizing each frame and stacking them column-wise. For illustration purposes, we arbitrarily select one of the original frames in the sequence of image frames obtained from the video, i.e., one of the columns of , and the corresponding columns in and obtained using NcRPCA and IALM. We run our real data experiments on a machine with Intel Dual 8-core Xeon (E5-2650) 2.0GHz CPU with 192GB RAM.
Shopping Mall dataset: Figure 6 shows the comparison of NcRPCA and IALM on the “Shopping Mall” dataset which has frames at a resolution of . NcRPCA achieves a solution of better visual quality (for example, unlike NcRPCA, notice the artifact of the low-rank solution from IALM in the top right corner of the image where the person is walking over the reflection of a light source; also notice the shadows of people in the low-rank part obtained by IALM which are not present in the low-rank solution obtained by NcRPCA), in , compared to IALM, which takes until convergence. NcRPCA obtains a rank solution for with whereas IALM obtains a rank solution for with .
Curtain dataset: We illustrate our recovery on one of the frames (frame ) wherein a person enters a room with a curtain on the background. Figure 7 shows the comparison of NcRPCA and IALM on the “Curtain” dataset which has frames at a resolution of . NcRPCA achieves a solution, in , which is of similar visual quality to that of IALM, which takes until convergence. NcRPCA obtains a rank solution for with whereas IALM obtains a rank solution for with .