B 0db@sFdZddlmZddlmZddlZddlmZddl m Z ddl m Z m Z dd lmZdd lmZdd lmZmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlm Z ddddgZ!ddZ"Gddde Z#ddZ$dddddZ%dd Z&d)d"d#Z'd*d$d%Z(Gd&dde e Z)ddd'd(dZ*dS)+z The :mod:`sklearn.pipeline` module implements utilities to build a composite estimator, as a chain of transforms and estimators. ) defaultdict)isliceN)sparse)Parallel)cloneTransformerMixin) _VisualBlock) available_if)Bunch_print_elapsed_time) deprecated) _safe_tags) check_memory)check_is_fitted)delayed)NotFittedError)_BaseCompositionPipeline FeatureUnion make_pipeline make_unioncsfdd}|S)z\Check that final_estimator has `attr`. Used together with `avaliable_if` in `Pipeline`.cst|jdS)NT)getattr_final_estimator)self)attrB/var/www/html/venv/lib/python3.7/site-packages/sklearn/pipeline.pycheck+s z#_final_estimator_has..checkr)rrr)rr_final_estimator_has&s rc@seZdZdZdgZdddddZdSd d Zd d Zd dZdTddZ ddZ ddZ e ddZ e ddZe ddZddZddZdUdd ZdVd!d"ZdWd#d$Zeed%d&d'Zeed(dXd)d*Zeed+d,d-Zeed.d/d0Zeed1d2d3Zeed4d5d6Zd7d8Zeed9d:Zd;d<Zeed=d>Z eed?dYd@dAZ!e dBdCZ"dDdEZ#e$dFe dGdHZ%dZdIdJZ&e dKdLZ'e dMdNZ(dOdPZ)dQdRZ*dS)[ra Pipeline of transforms with a final estimator. Sequentially apply a list of transforms and a final estimator. Intermediate steps of the pipeline must be 'transforms', that is, they must implement `fit` and `transform` methods. The final estimator only needs to implement `fit`. The transformers in the pipeline can be cached using ``memory`` argument. The purpose of the pipeline is to assemble several steps that can be cross-validated together while setting different parameters. For this, it enables setting parameters of the various steps using their names and the parameter name separated by a `'__'`, as in the example below. A step's estimator may be replaced entirely by setting the parameter with its name to another estimator, or a transformer removed by setting it to `'passthrough'` or `None`. Read more in the :ref:`User Guide `. .. versionadded:: 0.5 Parameters ---------- steps : list of tuple List of (name, transform) tuples (implementing `fit`/`transform`) that are chained, in the order in which they are chained, with the last object an estimator. memory : str or object with the joblib.Memory interface, default=None Used to cache the fitted transformers of the pipeline. By default, no caching is performed. If a string is given, it is the path to the caching directory. Enabling caching triggers a clone of the transformers before fitting. Therefore, the transformer instance given to the pipeline cannot be inspected directly. Use the attribute ``named_steps`` or ``steps`` to inspect estimators within the pipeline. Caching the transformers is advantageous when fitting is time consuming. verbose : bool, default=False If True, the time elapsed while fitting each step will be printed as it is completed. Attributes ---------- named_steps : :class:`~sklearn.utils.Bunch` Dictionary-like object, with the following attributes. Read-only attribute to access any step parameter by user given name. Keys are step names and values are steps parameters. classes_ : ndarray of shape (n_classes,) The classes labels. Only exist if the last step of the pipeline is a classifier. n_features_in_ : int Number of features seen during :term:`fit`. Only defined if the underlying first estimator in `steps` exposes such an attribute when fit. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Only defined if the underlying estimator exposes such an attribute when fit. .. versionadded:: 1.0 See Also -------- make_pipeline : Convenience function for simplified pipeline construction. Examples -------- >>> from sklearn.svm import SVC >>> from sklearn.preprocessing import StandardScaler >>> from sklearn.datasets import make_classification >>> from sklearn.model_selection import train_test_split >>> from sklearn.pipeline import Pipeline >>> X, y = make_classification(random_state=0) >>> X_train, X_test, y_train, y_test = train_test_split(X, y, ... random_state=0) >>> pipe = Pipeline([('scaler', StandardScaler()), ('svc', SVC())]) >>> # The pipeline can be used as any other estimator >>> # and avoids leaking the test set into the train set >>> pipe.fit(X_train, y_train) Pipeline(steps=[('scaler', StandardScaler()), ('svc', SVC())]) >>> pipe.score(X_test, y_test) 0.88 stepsNF)memoryverbosecCs||_||_||_|dS)N)r r!r"_validate_steps)rr r!r"rrr__init__szPipeline.__init__TcCs|jd|dS)aGet parameters for this estimator. Returns the parameters given in the constructor as well as the estimators contained within the `steps` of the `Pipeline`. Parameters ---------- deep : bool, default=True If True, will return the parameters for this estimator and contained subobjects that are estimators. Returns ------- params : mapping of string to any Parameter names mapped to their values. r )deep) _get_params)rr%rrr get_paramsszPipeline.get_paramscKs|jd||S)aCSet the parameters of this estimator. Valid parameter keys can be listed with ``get_params()``. Note that you can directly set the parameters of the estimators contained in `steps`. Parameters ---------- **kwargs : dict Parameters of this estimator or parameters of estimators contained in `steps`. Parameters of the steps may be set using its name and the parameter name separated by a '__'. Returns ------- self : object Pipeline class instance. r )r ) _set_params)rkwargsrrr set_paramss zPipeline.set_paramscCst|j\}}|||dd}|d}xP|D]H}|dks2|dkrHq2t|ds\t|drft|ds2td|t|fq2W|dk r|dkrt|dstd|t|fdS)N passthroughfit fit_transform transformzAll intermediate steps should be transformers and implement fit and transform or be the string 'passthrough' '%s' (type %s) doesn'tzaLast step of Pipeline should implement fit or be the string 'passthrough'. '%s' (type %s) doesn't)zipr _validate_nameshasattr TypeErrortype)rnames estimators transformers estimatortrrrr#s$    zPipeline._validate_stepsccslt|j}|s|d8}xPtt|jd|D]:\}\}}|sH|||fVq*|dk r*|dkr*|||fVq*WdS)z Generate (idx, (name, trans)) tuples from self.steps When filter_passthrough is True, 'passthrough' and None transformers are filtered out. rrNr,)lenr enumerater)r with_finalfilter_passthroughstopidxnametransrrr_iters  zPipeline._itercCs t|jS)z4 Returns the length of the Pipeline )r:r )rrrr__len__szPipeline.__len__cCsht|tr6|jdkrtd|j|j||j|jdSy|j|\}}Wntk rb|j |SX|S)aReturns a sub-pipeline or a single estimator in the pipeline Indexing with an integer will return an estimator; using a slice returns another Pipeline instance which copies a slice of this Pipeline. This copy is shallow: modifying (or fitting) estimators in the sub-pipeline will affect the larger pipeline and vice-versa. However, replacing a value in `step` will not affect a copy. )rNz*Pipeline slicing only supports a step of 1)r!r") isinstanceslicestep ValueError __class__r r!r"r3 named_steps)rindr@estrrr __getitem__s   zPipeline.__getitem__cCs|jddjS)Nr+r)r _estimator_type)rrrrrMszPipeline._estimator_typecCstft|jS)zAccess the steps by name. Read-only attribute to access any step by given name. Keys are steps names and values are the steps objects.)r dictr )rrrrrIszPipeline.named_stepscCs|jdd}|dkrdS|S)Nr+rr,)r )rr8rrrrszPipeline._final_estimatorcCs0|js dS|j|\}}d|dt|j|fS)Nz(step %d of %d) Processing %sr)r"r r:)rstep_idxr@_rrr _log_message!szPipeline._log_messagecKs\dd|jD}xF|D]:\}}d|kr8td||dd\}}||||<qW|S)NcSsi|]\}}|dk ri|qS)Nr).0r@rFrrr )sz.Pipeline._check_fit_params..__zPipeline.fit does not accept the {} parameter. You can pass parameters to specific steps of your pipeline using the stepname__parameter format, e.g. `Pipeline.fit(X, y, logisticregression__sample_weight=sample_weight)`.r)r itemsrGformatsplit)r fit_paramsfit_params_stepsZpnameZpvalrFparamrrr_check_fit_params(szPipeline._check_fit_paramsc Kst|j|_|t|j}|t}x|jdddD]\}}}|dksR|dkrptd| |w8WdQRXt |dr|j dkr|} qt |} n,t |dr|j dkr|} qt |} nt |} || ||dfd| |d||\}} || f|j|<q8W|S)NF)r<r=r,rlocationcachedir)message_clsnamemessage)listr r#rr!cache_fit_transform_onerBr rQr2r\rr]) rXyrYr!Zfit_transform_one_cachedrOr@ transformerZcloned_transformerZfitted_transformerrrr_fit9s8           z Pipeline._fitc Kst|jf|}|j||f|}td|t|jd4|jdkrf||jdd}|jj||f|WdQRX|S)a$Fit the model. Fit all the transformers one after the other and transform the data. Finally, fit the transformed data using the final estimator. Parameters ---------- X : iterable Training data. Must fulfill input requirements of first step of the pipeline. y : iterable, default=None Training targets. Must fulfill label requirements for all steps of the pipeline. **fit_params : dict of string -> object Parameters passed to the ``fit`` method of each step, where each parameter name is prefixed such that parameter ``p`` for step ``s`` has key ``s__p``. Returns ------- self : object Pipeline with fitted steps. rrr,r+rN)r[rfr rQr:r rr-)rrcrdrXrYXtfit_params_last_steprrrr-ks  z Pipeline.fitc Ks|jf|}|j||f|}|j}td|t|jdT|dkrJ|S||jdd}t|drv|j||f|S|j ||f| |SWdQRXdS)aFit the model and transform with the final estimator. Fits all the transformers one after the other and transform the data. Then uses `fit_transform` on transformed data with the final estimator. Parameters ---------- X : iterable Training data. Must fulfill input requirements of first step of the pipeline. y : iterable, default=None Training targets. Must fulfill label requirements for all steps of the pipeline. **fit_params : dict of string -> object Parameters passed to the ``fit`` method of each step, where each parameter name is prefixed such that parameter ``p`` for step ``s`` has key ``s__p``. Returns ------- Xt : ndarray of shape (n_samples, n_transformed_features) Transformed samples. rrr,r+rr.N) r[rfrr rQr:r r2r.r-r/)rrcrdrXrYrgZ last_steprhrrrr.s  zPipeline.fit_transformpredictcKsB|}x$|jddD]\}}}||}qW|jddj|f|S)a#Transform the data, and apply `predict` with the final estimator. Call `transform` of each transformer in the pipeline. The transformed data are finally passed to the final estimator that calls `predict` method. Only valid if the final estimator implements `predict`. Parameters ---------- X : iterable Data to predict on. Must fulfill input requirements of first step of the pipeline. **predict_params : dict of string -> object Parameters to the ``predict`` called at the end of all transformations in the pipeline. Note that while this may be used to return uncertainties from some models with return_std or return_cov, uncertainties that are generated by the transformations in the pipeline are not propagated to the final estimator. .. versionadded:: 0.20 Returns ------- y_pred : ndarray Result of calling `predict` on the final estimator. F)r<r+r)rBr/r ri)rrcZpredict_paramsrgrPr@r/rrrriszPipeline.predict fit_predictc Ksr|jf|}|j||f|}||jdd}td|t|jd |jddj||f|}WdQRX|S)aTransform the data, and apply `fit_predict` with the final estimator. Call `fit_transform` of each transformer in the pipeline. The transformed data are finally passed to the final estimator that calls `fit_predict` method. Only valid if the final estimator implements `fit_predict`. Parameters ---------- X : iterable Training data. Must fulfill input requirements of first step of the pipeline. y : iterable, default=None Training targets. Must fulfill label requirements for all steps of the pipeline. **fit_params : dict of string -> object Parameters passed to the ``fit`` method of each step, where each parameter name is prefixed such that parameter ``p`` for step ``s`` has key ``s__p``. Returns ------- y_pred : ndarray Result of calling `fit_predict` on the final estimator. r+rrrN)r[rfr r rQr:rj)rrcrdrXrYrgrhZy_predrrrrjs  $zPipeline.fit_predict predict_probacKsB|}x$|jddD]\}}}||}qW|jddj|f|S)a>Transform the data, and apply `predict_proba` with the final estimator. Call `transform` of each transformer in the pipeline. The transformed data are finally passed to the final estimator that calls `predict_proba` method. Only valid if the final estimator implements `predict_proba`. Parameters ---------- X : iterable Data to predict on. Must fulfill input requirements of first step of the pipeline. **predict_proba_params : dict of string -> object Parameters to the `predict_proba` called at the end of all transformations in the pipeline. Returns ------- y_proba : ndarray of shape (n_samples, n_classes) Result of calling `predict_proba` on the final estimator. F)r<r+r)rBr/r rk)rrcZpredict_proba_paramsrgrPr@r/rrrrkszPipeline.predict_probadecision_functioncCs>|}x$|jddD]\}}}||}qW|jdd|S)aTransform the data, and apply `decision_function` with the final estimator. Call `transform` of each transformer in the pipeline. The transformed data are finally passed to the final estimator that calls `decision_function` method. Only valid if the final estimator implements `decision_function`. Parameters ---------- X : iterable Data to predict on. Must fulfill input requirements of first step of the pipeline. Returns ------- y_score : ndarray of shape (n_samples, n_classes) Result of calling `decision_function` on the final estimator. F)r<r+r)rBr/r rl)rrcrgrPr@r/rrrrlszPipeline.decision_function score_samplescCs>|}x$|jddD]\}}}||}qW|jdd|S)aTransform the data, and apply `score_samples` with the final estimator. Call `transform` of each transformer in the pipeline. The transformed data are finally passed to the final estimator that calls `score_samples` method. Only valid if the final estimator implements `score_samples`. Parameters ---------- X : iterable Data to predict on. Must fulfill input requirements of first step of the pipeline. Returns ------- y_score : ndarray of shape (n_samples,) Result of calling `score_samples` on the final estimator. F)r<r+r)rBr/r rm)rrcrgrPrerrrrm3szPipeline.score_samplespredict_log_probacKsB|}x$|jddD]\}}}||}qW|jddj|f|S)a\Transform the data, and apply `predict_log_proba` with the final estimator. Call `transform` of each transformer in the pipeline. The transformed data are finally passed to the final estimator that calls `predict_log_proba` method. Only valid if the final estimator implements `predict_log_proba`. Parameters ---------- X : iterable Data to predict on. Must fulfill input requirements of first step of the pipeline. **predict_log_proba_params : dict of string -> object Parameters to the ``predict_log_proba`` called at the end of all transformations in the pipeline. Returns ------- y_log_proba : ndarray of shape (n_samples, n_classes) Result of calling `predict_log_proba` on the final estimator. F)r<r+r)rBr/r rn)rrcZpredict_log_proba_paramsrgrPr@r/rrrrnLszPipeline.predict_log_probacCs|jdkpt|jdS)Nr,r/)rr2)rrrr_can_transformis zPipeline._can_transformcCs*|}x |D]\}}}||}qW|S)aTransform the data, and apply `transform` with the final estimator. Call `transform` of each transformer in the pipeline. The transformed data are finally passed to the final estimator that calls `transform` method. Only valid if the final estimator implements `transform`. This also works where final estimator is `None` in which case all prior transformations are applied. Parameters ---------- X : iterable Data to transform. Must fulfill input requirements of first step of the pipeline. Returns ------- Xt : ndarray of shape (n_samples, n_transformed_features) Transformed data. )rBr/)rrcrgrPr/rrrr/nszPipeline.transformcCstdd|DS)Ncss|]\}}}t|dVqdS)inverse_transformN)r2)rRrPr9rrr sz2Pipeline._can_inverse_transform..)allrB)rrrr_can_inverse_transformszPipeline._can_inverse_transformcCs2tt|}x|D]\}}}||}qW|S)aApply `inverse_transform` for each step in a reverse order. All estimators in the pipeline must support `inverse_transform`. Parameters ---------- Xt : array-like of shape (n_samples, n_transformed_features) Data samples, where ``n_samples`` is the number of samples and ``n_features`` is the number of features. Must fulfill input requirements of last step of pipeline's ``inverse_transform`` method. Returns ------- Xt : ndarray of shape (n_samples, n_features) Inverse transformed data, that is, data in the original feature space. )reversedr`rBrp)rrgZ reverse_iterrPr/rrrrpszPipeline.inverse_transformscorec CsX|}x$|jddD]\}}}||}qWi}|dk r>||d<|jddj||f|S)aTransform the data, and apply `score` with the final estimator. Call `transform` of each transformer in the pipeline. The transformed data are finally passed to the final estimator that calls `score` method. Only valid if the final estimator implements `score`. Parameters ---------- X : iterable Data to predict on. Must fulfill input requirements of first step of the pipeline. y : iterable, default=None Targets used for scoring. Must fulfill label requirements for all steps of the pipeline. sample_weight : array-like, default=None If not None, this argument is passed as ``sample_weight`` keyword argument to the ``score`` method of the final estimator. Returns ------- score : float Result of calling `score` on the final estimator. F)r<N sample_weightr+r)rBr/r ru) rrcrdrvrgrPr@r/Z score_paramsrrrruszPipeline.scorecCs|jddjS)z@The classes labels. Only exist if the last step is a classifier.r+r)r classes_)rrrrrwszPipeline.classes_cCsdt|jdddiS)Npairwiserr)rr )rrrr _more_tagsszPipeline._more_tagszcAttribute `_pairwise` was deprecated in version 0.24 and will be removed in 1.1 (renaming of 0.26).cCst|jddddS)Nrr _pairwiseF)rr )rrrrrzszPipeline._pairwisecCsB|}x8|D],\}}}t|ds0td|||}qW|S)ajGet output feature names for transformation. Transform input features using the pipeline. Parameters ---------- input_features : array-like of str or None, default=None Input features. Returns ------- feature_names_out : ndarray of str objects Transformed feature names. get_feature_names_outzpEstimator {} does not provide get_feature_names_out. Did you mean to call pipeline[:-1].get_feature_names_out()?)rBr2AttributeErrorrVr{)rinput_featuresZfeature_names_outrPr@r/rrrr{s zPipeline.get_feature_names_outcCs|jddjS)z7Number of features seen during first step `fit` method.rr)r n_features_in_)rrrrr~szPipeline.n_features_in_cCs|jddjS)z6Names of features seen during first step `fit` method.rr)r feature_names_in_)rrrrrszPipeline.feature_names_in_cCs0yt|jdddStk r*dSXdS)z'Indicate whether pipeline has been fit.r+rTFN)rr r)rrrr__sklearn_is_fitted__s zPipeline.__sklearn_is_fitted__csJt|j\}}ddfdd|jD}dd|D}td|||ddS) NcSs,|dks|dkr|dS|d|jjS)Nr,z : passthroughz: )rH__name__)r@rKrrr _get_names z-Pipeline._sk_visual_block_.._get_namecsg|]\}}||qSrr)rRr@rK)rrr sz.Pipeline._sk_visual_block_..cSsg|] }t|qSr)str)rRrKrrrrsserialF)r5 name_detailsZ dash_wrapped)r0r r )rrPr6r5rr)rr_sk_visual_block_szPipeline._sk_visual_block_)T)TT)N)N)N)N)NN)N)+r __module__ __qualname____doc___required_parametersr$r'r*r#rBrCrLpropertyrMrIrrQr[rfr-r.r rrirjrkrlrmrnror/rsrprurwryr rzr{r~rrrrrrrr3sPX #    2 # ("  $  "     cCsdd|D}tt}x&t||D]\}}||d7<q"Wx&t|D]\}}|dkrL||=qLWxPttt|D]<}||}||krx||d||7<||d8<qxWtt||S)zGenerate names for estimators.cSs(g|] }t|tr|n t|jqSr)rDrr4rlower)rRr8rrrr'sz$_name_estimators..rz-%d)rintr0r`rUrtranger:)r6r5Z namecountrKr@kvirrr_name_estimators#s rF)r!r"cGstt|||dS)aConstruct a :class:`Pipeline` from the given estimators. This is a shorthand for the :class:`Pipeline` constructor; it does not require, and does not permit, naming the estimators. Instead, their names will be set to the lowercase of their types automatically. Parameters ---------- *steps : list of Estimator objects List of the scikit-learn estimators that are chained together. memory : str or object with the joblib.Memory interface, default=None Used to cache the fitted transformers of the pipeline. By default, no caching is performed. If a string is given, it is the path to the caching directory. Enabling caching triggers a clone of the transformers before fitting. Therefore, the transformer instance given to the pipeline cannot be inspected directly. Use the attribute ``named_steps`` or ``steps`` to inspect estimators within the pipeline. Caching the transformers is advantageous when fitting is time consuming. verbose : bool, default=False If True, the time elapsed while fitting each step will be printed as it is completed. Returns ------- p : Pipeline Returns a scikit-learn :class:`Pipeline` object. See Also -------- Pipeline : Class for creating a pipeline of transforms with a final estimator. Examples -------- >>> from sklearn.naive_bayes import GaussianNB >>> from sklearn.preprocessing import StandardScaler >>> from sklearn.pipeline import make_pipeline >>> make_pipeline(StandardScaler(), GaussianNB(priors=None)) Pipeline(steps=[('standardscaler', StandardScaler()), ('gaussiannb', GaussianNB())]) )r!r")rr)r!r"r rrrr;s-cKs||}|dkr|S||S)N)r/)rercrdweightrXresrrr_transform_oneks rc Ksdt||8t|dr(|j||f|}n|j||f||}WdQRX|dkrX||fS|||fS)z Fits ``transformer`` to ``X`` and ``y``. The transformed result is returned with the fitted transformer. If ``weight`` is not ``None``, the result will be multiplied by ``weight``. r.N)r r2r.r-r/)rercrdrr^r_rXrrrrrbss   rbc Ks&t|||j||f|SQRXdS)z2 Fits ``transformer`` to ``X`` and ``y``. N)r r-)rercrdrr^r_rXrrr_fit_ones rc@seZdZdZdgZddddddZd*d d Zd d Zd dZddZ ddZ e dddZ d+ddZ d,ddZd-ddZddZddZd d!Zd"d#Zd$d%Zed&d'Zd(d)ZdS).ra Concatenates results of multiple transformer objects. This estimator applies a list of transformer objects in parallel to the input data, then concatenates the results. This is useful to combine several feature extraction mechanisms into a single transformer. Parameters of the transformers may be set using its name and the parameter name separated by a '__'. A transformer may be replaced entirely by setting the parameter with its name to another transformer, or removed by setting to 'drop'. Read more in the :ref:`User Guide `. .. versionadded:: 0.13 Parameters ---------- transformer_list : list of tuple List of tuple containing `(str, transformer)`. The first element of the tuple is name affected to the transformer while the second element is a scikit-learn transformer instance. The transformer instance can also be `"drop"` for it to be ignored. .. versionchanged:: 0.22 Deprecated `None` as a transformer in favor of 'drop'. n_jobs : int, default=None Number of jobs to run in parallel. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. .. versionchanged:: v0.20 `n_jobs` default changed from 1 to None transformer_weights : dict, default=None Multiplicative weights for features per transformer. Keys are transformer names, values the weights. Raises ValueError if key not present in ``transformer_list``. verbose : bool, default=False If True, the time elapsed while fitting each transformer will be printed as it is completed. Attributes ---------- n_features_in_ : int Number of features seen during :term:`fit`. Only defined if the underlying first transformer in `transformer_list` exposes such an attribute when fit. .. versionadded:: 0.24 See Also -------- make_union : Convenience function for simplified feature union construction. Examples -------- >>> from sklearn.pipeline import FeatureUnion >>> from sklearn.decomposition import PCA, TruncatedSVD >>> union = FeatureUnion([("pca", PCA(n_components=1)), ... ("svd", TruncatedSVD(n_components=2))]) >>> X = [[0., 1., 3], [2., 2., 5]] >>> union.fit_transform(X) array([[ 1.5 , 3.0..., 0.8...], [-1.5 , 5.7..., -0.4...]]) transformer_listNF)n_jobstransformer_weightsr"cCs$||_||_||_||_|dS)N)rrrr"_validate_transformers)rrrrr"rrrr$s zFeatureUnion.__init__TcCs|jd|dS)aGet parameters for this estimator. Returns the parameters given in the constructor as well as the estimators contained within the `transformer_list` of the `FeatureUnion`. Parameters ---------- deep : bool, default=True If True, will return the parameters for this estimator and contained subobjects that are estimators. Returns ------- params : mapping of string to any Parameter names mapped to their values. r)r%)r&)rr%rrrr'szFeatureUnion.get_paramscKs|jd||S)aaSet the parameters of this estimator. Valid parameter keys can be listed with ``get_params()``. Note that you can directly set the parameters of the estimators contained in `tranformer_list`. Parameters ---------- **kwargs : dict Parameters of this estimator or parameters of estimators contained in `transform_list`. Parameters of the transformers may be set using its name and the parameter name separated by a '__'. Returns ------- self : object FeatureUnion class instance. r)r)r()rr)rrrr*s zFeatureUnion.set_paramscCsft|j\}}||xH|D]@}|dkr,qt|ds@t|drJt|dstd|t|fqWdS)Ndropr-r.r/zIAll estimators should implement fit and transform. '%s' (type %s) doesn't)r0rr1r2r3r4)rr5r7r9rrrr s  z#FeatureUnion._validate_transformerscCsJ|js dStdd|jD}x&|jD]}||kr&td|dq&WdS)Ncss|]\}}|VqdS)Nr)rRr@rPrrrrq!sz=FeatureUnion._validate_transformer_weights..z"Attempting to weight transformer "z-", but it is not present in transformer_list.)rsetrrG)rZtransformer_namesr@rrr_validate_transformer_weightss z*FeatureUnion._validate_transformer_weightscs |jpijfdd|jDS)zg Generate (name, trans, weight) tuples excluding None and 'drop' transformers. c3s(|] \}}|dkr|||fVqdS)rNr)rRr@rA) get_weightrrrq0sz%FeatureUnion._iter..)rgetr)rr)rrrB)s  zFeatureUnion._iterzlget_feature_names is deprecated in 1.0 and will be removed in 1.2. Please use get_feature_names_out instead.cs`g}xV|D]J\}}t|ds.)rBr2r|rr4rextendr)r feature_namesrArr)r@rr5s   zFeatureUnion.get_feature_namescslg}xX|D]L\}}t|ds.)Zdtype) rBr2r|rr4rrr{npZasarrayobject)rr}rrArPr)r@rr{Ks  z"FeatureUnion.get_feature_names_outcKs&||||t}|s|S|||S)aFit all transformers using X. Parameters ---------- X : iterable or array-like, depending on transformers Input data, used to fit transformers. y : array-like of shape (n_samples, n_outputs), default=None Targets for supervised learning. **fit_params : dict, default=None Parameters to pass to the fit method of the estimator. Returns ------- self : object FeatureUnion class instance. )_parallel_funcr_update_transformer_list)rrcrdrXr7rrrr-ds  zFeatureUnion.fitcKsH||||t}|s(t|jddfSt|\}}||||S)aFit all transformers, transform the data and concatenate results. Parameters ---------- X : iterable or array-like, depending on transformers Input data to be transformed. y : array-like of shape (n_samples, n_outputs), default=None Targets for supervised learning. **fit_params : dict, default=None Parameters to pass to the fit method of the estimator. Returns ------- X_t : array-like or sparse matrix of shape (n_samples, sum_n_components) The `hstack` of results of transformers. `sum_n_components` is the sum of `n_components` (output dimension) over transformers. r)rrbrzerosshaper0r_hstack)rrcrdrXresultsXsr7rrrr.s   zFeatureUnion.fit_transformcCs|js dSd|||fS)Nz(step %d of %d) Processing %s)r")rr@r?totalrrrrQszFeatureUnion._log_messagecsVtj_ttjdfddtdDS)z Runs func in parallel on X and y)rc 3sF|]>\}\}}}t||fd||tdVqdS)r)r^r_N)rrQr:)rRr?r@rer)rcrXfuncrr7rdrrrqs z.FeatureUnion._parallel_func..r)r`rrrrBrrr;)rrcrdrXrr)rcrXrrr7rdrrs    zFeatureUnion._parallel_funccsDt|jdfdd|D}|s:tjddfS||S)aTransform X separately by each transformer, concatenate results. Parameters ---------- X : iterable or array-like, depending on transformers Input data to be transformed. Returns ------- X_t : array-like or sparse matrix of shape (n_samples, sum_n_components) The `hstack` of results of transformers. `sum_n_components` is the sum of `n_components` (output dimension) over transformers. )rc3s&|]\}}}tt|d|VqdS)N)rr)rRr@rAr)rcrrrqsz)FeatureUnion.transform..r)rrrBrrrr)rrcrr)rcrr/s   zFeatureUnion.transformcCs0tdd|Dr"t|}n t|}|S)Ncss|]}t|VqdS)N)rissparse)rRrrrrrqsz'FeatureUnion._hstack..)anyrZhstackZtocsrr)rrrrrrs zFeatureUnion._hstackcs*tfdd|jD|jdd<dS)Ncs(g|] \}}||dkr|ntfqS)r)next)rRr@old)r7rrrsz9FeatureUnion._update_transformer_list..)iterr)rr7r)r7rrs z%FeatureUnion._update_transformer_listcCs|jddjS)z+Number of features seen during :term:`fit`.rr)rr~)rrrrr~szFeatureUnion.n_features_in_cCst|j\}}td||dS)Nparallel)r5)r0rr )rr5r7rrrrszFeatureUnion._sk_visual_block_)T)N)N)N)rrrrrr$r'r*rrrBr rr{r-r.rQrr/rrrr~rrrrrrs(F       )rr"cGstt|||dS)a( Construct a FeatureUnion from the given transformers. This is a shorthand for the FeatureUnion constructor; it does not require, and does not permit, naming the transformers. Instead, they will be given names automatically based on their types. It also does not allow weighting. Parameters ---------- *transformers : list of estimators n_jobs : int, default=None Number of jobs to run in parallel. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. .. versionchanged:: v0.20 `n_jobs` default changed from 1 to None verbose : bool, default=False If True, the time elapsed while fitting each transformer will be printed as it is completed. Returns ------- f : FeatureUnion See Also -------- FeatureUnion : Class for concatenating the results of multiple transformer objects. Examples -------- >>> from sklearn.decomposition import PCA, TruncatedSVD >>> from sklearn.pipeline import make_union >>> make_union(PCA(), TruncatedSVD()) FeatureUnion(transformer_list=[('pca', PCA()), ('truncatedsvd', TruncatedSVD())]) )rr")rr)rr"r7rrrrs*)rN)rN)+r collectionsr itertoolsrnumpyrZscipyrZjoblibrbaserrZutils._estimator_html_reprr Zutils.metaestimatorsr utilsr r Zutils.deprecationr Z utils._tagsrZutils.validationrrZ utils.fixesr exceptionsrr__all__rrrrrrbrrrrrrrsB               u0  ^