\c@sIdZddlmZddlZddlZddlZddlmZddlZ ddl m Z ddl m Z mZddlmZmZmZdd lmZdd lmZmZmZmZdd lmZmZdd lmZdd lm Z m!Z!m"Z"m#Z#ddde%dde%de&d Z'ddddde%ddde%de&d Z(e&e&de&dZ)ddddddde&de&e&e&d Z*ddde%ddde&e%dddde&de&e&e&dZ+defdYZ,de e,fdYZ-de e,fd YZ.d!e e,fd"YZ/dS(#s Dictionary learning i(tprint_functionN(tceil(tlinalgi(t BaseEstimatortTransformerMixin(tParalleltdelayedteffective_n_jobs(tzip(t check_arraytcheck_random_statetgen_even_slicest gen_batches(trandomized_svdt row_norms(tcheck_is_fitted(tLassotorthogonal_mp_gramt LassoLarstLarst lasso_larsiic Csr|jdkr+|ddtjf}n|j\} } |jd}|jd|jdkrtdj|j|jn|dkr|dkrt}tj||j }n|dkrVt || }zntj dd}t d |d td | d td |dtd| }|j |j |j d||j}Wdtj |Xn|dkrt || }td |d td td |d|dtd| }|dk r||_n|j |j |j d| |j}nj|dkryzttj dd}td td | d td |dt|dtd| }|j |j |j d||j}Wdtj |Xn|dkrtj|tjtj||dj }| rOtj|ddd|qOnv|dkr?| rtdntd|d|dt|dddt|dtd|j }ntd||jd krn|j| |S|S(!s Generic sparse coding Each column of the result is the solution to a Lasso problem. Parameters ---------- X : array of shape (n_samples, n_features) Data matrix. dictionary : array 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 : None | array, shape=(n_components, n_components) Precomputed Gram matrix, dictionary * dictionary' gram can be None if method is 'threshold'. cov : array, shape=(n_components, n_samples) Precomputed covariance, dictionary * X' algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', 'threshold'} 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 | float The regularization parameter. It corresponds to alpha when algorithm is 'lasso_lars', 'lasso_cd' or 'threshold'. Otherwise it corresponds to n_nonzero_coefs. init : array of shape (n_samples, n_components) Initialization value of the sparse code. Only used if `algorithm='lasso_cd'`. max_iter : int, 1000 by default Maximum number of iterations to perform if `algorithm='lasso_cd'`. copy_cov : boolean, optional Whether to copy the precomputed covariance matrix; if False, it may be overwritten. check_input : boolean, optional If False, the input arrays X and dictionary will not be checked. verbose : int Controls the verbosity; the higher, the more messages. Defaults to 0. positive: boolean Whether to enforce a positivity constraint on the sparse code. .. versionadded:: 0.20 Returns ------- code : array of shape (n_components, n_features) The sparse codes See also -------- sklearn.linear_model.lars_path sklearn.linear_model.orthogonal_mp sklearn.linear_model.Lasso SparseCoder iNisRDictionary and X have different numbers of features:dictionary.shape: {} X.shape{}tlasso_cdRtalltignoretalphat fit_intercepttverboset normalizet precomputetfit_pathtpositivetXytmax_itert warm_startt check_inputtlarstn_nonzero_coefst thresholdtouttomps:Positive constraint not supported for "omp" coding method.tGramttolt norms_squaredtsquaredtcopy_Xys]Sparse coding method must be "lasso_lars" "lasso_cd", "lasso", "threshold" or "omp", got %s.i(tndimtnptnewaxistshapet ValueErrortformattNonetFalsetdottTtfloattseterrRtfittcoef_RtTrueRtinttsigntmaximumtabstclipRRtreshape(tXt dictionarytgramtcovt algorithmtregularizationtcopy_covtinitR R"RRt n_samplest n_featurest n_componentsRterr_mgtRtnew_codetclfR#((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyt_sparse_encodesrI                #   csK| r`dkrEtddddtddddq`ttnj\}}jd}dkrdkrtjjndkrdkrttjjndkr"| dkr=tt|d d | q=n| dkr=d nt | d ks[dkrt d dd ddddtd| d }|Stj ||f}t t |t | }td| d|  f d|D}x't||D]\}}|||`. Parameters ---------- X : array of shape (n_samples, n_features) Data matrix dictionary : array 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, shape=(n_components, n_components) Precomputed Gram matrix, dictionary * dictionary' cov : array, shape=(n_components, n_samples) Precomputed covariance, dictionary' * X algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', 'threshold'} 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' n_nonzero_coefs : int, 0.1 * n_features by default 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. alpha : float, 1. by default 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`. copy_cov : boolean, optional Whether to copy the precomputed covariance matrix; if False, it may be overwritten. init : array of shape (n_samples, n_components) Initialization value of the sparse codes. Only used if `algorithm='lasso_cd'`. max_iter : int, 1000 by default Maximum number of iterations to perform if `algorithm='lasso_cd'`. n_jobs : int or None, optional (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 : boolean, optional If False, the input arrays X and dictionary will not be checked. verbose : int, optional Controls the verbosity; the higher, the more messages. Defaults to 0. positive : boolean, optional Whether to enforce positivity when finding the encoding. .. versionadded:: 0.20 Returns ------- code : array of shape (n_samples, n_components) The sparse codes See also -------- sklearn.linear_model.lars_path sklearn.linear_model.orthogonal_mp sklearn.linear_model.Lasso SparseCoder RtordertCtdtypetfloat64iR%R#R'i ig?RERFRGRHRIR R"RRtn_jobsc3s|]}tt|dk rAdd|fndd dddk rl|ndddtdVqdS(NRGRHRIR R"R(RRPR3R4(t.0t this_slice( RBRFRHRERCRDRIR RRG(sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pys As N(R#R'(R R0R3R.R5R6R4tmintmaxRRPtemptytlistR RR(RBRCRDRERFR$RRHRIR RUR"RRRJRKRLtcodetslicest code_viewsRWt this_view(( RBRFRHRERCRDRIR RRGsBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyt sparse_encodesN]     "    ' c Cst|}|jd}t|}tjd|||f\} tjd||f\} tjd|f\} | d||d|} x9t|D]+} | d|dd| f|| ddfd| d t} tj| || ddf|dd| f<|rStj |dd| fddd |dd| fn| |dd| f}|d krl|d krt j j d t j jn|rtdn|j||dd| f<|rtj |dd| fddd |dd| fnd|| ddf<| |dd| f}|dd| fc|:'   >2<   <B idg:0yE>R#cCs|dkrtd|nd|}tj}t|}t| } |dk r|dk rtj|dd}|}n;tj|dt \}}}|ddtj f|}t |}||kr|ddd|f}|d|ddf}nYtj |tj t |||ff}tj|tj |||jd ff}tj|dd}d }g}tj}| d krtd d d nd}xt|D]}tj|}| d krtjjdtjjn'| r/td|||d|fnt||d|d|d|d|d|}t|j|j|jd| dtd| d| \}}|j}d||tjtj|}|j||d kr8|d|d}|||dkr8| d krtdn| r1td|nPq8n|dd kr| dk r| tqqW| r||||d fS|||fSdS( s9 Solves 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 ||_2^2 + alpha * || U ||_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. Read more in the :ref:`User Guide `. Parameters ---------- X : array of shape (n_samples, n_features) Data matrix. n_components : int, Number of dictionary atoms to extract. alpha : int, Sparsity controlling parameter. max_iter : int, Maximum number of iterations to perform. tol : float, Tolerance for the stopping condition. method : {'lars', 'cd'} 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 or None, optional (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 : array of shape (n_components, n_features), Initial value for the dictionary for warm restart scenarios. code_init : array of shape (n_samples, n_components), Initial value for the sparse code for warm restart scenarios. callback : callable or None, optional (default: None) Callable that gets invoked every five iterations verbose : bool, optional (default: False) To control the verbosity of the procedure. random_state : int, RandomState instance or None, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. return_n_iter : bool Whether or not to return the number of iterations. positive_dict : bool Whether to enforce positivity when finding the dictionary. .. versionadded:: 0.20 positive_code : bool Whether to enforce positivity when finding the code. .. versionadded:: 0.20 Returns ------- code : array of shape (n_samples, n_components) The sparse code factor in the matrix factorization. dictionary : array 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 DictionaryLearning MiniBatchDictionaryLearning SparsePCA MiniBatchSparsePCA R#tcds2Coding method %r not supported as a fit algorithm.tlasso_RQtFt full_matricesNiis[dict_learning]tendt it.sCIteration % 3i (elapsed time: % 3is, % 4.1fmn, current cost % 7.3f)i<RFRRIRURRRqRrg?its+--- Convergence reached after %d iterationsi(R#Rw(R1ttimeR7R R3R.tarrayRtsvdR4R/Rgtc_tzerostr_R0tnanRnRiRjRkRlRmR`RvR6R;tsumR?tappendtlocals(RBRLRR R)tmethodRUt dict_initt code_inittcallbackRRrt return_n_itert positive_dictt positive_codett0R\RCtStrt residualsterrorst current_costtiitdttdE((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyt dict_learningspf         , $     $    iic&Cs^|dkr|jd}n| d"kr7tdnd| } tj}|j\}}t|}t| } |dk r|}n;t||d| \}}}|ddtjf|}t |}||kr|d|ddf}n-tj |tj |||jdff}|dkrGt dd d n| ri|j }| j|n|}t|jd d d tjdt}tj|dd}t|d dd tjdt}t||}tj|}|dkr tj ||f}tj ||f}n |dj }|dj }| d}xtt| | ||D]\}}||} tj|}!|dkrtjjdtjjnM|r|dks|td|dkrt d||!|!dfqnt| |jd| d|d| dtd|j}"||dkr`t|d|}#nt|d|d|}#|#d||#d}$||$9}|tj|"|"j7}||$9}|tj| j|"j7}t |||d|d| d|}|dk rg|t!qgqgW|r_|rI|j||f|| dfS|j||ffSn|r8|dkrt dd d n|dkrt d d d nt||jd| d|d| dtd|}%|dkr tj|}!t d!|!|!dfn|r(|%|j|| dfS|%|jfSn|rS|j|| dfS|jSdS(#sSolves 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 ||_2^2 + alpha * || U ||_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. This is accomplished by repeatedly iterating over mini-batches by slicing the input data. Read more in the :ref:`User Guide `. Parameters ---------- X : array of shape (n_samples, n_features) Data matrix. n_components : int, Number of dictionary atoms to extract. alpha : float, Sparsity controlling parameter. n_iter : int, Number of iterations to perform. return_code : boolean, Whether to also return the code U or just the dictionary V. dict_init : array of shape (n_components, n_features), Initial value for the dictionary for warm restart scenarios. callback : callable or None, optional (default: None) callable that gets invoked every five iterations batch_size : int, The number of samples to take in each batch. verbose : bool, optional (default: False) To control the verbosity of the procedure. shuffle : boolean, Whether to shuffle the data before splitting it in batches. n_jobs : int or None, optional (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'} 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. random_state : int, RandomState instance or None, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. return_inner_stats : boolean, optional 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 inner_stats : tuple of (A, B) ndarrays Inner sufficient statistics that are kept by the algorithm. Passing them at initialization is useful in online settings, to avoid loosing 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 return_n_iter : bool Whether or not to return the number of iterations. positive_dict : bool Whether to enforce positivity when finding the dictionary. .. versionadded:: 0.20 positive_code : bool Whether to enforce positivity when finding the code. .. versionadded:: 0.20 Returns ------- code : array of shape (n_samples, n_components), the sparse code (only returned if `return_code=True`) dictionary : array 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 DictionaryLearning MiniBatchDictionaryLearning SparsePCA MiniBatchSparsePCA iR#Rws/Coding method not supported as a fit algorithm.RxRrNs[dict_learning]R{R|RQRyRStcopyt requirementstWRRiR}i gY@s.Iteration % 3i (elapsed time: % 3is, % 4.1fmn)i<RFRRUR"RiRsLearning code...t|s"done (total time: % 3is, % 4.1fmn)(R#Rw("R3R0R1RR7R R R.R/RgRRRnRtshuffleR R6RTR4trequireR t itertoolstcycleRRiRjRkRlRmRR`R5RvR(&RBRLRtn_itert return_codeRRt batch_sizeRRRURt iter_offsetRrtreturn_inner_statst inner_statsRRRRRJRKRCt_RRtX_traintbatchestAtBRtbatchtthis_XRt this_codetthetatbetaR\((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pytdict_learning_online]s|            $   !  )  &           tSparseCodingMixincBs2eZdZdddededZdZRS(sSparse coding mixinR'cCsC||_||_||_||_||_||_||_dS(N(RLttransform_algorithmttransform_n_nonzero_coefsttransform_alphat split_signRUR(tselfRLRRRRRUR((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyt_set_sparse_coding_paramsWs      c Cst|dt|}t||jd|jd|jd|jd|jd|j}|j r|j \}}t j |d|f}t j |d|d d d |ftminimum(RRBR\RJRKt split_code((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyt transformds     () N(t__name__t __module__t__doc__R3R4RR(((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyRTs  t SparseCodercBs>eZdZdgZdddededZddZRS(s Sparse 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 : array, [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'} 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, ``0.1 * n_features`` by default 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. transform_alpha : float, 1. by default 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`. split_sign : bool, False by default 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 or None, optional (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 Whether to enforce positivity when finding the code. .. versionadded:: 0.20 Attributes ---------- components_ : array, [n_components, n_features] The unchanged dictionary atoms See also -------- DictionaryLearning MiniBatchDictionaryLearning SparsePCA MiniBatchSparsePCA sparse_encode RCR'cCs3|j|jd||||||||_dS(Ni(RR0R(RRCRRRRRUR((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyt__init__s  cCs|S(sFDo nothing and return the estimator unchanged This method is just there to implement the usual API and hence work in pipelines. Parameters ---------- X : Ignored y : Ignored Returns ------- self : object Returns the object itself ((RRBty((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyR9sN(RRRt_required_parametersR3R4RR9(((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyRs I tDictionaryLearningcBsSeZdZdddddddddddeedeedZddZRS( sDictionary learning Finds a dictionary (a set of atoms) that can best be used to represent data using a sparse code. Solves the optimization problem:: (U^*,V^*) = argmin 0.5 || Y - U V ||_2^2 + alpha * || U ||_1 (U,V) with || V_k ||_2 = 1 for all 0 <= k < n_components Read more in the :ref:`User Guide `. Parameters ---------- n_components : int, number of dictionary elements to extract alpha : float, sparsity controlling parameter max_iter : int, maximum number of iterations to perform tol : float, tolerance for numerical error fit_algorithm : {'lars', 'cd'} 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. .. versionadded:: 0.17 *cd* coordinate descent method to improve speed. transform_algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', 'threshold'} 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'`` .. versionadded:: 0.17 *lasso_cd* coordinate descent method to improve speed. transform_n_nonzero_coefs : int, ``0.1 * n_features`` by default 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. transform_alpha : float, 1. by default 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`. n_jobs : int or None, optional (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 : array of shape (n_samples, n_components), initial value for the code, for warm restart dict_init : array of shape (n_components, n_features), initial values for the dictionary, for warm restart verbose : bool, optional (default: False) To control the verbosity of the procedure. split_sign : bool, False by default 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, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. positive_code : bool Whether to enforce positivity when finding the code. .. versionadded:: 0.20 positive_dict : bool Whether to enforce positivity when finding the dictionary .. versionadded:: 0.20 Attributes ---------- components_ : array, [n_components, n_features] dictionary atoms extracted from the data error_ : array vector of errors at each iteration n_iter_ : int Number of iterations run. Notes ----- **References:** J. Mairal, F. Bach, J. Ponce, G. Sapiro, 2009: Online dictionary learning for sparse coding (http://www.di.ens.fr/sierra/pdfs/icml09.pdf) See also -------- SparseCoder MiniBatchDictionaryLearning SparsePCA MiniBatchSparsePCA iig:0yE>R#R'cCst|j||||| | |||_||_||_||_| |_| |_| |_||_||_ dS(N( RRR R)t fit_algorithmRRRRrR(RRLRR R)RRRRRURRRRRrRR((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyRus          cCst|j}t|}|jd kr:|jd}n |j}t|||jd|jd|j d|j d|j d|j d|j d|jd |d td |jd |j \}}}|_||_||_|S(sqFit the model from data in X. Parameters ---------- X : array-like, shape (n_samples, n_features) Training vector, where n_samples in the number of samples and n_features is the number of features. y : Ignored Returns ------- self : object Returns the object itself iR)R RRURRRRrRRRN(R RrR RLR3R0RRR)R RRURRRR;RRtn_iter_Rterror_(RRBRRrRLtVtUtE((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyR9s(          N(RRRR3R4RR9(((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyRs  tMiniBatchDictionaryLearningcBsbeZdZd dddd ded dd d eed eedZd dZd d dZRS( srMini-batch dictionary learning Finds a dictionary (a set of atoms) that can best be used to represent data using a sparse code. Solves the optimization problem:: (U^*,V^*) = argmin 0.5 || Y - U V ||_2^2 + alpha * || U ||_1 (U,V) with || V_k ||_2 = 1 for all 0 <= k < n_components Read more in the :ref:`User Guide `. Parameters ---------- n_components : int, number of dictionary elements to extract alpha : float, sparsity controlling parameter n_iter : int, total number of iterations to perform fit_algorithm : {'lars', 'cd'} 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 or None, optional (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, number of samples in each mini-batch shuffle : bool, whether to shuffle the samples before forming batches dict_init : array of shape (n_components, n_features), initial value of the dictionary for warm restart scenarios transform_algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', 'threshold'} 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, ``0.1 * n_features`` by default 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. transform_alpha : float, 1. by default 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`. verbose : bool, optional (default: False) To control the verbosity of the procedure. split_sign : bool, False by default 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, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. positive_code : bool Whether to enforce positivity when finding the code. .. versionadded:: 0.20 positive_dict : bool Whether to enforce positivity when finding the dictionary. .. versionadded:: 0.20 Attributes ---------- components_ : array, [n_components, n_features] components extracted from the data inner_stats_ : tuple of (A, B) ndarrays Internal sufficient statistics that are kept by the algorithm. Keeping them is useful in online settings, to avoid loosing the history of the evolution, but they shouldn't have any use for the end user. A (n_components, n_components) is the dictionary covariance matrix. B (n_features, n_components) is the data approximation matrix n_iter_ : int Number of iterations run. Notes ----- **References:** J. Mairal, F. Bach, J. Ponce, G. Sapiro, 2009: Online dictionary learning for sparse coding (http://www.di.ens.fr/sierra/pdfs/icml09.pdf) See also -------- SparseCoder DictionaryLearning SparsePCA MiniBatchSparsePCA iiR#iR'cCs}|j|| | | | ||||_||_||_||_| |_||_||_| |_||_ ||_ dS(N( RRRRRRRRRRrR(RRLRRRRURRRRRRRRRrRR((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyR2s           cCst|j}t|}t||j|jd|jdtd|jd|j d|j d|j d|j d|j d |d td td |jd |j \}\}}|_||_||f|_|j|_|S(stFit the model from data in X. Parameters ---------- X : array-like, shape (n_samples, n_features) Training vector, where n_samples in the number of samples and n_features is the number of features. y : Ignored Returns ------- self : object Returns the instance itself. RRRRURRRRRrRRRR(R RrR RRLRRR4RRURRRRR;RRRRt inner_stats_t iter_offset_(RRBRRrRRR((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyR9Hs"     c CsFt|ds$t|j|_nt|}t|drK|j}n |j}t|dd}|dkrt|dd}nt ||j |j d|j d|j d|jd |d t|d td |jd td|d|jdtd|d|jd|j\}\}}||_||f|_||j |_|S(sUpdates the model using the data in X as a mini-batch. Parameters ---------- X : array-like, shape (n_samples, n_features) Training vector, where n_samples in the number of samples and n_features is the number of features. y : Ignored iter_offset : integer, optional The number of iteration on data batches that has been performed before this call to partial_fit. This is optional: if no number is passed, the memory of the object is used. Returns ------- self : object Returns the instance itself. t random_state_RRRiRRRURRRRRRRrRRRRN(thasattrR RrRR RRtgetattrR3RRLRRRRURgR4RR;RRRR( RRBRRRRRRR((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyt partial_fitms.       N( RRRR3R;R4RR9R(((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pyRs     %(0Rt __future__RRRjRtmathRtnumpyR.tscipyRtbaseRRt utils._joblibRRRtexternals.six.movesRtutilsR R R R t utils.extmathR Rtutils.validationRt linear_modelRRRRR3R;R4RPR`RvRRRRRR(((sBlib/python2.7/site-packages/sklearn/decomposition/dict_learning.pytsP    ""     R      7j