U _{jE@sdZddlZddlZddlZddlZddlmZddlmZm Z ddl Z ddl m Z ddlmZddlmZmZmZmZdd lmZmZmZmZdd lmZmZmZmZdd lm Z m!Z!m"Z"m#Z#dd l$m%Z%m&Z&m'Z'dd l(m)Z)m*Z*ddl+m,Z,ddZ-dddddddddd ddZ.e#dgdgddgddge"dddddhge!edddddge!e dddddgd gddge!eddddgedgd gd!gd gd"dd#ddddddddddddd$ d%d&Z/dddddddddddd' d(d)Z0dFd*d+Z1d,d-Z2dGd.d/Z3dHdd0ddddd1ddddd0dd0d0d0dddd2d3d4d5d6Z4e#dge"dd7hgd ge!eddddgd8dd#d9d:dddddddddddd; dd?d?eeZ6Gd@dAdAe6eZ7GdBdCdCe6eZ8GdDdEdEe6eZ9dS)Iz Dictionary learning. N)ceil)IntegralReal)effective_n_jobs)linalg) BaseEstimatorClassNamePrefixFeaturesOutMixinTransformerMixin _fit_context)LarsLasso LassoLarsorthogonal_mp_gram) check_arraycheck_random_state gen_batchesgen_even_slices)HiddenInterval StrOptionsvalidate_params)randomized_svd row_normssvd_flip)Paralleldelayed)check_is_fittedcCs|r|dkrtd|dS)N)omplarsz9Positive constraint not supported for '{}' coding method.) ValueErrorformatmethodpositiver%c/var/www/html/bwave/python/venv/lib/python3.8/site-packages/sklearn/decomposition/_dict_learning.py_check_positive_codings r' lasso_larsTF gramcov algorithmregularizationcopy_covinitmax_iterverboser$c  Cs|j\} } |jd} |dkr|t|| }z@tjdd}t|d| |d| |d}|j|j|j|d|j}W5tjf|Xn4|dkrt|| }t|d||d | d }|d k r|j d st |}||_|j|j|jdd |j}n|dkr>z@tjdd}t d| |t |dd}|j|j|j|d|j}W5tjf|Xnr|dkrt |tt||dj}| rtj|dd |dn,|dkrt||t |d t|d d|dj}|| | S)a Generic sparse coding with precomputed Gram and/or covariance matrices. Each row of the result is the solution to a Lasso problem. Parameters ---------- X : ndarray of shape (n_samples, n_features) Data matrix. dictionary : ndarray of shape (n_components, n_features) The dictionary matrix against which to solve the sparse coding of the data. Some of the algorithms assume normalized rows. gram : ndarray of shape (n_components, n_components), default=None Precomputed Gram matrix, `dictionary * dictionary'` gram can be `None` if method is 'threshold'. cov : ndarray of shape (n_components, n_samples), default=None Precomputed covariance, `dictionary * X'`. algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', 'threshold'}, default='lasso_lars' The algorithm used: * `'lars'`: uses the least angle regression method (`linear_model.lars_path`); * `'lasso_lars'`: uses Lars to compute the Lasso solution; * `'lasso_cd'`: uses the coordinate descent method to compute the Lasso solution (`linear_model.Lasso`). lasso_lars will be faster if the estimated components are sparse; * `'omp'`: uses orthogonal matching pursuit to estimate the sparse solution; * `'threshold'`: squashes to zero all coefficients less than regularization from the projection `dictionary * data'`. regularization : int or float, default=None The regularization parameter. It corresponds to alpha when algorithm is `'lasso_lars'`, `'lasso_cd'` or `'threshold'`. Otherwise it corresponds to `n_nonzero_coefs`. init : ndarray of shape (n_samples, n_components), default=None Initialization value of the sparse code. Only used if `algorithm='lasso_cd'`. max_iter : int, default=1000 Maximum number of iterations to perform if `algorithm='lasso_cd'` or `'lasso_lars'`. copy_cov : bool, default=True Whether to copy the precomputed covariance matrix; if `False`, it may be overwritten. verbose : int, default=0 Controls the verbosity; the higher, the more messages. positive: bool, default=False Whether to enforce a positivity constraint on the sparse code. .. versionadded:: 0.20 Returns ------- code : ndarray of shape (n_components, n_features) The sparse codes. rr(ignore)allF)alpha fit_interceptr2 precomputefit_pathr$r1)Xylasso_cdT)r5r6r7r1Z warm_startr$NZ WRITEABLE) check_inputr)r6r2r7n_nonzero_coefsr8 thresholdoutr)Zsquared)ZGramr9r<tolZ norms_squaredZcopy_Xy)shapefloatnpZseterrrfitTZcoef_r flagsarrayr intsignmaximumabscliprrZreshape)X dictionaryr+r,r-r.r/r0r1r2r$ n_samples n_features n_componentsr5Zerr_mgtr(Znew_codeZclfrr%r%r&_sparse_encode_precomputed&szO              "   rRz array-liker:rrr=leftclosedbooleanr2rMrNr+r,r-r<r5r/r0r1n_jobsr;r2r$Zprefer_skip_nested_validation) r+r,r-r<r5r/r0r1rYr;r2r$c Cs| rJ|dkr:t|dtjtjgd}t|dtjtjgd}nt|}t|}|jd|jdkrrtd|j|jt|| t|||||||||| | | | d S)aFSparse coding. Each row of the result is the solution to a sparse coding problem. The goal is to find a sparse array `code` such that:: X ~= code * dictionary Read more in the :ref:`User Guide `. Parameters ---------- X : array-like of shape (n_samples, n_features) Data matrix. dictionary : array-like of shape (n_components, n_features) The dictionary matrix against which to solve the sparse coding of the data. Some of the algorithms assume normalized rows for meaningful output. gram : array-like of shape (n_components, n_components), default=None Precomputed Gram matrix, `dictionary * dictionary'`. cov : array-like of shape (n_components, n_samples), default=None Precomputed covariance, `dictionary' * X`. algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', 'threshold'}, default='lasso_lars' The algorithm used: * `'lars'`: uses the least angle regression method (`linear_model.lars_path`); * `'lasso_lars'`: uses Lars to compute the Lasso solution; * `'lasso_cd'`: uses the coordinate descent method to compute the Lasso solution (`linear_model.Lasso`). lasso_lars will be faster if the estimated components are sparse; * `'omp'`: uses orthogonal matching pursuit to estimate the sparse solution; * `'threshold'`: squashes to zero all coefficients less than regularization from the projection `dictionary * data'`. n_nonzero_coefs : int, default=None Number of nonzero coefficients to target in each column of the solution. This is only used by `algorithm='lars'` and `algorithm='omp'` and is overridden by `alpha` in the `omp` case. If `None`, then `n_nonzero_coefs=int(n_features / 10)`. alpha : float, default=None If `algorithm='lasso_lars'` or `algorithm='lasso_cd'`, `alpha` is the penalty applied to the L1 norm. If `algorithm='threshold'`, `alpha` is the absolute value of the threshold below which coefficients will be squashed to zero. If `algorithm='omp'`, `alpha` is the tolerance parameter: the value of the reconstruction error targeted. In this case, it overrides `n_nonzero_coefs`. If `None`, default to 1. copy_cov : bool, default=True Whether to copy the precomputed covariance matrix; if `False`, it may be overwritten. init : ndarray of shape (n_samples, n_components), default=None Initialization value of the sparse codes. Only used if `algorithm='lasso_cd'`. max_iter : int, default=1000 Maximum number of iterations to perform if `algorithm='lasso_cd'` or `'lasso_lars'`. n_jobs : int, default=None Number of parallel jobs to run. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. check_input : bool, default=True If `False`, the input arrays X and dictionary will not be checked. verbose : int, default=0 Controls the verbosity; the higher, the more messages. positive : bool, default=False Whether to enforce positivity when finding the encoding. .. versionadded:: 0.20 Returns ------- code : ndarray of shape (n_samples, n_components) The sparse codes. See Also -------- sklearn.linear_model.lars_path : Compute Least Angle Regression or Lasso path using LARS algorithm. sklearn.linear_model.orthogonal_mp : Solves Orthogonal Matching Pursuit problems. sklearn.linear_model.Lasso : Train Linear Model with L1 prior as regularizer. SparseCoder : Find a sparse representation of data from a fixed precomputed dictionary. r:C)orderdtyperSzRDictionary and X have different numbers of features:dictionary.shape: {} X.shape{} r+r,r-r<r5r/r0r1rYr2r$) rrCfloat64float32rAr r!r'_sparse_encoderXr%r%r& sparse_encodesD   rbr^c  sLj\} }jd}dkr>| dkrNtt|dd| n| dkrNd dkrldkrltjdkrdkrd tjt| dksdkrt  d }|Sjd} jd}t| |f}t t | t| }t | d  f d d |D}t ||D]\}}|||<q4|S)z1Sparse coding without input/parameter validation.r)rrN rSg?r=r:Fr*)rYr2c3s\|]T}tt|dk r.dd|fnd dk rF|nd d VqdS)Nr*)rrR).0 this_slice rMr-r/r,rNr+r0r1r$r.r2r%r& sz!_sparse_encode..) rAminmaxrCdotrErrRemptylistrrzip)rMrNr+r,r-r<r5r/r0r1rYr2r$rOrPrQcodeZslicesZ code_viewsreZ this_viewr%rfr&razsN     ( rac CsF|j\}} t|}|dkr$|j|}|dkr6|j|}d} t| D]} || | fdkr|| |dd| f|| ||| | f7<nV|||} d| pd} |jd| t| d}| ||| <d|dd| f<| d7} |rtj || dd|| d|| t t || d<qB|rB| dkrBt | ddS) aUpdate the dense dictionary factor in place. Parameters ---------- dictionary : ndarray of shape (n_components, n_features) Value of the dictionary at the previous iteration. Y : ndarray of shape (n_samples, n_features) Data matrix. code : ndarray of shape (n_samples, n_components) Sparse coding of the data against which to optimize the dictionary. A : ndarray of shape (n_components, n_components), default=None Together with `B`, sufficient stats of the online model to update the dictionary. B : ndarray of shape (n_features, n_components), default=None Together with `A`, sufficient stats of the online model to update the dictionary. verbose: bool, default=False Degree of output the procedure will print. random_state : int, RandomState instance or None, default=None Used for randomly initializing the dictionary. Pass an int for reproducible results across multiple function calls. See :term:`Glossary `. positive : bool, default=False Whether to enforce positivity when finding the dictionary. .. versionadded:: 0.20 Nrgư>g{Gz?rS)sizer>z unused atoms resampled.)rArrErangechoiceZstdnormallenrCrLrirnormprint)rNYrnABr2 random_stater$rOrQZn_unusedkZnewdZ noise_levelnoiser%r%r& _update_dicts*,    6 "r|c Cspt}|dk r,|dk r,tj|dd}|}n8tj|dd\}}}t||\}}|ddtjf|}t|}||kr|ddd|f}|d|ddf}nBtj|t t|||ff}tj |t |||j dff}t |}g}tj }| dkr tddd d }t|D]2}t|}| dkrJtjd tjn| rhtd |||d |ft||||||||| d }t|||| | | ddt|||d|tt|}|||dkr&|d|d }|||d kr&| dkrtdn| r td|qL|ddkr| dk r| tq| rb||||dfS|||fSdS)z"Main dictionary learning algorithmNF)r\F)Z full_matricesrS[dict_learning] end.zCIteration % 3i (elapsed time: % 3is, % 4.1fmn, current cost % 7.3f)<)r-r5r0rYr$r1r2r2ryr$?rrz+--- Convergence reached after %d iterations)timerCrGrZsvdrnewaxisrsZc_zerosr_rAZasfortranarraynanrurpsysstdoutwriteflushrbr|sumrKappendlocals)rMrQr5r1r@r#rY dict_init code_initcallbackr2ry return_n_iter positive_dict positive_codemethod_max_itert0rnrNSrerrorsZ current_costiidtZdEr%r%r&_dict_learnings               rcCs>|dkr6d|d}|r&|d|7}t|t|S|SdS)N deprecated'zB' is deprecated in version 1.1 and will be removed in version 1.4.r)warningswarn FutureWarning)paramnamedefaultadditional_messagemsgr%r%r&_check_warn_deprecateds  rrMbP?rc)r5n_iterr1 return_coderr batch_sizer2shufflerYr# iter_offsetryreturn_inner_stats inner_statsrrrrr@max_no_improvementc-Cs||| |f}|dk r.tdd|Ds.tdt| ddd} t|dd d d }t|d dd}t|d d dd }|dk rd| }t|||| | || |||||||| |||d|}|s|jS||}||jfSt|dddd }|dkr|jd}| dkrtdt| |d| } t }|j\}}t |}t |}|dk r@|}n*t |||d\}} }| ddt jf|}t|}!||!kr|d|ddf}n(t j|t j||!|jdf|jdf}| dkrtddd| r|}"||"n|}"t|"dt jt jgd d}"t|d|"jd d}t j|dd }t||}#t|#}#|dkrnt j||f|"jd}$t j||f|"jd}%n|d}$|d}%| d}&tt| | ||#D]B\}&}'|"|'}(t |})| dkrtj !d!tj "n<| r| d"ks|&t#d#| dkrtd$|&|)|)d%ft$|(|| || d ||| d& }*|&|dkrXt |&d|}+nt |d'|&d|}+|+d||+d},|$|,9}$|$t %|*j&|*7}$|%|,9}%|%t %|(j&|*7}%t'||(|*|$|%| ||d(|dk r|t(q|r|r ||$|%f|&| dfS||$|%ffS|r| dkr4td)ddn| dkrJtd*ddt$||| || d ||| d& }| dkrt |})td+|)|)d%f|r|||&| dfS||fS|r||&| dfS|SdS),a[Solve a dictionary learning matrix factorization problem online. Finds the best dictionary and the corresponding sparse code for approximating the data matrix X by solving:: (U^*, V^*) = argmin 0.5 || X - U V ||_Fro^2 + alpha * || U ||_1,1 (U,V) with || V_k ||_2 = 1 for all 0 <= k < n_components where V is the dictionary and U is the sparse code. ||.||_Fro stands for the Frobenius norm and ||.||_1,1 stands for the entry-wise matrix norm which is the sum of the absolute values of all the entries in the matrix. This is accomplished by repeatedly iterating over mini-batches by slicing the input data. Read more in the :ref:`User Guide `. Parameters ---------- X : ndarray of shape (n_samples, n_features) Data matrix. n_components : int or None, default=2 Number of dictionary atoms to extract. If None, then ``n_components`` is set to ``n_features``. alpha : float, default=1 Sparsity controlling parameter. n_iter : int, default=100 Number of mini-batch iterations to perform. .. deprecated:: 1.1 `n_iter` is deprecated in 1.1 and will be removed in 1.4. Use `max_iter` instead. max_iter : int, default=None Maximum number of iterations over the complete dataset before stopping independently of any early stopping criterion heuristics. If ``max_iter`` is not None, ``n_iter`` is ignored. .. versionadded:: 1.1 return_code : bool, default=True Whether to also return the code U or just the dictionary `V`. dict_init : ndarray of shape (n_components, n_features), default=None Initial values for the dictionary for warm restart scenarios. If `None`, the initial values for the dictionary are created with an SVD decomposition of the data via :func:`~sklearn.utils.extmath.randomized_svd`. callback : callable, default=None A callable that gets invoked at the end of each iteration. batch_size : int, default=256 The number of samples to take in each batch. .. versionchanged:: 1.3 The default value of `batch_size` changed from 3 to 256 in version 1.3. verbose : bool, default=False To control the verbosity of the procedure. shuffle : bool, default=True Whether to shuffle the data before splitting it in batches. n_jobs : int, default=None Number of parallel jobs to run. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. method : {'lars', 'cd'}, default='lars' * `'lars'`: uses the least angle regression method to solve the lasso problem (`linear_model.lars_path`); * `'cd'`: uses the coordinate descent method to compute the Lasso solution (`linear_model.Lasso`). Lars will be faster if the estimated components are sparse. iter_offset : int, default=0 Number of previous iterations completed on the dictionary used for initialization. .. deprecated:: 1.1 `iter_offset` serves internal purpose only and will be removed in 1.4. random_state : int, RandomState instance or None, default=None Used for initializing the dictionary when ``dict_init`` is not specified, randomly shuffling the data when ``shuffle`` is set to ``True``, and updating the dictionary. Pass an int for reproducible results across multiple function calls. See :term:`Glossary `. return_inner_stats : bool, default=False Return the inner statistics A (dictionary covariance) and B (data approximation). Useful to restart the algorithm in an online setting. If `return_inner_stats` is `True`, `return_code` is ignored. .. deprecated:: 1.1 `return_inner_stats` serves internal purpose only and will be removed in 1.4. inner_stats : tuple of (A, B) ndarrays, default=None Inner sufficient statistics that are kept by the algorithm. Passing them at initialization is useful in online settings, to avoid losing the history of the evolution. `A` `(n_components, n_components)` is the dictionary covariance matrix. `B` `(n_features, n_components)` is the data approximation matrix. .. deprecated:: 1.1 `inner_stats` serves internal purpose only and will be removed in 1.4. return_n_iter : bool, default=False Whether or not to return the number of iterations. .. deprecated:: 1.1 `return_n_iter` will be removed in 1.4 and n_iter will never be returned. positive_dict : bool, default=False Whether to enforce positivity when finding the dictionary. .. versionadded:: 0.20 positive_code : bool, default=False Whether to enforce positivity when finding the code. .. versionadded:: 0.20 method_max_iter : int, default=1000 Maximum number of iterations to perform when solving the lasso problem. .. versionadded:: 0.22 tol : float, default=1e-3 Control early stopping based on the norm of the differences in the dictionary between 2 steps. Used only if `max_iter` is not None. To disable early stopping based on changes in the dictionary, set `tol` to 0.0. .. versionadded:: 1.1 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. Used only if `max_iter` is not None. To disable convergence detection based on cost function, set `max_no_improvement` to None. .. versionadded:: 1.1 Returns ------- code : ndarray of shape (n_samples, n_components), The sparse code (only returned if `return_code=True`). dictionary : ndarray of shape (n_components, n_features), The solutions to the dictionary learning problem. n_iter : int Number of iterations run. Returned only if `return_n_iter` is set to `True`. See Also -------- dict_learning : Solve a dictionary learning matrix factorization problem. DictionaryLearning : Find a dictionary that sparsely encodes data. MiniBatchDictionaryLearning : A faster, less accurate, version of the dictionary learning algorithm. SparsePCA : Sparse Principal Components Analysis. MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis. Ncss|]}|dkVqdS)rNr%)rdargr%r%r&rgasz'dict_learning_online..zuThe following arguments are incompatible with 'max_iter': return_n_iter, return_inner_stats, iter_offset, inner_statsrr)rrFz,From 1.4 inner_stats will never be returned.)rrrrzFrom 1.4 'n_iter' will never be returned. Refer to the 'n_iter_' and 'n_steps_' attributes of the MiniBatchDictionaryLearning object instead.lasso_)rQr5rrY fit_algorithmrrrrytransform_algorithmtransform_alpharrtransform_max_iterr2rr@rrdzUse 'max_iter' instead.rS)rcdz/Coding method not supported as a fit algorithm.ryr]r~rrr[r\r]copyr}W requirementsrrcY@z.Iteration % 3i (elapsed time: % 3is, % 4.1fmn)r)r-r5rYr;r$r1r2rrzLearning code...|z"done (total time: % 3is, % 4.1fmn)))r4r rMiniBatchDictionaryLearningrD components_ transformrAr'rrBrrrCrrsrrr]rurrrr_r`requirer itertoolscyclermrprrrrrrbrjrEr|r)-rMrQr5rr1rrrrr2rrYr#rryrrrrrrr@rdepsrZestrnrrOrPrN_rrX_trainbatchesrwrxrbatchZthis_XrZ this_codethetabetar%r%r&dict_learning_onlinesRI                               rr)rMr#rrr:0yE>) r1r@r#rYrrrr2ryrrrrcCsRt|||||||| || | || |d}||}| rD||j|j|jfS||j|jfS)a0Solve a dictionary learning matrix factorization problem. Finds the best dictionary and the corresponding sparse code for approximating the data matrix X by solving:: (U^*, V^*) = argmin 0.5 || X - U V ||_Fro^2 + alpha * || U ||_1,1 (U,V) with || V_k ||_2 = 1 for all 0 <= k < n_components where V is the dictionary and U is the sparse code. ||.||_Fro stands for the Frobenius norm and ||.||_1,1 stands for the entry-wise matrix norm which is the sum of the absolute values of all the entries in the matrix. Read more in the :ref:`User Guide `. Parameters ---------- X : array-like of shape (n_samples, n_features) Data matrix. n_components : int Number of dictionary atoms to extract. alpha : int or float Sparsity controlling parameter. max_iter : int, default=100 Maximum number of iterations to perform. tol : float, default=1e-8 Tolerance for the stopping condition. method : {'lars', 'cd'}, default='lars' The method used: * `'lars'`: uses the least angle regression method to solve the lasso problem (`linear_model.lars_path`); * `'cd'`: uses the coordinate descent method to compute the Lasso solution (`linear_model.Lasso`). Lars will be faster if the estimated components are sparse. n_jobs : int, default=None Number of parallel jobs to run. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. dict_init : ndarray of shape (n_components, n_features), default=None Initial value for the dictionary for warm restart scenarios. Only used if `code_init` and `dict_init` are not None. code_init : ndarray of shape (n_samples, n_components), default=None Initial value for the sparse code for warm restart scenarios. Only used if `code_init` and `dict_init` are not None. callback : callable, default=None Callable that gets invoked every five iterations. verbose : bool, default=False To control the verbosity of the procedure. random_state : int, RandomState instance or None, default=None Used for randomly initializing the dictionary. Pass an int for reproducible results across multiple function calls. See :term:`Glossary `. return_n_iter : bool, default=False Whether or not to return the number of iterations. positive_dict : bool, default=False Whether to enforce positivity when finding the dictionary. .. versionadded:: 0.20 positive_code : bool, default=False Whether to enforce positivity when finding the code. .. versionadded:: 0.20 method_max_iter : int, default=1000 Maximum number of iterations to perform. .. versionadded:: 0.22 Returns ------- code : ndarray of shape (n_samples, n_components) The sparse code factor in the matrix factorization. dictionary : ndarray of shape (n_components, n_features), The dictionary factor in the matrix factorization. errors : array Vector of errors at each iteration. n_iter : int Number of iterations run. Returned only if `return_n_iter` is set to True. See Also -------- dict_learning_online : Solve a dictionary learning matrix factorization problem online. DictionaryLearning : Find a dictionary that sparsely encodes data. MiniBatchDictionaryLearning : A faster, less accurate version of the dictionary learning algorithm. SparsePCA : Sparse Principal Components Analysis. MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis. )rQr5r1r@rrYrrrr2ryrrr)DictionaryLearning fit_transformrerror_n_iter_)rMrQr5r1r@r#rYrrrr2ryrrrrZ estimatorrnr%r%r& dict_learning6s2  rc@s(eZdZdZddZddZddZdS) _BaseSparseCodingz>Base class from SparseCoder and DictionaryLearning algorithms.cCs.||_||_||_||_||_||_||_dSN)rtransform_n_nonzero_coefsrr split_signrYr)selfrrrrrYrrr%r%r&__init__s z_BaseSparseCoding.__init__c Cs|j|dd}t|dr*|jdkr*|j}n|j}t|||j|j||j|j|j d}|j r|j \}}t |d|f}t |d|ddd|f<t |d |dd|df<|}|S)zWPrivate method allowing to accommodate both DictionaryLearning and SparseCoder.F)resetr5N)r-r<r5r1rYr$rr)_validate_datahasattrrr5rbrrrrYrrrArCrkrJminimum)rrMrNrrnrOrPZ split_coder%r%r& _transforms*  z_BaseSparseCoding._transformcCst||||jS)aEncode the data as a sparse combination of the dictionary atoms. Coding method is determined by the object parameter `transform_algorithm`. Parameters ---------- X : ndarray of shape (n_samples, n_features) Test data to be transformed, must have the same number of features as the data used to train the model. Returns ------- X_new : ndarray of shape (n_samples, n_components) Transformed data. )rrrrrMr%r%r&rsz_BaseSparseCoding.transformN)__name__ __module__ __qualname____doc__rrrr%r%r%r&rsrcs|eZdZdZdgZddddddddfdd Zdd d Zdfd d ZddZe ddZ e ddZ e ddZ Z S) SparseCoderaSparse coding. Finds a sparse representation of data against a fixed, precomputed dictionary. Each row of the result is the solution to a sparse coding problem. The goal is to find a sparse array `code` such that:: X ~= code * dictionary Read more in the :ref:`User Guide `. Parameters ---------- dictionary : ndarray of shape (n_components, n_features) The dictionary atoms used for sparse coding. Lines are assumed to be normalized to unit norm. transform_algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', 'threshold'}, default='omp' Algorithm used to transform the data: - `'lars'`: uses the least angle regression method (`linear_model.lars_path`); - `'lasso_lars'`: uses Lars to compute the Lasso solution; - `'lasso_cd'`: uses the coordinate descent method to compute the Lasso solution (linear_model.Lasso). `'lasso_lars'` will be faster if the estimated components are sparse; - `'omp'`: uses orthogonal matching pursuit to estimate the sparse solution; - `'threshold'`: squashes to zero all coefficients less than alpha from the projection ``dictionary * X'``. transform_n_nonzero_coefs : int, default=None Number of nonzero coefficients to target in each column of the solution. This is only used by `algorithm='lars'` and `algorithm='omp'` and is overridden by `alpha` in the `omp` case. If `None`, then `transform_n_nonzero_coefs=int(n_features / 10)`. transform_alpha : float, default=None If `algorithm='lasso_lars'` or `algorithm='lasso_cd'`, `alpha` is the penalty applied to the L1 norm. If `algorithm='threshold'`, `alpha` is the absolute value of the threshold below which coefficients will be squashed to zero. If `algorithm='omp'`, `alpha` is the tolerance parameter: the value of the reconstruction error targeted. In this case, it overrides `n_nonzero_coefs`. If `None`, default to 1. split_sign : bool, default=False Whether to split the sparse feature vector into the concatenation of its negative part and its positive part. This can improve the performance of downstream classifiers. n_jobs : int, default=None Number of parallel jobs to run. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. positive_code : bool, default=False Whether to enforce positivity when finding the code. .. versionadded:: 0.20 transform_max_iter : int, default=1000 Maximum number of iterations to perform if `algorithm='lasso_cd'` or `lasso_lars`. .. versionadded:: 0.22 Attributes ---------- n_components_ : int Number of atoms. 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. MiniBatchDictionaryLearning : A faster, less accurate, version of the dictionary learning algorithm. MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis. SparsePCA : Sparse Principal Components Analysis. sparse_encode : Sparse coding where each row of the result is the solution to a sparse coding problem. Examples -------- >>> import numpy as np >>> from sklearn.decomposition import SparseCoder >>> X = np.array([[-1, -1, -1], [0, 0, 3]]) >>> dictionary = np.array( ... [[0, 1, 0], ... [-1, -1, 2], ... [1, 1, 1], ... [0, 1, 1], ... [0, 2, 1]], ... dtype=np.float64 ... ) >>> coder = SparseCoder( ... dictionary=dictionary, transform_algorithm='lasso_lars', ... transform_alpha=1e-10, ... ) >>> coder.transform(X) array([[ 0., 0., -1., 0., 0.], [ 0., 1., 1., 0., 0.]]) rNrNFr))rrrrrYrrc s"t|||||||||_dSr)superrrN) rrNrrrrrYrr __class__r%r&rs  zSparseCoder.__init__cCs|S)aDo nothing and return the estimator unchanged. This method is just there to implement the usual API and hence work in pipelines. Parameters ---------- X : Ignored Not used, present for API consistency by convention. y : Ignored Not used, present for API consistency by convention. Returns ------- self : object Returns the instance itself. r%rrMyr%r%r&rDszSparseCoder.fitcst||jS)aQEncode the data as a sparse combination of the dictionary atoms. Coding method is determined by the object parameter `transform_algorithm`. Parameters ---------- X : ndarray 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. Returns ------- X_new : ndarray of shape (n_samples, n_components) Transformed data. )rrrNrrr%r&rszSparseCoder.transformcCsdtjtjgdS)NF)Z requires_fitpreserves_dtyperCr_r`rr%r%r& _more_tagss zSparseCoder._more_tagscCs |jjdS)zNumber of atoms.rrNrArr%r%r& n_components_szSparseCoder.n_components_cCs |jjdS)z%Number of features seen during `fit`.rSrrr%r%r&n_features_in_szSparseCoder.n_features_in_cCs|jS)&Number of transformed output features.)rrr%r%r&_n_features_outszSparseCoder._n_features_out)N)N)rrrrZ_required_parametersrrDrrpropertyrrr __classcell__r%r%rr&r#s&w   rcsNeZdZUdZeedddddgeeddddgeeddddgeeddddgeddhged d dd d hgeedddddgeedddddgedgej dgej dge dgd gdgdgdgdgeeddddgdZ e e d<d"ddddd dddddddddddddfdd Zd#ddZeddd$ddZeddZd d!ZZS)%raDictionary learning. Finds a dictionary (a set of atoms) that performs well at sparsely encoding the fitted data. Solves the optimization problem:: (U^*,V^*) = argmin 0.5 || X - U V ||_Fro^2 + alpha * || U ||_1,1 (U,V) with || V_k ||_2 <= 1 for all 0 <= k < n_components ||.||_Fro stands for the Frobenius norm and ||.||_1,1 stands for the entry-wise matrix norm which is the sum of the absolute values of all the entries in the matrix. Read more in the :ref:`User Guide `. Parameters ---------- n_components : int, default=None Number of dictionary elements to extract. If None, then ``n_components`` is set to ``n_features``. alpha : float, default=1.0 Sparsity controlling parameter. max_iter : int, default=1000 Maximum number of iterations to perform. tol : float, default=1e-8 Tolerance for numerical error. fit_algorithm : {'lars', 'cd'}, default='lars' * `'lars'`: uses the least angle regression method to solve the lasso problem (:func:`~sklearn.linear_model.lars_path`); * `'cd'`: uses the coordinate descent method to compute the Lasso solution (:class:`~sklearn.linear_model.Lasso`). Lars will be faster if the estimated components are sparse. .. versionadded:: 0.17 *cd* coordinate descent method to improve speed. transform_algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', 'threshold'}, default='omp' Algorithm used to transform the data: - `'lars'`: uses the least angle regression method (:func:`~sklearn.linear_model.lars_path`); - `'lasso_lars'`: uses Lars to compute the Lasso solution. - `'lasso_cd'`: uses the coordinate descent method to compute the Lasso solution (:class:`~sklearn.linear_model.Lasso`). `'lasso_lars'` will be faster if the estimated components are sparse. - `'omp'`: uses orthogonal matching pursuit to estimate the sparse solution. - `'threshold'`: squashes to zero all coefficients less than alpha from the projection ``dictionary * X'``. .. versionadded:: 0.17 *lasso_cd* coordinate descent method to improve speed. transform_n_nonzero_coefs : int, default=None Number of nonzero coefficients to target in each column of the solution. This is only used by `algorithm='lars'` and `algorithm='omp'`. If `None`, then `transform_n_nonzero_coefs=int(n_features / 10)`. transform_alpha : float, default=None If `algorithm='lasso_lars'` or `algorithm='lasso_cd'`, `alpha` is the penalty applied to the L1 norm. If `algorithm='threshold'`, `alpha` is the absolute value of the threshold below which coefficients will be squashed to zero. If `None`, defaults to `alpha`. .. versionchanged:: 1.2 When None, default value changed from 1.0 to `alpha`. n_jobs : int or None, default=None Number of parallel jobs to run. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. code_init : ndarray of shape (n_samples, n_components), default=None Initial value for the code, for warm restart. Only used if `code_init` and `dict_init` are not None. dict_init : ndarray of shape (n_components, n_features), default=None Initial values for the dictionary, for warm restart. Only used if `code_init` and `dict_init` are not None. callback : callable, default=None Callable that gets invoked every five iterations. .. versionadded:: 1.3 verbose : bool, default=False To control the verbosity of the procedure. split_sign : bool, default=False Whether to split the sparse feature vector into the concatenation of its negative part and its positive part. This can improve the performance of downstream classifiers. random_state : int, RandomState instance or None, default=None Used for initializing the dictionary when ``dict_init`` is not specified, randomly shuffling the data when ``shuffle`` is set to ``True``, and updating the dictionary. Pass an int for reproducible results across multiple function calls. See :term:`Glossary `. positive_code : bool, default=False Whether to enforce positivity when finding the code. .. versionadded:: 0.20 positive_dict : bool, default=False Whether to enforce positivity when finding the dictionary. .. versionadded:: 0.20 transform_max_iter : int, default=1000 Maximum number of iterations to perform if `algorithm='lasso_cd'` or `'lasso_lars'`. .. versionadded:: 0.22 Attributes ---------- components_ : ndarray of shape (n_components, n_features) dictionary atoms extracted from the data error_ : array vector of errors at each iteration 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 n_iter_ : int Number of iterations run. See Also -------- MiniBatchDictionaryLearning: A faster, less accurate, version of the dictionary learning algorithm. MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis. SparseCoder : Find a sparse representation of data from a fixed, precomputed dictionary. SparsePCA : Sparse Principal Components Analysis. References ---------- J. Mairal, F. Bach, J. Ponce, G. Sapiro, 2009: Online dictionary learning for sparse coding (https://www.di.ens.fr/sierra/pdfs/icml09.pdf) Examples -------- >>> import numpy as np >>> from sklearn.datasets import make_sparse_coded_signal >>> from sklearn.decomposition import DictionaryLearning >>> X, dictionary, code = make_sparse_coded_signal( ... n_samples=30, n_components=15, n_features=20, n_nonzero_coefs=10, ... random_state=42, ... ) >>> dict_learner = DictionaryLearning( ... n_components=15, transform_algorithm='lasso_lars', transform_alpha=0.1, ... random_state=42, ... ) >>> X_transformed = dict_learner.fit(X).transform(X) We can check the level of sparsity of `X_transformed`: >>> np.mean(X_transformed == 0) 0.52... We can compare the average squared euclidean norm of the reconstruction error of the sparse coded signal relative to the squared euclidean norm of the original signal: >>> X_hat = X_transformed @ dict_learner.components_ >>> np.mean(np.sum((X_hat - X) ** 2, axis=1) / np.sum(X ** 2, axis=1)) 0.05... rSNrTrUrrrr(r:rr=r2rWry)rQr5r1r@rrrrrYrrrr2rryrrr_parameter_constraintsr)rF)r5r1r@rrrrrYrrrr2rryrrrc s^t||||| ||||_||_||_||_||_| |_| |_| |_ | |_ ||_ ||_ dSr) rrrQr5r1r@rrrrr2ryr)rrQr5r1r@rrrrrYrrrr2rryrrrrr%r&rs( zDictionaryLearning.__init__cCs|||S)Fit the model from data in X. Parameters ---------- X : array-like 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. Returns ------- self : object Returns the instance itself. )rrr%r%r&rDs zDictionaryLearning.fitTrZc Cst|j|jdd|j}t|j}||}|jdkrD|jd}n|j}t|||j |j |j ||j |j |j|j|j|j|d|j|jd\}}}|_||_||_|S)aFit the model from data in X and return the transformed data. Parameters ---------- X : array-like 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. Returns ------- V : ndarray of shape (n_samples, n_components) Transformed data. r"rNrST)r5r@r1r#rrYrrrr2ryrrr)r'rrrryrrQrArr5r@r1rrYrrrr2rrrr) rrMrr#ryrQVUEr%r%r&r s8     z DictionaryLearning.fit_transformcCs |jjdSrrrrArr%r%r&rAsz"DictionaryLearning._n_features_outcCsdtjtjgiSNrrrr%r%r&rFs zDictionaryLearning._more_tags)N)N)N)rrrrrrrrrCndarraycallablerdict__annotations__rrDr rrrrrr%r%rr&rs` B +  4 rcseZdZUdZeedddddgeeddddgeeddddeedhgeedddddgedd hgdegeeddddgd gde j ged d d d dhgeedddddgeedddddgdgd gdgd gd geeddddgde geeddddgeedddddgdZ e ed<d/dddd ddddd ddddddddddddfdd ZddZddZd d!Zd"d#Zd$d%Zedd&d0d'd(Zedd&d1d)d*Zed+d,Zd-d.ZZS)2ra'Mini-batch dictionary learning. Finds a dictionary (a set of atoms) that performs well at sparsely encoding the fitted data. Solves the optimization problem:: (U^*,V^*) = argmin 0.5 || X - U V ||_Fro^2 + alpha * || U ||_1,1 (U,V) with || V_k ||_2 <= 1 for all 0 <= k < n_components ||.||_Fro stands for the Frobenius norm and ||.||_1,1 stands for the entry-wise matrix norm which is the sum of the absolute values of all the entries in the matrix. Read more in the :ref:`User Guide `. Parameters ---------- n_components : int, default=None Number of dictionary elements to extract. alpha : float, default=1 Sparsity controlling parameter. n_iter : int, default=1000 Total number of iterations over data batches to perform. .. deprecated:: 1.1 ``n_iter`` is deprecated in 1.1 and will be removed in 1.4. Use ``max_iter`` instead. max_iter : int, default=None Maximum number of iterations over the complete dataset before stopping independently of any early stopping criterion heuristics. If ``max_iter`` is not None, ``n_iter`` is ignored. .. versionadded:: 1.1 fit_algorithm : {'lars', 'cd'}, default='lars' The algorithm used: - `'lars'`: uses the least angle regression method to solve the lasso problem (`linear_model.lars_path`) - `'cd'`: uses the coordinate descent method to compute the Lasso solution (`linear_model.Lasso`). Lars will be faster if the estimated components are sparse. n_jobs : int, default=None Number of parallel jobs to run. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. batch_size : int, default=256 Number of samples in each mini-batch. .. versionchanged:: 1.3 The default value of `batch_size` changed from 3 to 256 in version 1.3. shuffle : bool, default=True Whether to shuffle the samples before forming batches. dict_init : ndarray of shape (n_components, n_features), default=None Initial value of the dictionary for warm restart scenarios. transform_algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', 'threshold'}, default='omp' Algorithm used to transform the data: - `'lars'`: uses the least angle regression method (`linear_model.lars_path`); - `'lasso_lars'`: uses Lars to compute the Lasso solution. - `'lasso_cd'`: uses the coordinate descent method to compute the Lasso solution (`linear_model.Lasso`). `'lasso_lars'` will be faster if the estimated components are sparse. - `'omp'`: uses orthogonal matching pursuit to estimate the sparse solution. - `'threshold'`: squashes to zero all coefficients less than alpha from the projection ``dictionary * X'``. transform_n_nonzero_coefs : int, default=None Number of nonzero coefficients to target in each column of the solution. This is only used by `algorithm='lars'` and `algorithm='omp'`. If `None`, then `transform_n_nonzero_coefs=int(n_features / 10)`. transform_alpha : float, default=None If `algorithm='lasso_lars'` or `algorithm='lasso_cd'`, `alpha` is the penalty applied to the L1 norm. If `algorithm='threshold'`, `alpha` is the absolute value of the threshold below which coefficients will be squashed to zero. If `None`, defaults to `alpha`. .. versionchanged:: 1.2 When None, default value changed from 1.0 to `alpha`. verbose : bool or int, default=False To control the verbosity of the procedure. split_sign : bool, default=False Whether to split the sparse feature vector into the concatenation of its negative part and its positive part. This can improve the performance of downstream classifiers. random_state : int, RandomState instance or None, default=None Used for initializing the dictionary when ``dict_init`` is not specified, randomly shuffling the data when ``shuffle`` is set to ``True``, and updating the dictionary. Pass an int for reproducible results across multiple function calls. See :term:`Glossary `. positive_code : bool, default=False Whether to enforce positivity when finding the code. .. versionadded:: 0.20 positive_dict : bool, default=False Whether to enforce positivity when finding the dictionary. .. versionadded:: 0.20 transform_max_iter : int, default=1000 Maximum number of iterations to perform if `algorithm='lasso_cd'` or `'lasso_lars'`. .. versionadded:: 0.22 callback : callable, default=None A callable that gets invoked at the end of each iteration. .. versionadded:: 1.1 tol : float, default=1e-3 Control early stopping based on the norm of the differences in the dictionary between 2 steps. Used only if `max_iter` is not None. To disable early stopping based on changes in the dictionary, set `tol` to 0.0. .. versionadded:: 1.1 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. Used only if `max_iter` is not None. To disable convergence detection based on cost function, set `max_no_improvement` to None. .. versionadded:: 1.1 Attributes ---------- components_ : ndarray of shape (n_components, n_features) Components extracted from the data. 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 n_iter_ : int Number of iterations over the full dataset. n_steps_ : int Number of mini-batches processed. .. versionadded:: 1.1 See Also -------- DictionaryLearning : Find a dictionary that sparsely encodes data. MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis. SparseCoder : Find a sparse representation of data from a fixed, precomputed dictionary. SparsePCA : Sparse Principal Components Analysis. References ---------- J. Mairal, F. Bach, J. Ponce, G. Sapiro, 2009: Online dictionary learning for sparse coding (https://www.di.ens.fr/sierra/pdfs/icml09.pdf) Examples -------- >>> import numpy as np >>> from sklearn.datasets import make_sparse_coded_signal >>> from sklearn.decomposition import MiniBatchDictionaryLearning >>> X, dictionary, code = make_sparse_coded_signal( ... n_samples=30, n_components=15, n_features=20, n_nonzero_coefs=10, ... random_state=42) >>> dict_learner = MiniBatchDictionaryLearning( ... n_components=15, batch_size=3, transform_algorithm='lasso_lars', ... transform_alpha=0.1, max_iter=20, random_state=42) >>> X_transformed = dict_learner.fit_transform(X) We can check the level of sparsity of `X_transformed`: >>> np.mean(X_transformed == 0) > 0.5 True We can compare the average squared euclidean norm of the reconstruction error of the sparse coded signal relative to the squared euclidean norm of the original signal: >>> X_hat = X_transformed @ dict_learner.components_ >>> np.mean(np.sum((X_hat - X) ** 2, axis=1) / np.sum(X ** 2, axis=1)) 0.052... rSNrTrUrrrrrWr(r:rr=r2ry)rQr5rr1rrYrrrrrrr2rryrrrrr@rrrTFr)rrc)r5rr1rrYrrrrrrr2rryrrrrr@rc svt| | | ||||||_||_||_||_||_| |_| |_||_ ||_ ||_ ||_ ||_ ||_||_||_dSr)rrrQr5rr1rrr2rrrryrrrr@)rrQr5rr1rrYrrrrrrr2rryrrrrr@rrr%r&rCs0 z$MiniBatchDictionaryLearning.__init__cCsP|j|_|jdkr|jd|_t|j|jd|j|_t|j|jd|_ dS)NrSrr) rQ _n_componentsrAr'rr_fit_algorithmrhr _batch_sizerr%r%r& _check_paramsus    z)MiniBatchDictionaryLearning._check_paramscCs|jdk r|j}n,t||j|d\}}}|ddtjf|}|jt|krd|d|jddf}n.t|tj|jt||jdf|j df}t |d|j dd}tj |dd }|S) z!Initialization of the dictionary.NrrSrr}Frrr) rrr rCrrsZ concatenaterrAr]rr)rrMryrNrrr%r%r&_initialize_dicts*   z,MiniBatchDictionaryLearning._initialize_dictcCs||dkr|d|}n|d|d|}|d||d}|j|9_|j|j||7_|j|9_|j|j||7_dS)zUpdate the inner stats inplace.rSrN)_ArE_B)rrMrnrsteprrr%r%r&_update_inner_statss z/MiniBatchDictionaryLearning._update_inner_statsc Cs|jd}t|||j|j|j|j|j|jd}d|||d|jt t ||}| ||||t ||||j |j|j||jd|S)z7Perform the update on the dictionary for one minibatch.r)r-r5rYr$r1r2rrr)rArar r5rYrrr2rrCrKrr|rrr)rrMrNryrrrn batch_costr%r%r&_minibatch_steps8   z+MiniBatchDictionaryLearning._minibatch_stepc Csl|jd}|d}|td||krH|jrDtd|d|d|dS|jdkrZ||_n.||d} t| d} |jd| || |_|jrtd|d|d|d |jt|||j} |jdkr| |jkr|jrtd |d|d S|j dks|j|j kr d|_ |j|_ n|j d7_ |j dk rh|j |j krh|jrdtd |d|d SdS) aHelper function to encapsulate the early stopping logic. Early stopping is based on two factors: - A small change of the dictionary between two minibatch updates. This is controlled by the tol parameter. - No more improvement on a smoothed estimate of the objective function for a a certain number of consecutive minibatch updates. This is controlled by the max_no_improvement parameter. rrSrzMinibatch step /z: mean batch cost: FNz , ewa cost: z,Converged (small dictionary change) at step Tz>Converged (lack of improvement in objective function) at step ) rArhr2ru _ewa_costrrtr r@ _ewa_cost_min_no_improvementr) rrMrZnew_dictold_dictrOrn_stepsrr5Z dict_diffr%r%r&_check_convergencesD      z.MiniBatchDictionaryLearning._check_convergencerZc Cs|j|tjtjgddd}|||jdkr@tdt|j}t |j |_ | ||j }| }|jr~| }|j |n|}|j\}}|jrtdtj|j|jf|jd|_tj||jf|jd|_|jdk rd|_d|_d |_t||j} t| } tt ||j} |j| } d } t!t"| | D]f\} } || }|#|||j | }|$|||||| | rpq|j%dk r|%t&||dd<q0| d |_'t |j'| |_(n|jdkrd n|j}t||j} t| } t!t"|| D]v\} } |#|| ||j | |jo*| t d |jd k}|jdks>|rLt| d|j%dk r|%t&q||_'t |tt ||j|_(||_)|S)rr[F)r]r\rrz'n_iter' is deprecated in version 1.1 and will be removed in version 1.4. Use 'max_iter' and let 'n_iter' to its default value instead. 'n_iter' is also ignored if 'max_iter' is specified.r~rNrrrSr)rrcz batches processed.)*rrCr_r`rrrrrrry _random_staterrrrAr2rurr r]rrr1rrrrr rrrHrrmrprrrrn_steps_rr)rrMrrrNrrrOrPrZn_steps_per_iterrirZX_batchrZtrigger_verboser%r%r&rD s                  zMiniBatchDictionaryLearning.fitcCst|d}|j|tjtjgd| d}|s||t|j|_| ||j}d|_ tj |j |j f|j d|_tj |jd|j f|j d|_n|j}||||j|j ||_|j d7_ |S)aUpdate the model using the data in X as a mini-batch. Parameters ---------- X : array-like 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. Returns ------- self : object Return the instance itself. rr[)r]r\rrrrS)rrrCr_r`rrryrrrrr r]rrArrr)rrMrZhas_componentsrNr%r%r& partial_fit s&     z'MiniBatchDictionaryLearning.partial_fitcCs |jjdSrrrr%r%r&r sz+MiniBatchDictionaryLearning._n_features_outcCsdtjtjgiSrrrr%r%r&r s z&MiniBatchDictionaryLearning._more_tags)N)N)N)rrrrrrrrrrCrrrr r rrrrrrr rDr rrrrr%r%rr&rLs| [  2  &D s , r)NNFNF)N)r):rrrrrmathrnumbersrrnumpyrCZjoblibrZscipyrbaserr r r Z linear_modelr r rrutilsrrrrZutils._param_validationrrrrZ utils.extmathrrrZutils.parallelrrZutils.validationrr'rRrbrar|rrrrrrrrr%r%r%r&s      ( T Pq  ! ISY