hH=ddlmZddlZddlZddlmZddlmZm Z ddl m Z m Z m Z mZddlmZdd lmZdd lmZdd lmZdd lmZGd de eZdS))IntegralN) OneHotEncoder) BaseEstimatorTransformerMixin)HiddenInterval StrOptionsOptions) check_array)check_is_fitted)check_random_state)_check_feature_names_in)_safe_indexingc 0eZdZUdZeeddddgehdgehdgeee j e j hdgeed ddde ed hgd gd Z eed < ddddd dddZddZdZdZdZddZdS)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. 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. Used when `strategy="quantile"`. `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. .. deprecated:: 1.1 In version 1.3 and onwards, `subsample=2e5` will be the default. 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.int_ 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 ----- 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]]) rNleft)closedz array-like> onehot-denseonehotordinal>kmeansuniformquantilerwarn random_staten_binsencodestrategydtype subsampler_parameter_constraintsrr)r r!r"r#rcZ||_||_||_||_||_||_dSNr)selfrr r!r"r#rs a/var/www/html/Sam_Eipo/venv/lib/python3.11/site-packages/sklearn/preprocessing/_discretization.py__init__zKBinsDiscretizer.__init__s5     "(c |||d}|jtjtjfvr|j}n|j}|j\}}|jdkr|jy|jdkr!|dkrtj dtnt|j }||jkr-|||jd }t||}n=|jdkr2t!|jt"rt%d |jd |jd }||}tj|t*} t-|D]} |dd| f} | | } } | | krKtj d | zd || <tjtj tjg| | <|jdkr$tj| | || d z| | <n6|jdkrJtjdd|| d z}tjtj| || | <n|jdkrddlm}tj| | || d z}|d d|ddzdddfdz}||| |d }| | dddfj!dddf}|"|d d|ddzdz| | <tj#| | | | f| | <|jdvrtj$| | tjdk}| | || | <tK| | d z || kr2tj d| ztK| | d z || <| |_&||_'d|j(vrotSd|j'D|j(dk||_*|j* tjd tK|j'f|S)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`. Returns ------- self : object Returns the instance itself. numericr"rNrgjAzIn version 1.3 onwards, subsample=2e5 will be used by default. Set subsample explicitly to silence this warning in the mean time. Set subsample=None to disable subsampling explicitly.F)sizereplacez"Invalid parameter for `strategy`: z6. `subsample` must be used with `strategy="quantile"`.rz3Feature %d is constant and will be replaced with 0.rrdrr)KMeans?) n_clustersinitn_init)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.rc6g|]}tj|S)nparange.0is r) z(KBinsDiscretizer.fit..#s ???QBIaLL???r+) categories sparse_outputr")+_validate_params_validate_datar"r;float64float32shaper!r#warningsr FutureWarningrrchoicer isinstancer ValueError_validate_n_binszerosobjectrangeminmaxarrayinflinspaceasarray percentileclusterr2fitcluster_centers_sortr_ediff1dlen bin_edges_n_bins_r r_encoder)r(Xy output_dtype n_samples n_featuresrng subsample_idxr bin_edgesjjcolumncol_mincol_max quantilesr2 uniform_edgesr6kmcentersmasks r)rYzKBinsDiscretizer.fits$      3 3 :"*bj1 1 1:LL7L ! : =J & &4>+E~''s??ML& )):;;t~--$'JJ!%/%%M'q-88A ]j ( (Z-Q-Q (GT]GGG  WQZ &&z22HZv666  ##, 8, 8Bqqq"uXF%zz||VZZ\\WG'!! IBNr "26'26): ; ; " } )) " GWfRj1n M M " *,,K3r Q?? " 2=+K+K L L " (**,,,,,,!# GWfRj1n M M %abb)M#2#,>>4H3NVvbzQGGG&&411B111a4H !(wss|!;s B " "gy}g&E F " } 666z)B-"&AAADH )" d 3 " y}%%)VBZ77M9;=> "%Yr]!3!3a!7F2J# t{ " ")??$,???"kX5"DM M  bh3t|+<+<'=>> ? ? ? r+c|j}t|trtj||t St |t dd}|jdks|jd|krtd|dk||kz}tj |d}|jddkrLd d |D}td tj||S) z0Returns n_bins_, the number of bins per feature.r.TF)r"copy ensure_2drrz8n_bins must be a scalar or array of shape (n_features,).rz, c34K|]}t|VdSr')strr=s r) z4KBinsDiscretizer._validate_n_bins..<s(BB1ABBBBBBr+zk{} received an invalid number of bins at indices {}. Number of bins must be at least 2, and must be an int.)rrKrr;fullintr ndimrGrLwherejoinformatr__name__)r(rf orig_binsrbad_nbins_valueviolating_indicesindicess r)rMz!KBinsDiscretizer._validate_n_bins-sK i * * =7:y<<< <YcNNN ;??fl1o;;WXX X!A:&I*=>H_55a8  "1 % ) )iiBB0ABBBBBG::@&$-w;;  r+c2t||jtjtjfn|j}||d|d}|j}t|jdD]8}tj ||dd|dd|fd|dd|f<9|j d kr|Sd}d |j vr|j j}|j|j _ |j |}||j _n#||j _wxYw|S) 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)rtr"resetrr3right)siderr) rr"r;rErFrDr_rPrG searchsortedr ra transform)r(rbr"Xtrirj dtype_initXt_encs r)rzKBinsDiscretizer.transformFs- -1J,>RZ((DJ  U% H HO  $$ V VB " ad(;R2YWUUUBqqq"uII ;) # #I t{ " ",J"$(DM  -],,R00F#-DM  *DM  , , , , s DDc t|d|jvr|j|}t |dt jt jf}|jj d}|j d|kr.td ||j dt|D]R}|j |}|dd|ddzd z}|t j|dd|f|dd|f<S|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)rtr"rrz8Incorrect number of features. Expecting {}, received {}.Nr3r4)rr rainverse_transformr r;rErFr`rGrLr~rPr_int_)r(rXinvrfrjri bin_centerss r)rz"KBinsDiscretizer.inverse_transformms"  t{ " "0044B2DRZ0HIII\'* :a=J & &JQQ 1    ## < 9S@K%bgd111b5k&:&:;DBKK r+czt||}t|dr|j|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. ra)rhasattrraget_feature_names_out)r(input_featuress r)rz&KBinsDiscretizer.get_feature_names_outsD(1~FF 4 $ $ G=66~FF Fr+)r%r')r __module__ __qualname____doc__r rr r typer;rErFr r$dict__annotations__r*rYrMrrrr:r+r)rrsxBBJ8Haf===|L:CCCDDEZ A A ABBC'$RZ 8994@ HXq$v 6 6 6  F::vh'' ( ( (( $ $D   ))))))"rrrrh2%%%N$$$Lr+r)numbersrnumpyr;rHrbaserrutils._param_validationr r r r utils.validationr rrrutilsrrr:r+r)rs22222222KKKKKKKKKKKK******......111111666666""""""VVVVV'VVVVVr+