Home > brede > brede_nmf_est.m

brede_nmf_est

PURPOSE ^

brede_nmf_est - Non-negative matrix factorization

SYNOPSIS ^

function [Output1, Output2, Output3] = brede_nmf_est(X, varargin);

DESCRIPTION ^

 brede_nmf_est        - Non-negative matrix factorization

       function [W, H] = brede_nmf_est(X, ...
          'PropertyName', 'PropertyValue')
       function [W, L, H] = brede_nmf_est(X, ...
          'PropertyName', 'PropertyValue')

       Input:    X      Data matrix or 'mat' structure

       Property: Components      {4} Dimension of the subspace, ie,
                                 the columns of W and rows of H.
                 Cost            [ {Euclidean} | Divergence ]
                 Hinit           Initialization matrix for H 
                 Info            {0} Amount of (debug) information
                 IterationProbe  [ {250} | positive integer ]
                                 Iterations between evaluations of
                                 the cost function
                 MaxIterations   [ {50000} | positive integer ]
                                 Numbers of iterations before
                                 breaking optimization
                 Seed            [ {[]} | real ] Seed for random
                                 generator 
                 ToleranceZeroWH [ {norm(X) * max(size(X)') * eps} |
                                 real | [] ] Value specifying
                                 numerically zero element in W and H
                 Runs            [ {1} | positive integer ] Number of
                                 restarts 
                 Winit           Initialization matrix for W

       Output:   W      Left matrix of factorization
                 H      Right matrix of factorization
                 L      Diagonal matrix  

       This function performs non-negative matrix factorization on a
       matrix X(NxP) (estimation of the parameters W and H)

                          W * H = X

       The positive matrices W(NxR) and H(RxP) forms a small
       subspace: R < min(N,P). If three output arguments are required
       then the returned matrices are:

                        W * L * H = X

       With L as a diagonal matrix and W and H are matrices where
       row or column vectors have unit length - measured by the
       two-norm. 

       The 'Runs' property determines the number of (re)runs. The
       algorithm is run several times and the best model in terms of
       lowest cost is returned. The Winit and Hinit variables
       should not be set if runs>1 since the same initialization will
       be used.
       
       'ToleranceZeroWH' specifies the threshold for the elements in W
       and H which should be set to zero during the iterative
       optimization. If an element in W or H is below this value it
       will be set to zero. A major effect on the efficiency of the
       optimization can be the multiplication of numbers (in W and H)
       between 0 and realmin - due to underflow interrupts. These
       might slow down the algorithm and the algorithm will work
       faster if 'ToleranceZeroWH' is set to a positive value above
       'realmin'.  

       The 'Cost'='divergence' might not be stable.

       Reference:
         DD Lee, HS Seung, NIPS 2000.

       Example: 
         X = rand(10,5);
         [W,H] = brede_nmf_est(X, 'maxiterations', 1000)

         [W,H] = brede_nmf_est(X, 'maxiterations', 1000, 'cost', 'divergence')

       See also BREDE, BREDE_MAT, BREDE_NMF_COST_EUCL,
                BREDE_NMF_COST_DIV, BREDE_MAT_NMF, BREDE_MAT_SVD.

 $Id: brede_nmf_est.m,v 1.29 2008/06/17 15:56:16 fn Exp $

CROSS-REFERENCE INFORMATION ^

This function calls: This function is called by:
Generated on Fri 27-Nov-2009 18:11:22 by m2html © 2005