h$,fCddlZddlmZddlZddlmZmZmZddl m Z ddl m Z m Z mZmZddlmZddlmZmZmZmZmZd d lmZGd d eeZy) N)Integral) BaseEstimatorTransformerMixin _fit_context)_safe_indexing)HiddenIntervalOptions StrOptions)_weighted_percentile)_check_feature_names_in_check_sample_weight check_arraycheck_is_fittedcheck_random_state) OneHotEncoderc 0eZdZUdZeeddddgehdgehdgeee je jhdgeed ddde ed hgd gd Z eed < ddddd dddZedddZdZdZdZddZy)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`. 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='warn' Maximum number of samples, used to fit the model, for computational efficiency. Defaults to 200_000 when `strategy='quantile'` and to `None` when `strategy='uniform'` or `strategy='kmeans'`. `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', subsample=None ... ) >>> 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]]) rNleft)closedz array-like> onehot-denseonehotordinal>kmeansuniformquantilerwarn random_staten_binsencodestrategydtype subsampler _parameter_constraintsrr)r#r$r%r&r cX||_||_||_||_||_||_yNr!)selfr"r#r$r%r&r s Elib/python3.12/site-packages/sklearn/preprocessing/_discretization.py__init__zKBinsDiscretizer.__init__s/     "(T)prefer_skip_nested_validationc  |j|d}|jtjtjfvr |j}n |j}|j \}}|(|j dk(rtd|j d|j dvr)|jdk(rtjd t|j}|dk(r|j d k(rd nd}|:||kDr5t|j}|j||d } t|| }|j d}|j!|} |t#|||j}tj$|t&} t)|D]} |dd| f} | j+| j-}}||k(rUtjd| zd| | <tj.tj0 tj0g| | <|j dk(r"tj2||| | dz| | <nZ|j d k(rtj2dd| | dz}|-tj4tj6| || | <ntj4|Dcgc]}t9| ||c}tj| | <n|j dk(rddlm}tj2||| | dz}|dd|ddzdddfdz}|| | |d}|j?| dddf|j@dddf}|jC|dd|ddzdz| | <tjD|| | |f| | <|j dvs"tjF| | tj0dkD}| | || | <tI| | dz | | k7sqtjd| ztI| | dz | | <| |_%| |_&d|jNvrtQ|jLDcgc]}tjR|c}|jNdk(||_*|jTj?tj$dtI|jLf|Scc}wcc}w)as 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. Only possible when `strategy` is set to `"quantile"`. .. versionadded:: 1.3 Returns ------- self : object Returns the instance itself. numericr%NrzY`sample_weight` was provided but it cannot be used with strategy='uniform'. Got strategy=z instead.)rrrzIn version 1.5 onwards, subsample=200_000 will be used by default. Set subsample explicitly to silence this warning in the mean time. Set subsample=None to disable subsampling explicitly.ri@ F)sizereplacerz3Feature %d is constant and will be replaced with 0.rdrr)KMeans?) n_clustersinitn_init) sample_weight)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%)+_validate_datar%npfloat64float32shaper$ ValueErrorr&warningsr FutureWarningrr choicer_validate_n_binsrzerosobjectrangeminmaxarrayinflinspaceasarray percentiler clusterr5fitcluster_centers_sortr_ediff1dlen bin_edges_n_bins_r#rarange_encoder)r*Xyr; output_dtype n_samples n_featuresr&rng subsample_idxr" bin_edgesjjcolumncol_mincol_max quantilesqr5 uniform_edgesr9kmcentersmaskis r+rTzKBinsDiscretizer.fits2     3 ::"**bjj1 1::L77L ! :  $))C>==#9.  ==1 1dnn6N MMH  NN  "&--:"=4I  Y%:$T%6%67CJJyy%JPMq-0AWWQZ &&z2  $0QMHHZv6  #6 8Bq"uXF%zz|VZZ\WG'! IBNr "266'266): ; " }} ) " GWfRj1n M " *,KK3r Q?  ($&JJr}}VY/O$PIbM$&JJ&/ !1J!jj %IbM(*,!# GWfRj1n M %ab)M#2,>>4H3NvbzQG&&1d7O=!""1a4) !(ws|!;s B " "gy}g&E F " }} 66zz)B-"&&ADH )" d 3 " y}%)VBZ7MM9;=> "%Yr]!3a!7F2Jm6 8p$ t{{ ")26,,?QBIIaL?"kkX5"DM MM  bhh3t||+<'=> ? aP@s /S Sc|j}t|trtj||t St |t dd}|jdkDs|jd|k7r td|dk||k7z}tj|d}|jddkDrAd jd |D}td jtj||S) z0Returns n_bins_, the number of bins per feature.r1TF)r%copy ensure_2drrz8n_bins must be a scalar or array of shape (n_features,).rz, c32K|]}t|ywr))str).0rps r+ z4KBinsDiscretizer._validate_n_bins..gsB1ABszk{} received an invalid number of bins at indices {}. Number of bins must be at least 2, and must be an int.)r" isinstancerr@fullintrndimrCrDwherejoinformatr__name__)r*rb orig_binsr"bad_nbins_valueviolating_indicesindicess r+rHz!KBinsDiscretizer._validate_n_binsXsKK i *77:y< <YcN ;;?fll1o;WX X!A:&I*=>HH_5a8  " "1 % )iiB0ABBG::@&$--w;  r-ct||j tjtjfn |j}|j |d|d}|j }t|jdD].}tj||dd|dd|fd|dd|f<0|jd k(r|Sd}d |jvr1|jj}|j|j_ |jj|}||j_|S#||j_wxYw) a 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)rrr%resetrr6right)siderr) rr%r@rArBr?rZrKrC searchsortedr#r] transform)r*r^r%Xtrerf dtype_initXt_encs r+rzKBinsDiscretizer.transformqs -1JJ,>RZZ(DJJ  U% HOO  $ VB " a(;R2YWUBq"uI V ;;) #I t{{ ",,J"$((DMM  -]],,R0F#-DMM  #-DMM s D//Ec&t|d|jvr|jj|}t |dt j t jf}|jjd}|jd|k7r(tdj||jdt|D]O}|j|}|dd|ddzd z}||dd|fjt j|dd|f<Q|S) a Transform discretized data back to original feature space. Note that this function does not regenerate the original data due to discretization rounding. Parameters ---------- Xt : array-like of shape (n_samples, n_features) Transformed data in the binned space. Returns ------- Xinv : ndarray, dtype={np.float32, np.float64} Data in the original feature space. rT)rrr%rrz8Incorrect number of features. Expecting {}, received {}.Nr6r7)rr#r]inverse_transformrr@rArBr[rCrDr~rKrZastypeint64)r*rXinvrbrfre bin_centerss r+rz"KBinsDiscretizer.inverse_transforms"  t{{ "004B2DRZZ0HI\\''* ::a=J &JQQ 1    # FB+I$QR=9Sb>9S@K%tArE{&:&:288&DEDBK F  r-ct|dt||}t|dr|jj |S|S)aGet 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_r])rrhasattrr]get_feature_names_out)r*input_featuress r+rz&KBinsDiscretizer.get_feature_names_outsB( ./0~F 4 $==66~F Fr-))NNr))r __module__ __qualname____doc__r rr r typer@rArBr r'dict__annotations__r,rrTrHrrrr-r+rrsSlHaf=|LCDE ABC$RZZ 894@ Xq$v 6  :vh' ( (( $D ))"5G6GR2%N$Lr-r)rEnumbersrnumpyr@baserrrutilsrutils._param_validationr r r r utils.statsr utils.validationrrrrr _encodersrrrr-r+rsB@@"KK.%~'~r-