0Ph@dZddlZddlZddlZddlmZddlmZddlm Z m Z ddl Z ddl mZddlmZddlmZdd lmZmZmZmZdd lmZdd lmZmZmZmZdd l m!Z!m"Z"m#Z#dd l$m%Z%ddl&m'Z'm(Z(m)Z)ddl*m+Z+m,Z,m-Z-ddl.m/Z/e j0e j1j2Z3dZ4dZ5dZ6d5dZ7dZ8dZ9d6dZ:dZ; d7dZ< d8d Z= d9d!Z> d:d#Z?e#d$d%gd$dgd$dgd&gd'd( d;ddd*d"ddd+d,d+dddd- d.Z@Gd/d0eeeeZAGd1d2eAZBGd3d4eAZCdS)> M!   aA aA qyy ;q>> 7VAFAF++F 3 3QS!QK @ @!DDG"AGa00JG#cJ&66#=CCq26!Q<</0036C  737## #J {1~~%aA..3 VAq\\((**wGgG G_F")GGg  qyyqq)))26!!+<+<+<==wfVRVC[[)) v $$ wfSkkBGAG,,,rvbfSkk/B/BB ;q>> +K171:&& B BrvbfQ!!!Q$&8&8D&@AAA  B&T**K6&'dQh"788t|  ""TH_4 {dQh'' ttax  #qkkwq3w r#c\tj|r|\}}|jd}t j|}|jd}t |||z}td||D]f} t| | |z} t j ||| ddf|j || ddf d|| <gtj |||ff|j} | St j||S)z0Computes np.dot(W, H), only where X is non zero.rrNr6)r.)r9r:nonzeror.r%emptyr0rDslicemultiplyr>rA coo_matrixtocsrr&) rErFr(iijjn_valsdot_vals n_components batch_sizestartbatchrOs r!r?r?s {1~~B!8F##wqz v'=>> 1fj11  E%!344E k!BuIqqqL/13r%y!!!|;LMMQQRHUOO]Hr2h/qw ? ? ?xxzzva||r#cLdddd}t|tr||}|S)z"Convert string beta_loss to float.rrr) frobeniuskullback-leibler itakura-saito) isinstancestr) beta_loss beta_loss_maps r!r8r8s3"#QOOM)S!!-!), r#ư>c t|d|j\}}|<|dkr6|t||kr"td|||t||krd}nd}|dkrt j||z }t|}|| ||f |j dz} || ||f |j dz} t j | | t j | | | | fSt||| \} } } t j| } t j| } t j| d t j | ddd fz| ddd f<t j| d t j | d ddfz| d ddf<td |D]-}| dd|f| |ddf}}t j|d t j|d }}t j t j|d t j t j|d }}t%|t%|}}t%|t%|}}||z||z}}||kr ||z }||z }|}n ||z }||z }|}t j| ||z}||z| dd|f<||z| |ddf</d | | |k<d | | |k<|d krn|dkr'|}|| | d k<|| | d k<n|dkrt|}|}t|| t'| | d kzdz | | d k<t|| t'| | d kzdz | | d k<ntd|dd| | fS)aNAlgorithms for NMF initialization. Computes an initial guess for the non-negative rank k matrix approximation for X: X = WH. Parameters ---------- X : array-like of shape (n_samples, n_features) The data matrix to be decomposed. n_components : int The number of components desired in the approximation. init : {'random', 'nndsvd', 'nndsvda', 'nndsvdar'}, default=None Method used to initialize the procedure. Valid options: - None: 'nndsvda' if n_components <= min(n_samples, n_features), otherwise 'random'. - 'random': non-negative random matrices, scaled with: sqrt(X.mean() / n_components) - 'nndsvd': 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) - 'custom': use custom matrices W and H .. versionchanged:: 1.1 When `init=None` and n_components is less than n_samples and n_features defaults to `nndsvda` instead of `nndsvd`. eps : float, default=1e-6 Truncate all values less then this in output to zero. random_state : int, RandomState instance or None, default=None Used when ``init`` == 'nndsvdar' or 'random'. Pass an int for reproducible results across multiple function calls. See :term:`Glossary `. Returns ------- W : array-like of shape (n_samples, n_components) Initial guesses for solving X ~= WH. H : array-like of shape (n_components, n_features) Initial guesses for solving X ~= WH. References ---------- C. Boutsidis, E. Gallopoulos: SVD based initialization: A head start for nonnegative matrix factorization - Pattern Recognition, 2008 http://tinyurl.com/nndsvd zNMF initializationNrandomzLinit = '{}' can only be used when n_components <= min(n_samples, n_features)nndsvda)sizeF)copyout) random_staterrnndsvdnndsvdardzInvalid init parameter: got z instead of one of )Nrprwrqrx)rr.minr/formatr%rmeanrstandard_normalastypedtypeabsr zeros_likerDmaximumminimumr"len)r(rbinitepsrv n_samples n_featuresavgrngrFrEUSVjr yx_py_px_ny_nx_p_nrmy_p_nrmx_n_nrmy_n_nrmm_pm_nuvsigmalbds r!_initialize_nmfrs|q.///GIz  H   3y*55 5 5 99?    | 3y*55 5 5DDD xgaffhh-.. .. #%%L*+E%FFMM G%N    #%%I|+D%EELL G%M    qa qa!t Q <HHHGAq! aA aAgadmmbfQqqq!tWoo-AaaadGgadmmbfQq!!!tWoo-AadG 1l # #Aw!QQQ$1:a##RZ1%5%5S6"*Q**++RVBJq!4D4D-E-ES 99d3ii99d3iiW$g&7S 99g Ag AEEg Ag AEgadUl##'!!!Q$'!QQQ$Aa#gJAa#gJ x   ffhh!q& !q&    ..ffhhc11s1Q!V9~~1FFFLMM!q& c11s1Q!V9~~1FFFLMM!q& jttFF H   a4Kr#c|jd}tj|j|}t ||} |dkr|jdd|dzxx|z cc<|dkr| |z} |r||} ntj|} tj| tj } t||| | S)zHelper function for _fit_coordinate_descent. Update W to minimize the objective function, iterating once over all coordinates. By symmetry, to update H, one can call _update_coordinate_descent(X.T, Ht, W, ...). rNr) r.r%r&r>rflat permutationarangeasarrayintpr) r(rEHtl1_regl2_regshufflervrbHHtXHtrs r!_update_coordinate_descentrys8A;L &r  C !R C}} $$L1$$%%%/%%% }} v ."..|<< i -- *[888K ac; 7 77r#-C6?Tc t|jd} t|d}t| }td|dzD]}d}|t ||| ||| |z }| r|t |j| |||| |z }|dkr|}|dkrn6| rt d||z ||z |kr| rt d |dzn|| j|fS) a Compute Non-negative Matrix Factorization (NMF) with Coordinate Descent The objective function is minimized with an alternating minimization of W and H. Each minimization is done with a cyclic (up to a permutation of the features) Coordinate Descent. Parameters ---------- X : array-like of shape (n_samples, n_features) Constant matrix. W : array-like of shape (n_samples, n_components) Initial guess for the solution. H : array-like of shape (n_components, n_features) Initial guess for the solution. tol : float, default=1e-4 Tolerance of the stopping condition. max_iter : int, default=200 Maximum number of iterations before timing out. l1_reg_W : float, default=0. L1 regularization parameter for W. l1_reg_H : float, default=0. L1 regularization parameter for H. l2_reg_W : float, default=0. L2 regularization parameter for W. l2_reg_H : float, default=0. L2 regularization parameter for H. update_H : bool, default=True Set to True, both W and H will be estimated from initial guesses. Set to False, only W will be estimated. verbose : int, default=0 The verbosity level. shuffle : bool, default=False If true, randomize the order of coordinates in the CD solver. random_state : int, RandomState instance or None, default=None Used to randomize the coordinates in the CD solver, when ``shuffle`` is set to ``True``. Pass an int for reproducible results across multiple function calls. See :term:`Glossary `. Returns ------- W : ndarray of shape (n_samples, n_components) Solution to the non-negative least squares problem. H : ndarray of shape (n_components, n_features) Solution to the non-negative least squares problem. n_iter : int The number of iterations done by the algorithm. References ---------- .. [1] :doi:`"Fast local algorithms for large scale nonnegative matrix and tensor factorizations" <10.1587/transfun.E92.A.708>` Cichocki, Andrzej, and P. H. A. N. Anh-Huy. IEICE transactions on fundamentals of electronics, communications and computer sciences 92.3: 708-721, 2009. C)ordercsr) accept_sparserrrz violation:zConverged at iteration)rr>rrDrprint)r(rErFtolmax_iterl1_reg_Wl1_reg_Hl2_reg_Wl2_reg_Hupdate_Hverboserrvrrn_iter violationviolation_inits r!_fit_coordinate_descentrs8j QS $ $ $BAU+++A \ * *C8a<((  / q"h'3      3RHh I Q;;&N Q   E  < , N : ; ; ; ~ % , , <. ;;; E - bdF?r#c  |dkrc| t||j} | r| } n| } |tj||j}tj||} nt |||} t j|r| j}|j}n4| }|}| }|dz dkrt||tk<|dz dkrt||tk<|dkrtj |||n#|dkr|dz}|dz}||z}n ||dz z}||z}t| |j} |dkr/|tj |d }|tj ddf} nt j|rtj |j}t|jdD]f}tj||ddf|}|dz dkrt||tk<||dz z}tj||j||ddf<gn"||dz z}tj||j}|} |dkr| |z } |dkr| ||zz} t| | dk<| | z} | }|dkr||z}||z}|||| fS) z&Update W in Multiplicative Update NMF.rN?rr5rrtr6)rr>rsr%r&r?r9r:r<r@dividerAnewaxisrYr.rD)r(rErFrlrrgammaH_sumrrr numerator denominator WH_safe_XWH_safe_X_datarNrOWHHtrTWHidelta_Ws r!_multiplicative_update_wrsA~~ ;!!QS))C  #II I ;&AC..CfQnn (1a00 ;q>> +&^NVFF&NF!!B3""#*2<  s?Q  7>N>G3 4 >> Ifn. A A A A A !^^ r !N q N f $NN y1} ,N f $N$Iqs33  >>}qq))) AAA .KK{1~~ 'x((qwqz**22A&1aaa4!,,C 1}q((-4C'M*IM)C!#QS!1!1DAAAJJ 2y1}$vb!#K!||x !||!HqL0 $+K q ! IG zzELA eS# r#c T|dkr>t|j|} tj|j||g} nt |||} t j|r| j} |j}n4| } |}| }|dz dkrt||tk<|dz dkrt| | tk<|dkrtj || | n#|dkr| dz} | dz} | |z} n | |dz z} | |z} t|j| } |dkr6tj |d}d||dk<|d d tj f} nt j|rtj|j}t!|jdD]f}tj||d d |f}|dz dkrt||tk<||dz z}tj|j||d d |f<gn"||dz z}tj|j|}|} |dkr| |z } |dkr| ||zz} t| | dk<|:|8|dkr|d|z z}| |z} || z}|| z}|| z }|| z }||z }|dkr||z}n| }|| z}|dkr||z}||z}|S) z&update H in Multiplicative Update NMF.rrrr5rrtrr6N)rr>r%rr=r?r9r:r<rsr@rrArrYr.rDr&)r(rErFrlrrrr1BrhorrrrrNrOW_sumWtWHrTrdelta_Hs r!_multiplicative_update_hr{s,A~~#AC++ i))131+66 (1a00 ;q>> +&^NVFF&NF!!B3""#*2<  s?Q  7>N>G3 4 >> Ifn. A A A A A !^^ r !N q N f $NN y1} ,N f $N$AC33  >>F11%%%E #E%1* 2: .KK {1~~ 'x((qwqz**22A&AaaadG,,C 1}q((-4C'M*IM)C!#S!1!1DAJJ 2y1}$vac2K!||x !||!HqL0 $+K q !} A:: !e)OAQ  S S Y [ E A:: %KA; A::  G W  Hr#rgc htj} t|}|dkr dd|z z } n|dkr d|dz z } nd} t||||d}|}d\}}}td|dzD]}t ||||||| ||||  \}}}}|dkr*d ||t jt jjk<| rLt|||||| | }d\}}}|dkr*d ||t jt jjk<|d krZ|d zd krQt||||d}| r+tj}td ||| z |fz||z |z |krn|}| r9|d ks |d zd kr*tj}td||| z fz|||fS)aK Compute Non-negative Matrix Factorization with Multiplicative Update. The objective function is _beta_divergence(X, WH) and is minimized with an alternating minimization of W and H. Each minimization is done with a Multiplicative Update. Parameters ---------- X : array-like of shape (n_samples, n_features) Constant input matrix. W : array-like of shape (n_samples, n_components) Initial guess for the solution. H : array-like of shape (n_components, n_features) Initial guess for the solution. beta_loss : float or {'frobenius', 'kullback-leibler', 'itakura-saito'}, default='frobenius' String must be in {'frobenius', 'kullback-leibler', 'itakura-saito'}. Beta divergence to be minimized, measuring the distance between X and the dot product WH. Note that values different from 'frobenius' (or 2) and 'kullback-leibler' (or 1) lead to significantly slower fits. Note that for beta_loss <= 0 (or 'itakura-saito'), the input matrix X cannot contain zeros. max_iter : int, default=200 Number of iterations. tol : float, default=1e-4 Tolerance of the stopping condition. l1_reg_W : float, default=0. L1 regularization parameter for W. l1_reg_H : float, default=0. L1 regularization parameter for H. l2_reg_W : float, default=0. L2 regularization parameter for W. l2_reg_H : float, default=0. L2 regularization parameter for H. update_H : bool, default=True Set to True, both W and H will be estimated from initial guesses. Set to False, only W will be estimated. verbose : int, default=0 The verbosity level. Returns ------- W : ndarray of shape (n_samples, n_components) Solution to the non-negative least squares problem. H : ndarray of shape (n_components, n_features) Solution to the non-negative least squares problem. n_iter : int The number of iterations done by the algorithm. References ---------- Lee, D. D., & Seung, H., S. (2001). Algorithms for Non-negative Matrix Factorization. Adv. Neural Inform. Process. Syst.. 13. Fevotte, C., & Idier, J. (2011). Algorithms for nonnegative matrix factorization with the beta-divergence. Neural Computation, 23(9). rrr5rTrHNNN)rlrrrrrrrr)rlrrrr z0Epoch %02d reached after %.3f seconds, error: %fz&Epoch %02d reached after %.3f seconds.) timer8rVrDrr%finfofloat64rrr)r(rErFrlrrrrrrrr start_timer error_at_initprevious_errorrrrrerror iter_timeend_times r!_fit_multiplicative_updaters[fJ#I..I1}}sY' Qy3'%Q1iTJJJM"N&OE38a<((5#5#6     5#s q==.1Aa"(2:&&** +  6(#!!A/OE3A~~25!bhrz**../ 77v{a''$Q1iTJJJE  IKK Fy:5u=> &-7#=="N C1HH q 0 09;; 4:@U7V V    a<r#z array-likez sparse matrixboolean)r(rErFrprefer_skip_nested_validationr,cdrsame) rrsolverrlrralpha_Walpha_Hl1_ratiorvrrc Dt|||||| | | | | || }|t|dtjtjg}t d5|||||\}}}dddn #1swxYwY|||fS)aCompute Non-negative Matrix Factorization (NMF). Find two non-negative matrices (W, H) whose product approximates the non- negative matrix X. This factorization can be used for example for dimensionality reduction, source separation or topic extraction. The objective function is: .. math:: L(W, H) &= 0.5 * ||X - WH||_{loss}^2 &+ alpha\_W * l1\_ratio * n\_features * ||vec(W)||_1 &+ alpha\_H * l1\_ratio * n\_samples * ||vec(H)||_1 &+ 0.5 * alpha\_W * (1 - l1\_ratio) * n\_features * ||W||_{Fro}^2 &+ 0.5 * alpha\_H * (1 - l1\_ratio) * n\_samples * ||H||_{Fro}^2, where :math:`||A||_{Fro}^2 = \sum_{i,j} A_{ij}^2` (Frobenius norm) and :math:`||vec(A)||_1 = \sum_{i,j} abs(A_{ij})` (Elementwise L1 norm) The generic norm :math:`||X - WH||_{loss}^2` may represent the Frobenius norm or another supported beta-divergence loss. The choice between options is controlled by the `beta_loss` parameter. The regularization terms are scaled by `n_features` for `W` and by `n_samples` for `H` to keep their impact balanced with respect to one another and to the data fit term as independent as possible of the size `n_samples` of the training set. The objective function is minimized with an alternating minimization of W and H. If H is given and update_H=False, it solves for W only. Note that the transformed data is named W and the components matrix is named H. In the NMF literature, the naming convention is usually the opposite since the data matrix X is transposed. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Constant matrix. W : array-like of shape (n_samples, n_components), default=None If `init='custom'`, it is used as initial guess for the solution. If `update_H=False`, it is initialised as an array of zeros, unless `solver='mu'`, then it is filled with values calculated by `np.sqrt(X.mean() / self._n_components)`. If `None`, uses the initialisation method specified in `init`. H : array-like of shape (n_components, n_features), default=None If `init='custom'`, it is used as initial guess for the solution. If `update_H=False`, it is used as a constant, to solve for W only. If `None`, uses the initialisation method specified in `init`. n_components : int or {'auto'} or None, default='auto' Number of components. If `None`, all features are kept. If `n_components='auto'`, the number of components is automatically inferred from `W` or `H` shapes. .. versionchanged:: 1.4 Added `'auto'` value. .. versionchanged:: 1.6 Default value changed from `None` to `'auto'`. init : {'random', 'nndsvd', 'nndsvda', 'nndsvdar', 'custom'}, default=None Method used to initialize the procedure. Valid options: - None: 'nndsvda' if n_components < n_features, otherwise 'random'. - 'random': non-negative random matrices, scaled with: `sqrt(X.mean() / n_components)` - 'nndsvd': 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) - 'custom': If `update_H=True`, use custom matrices W and H which must both be provided. If `update_H=False`, then only custom matrix H is used. .. versionchanged:: 0.23 The default value of `init` changed from 'random' to None in 0.23. .. versionchanged:: 1.1 When `init=None` and n_components is less than n_samples and n_features defaults to `nndsvda` instead of `nndsvd`. update_H : bool, default=True Set to True, both W and H will be estimated from initial guesses. Set to False, only W will be estimated. solver : {'cd', 'mu'}, default='cd' Numerical solver to use: - 'cd' is a Coordinate Descent solver that uses Fast Hierarchical Alternating Least Squares (Fast HALS). - 'mu' is a Multiplicative Update solver. .. versionadded:: 0.17 Coordinate Descent solver. .. versionadded:: 0.19 Multiplicative Update solver. beta_loss : float or {'frobenius', 'kullback-leibler', 'itakura-saito'}, default='frobenius' Beta divergence to be minimized, measuring the distance between X and the dot product WH. Note that values different from 'frobenius' (or 2) and 'kullback-leibler' (or 1) lead to significantly slower fits. Note that for beta_loss <= 0 (or 'itakura-saito'), the input matrix X cannot contain zeros. Used only in 'mu' solver. .. versionadded:: 0.19 tol : float, default=1e-4 Tolerance of the stopping condition. max_iter : int, default=200 Maximum number of iterations before timing out. alpha_W : float, default=0.0 Constant that multiplies the regularization terms of `W`. Set it to zero (default) to have no regularization on `W`. .. versionadded:: 1.0 alpha_H : float or "same", default="same" Constant that multiplies the regularization terms of `H`. Set it to zero to have no regularization on `H`. If "same" (default), it takes the same value as `alpha_W`. .. versionadded:: 1.0 l1_ratio : float, default=0.0 The regularization mixing parameter, with 0 <= l1_ratio <= 1. For l1_ratio = 0 the penalty is an elementwise L2 penalty (aka Frobenius Norm). For l1_ratio = 1 it is an elementwise L1 penalty. For 0 < l1_ratio < 1, the penalty is a combination of L1 and L2. random_state : int, RandomState instance or None, default=None Used for NMF initialisation (when ``init`` == 'nndsvdar' or 'random'), and in Coordinate Descent. Pass an int for reproducible results across multiple function calls. See :term:`Glossary `. verbose : int, default=0 The verbosity level. shuffle : bool, default=False If true, randomize the order of coordinates in the CD solver. Returns ------- W : ndarray of shape (n_samples, n_components) Solution to the non-negative least squares problem. H : ndarray of shape (n_components, n_features) Solution to the non-negative least squares problem. n_iter : int Actual number of iterations. References ---------- .. [1] :doi:`"Fast local algorithms for large scale nonnegative matrix and tensor factorizations" <10.1587/transfun.E92.A.708>` Cichocki, Andrzej, and P. H. A. N. Anh-Huy. IEICE transactions on fundamentals of electronics, communications and computer sciences 92.3: 708-721, 2009. .. [2] :doi:`"Algorithms for nonnegative matrix factorization with the beta-divergence" <10.1162/NECO_a_00168>` Fevotte, C., & Idier, J. (2011). Neural Computation, 23(9). Examples -------- >>> import numpy as np >>> X = np.array([[1,1], [2, 1], [3, 1.2], [4, 1], [5, 0.8], [6, 1]]) >>> from sklearn.decomposition import non_negative_factorization >>> W, H, n_iter = non_negative_factorization( ... X, n_components=2, init='random', random_state=0) ) rbrrrlrrrvrrrrrrcscrrT assume_finiterErFrN)NMF_validate_paramsrr%rfloat32r _fit_transform)r(rErFrbrrrrlrrrrrrvrrestrs r!non_negative_factorizationrsl !  !   CA^BJ ;STTTA d + + +JJ))!qA)II 1fJJJJJJJJJJJJJJJ a<s(BBBceZdZUdZdejiZeedddde dhge hddge hd e gee d ddgeedddgd gee d ddgee d dde d hgee d dd gdgd Z e e d< dddddddd dd d dZdZdZdZd dZd dddZedZfdZxZS)!_BaseNMFz$Base class for NMF and MiniBatchNMF.XtrNleftclosedr,>customrwrprqrx>rgrirhrrvrbothr rbrrlrrrvrrrr_parameter_constraintsrgrrr) rrlrrrvrrrrc ||_||_||_||_||_||_||_||_| |_| |_ dSNr) selfrbrrlrrrvrrrrs r!__init__z_BaseNMF.__init__sP) "  (     r#c|j|_|j|jd|_t|j|_dS)Nr)rb _n_componentsr.r8rl _beta_loss)rr(s r! _check_paramsz_BaseNMF._check_paramss;!.   %!"D .dn==r#cF|j\}}|jdkr|rt||j|fdt|||jfd|jdkr|jd|_|j|jks|j|jkr-t d|j|jnk|s|tjdtt||j|fd|jdkr|jd|_|j|jkr't d |j|j d krRtj | |jz }tj||jf||j }ntj||jf|j }n`||tjd t|jdkr|jd |_t!||j|j|j\}}||fS)z"Check W and H, or initialize them.rz NMF (input H)z NMF (input W)r,rzKH and W should have the same dtype as X. Got H.dtype = {} and W.dtype = {}.Nz8When update_H=False, the provided initial W is not used.z4H should have the same dtype as X. Got H.dtype = {}.murzcWhen init!='custom', provided W or H are ignored. Set init='custom' to use them as initialization.r)rrv)r.rr3r r TypeErrorr{warningswarnRuntimeWarningrr%rr|fullzerosrrv)rr(rErFrrrrs r! _check_w_hz_BaseNMF._check_w_hsB ! : 9 X D. ;_ M M M It'9:O L L L!V++%&WQZ"w!'!!QW%7%755;VAGQW5M5M&8 ( } N" D. ;_ M M M!V++%&WQZ"w!'!!JQQ{d""gaffhh);;<<GY(:;SPPPHi);?w&# *=>8X55r#c "|j|fi||S)aSLearn a NMF model for the data X. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training vector, where `n_samples` is the number of samples and `n_features` is the number of features. y : Ignored Not used, present for API consistency by convention. **params : kwargs Parameters (keyword arguments) and values passed to the fit_transform instance. Returns ------- self : object Returns the instance itself. ) fit_transform)rr(rparamss r!fitz _BaseNMF.fits$. 1''''' r#)rcTt||}t|||jzS)a^Transform data back to its original space. .. versionadded:: 0.18 Parameters ---------- X : {ndarray, sparse matrix} of shape (n_samples, n_components) Transformed data matrix. Xt : {ndarray, sparse matrix} of shape (n_samples, n_components) Transformed data matrix. .. deprecated:: 1.5 `Xt` was deprecated in 1.5 and will be removed in 1.7. Use `X` instead. Returns ------- X : ndarray of shape (n_samples, n_features) Returns a data matrix of the original shape. )rr components_)rr(rs r!inverse_transformz_BaseNMF.inverse_transforms/, /q" 5 54###r#c&|jjdS)z&Number of transformed output features.r)rr.)rs r!_n_features_outz_BaseNMF._n_features_out.s%a((r#ct}d|j_d|j_ddg|j_|S)NTrr)super__sklearn_tags__ input_tags positive_onlysparsetransformer_tagspreserves_dtype)rtags __class__s r!r$z_BaseNMF.__sklearn_tags__3sAww''))(,%!%1:I0F- r#r,r)__name__ __module__ __qualname____doc__rUNUSED-_BaseNMF__metadata_request__inverse_transformrrrrrdict__annotations__r r rrrrpropertyr!r$ __classcell__r+s@r!rros/.. .23C3J,K) HXq$v 6 6 6  Jx  JLLL M M  JIII J J  q$v6667Xh4???@'(HT1d6:::;HT1d6:::JJx>>:::x 6 6 64$d$$$$$6))X)r#rc eZdZUdZiejeddhgdgdZeed< dddd d d dd d d ddd fd Z fdZ e dddZ ddZ dZxZS)raNon-Negative Matrix Factorization (NMF). Find two non-negative matrices, i.e. matrices with all non-negative elements, (W, H) whose product approximates the non-negative matrix X. This factorization can be used for example for dimensionality reduction, source separation or topic extraction. The objective function is: .. math:: L(W, H) &= 0.5 * ||X - WH||_{loss}^2 &+ alpha\_W * l1\_ratio * n\_features * ||vec(W)||_1 &+ alpha\_H * l1\_ratio * n\_samples * ||vec(H)||_1 &+ 0.5 * alpha\_W * (1 - l1\_ratio) * n\_features * ||W||_{Fro}^2 &+ 0.5 * alpha\_H * (1 - l1\_ratio) * n\_samples * ||H||_{Fro}^2, where :math:`||A||_{Fro}^2 = \sum_{i,j} A_{ij}^2` (Frobenius norm) and :math:`||vec(A)||_1 = \sum_{i,j} abs(A_{ij})` (Elementwise L1 norm). The generic norm :math:`||X - WH||_{loss}` may represent the Frobenius norm or another supported beta-divergence loss. The choice between options is controlled by the `beta_loss` parameter. The regularization terms are scaled by `n_features` for `W` and by `n_samples` for `H` to keep their impact balanced with respect to one another and to the data fit term as independent as possible of the size `n_samples` of the training set. The objective function is minimized with an alternating minimization of W and H. Note that the transformed data is named W and the components matrix is named H. In the NMF literature, the naming convention is usually the opposite since the data matrix X is transposed. Read more in the :ref:`User Guide `. Parameters ---------- n_components : int or {'auto'} or None, default='auto' Number of components. If `None`, all features are kept. If `n_components='auto'`, the number of components is automatically inferred from W or H shapes. .. versionchanged:: 1.4 Added `'auto'` value. .. versionchanged:: 1.6 Default value changed from `None` to `'auto'`. init : {'random', 'nndsvd', 'nndsvda', 'nndsvdar', 'custom'}, default=None Method used to initialize the procedure. Valid options: - `None`: 'nndsvda' if n_components <= min(n_samples, n_features), otherwise random. - `'random'`: non-negative random matrices, scaled with: `sqrt(X.mean() / n_components)` - `'nndsvd'`: 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) - `'custom'`: Use custom matrices `W` and `H` which must both be provided. .. versionchanged:: 1.1 When `init=None` and n_components is less than n_samples and n_features defaults to `nndsvda` instead of `nndsvd`. solver : {'cd', 'mu'}, default='cd' Numerical solver to use: - 'cd' is a Coordinate Descent solver. - 'mu' is a Multiplicative Update solver. .. versionadded:: 0.17 Coordinate Descent solver. .. versionadded:: 0.19 Multiplicative Update solver. beta_loss : float or {'frobenius', 'kullback-leibler', 'itakura-saito'}, default='frobenius' Beta divergence to be minimized, measuring the distance between X and the dot product WH. Note that values different from 'frobenius' (or 2) and 'kullback-leibler' (or 1) lead to significantly slower fits. Note that for beta_loss <= 0 (or 'itakura-saito'), the input matrix X cannot contain zeros. Used only in 'mu' solver. .. versionadded:: 0.19 tol : float, default=1e-4 Tolerance of the stopping condition. max_iter : int, default=200 Maximum number of iterations before timing out. random_state : int, RandomState instance or None, default=None Used for initialisation (when ``init`` == 'nndsvdar' or 'random'), and in Coordinate Descent. Pass an int for reproducible results across multiple function calls. See :term:`Glossary `. alpha_W : float, default=0.0 Constant that multiplies the regularization terms of `W`. Set it to zero (default) to have no regularization on `W`. .. versionadded:: 1.0 alpha_H : float or "same", default="same" Constant that multiplies the regularization terms of `H`. Set it to zero to have no regularization on `H`. If "same" (default), it takes the same value as `alpha_W`. .. versionadded:: 1.0 l1_ratio : float, default=0.0 The regularization mixing parameter, with 0 <= l1_ratio <= 1. For l1_ratio = 0 the penalty is an elementwise L2 penalty (aka Frobenius Norm). For l1_ratio = 1 it is an elementwise L1 penalty. For 0 < l1_ratio < 1, the penalty is a combination of L1 and L2. .. versionadded:: 0.17 Regularization parameter *l1_ratio* used in the Coordinate Descent solver. verbose : int, default=0 Whether to be verbose. shuffle : bool, default=False If true, randomize the order of coordinates in the CD solver. .. versionadded:: 0.17 *shuffle* parameter used in the Coordinate Descent solver. Attributes ---------- components_ : ndarray of shape (n_components, n_features) Factorization matrix, sometimes called 'dictionary'. n_components_ : int The number of components. It is same as the `n_components` parameter if it was given. Otherwise, it will be same as the number of features. reconstruction_err_ : float Frobenius norm of the matrix difference, or beta-divergence, between the training data ``X`` and the reconstructed data ``WH`` from the fitted model. n_iter_ : int Actual number of iterations. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 See Also -------- DictionaryLearning : Find a dictionary that sparsely encodes data. MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis. PCA : Principal component analysis. SparseCoder : Find a sparse representation of data from a fixed, precomputed dictionary. SparsePCA : Sparse Principal Components Analysis. TruncatedSVD : Dimensionality reduction using truncated SVD. References ---------- .. [1] :doi:`"Fast local algorithms for large scale nonnegative matrix and tensor factorizations" <10.1587/transfun.E92.A.708>` Cichocki, Andrzej, and P. H. A. N. Anh-Huy. IEICE transactions on fundamentals of electronics, communications and computer sciences 92.3: 708-721, 2009. .. [2] :doi:`"Algorithms for nonnegative matrix factorization with the beta-divergence" <10.1162/NECO_a_00168>` Fevotte, C., & Idier, J. (2011). Neural Computation, 23(9). Examples -------- >>> import numpy as np >>> X = np.array([[1, 1], [2, 1], [3, 1.2], [4, 1], [5, 0.8], [6, 1]]) >>> from sklearn.decomposition import NMF >>> model = NMF(n_components=2, init='random', random_state=0) >>> W = model.fit_transform(X) >>> H = model.components_ rrr)rrrr,NrgrrrrrF) rrrlrrrvrrrrrc zt|||||||| | |  ||_| |_dSNr)r#r rr)rrbrrrlrrrvrrrrrr+s r!r z NMF.__init__sX %%    r#ct||jdkr(|jdvrt d|jd|j|jdkr%|jdkrt jdt|S)Nr)rrgz$Invalid beta_loss parameter: solver z does not handle beta_loss = rwzThe multiplicative update ('mu') solver cannot update zeros present in the initialization, and so leads to poorer results when used jointly with init='nndsvd'. You may try init='nndsvda' or init='nndsvdar' instead.) r#r rrlr/rrr UserWarningrr(r+s r!r zNMF._check_params0s a    ;$  4>9I#I#I2t{22#~22  ;$  49#8#8 MM     r#Trc\t||dtjtjg}t d5||||\}}}dddn #1swxYwYt ||||jd|_|j d|_ ||_ ||_ |S) aLearn 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-like, sparse matrix} of shape (n_samples, n_features) Training vector, where `n_samples` is the number of samples and `n_features` is the number of features. y : Ignored Not used, present for API consistency by convention. W : array-like of shape (n_samples, n_components), default=None If `init='custom'`, it is used as initial guess for the solution. If `None`, uses the initialisation method specified in `init`. H : array-like of shape (n_components, n_features), default=None If `init='custom'`, it is used as initial guess for the solution. If `None`, uses the initialisation method specified in `init`. Returns ------- W : ndarray of shape (n_samples, n_components) Transformed data. rrTrrErFNrr) rr%rrr rrVr reconstruction_err_r. n_components_rn_iter_)rr(rrErFrs r!rzNMF.fit_transformGs8  !>"*bj9Q   $ / / / < <..qA.;;LAq& < < < < < < < < < < < < < < <$4 q!T_$$ $ $  WQZ sA##A'*A'c|||dkr|jdkrtd|||||\}}||\}}}} |jdkr:t||||j|j |||| ||j |j |j  \}}} nU|jdkr3t||||j|j |j|||| ||j ^}}} } ntd|jz| |j kr-|jdkr"tjd|j zt ||| fS)a4Learn a NMF model for the data X and returns the transformed data. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Data matrix to be decomposed y : Ignored W : array-like of shape (n_samples, n_components), default=None If `init='custom'`, it is used as initial guess for the solution. If `update_H=False`, it is initialised as an array of zeros, unless `solver='mu'`, then it is filled with values calculated by `np.sqrt(X.mean() / self._n_components)`. If `None`, uses the initialisation method specified in `init`. H : array-like of shape (n_components, n_features), default=None If `init='custom'`, it is used as initial guess for the solution. If `update_H=False`, it is used as a constant, to solve for W only. If `None`, uses the initialisation method specified in `init`. update_H : bool, default=True If True, both W and H will be estimated from initial guesses, this corresponds to a call to the 'fit_transform' method. If False, only W will be estimated, this corresponds to a call to the 'transform' method. Returns ------- W : ndarray of shape (n_samples, n_components) Transformed data. H : ndarray of shape (n_components, n_features) Factorization matrix, sometimes called 'dictionary'. n_iter_ : int Actual number of iterations. r|When beta_loss <= 0 and X contains zeros, the solver may diverge. Please add small values to X, or use a positive beta_loss.r)rrrrvrzInvalid solver parameter '%s'.zLMaximum number of iterations %d reached. Increase it to improve convergence.)r rzr r/rrrrrrrrrvrrrr) rr(rrErFrrrrrr_s r!rzNMF._fit_transformtsP 1 5577a<A;r,rNNNT)r-r.r/r0rrrr3r4r r r rrrIr6r7s@r!rr;s;LL\$  )$:tTl++,;$$$D @.\555***65*X````Dr#rceZdZUdZiejeeddddgeedddgeedddgdgeedddgeeddddgd Ze e d < d"dd d dddddddddddddfd Z fdZ dZ dZdZedd#dZd$dZd Zedd#d!ZxZS)% MiniBatchNMFa; Mini-Batch Non-Negative Matrix Factorization (NMF). .. versionadded:: 1.1 Find two non-negative matrices, i.e. matrices with all non-negative elements, (`W`, `H`) whose product approximates the non-negative matrix `X`. This factorization can be used for example for dimensionality reduction, source separation or topic extraction. The objective function is: .. math:: L(W, H) &= 0.5 * ||X - WH||_{loss}^2 &+ alpha\_W * l1\_ratio * n\_features * ||vec(W)||_1 &+ alpha\_H * l1\_ratio * n\_samples * ||vec(H)||_1 &+ 0.5 * alpha\_W * (1 - l1\_ratio) * n\_features * ||W||_{Fro}^2 &+ 0.5 * alpha\_H * (1 - l1\_ratio) * n\_samples * ||H||_{Fro}^2, where :math:`||A||_{Fro}^2 = \sum_{i,j} A_{ij}^2` (Frobenius norm) and :math:`||vec(A)||_1 = \sum_{i,j} abs(A_{ij})` (Elementwise L1 norm). The generic norm :math:`||X - WH||_{loss}^2` may represent the Frobenius norm or another supported beta-divergence loss. The choice between options is controlled by the `beta_loss` parameter. The objective function is minimized with an alternating minimization of `W` and `H`. Note that the transformed data is named `W` and the components matrix is named `H`. In the NMF literature, the naming convention is usually the opposite since the data matrix `X` is transposed. Read more in the :ref:`User Guide `. Parameters ---------- n_components : int or {'auto'} or None, default='auto' Number of components. If `None`, all features are kept. If `n_components='auto'`, the number of components is automatically inferred from W or H shapes. .. versionchanged:: 1.4 Added `'auto'` value. .. versionchanged:: 1.6 Default value changed from `None` to `'auto'`. init : {'random', 'nndsvd', 'nndsvda', 'nndsvdar', 'custom'}, default=None Method used to initialize the procedure. Valid options: - `None`: 'nndsvda' if `n_components <= min(n_samples, n_features)`, otherwise random. - `'random'`: non-negative random matrices, scaled with: `sqrt(X.mean() / n_components)` - `'nndsvd'`: 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). - `'custom'`: Use custom matrices `W` and `H` which must both be provided. batch_size : int, default=1024 Number of samples in each mini-batch. Large batch sizes give better long-term convergence at the cost of a slower start. beta_loss : float or {'frobenius', 'kullback-leibler', 'itakura-saito'}, default='frobenius' Beta divergence to be minimized, measuring the distance between `X` and the dot product `WH`. Note that values different from 'frobenius' (or 2) and 'kullback-leibler' (or 1) lead to significantly slower fits. Note that for `beta_loss <= 0` (or 'itakura-saito'), the input matrix `X` cannot contain zeros. tol : float, default=1e-4 Control early stopping based on the norm of the differences in `H` between 2 steps. To disable early stopping based on changes in `H`, set `tol` to 0.0. max_no_improvement : int, default=10 Control early stopping based on the consecutive number of mini batches that does not yield an improvement on the smoothed cost function. To disable convergence detection based on cost function, set `max_no_improvement` to None. max_iter : int, default=200 Maximum number of iterations over the complete dataset before timing out. alpha_W : float, default=0.0 Constant that multiplies the regularization terms of `W`. Set it to zero (default) to have no regularization on `W`. alpha_H : float or "same", default="same" Constant that multiplies the regularization terms of `H`. Set it to zero to have no regularization on `H`. If "same" (default), it takes the same value as `alpha_W`. l1_ratio : float, default=0.0 The regularization mixing parameter, with 0 <= l1_ratio <= 1. For l1_ratio = 0 the penalty is an elementwise L2 penalty (aka Frobenius Norm). For l1_ratio = 1 it is an elementwise L1 penalty. For 0 < l1_ratio < 1, the penalty is a combination of L1 and L2. forget_factor : float, default=0.7 Amount of rescaling of past information. Its value could be 1 with finite datasets. Choosing values < 1 is recommended with online learning as more recent batches will weight more than past batches. fresh_restarts : bool, default=False Whether to completely solve for W at each step. Doing fresh restarts will likely lead to a better solution for a same number of iterations but it is much slower. fresh_restarts_max_iter : int, default=30 Maximum number of iterations when solving for W at each step. Only used when doing fresh restarts. These iterations may be stopped early based on a small change of W controlled by `tol`. transform_max_iter : int, default=None Maximum number of iterations when solving for W at transform time. If None, it defaults to `max_iter`. random_state : int, RandomState instance or None, default=None Used for initialisation (when ``init`` == 'nndsvdar' or 'random'), and in Coordinate Descent. Pass an int for reproducible results across multiple function calls. See :term:`Glossary `. verbose : bool, default=False Whether to be verbose. Attributes ---------- components_ : ndarray of shape (n_components, n_features) Factorization matrix, sometimes called 'dictionary'. n_components_ : int The number of components. It is same as the `n_components` parameter if it was given. Otherwise, it will be same as the number of features. reconstruction_err_ : float Frobenius norm of the matrix difference, or beta-divergence, between the training data `X` and the reconstructed data `WH` from the fitted model. n_iter_ : int Actual number of started iterations over the whole dataset. n_steps_ : int Number of mini-batches processed. n_features_in_ : int Number of features seen during :term:`fit`. feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. See Also -------- NMF : Non-negative matrix factorization. MiniBatchDictionaryLearning : Finds a dictionary that can best be used to represent data using a sparse code. References ---------- .. [1] :doi:`"Fast local algorithms for large scale nonnegative matrix and tensor factorizations" <10.1587/transfun.E92.A.708>` Cichocki, Andrzej, and P. H. A. N. Anh-Huy. IEICE transactions on fundamentals of electronics, communications and computer sciences 92.3: 708-721, 2009. .. [2] :doi:`"Algorithms for nonnegative matrix factorization with the beta-divergence" <10.1162/NECO_a_00168>` Fevotte, C., & Idier, J. (2011). Neural Computation, 23(9). .. [3] :doi:`"Online algorithms for nonnegative matrix factorization with the Itakura-Saito divergence" <10.1109/ASPAA.2011.6082314>` Lefevre, A., Bach, F., Fevotte, C. (2011). WASPA. Examples -------- >>> import numpy as np >>> X = np.array([[1, 1], [2, 1], [3, 1.2], [4, 1], [5, 0.8], [6, 1]]) >>> from sklearn.decomposition import MiniBatchNMF >>> model = MiniBatchNMF(n_components=2, init='random', random_state=0) >>> W = model.fit_transform(X) >>> H = model.components_ rNrrrrr)max_no_improvementrc forget_factorfresh_restartsfresh_restarts_max_itertransform_max_iterrr,irgrrrrrgffffff?F)rrcrlrrMrrrrrNrOrPrQrvrc t|||||||| | | ||_||_| |_| |_| |_||_dSr:)r#r rMrcrNrOrPrQ)rrbrrcrlrrMrrrrrNrOrPrQrvrr+s r!r zMiniBatchNMF.__init__s{( %%  #5$*,'>$"4r#ct|t|j|jd|_|j|j|jdz z|_|jdkrdd|jz z |_ n%|jdkrd|jdz z |_ nd|_ |j |j n|j |_ |S)Nrrrr5r) r#r rzrcr. _batch_sizerN_rhor _gammarQr_transform_max_iterr=s r!r zMiniBatchNMF._check_paramss a   t ;;&4+;agaj+HI  ?Q  t!67DKK _q 3!67DKKDK &. MM(   r#c tj||jz }tj|jd|jf||j}|}||\}}} }t|D]n}t||||j || |j ^}}tj||z tj|z } |jdkr | |jkrn||dd<o|S)zMinimize the objective function w.r.t W. Update W with H being fixed, until convergence. This is the heart of `transform` but it's also used during `fit` when doing fresh restarts. rrN)r%rr|r rr.rrsrrDrr rWrr"r) rr(rFrrrEW_bufferrrErW_diffs r!_solve_WzMiniBatchNMF._solve_W s gaffhh!3344 GQWQZ!34c I I I6688$(#?#?#B#B !Xqx  A,1a(HdkEA[X..Q?Fx!||$( 2 2HQQQKKr#c (|jd}||\}}}} |js|||||j}n!t ||||j|||j^}} |jdkr*d||tj tj j k<t||||j|| zz|| zz||dz zz| |dz zz|z } |rlt||||j|| |j|j|j|j |dd<|jdkr*d||tj tj j k<| S)z0Perform the update of W and H for one minibatch.rNrrr)rlrrrr1rr)r.rrOr\rPrr rWr%rrrrVrAr_components_numerator_components_denominatorrV) rr(rErFrrcrrrrrE batch_costs r!_minibatch_stepzMiniBatchNMF._minibatch_step'sWQZ 261M1Ma1P1P.(Hh   !) aD$@AAAA,1a(HdkEA ?Q  .1Aa"(2:&&** + Q1do 6 6  !  !!Q$% &!Q$%  &     6+/!!k,.I   AaaaD!##25!bhrz**../r#c |jd}|dz}|dkr!|jrtd|d|d|dS|j||_n0||dzz } t | d} |jd| z z|| zz|_|jr td|d|d|d|jt j||z t j|z } |jdkr)| |jkr|jrtd |d|d S|j|j|jkrd|_ |j|_n|xj dz c_ |j .|j |j kr|jrtd |d|d SdS) z7Helper function to encapsulate the early stopping logicrrzMinibatch step /z: mean batch cost: FNz , ewa cost: z#Converged (small H change) at step Tz>Converged (lack of improvement in objective function) at step ) r.rr _ewa_costrzrr"r _ewa_cost_min_no_improvementrM) rr(r`rFH_bufferrstepn_stepsrcalphaH_diffs r!_minibatch_convergencez#MiniBatchNMF._minibatch_convergenceXs WQZ ax 199| YWWWwWW:WWXXX5 > !'DNN)a-0EqMME!^q5y9J<<    Q\**V[^^; 8a<"*bj9Q   $ / / / E E$($7$7Q!$7$D$D !Aq&' E E E E E E E E E E E E E E E$4 q!T_$$ $ $  WQZ  sA$$A(+A(c t|d|||dkr|jdkrt d|jd}|||||\}}|}||_tj |j|j |_ d|_ d|_d|_t!||j}t%j|}t)tj||jz }|j|z} t/t1| |D]U\} } ||| || ||} |r#||| | |||| | rn||dd<V|jr||||j}| dz} t)tj| |z } | |jkr.|jdkr#t?j d|jdtB||| | fS) aLearn a NMF model for the data X and returns the transformed data. Parameters ---------- X : {ndarray, sparse matrix} of shape (n_samples, n_features) Data matrix to be decomposed. W : array-like of shape (n_samples, n_components), default=None If `init='custom'`, it is used as initial guess for the solution. If `update_H=False`, it is initialised as an array of zeros, unless `solver='mu'`, then it is filled with values calculated by `np.sqrt(X.mean() / self._n_components)`. If `None`, uses the initialisation method specified in `init`. H : array-like of shape (n_components, n_features), default=None If `init='custom'`, it is used as initial guess for the solution. If `update_H=False`, it is used as a constant, to solve for W only. If `None`, uses the initialisation method specified in `init`. update_H : bool, default=True If True, both W and H will be estimated from initial guesses, this corresponds to a call to the `fit_transform` method. If False, only W will be estimated, this corresponds to a call to the `transform` method. Returns ------- W : ndarray of shape (n_samples, n_components) Transformed data. H : ndarray of shape (n_components, n_features) Factorization matrix, sometimes called 'dictionary'. n_iter : int Actual number of started iterations over the whole dataset. n_steps : int Number of mini-batches processed. zMiniBatchNMF (input X)rrDrNrzMaximum number of iterations z- reached. Increase it to improve convergence.)"rr rzr r/r.rrsr^r%onesrr_rdrerfrrU itertoolscycleintceilrziprDrarlrOr\rXrrrr)rr(rErFrrrgbatchesn_steps_per_iterrirTrer`rs r!rzMiniBatchNMF._fit_transformsWP 16777 1 5577a< aD$<==Aa%RWW'778899 T] " "tx!|| M:DM:::#    !VW$$r#ct|t||dtjtjgd}|||j|j}|S)agTransform the data X according to the fitted MiniBatchNMF model. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Data matrix to be transformed by the model. Returns ------- W : ndarray of shape (n_samples, n_components) Transformed data. rFrrrG)rrr%rrr\rrX)rr(rEs r!rIzMiniBatchNMF.transform" s`    (:rz*     MM!T-t/G H Hr#ct|d}t||dtjtjg| }|sw||||||d\}}||_tj |j |j |_ d|_ n|j}||d|d |j d|_||_|xj d z c_ |S) afUpdate the model using the data in `X` as a mini-batch. This method is expected to be called several times consecutively on different chunks of a dataset so as to implement out-of-core or online learning. This is especially useful when the whole dataset is too big to fit in memory at once (see :ref:`scaling_strategies`). Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Data matrix to be decomposed. y : Ignored Not used, present here for API consistency by convention. W : array-like of shape (n_samples, n_components), default=None If `init='custom'`, it is used as initial guess for the solution. Only used for the first call to `partial_fit`. H : array-like of shape (n_components, n_features), default=None If `init='custom'`, it is used as initial guess for the solution. Only used for the first call to `partial_fit`. Returns ------- self Returns the instance itself. rrryTrrrN)rr)hasattrrr%rrr rrsr^rpr.rr_rnrrarA)rr(rrErFhas_componentsrEs r! partial_fitzMiniBatchNMF.partial_fit< s@!}55   (:rz*$$     !   q ! ! !??1Q?>>DAq)*D &+-717!'+J+J+JD (DMM A Qa$777WQZ   r#r,r)NNT)r-r.r/r0rrrrrr3r4r r r\rarlr rrrIr}r6r7s@r!rLrLsIIV$  )$'x!T&III4Px!T&AAAB"(4Af===>$+$,HXq$v$N$N$N#O'x!T&III4P$$$D&5  "%&5&5&5&5&5&5&5P46///b:::x\555***65*X_%_%_%_%B4\555:::65:::::r#rL)F)NrnN) rrrrrrTrFNrJr) rgrrrrrrTr)NNr,)Dr0rqrrabcrmathrnumbersrrnumpyr% scipy.sparser'r9scipyr_configr baser r r r exceptionsrutilsrrrrutils._param_validationrrrutils.deprecationr utils.extmathrrrutils.validationrrr _cdnmf_fastrrrrr@r"r*r3rVr?r8rrrrrrrrrrLr#r!rss((  """"""""$$$$$$ ,+++++RRRRRRRRRRRR CBBBBBIIIIIIIIII ,+++++ "(2:   " ! ! ! ( ( (FFF"hhhhV*XXXXv888D       uuuu@   iiiiZHL^ ^ ^ ^ J       bbbbJO ,D !D !K  #(   b        #bbbbbJIIIII.0@-QTIIIXvvvvv(vvvr C C C C C 8C C C C C r#