o iQ@sddlZddlmZddlZddlmZmZmZddl m Z ddl m Z m Z mZddlmZmZddlmZmZmZmZmZd d lmZGd d d eeZdS) N)Integral) BaseEstimatorTransformerMixin _fit_context)resample)IntervalOptions StrOptions)_averaged_weighted_percentile_weighted_percentile)_check_feature_names_in_check_sample_weight check_arraycheck_is_fitted validate_data) OneHotEncoderc @seZdZUdZeedddddgehdgehdgehd geee j e j hdgeed ddddgd gd Z e ed < d"dddddddddZeddd#ddZddZddZddZd$d d!ZdS)%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="linear" 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 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]]) rNleft)closedz array-like>onehotz onehot-denseordinal>quantileuniformkmeans> Zmedian_unbiasedwarnZhazenlinearZweibullZinterpolated_inverted_cdfZclosest_observationaveraged_inverted_cdfZnormal_unbiased inverted_cdfr random_staten_binsencodestrategyquantile_methoddtype subsampler _parameter_constraintsrrri@ )r#r$r%r&r'r cCs.||_||_||_||_||_||_||_dSNr!)selfr"r#r$r%r&r'r r,t/var/www/html/eduruby.in/lip-sync/lip-sync-env/lib/python3.10/site-packages/sklearn/preprocessing/_discretization.py__init__s  zKBinsDiscretizer.__init__T)Zprefer_skip_nested_validationcst||dd}|jtjtjfvr|j}n|j}|j\}}dur(t||jd|jdur?||jkr?t|d|j|j d}d|jd}| |}tj |t d}|j } |jdkrd| dkrdtd td } |jdkry| d vrydurytd | d |jdkrdurdk} ntd} t|D]7} |dd| f| } | } | | krtd| d|| <ttj tjg|| <q|jdkrt| | || d|| <n|jdkr'tdd|| d}i}| d krdur| |d<dur tjtj|fi|tjd|| <nttd | tjfdd|Dtjd|| <nh|jdkrddlm}t| | || d}|dd|dddddfd}||| |dd}|j dddfdj!dddf}|"|dd|ddd|| <tj#| || | f|| <|jdvrtj$|| tjddk}|| ||| <t%|| d|| krtd| t%|| d|| <q||_&||_'d |j(vrt)d!d|j'D|j(d k|d"|_*|j* t dt%|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`. 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_weightrrra%The current default behavior, quantile_method='linear', will be changed to quantile_method='averaged_inverted_cdf' in scikit-learn version 1.9 to naturally support sample weight equivalence properties by default. Pass quantile_method='averaged_inverted_cdf' explicitly to silence this warning.r)rrzWhen 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.rdmethodcsg|] }|dqS))Zpercentile_rankr,).0pcolumnZpercentile_funcr3r,r- qs z(KBinsDiscretizer.fit..rr)KMeans?)Z n_clustersinitZn_init)r3)rr)Zto_beging:0yE>zqBins whose width are too small (i.e., <= 1e-8) in feature %d are removed. Consider decreasing the number of bins.rcSsg|]}t|qSr,)npZaranger6ir,r,r-r:s) categoriesZ sparse_outputr&)+rr&r?float64float32shaperr'rr _validate_n_binsZzerosobjectr%r$warningsr FutureWarning ValueErrorslicerangeminmaxarrayinfZlinspaceZasarrayZ percentiler r Zclusterr;fitZcluster_centers_sortZr_Zediff1dlen bin_edges_n_bins_r#r_encoder)r+Xyr3Z output_dtyper2 n_featuresr" bin_edgesr%Znnz_weight_maskjjZcol_minZcol_maxZpercentile_levelsZpercentile_kwargsr;Z uniform_edgesr>kmZcentersmaskr,r8r-rQs              (    zKBinsDiscretizer.fitcCs|j}t|trtj||tdSt|tddd}|jdks$|jd|kr(t d|dk||kB}t |d}|jddkrQd d d |D}t d t j||S) z0Returns n_bins_, the number of bins per feature.r0TF)r&copyZ ensure_2drrz8n_bins must be a scalar or array of shape (n_features,).rz, css|]}t|VqdSr*)strr@r,r,r- sz4KBinsDiscretizer._validate_n_bins..zk{} received an invalid number of bins at indices {}. Number of bins must be at least 2, and must be an int.)r" isinstancerr?fullintrndimrErJwherejoinformatr__name__)r+rYZ orig_binsr"Zbad_nbins_valueZviolating_indicesindicesr,r,r-rFs" z!KBinsDiscretizer._validate_n_binscCst||jdurtjtjfn|j}t||d|dd}|j}t|jdD]}tj ||dd|dd|fdd|dd|f<q%|j d krI|Sd}d |j vrY|j j}|j|j _z |j |}W||j _|S||j _w) 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)r^r&resetrr<right)Zsiderr) rr&r?rCrDrrTrLrEZ searchsortedr#rV transform)r+rWr&ZXtrZr[Z dtype_initZXt_encr,r,r-rls"6    zKBinsDiscretizer.transformcCst|d|jvr|j|}t|dtjtjfd}|jj d}|j d|kr2t d ||j dt |D])}|j |}|dd|ddd }||dd|ftj|dd|f<q6|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 ---------- 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&rrz8Incorrect number of features. Expecting {}, received {}.Nr<r=)rr#rVinverse_transformrr?rCrDrUrErJrgrLrTZastypeZint64)r+rWZXinvrYr[rZZ bin_centersr,r,r-rms       *z"KBinsDiscretizer.inverse_transformcCs.t|dt||}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. Zn_features_in_rV)rr hasattrrVget_feature_names_out)r+Zinput_featuresr,r,r-ro s    z&KBinsDiscretizer.get_feature_names_out)r))NNr*)rh __module__ __qualname____doc__rrr r typer?rCrDr(dict__annotations__r.rrQrFrlrmror,r,r,r-rs< !    ?''r)rHnumbersrnumpyr?baserrrutilsrZutils._param_validationrr r Z utils.statsr r Zutils.validationr rrrrZ _encodersrrr,r,r,r-s