ZPhdZddlZddlmZddlmZddlmZddlm Z ddl m Z ddl m Z dd lmZdd lmZdd lmZmZmZmZdd lmZdd lmZmZddlmZddlmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%ddgZ&edZ'dZ(Gddej)Z)d!dZ*d"dZ+ d!dZ,e%de-edggde.gdgddddddd Z/dS)#z The :mod:`imblearn.pipeline` module implements utilities to build a composite estimator, as a chain of transforms, samples and estimators. N)contextmanager)deepcopy)pipeline)clone)NotFittedError)Bunch) HasMethods) parse_version)MetadataRouter MethodMapping_routing_enabledget_routing_for_object) available_if)check_is_fitted check_memory)METHODS) _fit_context_print_elapsed_time_raise_for_paramsget_tagsprocess_routingsklearn_versionvalidate_paramsPipeline make_pipelinec#K dVn"#t$r}td|d}~wwxYw t|dS#t$rtjdtYdSwxYw)a A 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(0.15): 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 0.15 instead of the current warning.)rrwarningswarn FutureWarning) estimatorexcs Q/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/imblearn/pipeline.py_raise_or_warn_if_not_fittedr$1sE  EEE:;;DE   """""               s (#(=$A%$A%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 r# z$_cached_transform..hsM&&' &wCC2BCC&&&&&&) isinstancetupler))r,cache param_name param_valuer-s` `r#_cached_transformr5Ls, k5 ) ) X %&&&&&*&&&!!E*   !7 6{ W WFV W WE*   r/ceZdZUdZdedgdeedggdgdZee d<dddd d Z d Z d,fd Z dZ d-dZedd.dZdZeeedd.dZeejddZdZeeedd.dZeejdedd.dZeejddZeejddZeejddZeejd d!Zd"Zeed#Zd$Z ee d%Z!eejd&d/d'Z"d(Z#d)Z$d*Z%fd+Z&xZ'S)0raPipeline of transforms and resamples with a final estimator. Sequentially apply a list of transforms, sampling, and a final estimator. Intermediate steps of the pipeline must be transformers or resamplers, that is, they must implement fit, transform and sample methods. The samplers are only applied during fit. The final estimator only needs to implement fit. The transformers and samplers 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``. Parameters ---------- steps : list List of (name, transform) tuples (implementing fit/transform/fit_resample) that are chained, in the order in which they are chained, with the last object an estimator. 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 : Instance of joblib.Memory or str, 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` 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. n_features_in_ : int Number of features seen during first step `fit` method. 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. See Also -------- make_pipeline : Helper function to make pipeline. Notes ----- See :ref:`sphx_glr_auto_examples_pipeline_plot_pipeline_classification.py` .. warning:: A surprising behaviour of the `imbalanced-learn` pipeline is that it breaks the `scikit-learn` contract where one expects `estimmator.fit_transform(X, y)` to be equivalent to `estimator.fit(X, y).transform(X)`. The semantic of `fit_resample` is to be applied only during the fit stage. Therefore, resampling will happen when calling `fit_transform` while it will only happen on the `fit` stage when calling `fit` and `transform` separately. Practically, `fit_transform` will lead to a resampled dataset while `fit` and `transform` will not. Examples -------- >>> from collections import Counter >>> from sklearn.datasets import make_classification >>> from sklearn.model_selection import train_test_split as tts >>> from sklearn.decomposition import PCA >>> from sklearn.neighbors import KNeighborsClassifier as KNN >>> from sklearn.metrics import classification_report >>> from imblearn.over_sampling import SMOTE >>> from imblearn.pipeline import Pipeline >>> X, y = make_classification(n_classes=2, class_sep=2, ... weights=[0.1, 0.9], n_informative=3, n_redundant=1, flip_y=0, ... n_features=20, n_clusters_per_class=1, n_samples=1000, random_state=10) >>> print(f'Original dataset shape {Counter(y)}') Original dataset shape Counter({1: 900, 0: 100}) >>> pca = PCA() >>> smt = SMOTE(random_state=42) >>> knn = KNN() >>> pipeline = Pipeline([('smt', smt), ('pca', pca), ('knn', knn)]) >>> X_train, X_test, y_train, y_test = tts(X, y, random_state=42) >>> pipeline.fit(X_train, y_train) Pipeline(...) >>> y_hat = pipeline.predict(X_test) >>> print(classification_report(y_test, y_hat)) precision recall f1-score support 0 0.87 1.00 0.93 26 1 1.00 0.98 0.99 224 accuracy 0.98 250 macro avg 0.93 0.99 0.96 250 weighted avg 0.99 0.98 0.98 250 no_validationNr2booleanstepstransform_inputmemoryverbose_parameter_constraintsF)r;r<r=c>||_||_||_||_dSr'r9)selfr:r;r<r=s r#__init__zPipeline.__init__s# .  r/c Bt|j\}}|||dd}|d}|D]}||dkr t|dot|d}t|d}|p| }|r#t d|dt |d|r|rt d |zt |tjrt d |9|dkr5t|ds't d |dt |d dSdSdS) N passthroughfitr) fit_resamplezAll intermediate steps of the chain should be estimators that implement fit and transform or fit_resample (but not both) or be a string 'passthrough' 'z' (type z ) doesn't)zAll intermediate steps of the chain should be estimators that implement fit and transform or fit_resample. '%s' implements both)z;All intermediate steps of the chain should not be PipelineszLLast step of Pipeline should implement fit or be the string 'passthrough'. 'z ) doesn't) zipr:_validate_nameshasattr TypeErrortyper0rr) r@names estimators transformersr!t is_transfomer is_sampleris_not_transfomer_or_samplers r#_validate_stepszPipeline._validate_stepss,z U###"#2# rN   AyA..#Au--I'![2I2IM N33J0=0K+L (+ i23DGGGG=  -123!X.// Q   !]**Iu--+)99d9oooo/  " !****r/Tcrt||}|rtd|S|S)a Generate (idx, (name, trans)) tuples from self.steps. When `filter_passthrough` is `True`, 'passthrough' and None transformers are filtered out. When `filter_resample` is `True`, estimator with a method `fit_resample` are filtered out. c0t|dd S)NrCrFrI)xs r#z Pipeline._iter..:s"~(F(F$Fr/)super_iterfilter)r@ with_finalfilter_passthroughfilter_resampleit __class__s r#rZzPipeline._iter1s>WW]]:'9 : :  FFKK KIr/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)r))methodparams)consumeskeys)r*keyvalue all_paramssub_metadata_routings r# z3Pipeline._get_metadata_for_step..jsc   U#,,":??+<+<- r/)r2r3r4r-)r;ritemsdictrr5) r@step_idx step_paramsrir,r-transformed_paramstransformed_cacherc method_paramsr3r4rjs ` @r#_get_metadata_for_stepzPipeline._get_metadata_for_step>s[@  ( ) )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 rt|j|_|t|j}|t }|t}|dddD]%\}} } | | dkrt| d r.|| ||d| |||  \}}} | | f|j|<'||fS) NFr\r]r^rDrlocationrnrorir) fit_transform)weightmessage_clsnamemessagerdrF)rzr{rd)listr:rSrr<r2_fit_transform_one_fit_resample_onerZr _log_messagerIrvrrs)r@Xy routed_params raw_paramsr<fit_transform_one_cachedfit_resample_one_cachedrnname transformercloned_transformerrofitted_transformers r#_fitz Pipeline._fitsZ$*%%  dk**#)<<0B#C#C "(,,/@"A"A+/::,6, , , >, > 'HdK"k]&B&B(T5F5Fx5P5PQQvz** 8v/F&1""%*;%7%7"55!)$/%6K );77 7"O<< )A(@&$. --h77&)))%%%+^<< +B+B&$. --h77(. ,,,(1(%)*<#=DJx !t sCC C prefer_skip_nested_validationc xts|jtdtt dkr|jtd|d|}|||||\}}td|t|j d z 5|j d krY| t|d z ||j d d | }|j j ||fi|ddddn #1swxYwY|S)aFit the model. Fit all the transforms/samplers one after the other and transform/sample the data, then fit the transformed/sampled 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 : Pipeline This estimator. 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)`.z1.4zThe `transform_input` parameter is not supported in scikit-learn versions prior to 1.4. Please upgrade to scikit-learn 1.4 or later.rErcprops)rrrrDrCrrw)r r; ValueErrorrr _check_method_paramsrrrlenr:_final_estimatorrsrE)r@rrrdrXtytlast_step_paramss r#rEz Pipeline.fits` !! d&:&FF  ]511 1 1d6J6V  11f1MM 1a6BBB T->->s4:QR?R-S-S T T M M$ 55#'#>#> YY] -djnQ.? @%$?$$ *%)"bLL4DU4KLLL M M M M M M M M M M M M M M M s>A%D//D36D3cl|jdkp)t|jdpt|jdS)NrDr)rxrrIr@s r#_can_fit_transformzPipeline._can_fit_transforms<  !] 2 ?t,k:: ?t,o>> r/c l|d|}||||\}}|j}td|t |jdz 5|dkr|cdddS|t |dz ||jdd| }t|dr!|j ||fi|dcdddS|j ||fi|d j |fi|d cdddS#1swxYwYdS) a Fit the model and transform with the final estimator. Fits all the transformers/samplers one after the other and transform/sample 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. **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 : array-like of shape (n_samples, n_transformed_features) Transformed samples. rxrrrrDNrCrrwrEr)) rrrrrrr:rsrIrxrEr) r@rrrdrrr last_steprs r#rxzPipeline.fit_transforms`11PV1WW 1a//B) T->->s4:QR?R-S-S T T  M))         $::TQ)$*R.*;<! ;    y/22 .y..?        Q}y}RFF.>u.EFFP*;7                  s1D)A#D)6&D))D-0D-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\rCrNrr)r$r rZr)r:rrr@rrdr_rr)rs r#rzPipeline.predict]s`*$ / /  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 cB|jdkpt|jdS)NrDrFrrs r#_can_fit_resamplezPipeline._can_fit_resamples+$ 5   !>: :  r/c |d|}||||\}}|j}td|t |jdz 5|dkr|cdddS||jdd}t|dr!|j||fi|dcdddS ddddS#1swxYwYdS) amFit the model and sample with the final estimator. Fits all the transformers/samplers one after the other and transform/sample the data, then uses fit_resample 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. **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 : array-like of shape (n_samples, n_transformed_features) Transformed samples. yt : array-like of shape (n_samples, n_transformed_features) Transformed target. rFrrrrDNrCr) rrrrrrr:rIrFrs r#rFzPipeline.fit_resamplesf11v1VV 1a//B) T->->s4:QR?R-S-S T T  M))         -TZ^A->? y.11 -y-.~>                             s1C=CC"%C" fit_predictc |d|}||||\}}||jdd}td|t |jdz 5|jddj||fi|di}dddn #1swxYwY|S)aApply `fit_predict` of last step in pipeline after transforms. Applies fit_transforms of a pipeline to the data, followed by the fit_predict method of the final estimator in the pipeline. Valid only 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 of shape (n_samples,) The predicted target. rrrCrrrN)rrr:rrrrget) r@rrrdrrrparams_last_stepy_preds r#rzPipeline.fit_predictsl11f1UU 1a//B(B):; T->->s4:QR?R-S-S T T  3TZ^B'3B*..}bAAF                s5CC C 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. FrrCrNrr)r$r rZr)r:rrrs r#rzPipeline.predict_proba$sV*$ / /  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. rFrr)rCrrN)r$rrrZr)rr:rr@rrdrrrrr)s r#rzPipeline.decision_function_sn>*$ / /   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. FrrCrN)r$rZr)r:r)r@rrrrs r#rzPipeline.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. FrrCrNrr)r$r rZr)r:rrrs r#rzPipeline.predict_log_probasV*$ / /  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)NrDr)rrs r#_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. r)N)r$rrrZr)rs r#r)zPipeline.transformsD*$ / /   fdK 8 8 8,D+HHHHMB&*jjll N N"4(Y(MM}T/B/LMM                  sAA44A8;A8cXtd|DS)Nc3>K|]\}}}t|dVdS)inverse_transformNrV)r*rrOs r#r.z2Pipeline._can_inverse_transform..s3OOwq!Q71122OOOOOOr/)allrZrs r#_can_inverse_transformzPipeline._can_inverse_transforms'OO$**,,OOOOOOr/c 6t|5t||dt|dfi|}tt |}|D]\}}}|j|fi||j} |cdddS#1swxYwYdS)aJApply `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. **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)r$rrreversedr|rZr)r@rrdr reverse_iterrrr)s r#rzPipeline.inverse_transforms >*$ / /   fd,? @ @ @,D2EPPPPM#D$6$677L&2  "40Y0'-?                  sA1BBBscorec 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_weightrCrrr)r$r rZr)r:rr) r@rrrrdrrrr) score_paramsrs r#rzPipeline.scoreFsL*$ / /  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+DBDDDc t|jj}|dddD]\}}}t }t |drB|ddddddn|dddd dddd dddd |dd dd dd |d d d d d d d d dd d d dddd d d |jdd|i||i|jd\}}||dkr|St }t |dr|ddn,|dddd |ddd d ddd d d d ddd d ddddd d |jdd|i||i|S)aCGet metadata routing of this object. Please check :ref:`User Guide ` on how the routing mechanism works. Returns ------- routing : MetadataRouter A :class:`~utils.metadata_routing.MetadataRouter` encapsulating routing information. )ownerFTrurxrE)callercalleerr)rFrrrrrrmethod_mappingrCNrD)r r`__name__rZr rIaddr:)r@routerrrtransr final_name final_ests r#get_metadata_routingzPipeline.get_metadata_routings dn&=>>>#jju)  ( G( GNAtU+__Nuo.. "&&eO&LLSSHHS oSFFFF#&&eE&BBSkS::SS>>S SDDS eS<<S kSBBB ""%"GGONCCM.AAA"")K"HHIk::OK@@/ DD/ DDK <</8KLLGK88N;??? FJ F Fn Fu F F F F $ 2 I   ] : :M' 9o . .    oo  N N N N""%">>BB C   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 S~S > > >  LL.LZ4KLLL r/c trt||fi||}|Stdid|jD}|D]w\}}d|vr"t d||dd\}} |||d| <|||d| <|||d| <x|S) Nc Pi|]#\}}||tdidtD$S)Nci|]}|iSrr)r*rcs r#rkz..s"D"D"D&62"D"D"Dr/r)rr)r*rsteps r#rkz1Pipeline._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)`.rrErxrr)r rrr:rlrformatsplit) r@rcrkwargsrfit_params_stepspnamepvalrparams r#rzPipeline._check_method_paramss    $+D&LLELVLLM $  &*j    %{{}} D D tu$$$,-3F5MM $kk$22 e7; &u-e4BF &7>?C &}5e<<# #r/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. NrDTF)rr:rr)r@rrr!s r#__sklearn_is_fitted__zPipeline.__sklearn_is_fitted__s $TZ00  LAyM))% *  4  I & & &4   55 s= A  A ct}|js|S |jddK|jdddkr4t|jddjj|j_n#t ttf$rYnwxYw |jdd|jdddkrt|jdd}|j |_ |j j |j _ t|j |_ t|j|_t|j|_n#t ttf$rYnwxYw|S)NrrrDrC)rY__sklearn_tags__r:r input_tagspairwiserAttributeErrorrJestimator_type target_tags multi_outputrclassifier_tagsregressor_tagstransformer_tags)r@tagslast_step_tagsr`s r#rzPipeline.__sklearn_tags__sqww''))z K z!}Q+ 1 a0@M0Q0Q+3JqM!$,,X(NI6    D  z"~a ,B1Bm1S1S!)$*R.*;!0J0W -'/0N'O'O$&.~/L&M&M#(01P(Q(Q%NI6    D   s%AB B%$B%)B7E!!E;:E;)TTT)NNNr')NN)(r __module__ __qualname____doc__r|strr r>rm__annotations__rArSrZrsrrrErrrxr_final_estimator_hasrrrFrrrrrrr)rrrrrrr __classcell__)r`s@r#rrrs?zzz! $<jj'334; $$D26dE111f      K"K"K"`6666r\&+DDD DL   \$%%\&+>>> &% >@\/(/ ::;;==<;=~   \#$$\&+888 %$ 8t\/(/ >>??\&+999 @? 9|\/(/@@AA88BA8t\/(/0CDDEE--FE-^\/(/@@AA77BA74\/(/0CDDEE88FE8t   \.!!**"!*XPPP\())))*))V\/(/8899999:99zUUUn$$$:<r/c t||5|j||fi|di\}}|||fcdddS#1swxYwYdS)NrF)rrFr)samplerrrrzr{rdX_resy_ress r#r~r~6s _g 6 6%%+w+AqSSFJJ~r4R4RSS ueW$%%%%%%%%%%%%%%%%%%s+A  A A 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()rrrryrdress r#_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"]``. rxrEr)N)rrIrxrrEr))rrrryrzr{rdrs r#r}r}Zs(\rF _g 6 6 ; 0 0 +++AqTTFJJPR4S4STTCCJ/+/!Q@@&**UB*?*?@@JZZ R00C ~K < $$sA8BB Br2r8r<r;r=TrFcLttj||||S)aConstruct a Pipeline from the given estimators. This is a shorthand for the 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 estimators A list of estimators. memory : None, 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. 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 an imbalanced-learn `Pipeline` instance that handles samplers. See Also -------- imblearn.pipeline.Pipeline : Class for creating a pipeline of transforms with a final estimator. Examples -------- >>> from sklearn.naive_bayes import GaussianNB >>> from sklearn.preprocessing import StandardScaler >>> make_pipeline(StandardScaler(), GaussianNB(priors=None)) Pipeline(steps=[('standardscaler', StandardScaler()), ('gaussiannb', GaussianNB())]) r)rr_name_estimators)r<r;r=r:s r#rrrs3~ !%(('    r/)rNNr')0rr contextlibrcopyrsklearnr sklearn.basersklearn.exceptionsr sklearn.utilsrsklearn.utils._param_validationr sklearn.utils.fixesr sklearn.utils.metadata_routingr r r rsklearn.utils.metaestimatorsrsklearn.utils.validationrrbaserutils._sklearn_compatrrrrrrr__all__r$r5rr~rr}rr|rrr/r#r s%%%%%%------666666------ 655555BBBBBBBB  '   4###LAAAAAx AAAH&%%%%<IM%%%%0jj'334 $<; #' "&tU<<<<<<<r/