scikits.learn.decomposition.NMF

class scikits.learn.decomposition.NMF(n_components=None, init='nndsvdar', sparseness=None, beta=1, eta=0.10000000000000001, tol=0.0001, max_iter=200, nls_max_iter=2000)

Non-Negative matrix factorization by Projected Gradient (NMF)

Parameters :

X: array, [n_samples, n_features] :

Data the model will be fit to.

n_components: int or None :

Number of components if n_components is not set all components are kept

init: ‘nndsvd’ | ‘nndsvda’ | ‘nndsvdar’ | int | RandomState :

Method used to initialize the procedure. Default: ‘nndsvdar’ Valid options:

‘nndsvd’: default Nonnegative Double Singular Value

Decomposition (NNDSVD) initialization (better for sparseness)

‘nndsvda’: NNDSVD with zeros filled with the average of X

(better when sparsity is not desired)

‘nndsvdar’: NNDSVD with zeros filled with small random values

(generally faster, less accurate alternative to NNDSVDa for when sparsity is not desired)

int seed or RandomState: non-negative random matrices

sparseness: ‘data’ | ‘components’ | None :

Where to enforce sparsity in the model. Default: None

beta: double :

Degree of sparseness, if sparseness is not None. Larger values mean more sparseness. Default: 1

eta: double :

Degree of correctness to mantain, if sparsity is not None. Smaller values mean larger error. Default: 0.1

tol: double :

Tolerance value used in stopping conditions. Default: 1e-4

max_iter: int :

Number of iterations to compute. Default: 200

nls_max_iter: int :

Number of iterations in NLS subproblem. Default: 2000

Notes

This implements C.-J. Lin. Projected gradient methods for non-negative matrix factorization. Neural Computation, 19(2007), 2756-2779. http://www.csie.ntu.edu.tw/~cjlin/nmf/

NNDSVD is introduced in C. Boutsidis, E. Gallopoulos: SVD based initialization: A head start for nonnegative matrix factorization - Pattern Recognition, 2008 http://www.cs.rpi.edu/~boutsc/files/nndsvd.pdf

Examples

>>> import numpy as np
>>> X = np.array([[1,1], [2, 1], [3, 1.2], [4, 1], [5, 0.8], [6, 1]])
>>> from scikits.learn.decomposition import ProjectedGradientNMF
>>> model = ProjectedGradientNMF(n_components=2, init=0)
>>> model.fit(X) 
ProjectedGradientNMF(nls_max_iter=2000, eta=0.1, max_iter=200,
           init=<mtrand.RandomState object at 0x...>, beta=1,
           sparseness=None, n_components=2, tol=0.0001)
>>> model.components_
array([[ 0.77032744,  0.11118662],
       [ 0.38526873,  0.38228063]])
>>> model.reconstruction_err_ 
0.00746...
>>> model = ProjectedGradientNMF(n_components=2, init=0,
...                              sparseness='components')
>>> model.fit(X) 
ProjectedGradientNMF(nls_max_iter=2000, eta=0.1, max_iter=200,
           init=<mtrand.RandomState object at 0x...>, beta=1,
           sparseness='components', n_components=2, tol=0.0001)
>>> model.components_
array([[ 1.67481991,  0.29614922],
       [-0.        ,  0.4681982 ]])
>>> model.reconstruction_err_ 
0.513...

Attributes

Methods

__init__(n_components=None, init='nndsvdar', sparseness=None, beta=1, eta=0.10000000000000001, tol=0.0001, max_iter=200, nls_max_iter=2000)

fit(X, y=None, **params)

Learn a NMF model for the data X.

Parameters :

X: array, [n_samples, n_features] :

Data matrix to be decomposed

Returns :

self :

fit_transform(X, y=None, **params)

Learn a NMF model for the data X and returns the transformed data.

This is more efficient than calling fit followed by transform.

Parameters :

X: array, [n_samples, n_features] :

Data matrix to be decomposed

Returns :

data: array, [n_samples, n_components] :

Transformed data

transform(X)

Transform the data X according to the fitted NMF model

Parameters :

X: array, [n_samples, n_features] :

Data matrix to be transformed by the model

Returns :

data: array, [n_samples, n_components] :

Transformed data