0PhDddlZddlmZddlmZmZddlmZddlZddl m Z ddl m Z m Z ddlmZdd lmZdd lmZmZmZdd lmZdd lmZdd lmZddlmZmZmZddl m!Z!m"Z"m#Z#m$Z$ddl%m&Z&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,m-Z-m.Z.edgdZ/dZ0Gdde-Z1dS)N) namedtuple)IntegralReal)time)stats) _fit_contextclone)ConvergenceWarning) normalize)_safe_indexing check_arraycheck_random_state) _safe_assign) _get_mask) is_scalar_nan) HasMethodsInterval StrOptions)MetadataRouter MethodMapping_raise_for_paramsprocess_routing) FLOAT_DTYPES_check_feature_names_in _num_samplescheck_is_fitted validate_data) SimpleImputer _BaseImputer_check_inputs_dtype_ImputerTriplet)feat_idxneighbor_feat_idx estimatorcpt|dr|||ddS||||<dS)a>Assign X2 to X1 where cond is True. Parameters ---------- X1 : ndarray or dataframe of shape (n_samples, n_features) Data. X2 : ndarray of shape (n_samples, n_features) Data to be assigned. cond : ndarray of shape (n_samples, n_features) Boolean mask to assign data. maskT)condotherinplaceN)hasattrr()X1X2r)s Y/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/impute/_iterative.py _assign_wherer0(sEr6 TT22222d84ceZdZUdZiejdeddggdgeedddgee dddgdeed ddge hd gd e hd gdgdee ddd dgdee ddd dgdgdgd Ze e d< d(e jdddddddde j e jdddddfd Z d)dZdZdZd*dZd+d Zed!Zed"d(fd# Zfd$Zd(d%Zd(d&Zd'ZxZS),IterativeImputera(Multivariate imputer that estimates each feature from all the others. A strategy for imputing missing values by modeling each feature with missing values as a function of other features in a round-robin fashion. Read more in the :ref:`User Guide `. .. versionadded:: 0.21 .. note:: This estimator is still **experimental** for now: the predictions and the API might change without any deprecation cycle. To use it, you need to explicitly import `enable_iterative_imputer`:: >>> # explicitly require this experimental feature >>> from sklearn.experimental import enable_iterative_imputer # noqa >>> # now you can import normally from sklearn.impute >>> from sklearn.impute import IterativeImputer Parameters ---------- estimator : estimator object, default=BayesianRidge() The estimator to use at each step of the round-robin imputation. If `sample_posterior=True`, the estimator must support `return_std` in its `predict` method. missing_values : int or np.nan, default=np.nan The placeholder for the missing values. All occurrences of `missing_values` will be imputed. For pandas' dataframes with nullable integer dtypes with missing values, `missing_values` should be set to `np.nan`, since `pd.NA` will be converted to `np.nan`. sample_posterior : bool, default=False Whether to sample from the (Gaussian) predictive posterior of the fitted estimator for each imputation. Estimator must support `return_std` in its `predict` method if set to `True`. Set to `True` if using `IterativeImputer` for multiple imputations. max_iter : int, default=10 Maximum number of imputation rounds to perform before returning the imputations computed during the final round. A round is a single imputation of each feature with missing values. The stopping criterion is met once `max(abs(X_t - X_{t-1}))/max(abs(X[known_vals])) < tol`, where `X_t` is `X` at iteration `t`. Note that early stopping is only applied if `sample_posterior=False`. tol : float, default=1e-3 Tolerance of the stopping condition. n_nearest_features : int, default=None Number of other features to use to estimate the missing values of each feature column. Nearness between features is measured using the absolute correlation coefficient between each feature pair (after initial imputation). To ensure coverage of features throughout the imputation process, the neighbor features are not necessarily nearest, but are drawn with probability proportional to correlation for each imputed target feature. Can provide significant speed-up when the number of features is huge. If `None`, all features will be used. initial_strategy : {'mean', 'median', 'most_frequent', 'constant'}, default='mean' Which strategy to use to initialize the missing values. Same as the `strategy` parameter in :class:`~sklearn.impute.SimpleImputer`. fill_value : str or numerical value, default=None When `strategy="constant"`, `fill_value` is used to replace all occurrences of missing_values. For string or object data types, `fill_value` must be a string. If `None`, `fill_value` will be 0 when imputing numerical data and "missing_value" for strings or object data types. .. versionadded:: 1.3 imputation_order : {'ascending', 'descending', 'roman', 'arabic', 'random'}, default='ascending' The order in which the features will be imputed. Possible values: - `'ascending'`: From features with fewest missing values to most. - `'descending'`: From features with most missing values to fewest. - `'roman'`: Left to right. - `'arabic'`: Right to left. - `'random'`: A random order for each round. skip_complete : bool, default=False If `True` then features with missing values during :meth:`transform` which did not have any missing values during :meth:`fit` will be imputed with the initial imputation method only. Set to `True` if you have many features with no missing values at both :meth:`fit` and :meth:`transform` time to save compute. min_value : float or array-like of shape (n_features,), default=-np.inf Minimum possible imputed value. Broadcast to shape `(n_features,)` if scalar. If array-like, expects shape `(n_features,)`, one min value for each feature. The default is `-np.inf`. .. versionchanged:: 0.23 Added support for array-like. max_value : float or array-like of shape (n_features,), default=np.inf Maximum possible imputed value. Broadcast to shape `(n_features,)` if scalar. If array-like, expects shape `(n_features,)`, one max value for each feature. The default is `np.inf`. .. versionchanged:: 0.23 Added support for array-like. verbose : int, default=0 Verbosity flag, controls the debug messages that are issued as functions are evaluated. The higher, the more verbose. Can be 0, 1, or 2. random_state : int, RandomState instance or None, default=None The seed of the pseudo random number generator to use. Randomizes selection of estimator features if `n_nearest_features` is not `None`, the `imputation_order` if `random`, and the sampling from posterior if `sample_posterior=True`. Use an integer for determinism. See :term:`the Glossary `. add_indicator : bool, default=False If `True`, a :class:`MissingIndicator` transform will stack onto output of the imputer's transform. This allows a predictive estimator to account for missingness despite imputation. If a feature has no missing values at fit/train time, the feature won't appear on the missing indicator even if there are missing values at transform/test time. keep_empty_features : bool, default=False If True, features that consist exclusively of missing values when `fit` is called are returned in results when `transform` is called. The imputed value is always `0` except when `initial_strategy="constant"` in which case `fill_value` will be used instead. .. versionadded:: 1.2 Attributes ---------- initial_imputer_ : object of type :class:`~sklearn.impute.SimpleImputer` Imputer used to initialize the missing values. imputation_sequence_ : list of tuples Each tuple has `(feat_idx, neighbor_feat_idx, estimator)`, where `feat_idx` is the current feature to be imputed, `neighbor_feat_idx` is the array of other features used to impute the current feature, and `estimator` is the trained estimator used for the imputation. Length is `self.n_features_with_missing_ * self.n_iter_`. n_iter_ : int Number of iteration rounds that occurred. Will be less than `self.max_iter` if early stopping criterion was reached. n_features_in_ : int Number of features seen during :term:`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.0 n_features_with_missing_ : int Number of features with missing values. indicator_ : :class:`~sklearn.impute.MissingIndicator` Indicator used to add binary indicators for missing values. `None` if `add_indicator=False`. random_state_ : RandomState instance RandomState instance that is generated either from a seed, the random number generator or by `np.random`. See Also -------- SimpleImputer : Univariate imputer for completing missing values with simple strategies. KNNImputer : Multivariate imputer that estimates missing features using nearest samples. Notes ----- To support imputation in inductive mode we store each feature's estimator during the :meth:`fit` phase, and predict without refitting (in order) during the :meth:`transform` phase. Features which contain all missing values at :meth:`fit` are discarded upon :meth:`transform`. Using defaults, the imputer scales in :math:`\mathcal{O}(knp^3\min(n,p))` where :math:`k` = `max_iter`, :math:`n` the number of samples and :math:`p` the number of features. It thus becomes prohibitively costly when the number of features increases. Setting `n_nearest_features << n_features`, `skip_complete=True` or increasing `tol` can help to reduce its computational cost. Depending on the nature of missing values, simple imputers can be preferable in a prediction context. References ---------- .. [1] `Stef van Buuren, Karin Groothuis-Oudshoorn (2011). "mice: Multivariate Imputation by Chained Equations in R". Journal of Statistical Software 45: 1-67. `_ .. [2] `S. F. Buck, (1960). "A Method of Estimation of Missing Values in Multivariate Data Suitable for use with an Electronic Computer". Journal of the Royal Statistical Society 22(2): 302-306. `_ Examples -------- >>> import numpy as np >>> from sklearn.experimental import enable_iterative_imputer >>> from sklearn.impute import IterativeImputer >>> imp_mean = IterativeImputer(random_state=0) >>> imp_mean.fit([[7, 2, 3], [4, np.nan, 6], [10, 5, 9]]) IterativeImputer(random_state=0) >>> X = [[np.nan, 2, 3], [4, np.nan, 6], [10, np.nan, 9]] >>> imp_mean.transform(X) array([[ 6.9584..., 2. , 3. ], [ 4. , 2.6000..., 6. ], [10. , 4.9999..., 9. ]]) For a more detailed example see :ref:`sphx_glr_auto_examples_impute_plot_missing_values.py` or :ref:`sphx_glr_auto_examples_impute_plot_iterative_imputer_variants_comparison.py`. Nfitpredictbooleanrleft)closedr>meanmedianconstant most_frequent no_validation>romanarabicrandom ascending descendingbothz array-likeverbose random_state) r&sample_posteriormax_itertoln_nearest_featuresinitial_strategy fill_valueimputation_order skip_complete min_value max_valuerDrE_parameter_constraintsF gMbP?r9rA)missing_valuesrFrGrHrIrJrKrLrMrNrOrDrE add_indicatorkeep_empty_featuresct|||||_||_||_||_||_||_||_| |_ | |_ | |_ | |_ | |_ ||_dS)N)rRrSrT)super__init__r&rFrGrHrIrJrKrLrMrNrOrDrE)selfr&rRrFrGrHrIrJrKrLrMrNrOrDrErSrT __class__s r/rWzIterativeImputer.__init__:s( )' 3    # 0  "4 0$ 0*"" (r1Tcf||durtd|t|j}|dd|f}|rUtt||d|d} tt||d|d} |j| | fi|t j|dkr||fStt||d|d} |jr|| d\} } t j | j |j }| dk}| |||<| |j |k}|j |||<| |j |k}|j |||<||z|z}| |} | |} |j || z | z }|j || z | z }tj||| | }||j ||<nA|| }t j||j ||j |}t'|||| ||fS) aImpute a single feature from the others provided. This function predicts the missing values of one of the features using the current estimates of all the other features. The `estimator` must support `return_std=True` in its `predict` method for this function to work. Parameters ---------- X_filled : ndarray Input data with the most recent imputations. mask_missing_values : ndarray Input data's missing indicator matrix. feat_idx : int Index of the feature currently being imputed. neighbor_feat_idx : ndarray Indices of the features to be used in imputing `feat_idx`. estimator : object The estimator to use at this step of the round-robin imputation. If `sample_posterior=True`, the estimator must support `return_std` in its `predict` method. If None, it will be cloned from self._estimator. fit_mode : boolean, default=True Whether to fit and predict with the estimator or just predict. params : dict Additional params routed to the individual estimator. Returns ------- X_filled : ndarray Input data with `X_filled[missing_row_mask, feat_idx]` updated. estimator : estimator with sklearn API The fitted estimator used to impute `X_filled[missing_row_mask, feat_idx]`. NFzKIf fit_mode is False, then an already-fitted estimator should be passed in.raxisrT) return_std)dtype)ablocscale)rE) row_indexercolumn_indexer) ValueErrorr _estimatorr r4npsumrFr5zerosshaper^ _min_value _max_valuer truncnormrvs random_state_clipr)rXX_filledmask_missing_valuesr$r%r&fit_modeparamsmissing_row_maskX_trainy_trainX_testmussigmasimputed_valuespositive_sigmas mus_too_low mus_too_high inrange_maskr_r`truncated_normals r/_impute_one_featurez$IterativeImputer._impute_one_featurebsh  U!2!21   do..I.qqq({;  6$x):CCC!!G %x:::!!G IM'7 5 5f 5 5 5 6" # #q ( (Y& & 8%6Q ? ? ?       #++Ft+DDKCXcix~FFFN%qjO/2O3C/DNO+ , 99K*./(*CN; '!::L+/?8+DN< (*k\9\MILl#CL)F*S0F:A*S0F:A$aSOOO +;+?+?!/,@,,N< ( ('..v66NW 94?8;TN   (#     ""r1c2|jM|j|krB|dd|f}|jtj||jd|}nBtj|}tj|dz|}tj||f}|S)azGet a list of other features to predict `feat_idx`. If `self.n_nearest_features` is less than or equal to the total number of features, then use a probability proportional to the absolute correlation between `feat_idx` and each other feature to randomly choose a subsample of the other features (without replacement). Parameters ---------- n_features : int Number of features in `X`. feat_idx : int Index of the feature currently being imputed. abs_corr_mat : ndarray, shape (n_features, n_features) Absolute correlation matrix of `X`. The diagonal has been zeroed out and each feature has been normalized to sum to 1. Can be None. Returns ------- neighbor_feat_idx : array-like The features to use to impute `feat_idx`. NF)replacepr)rIrochoicergarange concatenate)rX n_featuresr$ abs_corr_matrr% inds_left inds_rights r/_get_neighbor_feat_idxz'IterativeImputer._get_neighbor_feat_idxs2  " .43JZ3W3WQQQ[)A $ 2 9 9 *%%t'>QR!:!!   (++I8a<<t|t|z }tj|d |d}ny|jd krGt|t|z }tj|d |dddd}n'|jd kr|}|j ||S) aDecide in what order we will update the features. As a homage to the MICE R package, we will have 4 main options of how to order the updates, and use a random order if anything else is specified. Also, this function skips features which have no missing values. Parameters ---------- mask_missing_values : array-like, shape (n_samples, n_features) Input data's missing indicator matrix, where `n_samples` is the number of samples and `n_features` is the number of features. Returns ------- ordered_idx : ndarray, shape (n_features,) The order in which to impute the features. rr[r>r?NrA mergesort)kindrBr@) r9rMrg flatnonzerorrjrLlenargsortroshuffle)rXrrfrac_of_missing_valuesmissing_values_idx ordered_idxns r/_get_ordered_idxz!IterativeImputer._get_ordered_idxsc("5!9!9q!9!A!A   P!#0F!G!G  !#284J+K+KA+N!O!O   G + +,KK  "h . .,TTrT2KK  "k 1 1*++c2D.E.EEA*%;+NNNqrrRKK  "l 2 2*++c2D.E.EEA*%;+NNNqrrRSWSWUWSWXKK  "h . .,K   & &{ 3 3 3r1ư>c|jd}|j |j|krdStjd5tjtj|j}dddn #1swxYwY||tj|<tj||d|tj |dt|ddd }|S) aGet absolute correlation matrix between features. Parameters ---------- X_filled : ndarray, shape (n_samples, n_features) Input data with the most recent imputations. tolerance : float, default=1e-6 `abs_corr_mat` can have nans, which will be replaced with `tolerance`. Returns ------- abs_corr_mat : ndarray, shape (n_features, n_features) Absolute correlation matrix of `X` at the beginning of the current round. The diagonal has been zeroed out and each feature's absolute correlations with all others have been normalized to sum to 1. rNignore)invalid)outrl1F)normr\copy) rjrIrgerrstateabscorrcoefTisnanrp fill_diagonalr )rXrq tolerancerrs r/_get_abs_corr_matz"IterativeImputer._get_abs_corr_mat)s(^A&  " *d.E.S.S4 [ * * * ; ;6"+hj"9"9::L  ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; 09 RXl++,  i<@@@@ q))) DquMMM s,A//A36A3ct|jrd}nd}t||td||}t ||jt ||j}|}|jdko|j }|j t|j|j|j |j d |_ |r`tj5tjd t |j |}dddn #1swxYwYn|j |}n||r`tj5tjd t |j |}dddn #1swxYwYn|j |}|rt'j|d |_|jsZ|dd|jf}|dd|jf}|j d dkr|dd|jf}n-d|dd|jf<|}|dd|jf|dd|jf<||||fS)aPerform initial imputation for input `X`. Parameters ---------- X : ndarray of shape (n_samples, n_features) Input data, where `n_samples` is the number of samples and `n_features` is the number of features. in_fit : bool, default=False Whether function is called in :meth:`fit`. Returns ------- Xt : ndarray of shape (n_samples, n_features) Input data, where `n_samples` is the number of samples and `n_features` is the number of features. X_filled : ndarray of shape (n_samples, n_features) Input data with the most recent imputations. mask_missing_values : ndarray of shape (n_samples, n_features) Input data's missing indicator matrix, where `n_samples` is the number of samples and `n_features` is the number of features, masked by non-missing features. X_missing_mask : ndarray, shape (n_samples, n_features) Input data's mask matrix indicating missing datapoints, where `n_samples` is the number of samples and `n_features` is the number of features. z allow-nanTF)r^orderresetensure_all_finiter;N)rRstrategyrKrTdefault) transformrrr[rF)rrRrrr"rrrJrTinitial_imputer_r rK set_outputwarningscatch_warnings simplefilter FutureWarning fit_transformrrgall_is_empty_feature get_params) rXXin_fitrX_missing_maskrr catch_warningrqXts r/_initial_imputationz$IterativeImputer._initial_imputationOse> , - - % +   $    /     At2333"1d&9::,1133  !Z / P8P4P   ($1#2.?$($< %%% j9j--  ! B,..FF)(MBBB#4BB1EEHFFFFFFFFFFFFFFF 0>>qAA >,..BB)(MBBB#4>>qAAHBBBBBBBBBBBBBBB 0::1==  I%'V,?a%H%H%HD "' P111t---.B"5aaa$:P9P6P"Q $//11*=KK$AAA(>'>$>? >C 4#9 9 :B,4QQQ8N5N,OBqqq$(( )80.@@s$!5D""D&)D&5FF#&F#c t|}|Mtj|s9t||kr&td|d|dt |d|dkr tjn tj }||n|}tj|rtj||}t|ddd}|s)t |t |kr ||}|S) aValidate the limits (min/max) of the feature values. Converts scalar min/max limits to vectors of shape `(n_features,)`. Parameters ---------- limit: scalar or array-like The user-specified limit (i.e, min_value or max_value). limit_type: {'max', 'min'} Type of limit to validate. n_features: int Number of features in the dataset. is_empty_feature: ndarray, shape (n_features, ) Mask array indicating empty feature imputer has seen during fit. keep_empty_feature: bool If False, remove empty-feature indices from the limit. Returns ------- limit: ndarray, shape(n_features,) Array of limits, one for each feature. N'z_value' should be of shape (z',) when an array-like is provided. Got z , instead.maxF)rr ensure_2d)rrgisscalarrerinffullr)limit limit_typeris_empty_featurekeep_empty_feature n_features_in limit_bounds r/_validate_limitz IterativeImputer._validate_limits$4%%566  K&& U##}44GJGGMGG03E GGG  !+e 3 3bff"& $} % ;u   /GJ..EEURWXXX" -c%jjC8H4I4I&I&I++,E r1)prefer_skip_nested_validationc t||dt|dfi|}t|dt|j|_|jddlm}||_ nt|j|_ g|_ d|_ | |d\}}}}t|t|} |jdkst%j|r)d|_t|| S|jd d kr)d|_t|| S||jd |jd |j|j|_||jd |jd |j|j|_t%jt%j|j|jst?d | |} tC| |_"|#|} |j\} } |j$dkrtKd |jtM}|j'sI|(}|j)t%j*t%j+||z}tYd |jd zD]k|_|j-dkr| |} | D]m}|.| || }|/||||dd|jj0\}}tc|||}|j 2|n|j$d kr.tKd|j|jtM|z fz|j'st$j34||z t$j5d}|j$dkr#tKd6||||kr|j$dkrtKdn7|(}m|j'stoj8dtrtu|||t|| S)agFit the imputer on `X` and return the transformed `X`. Parameters ---------- X : array-like, shape (n_samples, n_features) Input data, where `n_samples` is the number of samples and `n_features` is the number of features. y : Ignored Not used, present for API consistency by convention. **params : dict Parameters routed to the `fit` method of the sub-estimator via the metadata routing API. .. versionadded:: 1.5 Only available if `sklearn.set_config(enable_metadata_routing=True)` is set. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- Xt : array-like, shape (n_samples, n_features) The imputed input data. r4roNr) BayesianRidgeTrrrminrz3One (or more) features have min_value >= max_value.0[IterativeImputer] Completing matrix with shape r@)r&rsrtD[IterativeImputer] Ending imputation round %d/%d, elapsed time %0.2f)ordr\z4[IterativeImputer] Change: {}, scaled tolerance: {} z4[IterativeImputer] Early stopping criterion reached.z8[IterativeImputer] Early stopping criterion not reached.r));rrgetattrrrEror& linear_modelrrfr imputation_sequence_rrrV_fit_indicator_transform_indicatorrGrgrn_iter__concatenate_indicatorrjrrNrrTrkrOrlgreaterrerrn_features_with_missing_rrDprintrrFrrHrrrangerLrrr4r#appendlinalgrrformatrwarnr r0)rXryrt routed_paramsrrrr complete_mask X_indicatorrr n_samplesrstart_t Xt_previousnormalized_tolr$r%r&estimator_tripletinf_normrYs r/rzIterativeImputer.fit_transforms> &$...'      % /#5d6G#H#H   > ! 4 4 4 4 4 4+mooDOO#DN33DO$&! $484L4L d5M5 5 12"M }---gg22=AA =A  (;!>"{*:T>RR>>r1c :t|||d\}}}}t|}|jdkst j|r"t||St|j |jz}d}|j dkrtd|j t}t|j D]v\} } |||| j| j| jd\}} | dz|zs<|j dkr,td|dz|jt|z fz|dz }wt'|||t||S) aImpute all missing values in `X`. Note that this is stochastic, and that if `random_state` is not fixed, repeated calls, or permuted input, results will differ. Parameters ---------- X : array-like of shape (n_samples, n_features) The input data to complete. Returns ------- Xt : array-like, shape (n_samples, n_features) The imputed input data. Frrr)r&rsrrr)rrrVrrrgrrrrrDrrjr enumeraterr$r%r&r0) rXrrrrrrimputations_per_roundi_rndritr_rYs r/rzIterativeImputer.transforms 484L4L e5M5 5 12"Mgg22=AA <1  ': ; ; 7711"kBB B #D$= > >$, N >>r1c "|j|fi||S)a5Fit the imputer on `X` and return self. Parameters ---------- X : array-like, shape (n_samples, n_features) Input data, where `n_samples` is the number of samples and `n_features` is the number of features. y : Ignored Not used, present for API consistency by convention. **fit_params : dict Parameters routed to the `fit` method of the sub-estimator via the metadata routing API. .. versionadded:: 1.5 Only available if `sklearn.set_config(enable_metadata_routing=True)` is set. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- self : object Fitted estimator. )r)rXrr fit_paramss r/r4zIterativeImputer.fits$6 1++ +++ r1ct|dt||}|j|}|||S)aGet output feature names for transformation. Parameters ---------- input_features : array-like of str or None, default=None Input features. - If `input_features` is `None`, then `feature_names_in_` is used as feature names in. If `feature_names_in_` is not defined, then the following input feature names are generated: `["x0", "x1", ..., "x(n_features_in_ - 1)"]`. - If `input_features` is an array-like, then `input_features` must match `feature_names_in_` if `feature_names_in_` is defined. Returns ------- feature_names_out : ndarray of str objects Transformed feature names. n_features_in_)rrrget_feature_names_out(_concatenate_indicator_feature_names_out)rXinput_featuresnamess r/rz&IterativeImputer.get_feature_names_outsP( .///0~FF%;;NKK<` on how the routing mechanism works. .. versionadded:: 1.5 Returns ------- routing : MetadataRouter A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating routing information. )ownerr4)calleecaller)r&method_mapping)rrY__name__addr&r)rXrouters r/get_metadata_routingz%IterativeImputer.get_metadata_routingsU dn&=>>>BBn(??..eE.JJC   r1)N)NTN)r)F)r __module__ __qualname____doc__r!rPrrrrrdict__annotations__rgnanrrWrrrrr staticmethodrr rrr4rr __classcell__)rYs@r/r3r3<sffP$  -$JJy'9::;&KXh4???@q$v6667#XXh4%O%O%OP JFFF G G & JOOO P P $HHT4fEEE|THHT4fEEE|T;'(%$$$D.&)v $6'&!%&)&)&)&)&)&)&)\y#y#y#y#v"!"!"!H&&&P$$$$LiAiAiAiAV..\.`\&+V?V?V?V?V? V?p4?4?4?4?4?l<TTTT2r1r3)2r collectionsrnumbersrrrnumpyrgscipyrbaser r exceptionsr preprocessingr utilsr rrutils._indexingr utils._maskrutils._missingrutils._param_validationrrrutils.metadata_routingrrrrutils.validationrrrrr_baser r!r"r#r0r3r1r/r!s%""""""""""""""&&&&&&&&++++++%%%%%%CCCCCCCCCC******######******FFFFFFFFFF DCCCCCCCCC*EEE (JJJJJ|JJJJJr1