0PhJdZddlZddlmZmZddlmZddlmZddl m Z m Z ddl Z ddlmZdd lmZmZmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZm Z ddl!m"Z"m#Z#ddl$m%Z%ddl&m'Z'ddl(m)Z)ddl*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2m3Z3ddl4m5Z5m6Z6ddl7m8Z8m9Z9gdZ:edZ;dZdZ?dddd d!Z@d*d"ZA d+d$ZBd+d%ZCGd&d'ee2ZDddd(d)ZEdS),zQUtilities to build a composite estimator as a chain of transforms and estimators.N)Counter defaultdict)contextmanager)deepcopy)chainislice)sparse)TransformerMixin _fit_contextclone)NotFittedError)FunctionTransformer)Bunch) _VisualBlock)METHODS) HasMethodsHidden)_get_container_adapter_safe_set_output)get_tags)_print_elapsed_time)"_deprecate_Xt_in_inverse_transform)MetadataRouter MethodMapping_raise_for_params_routing_enabledget_routing_for_objectprocess_routing)_BaseComposition available_if)Paralleldelayed)check_is_fitted check_memory)Pipeline FeatureUnion make_pipeline make_unionc#K dVn"#t$r}td|d}~wwxYw t|dS#t$rtjdtYdSwxYw)aA context manager to make sure a NotFittedError is raised, if a sub-estimator raises the error. Otherwise, we raise a warning if the pipeline is not fitted, with the deprecation. TODO(1.8): remove this context manager and replace with check_is_fitted. NzPipeline is not fitted yet.zThis Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.)rr$warningswarn FutureWarning) estimatorexcs P/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/pipeline.py_raise_or_warn_if_not_fittedr1,sE  EEE:;;DE   """""               s (#(=$A%$A%cfd}|S)z\Check that final_estimator has `attr`. Used together with `available_if` in `Pipeline`.c2t|jdSNT)getattr_final_estimator)selfattrs r0checkz#_final_estimator_has..checkLs%t,,,t)r8r9s` r0_final_estimator_hasr<Gs#  Lr:c||vrFt|tr tfd|D||<nj|fi||<||S)aTransform a parameter value using a sub-pipeline and cache the result. Parameters ---------- sub_pipeline : Pipeline The sub-pipeline to be used for transformation. cache : dict The cache dictionary to store the transformed values. param_name : str The name of the parameter to be transformed. param_value : object The value of the parameter to be transformed. transform_params : dict The metadata to be used for transformation. This passed to the `transform` method of the sub-pipeline. Returns ------- transformed_value : object The transformed value of the parameter. c34K|]}j|fiVdSN transform).0element sub_pipelinetransform_paramss r0 z$_cached_transform..rsM&&' &wCC2BCC&&&&&&r:) isinstancetuplerA)rDcache param_name param_valuerEs` `r0_cached_transformrLTs0 k5 ) ) X %&&&&&*&&&!!E*   !7 6{ W WFV W WE*   r:ceZdZUdZeeegedgdeedggdgdZ e e d<ddddd Z dd d Z d9d ZdZdZd:dZdZdZedZedZedZdZdZdZd;dZeddr&a A sequence of data transformers with an optional final predictor. `Pipeline` allows you to sequentially apply a list of transformers to preprocess the data and, if desired, conclude the sequence with a final :term:`predictor` for predictive modeling. Intermediate steps of the pipeline must be transformers, that is, they must implement `fit` and `transform` methods. The final :term:`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`. For an example use case of `Pipeline` combined with :class:`~sklearn.model_selection.GridSearchCV`, refer to :ref:`sphx_glr_auto_examples_compose_plot_compare_reduction.py`. The example :ref:`sphx_glr_auto_examples_compose_plot_digits_pipe.py` shows how to grid search on a pipeline using `'__'` as a separator in the parameter names. Read more in the :ref:`User Guide `. .. versionadded:: 0.5 Parameters ---------- steps : list of tuples List of (name of step, estimator) tuples that are to be chained in sequential order. To be compatible with the scikit-learn API, all steps must define `fit`. All non-last steps must also define `transform`. See :ref:`Combining Estimators ` for more details. transform_input : list of str, default=None The names of the :term:`metadata` parameters that should be transformed by the pipeline before passing it to the step consuming it. This enables transforming some input arguments to ``fit`` (other than ``X``) to be transformed by the steps of the pipeline up to the step which requires them. Requirement is defined via :ref:`metadata routing `. For instance, this can be used to pass a validation set through the pipeline. You can only set this if metadata routing is enabled, which you can enable using ``sklearn.set_config(enable_metadata_routing=True)``. .. versionadded:: 1.6 memory : str or object with the joblib.Memory interface, default=None Used to cache the fitted transformers of the pipeline. The last step will never be cached, even if it is a transformer. 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. See :ref:`sphx_glr_auto_examples_neighbors_plot_caching_nearest_neighbors.py` for an example on how to enable caching. 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).score(X_test, y_test) 0.88 >>> # An estimator's parameter can be set using '__' syntax >>> pipe.set_params(svc__C=10).fit(X_train, y_train).score(X_test, y_test) 0.76 NrIbooleanstepstransform_inputmemoryverbose_parameter_constraintsFrQrRrSc>||_||_||_||_dSr?rO)r7rPrQrRrSs r0__init__zPipeline.__init__s# .  r:r@c^|D]\}}}t|||S)aSet 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", "polars"}, default=None Configure output of `transform` and `fit_transform`. - `"default"`: Default output format of a transformer - `"pandas"`: DataFrame output - `"polars"`: Polars output - `None`: Transform configuration is unchanged .. versionadded:: 1.4 `"polars"` option was added. Returns ------- self : estimator instance Estimator instance. r@)_iterr)r7rA_steps r0 set_outputzPipeline.set_outputs<.**,, 8 8JAq$ TY 7 7 7 7 7 r:Tc0|d|S)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. rPdeep _get_paramsr7r_s r0 get_paramszPipeline.get_paramss"d333r:c |jdi||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. rP)rP _set_paramsr7kwargss r0 set_paramszPipeline.set_params-s"& ++F+++ r:c t|j\}}|||dd}|d}|D]^}||dkr t|dst|drt|ds#t d|dt |d_|9|dkr5t|ds't d |dt |ddSdSdS) N passthroughfit fit_transformrAznAll intermediate steps should be transformers and implement fit and transform or be the string 'passthrough' '' (type ) doesn'tzLLast step of Pipeline should implement fit or be the string 'passthrough'. ')ziprP_validate_nameshasattr TypeErrortype)r7names estimators transformersr.ts r0_validate_stepszPipeline._validate_stepsCs<,z U###"#2# rN   AyA..Au%% O)D)D W;NN  i1247777<   !]**Iu--+)-6IItIH  " !****r:c#Kt|j}|s|dz}tt|jd|D]!\}\}}|s|||fV| |dkr|||fV"dS)z Generate (idx, (name, trans)) tuples from self.steps When filter_passthrough is True, 'passthrough' and None transformers are filtered out. r rNrl)lenrP enumerater)r7 with_finalfilter_passthroughstopidxnametranss r0rYzPipeline._iterfs4:  AID"+F4:q$,G,G"H"H ' ' C$% '4&&&&&"u '='=4&&&&  ' 'r:c*t|jS)z4 Returns the length of the Pipeline )r|rPr7s r0__len__zPipeline.__len__ws4:r:ct|trE|jdvrtd||j||j|jS |j|\}}n#t$r|j |cYSwxYw|S)aeReturns 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. See :ref:`sphx_glr_auto_examples_feature_selection_plot_feature_selection_pipeline.py` for an example of how to use slicing to inspect part of a pipeline. )r Nz*Pipeline slicing only supports a step of 1)rRrS) rGslicer[ ValueError __class__rPrRrSrt named_steps)r7indrests r0 __getitem__zPipeline.__getitem__}s c5 ! ! xy(( !MNNN>> 3 T\"  ) 3ID## ) ) )#C( ( ( ( ) sA--BBcD|jsdS|jddjS)z;Return the estimator type of the last step in the pipeline.Nrkr )rP_estimator_typers r0rzPipeline._estimator_types'z 4z"~a 00r:c>tdit|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;)rdictrPrs r0rzPipeline.named_stepss"((tDJ''(((r:cr |jdd}|dn|S#tttf$rYdSwxYw)Nrkr rl)rPrAttributeErrorrt)r7r.s r0r6zPipeline._final_estimatorsQ  2q)I$-$5==9 DNI6    44  s 66cn|jsdS|j|\}}d|dzt|j|fzS)N(step %d of %d) Processing %sr )rSrPr|)r7step_idxrrZs r0 _log_messagezPipeline._log_messages@| 4*X&a.(Q,DJQU1VVVr:c trt||fi||}|Stdid|jD}|D]w\}}d|vr"t d||dd\}} |||d| <|||d| <|||d| <x|S) Nc Pi|]#\}}||tdidtD$S)Nci|]}|iSr;r;)rBmethods r0 z..s"D"D"D&62"D"D"Dr:r;)rrrBrr[s r0rz1Pipeline._check_method_params..sK"d'%EE"D"DG"D"D"DEE'''r:__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 rmrn fit_predictr;)rrrrPitemsrformatsplit) r7rpropsrh routed_paramsfit_params_stepspnamepvalr[params r0_check_method_paramszPipeline._check_method_paramss    $+D&LLELVLLM $  &*j    %{{}} D D tu$$$,-3F5MM $kk$22 e7; &u-e4BF &7>?C &}5e<<# #r:c  |j r|r|dkr|S|d|}t|  fdD}t}t}|D]b\}} t ||<| D]7\} } | |jvrt ||| | |||| <,| ||| <8c|S)a<Get params (metadata) for step `name`. This transforms the metadata up to this step if required, which is indicated by the `transform_input` parameter. If a param in `step_params` is included in the `transform_input` list, it will be transformed. Parameters ---------- step_idx : int Index of the step in the pipeline. step_params : dict Parameters specific to the step. These are routed parameters, e.g. `routed_params[name]`. If a parameter name here is included in the `pipeline.transform_input`, then it will be transformed. Note that these parameters are *after* routing, so the aliases are already resolved. all_params : dict All parameters passed by the user. Here this is used to call `transform` on the slice of the pipeline itself. Returns ------- dict Parameters to be passed to the step. The ones which should be transformed are transformed. Nrcri|]3\}}|dv0||4S)rA)rparams)consumeskeys)rBkeyvalue all_paramssub_metadata_routings r0rz3Pipeline._get_metadata_for_step..sc   U#,,":??+<+<- r:)rIrJrKrE)rQrrrrrL) r7r step_paramsrrDrEtransformed_paramstransformed_cacher method_paramsrJrKrs ` @r0_get_metadata_for_stepzPipeline._get_metadata_for_steps[@  ( ) )1}} IXI 5lCC     (..00   "VV FF &1%6%6%8%8 I I !FM). v &+8+>+>+@+@ I I' K!555>O$/#-$/)9 >>>&v.z::>I&v.z:: I"!r:c vt|j|_|t|j}|t }|ddD]\}}} | | dkr > 'HdK"k]&B&B(T5F5Fx5P5PQQvz** 8v/F&1""%*;%7%7"55!)$/%6K %=$<" *))(33"%%% !A!%)*<#=DJx s$B22B6 9B6 )prefer_skip_nested_validationc ts|jtd|d|}|||||}t d|t|jdz 5|j dkrY| t|dz ||jd d | }|j j ||fi|ddddn #1swxYwY|S) aFit the model. Fit all the transformers one after the other and sequentially 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. **params : dict of str -> object - If `enable_metadata_routing=False` (default): 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``. - If `enable_metadata_routing=True`: Parameters requested and accepted by steps. Each step must have requested certain metadata for these parameters to be forwarded to them. .. versionchanged:: 1.4 Parameters are now passed to the ``transform`` method of the intermediate steps as well, if requested, and if `enable_metadata_routing=True` is set via :func:`~sklearn.set_config`. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- self : object Pipeline with fitted steps. NzThe `transform_input` parameter can only be set if metadata routing is enabled. You can enable metadata routing using `sklearn.set_config(enable_metadata_routing=True)`.rmrr)rr&r rlrkrr) rrQrrrrrr|rPr6rrm)r7rrrrXtlast_step_paramss r0rmz Pipeline.fit[ssV !! d&:&FF  11f1MM YYq!]vY > > T->->s4:QR?R-S-S T T L L$ 55#'#>#> YY] -djnQ.? @%$?$$ *%)"aKK3CE3JKKK L L L L L L L L L L L L L L L s A%C>>DDcl|jdkp)t|jdpt|jdS)NrlrArnr6rsrs r0_can_fit_transformzPipeline._can_fit_transforms<  !] 2 ?t,k:: ?t,o>> r:c f|d|}||||}|j}td|t |jdz 5|dkr|cdddS|t |dz ||jdd| }t|dr!|j ||fi|dcdddS|j ||fi|d j |fi|d cdddS#1swxYwYdS) aFit the model and transform with the final estimator. Fit all the transformers one after the other and sequentially transform the data. Only valid if the final estimator either implements `fit_transform` or `fit` and `transform`. 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. **params : dict of str -> object - If `enable_metadata_routing=False` (default): 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``. - If `enable_metadata_routing=True`: Parameters requested and accepted by steps. Each step must have requested certain metadata for these parameters to be forwarded to them. .. versionchanged:: 1.4 Parameters are now passed to the ``transform`` method of the intermediate steps as well, if requested, and if `enable_metadata_routing=True`. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- Xt : ndarray of shape (n_samples, n_transformed_features) Transformed samples. rnrr&r rlNrkrrrmrA) rrr6rrr|rPrrsrnrmrA)r7rrrrr last_steprs r0rnzPipeline.fit_transformsX11PV1WW YYq!] + +) T->->s4:QR?R-S-S T T  M))         $::TQ)$*R.*;<! ;    y/22 .y.-o>        Q}y}RFF.>u.EFFP*;7                  s.D&A#D&3&D&&D*-D*predictc ,t|5|}ts]|dD]\}}}||}|jddj|fi|cdddSt |dfi|}|dD]\}}}|j|fi||j} |jddj|fi||jddjcdddS#1swxYwYdS)aTransform 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. **params : dict of str -> object - If `enable_metadata_routing=False` (default): Parameters to the ``predict`` called at the end of all transformations in the pipeline. - If `enable_metadata_routing=True`: Parameters requested and accepted by steps. Each step must have requested certain metadata for these parameters to be forwarded to them. .. versionadded:: 0.20 .. versionchanged:: 1.4 Parameters are now passed to the ``transform`` method of the intermediate steps as well, if requested, and if `enable_metadata_routing=True` is set via :func:`~sklearn.set_config`. See :ref:`Metadata Routing User Guide ` for more details. 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. Returns ------- y_pred : ndarray Result of calling `predict` on the final estimator. Fr~rkr Nrr)r1rrYrArPrrr7rrrrZrrArs r0rzPipeline.predictsX*$ / /  B#%% ?*.****F*F11&AtY",,R00BB0tz"~a(0>>v>>         ,D)FFvFFM&*jjEj&B&B N N"4(Y(MM}T/B/LMM,4:b>!$,#DJrN1$56>                  A!D >A>D  D D rc |d|}||||}||jdd}td|t |jdz 5|jddj||fi|di}dddn #1swxYwY|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. **params : dict of str -> object - If `enable_metadata_routing=False` (default): Parameters to the ``predict`` called at the end of all transformations in the pipeline. - If `enable_metadata_routing=True`: Parameters requested and accepted by steps. Each step must have requested certain metadata for these parameters to be forwarded to them. .. versionadded:: 0.20 .. versionchanged:: 1.4 Parameters are now passed to the ``transform`` method of the intermediate steps as well, if requested, and if `enable_metadata_routing=True`. See :ref:`Metadata Routing User Guide ` for more details. 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. Returns ------- y_pred : ndarray Result of calling `fit_predict` on the final estimator. rrrkrr&r N)rrrPrrr|rget)r7rrrrrparams_last_stepy_preds r0rzPipeline.fit_predictsf11f1UU YYq!] + +(B):; T->->s4:QR?R-S-S T T  2TZ^A&2A)--mR@@F                s5CCC predict_probac ,t|5|}ts]|dD]\}}}||}|jddj|fi|cdddSt |dfi|}|dD]\}}}|j|fi||j} |jddj|fi||jddjcdddS#1swxYwYdS)aTransform 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. **params : dict of str -> object - If `enable_metadata_routing=False` (default): Parameters to the `predict_proba` called at the end of all transformations in the pipeline. - If `enable_metadata_routing=True`: Parameters requested and accepted by steps. Each step must have requested certain metadata for these parameters to be forwarded to them. .. versionadded:: 0.20 .. versionchanged:: 1.4 Parameters are now passed to the ``transform`` method of the intermediate steps as well, if requested, and if `enable_metadata_routing=True`. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- y_proba : ndarray of shape (n_samples, n_classes) Result of calling `predict_proba` on the final estimator. Frrkr Nrr)r1rrYrArPrrrs r0rzPipeline.predict_proba[sN*$ / /  B#%% E*.****F*F11&AtY",,R00BB6tz"~a(6rDDVDD         ,D/LLVLLM&*jjEj&B&B N N"4(Y(MM}T/B/LMM24:b>!$2#DJrN1$56D                  rdecision_functionc t|5t||dt|dfi|}|}|dD]<\}}}|j|fi||idi}=|jddj|fi||jddidicdddS#1swxYwYdS) aJTransform 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. **params : dict of string -> object Parameters requested and accepted by steps. Each step must have requested certain metadata for these parameters to be forwarded to them. .. versionadded:: 1.4 Only available if `enable_metadata_routing=True`. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- y_score : ndarray of shape (n_samples, n_classes) Result of calling `decision_function` on the final estimator. rFrrArkr rN)r1rrrYrArrPrr7rrrrrZrrAs r0rzPipeline.decision_functionsn>*$ / /   fd,? @ @ @,D2EPPPPMB&*jjEj&B&B  "4(Y('++D"5599+rJJ74:b>!$6##DJrN1$5r::>>?RTVWW                  sC C))C-0C- score_samplesct|5|}|dD]\}}}||}|jdd|cdddS#1swxYwYdS)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. Frrkr N)r1rYrArPr)r7rrrZrs r0rzPipeline.score_sampless**$ / / 7 7B%)ZZ5Z%A%A / /!1k **2..:b>!$22266  7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7sAA77A;>A;predict_log_probac ,t|5|}ts]|dD]\}}}||}|jddj|fi|cdddSt |dfi|}|dD]\}}}|j|fi||j} |jddj|fi||jddjcdddS#1swxYwYdS)aTransform 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. **params : dict of str -> object - If `enable_metadata_routing=False` (default): Parameters to the `predict_log_proba` called at the end of all transformations in the pipeline. - If `enable_metadata_routing=True`: Parameters requested and accepted by steps. Each step must have requested certain metadata for these parameters to be forwarded to them. .. versionadded:: 0.20 .. versionchanged:: 1.4 Parameters are now passed to the ``transform`` method of the intermediate steps as well, if requested, and if `enable_metadata_routing=True`. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- y_log_proba : ndarray of shape (n_samples, n_classes) Result of calling `predict_log_proba` on the final estimator. Frrkr Nrr)r1rrYrArPrrrs r0rzPipeline.predict_log_probasP*$ / /  B#%% I*.****F*F11&AtY",,R00BB:tz"~a(:2HHHH         ,D2EPPPPM&*jjEj&B&B N N"4(Y(MM}T/B/LMM64:b>!$6#DJrN1$56H                  rcB|jdkpt|jdS)NrlrArrs r0_can_transformzPipeline._can_transforms+$ 5   !;: :  r:c t|5t||dt|dfi|}|}|D]\}}}|j|fi||j} |cdddS#1swxYwYdS)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. **params : dict of str -> object Parameters requested and accepted by steps. Each step must have requested certain metadata for these parameters to be forwarded to them. .. versionadded:: 1.4 Only available if `enable_metadata_routing=True`. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- Xt : ndarray of shape (n_samples, n_transformed_features) Transformed data. rAN)r1rrrYrArs r0rAzPipeline.transformsD*$ / /   fdK 8 8 8,D+HHHHMB&*jjll N N"4(Y(MM}T/B/LMM                  sAA44A8;A8cXtd|DS)Nc3>K|]\}}}t|dVdS)inverse_transformN)rs)rBrZrys r0rFz2Pipeline._can_inverse_transform..Hs3OOwq!Q71122OOOOOOr:)allrYrs r0_can_inverse_transformzPipeline._can_inverse_transformGs'OO$**,,OOOOOOr:)rc Vt|5t||dt||}t|dfi|}t t |}|D]\}}}|j|fi||j} |cdddS#1swxYwYdS)aApply `inverse_transform` for each step in a reverse order. All estimators in the pipeline must support `inverse_transform`. Parameters ---------- X : 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. 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. .. deprecated:: 1.5 `Xt` was deprecated in 1.5 and will be removed in 1.7. Use `X` instead. **params : dict of str -> object Parameters requested and accepted by steps. Each step must have requested certain metadata for these parameters to be forwarded to them. .. versionadded:: 1.4 Only available if `enable_metadata_routing=True`. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- Xt : ndarray of shape (n_samples, n_features) Inverse transformed data, that is, data in the original feature space. rN)r1rrrreversedrrYr) r7rrrr reverse_iterrZrrAs r0rzPipeline.inverse_transformJsP*$ / /   fd,? @ @ @21b99A,D2EPPPPM#D$6$677L&2  "4/I/&t,>                  sBBB"%B"scorec Jt|5|}tsg|dD]\}}}||}i} ||| d<|jddj||fi| cdddSt |dfd|i|} |}|dD]\}}}|j|fi| |j} |jddj||fi| |jddjcdddS#1swxYwYdS) aETransform 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. **params : dict of str -> object Parameters requested and accepted by steps. Each step must have requested certain metadata for these parameters to be forwarded to them. .. versionadded:: 1.4 Only available if `enable_metadata_routing=True`. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- score : float Result of calling `score` on the final estimator. FrN sample_weightrkr rr)r1rrYrArPrr) r7rrrrrrZrrA score_paramsrs r0rzPipeline.scoresL*$ / /  B#%% F*.****F*F11&AtY",,R00BB!  ,4AL1.tz"~a(.r1EE EE        ,g-:>DMB&*jjEj&B&B N N"4(Y(MM}T/B/LMM*4:b>!$*A&tz"~a'89?%                  sA+DBDDDc2|jddjS)z@The classes labels. Only exist if the last step is a classifier.rkr )rPclasses_rs r0rzPipeline.classes_sz"~a ))r:cPt}|js|S |jddK|jdddkr4t|jddjj|j_t d|jD|j_n#tttf$rYnwxYw |jdd|jdddkrt|jdd}|j |_ |j j |j _ t|j|_t|j|_t|j|_n#tttf$rYnwxYw|S)Nrr rlc3ZK|]&\}}|dk t|jjV'dS)rlNr input_tagsr rs r0rFz,Pipeline.__sklearn_tags__..sI))D$=(()0(((())r:rk)super__sklearn_tags__rPrrpairwiserr rrrtestimator_type target_tags multi_outputrclassifier_tagsregressor_tagstransformer_tags)r7tagslast_step_tagsrs r0rzPipeline.__sklearn_tags__sww''))z K z!}Q+ 1 a0@M0Q0Q+3JqM!$,,X(&)))"&*)))&&DO " " NI6    D  z"~a ,B1Bm1S1S!)$*R.*;!0J0W -'/0N'O'O$&.~/L&M&M#(01P(Q(Q%NI6    D   s%BB33C  C B7F F#"F#c|}|D]M\}}}t|ds"td|||}N|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()?)rYrsrrr)r7input_featuresfeature_names_outrZrrAs r0rzPipeline.get_feature_names_outs+"&**,, S S AtY9&=>> $ &,, !* ? ?@Q R R    r:c2|jddjS)z7Number of features seen during first step `fit` method.rr )rPn_features_in_rs r0r zPipeline.n_features_in_sz!}Q..r:c2|jddjS)z6Names of features seen during first step `fit` method.rr )rPfeature_names_in_rs r0r zPipeline.feature_names_in_ sz!}Q11r:cd}t|jD]\}}|dkr|}n|dS t|dS#t$rYdSwxYw)zIndicate whether pipeline has been fit. This is done by checking whether the last non-`passthrough` step of the pipeline is fitted. An empty pipeline is considered fitted. NrlTF)rrPr$r)r7rrZr.s r0__sklearn_is_fitted__zPipeline.__sklearn_is_fitted__s $TZ00  LAyM))% *  4  I & & &4   55 s= A  A ct|j\}}dfd|jD}d|D}td|||dS)Nc>||dkr|dS|d|jjS)Nrlz : passthroughz: )r__name__)rrs r0 _get_namez-Pipeline._sk_visual_block_.._get_name1s9{c]22----66cm466 6r:c.g|]\}}||Sr;r;)rBrrrs r0 z.Pipeline._sk_visual_block_..7s)BBB)$4%%BBBr:c,g|]}t|Sr;)str)rBrs r0rz.Pipeline._sk_visual_block_..8s777SC777r:serialF)rv name_details dash_wrapped)rqrPr)r7rZrwrvrrs @r0_sk_visual_block_zPipeline._sk_visual_block_.syTZ( : 7 7 7 CBBBtzBBB77J777   %     r:cHt|jj}|ddD]\}}}t }t |drB|ddddddn|dddd dddd dddd |d d d d d d d d d d d d dddd |jdd|i||i|jd\}}||dkr|St }t |dr|ddn,|dddd |ddd d ddd d d d d d d d dddd|jdd|i||i|S)aKGet metadata routing of this object. Please check :ref:`User Guide ` on how the routing mechanism works. Returns ------- routing : MetadataRouter A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating routing information. ownerFTrrnrmcallercalleerrArrrrrrmethod_mappingrkNrlr;)rrrrYrrsaddrP)r7routerrZrrr" final_name final_ests r0get_metadata_routingzPipeline.get_metadata_routingAs. dn&=>>>#jjEdjSS G GNAtU*__Nuo.. "&&eO&LLSSHHS oSFFFF#&&eE&BBSkS::SS>>S SDDS eS<<S kSBBB"")K"HHIk::OK@@/ DD/ DDK <</8KLLGK888 FJ F Fn Fu F F F F $ 2 I   ] : :M' 9o . .    oo  N N N N   eE  : : > >[ ?      eE  : : S )S 4 4 S mS < < SS @ @ S+4GS H H S+4GS H H S KS 8 8 S+4GS H H SS 0 0 0  LL.LZ4KLLL r:T)TT)NNNr?)NN)6r __module__ __qualname____doc__rrrHrrrTr__annotations__rWr\rcrirzrYrrpropertyrrr6rrrrr rmrr!rnr<rrrrrrrrArrrrrrr r rrr' __classcell__rs@r0r&r&|srrlu & $<jj'334; $$D26dE '+64444&,!!!F''''" 611X1))X)  X WWW$$$:K"K"K"^0000d\&+999 9v   \$%%\&+::: &% :x\&&y112299329v\&&}5566\&+666 76 6p\&&778844984l\&&':;;<<--=<-^\&&7788779874\&&':;;<<55=<5n   \.!!**"!*XPPP\())4d4444*)4l\&&w//00999109v**X*&&&&&P!!!!4//X/ 22X2 <   &IIIIIIIr:r&cd|D}tt}t||D]\}}||xxdz cc<t|D]\}}|dkr||=t t t|D]7}||}||vr)||xxd||zz cc<||xxdzcc<8tt||S)zGenerate names for estimators.cg|]?}t|tr|n%t|j@Sr;)rGrrurlower)rBr.s r0rz$_name_estimators..sP     3//U T)__5M5S5S5U5U   r:r z-%d)rintrqrrrranger|)rwrv namecountrrkvis r0_name_estimatorsr9s!  #   EC  IU++ T$1Y__&&''1 66! eC OO,, - -!!Qx 9   !HHH $/ /HHH dOOOq OOO E:&& ' ''r:F)rRrQrScBtt||||S)aQ Construct 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. The last step will never be cached, even if it is a transformer. 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. transform_input : list of str, default=None This enables transforming some input arguments to ``fit`` (other than ``X``) to be transformed by the steps of the pipeline up to the step which requires them. Requirement is defined via :ref:`metadata routing `. This can be used to pass a validation set through the pipeline for instance. You can only set this if metadata routing is enabled, which you can enable using ``sklearn.set_config(enable_metadata_routing=True)``. .. versionadded:: 1.6 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())]) rU)r&r9)rRrQrSrPs r0r(r(s0p '    r:c:|j|fi|j}||S||zS)a;Call transform and apply weight to output. Parameters ---------- transformer : estimator Estimator to be used for transformation. X : {array-like, sparse matrix} of shape (n_samples, n_features) Input data to be transformed. y : ndarray of shape (n_samples,) Ignored. weight : float Weight to be applied to the output of the transformation. params : dict Parameters to be passed to the transformer's ``transform`` method. This should be of the form ``process_routing()["step_name"]``. r@)rrrrrress r0_transform_oner=s5, +  6 6V%5 6 6C ~ <r:c b|pi}t||5t|dr$|j||fi|di}nC|j||fi|dij|fi|di}dddn #1swxYwY|||fS||z|fS)a 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``. ``params`` needs to be of the form ``process_routing()["step_name"]``. rnrmrAN)rrsrnrrmrA)rrrrrrrr<s r0rrs(\rF _g 6 6 ; 0 0 +++AqTTFJJPR4S4STTCCJ/+/!Q@@&**UB*?*?@@JZZ R00C ~K < $$sA8BB Bct||5|j||fi|dcdddS#1swxYwYdS)z2 Fits ``transformer`` to ``X`` and ``y``. rmN)rrm)rrrrrrrs r0_fit_onerAs _g 6 666{q!55ve}55666666666666666666s 377ceZdZdZddddddZddfd Zed Zdd Zd Z d Z d Z dZ d dZ dZd dZd dZdZdZdZdZdZedZedZdZdZdZdZfdZxZS)!r'apConcatenates 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. verbose_feature_names_out : bool, default=True If True, :meth:`get_feature_names_out` will prefix all feature names with the name of the transformer that generated that feature. If False, :meth:`get_feature_names_out` will not prefix any feature names and will error if feature names are not unique. .. versionadded:: 1.5 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 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.3 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...]]) >>> # An estimator's parameter can be set using '__' syntax >>> union.set_params(svd__n_components=1).fit_transform(X) array([[-1.5 , 3.0...], [ 1.5 , 5.7...]]) For a more detailed example of usage, see :ref:`sphx_glr_auto_examples_compose_plot_feature_union.py`. NFT)n_jobstransformer_weightsrSverbose_feature_names_outcL||_||_||_||_||_dSr?)transformer_listrCrDrSrE)r7rGrCrDrSrEs r0rWzFeatureUnion.__init__s0!1 #6  )B&&&r:r@ct||D]\}}}t|||S)aSet 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", "polars"}, default=None Configure output of `transform` and `fit_transform`. - `"default"`: Default output format of a transformer - `"pandas"`: DataFrame output - `"polars"`: Polars output - `None`: Transform configuration is unchanged Returns ------- self : estimator instance Estimator instance. r@)rr\rYr)r7rArZr[rs r0r\zFeatureUnion.set_outputsX( Y///**,, 8 8JAtQ TY 7 7 7 7 7 r:c>tdit|jS)Nr;)rrrGrs r0named_transformerszFeatureUnion.named_transformerss#33tD122333r:c0|d|S)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. rGr^r`rbs r0rczFeatureUnion.get_paramss$ 2>>>r:c |jdi||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. rG)rGrergs r0rizFeatureUnion.set_paramss"& 66v666 r:c  t|j\}}|||D]Z}|dvrt|dst|drt|ds#t d|dt |d[dS)N)droprlrmrnrAz4All estimators should implement fit and transform. 'rorp)rqrGrrrsrtru)r7rvrxrys r0_validate_transformersz#FeatureUnion._validate_transformerss!4#89| U###  A+++Au%% O)D)D W;NN  i;<11d1ggggG   r:c|jsdStd|jD}|jD]}||vrtd|ddS)Nc3 K|] \}}|V dSr?r;)rBrrZs r0rFz=FeatureUnion._validate_transformer_weights..s&JJqJJJJJJr:z"Attempting to weight transformer "z-", but it is not present in transformer_list.)rDsetrGr)r7transformer_namesrs r0_validate_transformer_weightsz*FeatureUnion._validate_transformer_weightss'  FJJD4IJJJJJ,  D,,, AAAA-  r:c#K|jpij}|jD]2\}}|dkr |dkrtd}||||fV3dS)zg Generate (name, trans, weight) tuples excluding None and 'drop' transformers. rNrlz one-to-one)r N)rDrrGr)r7 get_weightrrs r0rYzFeatureUnion._iters .4"9 0 2 2KD% %%+lKKK 4 0 01 1 1 1 1  2 2r:c Hg}|D]w\}}}t|ds5tdt|dt |jd||}|||fx||S)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 z (type z)) does not provide get_feature_names_out.) rYrsrrrurrappend!_add_prefix_for_feature_names_out)r7r"transformer_with_feature_names_outrrrZr s r0rz"FeatureUnion.get_feature_names_outs.0*"jjll Q QND%5"9:: $n4yyyy$u++"6"6"68!& ; ;N K K  . 5 5t=N6O P P P P55 .   r:cH|jrFttjd|D}t j|t Sttjd|D}d|dD}| |rXt|dkr#t|ddddd z}nt|}td |d t j d |DS) aAdd prefix for feature names out that includes the transformer names. Parameters ---------- transformer_with_feature_names_out : list of tuples of (str, array-like of str) The tuple consistent of the transformer's name and its feature names out. Returns ------- feature_names_out : ndarray of shape (n_features,), dtype=str Transformed feature names. c3:K|]\}fd|DVdS)c3&K|] }d|V dS)rNr;)rBr8rs r0rFzKFeatureUnion._add_prefix_for_feature_names_out...;s-??^^^^??????r:Nr;)rBr rs @r0rFzAFeatureUnion._add_prefix_for_feature_names_out..:sR$$//@???->???$$$$$$r:)dtypec3 K|] \}}|V dSr?r;)rBrZss r0rFzAFeatureUnion._add_prefix_for_feature_names_out..Ds&QQdaQQQQQQr:c$g|] \}}|dk |S)r r;)rBrcounts r0rzBFeatureUnion._add_prefix_for_feature_names_out..Fs)    T5%RS))D)))r:Nrkz, ...]zOutput feature names: z[ are not unique. Please set verbose_feature_names_out=True to add prefixes to feature namescg|]\}}|Sr;r;)rBrZrs r0rzBFeatureUnion._add_prefix_for_feature_names_out..Ws D D DgaT D D Dr:)rErr from_iterablenpasarrayobjectr most_commonsortr|rr concatenate)r7rZrvfeature_names_count top_6_overlap names_reprs r0rYz.FeatureUnion._add_prefix_for_feature_names_out*su  ) 3#$$3U$$$E :e6222 2&  QQ.PQQQ Q Q    $7$C$CA$F$F      =!!Q&&!rr!233CRC88C  // RRRR  ~ D D!C D D D   r:c "trt|dfi|}n;t}|jD]%\}}ti||<|||_&|||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 - If `enable_metadata_routing=False` (default): Parameters directly passed to the `fit` methods of the sub-transformers. - If `enable_metadata_routing=True`: Parameters safely routed to the `fit` methods of the sub-transformers. See :ref:`Metadata Routing User Guide ` for more details. .. versionchanged:: 1.5 `**fit_params` can be routed via metadata routing API. Returns ------- self : object FeatureUnion class instance. rmrm)rrrrGrm_parallel_funcrA_update_transformer_list)r7rr fit_paramsrrrZrxs r0rmzFeatureUnion.fitZs:    5+D%FF:FFMM"GGM0 5 5a&+mmm d#*4 d#''**1a=II  K %%l333 r:c &trt|dfi|}nt}|jD]i\}}t |dr!ti||<|||_6ti||<ti||<|||_j|||t|}|s!tj |j ddfSt|\}} | | ||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. **params : dict, default=None - If `enable_metadata_routing=False` (default): Parameters directly passed to the `fit` methods of the sub-transformers. - If `enable_metadata_routing=True`: Parameters safely routed to the `fit` methods of the sub-transformers. See :ref:`Metadata Routing User Guide ` for more details. .. versionchanged:: 1.5 `**params` can now be routed via metadata routing API. 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. rn)rnrqr@r)rrrrGrsrnrmrrrrgzerosshaperqrs_hstack) r7rrrrrobjresultsXsrxs r0rnzFeatureUnion.fit_transforms*>    5+D/LLVLLMM"GGM!2 5 5 c3005*/b*A*A*AM$'8>M$'55*/B---M$'*/"*=*=*=M$'.4M$'++%%a,> NN -8QWQZO,, ,=L %%l333||Br:c$|jsdSd|||fzS)Nr)rS)r7rrtotals r0rzFeatureUnion._log_messages#| 4.#ud1CCCr:cLtj_tt jfdtdDS)z Runs func in parallel on X and yrCc3K|]R\}\}}}t| |d||t |VSdS)r')rrrN)r#rr|) rBrrrrrfuncrr7rxrs r0rFz.FeatureUnion._parallel_func..s , , 10dK GDMM .))$S5F5FGG$T*    , , , , , , r:r )rrGrOrTrYr"rCr})r7rrrrrxs`````@r0rrzFeatureUnion._parallel_funcs $T%: ; ; ##%%% **,,,DJJLL)) +xt{+++ , , , , , , , , , 5>lA4N4N , , ,   r:c t||dtrt|dfi|n.t|jD]\}}ti|<t |jfd|D}|s!tj j ddfS| |S)aTransform X separately by each transformer, concatenate results. Parameters ---------- X : iterable or array-like, depending on transformers Input data to be transformed. **params : dict, default=None Parameters routed to the `transform` method of the sub-transformers via the metadata routing API. See :ref:`Metadata Routing User Guide ` for more details. .. versionadded:: 1.5 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. rAr@rc 3pK|]0\}}}tt|d||V1dS)N)r)r#r=)rBrrrrrs r0rFz)FeatureUnion.transform..s`* * #eV $GN # #E1dF=QUCV W W W* * * * * * r:r) rrrrrGr"rCrYrgrvrwrx)r7rrrrZr{rs ` @r0rAzFeatureUnion.transforms, &$ 444    :+D+HHHHMM"GGM0 : :a&+b&9&9&9 d## )XT[ ) ) )* * * * * '+zz||* * *    -8QWQZO,, ,||Br:c4td|r0tfd|Dr|Std|Dr't j|}nt j|}|S)NrAc3BK|]}|VdSr?)is_supported_container)rBradapters r0rFz'FeatureUnion._hstack..s1II799!<<IIIIIIr:c3>K|]}tj|VdSr?)r issparse)rBfs r0rFz'FeatureUnion._hstack..s,..avq!!......r:)rrhstackanyr tocsrrg)r7r{rs @r0rxzFeatureUnion._hstacks(d;;  &sIIIIbIIIII &>>"%% % ..2... . . r""((**BB2B r:c`tfd|jD|jdd<dS)NcHg|]\}}||dkr|ntfS)rN)next)rBroldrxs r0rz9FeatureUnion._update_transformer_list..sF$ $ $ c#--33T,-?-? @$ $ $ r:)iterrG)r7rxs `r0rsz%FeatureUnion._update_transformer_listsML)) $ $ $ $ !2$ $ $ aaa   r:c2|jddjS)z+Number of features seen during :term:`fit`.rr )rGr rs r0r zFeatureUnion.n_features_in_s $Q'*99r:c2|jddjS)z*Names of features seen during :term:`fit`.rr )rGr rs r0r zFeatureUnion.feature_names_in_s$Q'*<` on how the routing mechanism works. .. versionadded:: 1.5 Returns ------- routing : MetadataRouter A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating routing information. rr"rmrrnrAr;)rrrrGr#r)r7r$rrs r0r'z!FeatureUnion.get_metadata_routing2s dn&=>>>!%!6   D+ FJ  %  ,E%00OODDOE::OK@@K <<      r:ct} td|jD|j_n#t $rYnwxYw|S)Nc3VK|]$\}}|dv t|jjV%dS)>rNrlNr)rBrrs r0rFz0FeatureUnion.__sklearn_tags__..RsJ))D% 777*17777))r:)rrrrGrr Exception)r7rrs r0rzFeatureUnion.__sklearn_tags__Os~ww'')) %())#'#8)))&&DO " "     D    s(A AAr(r?)rr)r*r+rWr\r-rJrcrirOrTrYrrYrmrnrrrrArxrsr r rrrr'rr.r/s@r0r'r'"seeV "& C C C C C'+244X4????(,$    2 2 2    8. . . `----^5 5 5 5 nDDD    (( ( ( T      ::X: ==X=  CCC--- :         r:r'rCrSc@tt|||S)aConstruct a :class:`FeatureUnion` from the given transformers. This is a shorthand for the :class:`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)r'r9)rCrSrxs r0r)r)_s#Z (66vw W W WWr:r?)r>NN)Fr+r+ collectionsrr contextlibrcopyr itertoolsrrnumpyrgscipyr baser r r exceptionsr preprocessingrutilsrutils._estimator_html_reprrutils._metadata_requestsrutils._param_validationrrutils._set_outputrr utils._tagsrutils._user_interfacerutils.deprecationrutils.metadata_routingrrrrrrutils.metaestimatorsr r!utils.parallelr"r#utils.validationr$r%__all__r1r<rLr&r9r(r=rrAr'r)r;r:r0rsiWW ,,,,,,,,%%%%%%########7777777777&&&&&&......444444------77777777"!!!!!666666AAAAAAA@@@@@@@--------;;;;;;;; E E E   4   %%%PNNNNNNNNb((((0"&tU=====@<IM%%%%06666zzzzz#%5zzzz&*5-X-X-X-X-X-X-Xr: