U 2d@sZdZddlmZddlmZddlZddlmZddl m Z m Z ddl m Z dd lmZdd lmZdd lmZmZdd lmZdd lmZddlmZddlmZddlmZmZddlmZm Z ddl!m"Z"ddlm#Z#ddddgZ$ddZ%Gddde#Z&ddZ'dddddZ(d d!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)cloneTransformerMixin)FunctionTransformer) _VisualBlock) available_if)Bunch_print_elapsed_time) _safe_tags) check_memory)check_is_fitted)check_pandas_support)_safe_set_output_get_output_config)delayedParallel)NotFittedError)_BaseCompositionPipeline FeatureUnion make_pipeline make_unioncsfdd}|S)z\Check that final_estimator has `attr`. Used together with `avaliable_if` in `Pipeline`.cst|jdSNT)getattr_final_estimatorselfattr4/tmp/pip-unpacked-wheel-zrfo1fqw/sklearn/pipeline.pycheck,s z#_final_estimator_has..checkr")r!r$r"r r#_final_estimator_has's r%c@seZdZdZdgZdddddZddd d ZdSd d ZddZddZ dTddZ ddZ ddZ e ddZe ddZe ddZddZd d!ZdUd"d#ZdVd$d%ZdWd&d'Zeed(d)d*Zeed+dXd,d-Zeed.d/d0Zeed1d2d3Zeed4d5d6Zeed7d8d9Zd:d;Zeedd?Z ee d@dAZ!eedBdYdCdDZ"e dEdFZ#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 sequential order. The last transform must be 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 stepsNFmemoryverbosecCs||_||_||_dSN)r&r(r))rr&r(r)r"r"r#__init__szPipeline.__init__ transformcCs$|D]\}}}t||dq|S)aRSet the output container when `"transform"` and `"fit_transform"` are called. Calling `set_output` will set the output of all estimators in `steps`. Parameters ---------- transform : {"default", "pandas"}, default=None Configure output of `transform` and `fit_transform`. - `"default"`: Default output format of a transformer - `"pandas"`: DataFrame output - `None`: Transform configuration is unchanged Returns ------- self : estimator instance Estimator instance. r,)_iterrrr-_stepr"r"r# set_outputszPipeline.set_outputTcCs|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&deepZ _get_paramsrr4r"r"r# 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&Z _set_paramsrkwargsr"r"r# set_paramss zPipeline.set_paramscCst|j\}}|||dd}|d}|D]H}|dks0|dkrFq0t|dsZt|drdt|ds0td|t|fq0|dk r|dkrt|dstd|t|fdS)N passthroughfit fit_transformr-zAll 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 estimatortr"r"r#_validate_stepss6     zPipeline._validate_stepsccsht|j}|s|d8}tt|jd|D]:\}\}}|sF|||fVq(|dk r(|dkr(|||fVq(dS)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_passthroughstopidxnametransr"r"r#r.s zPipeline._itercCs t|jS)z4 Returns the length of the Pipeline )rKr&rr"r"r#__len__ szPipeline.__len__cCslt|tr6|jdkrtd|j|j||j|jdSz|j|\}}Wntk rf|j |YSX|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 1r') isinstanceslicer1 ValueError __class__r&r(r)rC named_steps)rindrQestr"r"r# __getitem__s  zPipeline.__getitem__cCs|jddjS)Nr<r)r&_estimator_typerr"r"r#r\&szPipeline._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&rr"r"r#rX*szPipeline.named_stepscCs|jdd}|dkrdS|S)Nr<rr=)r&)rrHr"r"r#r3szPipeline._final_estimatorcCs0|js dS|j|\}}d|dt|j|fS)N(step %d of %d) Processing %sr)r)r&rK)rstep_idxrQr0r"r"r# _log_message8szPipeline._log_messagecKsXdd|jD}|D]:\}}d|kr6td||dd\}}||||<q|S)NcSsi|]\}}|dk r|iqSr*r").0rQr1r"r"r# @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&itemsrVformatsplit)r fit_paramsfit_params_stepsZpnameZpvalr1paramr"r"r#_check_fit_params?szPipeline._check_fit_paramsc Kst|j|_|t|j}|t}|jdddD]\}}}|dksP|dkrxtd| |W5QRq6W5QRXt |dr|j dkr|} nt |} || ||dfd| |d||\}} || f|j|<q6|S)NF)rMrNr=rlocationmessage_clsnamemessage) listr&rJrr(cache_fit_transform_oner.r r`rBrkr) rXyrhr(Zfit_transform_one_cachedr_rQ transformerZcloned_transformerZfitted_transformerr"r"r#_fitPs6    z Pipeline._fitc Kst|jf|}|j||f|}td|t|jd4|jdkrf||jdd}|jj||f|W5QRX|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<r)rjrur r`rKr&rr>)rrrrsrgrhXtfit_params_last_stepr"r"r#r>vs  z Pipeline.fitc Ks|jf|}|j||f|}|j}td|t|jdx|dkrV|W5QRS||jdd}t|dr|j||f|W5QRS|j ||f| |W5QRSW5QRXdS)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) rjrurr r`rKr&rBr?r>r-)rrrrsrgrhrvZ last_steprwr"r"r#r?s  zPipeline.fit_transformpredictcKs>|}|jddD]\}}}||}q|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. FrMr<r)r.r-r&rx)rrrZpredict_paramsrvr0rQr-r"r"r#rxs zPipeline.predict fit_predictc Ksr|jf|}|j||f|}||jdd}td|t|jd |jddj||f|}W5QRX|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<rrr)rjrur&r r`rKrz)rrrrsrgrhrvrwZy_predr"r"r#rzs  $zPipeline.fit_predict predict_probacKs>|}|jddD]\}}}||}q|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. Fryr<r)r.r-r&r{)rrrZpredict_proba_paramsrvr0rQr-r"r"r#r{s zPipeline.predict_probadecision_functioncCs:|}|jddD]\}}}||}q|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. Fryr<r)r.r-r&r|)rrrrvr0rQr-r"r"r#r|%s zPipeline.decision_function score_samplescCs:|}|jddD]\}}}||}q|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. Fryr<r)r.r-r&r})rrrrvr0rtr"r"r#r}>s zPipeline.score_samplespredict_log_probacKs>|}|jddD]\}}}||}q|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. Fryr<r)r.r-r&r~)rrrZpredict_log_proba_paramsrvr0rQr-r"r"r#r~Ws zPipeline.predict_log_probacCs|jdkpt|jdS)Nr=r-)rrBrr"r"r#_can_transformts zPipeline._can_transformcCs&|}|D]\}}}||}q |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. )r.r-)rrrrvr0r-r"r"r#r-ys zPipeline.transformcCstdd|DS)Ncss|]\}}}t|dVqdS)inverse_transformNrB)rar0rIr"r"r# sz2Pipeline._can_inverse_transform..)allr.rr"r"r#_can_inverse_transformszPipeline._can_inverse_transformcCs.tt|}|D]\}}}||}q|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. )reversedror.r)rrvZ reverse_iterr0r-r"r"r#rs zPipeline.inverse_transformscorec CsT|}|jddD]\}}}||}qi}|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. FryN sample_weightr<r)r.r-r&r) rrrrsrrvr0rQr-Z score_paramsr"r"r#rs zPipeline.scorecCs|jddjS)z@The classes labels. Only exist if the last step is a classifier.r<r)r&classes_rr"r"r#rszPipeline.classes_cCsdt|jdddiS)NZpairwiserr)r r&rr"r"r# _more_tagsszPipeline._more_tagscCs>|}|D],\}}}t|ds.td|||}q |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()?)r.rBAttributeErrorrer)rinput_featuresfeature_names_outr0rQr-r"r"r#rs  zPipeline.get_feature_names_outcCs|jddjS)z7Number of features seen during first step `fit` method.rr)r&n_features_in_rr"r"r#rszPipeline.n_features_in_cCs|jddjS)z6Names of features seen during first step `fit` method.rr)r&feature_names_in_rr"r"r#rszPipeline.feature_names_in_cCs4zt|jddWdStk r.YdSXdS)z'Indicate whether pipeline has been fit.r<rTFN)rr&rrr"r"r#__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: )rW__name__)rQrZr"r"r# _get_names z-Pipeline._sk_visual_block_.._get_namecsg|]\}}||qSr"r")rarQrZrr"r# sz.Pipeline._sk_visual_block_..cSsg|] }t|qSr")str)rarZr"r"r#rsserialF)rE name_detailsZ dash_wrapped)r@r&r )rr0rFrErr"rr#_sk_visual_block_szPipeline._sk_visual_block_)T)TT)N)N)N)N)NN)N)*r __module__ __qualname____doc___required_parametersr+r2r7r;rJr.rSr[propertyr\rXrr`rjrur>r?r r%rxrzr{r|r}r~rr-rrrrrrrrrrr"r"r"r#r4sfZ #     & # (  !  $            "     cCsdd|D}tt}t||D]\}}||d7<q t|D]\}}|dkrF||=qFttt|D]<}||}||krn||d||7<||d8<qntt||S)zGenerate names for estimators.cSs(g|] }t|tr|n t|jqSr")rTrrDrlower)rarHr"r"r#r&sz$_name_estimators..rz-%d)rintr@rordrrangerK)rFrEZ namecountrZrQkvir"r"r#_name_estimators#srFr'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')rr)r(r)r&r"r"r#r;s-cKs||}|dkr|S||Sr*r,)rtrrrsweightrgresr"r"r#_transform_oneks rc Ksdt||8t|dr(|j||f|}n|j||f||}W5QRX|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 rBr?r>r-)rtrrrsrrmrnrgrr"r"r#rqss   rqc Ks2t|||j||f|W5QRSQRXdS)z2 Fits ``transformer`` to ``X`` and ``y``. N)r r>)rtrrrsrrmrnrgr"r"r#_fit_ones rcseZdZdZdgZddddddZddfd d Zed d Zd.ddZ ddZ ddZ ddZ ddZ d/ddZd0ddZd1ddZddZd d!Zd"d#Zd$d%Zd&d'Zed(d)Zd*d+Zd,d-ZZS)2ra 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, removed by setting to 'drop' or disabled by setting to 'passthrough' (features are passed without transformation). Read more in the :ref:`User Guide `. .. versionadded:: 0.13 Parameters ---------- transformer_list : list of (str, transformer) tuples List of transformer objects to be applied to the data. The first half of each tuple is the name of the transformer. The transformer can be 'drop' for it to be ignored or can be 'passthrough' for features to be passed unchanged. .. versionadded:: 1.1 Added the option `"passthrough"`. .. 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 ---------- named_transformers : :class:`~sklearn.utils.Bunch` Dictionary-like object, with the following attributes. Read-only attribute to access any transformer parameter by user given name. Keys are transformer names and values are transformer parameters. .. versionadded:: 1.2 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||_||_||_||_dSr*)rrrr))rrrrr)r"r"r#r+szFeatureUnion.__init__r,cs2tj|d|D]\}}}t||dq|S)aUSet the output container when `"transform"` and `"fit_transform"` are called. `set_output` will set the output of all estimators in `transformer_list`. Parameters ---------- transform : {"default", "pandas"}, default=None Configure output of `transform` and `fit_transform`. - `"default"`: Default output format of a transformer - `"pandas"`: DataFrame output - `None`: Transform configuration is unchanged Returns ------- self : estimator instance Estimator instance. r,)superr2r.rr/rWr"r#r2szFeatureUnion.set_outputcCstft|jSr*)r r]rrr"r"r#named_transformersszFeatureUnion.named_transformersTcCs|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. rr3r5r6r"r"r#r7szFeatureUnion.get_paramscKs|jd||S)abSet 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 `transformer_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)rr8r9r"r"r#r;s zFeatureUnion.set_paramscCsbt|j\}}|||D]@}|dkr*qt|ds>t|drHt|dstd|t|fqdS)N)dropr=r>r?r-zIAll estimators should implement fit and transform. '%s' (type %s) doesn't)r@rrArBrCrD)rrErGrIr"r"r#_validate_transformers2s  z#FeatureUnion._validate_transformerscCsF|js dStdd|jD}|jD]}||kr$td|dq$dS)Ncss|]\}}|VqdSr*r")rarQr0r"r"r#rHsz=FeatureUnion._validate_transformer_weights..z"Attempting to weight transformer "z-", but it is not present in transformer_list.)rsetrrV)rZtransformer_namesrQr"r"r#_validate_transformer_weightsDs  z*FeatureUnion._validate_transformer_weightsccsL|jpij}|jD]4\}}|dkr$q|dkr6tdd}||||fVqdS)zg Generate (name, trans, weight) tuples excluding None and 'drop' transformers. rr=z one-to-one)rN)rgetrr)rZ get_weightrQrRr"r"r#r.Ps  zFeatureUnion._itercshg}|D]L\}}t|ds:tdtt|jf|fdd||Dq tj |t dS)a4Get output feature names for transformation. Parameters ---------- input_features : array-like of str or None, default=None Input features. Returns ------- feature_names_out : ndarray of str objects Transformed feature names. rz@Transformer %s (type %s) does not provide get_feature_names_out.csg|]}d|qS)rcr"rafrQr"r#rtsz6FeatureUnion.get_feature_names_out..)Zdtype) r.rBrrrDrextendrnpZasarrayobject)rrZ feature_namesrRr0r"rr#r_s  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)rrrrsrgrGr"r"r#r>xs  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)rrqrzerosshaper@r_hstack)rrrrsrgresultsXsrGr"r"r#r?s   zFeatureUnion.fit_transformcCs|js dSd|||fS)Nr^)r))rrQrPtotalr"r"r#r`szFeatureUnion._log_messagecsVtj_ttjdfddtdDS)z Runs func in parallel on X and yrc 3sF|]>\}\}}}t||fd||tdVqdS)rrlN)rr`rK)rarPrQrtrrrrgfuncrrGrsr"r#rs z.FeatureUnion._parallel_func..r)rorrrr.rrrL)rrrrsrgrr"rr#rs   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|VqdSr*)rr)rarQrRrrrr"r#rsz)FeatureUnion.transform..r)rrr.rrrr)rrrrr"rr#r-s zFeatureUnion.transformcCsntd|}|ddkr>tdd|Dr>td}|j|ddStdd|Dr`t|}n t|}|S) Nr-ZdenseZpandascss|]}t|dVqdS)ZilocNr)rarrr"r"r#rsz'FeatureUnion._hstack..r)Zaxiscss|]}t|VqdSr*)rissparserr"r"r#rs) rrrconcatanyrZhstackZtocsrr)rrconfigpdr"r"r#rs  zFeatureUnion._hstackcs*tfdd|jD|jdd<dS)Ncs(g|] \}}||dkr|ntfqS)r)next)rarQoldrGr"r#rsz9FeatureUnion._update_transformer_list..)iterr)rrGr"rr#rs z%FeatureUnion._update_transformer_listcCs|jddjS)z+Number of features seen during :term:`fit`.rr)rrrr"r"r#rszFeatureUnion.n_features_in_cCs |D]\}}}t|qdSr)r.r)rr0rtr"r"r#rs z"FeatureUnion.__sklearn_is_fitted__cCst|j\}}td||dS)Nparallel)rE)r@rr )rrErGr"r"r#rszFeatureUnion._sk_visual_block_)T)N)N)N)rrrrrr+r2rrr7r;rrr.rr>r?r`rr-rrrrr __classcell__r"r"rr#rs4R         rr)cGstt|||dS)aConstruct 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 One or more 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 A :class:`FeatureUnion` object for concatenating the results of multiple transformer objects. 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())]) r)rr)rr)rGr"r"r#r s,)rN)rN).r collectionsr itertoolsrZnumpyrZscipyrbaserrZ preprocessingrZutils._estimator_html_reprr Zutils.metaestimatorsr utilsr r Z utils._tagsr Zutils.validationrrrZutils._set_outputrrZutils.parallelrr exceptionsrr__all__r%rrrrrqrrrr"r"r"r#sH              t0  }