a ;Zaa8@snddlZddlZddlZddlmZddlmZmZddl m Z ddl m Z ddl m Z Gd d d eeZ dS) N) OneHotEncoder) BaseEstimatorTransformerMixin) check_array)check_is_fitted)_check_feature_names_inc@sPeZdZdZdddddddZdd d Zd d Zd dZddZdddZ dS)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 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]]) onehotquantileN)encodestrategydtypecCs||_||_||_||_dSN)n_binsrrr)selfrrrrrDlib/python3.9/site-packages/sklearn/preprocessing/_discretization.py__init__szKBinsDiscretizer.__init__cCs |j|dd}tjtjf}|j|vr,|j}n.|jdur>|j}ntd|dd|jdd}|j|vrztd ||jd }|j|vrtd ||j|j d }| |}tj |t d} t |D]} |dd| f} | | } } | | kr&td | d || <ttj tjg| | <q|jdkrPt| | || d | | <n|jdkrtdd|| d }tt| || | <n|jdkrXddlm}t| | || d }|d d|dddddfd}||| |d dd}|| dddfjdddf}||d d|ddd| | <tj| | | | f| | <|jdvrtj| | tjddk}| | || | <t| | d || krtd| t| | d || <q| |_||_ d|jvrt!dd|j D|jdk|d |_"|j"t d t|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. ZnumericrNzValid options for 'dtype' are rz . Got dtype=z instead.)r z onehot-denseordinalz;Valid options for 'encode' are {}. Got encode={!r} instead.)uniformr kmeansz?Valid options for 'strategy' are {}. Got strategy={!r} instead.rz3Feature %d is constant and will be replaced with 0.rr rdrr)KMeans?full)Z n_clustersinitZn_init algorithm)r r)Zto_begin:0yE>zqBins whose width are too small (i.e., <= 1e-8) in feature %d are removed. Consider decreasing the number of bins.r cSsg|]}t|qSr)npZarange.0irrr z(KBinsDiscretizer.fit..)Z categoriesZsparser)#_validate_datar#float64float32r ValueErrorrformatrshape_validate_n_binsZzerosobjectrangeminmaxwarningswarnZarrayinfZlinspaceZasarrayZ percentileZclusterrfitZcluster_centers_sortZr_Zediff1dlen bin_edges_n_bins_r_encoder)rXyZsupported_dtypeZ output_dtypeZ valid_encodeZvalid_strategy n_featuresr bin_edgesjjcolumnZcol_minZcol_maxZ quantilesrZ uniform_edgesr ZkmZcentersmaskrrrr7s            ( $   zKBinsDiscretizer.fitcCs|j}t|tjr`t|tjs6tdtjt |j|dkrPtdtj|t j ||t dSt |t ddd}|jdks|jd |krtd |dk||kB}t |d }|jd d krd d d |D}tdtj||S)z0Returns n_bins_, the number of bins per feature.z>{} received an invalid n_bins type. Received {}, expected int.rzH{} received an invalid number of bins. Received {}, expected at least 2.rTF)rcopyZ ensure_2drrz8n_bins must be a scalar or array of shape (n_features,).z, css|]}t|VqdSr)strr$rrr r(z4KBinsDiscretizer._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 isinstancenumbersNumberZIntegralr,r-r __name__typer#rintrndimr.wherejoin)rr?Z orig_binsrZbad_nbins_valueZviolating_indicesindicesrrrr/s8   z!KBinsDiscretizer._validate_n_binsc Cst||jdurtjtjfn|j}|j|d|dd}|j}t|jdD]^}d}d}||t |dd|f}t |dd|f|||dd|dd|f<qJtj |d|j d|d |j d kr|Sd} d |j vr|jj} |j|j_z|j|} W| |j_n | |j_0| 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)rDrresetrgh㈵>r"r)outrr )rrr#r*r+r)r:r1r.absZdigitizeZclipr;rr< transform) rr=rXtr@rAZrtolZatolZepsZ dtype_initZXt_encrrrrT#s(6   zKBinsDiscretizer.transformcCst|d|jvr|j|}t|dtjtjfd}|jj d}|j d|krdt d ||j dt |D]P}|j |}|dd|ddd }|t|dd|f|dd|f<ql|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. r T)rDrrrz8Incorrect number of features. Expecting {}, received {}.Nrr)rrr<inverse_transformrr#r*r+r;r.r,r-r1r:Zint_)rrUZXinvr?rAr@Z bin_centersrrrrVRs       (z"KBinsDiscretizer.inverse_transformcCst||}|j|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 names are generated: `[x0, x1, ..., x(n_features_in_)]`. - 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. )r r<get_feature_names_out)rZinput_featuresrrrrWxs z&KBinsDiscretizer.get_feature_names_out)r )N)N) rJ __module__ __qualname____doc__rr7r/rTrVrWrrrrr so q'/&r )rHZnumpyr#r4rbaserrZutils.validationrrr r rrrr s