# Patent

## Title
Finding a CUR decomposition

## Abstract

One embodiments is a computer-implemented method for finding a CUR decomposition. The method includes constructing, by a computer processor, a matrix C based on a matrix A. A matrix R is constructed based on the matrix A and the matrix C. A matrix U is constructed based on the matrices A, C, and R. The matrices C, U, and R provide a CUR decomposition of the matrix A. The construction of the matrices C, U, and R provide at least one of an input-sparsity-time CUR and a deterministic CUR.

## Background
BACKGROUND
Various embodiments of this disclosure relate to CUR decompositions and, more particularly, to improved techniques for finding a CUR decomposition.
CUR decompositions are often applied to the field of data compression. If data is in the form of an m×n matrix A, then storage space of O(mn) is required to store this data. CUR decompositions compress the data by removing some redundancy and reducing the rank of A, hence requiring reduced storage.
Given as inputs a matrix Aεm×n and integers c<n and r<m, the CUR decomposition, or factorization, of A finds Cεm×c with c columns of A, Rεr×n with r rows of A, and Uεc×r, such that A=CUR+E. The value of E=A−CUR represents the residual error matrix.
Generally, where matrix A represents some data set, the CUR decomposition of A (i.e., C*U*R) approximates A. For example, a CUR decomposition can be used to compress the data in A by removing some of the redundancy in A. From an algorithmic perspective, it is a challenge to construct C, U, and R quickly and in such a way as to minimize the approximation error ∥A−CUR∥F2.
More precisely, the “CUR Problem,” as is will be referred to herein, is as follows: Given Aεm×n of rank ρ=rank(A), rank parameter k<ρ, and accuracy parameter 0<ε<1, construct Cεm×c with c columns from A, Rεr×n with r rows from A, and Uεc×r, with c, r, and rank (U) being as small as possible, in order to reconstruct A within relative-error:

∥A−CUR∥F2≦(1+ε)∥A−Ak∥F2.

In contrast to the above is the singular value decomposition (SVD) factorization, where k<rank (A), and A=UkΣkVkT+Aρ−k. The SVD residual error Aρ−k is the best possible, under certain rank constraints. The matrices Ukεm×k and Vkεn×k contain the top k left and right singular vectors of A, while Σkεk×k contains the top k largest singular values of A. In CUR, C and R contain actual columns and rows of A, a property desirable for feature selection and data interpretation when using CUR as an approximation of A. Because C and R are actual columns and rows of A, sparsity in the input matrix A is also preserved in CUR. Thus, CUR is attractive in a wide range of applications.
SUMMARY
In one embodiment of this disclosure, a computer-implemented method includes constructing, by a computer processor, a matrix C based on a matrix A. A matrix R is constructed based on the matrix A and the matrix C. A matrix U is constructed based on the matrices A, C, and R. The matrices C, U, and R provide a CUR decomposition of the matrix A. The construction of the matrices C, U, and R provide at least one of an input-sparsity-time CUR and a deterministic CUR.
In another embodiment, a system includes a first construction unit, a second construction unit, and a third construction unit. The first construction unit is configured to construct, by a computer processor, a matrix C based on a matrix A. The second construction unit is configured to construct a matrix R based on the matrix A and the matrix C. The third construction unit is configured to construct a matrix U based on the matrices A, C, and R. The matrices C, U, and R provide a CUR decomposition of the matrix A. The construction of the matrices C, U, and R provide at least one of an input -sparsity-time CUR and a deterministic CUR.
In yet another embodiment, a computer program product for finding a CUR decomposition includes a computer readable storage medium having program instructions embodied therewith. The program instructions are executable by a processor to cause the processor to perform a method. The method includes constructing a matrix C based on a matrix A. Further according to the method, a matrix R is constructed based on the matrix A and the matrix C. A matrix U is constructed based on the matrices A, C, and R. The matrices C, U, and R provide a CUR decomposition of the matrix A. The construction of the matrices C, U, and R provide at least one of an input-sparsity-time CUR and a deterministic CUR.
Additional features and advantages are realized through the techniques of the present invention. Other embodiments and aspects of the invention are described in detail herein and are considered a part of the claimed invention. For a better understanding of the invention with the advantages and the features, refer to the description and to the drawings.



BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS
The subject matter which is regarded as the invention is particularly pointed out and distinctly claimed in the claims at the conclusion of the specification. The forgoing and other features, and advantages of the invention are apparent from the following detailed description taken in conjunction with the accompanying drawings in which:
FIG. 1 is a block diagram of a decomposition system, according to some embodiments of this disclosure;
FIG. 2 is a flow diagram of a method for finding a CUR decomposition of a matrix A, according to some embodiments of this disclosure;
FIG. 3 is a flow diagram of a method for finding a CUR decomposition of a matrix A in input-sparsity time, according to some embodiments of this disclosure;
FIG. 4 is a flow diagram of a third method for finding a deterministic CUR decomposition of a matrix A, according to some embodiments of this disclosure; and
FIG. 5 is a block diagram of a computing device for implementing some or all aspects of the decomposition system, according to some embodiments of this disclosure.



DETAILED DESCRIPTION
Various embodiments of decomposition systems and methods herein provide improved techniques for finding CUR decompositions. When used for compression, embodiments of the decomposition system may compress the data by removing redundancy and retaining only necessary information, hence requiring reduced less storage. Some embodiments may retain actual data from the input matrix A, which can offer an advantage over existing approaches in terms of interpretability. Further, as compared to CUR techniques used previously, some embodiments may perform faster and may provide a shorter output description than alternatives.
Despite the significant amount of work and progress on CUR, at least the following questions have remained unanswered, given an accuracy parameter 0<ε<1: (1) Optimal CUR: Are there any (1+ε)-error CUR algorithms selecting the optimal number of columns and rows? (2) Rank-k CUR: Are there any (1+ε)-error CUR algorithms constructing A with optimal rank? (3) Input-sparsity-time CUR: Are there any input-sparsity-time (1+ε)-error algorithms for CUR? (4) Deterministic CUR: Are there any deterministic, polynomial-time (1+ε)-error CUR algorithms? The present decomposition systems and methods may address these open problems related to CUR decompositions.
The decomposition system may be based on technical contributions to the art provided in this disclosure, answering the open problems related to optimal CUR, rank-k CUR, input-sparsity-time CUR, and deterministic CUR.
One such technical contribution is an input-sparsity-time, relative-error CUR algorithm selecting an optimal number of columns and rows and constructing a U matrix with optimal rank.
It can be shown that, given Aεm×n of rank ρ, a target rank 1≦k<ρ, and 0<ε<1, there exists such a randomized algorithm to select at most c=O(k/ε) columns and at most r=O(k/ε) rows from A, to form matrices Cεm×c, Rεr×n, and Uεc×r with rank(U)=k such that, with constant probability of success,

∥A−CUR∥F2≦(1+O(ε))∥A−Ak∥F2.

Further, the matrices C, U, and R can be computed in time

O(nnz(A)log n+(m+n)·poly(log n, k, 1/ε)).

Using such an algorithm the present decomposition system may be capable of achieving a relative-error CUR decomposition with O(k/ε) number of rows and columns, which is a task that was not achieved through conventional techniques. This number of rows and columns is asymptotically optimal.
A second technical contribution on which the present decomposition system may be based is a deterministic, relative-error CUR algorithm that runs in time O(mn3k/ε) (i.e., polynomial time). With this algorithm, the decomposition system may construct C with c=O(k/ε) columns, R with r=O(k/ε) rows, and U of rank k. Existing work provides a relative-error, deterministic algorithm based on volume sampling, constructing C with O(k/ε) columns of A such that ∥A−CC†A∥F2≦(1+ε)∥A−Ak∥F2. However, it is not obvious how to extend this to a rank k, column-based, relative-error decomposition, which is a harder instance of the problem. The best existing deterministic algorithm for a rank k, column-based, decomposition achieves only a (2+ε)-error.
FIG. 1 is a block diagram of a decomposition system 100, according to some embodiments of this disclosure. As shown, the decomposition system 100 may include a C-construction unit 110, an R-construction unit 120, and a U-construction unit. In general, the C-construction unit 110 may construct matrix C of a CUR decomposition of matrix A; the R-construction 120 unit may construct matrix R of the CUR decomposition; and the U-construction unit 130 may construct matrix U of the CUR decomposition based on C and R. Each of these units 110, 120, 130 may be implemented in hardware, software, or a combination thereof. The construction of each of these matrices will be described further below.
Following is an overview of various techniques used by embodiments of the decomposition system 100. A useful starting point of the present decomposition system 100 is the following tool from prior work, which connects matrix factorizations and column subset selection.
The lemma immediately below has been shown in Boutsidis (C. Boutsidis, P. Drineas, and M. Magdon-Ismail; Near optimal column based matrix reconstruction; SIAM Journal on Computing (SICOMP), 2013):
The following is referred to herein as Lemma 1: Let A=AZZT+Eεm×n be a low-rank matrix factorization of A, with Zεn×k and ZTZ=Ik. Let Sεn×c (c≧k) be any matrix such that rank(ZTS)=rank(Z)=k. Let C=ASεm×c. Then ∥A−CC†A∥F2≦∥A−ΠC,kF(A)∥F2≦∥E∥F2+∥ES(ZTS)†∥F2. Here, ΠC,kF(A)=CXoptεm×n where Xoptεc×n has rank at most k and CXopt is the best rank-k approximation to A in the column span of C.
If S samples columns from A (i.e., C=AS) consist of original columns of A, then, using the above lemma, one obtains a bound for a column-based, low-rank matrix approximation of A. This bound depends on the specific choice of Z.
Some embodiments of the decompositions system obtain an optimal, relative -error, rank-k CUR by using this lemma twice and adaptively, one time to sample columns from A and the other time to sample rows. This technique is “adaptive” in that the two sampling processes are not independent. Rather, the rows sampled in the second application of the lemma depend on the columns sampled in the first application. An overview of this approach follows.
Assume that for an appropriate matrix Z1εn×k, one can find S1εn×cs that samples c1=O(k) columns from A such that after applying Lemma 1 with A and Z1 gives (C1=AS1; E1=A−AZ1Z1T):

∥A−C1C1†A∥F2≦∥E1∥F2+∥E1S1(Z1TS1)†∥F2≦O(1)∥A−AZ1Z1T∥F2≦O(1)∥A−Ak∥F2.

where in the third inequality, it is further assumed that

∥E1∥F2=∥A−AZ1Z1T∥F2≦O(1)∥A−Ak ∥F2.

In other words, Z1 may approximate, within a constant factor, the best rank-k SVD of A. One choice for Z1 is the matrix Vk from the rank-k SVD of A. However, since this choice is costly, some embodiments herein use methods that approximate the SVD. The bound in the second inequality also requires that the term ∥E1S1(Z1TS1)†∥F2 is sufficiently small, specifically ∥E1S1(Z1TS1)†∥F2≦O(1)∥E1∥F2. This can be achieved by choosing the sampling matrix S1 carefully, which is further discussed below.
Once the matrix C1 with O(k) columns of A is obtained, which approximates the best rank-k matrix within a constant factor, an adaptive sampling method, e.g., the adaptive sampling method of Deshpande (A. Deshpande, L. Rademacher, S. Vempala, and G. Wang; Matrix approximation and projective clustering via volume sampling; in Proceedings of the 17th Annual ACM-SIAM Symposium on Discrete Algorithms, pages 1117-1126, 2006), to sample O(k/ε) columns to obtain a matrix C with c=O(k)+O(k/ε) columns for which

∥A−CC†A∥F2≦∥A−CXopt∥F2≦(1+ε)∥A−Ak∥F2.

Herein, the above formula is referred to as Equation 1.

The adaptive sampling may convert a constant factor approximation to a relative-error one, by sampling an additional of O(k/ε) columns. Matrix Xoptεc×n has rank at most r. Matrix CXopt is the best rank-k approximation of A in the column span of C, which would be the matrix with columns of A in the CUR decomposition that is sought.
Lemma 1 may be used again to sample rows from A, i.e., by applying the lemma to AT. If matrix C had orthonormal columns, then it could immediately play the role of Z in Lemma 1. In that case, E=AT−ATCCT. However, matrix C is not orthonormal. An orthonormal matrix with a similar bound as in Equation 1 is sought. A possible choice is to take Z to be an orthonormal basis of C. However, this choice is not ideal because, in that case, Z would have dimensions m×c. Hence, to satisfy the rank assumption in Lemma 1, one would need to sample at least c rows from Zεm×c. Recall that c=O(k/ε), and therefore O(k/ε2) rows would need to be sampled in this operation. However, it is desired to obtain a CUR decomposition with only O(k/ε) rows. To achieve that, O(k/ε) rows is too many to select at this point. Rather, some embodiments may select O(k) rows, because otherwise the adaptive sampling operation that follows, which may be unavoidable, would sample O(k/ε2) rows from A. What is sought is therefore some matrix Z in the column span of C such that ZZTA approximates A as well as CXopt, and at the same time the number of columns of Z is O(k). To this end, a matrix Z2 is constructed, where Z2εm×k and Z2εspan(C), with

∥AT−ATZ2Z2T∥F2≦(1+O(ε))∥A−CXopt∥F2.

Herein, the above is referred to herein as Equation 2.
It is sought to apply Lemma 1 to AT and Z2εm×k. It is assumed that S2εm×r1 (i.e., R1=(ATS2)Tεr×n) can be found with r1=O(k) rows, such that (E2T=AT−ATZ2TZ2):

∥A−AR1†R1∥F2≦∥E2∥F2+∥E2S2(Z2TS2)†∥F2=∥A−Z2Z2TA∥F2+∥(A−Z2Z2TA)S2(Z2TS2)†∥F2≦O(1)∥A−Z2Z2TA∥F2.

Herein, the above is referred to herein as Equation 3.
The last inequality in the above requires that ∥E2S2(Z2TS2)†∥F2=O(1)∥E2∥F2, which is possible after constructing the matrix S2 appropriately.
At this point, a C and a subset of rows R in the optimal CUR have been found. Two additional operations are desired: (1) The adaptive sampling method for CUR that appeared in Wang (S. Wang and Z. Zhang; Improving cur matrix decomposition and the nystrom approximation via adaptive sampling; Journal of Machine Learning Research, 2013) may be used to further sample another r2=O(k/ε) rows in R1, i.e., construct Rεr×n with r=O(k+k/ε) rows. And (2) for Z2Z2TAR†R, replace Z2 with CΘ, for an appropriate Θ, and take U=ΘZ2TAR†εc×r. Such a Θ always exists because Z2 is in the span of C. So overall,

CUR=Z2Z2TAR†R, 

and the bound is as follows:





  
    
      
        
        
          A
          -
          
            
              Z
              2
            
            ⁢
            
              Z
              2
              T
            
            ⁢
            
              AR
              †
            
            ⁢
            R
          
        
        
      
      F
      2
    
    ≤
    
      
        
          
          
            A
            -
            
              
                Z
                2
              
              ⁢
              
                Z
                2
                T
              
              ⁢
              A
            
          
          
        
        P
        2
      
      +
      
        
          
            rank
            ⁡
            
              (
              
                
                  Z
                  2
                
                ⁢
                
                  Z
                  2
                  T
                
                ⁢
                A
              
              )
            
          
          
            r
            2
          
        
        ⁢
        
          
            
            
              A
              -
              
                
                  AR
                  1
                  †
                
                ⁢
                
                  R
                  1
                
              
            
            
          
          F
          2
        
      
    
  
  =
  
    
      
        
          
          
            A
            -
            
              
                Z
                2
              
              ⁢
              
                Z
                2
                T
              
              ⁢
              A
            
          
          
        
        P
        2
      
      +
      
        
          O
          ⁡
          
            (
            ɛ
            )
          
        
        ⁢
        
          
            
            
              A
              -
              
                
                  A
                  1
                  †
                
                ⁢
                
                  R
                  1
                
              
            
            
          
          F
          2
        
      
    
    ≤
    
      
        (
        
          1
          +
          
            O
            ⁡
            
              (
              ɛ
              )
            
          
        
        )
      
      ⁢
      
        
          
          
            A
            -
            
              
                Z
                2
              
              ⁢
              
                Z
                2
                T
              
              ⁢
              A
            
          
          
        
        F
        2
      
    
    ≤
    
      
        (
        
          1
          +
          
            O
            ⁡
            
              (
              ɛ
              )
            
          
        
        )
      
      ⁢
      
        
          
          
            A
            -
            
              CX
              opt
            
          
          
        
        F
        2
      
    
    ≤
    
      
        (
        
          1
          +
          
            O
            ⁡
            
              (
              ɛ
              )
            
          
        
        )
      
      ⁢
      
        
          
          
            A
            -
            
              A
              k
            
          
          
        
        F
        2
      
    
  




The first inequality in the group directly above is from the adaptive sampling argument. The equality is from a selected choice of r2. The second inequality is from Equation 3. The third inequality is from Equation 2. The last inequality is from Equation 1.
From all the above derivations, four sufficient conditions that give an optimal, relative-error, rank-k CUR may be identified. These conditions are referred to herein as primitives. By designing matrices C, U, and R satisfying those basic primitives, an optimal, relative-error, rank-k CUR may be secured, according to some embodiments.
To construct an optimal, relative-error, and rank-k CUR, the four basic primitives that may be relied upon are: (1) There is a Cεm×c, Xoptεc×n with a relative-error bound to A−Ak and c=O(k/ε), as provided in Equation 1. (2) There is a Z2εm×k (Z2εspan(C) and Z2TZ2=Ik) with a relative-error bound to A−CXopt, as provided in Equation 2. (3) There is R1εr2×n with a constant factor error to A−Z2Z2TA and r1=O(k), as provided in Equation 3. And (4) there is an adaptive sampling algorithm for CUR.
In some embodiments, a user or administrator of the decomposition system 100 may be enabled to select C, Z2, and R1 in the above conditions as desired. Below, various implementation choices that lead to desirable CUR algorithms are further discussed.
To address Primitive 1 above, known ideas for column subset selection, including leverage-scores sampling as in Drineas (P. Drineas, M. W. Mahoney, and S. Muthukrishnan; Relative-error cur matrix decompositions; SIAM Journal Matrix Analysis and Applications, 30(2):844-881, 2008); BSS sampling, i.e., deterministic sampling similar to the method of Batson (J. Batson, D. Spielman, and N. Srivastava. Twice-ramanujan sparsifiers; In Proceedings of the 41st annual ACM symposium on Theory of computing, pages 255-262; ACM, 2009); and adaptive sampling, as in Deshpande, may be combined. To find techniques for approximating the SVD may be used. To address Primitive 2, methods to find low-rank approximations within a subspace may be used. To address Primitive 3, leverage-score sampling and BSS sampling may again be used, as in Primitive 1. To address Primitive 4, an adaptive sampling method, such as that of Wang, may be used to turn a constant factor CUR to relative error by sampling an additional O(k/ε) rows. These various operations are summarized in Algorithm 1, which is referred to herein as a “proto-algorithm” for an optimal, relative -error, rank-k CUR.
Algorithm 1 is a proto-algorithm for an optimal, relative-error, rank-k CUR. Algorithm 1 may be implemented on a computer system in hardware, software, or a combination thereof. Various operations performed in this algorithm follow immediately below:
Input: Aεm×n; rank parameter k<rank(A); accuracy parameter 0<ε<1.
Output: Cεm×c with c=O(k/ε); Rεr×n with r=O(k/ε); Uεc×r with rank(U)=k.
(1) Construct C with O(k+k/ε) columns. This includes the operations of (1a) -(1d).
(1a) Approximate SVD: find Z1εn×O(k) that approximates Vkεn×k from the SVD of A.
(1b) Leverage-scores sampling: Sample O(k log k) columns from A with probabilities from Z1.
(1c) BSS sampling: downsample these columns to O(k) columns.
(1d) Adaptive sampling: sample O(k/ε) additional columns.
(2) Construct R with O(k+k/ε) rows. This includes the operations of (2a) -(2d).
(2a) Restricted low-rank approximation: find Z2εm×O(k) with Z2εspan(C).
(2b) Leverage-scores sampling: sample O(k log k) rows from A with probabilities from Z2.
(2c) BSS sampling: downsample these rows to O(k) rows.
(2d) Adaptive sampling: sample O(k/ε) additional rows.
(3) Construct U of rank k. This includes the operations of (3a).
(3a) Let Z2Z2TAR†R; then, replace Z2=CΘ; for an appropriate Θ; and use U=ΘZ2TAR†.
FIG. 2 is a flow diagram of a method 200 for finding a CUR decomposition of a matrix A, using Algorithm 1, according to some embodiments of this disclosure. At a high level, matrix C may be constructed with O(k/ε) columns at block 210, matrix R may be constructed with O(k/ε) rows at block 220, and matrix U may be constructed from matrices C and R at block 230.
More specifically, block 210 for constructing C may include blocks 212, 214, 216, and 218. At block 212, Z1 may be computed as the top k singular vectors of A, such that ∥A−AZ1Z1T∥F2≦(1+ε)∥A−Ak∥F2. At block 214, O(k log k) columns may be sampled from the transpose of Z1 or, equivalently, from A, with leverage scores, i.e., Euclidean norms of the columns of Z1 transpose. At block 216, the sampled columns may be down-sampled to C1εm×c2 containing c1=O(k) columns, such as by using BSS sampling, and such that ∥A−C1C1†∥F2≦O(1)∥A−AZ1Z1T∥F2. At block 218, c2=O(k/ε) columns of A may be adaptively sampled, such that ∥A−C·D∥F2≦∥A−Ak∥F2+(k/c2)∥A−C1C1†A∥F2, where D is a rank-k matrix.
Block 220 for constructing R may include block 222, 224, 226, and 228. At block 222, Z2εm×k may be found in the span of C, such that ∥A−AZ2Z2T∥F2≦(1+ε)∥A−Ak∥F2. To do this efficiently, instead of projecting columns of A onto C, the decomposition system 100 may project columns of AW onto C, where W is a random subspace embedding. The decomposition system 100 may then find a best rank-k approximate of the columns of AW in C. At block 224, O(k log k) rows with leverage scores may be sampled from Z2. At block 226, those sampled rows may be down-sampled to R1εr2×n containing r1=O(k) rows, such as by BSS sampling, and such that ∥A−R1R1†∥F2≦O(1)∥A−AZ2Z2TA∥F2. At block 228, r2=O(k/ε) rows of A may be adaptively sampled, such that




  
    
      
      
        A
        -
        
          
            Z
            2
          
          ⁢
          
            Z
            2
            T
          
          ⁢
          
            AR
            †
          
          ⁢
          R
        
      
      
    
    F
    2
  
  ≤
  
    
      
        
        
          A
          -
          
            
              Z
              2
            
            ⁢
            
              Z
              2
              T
            
            ⁢
            A
          
        
        
      
      P
      2
    
    +
    
      
        rank
        ⁡
        
          (
          
            
              
                Z
                2
              
              ⁢
              
                Z
                2
                T
              
              ⁢
              A
            
            
              r
              2
            
          
          )
        
      
      ⁢
      
        
          
            
            
              A
              -
              
                
                  AR
                  1
                
                ⁢
                
                  R
                  1
                  †
                
              
            
            
          
          F
          2
        
        .
      
    
  




To obtain a deterministic or input-sparsity-time CUR, the decomposition system 100 may implement the corresponding operations of the proto-algorithm, as provided above, in an appropriate setting. This is further discussed below.
For an algorithm that runs in time proportional to the number of non-zero entries of A, one may to implement the four primitives in input-sparsity time. Equivalently, all the operations of the proto-algorithm may be implemented in input -sparsity time. It is known how to implement approximate SVD in input-sparsity time. Given the relevant probabilities, the leverage-scores sampling operation can be implemented fast as well. For the remainder of the operations of the proto-algorithm, new tools are needed and used by various embodiments.
An input-sparsity-time version of the BSS sampling operation may be used. To design this, as will be described further below, one combines the method from Boutsidis with ideas from the sparse subspace embedding literature of Clarkson (K. L. Clarkson and D. P. Woodruff; Low rank approximation and regression in input sparsity time; In STOC, 2013). Various embodiments also use input-sparsity-time versions of the adaptive sampling algorithms of Deshpande and Wang. To this end, one combines existing ideas in Deshpande and Wang with the Johnson-Lindenstrauss lemma. An input -sparsity-time algorithm to find a relative-error, low-rank matrix within a given subspace may also be used. To this end, one combines ideas for subspace-restricted matrix approximations with ideas from Kannan (R. Kannan, S. Vempala, and D. P. Woodruff; Nimble algorithms for cloud computing; arXiv preprint arXiv:1304.3162, v3, 2013) and Clarkson. A method, presented below, may be used to compute a rank-k matrix U in input-sparsity time. To determine this method, one may take the original construction of U, which is a series of products of various matrices, and reduce the dimensions of some of those matrices using the sparse subspace embeddings in Clarkson. The computation of U may be viewed as the solution of a generalized matrix approximation problem, to which sketching concepts may be applied.
For a deterministic CUR algorithm, the CUR proto-algorithm may be implemented in a deterministic way. Various operations may be implemented deterministically with tools from conventional techniques. A missing piece from the existing art is a deterministic version of adaptive sampling, which is obtained in this disclosure by derandomizing the adaptive sampling algorithms in Deshpande and Wang.
Some embodiments of the decomposition system 100 of this disclosure implement a randomized CUR algorithm that runs in linear time. In some embodiments, the algorithm constructs C and R with rescaled columns and rows from A. To convert this to a truly CUR decomposition, the decomposition system 100 may keep the un-rescaled versions of C and R, and introduce the scaling factors in U. The analysis carries over to that CUR version unchanged. The embodiment below need not provide the fastest possible CUR algorithm, but does provide a benefit in its simplicity. A faster randomized algorithm is presented following this one. The analysis of the algorithm in this section serves as a stepping stone for the input-sparsity-time and deterministic CUR algorithms presented later.
Algorithm 2 is a randomized, linear-time, optimal, relative-error, rank-k CUR, that closely follows the CUR proto-algorithm (i.e., Algorithm 1). Algorithm 2 may be implemented on a computer system in hardware, software, or a combination thereof. Various operations performed in this algorithm follow immediately below:
Input: Aεm×n; rank parameter k<rank (A); and accuracy parameter 0<ε<1.
Output: Cεm×c with c=O(k/ε); Rεr×n with r=O(k/ε); and Uεc×r with rank (U)=k.
(1) Construct C with O(k+k/ε) columns. This includes the operations of (1a) -(1d).
(1a) Z1=RandomizedSVD(A, k, 1); Z1εn×k(Z1TZ1=Ik); E1=A−AZ1Z1Tεm×n.
(1b) [Ω1, D1]=RandSampling(Z1, h1, 1); h1=16kln(20k); Ω1εn×h2; D1εh2×h2.
M1=Z1TΩ1D1εk×h1. M1=UM2ΣM2VM2T with rank(M1)=k and VM1εh1×k.
(1c) S1=BssSampling(VM1, (E1Ω1D1)T, c1), with c1=4k, S1εh1×cs.
C1=AΩ1D1S1εm×c2 containing rescaled columns of A.
(1d) C2=AdaptiveCols(A, C1, 1, c2), with




  
    c
    2
  
  =
  
    
      1620
      ⁢
      
        
      
      ⁢
      k
    
    s
  




and C2εm×c2 with columns of A.

C=[C1C2]εm×c containing




  c
  =
  
    
      
        c
        1
      
      +
      
        c
        2
      
    
    =
    
      
        4
        ⁢
        k
      
      +
      
        
          1620
          ⁢
          k
        
        s
      
    
  




rescaled columns of A.

(2) Construct R with O(k+l/ε) rows. This includes the operations of (2a) -(2d).
(2a) [Y,Ψ, Δ]=BestSubspaceSVD(A,C,k); Yεm×c, Ψεc×c, Δεc×k; B=YΔ.
B=ZZD is a qr-factorization of B with Z2εm×k (Z2TZ2=Ik), Dεk×k, and E2=AT−ATZ2Z2T.
(2b) [Ω2, D2]=RandSampling(Z2,h2,1); h2=8kln(20k); Ω2εm×h2; D2εh2×h2.
M2=Z2TΩ2D2εk×h2. M2=UM2ΣM2VM2T with rank(M2)=k and VM2εh2×k.
(2c) S2=BssSampling(VM2, (E2Ω2D2)T, r1), with r1=4k and S2εh2×21.
R1=(ATΩ2D2S2)Tεrs×n containing rescaled rows from A.
(2d) R2=AdaptiveRows(A, Z2, R1, r2), with




  
    r
    2
  
  =
  
    
      
        [
        
          
            1620
            ⁢
            k
          
          s
        
        ]
      
      ⁢
      
        
      
      ⁢
      and
      ⁢
      
        
      
      ⁢
      
        R
        2
      
    
    ∈
    
      R
      
        
          r
          2
        
        ×
        n
      
    
  




with rows of A.

R=[R1T, R2T]Tε(r2+r2)×n containing




  r
  =
  
    
      4
      ⁢
      
        
      
      ⁢
      k
    
    +
    
      
        1620
        ⁢
        k
      
      s
    
  




rescaled rows of A.

(3) Construct U of rank k. This includes the operations of (3a).
(3a) Construct Uεc×r with rank at most k as follows, with these equivalent formulas:




  
    
      
        U
        =
        
          
            
              Ψ
              
                -
                1
              
            
            ⁢
            Δ
            ⁢
            
              
            
            ⁢
            
              D
              
                -
                1
              
            
            ⁢
            
              Z
              2
              T
            
            ⁢
            
              AR
              †
            
          
          =
          
          ⁢
          
            
              Ψ
              
                -
                1
              
            
            ⁢
            Δ
            ⁢
            
              
            
            ⁢
            
              
                
                  D
                  
                    -
                    1
                  
                
                ⁡
                
                  (
                  
                    C
                    ⁢
                    
                      
                    
                    ⁢
                    
                      Ψ
                      
                        -
                        1
                      
                    
                    ⁢
                    Δ
                    ⁢
                    
                      
                    
                    ⁢
                    
                      D
                      
                        -
                        1
                      
                    
                  
                  )
                
              
              T
            
            ⁢
            
              AR
              †
            
          
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            Ψ
            
              -
              1
            
          
          ⁢
          Δ
          ⁢
          
            
          
          ⁢
          
            
              
                D
                
                  -
                  1
                
              
              ⁡
              
                (
                
                  C
                  ⁢
                  
                    
                  
                  ⁢
                  
                    Ψ
                    
                      -
                      1
                    
                  
                  ⁢
                  Δ
                  ⁢
                  
                    
                  
                  ⁢
                  
                    D
                    
                      -
                      1
                    
                  
                
                )
              
            
            †
          
          ⁢
          
            AR
            †
          
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            Ψ
            
              -
              1
            
          
          ⁢
          Δ
          ⁢
          
            
          
          ⁢
          
            D
            
              -
              1
            
          
          ⁢
          D
          ⁢
          
            
          
          ⁢
          
            Δ
            T
          
          ⁢
          Ψ
          ⁢
          
            
          
          ⁢
          
            C
            †
          
          ⁢
          
            AR
            †
          
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            Ψ
            
              -
              1
            
          
          ⁢
          
            ΔΔ
            T
          
          ⁢
          Ψ
          ⁢
          
            
          
          ⁢
          
            C
            †
          
          ⁢
          
            AR
            †
          
        
      
    
  




Algorithm 2 takes as input an m×n matrix A, rank parameter k<rank(A), and accuracy parameter 0<ε<1. These are the same inputs as in the CUR Problem. The algorithm may output matrix C εm×c with c=O(k/ε) columns of A, matrix Rεr×n with r=O(k/ε) rows of A, and matrix Uεc×r with rank at most k. Algorithm 2 may closely follow the CUR proto-algorithm that is Algorithm 1. However, Algorithm 2 may make specific choices for the various operations of the proto-algorithm that can be implemented in linear time. Algorithm 2 may have three operations: (1) an optimal number of columns are selected in C; (2) an optimal number of rows are selected in R; and (3) an intersection matrix with optimal rank is constructed as U. The algorithm itself refers to several other algorithms, combined in a novel manner. Specifically, the algorithm refers to RandomizedSVD, which is described in Lemma 3.4 of Boutsidis; RandSampling, which is described in Rudelson (M. Rudelson and R. Vershynin; Sampling from large matrices: An approach through geometric functional analysis; JACM: Journal of the ACM, 54, 2007); BssSampling, which is described in Lemma 3.6 of Boutsidis; AdaptiveCols, which is described in Lemma 2.1 of Deshpande II (A. Deshpande, L. Rademacher, S. Vempala, and G.Wang; Matrix approximation and projective clustering via volume sampling; In Proceedings of the 17th Annual ACM -SIAM Symposium on Discrete Algorithms, pages 1117-1126, 2006); BestSubspaceSVD, which is described in Clarkson II (K. Clarkson and D. Woodruff; Numerical linear algebra in the streaming mode;. In Proceedings of the 41st annual ACM symposium on Theory of computing (STOC), 2009); and AdaptiveRows, which is described in Theorem 4 of Wang.
It can be shown that the total asymptotic running time of the above algorithm is as follows:




  
    O
    ⁡
    
      (
      
        
          
            n
            2
          
          ⁢
          
            k
            /
            ɛ
          
        
        +
        
          
            m
            2
          
          ⁢
          
            k
            /
            ɛ
          
        
        +
        
          
            mk
            2
          
          /
          
            ɛ
            2
          
        
        +
        
          
            k
            3
          
          /
          
            ɛ
            3
          
        
        +
        
          
            k
            4
          
          ⁢
          ln
          ⁢
          
            
          
          ⁢
          k
        
        +
        
          
            k
            ɛ
          
          ⁢
          log
          ⁢
          
            k
            ɛ
          
        
      
      )
    
  
  .




With respect to an error bound, it can additionally be shown that the matrices C, U, and R in Algorithm 2 satisfy the following with probability at least 0.2:

∥A−CUR∥F2≦(1+20ε)∥A−Ak∥F2.

Following, a CUR algorithm that runs in input-sparsity time is presented and analyzed. More specifically, this algorithm constructs C and R with rescaled columns and rows from A. To convert this to a truly CUR decomposition, the decomposition system 100 may keep the un-rescaled versions of C and R and introduce the scaling factors in U. The analysis carries over to that CUR version unchanged.
The algorithm description below closely follows the CUR proto-algorithm in Algorithm 1. Algorithm 3 may be implemented on a computer system in hardware, software, or a combination thereof. Various operations performed in this algorithm follow immediately below:
Input: Aεm×n; rank parameter k<rank (A); and accuracy parameter 0<ε<1.
Output: Cεm×c with c=O(k/ε); Rεr×n with r=O(k/ε); Uεc×r with rank(U)=k.
Construct C with O(k+k/ε) columns. This includes the operations of (1a) -(1d).
(1a) Z1=SparseSVD(A, k, 1); Z1εn×k(Z1TZ1=Ik).
(1b) [Ω1, D1]=RandSampling(Z1, h1, 1); h1=16kln(20k); Ω1εn×h2; D1εh1×h1.
M1=Z1TΩ1D1εk×h1. M1=UM2ΣM2VM2T with rank(M1)=k and VM1εh2×k.
(1c) S1=BssSamplingSparse(VM1, ((A−AZ1Z1T)Ω1D1)T, c1, 0.5), with c1=4k, S1εh1×11.
C1=AΩ1D1S1εm×c2 containing rescaled columns of A.
(1d) C2=AdaptiveColsSparse(A, C1, 1, c2);




  
    
      c
      2
    
    =
    
      
        482
        ⁢
        
          
        
        ⁢
        0
        ⁢
        k
      
      s
    
  
  ;
  
    
      C
      2
    
    ∈
    
      R
      
        m
        ×
        
          c
          2
        
      
    
  




with columns of A.

C=[C1C2]εm×c containing




  c
  =
  
    
      
        c
        1
      
      +
      
        c
        2
      
    
    =
    
      
        4
        ⁢
        
          
        
        ⁢
        k
      
      +
      
        
          482
          ⁢
          
            
          
          ⁢
          0
          ⁢
          k
        
        s
      
    
  




rescaled columns of A.

(2) Construct R with O(k+l/ε) rows. This includes the operations of (2a) -(2d).
(2a) [Y,Ψ, Δ]=ApproxSubspaceSVD(A,C,k); Yεm×c, Ψεc×c, Δεc×k; B=YΔ.
B=Z2D is a qr decomposition of B with Z2εm×k (Z2TZ2=Ik), Dεk×k.
(2b) [Ω2, D2]=RandSampling(Z2,h2,1); h2=8kln(20k); Ω2εm×h2; D2εh2×h2.
M2=Z2TΩ2D2εk×h2. M2=UM2ΣM2VM2T with rank(M2)=k and VM2εh2×k.
(2c) S2=BssSamplingSparse(VM2, ((AT−ATZ2Z2T)Ω2D2)T, r1, 0.5), with r1=4k, S2εh2×r2.
R1=(ATΩ2D2S2)Tεr2×n containing rescaled rows from A.
(2d) R2=AdaptiveRowsSparse(A, Z2, R1, r2);




  
    
      
        
          
            r
            2
          
          =
          
            
              482
              ⁢
              
                
              
              ⁢
              0
              ⁢
              
                
              
              ⁢
              k
            
            s
          
        
        ;
        
          
            R
            2
          
          ∈
          
            R
            
              
                r
                2
              
              ×
              m
            
          
        
      
    
    
      
        
      
    
  




with rows of A.

R=[R1T, R2T]Tε(r2+r2)×n containing




  r
  =
  
    
      4
      ⁢
      
        
      
      ⁢
      k
    
    +
    
      
        4820
        ⁢
        k
      
      s
    
  




rescaled rows of A.

(3) Construct U of rank k. This includes the operations of (3a).
(3a) Let Wεζ×m be a randomly chosen sparse subspace embedding with ζ=Ω(k2ε−2). Then

U=Ψ−1ΔD−1(WCΨ−1ΔD−1)554 WAR†=Ψ−1ΔΔT(WC)†WAR†.

Algorithm 3 takes as input an m×n matrix A, rank parameter k<rank(A), and accuracy parameter 0<ε<1. These are the same inputs as in the CUR Problem. The algorithm may return matrix Cεm×c with c=O(k/ε) columns of A, matrix Rεr×n with r=O(k/ε) rows of A, and matrix Uεc×r with rank at most k. Although Algorithm 3 follows closely the CUR proto-algorithm in Algorithm 1, this algorithm may make specific choices for the various actions of the proto-algorithm that can be implemented in input-sparsity time.
In some embodiments, Algorithm 3 may run as follows: (1) An optimal number of columns are selected in C. (2) An optimal number of rows are selected in R. And (3) an intersection matrix with optimal rank is constructed and denoted as U. As provided above, the algorithm itself refers to several other algorithms, including new algorithms as well as existing ones combined in a novel manner. Specifically, the algorithm refers to SparseSVD, which is described in Theorem 47 of Clarkson III (K. L. Clarkson and D. P. Woodruff; Low rank approximation and regression in input sparsity time; 2013); RandSampling, which is described in Rudelson; BssSampling, which is described in Lemma 3.6 of Boutsidis; AdaptiveColsSparse, which is described in Lemma 3 herein; ApproxSubspaceSVD, which is described in Kannan (R. Kannan, S. Vempala, and D. P. Woodruff; Nimble algorithms for cloud computing. arXiv preprint arXiv:1304.3162, v3, 2013); and AdaptiveRowsSparse, which is described in Lemma 4 herein.
FIG. 3 is a flow diagram of a method 300 for finding a CUR decomposition of a matrix A in input-sparsity time, using Algorithm 3, according to some embodiments of this disclosure. At a high level, matrix C may be constructed with O(k/ε) columns at block 310, matrix R may be constructed with O(k/ε) rows at block 320, and matrix U may be constructed from matrices C and R at block 330. The decomposition method 300 of FIG. 3 is similar to the decomposition method 200 of FIG. 2, with some exceptions. As a first exception, at blocks 316 and 326, an input-sparsity-time version of the BSS sampling technique may be used, as will be described further below. As a second exception, at blocks 318 and 328, the adaptive sampling performed may be an input -sparsity-time version, as will be described further below. Additionally, the constructions of U at block 330 may run in input-sparsity time.
It can be shown that the total running time of the above algorithm is as follows:

O(nnz(A)log n+(m+n)·poly(log n, k, 1/ε)).

With respect to a quality-of-approximation result (i e , error bounds) of Algorithm 3, it can also be shown that the matrices C, U, and R in Algorithm 3 satisfy, with probability at least 0.16−2/n,

∥A−CUR∥F2≦(1+ε)(1+60ε)∥A−Ak∥F2.

The above Algorithm 3 for an input-sparsity-time CUR decomposition may include other algorithms, some of which exist in the art and some of which are newly provided in this disclosure. Below, those that are new are described in detail.
For use in this algorithm, an input-sparsity-time version of the so-called “BSS sampling” algorithm of Batson may be developed, as an extension of the original BSS algorithm that appeared in Boutsidis.
The following is referred to herein as Lemma 2, an input-sparsity-time, dual- set, spectral-frobenius sparsification: Let V=(v1, . . . , vn) be a decomposition of the identity, where v1εk(k<n) and Σi=1nviviT=Ik. Let A=(a1, . . . , an) be an arbitrary set of vectors, where αiεl. Let Wεζ×l be a randomly chosen sparse subspace embedding with ζ=O(n2/ε2)<l, for some 0<ε<1 Consider a new set of vectors B=(Wα1, . . . , Wαn), with Wα1εζ. Run the algorithm of Lemma 3.6 of Boutsidis, with v=(v1, . . . , vn), B=(Wα1, . . . , Wαn), and some integer r such that k<r≦n. Let the output of this be a set of weights s1≧0(l=1 . . . n), at most r of which are non-zero Then, with probability at least 0.98,




  
    
      
        λ
        k
      
      ⁡
      
        (
        
          
            ∑
            
              i
              =
              1
            
            n
          
          ⁢
          
            
          
          ⁢
          
            
              s
              i
            
            ⁢
            
              v
              i
            
            ⁢
            
              v
              i
              T
            
          
        
        )
      
    
    ≥
    
      
        (
        
          1
          -
          
            
              k
              r
            
          
        
        )
      
      2
    
  
  ,
  
    

  
  ⁢
  
    
      
        
          
            Tr
            ⁡
            
              (
              
                
                  ∑
                  
                    i
                    =
                    1
                  
                  n
                
                ⁢
                
                  
                
                ⁢
                
                  
                    s
                    i
                  
                  ⁢
                  
                    a
                    i
                  
                  ⁢
                  
                    a
                    i
                    T
                  
                
              
              )
            
          
          ≤
          
          ⁢
          
            
              
                1
                +
                ɛ
              
              
                1
                -
                ɛ
              
            
            ·
            
              Tr
              ⁡
              
                (
                
                  
                    ∑
                    
                      i
                      =
                      1
                    
                    n
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    
                      a
                      i
                    
                    ⁢
                    
                      a
                      i
                      T
                    
                  
                
                )
              
            
          
        
      
    
    
      
        
          =
          
          ⁢
          
            
              
                1
                +
                ɛ
              
              
                1
                -
                ɛ
              
            
            ·
            
              
                ∑
                
                  i
                  =
                  1
                
                n
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    
                    
                      a
                      i
                    
                    
                  
                  2
                  2
                
                .
              
            
          
        
      
    
  




Equivalently, if Vεn×k is a matrix whose rows are the vectors viT, Aεn×l is a matrix whose rows are the vectors αiT, B=AWTεn×ζ is a matrix whose rows are the vectors αiTWT, and Sεn×r is the sampling matrix containing the weights si>0, then with probability at least 0.98,





  
    
      
        σ
        k
      
      ⁡
      
        (
        
          
            V
            T
          
          ⁢
          S
        
        )
      
    
    ≥
    
      1
      -
      
        
          k
          r
        
      
    
  
  ,
  
    
  
  ⁢
  
    
      
        
        
          
            A
            T
          
          ⁢
          S
        
        
      
      F
      2
    
    ≤
    
      
        1
        +
        ɛ
      
      
        1
        -
        ɛ
      
    
  
  ,
  
    
      
        
        A
        
      
      F
      2
    
    .
  




The weights si can be computed in O(nnz(A)+rnk2+nζ) time. The procedure is denoted herein as S=BssSamplingSparse(V , A, r ε).

Lemma 2 may be proven as follows: The algorithm constructs S as S=BssSampling(V , B, r). The lower bound for the smallest singular value of V is immediate from Lemma 3.6 of Boutsidis . That lemma also ensures that

∥BTS∥F2≦∥BT∥F2.

i.e.,

∥WATS∥F2≦∥WAT∥F2.

Since is a subspace embedding, from Clarkson III, it is the case that, with probability at least 0.99, and for all vectors yεn simultaneously,

(1−ε)∥ATy∥22≦∥WATy∥22.

Apply this r times for yεn being columns from Sεn×r, and take a sum on the resulting inequalities,

(1−ε)∥ATS∥F2≦∥WATS∥F2.

From Lemma 40 of Clarkson III, it is the case that, with probability at least 0.99,

∥WAT∥F2≦(1+ε)∥AT∥F2.

Combining these inequalities together, it can be concluded that, with probability at least 0.98,




  
    
      
        
        
          
            A
            T
          
          ⁢
          S
        
        
      
      F
      2
    
    ≤
    
      
        1
        +
        ɛ
      
      
        1
        -
        ɛ
      
    
  
  ,
  
    
      
        
        
          A
          T
        
        
      
      F
      2
    
    .
  




Following are developed input-sparsity-time versions of certain adaptive sampling algorithms. The lemma below corresponds to a fast version of the adaptive sampling algorithm of Theorem 2.1 of Deshpande II.
The following is referred to herein as Lemma 3: Given Aεm×n and Vεm×cs (with c1≦n, m), there exists a randomized algorithm to construct C2εm×c2 containing c2 columns of A, such that the matrix C=[V C2]εm×(c2+c2) contianing the columns of V and C2 satisfies, for any integer k>0, and with probability




  
    0.9
    -
    
      1
      n
    
  
  ,
  
    

  
  ⁢
  
    
      
        
        
          A
          -
          
            
              ∏
              
                C
                ,
                k
              
              F
            
            ⁢
            
              
            
            ⁢
            
              (
              A
              )
            
          
        
        
      
      F
      2
    
    ≤
    
      
        
          
          
            A
            -
            
              A
              k
            
          
          
        
        F
        2
      
      +
      
        
          
            30
            ⁢
            
              
            
            ⁢
            k
          
          
            c
            2
          
        
        ⁢
        
          
            
              
              
                A
                -
                
                  
                    VV
                    †
                  
                  ⁢
                  A
                
              
              
            
            F
            2
          
          .
        
      
    
  




The above procedure is denoted as C2=AdaptiveColsSparse(A, V, c2). Given A and V, the algorithm takes O(nnz(A)log n+mc1 log n+mc12) time to find C2.

Lemma 3 may be proven as follows: Define the residual B=A−VV†Aεm×n. From Theorem 1 (for fixed ε=0.5) of Achlioptas (D. Achlioptas; Database-friendly random projections: Johnson-Lindenstrauss with binary coins; J. Comput. Syst. Sci., 66(4):671-687, 2003), let

B=JLT(B,1).

The lemma gives




  
    
      
      
        
          b
          ~
        
        i
      
      
    
    2
    2
  
  ≥
  
    
      1
      2
    
    ⁢
    
      
        
          
          
            b
            i
          
          
        
        2
        2
      
      .
    
  




So from Theorem 2.1 of Deshpande II, after using the following distribution for the sampling,





  
    
      p
      i
    
    =
    
      
        
          
            
              
              
                
                  b
                  ~
                
                i
              
              
            
            2
            2
          
          
            
              
              
                B
                ~
              
              
            
            F
            2
          
        
        ≥
        
          
            1
            2
          
          ·
          
            2
            3
          
          ·
          
            
              
                
                
                  b
                  i
                
                
              
              2
              2
            
            
              
                
                B
                
              
              F
              2
            
          
        
      
      =
      
        
          1
          3
        
        ⁢
        
          
            
              
              
                b
                i
              
              
            
            2
            2
          
          
            
              
              B
              
            
            F
            2
          
        
      
    
  
  ,




one obtains





  
    E
    ⁡
    
      [
      
        
          
          
            A
            -
            
              
                ∏
                
                  C
                  ,
                  k
                
                F
              
              ⁢
              
                
              
              ⁢
              
                (
                A
                )
              
            
          
          
        
        F
        2
      
      ]
    
  
  ≤
  
    
      
        
        
          A
          -
          
            A
            k
          
        
        
      
      F
      2
    
    +
    
      
        
          3
          ⁢
          
            
          
          ⁢
          k
        
        
          c
          2
        
      
      ⁢
      
        
          
            
            
              A
              -
              
                
                  VV
                  †
                
                ⁢
                A
              
            
            
          
          F
          2
        
        .
      
    
  




The expectation is taken with respect to the randomness in constructing C2, so




  
    
      E
      ⁡
      
        [
        
          
            
            
              A
              -
              
                
                  ∏
                  
                    C
                    ,
                    k
                  
                  F
                
                ⁢
                
                  
                
                ⁢
                
                  (
                  A
                  )
                
              
            
            
          
          F
          2
        
        ]
      
    
    -
    
      
        
        
          A
          -
          
            A
            k
          
        
        
      
      F
      2
    
  
  ≤
  
    
      
        3
        ⁢
        
          
        
        ⁢
        k
      
      
        c
        2
      
    
    ⁢
    
      
        
          
          
            A
            -
            
              
                VV
                †
              
              ⁢
              A
            
          
          
        
        F
        2
      
      .
    
  




The following relation is immediate:

∥A−ΠC,kF(A)∥F2−∥A−Ak∥F2>0,

so, from Markov's inequality, with probability at least 0.9,





  
    
      
        
          
          
            A
            -
            
              
                ∏
                
                  C
                  ,
                  k
                
                F
              
              ⁢
              
                
              
              ⁢
              
                (
                A
                )
              
            
          
          
        
        F
        2
      
      -
      
        
          
          
            A
            -
            
              A
              k
            
          
          
        
        F
        2
      
    
    ≤
    
      
        
          30
          ⁢
          
            
          
          ⁢
          k
        
        
          c
          2
        
      
      ⁢
      
        
          
          
            A
            -
            
              
                VV
                †
              
              ⁢
              A
            
          
          
        
        F
        2
      
    
  
  ,




which implies





  
    
      
      
        A
        -
        
          
            ∏
            
              C
              ,
              k
            
            F
          
          ⁢
          
            
          
          ⁢
          
            (
            A
            )
          
        
      
      
    
    F
    2
  
  ≤
  
    
      
        
        
          A
          -
          
            A
            k
          
        
        
      
      F
      2
    
    +
    
      
        
          30
          ⁢
          
            
          
          ⁢
          k
        
        
          c
          2
        
      
      ⁢
      
        
          
            
            
              A
              -
              
                
                  VV
                  †
                
                ⁢
                A
              
            
            
          
          F
          2
        
        .
      
    
  




The running time follows by a careful implementation of the random projection step inside the routine in Theorem 1 of Achlioptas. The matrices SA and SV are computed in O(nnz(A)log n) and O(mc1log n) arithmetic operations, respectively. Computing V† requires O(mc12) operations, and (SV)V† takes another O(mc1log n) operations. Computing (SVV†)A takes O(nnz(A)log n) operations, and computing SA−SVV†A takes another O(n log n) operations. Thus, these steps can be implemented in total time O(nnz(A)log n+mc1log n+mc12).
Following is developed an input-sparsity-time version of the adaptive sampling algorithm of Theorem 4 in Wang.
The following is referred to herein as Lemma 4: Given Aεm×n and Aεm×n such that

rank(V)=rank(VV†A)=ρ,

with p≦c≦n, let R1εr1×n consist of r1 rows of A. There exists a randomized algorithm to construct R2εr2×n with r2 rows such that, for R=[R1T, R2T]Tε(rs+r2)×n, with probability at least 0.9−1/n,





  
    
      
      
        A
        -
        
          
            VV
            †
          
          ⁢
          
            AR
            †
          
          ⁢
          R
        
      
      
    
    F
    2
  
  ≤
  
    
      
        
        
          A
          -
          
            
              VV
              †
            
            ⁢
            A
          
        
        
      
      F
      2
    
    +
    
      
        
          30
          ⁢
          
            
          
          ⁢
          ρ
        
        
          r
          2
        
      
      ⁢
      
        
          
            
            
              A
              -
              
                
                  AR
                  1
                  †
                
                ⁢
                
                  R
                  1
                
              
            
            
          
          F
          2
        
        .
      
    
  




This procedure is denoted as R2=AdaptiveRowsSparse(A, V, R1, r2). Given A. V, R1, the algorithm takes

O(nnz(A)log n+nr1log n+nr12)

arithmetic operations to find R2.

Lemma 4 may be proven as follows: There is an immediate generalization of Theorem 15 of Wang to the case when the sampling probabilities satisfy




  
    
      p
      i
    
    ≥
    
      α
      ⁢
      
        
          
            
            
              b
              i
            
            
          
          2
          2
        
        
          
            
            B
            
          
          F
          2
        
      
    
  
  ,




for some α<1, rather than just for α=1. This leads to the following version of Theorem 4 of Wang described herein: if the probabilities in that lemma satisfy





  
    
      p
      i
    
    ≥
    
      α
      ⁢
      
        
          
            
            
              b
              i
            
            
          
          2
          2
        
        
          
            
            B
            
          
          F
          2
        
      
    
  
  ,




for some α<1, then the bound is





  
    E
    ⁡
    
      [
      
        
          
          
            A
            -
            
              
                VV
                †
              
              ⁢
              
                AR
                †
              
              ⁢
              R
            
          
          
        
        F
        2
      
      ]
    
  
  ≤
  
    
      
        
        
          A
          -
          
            
              VV
              †
            
            ⁢
            A
          
        
        
      
      F
      2
    
    +
    
      
        ρ
        
          α
          ⁢
          
            
          
          ⁢
          
            r
            2
          
        
      
      ⁢
      
        
          
            
            
              A
              -
              
                
                  AR
                  1
                  †
                
                ⁢
                
                  R
                  1
                
              
            
            
          
          F
          2
        
        .
      
    
  




Given this bound, the proof continues by repeating the ideas used in Lemma 3. Although the proof is similar to that in Lemma 3, a proof is included herein for completeness.
Define the residual

B=A−AR1†R1εm×n.

From Theorem 1 in Achlioptas, let

{tilde over (E)}=JLT(B, 1).

Given that, it is the case that




  
    
      
      
        
          b
          ~
        
        i
      
      
    
    2
    2
  
  ≥
  
    
      1
      2
    
    ⁢
    
      
        
          
          
            b
            i
          
          
        
        2
      
      .
    
  




Using for the sampling the distribution





  
    
      p
      i
    
    =
    
      
        
          
            
              
              
                
                  b
                  ~
                
                i
              
              
            
            2
            2
          
          
            
              
              
                B
                ~
              
              
            
            F
            2
          
        
        ≥
        
          
            1
            2
          
          ·
          
            2
            3
          
          ·
          
            
              
                
                
                  b
                  i
                
                
              
              2
              2
            
            
              
                
                B
                
              
              F
              2
            
          
        
      
      =
      
        
          1
          3
        
        ⁢
        
          
            
              
              
                b
                i
              
              
            
            2
            2
          
          
            
              
              B
              
            
            F
            2
          
        
      
    
  
  ,




one may obtain





  
    [
    
      
        
        
          A
          -
          
            
              VV
              †
            
            ⁢
            
              AR
              †
            
            ⁢
            R
          
        
        
      
      F
      2
    
    ]
  
  ≤
  
    
      
        
        
          A
          -
          
            
              VV
              
                
                  
                
                ⁢
                †
              
            
            ⁢
            A
          
        
        
      
      F
      2
    
    +
    
      
        
          3
          ⁢
          
            
          
          ⁢
          ρ
        
        
          r
          2
        
      
      ⁢
      
        
          
            
            
              A
              -
              
                
                  AR
                  1
                  †
                
                ⁢
                
                  R
                  1
                
              
            
            
          
          F
          2
        
        .
      
    
  




The expectation is taken with respect to the randomness in constructing R2, so




  
    E
    ⁡
    
      [
      
        
          
            
            
              A
              -
              
                
                  VV
                  †
                
                ⁢
                
                  AR
                  †
                
                ⁢
                R
              
            
            
          
          F
          2
        
        -
        
          
            
            
              A
              -
              
                
                  VV
                  †
                
                ⁢
                A
              
            
            
          
          F
          2
        
      
      ]
    
  
  ≤
  
    
      
        3
        ⁢
        
          
        
        ⁢
        ρ
      
      
        r
        2
      
    
    ⁢
    
      
        
          
          
            A
            -
            
              
                AR
                1
                †
              
              ⁢
              
                R
                1
              
            
          
          
        
        F
        2
      
      .
    
  




It follows that

∥A−VV†AR†R∥F2−∥A−VV†A∥F2>0

since

∥A−VV†AR†R∥F2=∥A−VV†A+VV†A−VV†AR†R∥F2=∥A−VV†A∥F2+∥VV†A−VV†AR†R∥F2.

Hence, by Markov's inequality, with probability at least 0.9,




  
    
      
        
          
          
            A
            -
            
              
                VV
                †
              
              ⁢
              
                AR
                †
              
              ⁢
              R
            
          
          
        
        F
        2
      
      -
      
        
          
          
            A
            -
            
              
                VV
                †
              
              ⁢
              A
            
          
          
        
        F
        2
      
    
    ≤
    
      
        +
        
          
            30
            ⁢
            
              
            
            ⁢
            ρ
          
          
            r
            2
          
        
      
      ⁢
      
        
          
          
            A
            -
            
              
                AR
                1
                †
              
              ⁢
              
                R
                1
              
            
          
          
        
        F
        2
      
    
  
  ,




which implies





  
    
      
      
        A
        -
        
          
            VV
            †
          
          ⁢
          
            AR
            †
          
          ⁢
          R
        
      
      
    
    F
    2
  
  ≤
  
    
      
        
        
          A
          -
          
            
              VV
              †
            
            ⁢
            A
          
        
        
      
      F
      2
    
    +
    
      
        
          30
          ⁢
          
            
          
          ⁢
          ρ
        
        
          r
          2
        
      
      ⁢
      
        
          
            
            
              A
              -
              
                
                  AR
                  1
                  †
                
                ⁢
                
                  R
                  1
                
              
            
            
          
          F
          2
        
        .
      
    
  




The running time follows by a careful implementation of the random projection step inside the routine in Theorem 1 of Achlioptas. Computing SA may occur in O(nnz(A)log n) arithmetic operations. Computing R1† requires O(nr12) operations. Computing ((SA)V†)R1 requires another O(nr1log n) operations. Computing SA−SAR1†R1 requires O(n log n) operations. Thus, all these operations can be implemented in O(nnz(A) log n+nr1log n+nr12) time.
Below, a deterministic, polynomial-time CUR algorithm is presented in Algorithm 4. More precisely, the algorithm constructs C and R with rescaled columns and rows from A. To convert this to a truly CUR decomposition, one may keep the un -rescaled versions of C and R and introduce the scaling factors in U.
The algorithm description below closely follows the CUR proto-algorithm in Algorithm 1. Algorithm 4 may be implemented on a computer system in hardware, software, or a combination thereof. Various operations performed in this algorithm follow immediately below:
Input: Aεm×n; rank parameter k<rank(A); and accuracy parameter 0<ε<1.
Output: Cεm×c with c=O(k/ε); Rεr×n with r=O(k/ε); Uεc×r with rank(U)=k.
Construct C with O(k+k/ε) columns. This includes the operations of (1a)-(1d).
(1a) Z1=DeterministicSVD(A, k, 1); Z1εn×k(Z1TZ1=Ik); E1=A−AZ1Z1Tεm×n.
(1b) S1=BssSampling(VM1, E1T, C1), with c1=4k, S1εh2×c1.
c1=ASεm×c2 containing rescaled columns of A.
(1c) C2=AdaptiveColsD(A, C1, 1, c2); with




  
    c
    2
  
  =
  
    
      
        
          10
          ⁢
          
            
          
          ⁢
          k
        
        s
      
      ⁢
      
        
      
      ⁢
      and
      ⁢
      
        
      
      ⁢
      
        C
        2
      
    
    ∈
    
      R
      
        m
        ×
        
          c
          2
        
      
    
  




columns of A.

C=[C1C2]εm×c containing




  c
  =
  
    
      
        c
        1
      
      +
      
        c
        2
      
    
    =
    
      
        4
        ⁢
        
          
        
        ⁢
        k
      
      +
      
        
          10
          ⁢
          
            
          
          ⁢
          k
        
        s
      
    
  




rescaled columns of A.

(2) Construct R with O(k+l/ε) rows. This includes the operations of (2a) -(2d).
(2a) [Y,Ψ, Δ]=BestSubspaceSVD(A,C,k); Yεm×c, Ψεc×c, Δεc×k; B=YΔ.
B=Z2D is a qr-factorization of B with Z2εm×k (Z2TZ2=Ik), Dεk×k, and E2=AT−ATZ2Z2T.
(2b) S2=BssSampling(VM2, (E2)T, r1), with r1=4k and S2εh2×r2.
R1=(ATS2)Tεrs×n containing rescaled rows from A.
(2c) R2=AdaptiveRowsD(A, Z2, R1, r2), with




  
    r
    2
  
  =
  
    
      
        
          10
          ⁢
          
            
          
          ⁢
          k
        
        s
      
      ⁢
      
        
      
      ⁢
      and
      ⁢
      
        
      
      ⁢
      
        R
        2
      
    
    ∈
    
      R
      
        
          r
          2
        
        ×
        n
      
    
  




with rows of A.

R=[R1T, R2T]Tε(r2+r2)×n containing




  r
  =
  
    
      4
      ⁢
      k
    
    +
    
      
        10
        ⁢
        
          
        
        ⁢
        k
      
      s
    
  




rescaled rows of A.

(3) Construct U of rank k. This includes the operations of (3a).
(3a) Construct Uεc×r with rank at most k as follows, where the following formulas are equivalent:




  
    
      
        
          U
          =
          
            
              
                Ψ
                
                  -
                  1
                
              
              ⁢
              Δ
              ⁢
              
                
              
              ⁢
              
                D
                
                  -
                  1
                
              
              ⁢
              
                Z
                2
                T
              
              ⁢
              
                AR
                †
              
            
            =
            
            ⁢
            
              
                Ψ
                
                  -
                  1
                
              
              ⁢
              Δ
              ⁢
              
                
              
              ⁢
              
                
                  
                    D
                    
                      -
                      1
                    
                  
                  ⁡
                  
                    (
                    
                      C
                      ⁢
                      
                        
                      
                      ⁢
                      
                        Ψ
                        
                          -
                          1
                        
                      
                      ⁢
                      Δ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        D
                        
                          -
                          1
                        
                      
                    
                    )
                  
                
                T
              
              ⁢
              
                AR
                †
              
            
          
        
      
    
    
      
        
          =
          
          ⁢
          
            
              Ψ
              
                -
                1
              
            
            ⁢
            Δ
            ⁢
            
              
            
            ⁢
            
              
                
                  D
                  
                    -
                    1
                  
                
                ⁡
                
                  (
                  
                    C
                    ⁢
                    
                      
                    
                    ⁢
                    
                      Ψ
                      
                        -
                        1
                      
                    
                    ⁢
                    Δ
                    ⁢
                    
                      
                    
                    ⁢
                    
                      D
                      
                        -
                        1
                      
                    
                  
                  )
                
              
              †
            
            ⁢
            
              AR
              †
            
          
        
      
    
    
      
        
          =
          
          ⁢
          
            
              Ψ
              
                -
                1
              
            
            ⁢
            Δ
            ⁢
            
              
            
            ⁢
            
              D
              
                -
                1
              
            
            ⁢
            D
            ⁢
            
              
            
            ⁢
            
              Δ
              T
            
            ⁢
            Ψ
            ⁢
            
              
            
            ⁢
            
              C
              †
            
            ⁢
            
              AR
              †
            
          
        
      
    
    
      
        
          =
          
          ⁢
          
            
              Ψ
              
                -
                1
              
            
            ⁢
            
              ΔΔ
              T
            
            ⁢
            Ψ
            ⁢
            
              
            
            ⁢
            
              C
              †
            
            ⁢
            
              
                AR
                †
              
              .
            
          
        
      
    
  
   




Algorithm 4 may take as input an in m×n matrix A, rank parameter k<rank(A), and accuracy parameter 0<ε<1. These are also the inputs of the CUR Problem. The algorithm may return matrix Cεm×c with c=O(k/ε) columns of A, matrix Rεr×n with r=O(k/ε) rows of A, and matrix Uεc×r with rank at most k. Algorithm 4 may closely follow the CUR proto-algorithm of Algorithm 1. More particularly, Algorithm 4 may make specific choices for the various operations of the proto-algorithm that can be implemented deterministically in polynomial time.
In some embodiments, Algorithm 4 may run as follows: (1) An optimal number of columns may be selected in C. (2) An optimal number of rows may be selected in R. And (3) an intersection matrix with optimal rank may be constructed and denoted as U. The algorithm itself may integrate one or more other algorithms, including new algorithms as well as existing ones combined in a novel manner. Specifically, Algorithm 4 refers to DeterministicSVD, which is described in Theorem 3.1 in Ghashami (M. Ghashami and J. Phillips; Relative errors for deterministic low-rank matrix approximations; In SODA, 2013); BssSampling, which is described in Lemma 3.6 of Boutsidis; AdaptiveColsD, which is described in Lemma 5; BestSubspaceSVD, which is described in Clarkson II; and AdaptiveRowsD, which is described in Lemma 6.
FIG. 4 is a flow diagram of a method 400 for finding a deterministic CUR decomposition of a matrix A, using Algorithm 4, according to some embodiments of this disclosure. At a high level, matrix C may be constructed with O(k/ε) columns at block 410, matrix R may be constructed with O(k/ε) rows at block 420, and matrix U may be constructed from matrices C and R at block 430. The decomposition method 400 of FIG. 4 is similar to the decomposition method 200 of FIG. 2, except that, as shown at blocks 418 and 428, the adaptive sampling performed may be derandomized, as will be described further below.
It can be shown that the above algorithm runs in a total time of O(mn3k/ε).
With respect to error bounds, it can be further shown that matrices C, U, and R in Algorithm 4 satisfy,

∥A−CUR∥F2≦∥A−Ak∥F2+8ε∥A−Ak∥F2.

The above Algorithm 4 may include other algorithms, some of which exist in the art and some of which are newly provided in this disclosure. Below, those that are new are described in detail. As a starting point, below, a lemma is proven regarding derandomizing the adaptive sampling procedure of Deshpande II. The lemma offers a deterministic adaptive sampling algorithm used in the above deterministic CUR algorithm.
The following is referred to herein as Lemma 5: Given Aεm×n and Vεm×c1 (with c1≦n, m), let the residual be defined as

B=A−VV†Aεm×n.

There exists a deterministic algorithm to construct C2εm×c2 containing columns of A, such that C=[V C2]εm×(c2+c2) i.e., the matrix that contains the columns of V and C2, satisfies, for any integer k>0,





  
    
      
      
        A
        -
        
          
            ∏
            
              C
              ,
              k
            
            F
          
          ⁢
          
            
          
          ⁢
          
            (
            A
            )
          
        
      
      
    
    F
    2
  
  ≤
  
    
      
        
        
          A
          -
          
            A
            k
          
        
        
      
      F
      2
    
    +
    
      
        
          4
          ⁢
          k
        
        
          c
          2
        
      
      ⁢
      
        
          
            
            
              A
              -
              
                
                  VV
                  †
                
                ⁢
                A
              
            
            
          
          F
          2
        
        .
      
    
  




The above procedure is denoted as C2=AdaptiveColsD(A, V, c2). Given A and V, the algorithm requires O(mn3c) arithmetic operations to find C2. Here c=c1+c2.

Lemma 5 may be proven as follows: This lemma corresponds to a derandomization of Theorem 2.1 of Deshpande II. It suffices to derandomize Theorem 2.1 of Deshpande II, since the above lemma is equivalent to the theorem by taking transposes. This disclosure now switches to the notation to that of Deshpande II for the sake of clarity. In that theorem, E=A−AVVT, and a random sample S of s rows of A are chosen from a distribution p with

p1=∥E(t)∥22/∥E∥F2.

for each lε[m], and independently for each of the s trials. It will be understood that s corresponds to c.2 in the notation herein. It is shown in Deshpande II that if PPT is a projection operator onto the space spanned by the s sampled rows together with the rows of V, then there is a rank-k approximation to A, denoted AT, in the row space of P for which





  
    
      E
      S
    
    ⁢
    
      
        
        
          A
          -
          
            A
            ′
          
        
        
      
      P
      2
    
  
  ≤
  
    
      
        
        
          A
          -
          
            A
            k
          
        
        
      
      F
      2
    
    +
    
      
        k
        s
      
      ⁢
      
        
          
            
            E
            
          
          F
          2
        
        .
      
    
  




To derandomize Theorem 2.1 of Deshpande II, the distribution p is discretized, defining a new distribution q. Let l*ε[n] be such that pi≧pi for all i≠i*. Then, let




  
    
      r
      
        i
        *
      
    
    =
    
      
        p
        
          i
          *
        
      
      +
      
        
          ∑
          
            i
            ≠
            
              i
              *
            
          
        
        ⁢
        
          
            p
            i
          
          /
          2
        
      
    
  
  ;




hence, r is a distribution. Round each rpi≠i*, up to the nearest integer multiple of 1/(4n) by adding yi, and let qi be the resulting value. For qi*, let qi*=ri*−Σε1=ε*Yi. Then Σiqi=1 and 0≦qi≦1 for all i. Consider qi*. Then,





  
    0
    ≤
    
      
        ∑
        
          i
          ≠
          
            i
            *
          
        
      
      ⁢
      
        γ
        i
      
    
    <=
    
      n
      *
      
        (
        
          1
          /
          
            (
            
              4
              ⁢
              n
            
            )
          
        
        )
      
    
  
  =
  
    1
    /
    4.
  




On the other hand




  
    r
    
      i
      *
    
  
  =
  
    
      
        
          p
          
            i
            *
          
        
        +
        
          
            ∑
            
              i
              ≠
              
                i
                *
              
            
          
          ⁢
          
            
              p
              i
            
            /
            2
          
        
      
      ≥
      
        
          ∑
          i
        
        ⁢
        
          
            p
            i
          
          /
          2
        
      
    
    =
    
      1
      /
      2.
    
  




Hence qi*ε[0,1] as well. Hence q is a distribution. It should be noted that, for all i≠i*, qi≧ri≧pi/2. Moreover, qi*≧ri*−1/4≧1/4, so qi*≧pi*/4. Thus, all qi are within a factor of 4 from piqi≧pi/4.
Following, as compared to the proof of Theorem 2.1 of Deshpande distribution p is replaced with q. As in the proof of Deshpande II, vectors w(1), . . . , w(k) are defined in the column span of P such that there exists a rank-k approximation to A, denoted A1, whose rows are spanned by these vectors and for which




  
    
      E
      S
    
    ⁢
    
      
        
        
          A
          -
          
            A
            ′
          
        
        
      
      P
      2
    
  
  ≤
  
    
      
        
        
          A
          -
          
            A
            k
          
        
        
      
      F
      2
    
    +
    
      
        k
        s
      
      ⁢
      
        
          
            
            E
            
          
          F
          2
        
        .
      
    
  




This suffices to prove the theorem.
Define




  
    
      X
      l
      
        (
        j
        )
      
    
    =
    
      
        
          u
          i
          
            (
            j
            )
          
        
        ⁢
        
          E
          
            (
            i
            )
          
        
      
      
        q
        i
      
    
  
  ,




with probability qi, where lε[s] and lε[m], E(1) denotes the i-th row of E, and u(j) is the j-th left singular vector of A. As in the proof of Deshpande II, define




  
    X
    
      (
      j
      )
    
  
  =
  
    
      1
      s
    
    ⁢
    
      
        ∑
        
          l
          =
          1
        
        s
      
      ⁢
      
        
          X
          l
          
            (
            j
            )
          
        
        .
      
    
  




In that case, Es[X(j)]=ETu(j). Define w(j)=VVTATu(j)+X(j), so that Es[w(j)]=σjv(j), where σj is the j-th singular value of A, and v(j) the j-th right singular vector. The same calculation as in Equations 2.4 and 2.5 of the proof of Deshpande II gives





  
    
      
        E
        S
      
      ⁢
      
        
          
          
            
              w
              
                (
                j
                )
              
            
            -
            
              
                σ
                j
              
              ⁢
              
                v
                
                  (
                  j
                  )
                
              
            
          
          
        
        2
      
    
    =
    
      
        
          1
          
            s
            2
          
        
        ⁢
        
          
            ∑
            
              l
              =
              1
            
            s
          
          ⁢
          
            E
            ⁡
            
              [
              
                
                  
                  
                    X
                    l
                    
                      (
                      j
                      )
                    
                  
                  
                
                2
              
              ]
            
          
        
      
      -
      
        
          1
          s
        
        ⁢
        
          
            
            
              
                E
                T
              
              ⁢
              
                u
                
                  (
                  j
                  )
                
              
            
            
          
          2
        
      
    
  
  ,




as in Equation 2.6 of Deshpande II, where pairwise independence suffices for this aspect.

Based on the above, it is given that




  
    
      
        
          
            E
            S
          
          ⁢
          
            
              
              
                X
                l
                
                  (
                  j
                  )
                
              
              
            
            2
            2
          
        
        =
        
        ⁢
        
          
            ∑
            
              i
              =
              1
            
            m
          
          ⁢
          
            
              q
              i
            
            ⁢
            
              
                
                  
                  
                    
                      u
                      i
                      
                        (
                        j
                        )
                      
                    
                    ⁢
                    
                      E
                      
                        (
                        i
                        )
                      
                    
                  
                  
                
                2
              
              
                q
                i
                2
              
            
          
        
      
    
  
  
    
      
        ≤
        
        ⁢
        
          
            
              
                
                
                  
                    u
                    
                      i
                      *
                    
                    
                      (
                      j
                      )
                    
                  
                  ⁢
                  
                    E
                    
                      (
                      
                        i
                        *
                      
                      )
                    
                  
                
                
              
              2
              2
            
            
              
                1
                4
              
              ⁢
              
                
                  
                    
                    
                      E
                      
                        (
                        
                          i
                          *
                        
                        )
                      
                    
                    
                  
                  2
                  2
                
                
                  
                    
                    E
                    
                  
                  F
                  2
                
              
            
          
          +
          
            
              ∑
              
                i
                ≠
                
                  i
                  *
                
              
            
            ⁢
            
              
                
                  
                  
                    
                      u
                      i
                      
                        (
                        j
                        )
                      
                    
                    ⁢
                    
                      E
                      
                        (
                        i
                        )
                      
                    
                  
                  
                
                2
                2
              
              
                
                  
                    
                    
                      E
                      
                        (
                        i
                        )
                      
                    
                    
                  
                  2
                  2
                
                
                  
                    
                    E
                    
                  
                  F
                  2
                
              
            
          
        
      
    
  
  
    
      
        ≤
        
        ⁢
        
          4
          ⁢
          
            
              
                
                E
                
              
              F
              2
            
            .
          
        
      
    
  




This is a slightly weaker upper bound than using distribution p, which Deshpande II shows in its Equation 2.8




  
    
      E
      S
    
    ⁢
    
      
        
        
          X
          l
          
            (
            j
            )
          
        
        
      
      2
      2
    
  
  ≤
  
    
      
        
        E
        
      
      F
      2
    
    .
  




The constant 4 makes little difference for this disclosure purposes, while the fact that q is discrete assists with derandomization.

Equation 2.8 of Deshpande II changes to




  
    
      E
      S
    
    ⁢
    
      
        
        
          
            w
            
              (
              j
              )
            
          
          -
          
            
              σ
              j
            
            ⁢
            
              v
              
                (
                j
                )
              
            
          
        
        
      
      2
    
  
  ≤
  
    
      4
      s
    
    ⁢
    
      
        
          
          E
          
        
        F
        2
      
      .
    
  




The rest of the proof is as in Deshpande II, showing that, if PPT is a projection operator onto the space spanned by the s sampled rows together with the columns of V, then there is a rank-k approximation of A, denoted A1 in the column space of P for which





  
    
      E
      S
    
    ⁢
    
      
        
        
          A
          -
          
            A
            ′
          
        
        
      
      P
      2
    
  
  ≤
  
    
      
        
        
          A
          -
          
            A
            k
          
        
        
      
      F
      2
    
    +
    
      
        
          4
          ⁢
          k
        
        s
      
      ⁢
      
        
          
            
            E
            
          
          P
          2
        
        .
      
    
  




In particular there exists a choice of S for which, for the corresponding A1 it is the case that




  
    
      
      
        A
        -
        
          A
          ′
        
      
      
    
    P
    2
  
  ≤
  
    
      
        
        
          A
          -
          
            A
            k
          
        
        
      
      F
      2
    
    +
    
      
        
          4
          ⁢
          k
        
        s
      
      ⁢
      
        
          
            
            E
            
          
          F
          2
        
        .
      
    
  




Distribution q is a discrete distribution, and the trials need only be pairwise independent. Let h:[c2]→[4n] be drawn from a pairwise-independent hash function family F. In that case, F need only have size O(n2), as described in Carter (L. Carter and M. N. Wegman; Universal classes of hash functions. J. Comput. Syst. Sci., 18(2):143-154, 1979). For each trial lε[s], h(l) is computed. Since the probabilities qi, where i=1, . . . , n, are integer multiples of 1/(4n) and Σiql=1, the largest iΣ[n] for which h(l)/(4n)≦Σi*=1iq1 is selected. The probability of picking i in each trial is therefore qi. For each hεF, the corresponding sample set s is computed, along with the best rank-k approximation A1 of A in the space spanned by the s sampled rows together with the rows of V. ∥A−A1∥F is then computed. The S with the smallest such value is chosen. Computing this value can be done in O(mn(c1+c2)+n(c1+c2)2+mn) time, and since |F|=O(n2), the overall time is O(mn3(c1+c2)).
Following is a proof for a lemma derandomizing the recent row/column adaptive sampling method of Wang, which is stated in Theorem 4 therein. The following lemma in general does not necessarily imply the previous lemma due to the fact that the previous lemma concerned approximating A by a rank-k matrix, whereas the following lemma concerns approximating A by a matrix of rank ρ, which is in general different than k. By setting V=Ak and getting the transpose version of the result, one gets only a version of the previous lemma with A−CC†A in the left hand side. Nevertheless, the derandomization arguments are similar.
The following is referred to herein as Lemma 6: Given Aεm×n and Vεm×c, such that

rank(V)=rank(VV†A)=ρ,

with ρ≦c≦n, let R1εrs×n contain r1 rows of A. There exists a deterministic algorithm to construct R2εrs×n with r2 rows such that for R=[R1T, R2T]Tε(rs+rs)×n, it is the case that





  
    
      
      
        A
        -
        
          
            VV
            †
          
          ⁢
          
            AR
            †
          
          ⁢
          R
          ⁢
          
            
              
              F
              2
            
            
          
          ⁢
          A
        
        -
        
          
            VV
            †
          
          ⁢
          A
        
      
      
    
    F
    2
  
  +
  
    
      
        4
        ⁢
        ρ
      
      
        r
        2
      
    
    ⁢
    
      
        
          
          
            A
            -
            
              
                AR
                1
                †
              
              ⁢
              
                R
                1
              
            
          
          
        
        F
        2
      
      .
    
  




The above procedure is denoted herein as R2=AdaptiveRowsD(A, V, R1, r2). Given A, V, and R1, it takes O(n2(mc2+nr2+mnc+mnr)) time to find R2. Here c=c1+c2, r=r1+r2.

Lemma 6 may be proven as follows: This lemma corresponds to a derandomization of Theorem 5 of Wang. The matrix C in the proof of Wang corresponds to the matrix V herein. Despite the notation of Wang, as that reference states in its theorem statement and proves, the matrix C need not be a subset of columns of A. To prove the theorem, Wang actually restates it as Theorem 15 in that paper, switching the role of rows and columns, which will now be derandomized herein. Lemma 6 herein follows by taking transposes.
In that theorem of Wang, the authors define a distribution p on n columns b1, . . . , bn where B=A−C1C1†A for a matrix C1εm×c1 having c1 columns of A. In their, proof they show that, for pi=∥bi∥22/∥B∥F2, if one samples c2 columns of A in independent and identically distributed trials, where in each trial the i-th column is chosen with probability pi, then if C2εm×cs has the c2 sampled columns, and C=[C1, C2]εm×(c2+c2), then




  
    
      E
      
        C
        2
      
    
    ⁢
    
      
        
        
          A
          -
          
            
              CC
              †
            
            ⁢
            
              AR
              †
            
            ⁢
            R
          
        
        
      
      F
      2
    
  
  ≤
  
    
      
        
        
          A
          -
          
            
              AR
              †
            
            ⁢
            R
          
        
        
      
      F
      2
    
    +
    
      
        ρ
        
          c
          2
        
      
      ⁢
      
        
          
            
            
              A
              -
              
                
                  C
                  1
                
                ⁢
                
                  C
                  1
                  †
                
                ⁢
                A
              
            
            
          
          F
          2
        
        .
      
    
  




To derandomize Theorem 5 of Wang, this disclosure discretizes the distribution p, defining a new distribution q. Let i*ε[n] be such that pl*≧pi for all i≠l*. Then, let




  
    
      r
      
        i
        *
      
    
    =
    
      
        p
        
          i
          *
        
      
      +
      
        
          ∑
          
            i
            =
            
              i
              *
            
          
        
        ⁢
        
          
            p
            i
          
          /
          2
        
      
    
  
  ;




hence, r is a distribution. Round each ri, i≠i*, up to the nearest integer multiple of 1/(4n) by adding yi, and let qi be the resulting value. For qi*, let qi*=ri*−Σii=ε*Yi. It follows that Σiqi=1 and 0≦qi≦1 for all l. When qi* is considered, then 0≦Σi≠i*Yi<=n*(1/(4n))=1/4. On the other hand, ri*=pi*+Σi≠i*p1/2≧Σ1p1/2 ==1/2. Hence, qi*ε[0,1] as well. Thus, q is a distribution. For all i≠i*, q1≧ri≧p1/2. Moreover, qi*≧ri*−1/4≧1/4, so qi*≧pi*/4. Therefore, all qi are within a factor of 4 from piqi≧pi/4.

Follow the argument in the proof of Theorem 15 of Wang, distribution p is replaced with q below, pointing out the differences. Fefine the random variable




  
    
      x
      
        j
        ,
        
          (
          l
          )
        
      
    
    =
    
      
        
          v
          
            i
            ,
            j
          
        
        
          q
          i
        
      
      ⁢
      
        b
        i
      
    
  
  ,




where vi,j is the (i,j)-th entry of VAR\R,pεn×p, where VAR\R,pεn×p denotes the matrix of the top p right singular vectors of AR\R. It is the case that




  
    [
    
      x
      
        j
        ,
        
          (
          l
          )
        
      
    
    ]
  
  =
  
    
      
        ∑
        
          i
          =
          1
        
        n
      
      ⁢
      
        
          q
          i
        
        ⁢
        
          
            v
            
              i
              ,
              j
            
          
          
            q
            i
          
        
        ⁢
        
          b
          i
        
      
    
    =
    
      
        Bv
        j
      
      .
    
  




Moreover,




  
    E
    ⁢
    
      
        
        
          x
          
            j
            ,
            
              (
              l
              )
            
          
        
        
      
      2
      2
    
  
  =
  
    
      
        ∑
        
          i
          =
          1
        
        n
      
      ⁢
      
        
          q
          i
        
        ⁢
        
          
            v
            
              i
              ,
              j
            
            2
          
          
            q
            i
            2
          
        
        ⁢
        
          
            
            
              b
              i
            
            
          
          2
          2
        
      
    
    ≤
    
      
        
          
            v
            
              
                i
                *
              
              ,
              j
            
            2
          
          ⁢
          
            
              
              
                b
                
                  i
                  *
                
              
              
            
            2
            2
          
        
        
          
            
              
              
                b
                
                  i
                  *
                
              
              
            
            2
          
          
            4
            ⁢
            
              
                
                B
                
              
              F
              2
            
          
        
      
      +
      
        
          ∑
          
            i
            ≠
            
              i
              *
            
          
        
        ⁢
        
          
            
              v
              
                i
                ,
                j
              
              2
            
            ⁢
            
              
                
                
                  b
                  i
                
                
              
              2
              2
            
          
          
            
              
                
                
                  b
                  
                    i
                    *
                  
                
                
              
              2
            
            
              
                
                B
                
              
              F
              2
            
          
        
      
    
    ≤
    
      4
      ⁢
      
        
          
            
            B
            
          
          F
          2
        
        .
      
    
  




This is slightly weaker than the corresponding upper bound of E∥xj,(l)∥22≦∥B∥F2 shown for distribution p in Wang, but the constant 4 makes little difference for the purposes of this disclosure, while the fact that q is discrete assists with derandomization.
Let




  
    x
    j
  
  =
  
    
      1
      
        c
        2
      
    
    ⁢
    
      
        ∑
        
          l
          =
          1
        
        
          c
          2
        
      
      ⁢
      
        
          x
          
            j
            ,
            
              (
              l
              )
            
          
        
        .
      
    
  




By linearity of expectation, E[xj]=E[xj,(l)]=Bvj.
In bounding E∥xj−Bvj∥22, pairwise independence of the trials is enough to bound this quantity:




  
    E
    ⁢
    
      
        
        
          
            x
            j
          
          -
          
            Bv
            j
          
        
        
      
      2
      2
    
  
  =
  
    
      E
      ⁢
      
        
          
          
            
              x
              j
            
            -
            
              E
              ⁡
              
                [
                
                  x
                  j
                
                ]
              
            
          
          
        
        2
        =
      
      ⁢
      
        1
        
          c
          2
        
      
      ⁢
      E
      ⁢
      
        
          
          
            
              x
              
                j
                ,
                
                  (
                  l
                  )
                
              
            
            -
            
              E
              ⁡
              
                [
                
                  x
                  
                    j
                    ,
                    
                      (
                      l
                      )
                    
                  
                
                ]
              
            
          
          
        
        2
        2
      
    
    =
    
      
        1
        
          c
          2
        
      
      ⁢
      E
      ⁢
      
        
          
          
            
              x
              
                j
                ,
                
                  (
                  l
                  )
                
              
            
            -
            
              Bv
              j
            
          
          
        
        2
        2
      
    
  




(referred to herein as Equation 4), where the second equality uses pairwise-independence, as it corresponds to the sum of the variances being the variance of the sum.

The remainder of the proof of Theorem 15 in Wang only uses their slightly stronger bound, as compared to Equation 4 herein. With the weaker bound herein, Wang would obtain




  
    
      E
      
        C
        2
      
    
    ⁢
    
      
        
        
          A
          -
          
            
              CC
              †
            
            ⁢
            
              AR
              †
            
            ⁢
            R
          
        
        
      
      F
      2
    
  
  ≤
  
    
      
        
        
          A
          -
          
            
              AR
              †
            
            ⁢
            R
          
        
        
      
      F
      2
    
    +
    
      
        
          4
          ⁢
          ρ
        
        
          c
          2
        
      
      ⁢
      
        
          
            
            B
            
          
          F
          2
        
        .
      
    
  




whereas the bound of Wang would not have the factor of 4. In particular, there exists a choice of C2 for which, for the corresponding C, it is the case that





  
    
      
      
        A
        -
        
          
            CC
            †
          
          ⁢
          
            AR
            †
          
          ⁢
          R
        
      
      
    
    F
    2
  
  <
  
    
      
        
        
          A
          -
          
            
              AR
              †
            
            ⁢
            R
          
        
        
      
      F
      2
    
    +
    
      
        
          4
          ⁢
          ρ
        
        
          c
          2
        
      
      ⁢
      
        
          
            
            B
            
          
          F
          2
        
        .
      
    
  




Distribution q is a discrete distribution, and the trials need only be pairwise independent. Let h:[c2]→[4n] be drawn from a pairwise-independent hash function family F. Then F need only have size O(n2), as described in Carter. For each trial lε[c2], compute h(l) is computed. Since the probabilities qi, for 1, . . . , n, are integer multiples of 1/(4n) and Σiq1=1, the largest iε[n] for which h(l)/(4n)≦Σl*=1iqi is selected. The probability of picking i in the each trial is therefore qi. For each hεF, the corresponding column samples C2 is computed, along with ∥A−CC†AR†R∥F2. The C2 resulting in the smallest such value may be chosen.
Computing this value can be done in O(mc2+nr2+mnr+mnc+mn) time, and since |F|=O(n2), the overall time is O(n2(mc2+nr2+mnr+mnc)). Here c=c1+c2, r=r1+r2.
FIG. 5 illustrates a block diagram of a computer system 500 for use in implementing a decomposition system 100 or method according to some embodiments. The decomposition systems 100 and methods described herein may be implemented in hardware, software (e.g., firmware), or a combination thereof. In an exemplary embodiment, the methods described may be implemented, at least in part, in hardware and may be part of the microprocessor of a special or general-purpose computer system 500, such as a personal computer, workstation, minicomputer, or mainframe computer.
In an exemplary embodiment, as shown in FIG. 5, the computer system 500 includes a processor 505, memory 510 coupled to a memory controller 515, and one or more input devices 545 and/or output devices 540, such as peripherals, that are communicatively coupled via a local I/O controller 535. These devices 540 and 545 may include, for example, a printer, a scanner, a microphone, and the like. A conventional keyboard 550 and mouse 555 may be coupled to the I/O controller 535. The I/O controller 535 may be, for example, one or more buses or other wired or wireless connections, as are known in the art. The I/O controller 535 may have additional elements, which are omitted for simplicity, such as controllers, buffers (caches), drivers, repeaters, and receivers, to enable communications.
The I/O devices 540, 545 may further include devices that communicate both inputs and outputs, for instance disk and tape storage, a network interface card (NIC) or modulator/demodulator (for accessing other files, devices, systems, or a network), a radio frequency (RF) or other transceiver, a telephonic interface, a bridge, a router, and the like.
The processor 505 is a hardware device for executing hardware instructions or software, particularly those stored in memory 510. The processor 505 may be any custom made or commercially available processor, a central processing unit (CPU), an auxiliary processor among several processors associated with the computer system 500, a semiconductor based microprocessor (in the form of a microchip or chip set), a macroprocessor, or other device for executing instructions. The processor 505 includes a cache 570, which may include, but is not limited to, an instruction cache to speed up executable instruction fetch, a data cache to speed up data fetch and store, and a translation lookaside buffer (TLB) used to speed up virtual-to-physical address translation for both executable instructions and data. The cache 570 may be organized as a hierarchy of more cache levels (L1, L2, etc.).
The memory 510 may include any one or combinations of volatile memory elements (e.g., random access memory, RAM, such as DRAM, SRAM, SDRAM, etc.) and nonvolatile memory elements (e.g., ROM, erasable programmable read only memory (EPROM), electronically erasable programmable read only memory (EEPROM), programmable read only memory (PROM), tape, compact disc read only memory (CD -ROM), disk, diskette, cartridge, cassette or the like, etc.). Moreover, the memory 510 may incorporate electronic, magnetic, optical, or other types of storage media. Note that the memory 510 may have a distributed architecture, where various components are situated remote from one another but may be accessed by the processor 505.
The instructions in memory 510 may include one or more separate programs, each of which comprises an ordered listing of executable instructions for implementing logical functions. In the example of FIG. 5, the instructions in the memory 510 include a suitable operating system (OS) 511. The operating system 511 essentially may control the execution of other computer programs and provides scheduling, input-output control, file and data management, memory management, and communication control and related services.
Additional data, including, for example, instructions for the processor 505 or other retrievable information, may be stored in storage 520, which may be a storage device such as a hard disk drive or solid state drive. The stored instructions in memory 510 or in storage 520 may include those enabling the processor to execute one or more aspects of the decomposition systems 100 and methods of this disclosure.
The computer system 500 may further include a display controller 525 coupled to a display 530. In an exemplary embodiment, the computer system 500 may further include a network interface 560 for coupling to a network 565. The network 565 may be an IP-based network for communication between the computer system 500 and any external server, client and the like via a broadband connection. The network 565 transmits and receives data between the computer system 500 and external systems. In an exemplary embodiment, the network 565 may be a managed IP network administered by a service provider. The network 565 may be implemented in a wireless fashion, e.g., using wireless protocols and technologies, such as WiFi, WiMax, etc. The network 565 may also be a packet-switched network such as a local area network, wide area network, metropolitan area network, the Internet, or other similar type of network environment. The network 565 may be a fixed wireless network, a wireless local area network (LAN), a wireless wide area network (WAN) a personal area network (PAN), a virtual private network (VPN), intranet or other suitable network system and may include equipment for receiving and transmitting signals.
Decomposition systems 100 and methods according to this disclosure may be embodied, in whole or in part, in computer program products or in computer systems 500, such as that illustrated in FIG. 5.
The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention. As used herein, the singular forms “a”, “an” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises” and/or “comprising,” when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof
The corresponding structures, materials, acts, and equivalents of all means or step plus function elements in the claims below are intended to include any structure, material, or act for performing the function in combination with other claimed elements as specifically claimed. The description of the present invention has been presented for purposes of illustration and description, but is not intended to be exhaustive or limited to the invention in the form disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the invention. The embodiments were chosen and described in order to best explain the principles of the invention and the practical application, and to enable others of ordinary skill in the art to understand the invention for various embodiments with various modifications as are suited to the particular use contemplated.
The present invention may be a system, a method, and/or a computer program product. The computer program product may include a computer readable storage medium (or media) having computer readable program instructions thereon for causing a processor to carry out aspects of the present invention.
The computer readable storage medium can be a tangible device that can retain and store instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of the computer readable storage medium includes the following: a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), a static random access memory (SRAM), a portable compact disc read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanically encoded device such as punch-cards or raised structures in a groove having instructions recorded thereon, and any suitable combination of the foregoing. A computer readable storage medium, as used herein, is not to be construed as being transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission media (e.g., light pulses passing through a fiber-optic cable), or electrical signals transmitted through a wire.
Computer readable program instructions described herein can be downloaded to respective computing/processing devices from a computer readable storage medium or to an external computer or external storage device via a network, for example, the Internet, a local area network, a wide area network and/or a wireless network. The network may comprise copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers and/or edge servers. A network adapter card or network interface in each computing/processing device receives computer readable program instructions from the network and forwards the computer readable program instructions for storage in a computer readable storage medium within the respective computing/processing device.
Computer readable program instructions for carrying out operations of the present invention may be assembler instructions, instruction-set-architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, firmware instructions, state-setting data, or either source code or object code written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C++ or the like, and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The computer readable program instructions may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGA), or programmable logic arrays (PLA) may execute the computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry, in order to perform aspects of the present invention.
Aspects of the present invention are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer readable program instructions.
These computer readable program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. These computer readable program instructions may also be stored in a computer readable storage medium that can direct a computer, a programmable data processing apparatus, and/or other devices to function in a particular manner, such that the computer readable storage medium having instructions stored therein comprises an article of manufacture including instructions which implement aspects of the function/act specified in the flowchart and/or block diagram block or blocks.
The computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus or other device to produce a computer implemented process, such that the instructions which execute on the computer, other programmable apparatus, or other device implement the functions/acts specified in the flowchart and/or block diagram block or blocks.
The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts or carry out combinations of special purpose hardware and computer instructions.
The descriptions of the various embodiments of the present invention have been presented for purposes of illustration, but are not intended to be exhaustive or limited to the embodiments disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terminology used herein was chosen to best explain the principles of the embodiments, the practical application or technical improvement over technologies found in the marketplace, or to enable others of ordinary skill in the art to understand the embodiments disclosed herein.

## Claims

1. A computer-implemented method for reducing storage space occupied by a matrix A, the computer-implemented method comprising:
constructing, by a first hardware circuit, a matrix C based on the matrix A, wherein the constructing the matrix C based on the matrix A comprises:
computing Z1 as the top k singular vectors of A, wherein a scalar k is a target rank of a matrix U and is selected to be less than the rank of the matrix A, wherein Ak is a rank-k approximation of the matrix A, wherein a scalar ε is between 0 and 1 and represents a selected accuracy parameter, and wherein ∥A−AZ1Z1T∥F2≦(1+ε)∥A−Ak∥F2;
sampling O(k log k) columns from the transpose of Z1, wherein the sampling uses leverage scores;
down-sampling the sampled columns to C1 comprising c1=O(k) columns, wherein ∥A C1C1†∥F2≦O(1)∥A AZ1Z1T∥F2; and
adaptively sampling c2=O(k/ε) columns of A, wherein






  
    
      
        
        
          A
          -
          
            C
            ·
            D
          
        
        
      
      F
      2
    
    ≤
    
      
        
          
          
            A
            -
            
              A
              k
            
          
          
        
        F
        2
      
      +
      
        
          (
          
            k
            
              c
              2
            
          
          )
        
        ⁢
        
          
            
            
              A
              -
              
                
                  C
                  1
                
                ⁢
                
                  C
                  1
                  †
                
                ⁢
                A
              
            
            
          
          F
          2
        
      
    
  
  ,




wherein D is selected to be a rank-k matrix;
constructing, by a second hardware circuit distinct from the first hardware circuit, a matrix R based on the matrix A and the matrix C;
constructing, by a third hardware circuit distinct from the first hardware circuit and the second hardware circuit, the matrix U based on the matrices A, C, and R;
wherein the matrices C, U, and R comprise a CUR decomposition of the matrix A;
reducing storage space occupied by the matrix A by replacing the matrix A with the matrices C, U, and R.

2. The method of claim 1, wherein the constructing the matrix R based on the matrix A and the matrix C comprises:




  
    
      
        
        
          Λ
          -
          
            Λ
            ⁢
            
              
            
            ⁢
            
              Z
              1
            
            ⁢
            
              Z
              1
              T
            
          
        
        
      
      F
      2
    
    ≤
    
      
        (
        
          1
          +
          ɛ
        
        )
      
      ⁢
      
        
          
          
            Λ
            -
            
              Λ
              R
            
          
          
        
        F
        2
      
      ⁢
      
        
          
          
            A
            -
            
              
                C
                1
              
              ⁢
              
                C
                1
                †
              
            
          
          
        
        F
        2
      
    
    ≤
    
      
        O
        ⁡
        
          (
          1
          )
        
      
      ⁢
      
        
          
          
            A
            -
            
              
                AZ
                1
              
              ⁢
              
                Z
                1
                T
              
            
          
          
        
        F
        2
      
      ⁢
      
        
          
          
            A
            -
            
              C
              ·
              D
            
          
          
        
        F
        2
      
    
    ≤
    
      
        
          
          
            A
            -
            
              A
              k
            
          
          
        
        F
        2
      
      +
      
        
          (
          
            k
            
              c
              2
            
          
          )
        
        ⁢
        
          
            
            
              A
              -
              
                
                  C
                  1
                
                ⁢
                
                  C
                  1
                  †
                
                ⁢
                A
              
            
            
          
          F
          2
        
      
    
  
  ;




and finding Z2 in the span of the matrix C, wherein ∥Λ−ΛZ2Z2T∥F2≦(1+ε)∥Λ−Λk∥F2;
sampling O(k log k) rows of Z2, wherein the sampling uses leverage scores;
down-sampling the sampled rows to R1 comprising r1=O(k) columns using BSS sampling, wherein ∥A R1R1†∥F2≦O(1)∥A AZ2Z2TA∥F2; and
adaptively sampling r2=O(k/ε) rows of A, wherein





  
    
      
      
        A
        -
        
          
            Z
            2
          
          ⁢
          
            Z
            2
            T
          
          ⁢
          
            AR
            †
          
          ⁢
          R
        
      
      
    
    F
    2
  
  ≤
  
    
      
        
        
          A
          -
          
            
              Z
              2
            
            ⁢
            
              Z
              2
              T
            
            ⁢
            A
          
        
        
      
      F
      2
    
    +
    
      
        rank
        (
        
          
            
              Z
              1
            
            ⁢
            
              Z
              2
              T
            
            ⁢
            A
          
          
            r
            2
          
        
        )
      
      ⁢
      
        
          
            
            
              A
              -
              
                
                  AR
                  1
                
                ⁢
                
                  R
                  1
                  †
                
              
            
            
          
          F
          2
        
        .

3. The method of claim 2, further comprising projecting one or more columns of the matrix A*W onto the matrix C, wherein the matrix W is a random subspace embedding.

4. The method of claim 2, wherein:
down-sampling the sampled columns to C1 comprising c1=O(k) columns using BSS sampling uses an input-sparsity-time BSS sampling algorithm;
adaptively sampling c2=O(k/ε) columns of A occurs in input-sparsity time;
down-sampling the sampled rows to R1 comprising r1=O(k) columns using BSS sampling uses the input-sparsity-time BSS sampling algorithm;
adaptively sampling r2=O(k/ε) rows of A occurs in input-sparsity time; and
constructing the matrix U based on the matrices A, C, and R is performed in input -sparsity time.

5. The method of claim 4, wherein the construction of the matrices C, U, and R occurs in input-sparsity time.

6. The method of claim 2, wherein:
adaptively sampling c2=O(k/ε) columns of A comprises derandomization; and
adaptively sampling r2=O(k/ε) rows of A comprises derandomization.

7. The method of claim 6, wherein the construction of the matrices C, U, and R comprises a deterministic CUR decomposition.

8. A system for reducing storage space occupied by a matrix A, the system comprising:
a memory; and
one or more processors, communicatively coupled to the memory, the one or more processors configured to:
construct, by a first hardware circuit, a matrix C based on the matrix A, wherein the constructing the matrix C based on the matrix A comprises:
computing Z1 as the top k singular vectors of A, wherein a scalar k is a target rank of a matrix U and is selected to be less than the rank of the matrix A, wherein Ak is a rank-k approximation of the matrix A, wherein a scalar ε is between 0 and 1 and represents a selected accuracy parameter, and wherein ∥A−AZ1Z1T∥F2≦(1+ε)∥A−Ak∥F2;
sampling O(k log k) columns from the transpose of Z1, wherein the sampling uses leverage scores;
down-sampling the sampled columns to C1 comprising c1=O(k) columns, wherein ∥A C1C1†∥F2≦O(1)∥A AZ1Z1T∥F2; and
adaptively sampling c2=O(k/ε) columns of A, wherein







  
    
      
        
        
          A
          -
          
            C
            ·
            D
          
        
        
      
      F
      2
    
    ≤
    
      
        
          
          
            A
            -
            
              A
              k
            
          
          
        
        F
        2
      
      +
      
        
          (
          
            k
            
              c
              2
            
          
          )
        
        ⁢
        
          
            
            
              A
              -
              
                
                  C
                  1
                
                ⁢
                
                  C
                  1
                  †
                
                ⁢
                A
              
            
            
          
          F
          2
        
      
    
  
  ,




 wherein D is selected to be a rank-k matrix;

construct, by a second hardware circuit distinct from the first hardware circuit, a matrix R based on the matrix A and the matrix C; and
construct, by a third hardware circuit distinct from the first hardware circuit and the second hardware circuit, the matrix U based on the matrices A, C, and R;
wherein the matrices C, U, and R comprise a CUR decomposition of the matrix A; and
reduce storage space occupied by the matrix A by replacing the matrix A with the matrices C, U, and R.

9. The system of claim 8, wherein to construct the matrix R based on the matrix A and the matrix C, the one or more processors are further configured to:




  
    
      
        
        
          Λ
          -
          
            Λ
            ⁢
            
              
            
            ⁢
            
              Z
              1
            
            ⁢
            
              Z
              1
              T
            
          
        
        
      
      F
      2
    
    ≤
    
      
        (
        
          1
          +
          c
        
        )
      
      ⁢
      
        
          
          
            Λ
            -
            
              Λ
              k
            
          
          
        
        F
        2
      
      ⁢
      
        
          
          
            A
            -
            
              
                C
                1
              
              ⁢
              
                C
                1
                l
              
            
          
          
        
        F
        2
      
    
    ≤
    
      
        O
        ⁡
        
          (
          1
          )
        
      
      ⁢
      
        
          
          
            A
            -
            
              A
              ⁢
              
                
              
              ⁢
              
                Z
                1
              
              ⁢
              
                Z
                1
                T
              
            
          
          
        
        F
        2
      
      ⁢
      
        
          
          
            A
            -
            
              C
              ·
              D
            
          
          
        
        F
        2
      
    
    ≤
    
      
        
          
          
            A
            -
            
              A
              k
            
          
          
        
        F
        2
      
      +
      
        
          (
          
            k
            
              c
              2
            
          
          )
        
        ⁢
        
          
            
            
              A
              -
              
                
                  C
                  1
                
                ⁢
                
                  C
                  1
                  †
                
                ⁢
                A
              
            
            
          
          F
          2
        
      
    
  
  ;




and find Z2 in the span of the matrix C, wherein ∥Λ−ΛZ2Z2T∥F2≦(1+ε)∥Λ−Λk∥F2;
sample O(k log k) rows of Z2, wherein the sampling uses leverage scores;
down-sample the sampled rows to R1 comprising r1=O(k) columns using BSS sampling, wherein ∥A−R1R1l∥F2≦O(1)∥A−AZ2Z2TA∥F2; and
adaptively sample r2=O(k/ε) rows of A, wherein





  
    
      
      
        A
        -
        
          
            Z
            2
          
          ⁢
          
            Z
            2
            T
          
          ⁢
          
            AR
            †
          
          ⁢
          R
        
      
      
    
    F
    2
  
  ≤
  
    
      
        
        
          A
          -
          
            
              Z
              2
            
            ⁢
            
              Z
              2
              T
            
            ⁢
            A
          
        
        
      
      F
      2
    
    +
    
      
        rank
        (
        
          
            
              Z
              1
            
            ⁢
            
              Z
              2
              T
            
            ⁢
            A
          
          
            r
            2
          
        
        )
      
      ⁢
      
        
          
            
            
              A
              -
              
                
                  AR
                  1
                
                ⁢
                
                  R
                  1
                  †
                
              
            
            
          
          F
          2
        
        .

10. The system of claim 9, wherein the one or more processors are further configured to project one or more columns of the matrix A*W onto the matrix C, and wherein the matrix W is a random subspace embedding.

11. The system of claim 9, wherein:
down-sampling the sampled columns to C1 comprising c1=O(k) columns using BSS sampling uses an input-sparsity-time BSS sampling algorithm;
adaptively sampling c2=O(k/ε) columns of A occurs in input-sparsity time;
down-sampling the sampled rows to R1 comprising r1=O(k) columns using BSS sampling uses the input-sparsity-time BSS sampling algorithm;
adaptively sampling r2=O(k/ε) rows of A occurs in input-sparsity time; and
constructing the matrix U based on the matrices A, C, and R is performed in input -sparsity time.

12. The system of claim 11, wherein the construction of the matrices C, U, and R occurs in input-sparsity time.

13. The system of claim 9, wherein:
adaptively sampling c2=O(k/ε) columns of A comprises derandomization; and
adaptively sampling r2=O(k/ε) rows of A comprises derandomization.

14. The system of claim 13, wherein the construction of the matrices C, U, and R comprises a deterministic CUR decomposition.

15. A computer program product for reducing storage space occupied by a matrix A, the computer program product comprising a non-transitory computer readable storage medium having program instructions embodied therewith, the program instructions executable by one or more processors to cause the one or more processors to perform a method comprising:
constructing, by a first hardware circuit, a matrix C based on the matrix A, wherein the constructing the matrix C based on the matrix A comprises:
computing Z1 as the top k singular vectors of A, wherein a scalar k is a target rank of a matrix U and is selected to be less than the rank of the matrix A, wherein Ak is a rank-k approximation of the matrix A, wherein a scalar ε is between 0 and 1 and represents a selected accuracy parameter, and wherein ∥A−AZ1Z1T∥F2≦(1+ε)∥A−Ak∥F2;
sampling O(k log k) columns from the transpose of Z1, wherein the sampling uses leverage scores;
down-sampling the sampled columns to C1 comprising c1=O(k) columns, wherein ∥A−C1C1†∥F2≦O(1)∥A−AZ1Z1T∥F2; and
adaptively sampling c2=O(k/ε) columns of A, wherein






  
    
      
        
        
          A
          -
          
            C
            ·
            D
          
        
        
      
      F
      2
    
    ≤
    
      
        
          
          
            A
            -
            
              A
              k
            
          
          
        
        F
        2
      
      +
      
        
          (
          
            k
            
              c
              2
            
          
          )
        
        ⁢
        
          
            
            
              A
              -
              
                
                  C
                  1
                
                ⁢
                
                  C
                  1
                  †
                
                ⁢
                A
              
            
            
          
          F
          2
        
      
    
  
  ,




wherein D is selected to be a rank-k matrix;
constructing, by a second hardware circuit distinct from the first hardware circuit, a matrix R based on the matrix A and the matrix C; and
constructing, by a third hardware circuit distinct from the first hardware circuit and the second hardware circuit, the matrix U based on the matrices A, C, and R;
wherein the matrices C, U, and R comprise a CUR decomposition of the matrix A; and
reducing storage space occupied by the matrix A by replacing the matrix A with the matrices C, U, and R.

16. The computer program product of claim 15, wherein the constructing the matrix R based on the matrix A and the matrix C comprises:




  
    
      
        
        
          Λ
          -
          
            Λ
            ⁢
            
              
            
            ⁢
            
              Z
              1
            
            ⁢
            
              Z
              1
              T
            
          
        
        
      
      F
      2
    
    ≤
    
      
        (
        
          1
          +
          ɛ
        
        )
      
      ⁢
      
        
          
          
            Λ
            -
            
              Λ
              k
            
          
          
        
        F
        2
      
      ⁢
      
        
          
          
            A
            ⁢
            
              
            
            ⁢
            
              C
              1
            
            ⁢
            
              C
              1
              †
            
          
          
        
        F
        2
      
    
    ≤
    
      
        O
        ⁡
        
          (
          1
          )
        
      
      ⁢
      
        
          
          
            A
            ⁢
            
              
            
            ⁢
            A
            ⁢
            
              
            
            ⁢
            
              Z
              1
            
            ⁢
            
              Z
              1
              T
            
          
          
        
        F
        2
      
      ⁢
      
        
          
          
            A
            -
            
              C
              ·
              D
            
          
          
        
        F
        2
      
    
    ≤
    
      
        
          
          
            A
            -
            
              A
              k
            
          
          
        
        F
        2
      
      +
      
        
          (
          
            k
            
              c
              2
            
          
          )
        
        ⁢
        
          
            
            
              A
              -
              
                
                  C
                  1
                
                ⁢
                
                  C
                  1
                  †
                
                ⁢
                A
              
            
            
          
          F
          2
        
      
    
  
  ;




and finding Z2 in the span of the matrix C, wherein ∥A−A%2%2T∥F2<(1+ε)∥A−Ak∥F2;
sampling O(k log k) rows of Z2, wherein the sampling uses leverage scores;
down-sampling the sampled rows to R1 comprising r1=O(k) columns using BSS sampling, wherein ∥A R1R1†∥F2≦O(1)∥A AZ2Z2TA∥F2; and
adaptively sampling r2=O(k/ε) rows of A, wherein





  
    
      
      
        A
        -
        
          
            Z
            2
          
          ⁢
          
            Z
            2
            T
          
          ⁢
          
            AR
            †
          
          ⁢
          R
        
      
      
    
    F
    2
  
  ≤
  
    
      
        
        
          A
          -
          
            
              Z
              2
            
            ⁢
            
              Z
              2
              T
            
            ⁢
            A
          
        
        
      
      F
      2
    
    +
    
      
        rank
        (
        
          
            
              Z
              1
            
            ⁢
            
              Z
              2
              T
            
            ⁢
            A
          
          
            r
            2
          
        
        )
      
      ⁢
      
        
          
            
            
              A
              -
              
                
                  AR
                  1
                
                ⁢
                
                  R
                  1
                  †
                
              
            
            
          
          F
          2
        
        .

17. The computer program product of claim 16, wherein:
down-sampling the sampled columns to C1 comprising c1=O(k) columns using BSS sampling uses an input-sparsity-time BSS sampling algorithm;
adaptively sampling c2=O(k/ε) columns of A occurs in input-sparsity time;
down-sampling the sampled rows to R1 comprising r1=O(k) columns using BSS sampling uses the input-sparsity-time BSS sampling algorithm;
adaptively sampling r2=O(k/ε) rows of A occurs in input-sparsity time; and
constructing the matrix U based on the matrices A, C, and R is performed in input- sparsity time.

18. The computer program product of claim 17, wherein the construction of the matrices C, U, and R occurs in input-sparsity time.

19. The computer program product of claim 16, wherein:
adaptively sampling c2=O(k/ε) columns of A comprises derandomization; and
adaptively sampling r2=O(k/ε) rows of A comprises derandomization.

20. The computer program product of claim 19, wherein the construction of the matrices C, U, and R comprises a deterministic CUR decomposition.