:iSSKrSSKrSSKJr SSKJr SSKJr SSKr SSK J r SSK J r SSKJrJrJr SSKJr SS KJrJr SS KJrJr SS KJr SS KJr SS KJ r J!r!J"r" Sr#Sr$"SS\\5r%"SS\%5r&"SS\\5r'g)N)Counter)partial)Callable)sparse) BaseEstimatorTransformerMixin _fit_context) _get_mask) is_pandas_na is_scalar_nan) MissingValues StrOptions)_mode) _get_median) FLOAT_DTYPES_check_feature_names_incheck_is_fittedc[U5(agURRS;aN[U[R 5(d.[ SRUR[U555egg)N)fiuzn'X' and 'missing_values' types are expected to be both numerical. Got X.dtype={} and type(missing_values)={}.) r dtypekind isinstancenumbersReal ValueErrorformattype)Xmissing_valuess W/srv/projetos/modelo_ml_acdoc/venv/lib/python3.13/site-packages/sklearn/impute/_base.py_check_inputs_dtyper$s`N##ww||&z.',,/W/W ((.qww^8L(M  0X&c^URS:avUR[:XaF[U5nUR S5SSm[ U4SjUR 555nO [U5nUSSnUSSmOSnSmTS:XaUS:Xa[R$TU:aU$TU:aU$TU:Xa [ XA5$g)zCompute the most frequent value in a 1d array extended with [extra_value] * n_repeat, where extra_value is assumed to be not part of the array.rc3<># UHupUT:XdM Uv M g7fN).0valuecountmost_frequent_counts r# !_most_frequent..0s%&$3LE//$3s  N) sizerobjectr most_commonminitemsrnpnan)array extra_valuen_repeatcountermost_frequent_valuemoder.s @r#_most_frequentr>$s  zzA~ ;;& enG")"5"5a"8";A"> "%&$+MMO&#  +>?@@r%)rDrOrEr"N)__name__ __module__ __qualname____firstlineno____doc__rrFdict__annotations__r6r7rIrRrWr_rgrm__static_attributes__r*r%r#r@r@IsW )?+# ){$D!#eQV7# 00*8Ar%r@c^\rSrSr%Sr0\R E\"1Sk5\/SS/S.Er\ \ S'\ RSS S S S S .U4S jjr Sr\"S S9SSj5rU4SjrU4SjrU4SjrSrSrSSjrSrU=r$) SimpleImputeraUnivariate imputer for completing missing values with simple strategies. Replace missing values using a descriptive statistic (e.g. mean, median, or most frequent) along each column, or using a constant value. Read more in the :ref:`User Guide `. .. versionadded:: 0.20 `SimpleImputer` replaces the previous `sklearn.preprocessing.Imputer` estimator which is now removed. Parameters ---------- missing_values : int, float, str, np.nan, None or pandas.NA, 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` can be set to either `np.nan` or `pd.NA`. strategy : str or Callable, default='mean' The imputation strategy. - If "mean", then replace missing values using the mean along each column. Can only be used with numeric data. - If "median", then replace missing values using the median along each column. Can only be used with numeric data. - If "most_frequent", then replace missing using the most frequent value along each column. Can be used with strings or numeric data. If there is more than one such value, only the smallest is returned. - If "constant", then replace missing values with fill_value. Can be used with strings or numeric data. - If an instance of Callable, then replace missing values using the scalar statistic returned by running the callable over a dense 1d array containing non-missing values of each column. .. versionadded:: 0.20 strategy="constant" for fixed value imputation. .. versionadded:: 1.5 strategy=callable for custom value imputation. 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. copy : bool, default=True If True, a copy of X will be created. If False, imputation will be done in-place whenever possible. Note that, in the following cases, a new copy will always be made, even if `copy=False`: - If `X` is not an array of floating values; - If `X` is encoded as a CSR matrix; - If `add_indicator=True`. 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 `strategy="constant"` in which case `fill_value` will be used instead. .. versionadded:: 1.2 Attributes ---------- statistics_ : array of shape (n_features,) The imputation fill value for each feature. Computing statistics can result in `np.nan` values. During :meth:`transform`, features corresponding to `np.nan` statistics will be discarded. indicator_ : :class:`~sklearn.impute.MissingIndicator` Indicator used to add binary indicators for missing values. `None` if `add_indicator=False`. 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 See Also -------- IterativeImputer : Multivariate imputer that estimates values to impute for each feature with missing values from all the others. KNNImputer : Multivariate imputer that estimates missing features using nearest samples. Notes ----- Columns which only contained missing values at :meth:`fit` are discarded upon :meth:`transform` if strategy is not `"constant"`. In a prediction context, simple imputation usually performs poorly when associated with a weak learner. However, with a powerful learner, it can lead to as good or better performance than complex imputation such as :class:`~sklearn.impute.IterativeImputer` or :class:`~sklearn.impute.KNNImputer`. Examples -------- >>> import numpy as np >>> from sklearn.impute import SimpleImputer >>> imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean') >>> imp_mean.fit([[7, 2, 3], [4, np.nan, 6], [10, 5, 9]]) SimpleImputer() >>> X = [[np.nan, 2, 3], [4, np.nan, 6], [10, np.nan, 9]] >>> print(imp_mean.transform(X)) [[ 7. 2. 3. ] [ 4. 3.5 6. ] [10. 3.5 9. ]] For a more detailed example see :ref:`sphx_glr_auto_examples_impute_plot_missing_values.py`. >meanmedianconstant most_frequent no_validationrB)strategy fill_valuecopyrFrzNTF)r"rrrrDrEcH>[TU]UUUS9 X lX0lX@lg)NrC)superrIrrr)rHr"rrrrDrE __class__s r#rISimpleImputer.__init__ s1 )' 3  ! $ r%c *URS;a6[U[5(a[SU55(a[nO SnO[ nU(d&UR RS:Xa UR n[UR5(d[UR5(aSnOSnURUUSUU(dSOSUURS9nU(aUR Ul[#XR5 UR RS ;a$[S RUR 55e[$R&"U5(aURS :Xa [S 5eURS:XaU(aFUR(b9[+UR(5nSUR(<SU<SUR <S3nO?U(d,UR,R nSU<SUR <S3nO UR n[.R0"XqR SS9(d [W5eU$![a>nS[U5;a([S RURU55nUSeUeSnAff=f)N)r}r|c3T# UHoHn[U[5v M M g7fr))rstr)r+rowelems r#r/0SimpleImputer._validate_input..9s&+12#st 4%%s%s&(O allow-nanTcsc)reset accept_sparserforce_writeableforce_all_finiterzcould not convertz0Cannot use {} strategy with non-numeric data: {}rrrrzSimpleImputer does not support data with dtype {0}. Please provide either a numeric array (with a floating point or integer dtype) or categorical data represented either as an array with integer dtype or an array of string values with an object dtype.rdImputation not possible when missing_values == 0 and input is sparse. Provide a dense array instead.r|z fill_value=z (of type z+) cannot be cast to the input data that is z2. Make sure that both dtypes are of the same kind.z%The dtype of the filling value (i.e. z\. Make sure that the dtypes of the input data is of the same kind between fit and transform. same_kind)casting)rrlistanyr2r _fit_dtyperr r"r _validate_datarrrrrr$rZr[rr statistics_r6can_cast) rHr!in_fitrrvenew_vefill_value_dtypeerr_msgs r#_validate_inputSimpleImputer._validate_input3sf ==9 9 !T""s+12+(( E$//..#5OOE ++ , , d>Q>Q0R0R* #  ###,2!1YY$A( ggDOA223 77<<3 3( )/qww   ;;q>>d11Q6!  ==J &$//5#'#8 !$//!4J?O>RS@@A{K== #'#3#3#9#9 ;>#//==$"5"5z D  $==$"5"5z D  r%c>[X5nURnURS[R"UR 5- n[R "URS5nUS:XaURU5 GO[[URS5GH>n URUR U UR U S-n XaR U UR U S-n X)n [U S5n X)n U R5n XyU -n[U 5S:XaUR(aSX'MUS:Xa<U RU-nUS:Xa[ROU R5U- X'MUS:Xa[X5X'MUS:Xa[U SU5X'GM[!U["5(dGM+UR%U 5X'GMA [&TU]QU5 U$)z#Fit the transformer on sparse data.rr'r|rzr{r})r datashaper6diffindptremptyfillrangesumlenrEr1r7rr>rrrrrR)rHr!rr"r missing_mask mask_datan_implicit_zeros statisticsrcolumn mask_column mask_zerosn_explicit_zerosn_zerossrs r#rSimpleImputer._sparse_fits 3  %% 771:(99XXaggaj) z ! OOJ '1771:& ahhq1uo>' ahhq1uoF  -'vq1  ,#->>#3 *-0@@v;!#(@(@$%JM6)"KK'123q&fjjlQ>N !X-(3F(D !_4(6vq'(J #Hh77(, f(= 5'8 |,r%c2>[X5n[R"XS9n[TU]U5 US:Xa[ RR USS9n[ RRU5nUR(aSO[ RU[ RRU5'U$US:Xa[ RRUSS9n [ RRU 5n UR(aSO[ RU [ RRU 5'U $US:XGaUR5nUR5n URRS:Xa'[ R "UR"S[$S9n O#[ R "UR"S5n ['[)US S U S S 55Hxun up[ R*"U5R-[.5nXn[1U5S:XaUR(aSX'M[[3U[ RS5X'Mz U $US :Xa,[ R4"UR"S XARS9$[7U[85(am[ R "UR"S 5n[;UR"S 5H,n UR=US S 2U 4R?55UU 'M. U$g ) z"Fit the transformer on dense data.)maskrzraxisr{r}rrNr|r') r ma masked_arrayrrRr6rzgetdatarEr7getmaskr{ getmaskarray transposerrrrr2 enumeratezip logical_notastypeboolrr>fullrrrr compressed)rHr!rr"rrmasked_X mean_maskedrz median_maskedr{rr}rrrow_maskrrs r#rSimpleImputer._dense_fits` 3 ??18 |, v %%**XA*6K55==-D484L4LqRTRXRXD{+ ,K !EELLL:MUU]]=1F--266 255%%m4 5M (  A))+Dww||s" "6 B " 4 &/AaD$q'0B&C"?C>>(3::4@ms8q=T%=%='(M$'5c2661'EM$ 'D!  #771771:zA A( + +(.."34J8>>!,- $ hq!tn.G.G.I J 1 .  ,r%c>[U5 URUSS9nURnURSURS:wa4[ SURSURRS4-5e[ XR 5nURS:XdUR(aUnSnO[ U[R5n[R"U5nX'n[R"U5nUR5(av[R"URS5Un[US5(aUR Un["R$"S US URS 35 USS2U4n[&R("U5(aUR S:Xa [ S 5eUc UR*n O [ UR*UR 5n [R,"[R"[/UR05S- [2S 9[R4"UR055U n XJR7UR8SS9UR*U 'OhUcUn O USS2U4n [R:"U SS9n [R,"XL5n [R<"U R?55SSS2nXU'[@TU]U5n[@TU]X5$)a Impute all missing values in `X`. Parameters ---------- X : {array-like, sparse matrix}, shape (n_samples, n_features) The input data to complete. Returns ------- X_imputed : {ndarray, sparse matrix} of shape (n_samples, n_features_out) `X` with imputed values. Frr'rz)X has %d features per sample, expected %dr|Nfeature_names_in_z/Skipping features without any observed values: zI. At least one non-missing value is needed for imputation with strategy='z'.rr)rr)#rrrrrr r"rrEr6r7r flatnonzerorarangerUrwarningswarnrZr[rrepeatrrintrrrrwhererrrWr_)rHr!rrvalid_statisticsvalid_statistics_indexes invalid_mask valid_maskinvalid_featuresrindexesmask_valid_features n_missingvalues coordinatesr^rs r#rVSimpleImputer.transform*s   5 1%% 771:))!, ,;771:t//55a89:  !$7$78  ==J &$*B*B) '+ $%Z8L 5J)5 ')~~j'A $!!#%99QWWQZ#8#F 4!455'+'='=>N'O$ ()*66:mm_BH a112 ;;q>>""a' %,3',,D$QVVT-@-@AD))IIc!((ma/s;RWWQXX=N 08??e?Tt (/&2#&216N3N&O#2;IYY/;F((#6#@#@#BCDbDIK#kNg2<@ w-a==r%c6[U5 UR(d[SURS35e[URR 5nUR SU- nUSS2SU24R5nUSS2US24R[5n[UR5nUR SU4n[R"U5nXXSS2URR 4'UR[5n SupU [UR5:ac[R"USS2U 45(d!URU USS2U 4'U S- n U S- n OU S- n U [UR5:aMcURX'U$)aConvert the data back to the original representation. Inverts the `transform` operation performed on an array. This operation can only be performed after :class:`SimpleImputer` is instantiated with `add_indicator=True`. Note that `inverse_transform` can only invert the transform in features that have binary indicators for missing values. If a feature has no missing values at `fit` time, the feature won't have a binary indicator, and the imputation done at `transform` time won't be inverted. .. versionadded:: 0.24 Parameters ---------- X : array-like of shape (n_samples, n_features + n_features_missing_indicator) The imputed data to be reverted to original data. It has to be an augmented array of imputed data and the missing indicator mask. Returns ------- X_original : ndarray of shape (n_samples, n_features) The original `X` with missing values as it was prior to imputation. zr'inverse_transform' works only when 'SimpleImputer' is instantiated with 'add_indicator=True'. Got 'add_indicator=z ' instead.r'Nr)rr)rrDrrrO features_rrrrrr6zerosTallr") rHr!n_features_missingnon_empty_feature_count array_imputedrn_features_originalshape_original X_original full_mask imputed_idx original_idxs r#inverse_transformSimpleImputer.inverse_transforms8 !!&'+&8&8%9: !!:!:;"#''!*/A"A!55556;;= 3445<>)D4D4Dbff*MN0<n<| TTr%rxc\rSrSr%Sr\"5/\"SS15/S\"S15/S/S.r\\ S'\ RSSS S.S jr S r S rSSjr\"S S9SSj5rSr\"S S9SSj5rSSjrSrSrg )rNia Binary indicators for missing values. Note that this component typically should not be used in a vanilla :class:`~sklearn.pipeline.Pipeline` consisting of transformers and a classifier, but rather could be added using a :class:`~sklearn.pipeline.FeatureUnion` or :class:`~sklearn.compose.ColumnTransformer`. Read more in the :ref:`User Guide `. .. versionadded:: 0.20 Parameters ---------- missing_values : int, float, str, np.nan or None, 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`. features : {'missing-only', 'all'}, default='missing-only' Whether the imputer mask should represent all or a subset of features. - If `'missing-only'` (default), the imputer mask will only represent features containing missing values during fit time. - If `'all'`, the imputer mask will represent all features. sparse : bool or 'auto', default='auto' Whether the imputer mask format should be sparse or dense. - If `'auto'` (default), the imputer mask will be of same type as input. - If `True`, the imputer mask will be a sparse matrix. - If `False`, the imputer mask will be a numpy array. error_on_new : bool, default=True If `True`, :meth:`transform` will raise an error when there are features with missing values that have no missing values in :meth:`fit`. This is applicable only when `features='missing-only'`. Attributes ---------- features_ : ndarray of shape (n_missing_features,) or (n_features,) The features indices which will be returned when calling :meth:`transform`. They are computed during :meth:`fit`. If `features='all'`, `features_` is equal to `range(n_features)`. 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 See Also -------- SimpleImputer : Univariate imputation of missing values. IterativeImputer : Multivariate imputation of missing values. Examples -------- >>> import numpy as np >>> from sklearn.impute import MissingIndicator >>> X1 = np.array([[np.nan, 1, 3], ... [4, 0, np.nan], ... [8, 1, 0]]) >>> X2 = np.array([[5, 1, np.nan], ... [np.nan, 2, 3], ... [2, 4, 0]]) >>> indicator = MissingIndicator() >>> indicator.fit(X1) MissingIndicator() >>> X2_tr = indicator.transform(X2) >>> X2_tr array([[False, True], [ True, False], [False, False]]) missing-onlyrrBautor"featuresrrLrFTc4XlX lX0lX@lgr)r )rHr"r rrLs r#rIMissingIndicator.__init__<s-  (r%cUR(d[XR5nOUn[R"U5(apUR 5 UR S:XaURSS9nURSLaUR5nOURS:XaUR5nOmUR(d[XR5nOUnUR S:XaURSS9nURSLa[R"U5nUR S:Xa&[R"UR S5nX$4$[R""W5nX$4$) a8Compute the imputer mask and the indices of the features containing missing values. Parameters ---------- X : {ndarray, sparse matrix} of shape (n_samples, n_features) The input data with missing values. Note that `X` has been checked in :meth:`fit` and :meth:`transform` before to call this function. Returns ------- imputer_mask : {ndarray, sparse matrix} of shape (n_samples, n_features) The imputer mask of the original data. features_with_missing : ndarray of shape (n_features_with_missing) The features containing missing values. r rrFcsrTrr') _precomputedr r"rZr[eliminate_zerosr getnnzrtoarrayrtocscr csc_matrixr6rrr)rHr! imputer_maskrfeatures_indicess r#_get_missing_features_info+MissingIndicator._get_missing_features_infoIs0(  $Q(;(;>  ( ( *}}.(//Q/7 {{e#+335 $$-+113 $$(,?,?@  }}.(,,!,4 {{d"!}}\: ==E !!yy4 -- "~~i8 --r%c|[UR5(dSnOSnURUUSSUS9n[XR5 URR S;a$[ SRUR55e[R"U5(aURS:Xa [ S5eU$) NTr)rr)rrrrrzMissingIndicator does not support data with dtype {0}. Please provide either a numeric array (with a floating point or integer dtype) or categorical data represented either as an array with integer dtype or an array of string values with an object dtype.rzSSparse input with missing_values=0 is not supported. Provide a dense array instead.) r r"rr$rrrrrZr[)rHr!rrs r#r MissingIndicator._validate_inputsT0011# *     (-   A223 77<<3 3( )/qww   ;;q>>d11Q6!  r%NcfU(a>[US5(aURRS:Xd [S5eSUlOSUlUR(dUR USS9nOUR USS9 URSUlURU5nUSUl US $) aFit the transformer on `X`. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Input data, where `n_samples` is the number of samples and `n_features` is the number of features. If `precomputed=True`, then `X` is a mask of the input data. precomputed : bool Whether the input data is a mask. Returns ------- imputer_mask : {ndarray, sparse matrix} of shape (n_samples, n_features) The imputer mask of the original data. rb4precomputed is True but the input data is not a maskTFr)rr'r) rUrrrrr_check_n_featuresr _n_featuresrr)rHr!rrMmissing_features_infos r#rPMissingIndicator._fits& Aw''AGGLLC,? !WXX $D  %D   $$Qt$4A  " "1D " 1771: $ ? ? B.q1$Q''r%rc(URX5 U$)aZFit the transformer on `X`. Parameters ---------- X : {array-like, sparse matrix} of 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. Returns ------- self : object Fitted estimator. )rP)rHr!rs r#rMissingIndicator.fits$ ! r%c6[U5 UR(dURUSS9nO6[US5(aURR S:Xd [ S5eURU5up#URS:Xa[R"X0R5nUR(a*URS:a[ SRU55eURRUR:aUS S 2UR4nU$) axGenerate missing values indicator for `X`. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) The input data to complete. Returns ------- Xt : {ndarray, sparse matrix} of shape (n_samples, n_features) or (n_samples, n_features_with_missing) The missing indicator for input data. The data type of `Xt` will be boolean. Frrrrr rzSThe features {} have missing values in transform but have no missing values in fit.N)rrrrUrrrrr r6 setdiff1drrLr1rr!)rHr!rr features_diff_fit_transs r#rVMissingIndicator.transforms   $$Qu$5AAw''AGGLLC,? !WXX!%!@!@!C ==N *&(ll8^^&L #  %<%A%AA%E $f%<= ~~""T%5%55+At~~,=> r%cURX5nURRUR:aUSS2UR4nU$)aGenerate missing values indicator for `X`. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) The input data to complete. y : Ignored Not used, present for API consistency by convention. Returns ------- Xt : {ndarray, sparse matrix} of shape (n_samples, n_features) or (n_samples, n_features_with_missing) The missing indicator for input data. The data type of `Xt` will be boolean. N)rPrr1r!)rHr!rrs r# fit_transformMissingIndicator.fit_transform sB&yy >>  !1!1 1'4>>(9:Lr%c[US5 [X5nURRR 5n[ R "XRVs/sH nUSU3PM sn[S9$s snf)rr_r) rrrrolowerr6asarrayrr2)rHreprefix feature_names r#rb&MissingIndicator.get_feature_names_out#s{( ./0F((..0zz%3>>$B $BL(!L>*$B     sA7cSSS//S.$)NT2darraystring)rkX_typespreserves_dtyper*rls r#rmMissingIndicator._more_tagsBs!8,!  r%)r!rrLr rr"r)NFr))rorprqrrrsrrrFrtrur6r7rIrrrPr rrVr+rbrmrvr*r%r#rNrNsRj)?+ 789j&23" $Dvv )4.l D'(R56*'R562 > r%rN)(rr collectionsr functoolsrtypingrnumpyr6numpy.marscipyrrZbaserr r utils._maskr utils._missingr r utils._param_validationrr utils.fixesrutils.sparsefuncsrutils.validationrrrr$r>r@rxrNr*r%r#rGs{ @@#8?+UU  "5JGA#]GATJ TLJ TZg 'g r%