a
    �ù»júC  ã                   @   s¦   d dl Z d dlmZ d dlZddlmZmZmZ ddl	m
Z
 ddlmZmZmZ ddlmZ ddlmZ dd	lmZmZmZmZmZ d
dlmZ G dd„ deeƒZdS )é    N)ÚIntegralé   )ÚBaseEstimatorÚTransformerMixinÚ_fit_context)Úresample)ÚIntervalÚOptionsÚ
StrOptions)Ú"_deprecate_Xt_in_inverse_transform©Ú_weighted_percentile)Ú_check_feature_names_inÚ_check_sample_weightÚcheck_arrayÚcheck_is_fittedÚvalidate_dataé   )ÚOneHotEncoderc                
   @   sÊ   e Zd ZU dZeedddd�dgeh d£ƒgeh d£ƒgeee	j
e	jhƒdgeed	ddd�dgd
gdœZeed< d!ddddddœdd„Zedd�d"dd„ƒZdd„ Zdd„ Zd#ddœdd„Zd$dd „ZdS )%ÚKBinsDiscretizera  
    Bin continuous data into intervals.

    Read more in the :ref:`User Guide <preprocessing_discretization>`.

    .. 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=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 <random_state>`.

        .. 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]])
    r   NÚleft)Úclosedz
array-like>   Úonehotzonehot-denseÚordinal>   ÚuniformÚkmeansÚquantiler   Úrandom_state©Ún_binsÚencodeÚstrategyÚdtypeÚ	subsampler   Ú_parameter_constraintsé   r   r   i@ )r    r!   r"   r#   r   c                C   s(   || _ || _|| _|| _|| _|| _d S ©Nr   )Úselfr   r    r!   r"   r#   r   © r(   úKE:\soccer\ml_env\Lib\site-packages\sklearn/preprocessing/_discretization.pyÚ__init__·   s    
zKBinsDiscretizer.__init__T)Zprefer_skip_nested_validationc                    sT  t | |dd�}| jtjtjfv r(| j}n|j}|j\}}ˆdur\| jdkr\td| j›d�ƒ‚| jdur„|| jkr„t	|d| j| j
d�}|jd	 }|  |¡}ˆdur°tˆ||jd�‰tj|td�}t|ƒD �]0}	|dd…|	f ‰ ˆ  ¡ ˆ  ¡  }
}|
|k�r(t d
|	 ¡ d	||	< t tj tjg¡||	< qÆ| jdk�rRt |
|||	 d	 ¡||	< �n:| jdk�r¼t dd||	 d	 ¡}ˆdu �r–t t ˆ |¡¡||	< n$tj‡ ‡fdd„|D ƒtjd�||	< nÐ| jdk�rŒddlm} t |
|||	 d	 ¡}|d	d… |dd…  dd…df d }|||	 |d	d�}|jˆ dd…df ˆd�jdd…df }| ¡  |d	d… |dd…  d ||	< tj|
||	 |f ||	< | jdv rÆtj||	 tjd�dk}||	 | ||	< t ||	 ƒd	 ||	 krÆt d|	 ¡ t ||	 ƒd	 ||	< qÆ|| _!|| _"d| j#v �rPt$dd„ | j"D ƒ| j#dk|d�| _%| j% t d	t | j"ƒf¡¡ | S )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.
            Cannot be used when `strategy` is set to `"uniform"`.

            .. versionadded:: 1.3

        Returns
        -------
        self : object
            Returns the instance itself.
        Únumeric©r"   Nr   zY`sample_weight` was provided but it cannot be used with strategy='uniform'. Got strategy=z	 instead.F)ÚreplaceÚ	n_samplesr   r   z3Feature %d is constant and will be replaced with 0.r   r   éd   c                    s   g | ]}t ˆ ˆ|ƒ‘qS r(   r   )Ú.0Úq©ÚcolumnÚsample_weightr(   r)   Ú
<listcomp>  s   ÿz(KBinsDiscretizer.fit.<locals>.<listcomp>r   r   )ÚKMeanséÿÿÿÿç      à?)Z
n_clustersÚinitZn_init)r4   )r   r   )Zto_beging:Œ0âŽyE>zqBins whose width are too small (i.e., <= 1e-8) in feature %d are removed. Consider decreasing the number of bins.r   c                 S   s   g | ]}t  |¡‘qS r(   )ÚnpZarange©r0   Úir(   r(   r)   r5   >  ó    )Ú
categoriesZsparse_outputr"   )&r   r"   r:   Úfloat64Úfloat32Úshaper!   Ú
ValueErrorr#   r   r   Ú_validate_n_binsr   ZzerosÚobjectÚrangeÚminÚmaxÚwarningsÚwarnÚarrayÚinfZlinspaceZasarrayZ
percentileZclusterr6   ÚfitZcluster_centers_ÚsortZr_Zediff1dÚlenÚ
bin_edges_Ún_bins_r    r   Ú_encoder)r'   ÚXÚyr4   Zoutput_dtyper.   Ú
n_featuresr   Ú	bin_edgesÚjjZcol_minZcol_maxZ	quantilesr6   Zuniform_edgesr9   ÚkmZcentersÚmaskr(   r2   r)   rL   È   sœ    
þÿü


ÿ
þû(ÿ
þ 
þÿýzKBinsDiscretizer.fitc                 C   s¦   | j }t|tƒr tj||td�S t|tddd�}|jdksH|jd |krPt	dƒ‚|dk ||kB }t 
|¡d }|jd dkr¢d	 d
d„ |D ƒ¡}t	d tj|¡ƒ‚|S )z0Returns n_bins_, the number of bins per feature.r,   TF)r"   ÚcopyZ	ensure_2dr   r   z8n_bins must be a scalar or array of shape (n_features,).r   z, c                 s   s   | ]}t |ƒV  qd S r&   )Ústrr;   r(   r(   r)   Ú	<genexpr>W  r=   z4KBinsDiscretizer._validate_n_bins.<locals>.<genexpr>zk{} received an invalid number of bins at indices {}. Number of bins must be at least 2, and must be an int.)r   Ú
isinstancer   r:   ÚfullÚintr   ÚndimrA   rB   ÚwhereÚjoinÚformatr   Ú__name__)r'   rT   Z	orig_binsr   Zbad_nbins_valueZviolating_indicesÚindicesr(   r(   r)   rC   H  s     
ýÿz!KBinsDiscretizer._validate_n_binsc                 C   sÚ   t | ƒ | jdu rtjtjfn| j}t| |d|dd�}| j}t|jd ƒD ]8}tj	|| dd… |dd…|f dd�|dd…|f< qJ| j
d	kr’|S d}d
| j
v r²| jj}|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)rY   r"   Úresetr   r7   Úright)Zsider   r   )r   r"   r:   r?   r@   r   rO   rE   rA   Zsearchsortedr    rQ   Ú	transform)r'   rR   r"   ÚXtrU   rV   Z
dtype_initZXt_encr(   r(   r)   rg   a  s     6


zKBinsDiscretizer.transform)rh   c                C   sÎ   t ||ƒ}t| ƒ d| jv r(| j |¡}t|dtjtjfd�}| j	j
d }|j
d |krntd ||j
d ¡ƒ‚t|ƒD ]R}| j| }|dd… |dd…  d	 }||dd…|f  tj¡ |dd…|f< qv|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.

        Xt : array-like of shape (n_samples, n_features)
            Transformed data in the binned space.

            .. deprecated:: 1.5
                `Xt` was deprecated in 1.5 and will be removed in 1.7. Use `X` instead.

        Returns
        -------
        Xinv : ndarray, dtype={np.float32, np.float64}
            Data in the original feature space.
        r   T)rY   r"   r   r   z8Incorrect number of features. Expecting {}, received {}.Nr7   r8   )r   r   r    rQ   Úinverse_transformr   r:   r?   r@   rP   rA   rB   rb   rE   rO   ZastypeZint64)r'   rR   rh   ZXinvrT   rV   rU   Zbin_centersr(   r(   r)   ri   ˆ  s"    


ÿÿ
*z"KBinsDiscretizer.inverse_transformc                 C   s.   t | dƒ t| |ƒ}t| dƒr*| j |¡S |S )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.
        Zn_features_in_rQ   )r   r   ÚhasattrrQ   Úget_feature_names_out)r'   Zinput_featuresr(   r(   r)   rk   ¶  s
    


z&KBinsDiscretizer.get_feature_names_out)r%   )NN)N)N)rc   Ú
__module__Ú__qualname__Ú__doc__r   r   r
   r	   Útyper:   r?   r@   r$   ÚdictÚ__annotations__r*   r   rL   rC   rg   ri   rk   r(   r(   r(   r)   r      s.   
 ú þø'.r   )rH   Únumbersr   Únumpyr:   Úbaser   r   r   Úutilsr   Zutils._param_validationr   r	   r
   Zutils.deprecationr   Zutils.statsr   Zutils.validationr   r   r   r   r   Z	_encodersr   r   r(   r(   r(   r)   Ú<module>   s   