MpjOSSKrSSKJr SSKrSSKJrJrJr SSK J r SSK J r SSK JrJrJr SSKJr SSKJrJrJrJrJr "S S \\5rg) N)Integral) BaseEstimatorTransformerMixin _fit_context) OneHotEncoder)resample)IntervalOptions StrOptions)_weighted_percentile)_check_feature_names_in_check_sample_weight check_arraycheck_is_fitted validate_datac (\rSrSr%Sr\"\SSSS9S/\"1Sk5/\"1S k5/\"1S k5/\"\ \ R\ R15S/\"\S SSS9S/S /S .r \\S'SSSSSSSS.Sjjr\"SS9SSj5rSrSrSrSSjrSrg) KBinsDiscretizera Bin continuous data into intervals. Read more in the :ref:`User Guide `. .. versionadded:: 0.20 Parameters ---------- n_bins : int or array-like of shape (n_features,), default=5 The number of bins to produce. Raises ValueError if ``n_bins < 2``. encode : {'onehot', 'onehot-dense', 'ordinal'}, default='onehot' Method used to encode the transformed result. - 'onehot': Encode the transformed result with one-hot encoding and return a sparse matrix. Ignored features are always stacked to the right. - 'onehot-dense': Encode the transformed result with one-hot encoding and return a dense array. Ignored features are always stacked to the right. - 'ordinal': Return the bin identifier encoded as an integer value. strategy : {'uniform', 'quantile', 'kmeans'}, default='quantile' Strategy used to define the widths of the bins. - 'uniform': All bins in each feature have identical widths. - 'quantile': All bins in each feature have the same number of points. - 'kmeans': Values in each bin have the same nearest center of a 1D k-means cluster. For an example of the different strategies see: :ref:`sphx_glr_auto_examples_preprocessing_plot_discretization_strategies.py`. quantile_method : {"inverted_cdf", "averaged_inverted_cdf", "closest_observation", "interpolated_inverted_cdf", "hazen", "weibull", "linear", "median_unbiased", "normal_unbiased"}, default="averaged_inverted_cdf" Method to pass on to np.percentile calculation when using strategy="quantile". Only `averaged_inverted_cdf` and `inverted_cdf` support the use of `sample_weight != None` when subsampling is not active. .. versionadded:: 1.7 .. versionchanged:: 1.9 The default value changed from `"linear"` to `"averaged_inverted_cdf"`. dtype : {np.float32, np.float64}, default=None The desired data-type for the output. If None, output dtype is consistent with input dtype. Only np.float32 and np.float64 are supported. .. versionadded:: 0.24 subsample : int or None, default=200_000 Maximum number of samples, used to fit the model, for computational efficiency. `subsample=None` means that all the training samples are used when computing the quantiles that determine the binning thresholds. Since quantile computation relies on sorting each column of `X` and that sorting has an `n log(n)` time complexity, it is recommended to use subsampling on datasets with a very large number of samples. .. versionchanged:: 1.3 The default value of `subsample` changed from `None` to `200_000` when `strategy="quantile"`. .. versionchanged:: 1.5 The default value of `subsample` changed from `None` to `200_000` when `strategy="uniform"` or `strategy="kmeans"`. random_state : int, RandomState instance or None, default=None Determines random number generation for subsampling. Pass an int for reproducible results across multiple function calls. See the `subsample` parameter for more details. See :term:`Glossary `. .. versionadded:: 1.1 Attributes ---------- bin_edges_ : ndarray of ndarray of shape (n_features,) The edges of each bin. Contain arrays of varying shapes ``(n_bins_, )`` Ignored features will have empty arrays. n_bins_ : ndarray of shape (n_features,), dtype=np.int64 Number of bins per feature. Bins whose width are too small (i.e., <= 1e-8) are removed with a warning. 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 -------- Binarizer : Class used to bin values as ``0`` or ``1`` based on a parameter ``threshold``. Notes ----- For a visualization of discretization on different datasets refer to :ref:`sphx_glr_auto_examples_preprocessing_plot_discretization_classification.py`. On the effect of discretization on linear models see: :ref:`sphx_glr_auto_examples_preprocessing_plot_discretization.py`. In bin edges for feature ``i``, the first and last values are used only for ``inverse_transform``. During transform, bin edges are extended to:: np.concatenate([-np.inf, bin_edges_[i][1:-1], np.inf]) You can combine ``KBinsDiscretizer`` with :class:`~sklearn.compose.ColumnTransformer` if you only want to preprocess part of the features. ``KBinsDiscretizer`` might produce constant features (e.g., when ``encode = 'onehot'`` and certain bins do not contain any data). These features can be removed with feature selection algorithms (e.g., :class:`~sklearn.feature_selection.VarianceThreshold`). Examples -------- >>> from sklearn.preprocessing import KBinsDiscretizer >>> X = [[-2, 1, -4, -1], ... [-1, 2, -3, -0.5], ... [ 0, 3, -2, 0.5], ... [ 1, 4, -1, 2]] >>> est = KBinsDiscretizer( ... n_bins=3, encode='ordinal', strategy='uniform' ... ) >>> est.fit(X) KBinsDiscretizer(...) >>> Xt = est.transform(X) >>> Xt # doctest: +SKIP array([[ 0., 0., 0., 0.], [ 1., 1., 1., 0.], [ 2., 2., 2., 1.], [ 2., 2., 2., 2.]]) Sometimes it may be useful to convert the data back into the original feature space. The ``inverse_transform`` function converts the binned data into the original feature space. Each value will be equal to the mean of the two bin edges. >>> est.bin_edges_[0] array([-2., -1., 0., 1.]) >>> est.inverse_transform(Xt) array([[-1.5, 1.5, -3.5, -0.5], [-0.5, 2.5, -2.5, -0.5], [ 0.5, 3.5, -1.5, 0.5], [ 0.5, 3.5, -1.5, 1.5]]) While this preprocessing step can be an optimization, it is important to note the array returned by ``inverse_transform`` will have an internal type of ``np.float64`` or ``np.float32``, denoted by the ``dtype`` input argument. This can drastically increase the memory usage of the array. See the :ref:`sphx_glr_auto_examples_cluster_plot_face_compress.py` where `KBinsDescretizer` is used to cluster the image into bins and increases the size of the image by 8x. Nleft)closedz array-like>onehotordinal onehot-dense>kmeansuniformquantile> hazenlinearweibull inverted_cdfmedian_unbiasednormal_unbiasedclosest_observationaveraged_inverted_cdfinterpolated_inverted_cdf random_staten_binsencodestrategyquantile_methoddtype subsampler(_parameter_constraintsrrr%i@ )r+r,r-r.r/r(cXXlX lX0lX@lXPlX`lXplgNr))selfr*r+r,r-r.r/r(s a/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/sklearn/preprocessing/_discretization.py__init__KBinsDiscretizer.__init__s)   . "(T)prefer_skip_nested_validationc( [XSS9nUR[R[R4;a URnO URnUR upVUb[ X1URS9nURb2XPR:a#[USURURUS9nSnUR SnURU5n[R"U[S9nURn URS:XaU S;aUb[S U S 35eURS:wa UbUS :gn O [!S5n [#U5GHn USS2U 4n XR%5n XR'5nX:XaV[(R*"S U -5 SX{'[R,"[R.*[R./5X'MURS :Xa [R0"XX{S-5X'GOFURS:Xa[R0"S SX{S-5n0nU S:waUcU US'Uc;[R2"[R4"X40UD6[RS9X'OU S:XaSOSn[7XUUS9X'OURS:XaS SKJn [R0"XX{S-5nUSSUSS-SS2S4S-nU"X{USS9nUR=U SS2S4US9R>SS2S 4nURA5 USSUSS-S-X'[RBXU U4X'URS;dGM[RD"X[R.S9S:nXUX'[GX5S- X{:wdGM_[(R*"SU -5 [GX5S- X{'GM Xl$Xpl%SURL;a[OURJVs/sHn[RP"U5PM snURLS:HUS9Ul)URRR=[R"S[GURJ5455 U$s snf) a Fit the estimator. Parameters ---------- X : array-like of shape (n_samples, n_features) Data to be discretized. y : None Ignored. This parameter exists only for compatibility with :class:`~sklearn.pipeline.Pipeline`. sample_weight : ndarray of shape (n_samples,) Contains weight values to be associated with each sample. .. versionadded:: 1.3 .. versionchanged:: 1.7 Added support for strategy="uniform". Returns ------- self : object Returns the instance itself. numericr.NT)replace n_samplesr( sample_weightr'r)r!r%zWhen fitting with strategy='quantile' and sample weights, quantile_method should either be set to 'averaged_inverted_cdf' or 'inverted_cdf', got quantile_method='z ' instead.rz3Feature %d is constant and will be replaced with 0.rdrmethodr%F)averager)KMeans?) n_clustersinitn_init)r>)rr)to_beging:0yE>zqBins whose width are too small (i.e., <= 1e-8) in feature %d are removed. Consider decreasing the number of bins.r) categories sparse_outputr.)*rr.npfloat64float32shaperr/rr(_validate_n_binszerosobjectr-r, ValueErrorslicerangeminmaxwarningswarnarrayinflinspaceasarray percentiler sklearn.clusterrBfitcluster_centers_sortr_ediff1dlen bin_edges_n_bins_r+rarange_encoder)r3Xyr> output_dtyper= n_featuresr* bin_edgesr-nnz_weight_maskjjcolumncol_mincol_maxpercentile_levelspercentile_kwargsrArB uniform_edgesrFkmcentersmaskis r4r_KBinsDiscretizer.fitsY6 $ 3 ::"**bjj1 1::L77L !  $0QM >> %)nn*D..!..+ A!MWWQZ &&z2HHZv6 .. MMZ ''PP)88G7H T  ==J &=+D,q0O$DkO #Bq"uXF-113G-113G! IBN "266'266): ; }} ) " Gfj1n M *,$&KK3 Q$G! %'!"h.=3H2A%h/ ($&JJ fUCTU jj%IM !03J JPU%9/@'%IM(*2!# Gfj1n M %ab)M#2,>>4H3NvzQG&&1d7O=!""1a4) !(ws|!;s B "g}g&E F }} 66zz)-"&&ADH ) d 3 y}%)VZ7MM9;=> "%Y]!3a!7FJC$F$ t{{ ")26,,?,QBIIaL,?"kkX5"DM MM  bhh3t||+<'=> ? @s RcURn[U[5(a[R"X[ S9$[ U[ SSS9nURS:dURSU:wa [S5eUS:X2:g-n[R"U5SnURSS:aAS RS U55n[S R[RU55eU$) z0Returns n_bins_, the number of bins per feature.r;TF)r.copy ensure_2dr'rz8n_bins must be a scalar or array of shape (n_features,).rz, c38# UHn[U5v M g7fr2)str).0rys r4 4KBinsDiscretizer._validate_n_bins..sB0A1A0Aszk{} received an invalid number of bins at indices {}. Number of bins must be at least 2, and must be an int.)r* isinstancerrKfullintrndimrNrRwherejoinformatr__name__)r3rl orig_binsr*bad_nbins_valueviolating_indicesindicess r4rO!KBinsDiscretizer._validate_n_binssKK i * *77:< <YcN ;;?fll1o;WX X!A:&*=>HH_5a8  " "1 % )iiB0ABBG::@&$--w;  r7cz[U5 URc [R[R4O URn[ XSUSS9nUR n[URS5H,n[R"XESSUSS2U4SS9USS2U4'M. URS :XaU$SnS UR;a1URRnURURlURRU5nX`RlU$!X`Rlf=f) a3 Discretize the data. Parameters ---------- X : array-like of shape (n_samples, n_features) Data to be discretized. Returns ------- Xt : {ndarray, sparse matrix}, dtype={np.float32, np.float64} Data in the binned space. Will be a sparse matrix if `self.encode='onehot'` and ndarray otherwise. NTF)r|r.resetr'rCright)siderr) rr.rKrLrMrrerTrN searchsortedr+rh transform)r3rir.Xtrmro dtype_initXt_encs r4rKBinsDiscretizer.transforms -1JJ,>RZZ(DJJ 4U% HOO  $B a(;R2YWUBq"uI% ;;) #I t{{ ",,J"$((DMM  -]],,R0F#-MM  #-MM s ;D((D:c&[U5 SUR;aURRU5n[ US[ R [ R4S9nURRSnURSU:wa'[SRX2RS55e[U5HOnURUnUSSUSS-S -nXbSS2U4R[ R5USS2U4'MQ U$) az Transform discretized data back to original feature space. Note that this function does not regenerate the original data due to discretization rounding. Parameters ---------- X : array-like of shape (n_samples, n_features) Transformed data in the binned space. Returns ------- X_original : ndarray, dtype={np.float32, np.float64} Data in the original feature space. rT)r|r.rr'z8Incorrect number of features. Expecting {}, received {}.NrCrD)rr+rhinverse_transformrrKrLrMrfrNrRrrTreastypeint64)r3riXinvrlrorm bin_centerss r4r"KBinsDiscretizer.inverse_transforms$  t{{ " //2A14 BJJ/GH\\''* ::a=J &JQQ 1    #B+I$QR=9Sb>9S@K%ArE{&:&:288&DEDBK$  r7c[US5 [X5n[US5(aURR U5$U$)a\Get output feature names. 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_rh)rr hasattrrhget_feature_names_out)r3input_featuress r4r&KBinsDiscretizer.get_feature_names_outsC( ./0F 4 $ $==66~F Fr7) rhrer.r+r*rfr-r(r,r/))NNr2)r __module__ __qualname____firstlineno____doc__r rr r typerKrLrMr0dict__annotations__r5rr_rOrrr__static_attributes__r7r4rrshVHaf=|LCDE ABC    $RZZ 894@xD@$G'(+$D4)/)&5f6fP2%N%Nr7r)rWnumbersrnumpyrK sklearn.baserrrsklearn.preprocessing._encodersr sklearn.utilsrsklearn.utils._param_validationr r r sklearn.utils.statsr sklearn.utils.validationr rrrrrrr7r4rs@ FF9"II4@'@r7