{'fraction_non_alphanumeric': 0.041118052218484705, 'fraction_numerical': 0.016594585936248598, 'mean_word_length': 4.323697450328302, 'pattern_counts': {'":': 0, '<': 12, '<?xml version=': 0, '>': 9, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 18, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Algorithms for nonnegative matrix and tensor factorizations: a unified view based on block coordinate descent framework

We review algorithms developed for nonnegative matrix factorization (NMF) and nonnegative tensor factorization (NTF) from a unified view based on the block coordinate descent (BCD) framework. NMF and NTF are low-rank approximation methods for matrices and tensors in which the low-rank factors are constrained to have only nonnegative elements. The nonnegativity constraints have been shown to enable natural interpretations and allow better solutions in numerous applications including text analysis, computer vision, and bioinformatics. However, the computation of NMF and NTF remains challenging and expensive due the constraints. Numerous algorithmic approaches have been proposed to efficiently compute NMF and NTF. The BCD framework in constrained non-linear optimization readily explains the theoretical convergence properties of several efficient NMF and NTF algorithms, which are consistent with experimental observations reported in literature. In addition, we discuss algorithms that do not fit in the BCD framework contrasting them from those based on the BCD framework. With insights acquired from the unified perspective, we also propose efficient algorithms for updating NMF when there is a small change in the reduced dimension or in the data. The effectiveness of the proposed updating algorithms are validated experimentally with synthetic and real-world data sets.


Introduction
Nonnegative matrix factorization (NMF) is a dimension reduction and factor analysis method. Many dimension reduction techniques are closely related to the low-rank approximations of matrices, and NMF is special in that the low-rank factor matrices are constrained to have only nonnegative elements. The nonnegativity reflects the inherent representation of data in many application areas, and the resulting low-rank factors lead to physically natural interpretations [66]. NMF was first introduced by Paatero and Tapper [74] as positive matrix factorization and subsequently popularized by Lee and Seung [66]. Over the last decade, NMF has received enormous attention and has been successfully applied to a broad range of important problems in areas including text mining [77,85], computer vision [47,69], bioinformatics [10,23,52], spectral data analysis [76], and blind source separation [22] among many others.
Suppose a nonnegative matrix A ∈ R M×N is given. When the desired lower dimension is K , the goal of NMF is to find two matrices W ∈ R M×K and H ∈ R N ×K having only nonnegative elements such that According to (1), each data point, which is represented as a column in A, can be approximated by an additive combination of the nonnegative basis vectors, which are represented as columns in W. As the goal of dimension reduction is to discover compact representation in the form of (1), K is assumed to satisfy that K < min {M, N }. Matrices W and H are found by solving an optimization problem defined with Frobenius norm, Kullback-Leibler divergence [67,68], or other divergences [24,68]. In this paper, we focus on the NMF based on Frobenius norm, which is the most commonly used formulation: subject to W ≥ 0, H ≥ 0.
The constraints in (2) mean that all the elements in W and H are nonnegative. Problem (2) is a non-convex optimization problem with respect to variables W and H, and finding its global minimum is NP-hard [81]. A good algorithm therefore is expected to compute a local minimum of (2). Our first goal in this paper is to provide an overview of algorithms developed to solve (2) from a unifying perspective. Our review is organized based on the block coordinate descent (BCD) method in non-linear optimization, within which we show that most successful NMF algorithms and their convergence behavior can be explained. Among numerous algorithms studied for NMF, the most popular is the multiplicative updating rule by Lee and Seung [67]. This algorithm has an advantage of being simple and easy to implement, and it has contributed greatly to the popularity of NMF. However, slow convergence of the multiplicative updating rule has been pointed out [40,71], and more efficient algorithms equipped with stronger theoretical convergence property have been introduced. The efficient algorithms are based on either the alternating nonnegative least squares (ANLS) framework [53,59,71] or the hierarchical alternating least squares (HALS) method [19,20]. We show that these methods can be derived using one common framework of the BCD method and then characterize some of the most promising NMF algorithms in Sect. 2. Algorithms for accelerating the BCD-based methods as well as algorithms that do not fit in the BCD framework are summarized in Sect. 3, where we explain how they differ from the BCD-based methods. In the ANLS method, the subproblems appear as the nonnegativity constrained least squares (NLS) problems. Much research has been devoted to design NMF algorithms based on efficient methods to solve the NLS subproblems [18,42,51,53,59,71]. A review of many successful algorithms for the NLS subproblems is provided in Sect. 4 with discussion on their advantages and disadvantages.
Extending our discussion to low-rank approximations of tensors, we show that algorithms for some nonnegative tensor factorization (NTF) can similarly be elucidated based on the BCD framework. Tensors are mathematical objects for representing multidimensional arrays; vectors and matrices are first-order and second-order special cases of tensors, respectively. The canonical decomposition (CANDECOMP) [14] or the parallel factorization (PARAFAC) [43], which we denote by the CP decomposition, is one of the natural extensions of the singular value decomposition to higher order tensors. The CP decomposition with nonnegativity constraints imposed on the loading matrices [19,21,32,54,60,84], which we denote by nonnegative CP (NCP), can be computed in a way that is similar to the NMF computation. We introduce details of the NCP decomposition and summarize its computation methods based on the BCD method in Sect. 5.
Lastly, in addition to providing a unified perspective, our review leads to the realizations of NMF in more dynamic environments. Such a common case arises when we have to compute NMF for several K values, which is often needed to determine a proper K value from data. Based on insights from the unified perspective, we propose an efficient algorithm for updating NMF when K varies. We show how this method can compute NMFs for a set of different K values with much less computational burden. Another case occurs when NMF needs to be updated efficiently for a data set which keeps changing due to the inclusion of new data or the removal of obsolete data. This often occurs when the matrices represent data from time-varying signals in computer vision [11] or text mining [13]. We propose an updating algorithm which takes advantage of the fact that most of data in two consecutive time steps are overlapped so that we do not have to compute NMF from scratch. Algorithms for these cases are discussed in Sect. 7, and their experimental validations are provided in Sect. 8. Our discussion is focused on the algorithmic developments of NMF formulated as (2). In Sect. 9, we only briefly discuss other aspects of NMF and conclude the paper.
Notations: Notations used in this paper are as follows. A lowercase or an uppercase letter, such as x or X , denotes a scalar; a boldface lowercase letter, such as x, denotes a vector; a boldface uppercase letter, such as X, denotes a matrix; and a boldface Euler script letter, such as X, denotes a tensor of order three or higher. Indices typically start from 1 to its uppercase letter: For example, n ∈ {1, . . . , N }. Elements of a sequence of vectors, matrices, or tensors are denoted by superscripts within parentheses, such as X (1) , . . . , X (N ) , and the entire sequence is denoted by X (n) . When matrix X is given, (X) ·i or x ·i denotes its ith column, (X) i· or x i· denotes its ith row, and x i j denotes its (i, j)th element. For simplicity, we also let x i (without a dot) denote the ith column of X. The set of nonnegative real numbers are denoted by R + , and X ≥ 0 indicates that the elements of X are nonnegative. The notation [X] + denotes a matrix that is the same as X except that all its negative elements are set to zero. A nonnegative matrix or a nonnegative tensor refers to a matrix or a tensor with only nonnegative elements. The null space of matrix X is denoted by null(X). Operator denotes element-wise multiplcation of vectors or matrices.

A unified view-BCD framework for NMF
The BCD method is a divide-and-conquer strategy that can be generally applied to non-linear optimization problems. It divides variables into several disjoint subgroups and iteratively minimize the objective function with respect to the variables of each subgroup at a time.
We first introduce the BCD framework and its convergence properties and then explain several NMF algorithms under the framework.
Consider a constrained non-linear optimization problem: where X is a closed convex subset of R N . An important assumption to be exploited in the BCD framework is that X is represented by a Cartesian product: where The BCD method solves for x m fixing all other subvectors of x in a cyclic manner. That is, if is given as the current iterate at the ith step, the algorithm generates the next iterate ) block by block, according to the solution of the following subproblem: Also known as a non-linear Gauss-Siedel method [5], this algorithm updates one block each time, always using the most recently updated values of other blocks xm,m = m. This is important since it ensures that after each update the objective function value does not increase. For a sequence x (i) where each x (i) is generated by the BCD method, the following property holds.

Theorem 1 Suppose f is continuously differentiable in
is uniquely attained. Let x (i) be the sequence generated by the BCD method in (5). Then, every limit point of x (i) is a stationary point. The uniqueness of the minimum is not required when M is two.
The proof of this theorem for an arbitrary number of blocks is shown in Bertsekas [5], and the last statement regarding the two-block case is due to Grippo and Sciandrone [41]. For a non-convex optimization problem, most algorithms only guarantee the stationarity of a limit point [46,71].
When applying the BCD method to a constrained non-linear programming problem, it is critical to wisely choose a partition of X , whose Cartesian product constitutes X . An important criterion is whether subproblems (5) for m = 1, . . . , M are efficiently solvable: For example, if the solutions of subproblems appear in a closed form, each update can be computed fast. In addition, it is worth checking whether the solutions of subproblems depend on each other. The BCD method requires that the most recent values need to be used for each subproblem (5). When the solutions of subproblems depend on each other, they have to be computed sequentially to make use of the most recent values; if solutions for some blocks are independent from each other, however, simultaneous computation of them would be possible. We discuss how different choices of partitions lead to different NMF algorithms. Three cases of partitions are shown in Fig. 1, and each case is discussed below. In each case, the highlighted part for example is updated fixing all the rest. a Two matrix blocks. b 2K vector blocks. c K (M + N ) scalar blocks 2.1 BCD with two matrix blocks-ANLS method In (2), a natural partitioning of the variables is the two blocks representing W and H, as shown in Fig. 1a. In this case, following the BCD method in (5), we take turns solving These subproblems can be written as Since subproblems (7) are the nonnegativity constrained least squares (NLS) problems, the two-block BCD method has been called the alternating nonnegative least square (ANLS) framework [53,59,71]. Even though the subproblems are convex, they do not have a closedform solution, and a numerical algorithm for the subproblem has to be provided. Several approaches for solving the NLS subproblems proposed in NMF literature are discussed in Sect. 4 [18,42,51,53,59,71]. According to Theorem 1, the convergence property of the ANLS framework can be stated as follows. (7) is attained at each step, every limit point of the sequence (W, H) (i) generated by the ANLS framework is a stationary point of (2).

Corollary 1 If a minimum of each subproblem in
Note that the minimum is not required to be unique for the convergence result to hold because the number of blocks are two [41]. Therefore, H in (7a) or W in (7b) need not be of full column rank for the property in Corollary 1 to hold. On the other hand, some numerical methods for the NLS subproblems require the full rank conditions so that they return a solution that attains a minimum: See Sect. 4 as well as regularization methods in Sect. 2.4. Subproblems (7) can be decomposed into independent NLS problems with a single righthand side vector. For example, and we can solve the problems in the second term independently. This view corresponds to a BCD method with M + N vector blocks, in which each block corresponds to a row of W or H. In literature, however, this view has not been emphasized because often it is more efficient to solve the NLS problems with multiple right-hand sides altogether: See Sect. 4.

BCD with 2K vector blocks-HALS/RRI method
Let us now partition the unknowns into 2K blocks in which each block is a column of W or H, as shown in Fig. 1b. In this case, it is easier to consider the objective function in the following form: where The form in (9) represents that A is approximated by the sum of K rank-one matrices.
Following the BCD scheme, we can minimize f by iteratively solving for k = 1, . . . , K , and for k = 1, . . . , K . These subproblems appear as where A promising aspect of this 2K block partitioning is that each subproblem in (10) has a closed-form solution, as characterized in the following theorem.

Theorem 2 Consider a minimization problem
where G = [g 1 , . . . , g N ], and the problems in the second term are independent of each other. Let h(v n ) = uv n − g n 2 2 = u 2 2 v 2 n − 2v n u T g n + g n 2 2 . Since ∂h ∂v n = 2(v n u 2 2 − g T n u), if g T n u ≥ 0, it is clear that the minimum value of h(v n ) is attained at v n = g T n u u T u . If g T n u < 0, the value of h(v n ) increases as v n becomes larger than zero, and therefore the minimum is attained at v n = 0. Combining the two cases, the solution can be expressed as v n = [g T n u] + u T u .
Using Theorem 2, the solutions of (10) can be stated as This 2K -block BCD algorithm has been studied under the name of the hierarchical alternating least squares (HALS) method by Cichocki et al. [19,20] and the rank-one residue iteration (RRI) independently by Ho [44]. According to Theorem 1, the convergence property of the HALS/RRI algorithm can be written as follows.

Corollary 2
If the columns of W and H remain nonzero throughout all the iterations and the minimums in (13) are attained at each step, every limit point of the sequence (W, H) (i) generated by the HALS/RRI algorithm is a stationary point of (2).
In practice, a zero column could occur in W or H during the HALS/RRI algorithm. This To prevent zero columns, a small positive number could be used for the maximum operator in (13): That is, max(·, ) with a small positive number such as 10 −16 is used instead of max(·, 0) [20,35]. The HALS/RRI algorithm with this modification often shows faster convergence compared to other BCD methods or previously developed methods [37,59]. See Sect. 3.1 for acceleration techniques for the HALS/RRI method and Sect. 6.2 for more discussion on experimental comparisons.
For an efficient implementation, it is not necessary to explicitly compute R k . Replacing R k in (13) with the expression in (11), the solutions can be rewritten as The choice of update formulae is related with the choice of an update order. Two versions of an update order can be considered: and When using (13), update order (15) is more efficient because R k is explicitly computed and then used to update both w k and h k . When using (14), although either (15) N ), the latter is more efficient. Moreover, the memory requirement of (14) is smaller because R k need not be stored. For more details, see Cichocki and Phan [19].

BCD with K (M + N ) scalar blocks
In one extreme, the unknowns can be partitioned into K (M + N ) blocks of scalars, as shown in Fig. 1c. In this case, every element of W and H is considered as a block in the context of Theorem 1. To this end, it helps to write the objective function as a quadratic function of scalar w mk or h nk assuming all other elements in W and H are fixed: where a m· and a ·n denote the mth row and the nth column of A, respectively. According to the BCD framework, we iteratively update each block by The updates of w mk and h nk are independent of all other elements in the same column. Therefore, it is possible to update all the elements in each column of W (and H) simultaneously. Once we organize the update of (18) column-wise, the result is the same as (14). That is, a particular arrangement of the BCD method with scalar blocks is equivalent to the BCD method with 2K vector blocks. Accordingly, the HALS/RRI method can be derived by the BCD method either with vector blocks or with scalar blocks. On the other hand, it is not possible to simultaneously solve for the elements in each row of W (or H) because their solutions depend on each other. The convergence property of the scalar block case is similar to that of the vector block case. (18) are attained at each step, every limit point of the sequence (W, H) (i) generated by the BCD method with K (M + N ) scalar blocks is a stationary point of (2).

Corollary 3 If the columns of W and H remain nonzero throughout all the iterations and if the minimums in
The multiplicative updating rule also uses element-wise updating [67]. However, the multiplicative updating rule is different from the scalar block BCD method in a sense that its solutions are not optimal for subproblems (18). See Sect. 3.2 for more discussion.

BCD for some variants of NMF
To incorporate extra constraints or prior information into the NMF formulation in (2), various regularization terms can be added. We can consider an objective function min W,H≥0 where φ(·) and ψ(·) are regularization terms that often involve matrix or vector norms.
Here we discuss the Frobenius-norm and the l 1 -norm regularization and show how NMF regularized by those norms can be easily computed using the BCD method. Scalar parameters α or β in this subsection are used to control the strength of regularization. The Frobenius-norm regularization [53,76] corresponds to The Frobenius-norm regularization may be used to prevent the elements of W or H from growing too large in their absolute values. It can also be adopted to stabilize the BCD methods.
In the two matrix block case, since the uniqueness of the minimum of each subproblem is not required according to Corollary 1, H in (7a) or W in (7b) need not be of full column rank. The full column rank condition is however required for some algorithms for the NLS subproblems, as discussed in Sect. 4. As shown below, the Frobenius-norm regularization ensures that the NLS subproblems of the two matrix block case are always defined with a matrix of full column rank. Similarly in the 2K vector block or the K (M + N ) scalar block cases, the condition that w k and h k remain nonzero throughout all the iterations can be relaxed when the Frobenius-norm regularization is used.
Applying the BCD framework with two matrix blocks to (19) with the regularization term in (20), W can be updated as where I K is a K × K identity matrix and 0 K ×M is a K × M matrix containing only zeros, and H can be updated with a similar reformulation. Clearly, if α is nonzero, (21) is of full column rank. Applying the BCD framework with 2K vector blocks, a column of W is updated as If α is nonzero, the solution of (22) is uniquely defined without requiring h k to be a nonzero vector.
The l 1 -norm regularization can be adopted to promote sparsity in the factor matrices. In many areas such as linear regression [80] and signal processing [16], it has been widely known that the l 1 -norm regularization promotes sparse solutions. In NMF, sparsity was shown to improve the part-based interpretation [47] and the clustering ability [52,57]. When sparsity is desired on matrix H, the l 1 -norm regularization can be set as where h n· represents the nth row of H. The l 1 -norm term of ψ(H) in (23) promotes sparsity on H while the Frobenius norm term of φ(W) is needed to prevent W from growing too large. Similarly, sparsity can be imposed on W or on both W and H.
Applying the BCD framework with two matrix blocks to (19) with the regularization term in (23), W can be updated as (21), and H can be updated as where 1 1×K is a row vector of length K containing only ones. Applying the BCD framework with 2K vector blocks, a column of W is updated as (22), and a column of H is updated as Note that the l 1 -norm term in (23) is written as the sum of the squares of the l 1 -norm of the columns of H. Alternatively, we can impose the l 1 -norm based regularization without squaring: That is, Although both (23) and (26) promote sparsity, the squared form in (23) is easier to handle with the two matrix block case, as shown above. Applying the 2K -vector BCD framework on (19) with the regularization term in (26), the update for a column of h is written as For more information, see [19], Section 4.7.4 of [22], and Section 4.5 of [44]. When the BCD framework with two matrix blocks is used with the regularization term in (26), a custom algorithm for l 1 -regularized least squares problem has to be involved: See, e.g., [30].

Accelerated methods
The BCD methods described so far have been very successful for the NMF computation. In addition, several techniques to accelerate the methods have been proposed. Korattikara et al. [62] proposed a subsampling strategy to improve the two matrix block (i.e., ANLS) case. Their main idea is to start with a small factorization problem, which is obtained by random subsampling, and gradually increase the size of subsamples. Under the assumption of asymptotic normality, the decision whether to increase the size is made based on statistical hypothesis testing. Gillis and Glineur [38] proposed a multi-level approach, which also gradually increases the problem size based on a multi-grid representation. The method in [38] is applicable not only to the ANLS methods, but also to the HALS/RRI method and the multiplicative updating method.
Hsieh and Dhillon proposed a greedy coordinate descent method [48]. Unlike the HALS/RRI method, in which every element is updated exactly once per iteration, they selectively choose the elements whose update will lead to the largest decrease of the objective function. Although their method does not follow the BCD framework, they showed that every limit point generated by their method is a stationary point. Gillis and Glineur also proposed an acceleration scheme for the HALS/RRI and the multiplicative updating methods: Unlike the standard versions, their approach repeats updating the elements of W several times before updating the elements of H [37]. Noticeable improvements in the speed of convergence is reported.

Multiplicative updating rules
The multiplicative updating rule [67] is by far the most popular algorithm for NMF. Each element is updated through multiplications as Since elements are updated in this multiplication form, the nonnegativity is always satisfied when A is nonnegative. This algorithm can be contrasted with the HALS/RRI algorithm as follows. The element-wise gradient descent updates for (2) can be written as where λ mk and μ nk represent step-lengths. The multiplicative updating rule is obtained by taking whereas the HALS/RRI algorithm interpreted as the BCD method with scalar blocks as in (18) is obtained by taking The step-lengths chosen in the multiplicative updating rule is conservative enough so that the result is always nonnegative. On the other hand, the step-lengths chosen in the HALS/RRI algorithm could potentially lead to a nonnegative value, and therefore the projection [·] + is needed. Although the convergence property of the BCD framework holds for the HALS/RRI algorithm as in Corollary 3, it does not hold for the multiplicative updating rule since the step-lengths in (28) does not achieve the optimal solution. In practice, the convergence of the HALS/RRI algorithm is much faster than that of the multiplicative updating. Lee and Seung [67] showed that under the multiplicative updating rule, the objective function in (2) is non-increasing. However, it is unknown whether it converges to a stationary point. Gonzalez and Zhang demonstrated the difficulty [40], and the slow convergence of multiplicative updates has been further reported in [53,58,59,71]. To overcome this issue, Lin [70] proposed a modified update rule for which every limit point is stationary; note that, after this modification, the update rule becomes additive instead of multiplicative.
Since the values are updated only though multiplications, the elements of W and H obtained by the multiplicative updating rule typically remain nonzero. Hence, its solution matrices typically are denser than those from the BCD methods. The multiplicative updating rule breaks down if a zero value occurs to an element of the denominators in (27). To curcumvent this difficulty, practical implementations often add a small number, such as 10 −16 , to each element of the denominators.

Alternating least squares method
In the two-block BCD method of Sect. 2.1, it is required to find a minimum of the nonnegativity-constrained least squares (NLS) subproblems in (7). Earlier, Berry et al. has proposed to approximately solve the NLS subproblems hoping to accelerate the algorithm [4]. In their alternating least squares (ALS) method, they solved the least squares problems ignoring the nonnegativity constraints, and then negative elements in the computed solution matrix are set to zeros. That is, W and H are updated as When H T H or W T W is rank-deficient, the Moore-Penrose pseudo-inverse may be used instead of the inverse operator. Unfortunately, results from (30) are not the minimizers of subproblems (7). Although each subproblem of the ALS method can be solved efficiently, the convergence property in Corollary 1 is not applicable to the ALS method. In fact, the ALS method does not necessarily decrease the objective function after each iteration [59].
It is interesting to note that the HALS/RRI method does not have this difficulty although the same element-wise projection is used. In the HALS/RRI method, a subproblem in the form of , which is the optimal solution of (31) as shown in Theorem 2. On the other hand, in the ALS algorithm, a subproblem in the form of , which is not an optimal solution of (32).

Successive rank one deflation
Some algorithms have been designed to compute NMF based on successive rank-one deflation. This approach is motivated from the fact that the singular value decomposition (SVD) can be computed through successive rank-one deflation. When considered for NMF, however, the rank-one deflation method has a few issues as we summarize below. Let us first recapitulate the deflation approach for SVD. Consider a matrix A ∈ R M×N of rank R, and suppose its SVD is written as The rank-K SVD for K < R is obtained by taking only the first K singular values and corresponding singular vectors:Ã whereŨ K ∈ R M×K andṼ K ∈ R N ×K are sub-matrices of U and V obtained by taking the leftmost K columns. It is well-known that the best rank-K approximation of A in terms of minimizing the l 2 -norm or the Frobenius norm of the residual matrix is the rank-K SVD: See Theorem 2.5.3 in Page 72 of Golub and Van Loan [39]. The rank-K SVD can be computed through successive rank one deflation as follows. First, the best rank-one approximation, σ 1 u 1 v T 1 , is computed with an efficient algorithm such as the power iteration. Then, the residual matrix is obtained asẼ 1 , and the rank ofẼ 1 is R − 1. For the residual matrixẼ 1 , its best rank-one approximation, σ 2 u 2 v T 2 , is obtained, and the residual matrixẼ 2 , whose rank is R − 2, can be found in the same manner: Repeating this process for K times, one can obtain the rank-K SVD.
When it comes to NMF, a notable theoretical result about nonnegative matrices relates SVD and NMF when K = 1. The following theorem, which extends the Perron-Frobenius theorem [3,45], is shown in Chapter 2 of Berman and Plemmons [3].

Theorem 3 For a nonnegative symmetric matrix
, the eigenvalue of A with the largest magnitude is nonnegative, and there exists a nonnegative eigenvector corresponding to the largest eigenvalue.
A direct consequence of Theorem 3 is the nonnegativity of the best rank-one approximation.

Corollary 4 (Nonnegativity of best rank-one approximation) For any nonnegative matrix
has an optimal solution satisfying u ≥ 0 and v ≥ 0.
Another way to realizing Corollary 4 is through the use of the SVD. For a nonnegative matrix A ∈ R M×N + and for any vectors u ∈ R M and v ∈ R N , Hence, element-wise absolute values can be taken from the left and right singular vectors that correspond to the largest singular value to achieve the best rank-one approximation satisfying nonnegativity. There might be other optimal solutions of (34) involving negative numbers: See [34]. The elegant property in Corollary 4, however, is not readily applicable when K ≥ 2. After the best rank-one approximation matrix is deflated, the residual matrix may contain negative elements, and then Corollary 4 is not applicable any more. In general, successive rank-one deflation is not an optimal approach for NMF computation. Let us take a look at a small example which demonstrates this issue. Consider matrix A given as The best rank-one approximation of A is shown as A 1 below. The residual is E 1 = A − A 1 , which contains negative elements: One of the best rank-one approximations of E 1 with nonnegativity constraints is A 2 , and the residual matrix is E 2 = A 1 − A 2 : The nonnegative rank-two approximation obtained by this rank-one deflation approach is However, the best nonnegative rank-two approximation of A is in factÂ 2 with residual matrixÊ 2 Therefore, a strategy that successively finds the best rank-one approximation with nonnegativity constraints and deflates in each step does not necessarily lead to an optimal solution of NMF.
Due to this difficulty, some variations of rank-one deflation have been investigated for NMF. Biggs et al. [6] proposed a rank-one reduction algorithm in which they look for a nonnegative submatrix that is close to a rank-one approximation. Once such a submatrix is identified, they compute the best rank-one approximation using the power method and ignore the residual. Gillis and Glineur [36] sought a nonnegative rank-one approximation under the constraint that the residual matrix remains element-wise nonnegative. Due to the constraints, however, the problem of finding the nonnegative rank-one approximation becomes more complicated and computationally expensive than the power iteration. Optimization properties such as a convergence to a stationary point has not been shown for these modified rank-one reduction methods.
It is worth noting the difference between the HALS/RRI algorithm, described as the 2K vector block case in Sect. 2.2, and the rank-one deflation method. These approaches are similar in that the rank-one approximation problem with nonnegativity constraints is solved in each step, filling in the kth columns of W and H with the solution for k = 1, . . . , K . In the rank-one deflation method, once the kth columns of W and H are computed, they are fixed and kept as a part of the final solution before the (k + 1)th columns are computed. On the other hand, the HALS/RRI algorithm updates all the columns through multiple iterations until a local minimum is achieved. This simultaneous searching for all 2K vectors throughout the iterations is necessary to achieve an optimal solution of NMF, unlike in the case of SVD.
where B ∈ R P×Q , C = [c 1 , . . . , c R ] ∈ R Q×R , and X = [x 1 , . . . , x R ] ∈ R Q×R . We mainly discuss two groups of algorithms for the NLS problems. The first group consists of the gradient descent and the Newton-type methods that are modified to satisfy the nonnegativity constraints using a projection operator. The second group consists of the active-set and the active-set-like methods, in which zero and nonzero variables are explicitly kept track of and a system of linear equations is solved at each iteration. For more details, see Lawson and Hanson [64], Bjork [8], and Chen and Plemmons [15].
To facilitate our discussion, we state a simple NLS problem with a single right-hand side: Problem (36) may be solved by handling independent problems for the columns of X, whose form appears as (37). Otherwise, the problem in (36) can also be transformed into min

Projected iterative methods
Projected iterative methods for the NLS problems are designed based on the fact that the objective function in (36) is differentiable and that the projection to the nonnegative orthant is easy to compute. The first method of this type proposed for NMF was the projected gradient method of Lin [71]. Their update formula is written as where x (i) and α (i) represent the variables and the step length at the ith iteration.
Step length α (i) is chosen by a back-tracking line search to satisfy Armijo's rule with an optional stage that increases the step length. Kim et al. [51] proposed a quasi-Newton method by utilizing the second order information to improve convergence: where y (i) is a subvector of x (i) with elements that are not optimal in terms of the Karush-Kuhn-Tucker (KKT) conditions. They efficiently updated D (i) using the BFGS method and selected α (i) by a back-tracking line search. Whereas Lin considered a stacked-up problem as in (38), the quasi-Newton method by Kim et al. was applied to each column separately. A notable variant of the projected gradient method is the Barzilai-Borwein method [7]. Han et al. [42] proposed alternating projected Barzilai-Borwein method for NMF. A key characteristic of the Barzilai-Borwein method in unconstrained quadratic programming is that the step-length is chosen by a closed-form formula without having to perform a line search: −1) ).  [73] proposed an interior point gradient method, and Friedlander and Hatz [32] used a two-metric projected gradient method in their study on NTF. Zdunek and Cichocki [86] proposed a quasi-Newton method, but its lack of convergence was pointed out [51]. Zdunek and Cichocki [87] also studied the projected Landweber method and the projected sequential subspace method.

Active-set and active-set-like methods
The active-set method for the NLS problems is due to Lawson and Hanson [64]. A key observation is that, if the zero and nonzero elements of the final solution are known in advance, the solution can be easily computed by solving an unconstrained least squares problem for the nonzero variables and setting the rest to zeros. The sets of zero and nonzero variables are referred to as active and passive sets, respectively. In the active-set method, so-called workings sets are kept track of until the optimal active and passive sets are found. A rough pseudo-code for the active-set method is shown in Algorithm 1.
Lawson and Hanson's method has been a standard for the NLS problems, but applying it directly to NMF is very slow. When used for NMF, it can be accelerated in two different ways. The first approach is to use the QR decomposition to solve (41) or the Cholesky decomposition to solve the normal equations B T E B E z = B T E c and have the Cholesky or QR factors updated by the Givens rotations [39]. The second approach, which was proposed by Bro and De Jong [9] and Ven Benthem and Keenan [81], is to identify common computations in solving the NLS problems with multiple right-hand sides. More information and experimental comparisons of these two approaches are provided in [59].
The active-set methods possess a property that the objective function decreases after each iteration; however, maintaining this property often limits its scalability. A main computational burden of the active-set methods is in solving the unconstrained least squares problem (41); hence, the number of iterations required until termination considerably affects the computation cost. In order to achieve the monotonic decreasing property, typically only one variable is exchanged between working sets per iteration. As a result, when the number of unknowns is large, the number of iterations required for termination grows, slowing down the method. The block principal pivoting method developed by Kim and Park [58,59] overcomes this limitation. Their method, which is based on the work of Judice and Pires [50], allows the exchanges of multiple variables between working sets. This method does not maintain the nonnegativity of intermediate vectors nor the monotonic decrease of the objective function, but it requires a smaller number of iterations until termination than the active set methods. It is worth emphasizing that the grouping-based speed-up technique, which was earlier devised for the active-set method, is also effective with the block principal pivoting method for the NMF computation: For more details, see [59].

Discussion and other methods
A main difference between the projected iterative methods and the active-set-like methods for the NLS problems lies in their convergence or termination. In projected iterative methods, a sequence of tentative solutions is generated so that an optimal solution is approached in the limit. In practice, one has to somehow stop iterations and return the current estimate, which might be only an approximation of the solution. In the active-set and active-set-like methods, in contrast, there is no concept of a limit point. Tentative solutions are generated with a goal of finding the optimal active and passive set partitioning, which is guaranteed to be found in a finite number of iterations since there are only a finite number of possible active and passive set partitionings. Once the optimal active and passive sets are found, the methods terminate. There are trade-offs of these behavior. While the projected iterative methods may return an approximate solution after a few number of iterations, the active-set and active-set-like methods only return a solution after they terminate. After the termination, however, the solution from the active-set-like methods is an exact solution only subject to numerical rounding errors while the solution from the projected iterative methods might be an approximate one.
Other approaches for solving the NLS problems can be considered as a subroutine for the NMF computation. Bellavia et al. [2] have studied an interior point Newton-like method, and Franc et al. [31] presented a sequential coordinate-wise method. Some observations about the NMF computation based on these methods as well as other methods are offered in Cichocki et al. [22]. Chu and Lin [18] proposed an algorithm based on low-dimensional polytope approximation: Their algorithm is motivated by a geometrical interpretation of NMF that data points are approximated by a simplicial cone [27].
Different conditions are required for the NLS algorithms to guarantee convergence or termination. The requirement of the projected gradient method [71] is mild as it only requires an appropriate selection of the step-length. Both the quasi-Newton method [51] and the interior point gradient method [73] require that matrix B in (37) is of full column rank. The active-set method [53,64] does not require the full-rank condition as long as a zero vector is used for initialization [28]. In the block principal pivoting method [58,59], on the other hand, the full-rank condition is required. Since NMF is formulated as a lower rank approximation and K is typically much smaller than the rank of the input matrix, the ranks of both W and H in (7) typically remain full. When this condition is not likely to be satisfied, the Frobenius-norm regularization of Sect. 2.4 can be adopted to guarantee the full rank condition.

BCD framework for nonnegative CP
Our discussion on the low-rank factorizations of nonnegative matrices naturally extends to those of nonnegative tensors. In this section, we discuss nonnegative CANDE-COMP/PARAFAC (NCP) and explain how it can be computed by the BCD framework.
A few other decomposition models of higher order tensors have been studied, and interested readers are referred to [1,61]. The organization of this section is similar to that of Sect. 2, and we will show that the NLS algorithms reviewed in Sect. 4 can also be used to factorize tensors.
Let us consider an N th-order tensor A ∈ R M 1 ×···×M N . For an integer K , we are interested in finding nonnegative factor matrices H (1) , . . . , H (N ) where H (n) ∈ R M n ×K for n = 1, . . . , N such that where [[H (1) , . . . , The '•' symbol represents the outer product of vectors, and a tensor in the form of h k is called a rank-one tensor. Model (42) is known as CANDECOMP/PARAFAC (CP) [14,43]: In the CP decomposition, A is represented as the sum of K rank-one tensors. The smallest integer K for which (42) holds as equality is called the rank of tensor A. The CP decomposition reduces to a matrix decomposition if N = 2. The nonnegative CP decomposition is obtained by adding nonnegativity constraints to factor matrices H (1) , . . . , H (N ) . A corresponding problem can be written as, for A ∈ R We discuss algorithms for solving (45) in this section [19,32,54,60]. Toward that end, we introduce definitions of some operations of tensors. Mode-n product: The mode-n product of a tensor A ∈ R M 1 ×···×M N and a matrix U ∈ R J ×M n , denoted by A × n U, is a tensor obtained by multiplying all mode-n fibers of A with the columns of U. The result is a tensor of size M 1 × · · · × M n−1 × J × M n+1 × · · · × M N having elements as In particular, the mode-n product of A and a vector u ∈ R M n is a tensor of size M 1 × · · · × M n−1 × M n+1 × · · · × M N . Khatri-Rao product: The Khatri-Rao product of two matrices A ∈ R J 1 ×L and B ∈ R J 2 ×L , denoted by A B ∈ R (J 1 J 2 )×L , is defined as

BCD with N matrix blocks
A simple BCD method can be designed for (45) considering each of the factor matrics H (1) , . . . , H (N ) as a block. Using notations introduced above, approximation model (42) can be written as, for any n ∈ {1, . . . , N }, where Representation in (46) simplifies the treatment of this N matrix block case. After H (2) , . . . , H (N ) are initialized with nonnegative elements, the following subproblem is solved iteratively for n = 1, . . . N : Since subproblem (48) is an NLS problem, as in the matrix factorization case, this matrixblock BCD method is called the alternating nonnegative least squares (ANLS) framework [32,54,60]. The convergence property of the BCD method in Theorem 1 yields the following corollary. (48) and is attained for n = 1, . . . , N , then every limit point of the sequence H (1) , . . . , H (N ) (i) generated by the ANLS framework is a stationary point of (45).

Corollary 5 If a unique solution exists for
In particular, if each B (n) is of full column rank, the subproblem has a unique solution. Algorithms for the NLS subproblems discussed in Sect. 4 can be used to solve (48).
For higher order tensors, the number of rows in B (n) and (A <n> ) T , i.e., Ñ n=1,ñ =n Mñ, can be quite large. However, often B (n) and (A <n> ) T do not need to be explicitly constructed. In most algorithms explained in Sect. 4

, it is enough to have B (n)T (A <n> ) T and B (n) T B (n) .
It is easy to verify that B (n)T (A <n> ) T can be obtained by successive mode-n products: In addition, B (n) T B (n) can be obtained as where represents element-wise multiplication.

BCD with K N vector blocks
Another way to apply the BCD framework to (45) is to treat each column of H (1) , . . . , H (N ) as a block. The columns are updated by solving, for n = 1, . . . N and for k = 1, . . . , K , where Using matrix notations, problem (51) can be rewritten as where R <n> k is the mode-n matricization of R k and b (n) This vector-block BCD method corresponds to the HALS method by Cichocki et al. for NTF [19,22]. The convergence property in Theorem 1 yields the following corollary. (52) and is attained for n = 1, . . . , N and for k = 1, . . . , K , every limit point of the sequence H (1) , . . . , H (N ) (i) generated by the vector-block BCD method is a stationary point of (45).

Corollary 6 If a unique solution exists for
Using Theorem 2, the solution of (52) is Solution (54) can be evaluated without constructing R <n> which is a simple case of (50), and Solution (54) can then be simplified as where A <n> b (n) k can be computed using (49). Observe the similarity between (58) and (14).

Stopping criterion
Iterative methods have to be equipped with a criterion for stopping iterations. In NMF or NTF, an ideal criterion would be to stop iterations after a local minimum of (2) or (45) is attained. In practice, a few alternatives have been used. Let us first discuss stopping criteria for NMF. A naive approach is to stop when the decrease of the objective function becomes smaller than some predefined threshold: where is a tolerance value to choose. Although this method is commonly adopted, it is potentially misleading because the decrease of the objective function may become small before a local minimum is achieved. A more principled criterion was proposed by Lin as follows [71]. According to the Karush-Kuhn-Tucher (KKT) conditions, (W, H) is a stationary point of (2) if and only if [17] where Define the projected gradient ∇ p f W ∈ R M×K as, Using this definition, the stopping criterion is written by where Δ(0) is from the initial values of (W, H). Unlike (59), (62) guarantees the stationarity of the final solution. Variants of this criterion was used in [40,53]. An analogous stopping criterion can be derived for the NCP formulation in (45). The gradient matrix ∇ f H (n) can be derived from the least squares representation in (48): See (49) and (50) for efficient computation of B (n) T B (n) and A <n> B (n) . With function Δ defined as criterion in (62) can be used to stop iterations of an NCP algorithm. Using (59) or (62) for the purpose of comparing algorithms might be unreliable. One might want to measure the amounts of time until several algorithms satisfy one of these criteria and compare them [53,71]. Such comparison would usually reveal meaningful trends, but there are some caveats. The difficulty of using (59) is straightforward because, in some algorithm such as the multiplicative updating rule, the difference in (59) can become quite small before arriving at a minimum. The difficulty of using (62) is as follows. Note that the diagonal rescaling of W and H does not affect the quality of approximation: For a diagonal matrix D ∈ R K ×K + with positive diagonal elements, WH T = WD −1 (HD) T . However, the norm of the projected gradients in (61) is affected by a diagonal scaling: Hence, two solutions that are only different up to a diagonal scaling have the same objective function value, but they can be measured differently in terms of the norm of the projected gradients. See Kim and Park [59] for more information. Ho [44] considered including a normalization step before computing (61) to avoid this issue.

Results of experimental comparisons
A number of papers have reported the results of experimental comparisons of NMF algorithms. A few papers have shown the slow convergence of Lee and Seung's multiplicative updating rule and demonstrated the superiority of other algorithms published subsequently [40,53,71]. Comprehensive comparisons of several efficient algorithms for NMF were conducted in Kim and Park [59], where MATLAB implementations of the ANLS-based methods, the HALS/RRI method, the multiplicative updating rule, and a few others were compared. In their results, the slow convergence of the multiplicative updating was confirmed, and the ALS method in Sect. 3.3 was shown to fail to converge in many cases. Among all the methods tested, the HALS/RRI method and the ANLS/BPP method showed the fastest overall convergence. Further comparisons are presented in Gillis and Glineur [37] and Hsieh and Dhillon [48] where the authors proposed acceleration methods for the HALS/RRI method. Their comparisons show that the HALS/RRI method or the accelerated versions converge the fastest among all methods tested. Korattikara et al. [62] demonstrated an effective approach to accelerate the ANLS/BPP method. Overall, the HALS/RRI method, the ANLS/BPP method, and their accelerated versions show the state-of-the-art performance in the experimental comparisons.
Comparison results of algorithms for NCP are provided in [60]. Interestingly, the ANLS/BPP method showed faster convergence than the HALS/RRI method in the tensor factorization case. Further investigations and experimental evaluations of the NCP algorithms are needed to fully explain these observations.

Efficient NMF updating: algorithms
In practice, we often need to update a factorization with a slightly modified condition or some additional data. We consider two scenarios where an existing factorization needs to be efficiently updated to a new factorization. Importantly, the unified view of the NMF algorithms presented in earlier chapters provides useful insights when we choose algorithmic components for updating. Although we focus on the NMF updating here, similar updating schemes can be developed for NCP as well.
7.1 Updating NMF with an increased or decreased K NMF algorithms discussed in Sects. 2 and 3 assume that K , the reduced dimension, is provided as an input. In practical applications, however, prior knowledge on K might not be available, and a proper value for K has to be determined from data. To determine K from data, typically NMFs are computed for several different K values and then the best K is chosen according to some criterion [10,33,49]. In this case, computing several NMFs each time from scratch would be very expensive, and therefore it is desired to develop an algorithm to efficiently update an already computed factorization. We propose an algorithm for this task in this subsection.
Suppose we have computed W old ∈ R M×K 1 + and H old ∈ R N ×K 1 + as a solution of (2) with K = K 1 . For K = K 2 which is close to K 1 , we are to compute new factors W new ∈ R M×K 2 + and H new ∈ R N ×K 2 + as a minimizer of (2). Let us first consider the K 2 > K 1 case, which is shown in Fig. 2 where are generated with, e.g., random nonnegative entries. Using (64) as initial values, we can execute an NMF algorithm to find the solution of (2). Since W old and H old already approximate A, this warm-start strategy is expected to be more efficient than computing everything from scratch.
We further improve this strategy based on the following observation. Instead of initializing W add and H add with random entries, we can compute W add and H add that approximately factorize the residual matrix, i.e., A − W old H T old . This can be done by solving the following problem: K 2 columns can be selected as follows. Let δ k be the squared Frobenius norm of the kth rank-one matrix in (66), given as . We then take the largest K 2 values from δ 1 , . . . , δ K 1 and use corresponding columns of W old and H old as initializations for W new and H new .
Summarizing the two cases, an algorithm for updating NMF with an increased or decreased K value is presented in Algorithm 2. Note that the HALS/RRI method is chosen for Step 2: Since the new entries appear as column blocks (see Fig. 2), the HALS/RRI method is an optimal choice. For Step 2, although any algorithm may be chosen, we have adopted the HALS/RRI method for our experimental evaluation in Sect. 8.1.

Algorithm 2 Updating NMF with Increased or Decreased K Values
as a minimizer of (2), and K 2 .

Updating NMF with incremental data
In applications such as video analysis and mining of text stream, we have to deal with dynamic data where new data keep coming in and obsolete data get discarded. Instead of completely recomputing the factorization after only a small portion of data are updated, an efficient algorithm needs to be designed to update NMF. Let us first consider a case that new data are observed, as shown in Fig. 3 , is needed to represent the coefficients for new data. Although it is possible to initialize ΔH with random entries, an improved approach is to solve the following NLS problem: Using these initializations, we can then execute an NMF algorithm to find an optimal solution for W new and H new . Various algorithms for the NLS problem, discussed in Sect. 4, maybe used to solve (67). In order to achieve optimal efficiency, due to the fact that the number of rows of ΔH T is usually small, the block principal pivoting algorithm is one of the most efficient method as demonstrated in [59]. We summarize this method for updating NMF with incremental data in Algorithm 3.  and H new and execute an NMF algorithm to find a minimizer of (2).

Efficient NMF updating: experiments and applications
We provide the experimental validations of the effectiveness of Algorithms 2 and 3 and show their applications. The computational efficiency was compared on dense and sparse synthetic matrices as well as on real-world data sets. All the experiments were executed with MATLAB on a Linux machine with 2GHz Intel Quad-core processor and 4GB memory.

Comparisons of NMF updating methods for varying K
We compared Algorithm 2 with two alternative methods for updating NMF. The first method is to compute NMF with K = K 2 from scratch using the HALS/RRI algorithm, which we denote as 'recompute' in our figures. The second method, denoted as 'warm-restart' in the figures, computes the new factorization as follows. If using random entries to initialize W new and H new as in (64). If K 2 < K 1 , it randomly selects K 2 pairs of columns from W old and H old to initialize the new factors. Using these initializations, 'warm-restart' executes the HALS/RRI algorithm to finish the NMF computation.
Synthetic data sets and performance comparisons on them are as follows. We created both dense and sparse matrices. For dense matrices, we generated W ∈ R M×K + and H ∈ R N ×K + with random entries and computed A = WH T . Then, Gaussian noise was added to the elements of A where the noise has zero mean and standard deviation is 5 % of the average magnitude of elements in A. All negative elements after adding the noise were set to zero.
We generated a 600 × 600 dense matrix with K = 80. For sparse matrices, we first generated W ∈ R M×K + and H ∈ R N ×K + with 90 % sparsity and computed A = WH T . We then used a soft-thresholding operation to obtain a sparse matrix A, 1 and the resulting matrix had 88.2 % sparsity. We generated a synthetic sparse matrix of size 3, 000 × 3, 000. 2 In order to observe efficiency in updating, an NMF with K 1 = 60 was first computed and stored. We then computed NMFs with K 2 = 50, 65, and 80. The plots of relative error vs. execution time for all three methods are shown in Fig. 4. Our proposed method achieved faster convergence compared to 'warm-restart' and 'recompute', which sometimes required several times more computation to achieve the same accuracy as our method. The advantage of the proposed method can be seen in both dense and sparse cases.
We have also used four real-world data sets for our comparisons. From the Topic Detection and Tracking 2 (TDT2) text corpus, 3 we selected 40 topics to create a sparse term-document matrix of size 19, 009 × 3, 087. From the 20 Newsgroups data set, 4 a sparse term-document matrix of size 7, 845 × 11, 269 was obtained after removing keywords and documents with frequency less than 20. The AT&T facial image database 5 produced a dense matrix of size 10, 304 × 400. The images in the CMU PIE database 6 were resized to 64 × 64 pixels, and we formed a dense matrix of size 4, 096 × 11, 554. 7 We focused on the case when K increases, and the results are reported in Fig. 5. As with the synthetic data sets, our proposed method was shown to be the most efficient among the methods we tested.

Applications of NMF updating for varying K
Algorithm 2 can be used to determine the reduced dimension, K , from data. Our first example, shown in Fig. 6a, is determining a proper K value that represents the number of clusters. Using NMF as a clustering method [57,63], Brunet et al. [10] proposed to select the number of clusters by computing NMFs with multiple initializations for various K values and then evaluating the dispersion coefficients (See [10,52,57] for more details). We took the MNIST digit image database [65] and used 500 images with 28 × 28 pixels from each of the digits 6, 7, 8, and 9. The resulting data matrix was of size 784 × 2, 000. We computed NMFs for K = 3, 4, 5, and 6 with 50 different initializations for each K . The top of Fig. 6a shows that K = 4 can be correctly determined from the point where the dispersion coefficient starts to drop. The bottom of Fig. 6a shows the box-plot of the total execution time needed by Algorithm 2, 'recompute', and 'warm-restart'. We applied the same stopping criterion in (62) for all three methods.
Further applications of Algorithm 2 are shown in Fig. 6b, c. Figure 6b demonstrates a process of probing the approximation errors of NMF with various K values. With K = 20, 40, 60 and 80, we generated 600 × 600 synthetic dense matrices as described in Sect. 8.1. Then, we computed NMFs with Algorithm 2 for K values ranging from 10 to 160 with a step size 5. The relative objective function values with respect to K are shown in Fig. 6b. In each of the cases where K = 20, 40, 60, and 80, we were able to determine the correct K value by choosing a point where the relative error stopped decreasing significantly.  Figure 6c demonstrates the process of choosing K for a classification purpose. Using the 10, 304 × 400 matrix from the AT&T facial image database, we computed NMF to generate a K dimensional representation of each image, taken from each row of H. We then trained a nearest neighbor classifier using the reduced-dimensional representations [83] . Classification errors on both training and testing sets are shown in Fig. 6c. Five paths of training and testing errors are plotted using thin lines, and the averaged training and testing errors are plotted using thick lines. Based on the figure, we chose K = 13 since the testing error barely decreased beyond the point whereas the training error approached zero.

Comparisons of NMF updating methods for incremental data
We also tested the effectiveness of Algorithm 3. We created a 1, 000 × 500 dense matrix A as described in Sect. 8.1 with K = 100. An initial NMF with K = 80 was computed and stored. Then, an additional data set of size 1, 000 × 10, 1, 000 × 20, or 1, 000 × 50 was appended, and we computed the updated NMF with several methods as follows. In addition to Algorithm 3, we considered four alternative methods. A naive approach that computes the entire NMF from scratch is denoted as 'recompute'. An approach that initializes a new where ΔH is generated with random entries is denoted as 'warm-restart'. The incremental NMF algorithm (INMF) [11] as well as the online NMF algorithm (ONMF) [13] were also included in the comparisons. Figure 7 shows the execution results, where our proposed method outperforms other methods tested.

Conclusion and discussion
We have reviewed algorithmic strategies for computing NMF and NTF from a unifying perspective based on the BCD framework. The BCD framework for NMF and NTF enables simplified understanding of several successful algorithms such as the alternating nonnegative least squares (ANLS) and the hierarchical alternating least squares (HALS) methods. Based on the BCD framework, the theoretical convergence properties of the ANLS and the HALS methods are readily explained. We have also summarized how previous algorithms that do not fit in the BCD framework differ from the BCD-based methods. With insights from the unified view, we proposed efficient algorithms for updating NMF both for the cases that the reduced dimension varies and that data are incrementally added or discarded. There are many other interesting aspects of NMF that are not covered in this paper. Depending on the probabilistic model of the underlying data, NMF can be formulated with various divergences. Formulations and algorithms based on Kullback-Leibler divergence [67,79], Bregman divergence [24,68], Itakura-Saito divergence [29], and Alpha and Beta divergences [21,22] have been developed. For discussion on nonnegative rank as well as the geometric interpretation of NMF, see Lin and Chu [72], Gillis [34], and Donoho and Stodden [27]. NMF has been also studied from the Bayesian statistics point of view: See Schmidt et al. [78] and Zhong and Girolami [88]. In the data mining community, variants of NMF such as convex and semi-NMFs [25,75], orthogonal tri-NMF [26], and group-sparse NMF [56] have been proposed, and using NMF for clustering has been shown to be successful [12,57,63]. For an overview on the use of NMF in bioinformatics, see Devarajan [23] and references therein. Cichocki et al.'s book [22] explains the use of NMF for signal processing. See Chu and Plemmons [17], Berry et al. [4], and Cichocki et al. [22] for earlier surveys on NMF. See also Ph.D. dissertations on NMF algorithms and applications [34,44,55].
Open Access This article is distributed under the terms of the Creative Commons Attribution License which permits any use, distribution, and reproduction in any medium, provided the original author(s) and the source are credited.