Next Article in Journal
Mathematical and Statistical Modelling for Assessing COVID-19 Superspreader Contagion: Analysis of Geographical Heterogeneous Impacts from Public Events
Next Article in Special Issue
An Inverse Optimal Value Approach for Synchronously Optimizing Activity Durations and Worker Assignments with a Project Ideal Cost
Previous Article in Journal
Local Property of Depth Information in 3D Images and Its Application in Feature Matching
Previous Article in Special Issue
Scheduling of Jobs with Multiple Weights on a Single Machine for Minimizing the Total Weighted Number of Tardy Jobs
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

Low-Rank Matrix Completion via QR-Based Retraction on Manifolds

1
Department of Mathematics, Shanghai University, Shanghai 200444, China
2
Qianweichang College, Shanghai University, Shanghai 200444, China
*
Author to whom correspondence should be addressed.
Mathematics 2023, 11(5), 1155; https://doi.org/10.3390/math11051155
Submission received: 17 January 2023 / Revised: 23 February 2023 / Accepted: 23 February 2023 / Published: 26 February 2023
(This article belongs to the Special Issue Advanced Optimization Methods and Applications)

Abstract

:
Low-rank matrix completion aims to recover an unknown matrix from a subset of observed entries. In this paper, we solve the problem via optimization of the matrix manifold. Specially, we apply QR factorization to retraction during optimization. We devise two fast algorithms based on steepest gradient descent and conjugate gradient descent, and demonstrate their superiority over the promising baseline with the ratio of at least 24 % .
MSC:
90C29; 57R57; 49Q10; 90C30

1. Introduction

The problem of matrix completion (MC) has generated a great deal of interest over the last decade [1], and several variant problems have been considered, such as non-negative matrix completion (NMC) [2], structured matrix completion [3,4] (including Hankel matrices [5]), and low-rank matrix completion (LRMC) [6,7]. Because of its wide applications in sensor network localization [8], system identification [9], machine learning [10,11], computer vision [12], recommendation systems [13], etc., LRMC has drawn a great deal of attention. Let M R n × n be an observed matrix and Ω { ( i , j ) , i , j = 1 , , n } be an index set of the observed position. Then, the desired low-rank matrix X can be recovered by solving the following rank minimization problem [14,15]:
min X R n × n rank ( X ) s . t . P Ω ( X ) = P Ω ( M ) ,
where P Ω ( X ) i j = X i j , ( i , j ) Ω and 0, otherwise. Unfortunately, the calculation of the rank function is (non-deterministic polynomial) NP-hard, and thus all known algorithms need double exponential time on the dimension of n.
To overcome this limitation, many approaches have been proposed [13]. For instance, Candès and Recht [16] replaced the rank function with the nuclear norm, and (1) can be rewritten as
min X X * s . t . P Ω ( X ) = P Ω ( M ) ,
where X * = i σ i ( X ) and σ i ( X ) represents the i-th largest non-zero singular value. They proved that if the number of observed entries m = | Ω | obeys m c n 1.2 r log ( n ) with c being some positive constant and r being the rank of X, then most matrices of rank r can be perfectly recovered with very high probability by solving a simple convex optimization program. However, when the size of the matrix is large, the computation is still burdensome. To mitigate the computational burden, Cai et al. [17] introduced the singular value thresholding algorithm. The key idea of this approach is to place the regularization term into the objective function of the nuclear norm minimization problem. On the other hand, given the rank of a matrix, Lee and Bresler [18] replaced the rank function with the Frobenius norm, and (1) can be rewritten as
min X 1 2 P Ω ( M ) P Ω ( X ) F 2 s . t . rank ( X ) r .
According to matrix theory, the matrix M R n 1 × n 2 of rank r can be decomposed into two matrices X R n 1 × r and Y R n 2 × r such that M = X Y T . A straightforward method is to determine X and Y by minimizing the residual between the original M and the recovered one (that is, X Y T ) on the sampling set [19,20]:
min X , Y 1 2 P Ω ( M ) P Ω ( X Y T ) F 2 .
To solve this multiple objective optimization program, one can employ the alternating minimization technique: (i) set X first and determine Y via minimizing the residual and; (ii) fix Y and determine X in the same way.
To accelerate the completing process, a novel utilization of the rank information is definition of an inner product and a differentiable structure, which formulates a manifold-based optimization program [21,22]. Then, one can compute the Riemannian gradient and Hessian matrix to solve the following problem [14,23]:
min X M r P Ω ( X M ) ,
where M r : = { X R n 1 × n 2 , rank ( X ) = r } . Specially, Mishra et al. [24] discussed singular value decomposition, rank factorization, and QR factorization on manifolds. Following this line, Cambier and Absil [25] simultaneously considered singular value decomposition and regularization:
min X M r P Ω ( X M ) l 1 + λ P Ω ( X ) F 2 ,
where X l 1 = Σ i , j | X i , j | and λ is a regularization parameter. Yet, the improvement of the accuracy is not remarkable. More recently, Dong et al. [26] devised a preconditioned gradient descent algorithm for the rank factorization problem:
min ( G , H ) R m × k × R n × k 1 2 P Ω ( G H T M ) F 2 ,
which is a multiple objective problem on the product space that can be defined as a manifold. Although it shows good performance in comparison to single-objective problems, the algorithm hardly considers the structure on a per matrix basis.
In this paper, we consider QR factorization on manifolds. Different from single-objective optimization on the manifold [24,27,28], we study LRMC using multiple objective optimization in the product space R n 1 × r × R r × n 2 . During iteration, we first obtain the gradient of the objective function in the tangent space and then retract it with QR factorization. Specially, we introduce a measure to characterize the degree of orthogonality of Q for retraction, based on which we design two fast algorithms and show their advantage in comparison to rank factorization [26].
The paper is organized as follows. In Section 2, we introduce some preliminaries, including basic notations, problem formulation, and the element of manifolds. In Section 3, we show algorithms based on the choice of initial point, descent direction, step size, and retraction. In Section 4, we prove convergence and analyze the reason why the proposed algorithms outperform those in [26]. In Section 5, we demonstrate the superior performance of the proposed algorithms using numerical experiments. Finally, in Section 6 we provide a conclusion.

2. Preliminary

Notation. The Euclidean inner product and norm for the product space R n 1 × r × R r × n 2 , respectively, denoted with · , · and · , are defined by
x , y = T r ( Q x T Q y ) + T r ( R x R y T ) and x = x , x ,
for any pair of points x = ( Q x , R x ) , y = ( Q y , R y ) R n 1 × r × R r × n 2 .
Problem statement. The purpose of this paper is to solve the problem (5). With QR factorization, it becomes:
min ( Q , R ) R n 1 × r × R r × n 2 f Ω ( Q , R ) : = 1 2 P Ω ( Q R M ) F 2 .
QR factorization. QR factorization [29] can be carried out by using Householder transformation, Givens rotations, Gram–Schmidt process, and their variants. In this paper, we choose the modified Gram–Schmidt algorithm for a more reliable procedure. (see Algorithm 7 for details.)
Geometric element on R n 1 × r × R r × n 2 . The tangent space (see Figure 1) at a point x R n 1 × r × R r × n 2 is the finite Cartesian product of the tangent spaces of the two element matrix spaces. Then, T x ( R n 1 × r × R r × n 2 ) R n 1 × r × R r × n 2 (see Section 3.5.2, [21]) where X Y indicates that there is a homeomorphism between the topological space X and Y.
Comparing the performance of several metrics, we consider the following. Given two tangent vectors ξ , η T x ( R n 1 × r × R r × n 2 ) (see Section 4, [26]) at point x = ( Q , R ) R n 1 × r × R r × n 2 , the preconditioned metric is
M x ( ξ , η ) = T r ( ξ Q T η Q ( R R T + δ I r ) ) + T r ( ξ R η R T ( 1 + δ ) ) ,
where ξ = ( ξ Q , ξ R ) , η = ( η Q , η R ) , δ > 0 is a constant, which keeps the metric well defined and positive definite if Q or R does not have full rank. Furthermore, if ξ = η , one can write ξ x 2 = M x ( ξ , ξ ) as a kind of norm at point x.
Definition 1.
For a point x R n 1 × r × R r × n 2 , the gradient of f Ω is the unique vector in T x ( R n 1 × r × R r × n 2 ) , denoted with f Ω ( x ) , such that
M x ( ξ , f Ω ( x ) ) = D f Ω ( x ) [ ξ ] , ξ T x ( R n 1 × r × R r × n 2 ) ,
where D f Ω ( x ) [ ξ ] = T r ( ξ Q T P Ω ( Q R M ) R T ) ) + T r ( ξ R P Ω T ( Q R M ) Q ) is directional derivative defined [21] by
D f Ω ( x ) [ ξ ] = lim t 0 f Ω ( x + t ξ ) f Ω ( x ) t .
Combing Equations (8) and (11), it follows that
f Ω ( Q , R ) = ( Q f Ω ( Q , R ) ( R R T + δ I r ) 1 , R f Ω ( Q , R ) ( 1 + δ ) 1 ) ,
where Q f Ω ( Q , R ) = P Ω ( Q R M ) R T and R f Ω ( Q , R ) = Q T P Ω ( Q R M ) .

3. Algorithms

Initial point x 0 . Following the widely used spectral initialization [30], we apply k SVD to a zero-filled matrix M 0 : = P Ω ( M ) and yield three matrices U 0 , Σ 0 , and V 0 such that M 0 = U 0 Σ 0 V 0 T . Then, the initial point x 0 : = ( Q 0 , R 0 ) is set as (see Algorithm 1 for details)
( Q 0 , R 0 ) = ( U 0 Σ 0 1 / 2 , Σ 0 1 / 2 V 0 T ) .
Algorithm 1 Initialization
Input: data M and rank r
Output: initialization x 0
      1:
Use singular value decomposition (SVD) to compute U , Σ , V (that satisfies M = U Σ V T ).
      2:
Trim matrices U 0 = U ( : , 1 : r ) , Σ 0 = Σ ( 1 : r , 1 : r ) , V 0 = V ( : , 1 : r ) .
      3:
Set x 0 = [ U 0 ( Σ 0 ) 1 / 2 ; V 0 ( Σ 0 1 / 2 ) T ] .
Descent direction η t . Here, we consider two kinds of directions, the steepest descent (SD) direction (see Algorithm 2) and the conjugate descent (CD) direction (see Algorithm 3 and Figure 1), defined, respectively, by
η t = f ( x t ) ,
η t = f ( x t ) + β t η t 1 .
Although there are several calculations of β t , we adopt β t D Y = ξ t x 2 / M x ( η t 1 , Δ ξ t 1 ) from [31] because it outperforms the others.
Algorithm 2 Steepest descent (SD) direction of the function in (9) with orthogonality of Q
Input: Data M, iterate x t = [ Q ; R T ] , rank r, and metric constant δ .
Output: SD direction ξ t
      1:
S = P Ω ( Q R M ) .
      2:
f Ω ( x t ) = ( S R T / ( R R T + δ I r ) , S T Q / ( 1 + δ ) ) ( = f , for omitted ) .
      3:
ξ t = f
Algorithm 3 Conjugate descent (CD) direction of the function in (9)
Input: Last conjugate direction η t 1 (Set η 0 = 0 ), conjugate direction β t .
Output: Conjugate direction η t .
      1:
Compute f using Algorithm 2.
      2:
η t = f + β t η t 1 .
Stepsize s t . For the SD direction, we apply exact line search (ELS) [22] (see Algorithm 4). Let η = ( η Q , η R ) T x ( R n 1 × r × R r × n 2 ) be a given descent direction; then,
arg min s f Ω ( Q + s η Q , R + s η R ) = arg min s 1 2 P Ω ( ( Q + s η Q ) ( R + s η R ) M ) F 2 = arg min s 1 2 P Ω ( η Q η R ) s 2 + P Ω ( Q η R + η Q R ) s + P Ω ( Q R M ) F 2 = arg min s 1 2 T r ( A s 2 + B s + O ) T ( A s 2 + B s + O ) = arg min s 1 2 T r ( A T A ) s 4 + 2 T r ( A T B ) s 3 + ( 2 T r ( A T O ) + T r ( B T B ) ) s 2 + 2 T r ( B T O ) s + T r ( O T O ) ,
where A = P Ω ( η Q η R ) , B = P Ω ( Q η R + η Q R ) , and O = P Ω ( Q R M ) . The differential of the formula above reads as:
2 T r ( A T A ) s 3 + 3 T r ( A T B ) s 2 + ( 2 T r ( A T O ) + T r ( B T B ) ) s + T r ( B T O ) = 0 .
As a cubic equation, one can obtain its roots easily. The step size s t is exactly the real positive root.
Algorithm 4 Exact line search
Input: Data M, iterate x = [ Q ; R T ] , Conjugate direction η = [ η Q ; η R T ] .
Output: Step size s.
      1:
Set A = P Ω ( η Q η R ) , B = P Ω ( Q η R + η Q R ) and O = P Ω ( Q R M ) .
      2:
Furthermore, solve the cubic equation 2 T r ( A T A ) x 3 + 3 T r ( A T B ) x 2 + ( 2 T r ( A T O ) + T r ( B T B ) ) x + T r ( B T O ) = 0 .
      3:
Let the smallest absolute value s of their solutions be the step size.
For the CD direction, we apply the inexact line search (IELS) [32] (see Algorithm 5). For this purpose, we set s 0 = M x ( ξ t , η t ) / ( L η t x 2 ) , where L > 0 is constant, and σ ( 0 , 0.5 ] . Then, the step size s t at the t th iteration is the largest one in the set { s 0 , 0.5 s 0 , 0 . 5 2 s 0 , } , and therefore
f ( x t ) f ( x t + s t η t ) σ s t M x ( ξ t , η t ) .
Algorithm 5 Inexact line search
Input: Data M, iterate x, constant L > 0 , times limitation i m , parameter σ ( 0 , 0.5 ] , SD direction ξ , and CD direction η .
Output: Stepsize s.
      1:
Set s 0 = M x ( ξ , η ) / ( L η x 2 ) .
      2:
k 0
      3:
while f Ω ( x ) f Ω ( x + s η ) + σ s M x ( ξ , η ) < 0 & & k < i m do
      4:
    s 0.5 s
      5:
    k k + 1
      6:
end while
Retraction. With the descent direction η = ( η Q , η R ) and stepsize s, one can apply retraction (see Figure 1 and Algorithm 6). For this purpose, we introduce the concept of the degree of orthogonality.
Definition 2.
For a matrix Q R n 1 × r , we definite its degree of orthogonality as:
Orth ( Q ) = T r ( Q T Q ) r r .
Algorithm 6 Retraction with QR factorization
Input: Iteration x = [ Q ; R T ] , direction η = [ η Q ; η R T ] , stepsize s t and parameter θ .
Output: Next iterate x t + 1 = ( Q t + 1 , R t + 1 ) .
      1:
if Orth ( Q t + s t η Q t ) < θ (see (18)) then
      2:
    x t + 1 = x t
      3:
else {obtain Q ˜ and R ˜ from Q t + s t η Q t using Algorithm 7}
      4:
    x t + 1 = [ Q ˜ ; ( ( R t ) T + s t ( η R t ) T ) ( R ˜ ) T ]
      5:
end if
Algorithm 7 Modified Gram–Schmidt algorithm
Input: A R n 1 × r with rank ( A ) = r .
Output: Q R n 1 × r and R R r × r .
      1:
for k = 1 : r do
      2:
    R x , x = Σ i = 1 n 1 A i , k 2
      3:
   for  i = 1 : n 1  do
      4:
      Q i , k = A i , k / R k , k
      5:
   end for
      6:
   for  k = k + 1 : r  do
      7:
      R k , j = Σ i = 1 n 1 Q i , k A i , j
      8:
     for  i = 1 : n 1  do
      9:
         A i , j = A i , j Q i , k R k , j
      10:
     end for
      11:
   end for
      12:
end for
Given a small parameter θ , we say that the matrix Q + s η Q has good orthogonality if Orth ( Q + s η Q ) < θ . Then, we adopt ( Q + s η Q , R + s η R ) as the value for the next iterate. On the contrary, we have to decompose Q + s η Q [33] and obtain Q ˜ , R ˜ , and hence, the next iteration point ( Q ˜ , R ˜ ( R + s η R ) ) .
In summary, we present Algorithms 8 and 9 as the whole process of solving the optimization problem (9), respectively.
Algorithm 8 QR Riemannian gradient descent (QRRGD)
Input: Function f : R n 1 × r × R r × n 2 R (see (9)), initial point x 0 R n 1 × r × R r × n 2 (generated by Algorithm 1), tolerance parameter ϵ > 0
Output: x t
      1:
t 0
      2:
Compute the gradient by Algorithm 2
      3:
while ξ t x > ϵ do
      4:
   Find step size s t by Algorithm 4
      5:
   Update via retraction (Algorithm 6): x t + 1 = R x t ( s t η t )
      6:
    t t + 1
      7:
   Compute the steepest direction by Algorithm 2
      8:
end while
Algorithm 9 QR Riemannian conjugate gradient (QRRCG)
Input: Function f : R n 1 × r × R r × n 2 R (see (9)), initial point x 0 R n 1 × r × R r × n 2 , tolerance parameter ϵ > 0
p Output: x t
      1:
t 0
      2:
Compute the gradient using Algorithm 2
      3:
while ξ t x > ϵ do
      4:
   Find step size s t using Algorithm 4
      5:
   Update via retraction (Algorithm 6): x t + 1 = R x t ( s t η t )
      6:
    t t + 1
      7:
   Compute the conjugate direction using Algorithm 3
      8:
end while

4. Analysis

4.1. Convergence

We conduct analysis of Algorithm 8 as an instance and Algorithm 9 can be proved using a similar method. First, we prove that the objective function (9) is Lipschitz continuously differentiable [34] on the product space R n 1 × r × R r × n 2 over the Euclidean geometry. Then, we demonstrate that the proposed Riemannian gradient descent direction (14) has a sufficient decrease in the function value provided that the step size is selected properly depending on the local geometry at each iteration.
The Lipschitz continuity of the gradient of f in the sublevel set [35]
S 0 = { x R n 1 × r × R r × n 2 , f ( x ) f ( x 0 ) } .
with respect to a point x 0 R n 1 × r × R r × n 2 is shown below.
Lemma. 1
(Lipschitz continuous). Given a point x 0 R n 1 × r × R r × n 2 , there exists a Lipschitz constant L 0 > 0 such that the gradient of f in R n 1 × r × R r × n 2 is L 0 Lipschitz continuous for any x , y R n 1 × r × R r × n 2 belonging to the sublevel set S 0 (19) (see [36] for details to this lemma),
f ( y ) f ( x ) f ( x ) , y x + L 0 2 y x 2 .
Proof. 
By the definition of function (9), set S 0 , where S 0 is bounded with respect to any x < . Furthermore, let B be a closed ball that contains S 0 . For all x , y B , according to f is C , we have
f ( y ) = f ( x ) + 0 1 f ( x + τ ( y x ) ) , y x d τ = f ( x ) + f ( x ) , y x + 0 1 f ( x + τ ( y x ) ) f ( x ) , y x d τ
Then,
| f ( y ) f ( x ) f ( x ) , y x | = | 0 1 f ( x + τ ( y x ) ) f ( x ) , y x d τ | 0 1 | f ( x + τ ( y x ) ) f ( x ) , y x | d τ 0 1 f ( x + τ ( y x ) ) f ( x ) y x d τ τ L 0 y x 2 d τ = L 0 2 y x 2 .
This means that (20) is true on B, and it functions on its subset S 0 . □
Next, we obtain the following sufficient decrease property with Lemma 1.
Lemma 2.
At any iterate x t = ( Q t , R t ) produced by Algorithm 8 before stopping, the following sufficient decrease property holds, provided that the step size s satisfies 0 < s < 2 H t / L 0 for a positive value H t > 0 ,
f ( x t + 1 ) f ( x t ) C t ( s ) f ( x t ) 2 ,
where C t ( s ) = s ( H t L 0 s 2 ) > 0 and H t is defined by
H t = δ + min ( 1 , σ min 2 ( R t ) ) ,
under the gradient setting (14).
Proof. 
In Algorithm 8, at iterate x t R n 1 × r × R r × n 2 , the Riemannian gradient descent step is η t = f ( x t ) . Let s > 0 denote the step size for producing the next iterate: x t + 1 = x t + s η t = ( η Q , η R ) . In the gradient setting (14), the partial differentials are
Q f ( x ) = η Q ( R R T + δ I r ) and H f ( x ) = η R ( 1 + δ ) .
According to Lemma 1, it follows that
f ( x t + 1 ) f ( x t ) f ( x t ) , x t + 1 x t + L 0 2 x t + 1 x t 2 = s f ( x t ) , f ( x t ) + L 0 s 2 2 η t 2 = s ( T r ( η Q T η Q ( R R T + δ I r ) ) + T r ( η R η R T ( Q T Q + δ I r ) ) ) + L 0 s 2 2 η t 2 s ( δ η t 2 + σ m i n 2 ( R ) η Q F 2 + σ m i n 2 ( Q ) η R F 2 ) + L 0 s 2 2 η t 2 s η t 2 ( δ + min ( 1 , σ m i n 2 ( R t ) ) ) + L 0 s 2 2 η t 2 = C t ( s ) f ( x t ) 2 .
Next, we prove that Algorithm 8 with the step size selected by the exact line search (16) ensures sufficient decrease at each iteration.
Lemma 3.
The iterates produced by Algorithm 8, with step size chosen by the exact line search (see Algorithm 4) satisfy the following sufficient decrease property,
f ( x t + 1 ) f ( x t ) ( H t 2 / 2 L 0 ) f ( x t ) 2 .
Proof. 
In Algorithm (8), let η = f ( x t ) denote the Riemannian gradient descent direction at the iterate x t R n 1 × r × R r × n 2 . From Lemmas 2 and 3, one obtains
f ( x t + s η ) f ( x t ) C t ( s ) f ( x t ) 2 .
for s [ 0 , 2 H t / L 0 ] with H t defined in (22). On the other hand, let s ^ be the step size computed using Algorithm 4, and the next iterate x t + 1 = x t + s ^ η is the minimum of f along the direction η : f ( x t + 1 ) f ( x t + s η ) by procession, for all s 0 . Therefore,
f ( x t + 1 ) min s [ 0 , 2 H t / L 0 ] f ( x t + s η )
                                                                    min s [ 0 , 2 H t / L 0 ] ( f ( x t ) C t ( s ) f ( x t ) 2 )
                                            = f ( x t ) ( H t 2 / 2 L 0 ) f ( x t ) 2 .
In Equation (27), the conclusion max s [ 0 , 2 H t / L 0 ] C t ( s ) = max s [ 0 , 2 H t / L 0 ] s ( H t L 0 s 2 ) = H t 2 / 2 L 0 is applied. □
In both Lemmas 2 and 3, the sufficient decrease quantity depends on the local parameter H t . The quality H t is useful only when it is a strictly positive number. We address this in Proposition 1 for the gradient setting (12).
Proposition 1.
Under the same settings as in Lemmas 2 and 3, there exists a positive numerical constant H * > 0 such that the quantities (22) are lower bounded,
inf t 0 H t H * .
Proof. 
In the gradient setting (12),
H t = δ + min ( σ m i n 2 ( Q t ) , σ m i n 2 ( R t ) ) σ > 0 .
It is easy to find the result (28) can be ensured by H * : = σ as claimed. □
Now, we reach the main result using the following theorem.
Theorem 1.
Under the problem statement (9), given the initial point x 0 and the gradient setting (12), the sequence generated by Algorithm 8 with the step size (16) converges and a upper bound of the gradient norm shows as follows,
f ( x N ) 2 L 0 ( f ( x 0 ) f * ) H * N
after N iterations, where L 0 > 0 is the Lipschitz constant in Lemma 1, the numerical constant H * > 0 is given in Proposition (28), and f * is a lower bound of the function value of (9).
Proof. 
The convergence of the sequence ( x t ) t 0 is a direct result of the sufficient decrease property (21) in Lemma 2 and the boundedness of the sequence of function values f ( x t ) t 0 .
Let N 1 denote the number of iterations needed for reaching an iterate x N such that f ( x N ) ϵ , for a tolerance parameter ϵ > 0 .
Because Algorithm 8 does not terminate at t N 1 , the gradient norms f ( x t ) > ϵ for all t N 1 . Adding up the right hand sides of (24) for t = 0 , , N 1 follows
f ( x N ) f ( x 0 ) t = 0 N 1 ( H t 2 / 2 L 0 ) f ( x t ) 2
( ϵ 2 / 2 L 0 ) t = 0 N 1 H t 2
= ( H * / 2 L 0 ) ϵ 2 N .
In Equation (32), Proposition 1 is applied. Therefore, the number of iterations satisfies
N 2 L 0 ( f ( x 0 ) f ( x N ) ) H * ϵ 2 2 L 0 ( f ( x 0 ) f * ) H * ϵ 2 .
In other words, the iterate produced by the algorithm after N iteration obeys
f ( x N ) 2 L 0 ( f ( x 0 ) f * ) ) H * N .

4.2. Computational Cost

In this subsection, we analyze the computation cost of our QR-based method with the other. It demonstrates the reason that we can obtain better performance than the compared method. After we make a QR factorization to matrix Q, it leads to some computational cost, but what the factorization reaps, the benefits greatly exceeds what it costs using an ingenious trick.
Cost increase. In Figure 2, we mark three parts including computations in retraction as C 1 , C 2 , and C 3 , respectively. For C 1 , we compute T r ( Q T Q ) as the leading part where Q R n 1 × r , the cost of which is 2 n 1 r 2 . For C 2 , we compute the QR decomposition of a matrix in R n 1 × r by the MGS algorithm, which costs 2 n 1 r 2 . For C 3 , it just computes the product of matrices R ˜ R r × r and R R r × n 2 ; hence, it costs 2 n 2 r 2 . Assume that the rate of the good orthogonality is 1 θ 0 , and the iteration number is k iter ; then, the whole increasing cost is k iter ( C 1 + θ 0 ( C 2 + C 3 ) ) .
Cost decrease. A simple thought is to reduce the cost in each iteration process. First, we consider the gradient of the objective function (9), and the computational costs are summarized in Table 1, where C chol = 1 / 3 is a coefficient in the Cholesky decomposition while computing the inverse. Therefore, once we compute the gradient we have D 1 = 2 ( n 1 + n 2 ) r 2 + C chol r 3 reductions directly with respect to algorithms without QR. Second, we consider the metric (10), and the computational costs are summarized in Table 2. When we compute the metric, the reduction is D 2 = 2 ( n 1 + r ) r 2 under the QR method than those without it.
In Algorithm 8, if we find the step size s t using the exact line search (Algorithm 4), then the reduction is k iter D 1 , because the exact line search needs not to compute the metric. Furthermore, the reduction in the computational cost at one iteration is D 1 ( C 1 + θ 0 ( C 2 + C 3 ) ) = 1 3 r 3 + 2 ( 1 θ 0 ) n 2 r 2 2 n 1 r 2 .
In Algorithm 9, if we find the step size s t using the inexact line search (Algorithm 5), the reduction in the worst case is k iter ( D 1 + i m D 2 ) . Furthermore, the reduction in the computational cost at one iteration is ( D 1 + i m D 2 ) ( C 1 + θ 0 ( C 2 + C 3 ) ) = ( 2 i m + 1 3 ) r 3 + 2 ( i m r ) n 1 r 2 + 2 ( 1 θ 0 ) n 2 r 2 .

5. Numerical Experiments

This section shows a numerical comparison of our algorithms with the recent RGD/RCG algorithms [26], which outperforms existing matrix factorization models on manifolds. The experiments are divided into two parts: in the first part, we test our algorithm on synthetic data, whereas in the second part, we provide the results on an empirical dataset PeMS Traffic [37].
To assess the algorithmic performance, we use the root mean square error (RMSE). Given a matrix M R n 1 × n 2 observed on Ω , the RMSE of X R n 1 × n 2 with respect to M is defined by
RMSE ( X ; Ω ) = Σ ( i , j ) Ω ( X i j M i j ) 2 / | Ω | .
Other parameters used in experiments are as follows: (1) p is the probability of an entry being observed; (2) the stopping parameter ϵ = 10 10 is one of the two parameters stop the iteration process when RMSE reaches it; (3) the iteration budget parameter λ = 250 is another parameter that stops the iteration process when iterating a specific amount of times over it; (4) the metric parameter δ = 10 4 helps the metric be well defined; (5) the orthogonality parameter θ = 0.01 is used to judge whether a matrix has good orthogonality; and (6) the oversampling factor O S F ( 2.5 , 3 ) according to [14], defined by O S F = | Ω | / ( r ( n 1 + n 2 r ) ) , which decides the difficulty of the problem.
In our experiment, we first fix the values of n 1 , n 2 , and p. Next, we determine the difficulty of recovery, which can be characterized by the over sampling factor (OSF). Following [14], we set the OSF in ( 2.5 , 3 ) . Finally, we determine the value of the rank by r = 11 / 30 n 1 n 2 p / ( n 1 + n 2 ) . To ensure that the matrix M is low ranked (e.g., r = 10 ), there are two methods. One is setting n 1 and n 2 as small as possible given the values of p. For example, given p = 0.2 , the values of n 1 and n 2 are about 250. Because of the small size, the problem is trivial. The other is letting p be smaller given the larger values of n 1 and n 2 . This is what was performed in our experiment. For example, given n 1 = n 2 = 2000 in Figure 2, we set p = 0.05 and obtain r = 18 .
All numerical experiments were performed on a desktop with 16-core Intel i7-10700F CPUs and 32GB of memory running Windows10 and MATLAB R2022b. The source code is available at https://github.com/Cz1544252489/qrcode (accessed on 14 February 2023).

5.1. Synthetic Data

Initially, we provide some comments about the chosen rank on synthetic data. We first fix the values of n 1 , n 2 , and p. Next, we determine the difficulty of recovery, which can be characterized by the oversampling factor (OSF). Following [14], we set the OSF in ( 2.5 , 3 ) . Finally, we can determine the value of the rank by r = 11 / 30 n 1 n 2 p / ( n 1 + n 2 ) .
We generate two observed matrices M 1 and M 2 with probability p, which is the ratio of an entry being observed defined by M 1 = F Q with ( F , Q T ) R n 1 × r × R n 2 × r and M 2 = M 1 / ( max ( M 1 ) min ( M 1 ) ) , where ( F , Q T ) are composed of columns that are i.i.d. Gaussian vectors. The reason why we generate them is to test our algorithm on different scale of entries, and it will be measured by E ( M ) that is the average of random entries.
Table 3 and Table 4 show the results with matrices size of 2000 × 2000 and 4000 × 4000 . And Table 5 shows the results with matrices size ranging from 2000 × 2000 to 8000 × 2000 .

5.2. Empirical Data

In this part, we test our algorithm on the PeMS Traffic [37] dataset. It is a matrix with a size of 963 × 10560 containing traffic occupancy rates (between 0 and 1) recorded across time by m = 963 sensors placed along different lanes of freeways in the San Francisco Bay Area. The recordings are sampled every 10 minutes, covering a period of 15 months. The column index set corresponds to the time domain and the row index set corresponds to geographical points (sensors), which are referred to as the spatial domain. In the experiment, we use the part of test dataset; it has 173 rows and 6837 columns with p = 0.05 . Table 6 shows the results on the empirical data.
As shown above, solid lines represent the results of our algorithms with QR factorization, whereas dashed lines correspond to those of the algorithms with rank factorization [26]. For synthetic data, our algorithms either yield better solutions or run with less time in comparison to [26] on most cases. Whereas for the empirical dataset, it shows a slight advantage for weak structures on earth. It has been demonstrated that the algorithms in [26] outperform the state-of-the-art methods using alternating minimization and the manifold concept.
Furthermore, we briefly measure the ratio of speedup from the compared algorithm. It can be defined by the means of speedup on all our experiment, that is, S U = Σ i E S U i / | E | , where E is the set of experiments. Furthermore, a single speedup S U i defined as below:
S U i = 0 if t 1 > t 2 and ϵ 1 > ϵ 2 | t 2 ϵ 2 t 1 ϵ 1 1 | o t h e r w i s e
where t 1 and ϵ 1 are the time in seconds and theRMSE of the QR method, respectively, whereas t 2 and ϵ 2 are the time in seconds and the RMSE of the compared method. Finally, we obtain S U = 24.00 % .

6. Conclusions

We have proposed two LRMC algorithms, QRRGD and QRRCG, for reconstruction of an observed matrix via QR-based retraction on manifolds. These two algorithms are computationally efficient and have higher accuracy, demonstrated by theoretical analysis of computational costs and numerical experiments with synthetic data and a real-world dataset PeMS Traffic. To improve efficacy, one could adjust the values of other parameters such as using smaller θ for orthogonality, a larger O S F , and a more suitable δ value for the metric. On the other hand, different conjugate methods [38], as well as the rank adaptive method [39], can be considered.

Author Contributions

Conceptualization, S.Y. and X.X.; Methodology, S.Y. and X.X.; Validation, X.X.; Formal analysis, K.W. and Z.C.; Investigation, K.W. and Z.C.; Writing—original draft, K.W. and Z.C.; Writing—review & editing, S.Y. and X.X.; Project administration, X.X.; Funding acquisition, S.Y. and X.X. All authors have read and agreed to the published version of the manuscript.

Funding

This work was supported by the Natural Science Foundation of China under Grant Nos. 11971296 and 12071281.

Data Availability Statement

Data available in a publicly accessible repository that does not issue DOIs Publicly available datasets were analyzed in this study. This data can be found here: https://file.cz123.top/DatainManQR/.

Acknowledgments

The authors thank anonymous referees for their valuable comments.

Conflicts of Interest

The authors declare no conflict of interest.

References

  1. Candes, E.J.; Plan, Y. Matrix Completion With Noise. Proc. IEEE 2010, 98, 925–936. [Google Scholar] [CrossRef] [Green Version]
  2. Xu, Y.; Yin, W.; Wen, Z.; Zhang, Y. An alternating direction algorithm for matrix completion with nonnegative factors. Front. Math. China 2012, 7, 365–384. [Google Scholar] [CrossRef] [Green Version]
  3. Markovsky, I.; Usevich, K. Structured Low-Rank Approximation with Missing Data. SIAM J. Matrix Anal. Appl. 2013, 34, 814–830. [Google Scholar] [CrossRef] [Green Version]
  4. Markovsky, I. Recent progress on variable projection methods for structured low-rank approximation. Signal Process. 2014, 96, 406–419. [Google Scholar] [CrossRef]
  5. Usevich, K.; Comon, P. Hankel Low-Rank Matrix Completion: Performance of the Nuclear Norm Relaxation. IEEE J. Sel. Top. Signal Process. 2016, 10, 637–646. [Google Scholar] [CrossRef] [Green Version]
  6. Davenport, M. An overview of low-rank matrix recovery from incomplete observations. IEEE J. Sel. Top. Signal Process. 2016, 10, 608–622. [Google Scholar] [CrossRef]
  7. Chi, Y. Low-rank matrix completion [lecture notes]. IEEE Signal Process. Mag. 2018, 35, 178–181. [Google Scholar] [CrossRef]
  8. Ding, Y.; Krislock, N.; Qian, J.; Wolkowicz, H. Sensor Network Localization, Euclidean Distance Matrix completions, and graph realization. Optim. Eng. 2010, 11, 45–66. [Google Scholar] [CrossRef] [Green Version]
  9. Liu, Z.; Vandenberghe, L. Interior-Point Method for Nuclear Norm Approximation with Application to System Identification. SIAM J. Matrix Anal. Appl. 2010, 31, 1235–1256. [Google Scholar] [CrossRef] [Green Version]
  10. Jacob, M.; Mani, M.P.; Ye, J.C. Structured Low-Rank Algorithms: Theory, Magnetic Resonance Applications, and Links to Machine Learning. IEEE Signal Process. Mag. 2020, 37, 54–68. [Google Scholar] [CrossRef] [Green Version]
  11. Jawanpuria, P.; Mishra, B. Structured low-rank matrix learning: Algorithms and applications. arXiv 2017, arXiv:1704.07352. [Google Scholar]
  12. Lu, S.; Ren, X.; Liu, F. Depth Enhancement via Low-rank Matrix Completion. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), Columbus, OH, USA, 23–28 June 2014; pp. 3390–3397. [Google Scholar]
  13. Nguyen, L.T.; Kim, J.; Shim, B. Low-rank matrix completion: A contemporary survey. IEEE Access 2019, 7, 94215–94237. [Google Scholar] [CrossRef]
  14. Vandereycken, B. Low-rank matrix completion by Riemannian optimization. SIAM J. Optim. 2013, 23, 1214–1236. [Google Scholar] [CrossRef] [Green Version]
  15. Wang, H.; Zhao, R.; Cen, Y.; Liang, L.; He, Q.; Zhang, F.; Zeng, M. Low-rank matrix recovery via smooth rank function and its application in image restoration. Int. J. Mach. Learn. Cybern. 2018, 9, 1565–1576. [Google Scholar] [CrossRef]
  16. Candès, E.J.; Recht, B. Exact matrix completion via convex optimization. Found. Comput. Math. 2009, 9, 717–772. [Google Scholar] [CrossRef] [Green Version]
  17. Cai, J.F.; Candès, E.J.; Shen, Z. A singular value thresholding algorithm for matrix completion. SIAM J. Optim. 2010, 20, 1956–1982. [Google Scholar] [CrossRef]
  18. Lee, K.; Bresler, Y. Admira: Atomic decomposition for minimum rank approximation. IEEE Trans. Inf. Theory 2010, 56, 4402–4416. [Google Scholar] [CrossRef] [Green Version]
  19. Jain, P.; Netrapalli, P.; Sanghavi, S. Low-rank matrix completion using alternating minimization. In Proceedings of the 45th Annual ACM Symposium on Theory of Computing, Palo Alto, CA, USA, 1–4 June 2013; pp. 665–674. [Google Scholar]
  20. Tanner, J.; Wei, K. Low rank matrix completion by alternating steepest descent methods. Appl. Comput. Harmon. Anal. 2016, 40, 417–429. [Google Scholar] [CrossRef]
  21. Absil, P.A.; Mahony, R.; Sepulchre, R. Optimization Algorithms on Matrix Manifolds; Princeton University Press: Princeton, NJ, USA, 2009. [Google Scholar]
  22. Boumal, N. An Introduction to Optimization on Smooth Manifolds; Cambridge University Press: Cambridge, UK, 2023. [Google Scholar]
  23. Guglielmi, N.; Scalone, C. An efficient method for non-negative low-rank completion. Adv. Comput. Math. 2020, 46, 31. [Google Scholar] [CrossRef]
  24. Mishra, B.; Meyer, G.; Bonnabel, S.; Sepulchre, R. Fixed-rank matrix factorizations and Riemannian low-rank optimization. Comput. Stat. 2014, 29, 591–621. [Google Scholar] [CrossRef] [Green Version]
  25. Cambier, L.; Absil, P.A. Robust low-rank matrix completion by Riemannian optimization. SIAM J. Sci. Comput. 2016, 38, S440–S460. [Google Scholar] [CrossRef] [Green Version]
  26. Dong, S.; Absil, P.A.; Gallivan, K. Riemannian gradient descent methods for graph-regularized matrix completion. Linear Algebra Its Appl. 2021, 623, 193–235. [Google Scholar] [CrossRef]
  27. Zhu, X. A Riemannian conjugate gradient method for optimization on the Stiefel manifold. Comput. Optim. Appl. 2017, 67, 73–110. [Google Scholar] [CrossRef]
  28. Sato, H.; Aihara, K. Cholesky QR-based retraction on the generalized Stiefel manifold. Comput. Optim. Appl. 2019, 72, 293–308. [Google Scholar] [CrossRef]
  29. Golub, G.H.; Van Loan, C.F. Matrix Computations; JHU Press: Baltimore, MD, USA, 2013. [Google Scholar]
  30. Keshavan, R.H.; Montanari, A.; Oh, S. Matrix completion from noisy entries. J. Mach. Learn. Res. 2010, 11, 2057–2078. [Google Scholar]
  31. Dai, Y.H.; Yuan, Y. A nonlinear conjugate gradient method with a strong global convergence property. SIAM J. Optim. 1999, 10, 177–182. [Google Scholar] [CrossRef] [Green Version]
  32. Armijo, L. Minimization of functions having Lipschitz continuous first partial derivatives. Pac. J. Math. 1966, 16, 1–3. [Google Scholar] [CrossRef] [Green Version]
  33. Björck, Å.; Paige, C.C. Loss and recapture of orthogonality in the modified Gram–Schmidt algorithm. SIAM J. Matrix Anal. Appl. 1992, 13, 176–190. [Google Scholar] [CrossRef]
  34. O’Searcoid, M. Metric Spaces; Springer Science & Business Media: Berlin/Heidelberg, Germany, 2006. [Google Scholar]
  35. Boyd, S.; Boyd, S.P.; Vandenberghe, L. Convex optimization; Cambridge University Press: Cambridge, UK, 2004. [Google Scholar]
  36. Nesterov, Y. Introductory Lectures on Convex Optimization: A Basic Course; Springer Science & Business Media: Berlin/Heidelberg, Germany, 2003. [Google Scholar]
  37. Dua, D.; Graff, C. UCI Machine Learning Repository. 2017. Available online: http://archive.ics.uci.edu/ml (accessed on 10 February 2019).
  38. Liu, J.; Feng, Y.; Zou, L. Some three-term conjugate gradient methods with the inexact line search condition. Calcolo 2018, 55, 1–16. [Google Scholar] [CrossRef]
  39. Zhou, G.; Huang, W.; Gallivan, K.A.; Van Dooren, P.; Absil, P.A. A Riemannian rank-adaptive method for low-rank optimization. Neurocomputing 2016, 192, 72–80. [Google Scholar] [CrossRef] [Green Version]
Figure 1. Illustration of the tangent space, the conjugate direction, and the retraction process.
Figure 1. Illustration of the tangent space, the conjugate direction, and the retraction process.
Mathematics 11 01155 g001
Figure 2. Illustration of the QR factorization in retraction.
Figure 2. Illustration of the QR factorization in retraction.
Mathematics 11 01155 g002
Figure 3. Performance comparison of RGD (a,b) and RCG (c,d) with and without QR factorization. Simulations were carried out on square matrices M 1 (a,c) and M 2 (b,d). We apply the ELS and IELS to find the step size. The parameter values are n 1 = 2000 , n 2 = 2000 , r = 18 , and p = 0.05 .
Figure 3. Performance comparison of RGD (a,b) and RCG (c,d) with and without QR factorization. Simulations were carried out on square matrices M 1 (a,c) and M 2 (b,d). We apply the ELS and IELS to find the step size. The parameter values are n 1 = 2000 , n 2 = 2000 , r = 18 , and p = 0.05 .
Mathematics 11 01155 g003
Figure 4. Performance comparison of the RCG with and without QR factorization. Simulations were carried out on square matrices M 1 (a,c) and M 2 (b,d). We apply ELS and IELS to find the step size. The parameter values are n 1 = 4000 , n 2 = 4000 , r = 36 , and p = 0.05 .
Figure 4. Performance comparison of the RCG with and without QR factorization. Simulations were carried out on square matrices M 1 (a,c) and M 2 (b,d). We apply ELS and IELS to find the step size. The parameter values are n 1 = 4000 , n 2 = 4000 , r = 36 , and p = 0.05 .
Mathematics 11 01155 g004
Figure 5. Performance comparison of RCG with and without QR factorization. Simulations were carried out on square matrices M 1 . We applied ELS. The parameter values are n 1 = 2000 , 4000, 6000, 8000, n 2 = 2000 , p = 0.05 , then r = 18 , 24, 27, 29.
Figure 5. Performance comparison of RCG with and without QR factorization. Simulations were carried out on square matrices M 1 . We applied ELS. The parameter values are n 1 = 2000 , 4000, 6000, 8000, n 2 = 2000 , p = 0.05 , then r = 18 , 24, 27, 29.
Mathematics 11 01155 g005
Figure 6. Performance comparison of RGD (a,b) and RCG (c,d) with and without QR factorization. Simulations were carried out on the same matrices M built by PeMS Traffic. We applied ELS and IELS to find the step size. The parameter values are n 1 = 173 , n 2 = 6837 , p = 0.05 , r = 3 , and O S F = 2.82 .
Figure 6. Performance comparison of RGD (a,b) and RCG (c,d) with and without QR factorization. Simulations were carried out on the same matrices M built by PeMS Traffic. We applied ELS and IELS to find the step size. The parameter values are n 1 = 173 , n 2 = 6837 , p = 0.05 , r = 3 , and O S F = 2.82 .
Mathematics 11 01155 g006
Table 1. Computational costs of the gradients of the objective function.
Table 1. Computational costs of the gradients of the objective function.
ComputationCost
P Ω ( Q R M ) R T ( R R T + δ I r ) 1 ( 4 r + 1 ) | Ω | + 2 ( n 1 + n 2 ) r 2 + C chol r 3
Q T P Ω ( Q R M ) ( Q T Q + δ I r ) 1 ( 4 r + 1 ) | Ω | + 2 ( n 1 + n 2 ) r 2 + C chol r 3
Q T P Ω ( Q R M ) / ( 1 + δ ) ( 4 r + 1 ) | Ω |
Table 2. Computation costs of the metric.
Table 2. Computation costs of the metric.
ComputationCost
T r ( ξ Q T η Q ( R R T + δ I r ) ) 2 ( n 1 + n 2 + r ) r 2
T r ( ξ R η R T ( Q T Q + δ I r ) ) 2 ( n 1 + n 2 + r ) r 2
T r ( ξ R η R T ( 1 + δ ) ) 2 n 2 r 2
Table 3. Computational results for Figure 3 with matrices size of 2000 × 2000 . The time is rounded to three decimal places and RMSE is rounded to five decimal places.
Table 3. Computational results for Figure 3 with matrices size of 2000 × 2000 . The time is rounded to three decimal places and RMSE is rounded to five decimal places.
SubfigureMethodTimeRMSEIteration
(a)QRRGD+ELS108.282 9.42416 × 10 11 223
RGD+ELS120.644 5.65317 × 10 6 250
QRRGD+IELS58.763 2.66777 × 10 2 250
RGD+IELS57.905 2.88969 × 10 2 250
(b)QRRGD+ELS113.655 9.89826 × 10 11 237
RGD+ELS122.815 1.21759 × 10 5 250
QRRGD+IELS59.640 2.27510 × 10 1 250
RGD+IELS59.400 2.45927 × 10 1 250
(c)QRRCG+ELS109.363 9.39990 × 10 11 227
RCG+ELS118.726 3.69309 × 10 3 250
QRRCG+IELS58.677 2.50264 × 10 2 250
RCG+IELS59.849 2.68750 × 10 2 250
(d)QRRCG+ELS121.740 9.28316 × 10 10 250
RCG+ELS119.905 1.36830 × 10 5 250
QRRCG+IELS59.449 2.24703 × 10 1 250
RCG+IELS58.432 2.45275 × 10 1 250
Table 4. Computational results for Figure 4 with matrices size of 4000 × 4000 . The time is rounded to three decimal places and RMSE is rounded to five decimal places.
Table 4. Computational results for Figure 4 with matrices size of 4000 × 4000 . The time is rounded to three decimal places and RMSE is rounded to five decimal places.
SubfigureMethodTimeRMSEIteration
(a)QRRGD+ELS529.851 9.89657 × 10 11 181
RGD+ELS733.993 2.40792 × 10 10 250
QRRGD+IELS337.730 1.76829 × 10 2 250
RGD+IELS335.950 2.82502 × 10 2 250
(b)QRRGD+ELS586.522 9.55942 × 10 11 201
RGD+ELS745.970 4.96694 × 10 4 250
QRRGD+IELS349.708 1.53603 × 10 1 250
RGD+IELS348.213 3.59285 × 10 1 250
(c)QRRCG+ELS547.370 9.03539 × 10 11 173
RCG+ELS782.545 1.99382 × 10 8 250
QRRCG+IELS351.655 1.77931 × 10 2 250
RCG+IELS350.344 2.56178 × 10 2 250
(d)QRRCG+ELS586.297 9.00940 × 10 11 199
RCG+ELS738.357 1.38944 × 10 7 250
QRRCG+IELS341.237 1.66425 × 10 1 250
RCG+IELS338.835 3.59287 × 10 1 250
Table 5. Computational results for Figure 5 with matrices size ranging from 2000 × 2000 to 8000 × 2000 . The time is rounded to three decimal places and RMSE is rounded to five decimal places.
Table 5. Computational results for Figure 5 with matrices size ranging from 2000 × 2000 to 8000 × 2000 . The time is rounded to three decimal places and RMSE is rounded to five decimal places.
r,OSFSizeMethodTimeRMSEIteration
18,2.79 2000 × 2000 QRRCG102.939 9.78333 × 10 11 210
RCG118.397 1.71532 × 10 3 250
24,2.79 4000 × 2000 QRRCG211.122 9.43873 × 10 11 234
RCG230.015 5.98057 × 10 3 250
27,2.79 6000 × 2000 QRRCG335.745 1.03872 × 10 8 250
RCG336.917 1.07408 × 10 2 250
29,2.77 8000 × 2000 QRRCG442.133 1.74723 × 10 9 250
RCG449.752 1.17567 × 10 1 250
Table 6. Computational results for Figure 6 on PeMS Traffic. The time is rounded to three decimal places and RMSE is rounded to five decimal places.
Table 6. Computational results for Figure 6 on PeMS Traffic. The time is rounded to three decimal places and RMSE is rounded to five decimal places.
SubfigureMethodTimeRMSEIteration
(a)QRG+ELS189.945 1.57521 × 10 2 250
RGD+ELS192.104 1.57584 × 10 2 250
QRRGD+IELS116.213 1.62539 × 10 2 250
RGD+IELS116.576 1.62615 × 10 2 250
(b)QRRGD+ELS198.433 1.59324 × 10 2 250
RGD+ELS196.615 1.59392 × 10 2 250
QRRGD+IELS115.070 1.63650 × 10 2 250
RGD+IELS113.418 1.63721 × 10 2 250
(c)QRRCG+ELS196.291 1.54291 × 10 2 250
RCG+ELS194.373 1.54170 × 10 2 250
QRRCG+IELS112.798 1.59846 × 10 2 250
RCG+IELS122.820 1.59796 × 10 2 250
(d)QRRCG+ELS201.373 1.44327 × 10 2 250
RCG+ELS196.029 1.44283 × 10 2 250
QRRCG+IELS112.663 1.48999 × 10 2 250
RCG+IELS112.358 1.48827 × 10 2 250
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Share and Cite

MDPI and ACS Style

Wang, K.; Chen, Z.; Ying, S.; Xu, X. Low-Rank Matrix Completion via QR-Based Retraction on Manifolds. Mathematics 2023, 11, 1155. https://doi.org/10.3390/math11051155

AMA Style

Wang K, Chen Z, Ying S, Xu X. Low-Rank Matrix Completion via QR-Based Retraction on Manifolds. Mathematics. 2023; 11(5):1155. https://doi.org/10.3390/math11051155

Chicago/Turabian Style

Wang, Ke, Zhuo Chen, Shihui Ying, and Xinjian Xu. 2023. "Low-Rank Matrix Completion via QR-Based Retraction on Manifolds" Mathematics 11, no. 5: 1155. https://doi.org/10.3390/math11051155

APA Style

Wang, K., Chen, Z., Ying, S., & Xu, X. (2023). Low-Rank Matrix Completion via QR-Based Retraction on Manifolds. Mathematics, 11(5), 1155. https://doi.org/10.3390/math11051155

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop