
    >[g/                         d Z ddlZddlmZmZ ddlZddlmZ ddl	m
Z
mZ ddlmZ ddlmZ dd	l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 g dZeedZ G d de
      Zy)z5
Kernel Density Estimation
-------------------------
    N)IntegralReal)gammainc   )BaseEstimator_fit_context)VALID_METRICS)check_random_state)Interval
StrOptions)	row_norms)_check_sample_weightcheck_is_fittedvalidate_data   )BallTree)KDTree)gaussiantophatepanechnikovexponentiallinearcosine)	ball_treekd_treec                      e Zd ZU dZ eeddd       eddh      g e eej                               dhz        g e ee
            g e e ej                  ej                         D  cg c]  }t        |    c}}}              g eeddd	      g eeddd	      gd
g eeddd	      gdegd	Zeed<   dddddddddd	dZd Z ed      dd       Zd ZddZddZyc c}}} w )KernelDensitya  Kernel Density Estimation.

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

    Parameters
    ----------
    bandwidth : float or {"scott", "silverman"}, default=1.0
        The bandwidth of the kernel. If bandwidth is a float, it defines the
        bandwidth of the kernel. If bandwidth is a string, one of the estimation
        methods is implemented.

    algorithm : {'kd_tree', 'ball_tree', 'auto'}, default='auto'
        The tree algorithm to use.

    kernel : {'gaussian', 'tophat', 'epanechnikov', 'exponential', 'linear',                  'cosine'}, default='gaussian'
        The kernel to use.

    metric : str, default='euclidean'
        Metric to use for distance computation. See the
        documentation of `scipy.spatial.distance
        <https://docs.scipy.org/doc/scipy/reference/spatial.distance.html>`_ and
        the metrics listed in
        :class:`~sklearn.metrics.pairwise.distance_metrics` for valid metric
        values.

        Not all metrics are valid with all algorithms: refer to the
        documentation of :class:`BallTree` and :class:`KDTree`. Note that the
        normalization of the density output is correct only for the Euclidean
        distance metric.

    atol : float, default=0
        The desired absolute tolerance of the result.  A larger tolerance will
        generally lead to faster execution.

    rtol : float, default=0
        The desired relative tolerance of the result.  A larger tolerance will
        generally lead to faster execution.

    breadth_first : bool, default=True
        If true (default), use a breadth-first approach to the problem.
        Otherwise use a depth-first approach.

    leaf_size : int, default=40
        Specify the leaf size of the underlying tree.  See :class:`BallTree`
        or :class:`KDTree` for details.

    metric_params : dict, default=None
        Additional parameters to be passed to the tree for use with the
        metric.  For more information, see the documentation of
        :class:`BallTree` or :class:`KDTree`.

    Attributes
    ----------
    n_features_in_ : int
        Number of features seen during :term:`fit`.

        .. versionadded:: 0.24

    tree_ : ``BinaryTree`` instance
        The tree algorithm for fast generalized N-point problems.

    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.

    bandwidth_ : float
        Value of the bandwidth, given directly by the bandwidth parameter or
        estimated using the 'scott' or 'silverman' method.

        .. versionadded:: 1.0

    See Also
    --------
    sklearn.neighbors.KDTree : K-dimensional tree for fast generalized N-point
        problems.
    sklearn.neighbors.BallTree : Ball tree for fast generalized N-point
        problems.

    Examples
    --------
    Compute a gaussian kernel density estimate with a fixed bandwidth.

    >>> from sklearn.neighbors import KernelDensity
    >>> import numpy as np
    >>> rng = np.random.RandomState(42)
    >>> X = rng.random_sample((100, 3))
    >>> kde = KernelDensity(kernel='gaussian', bandwidth=0.5).fit(X)
    >>> log_density = kde.score_samples(X[:3])
    >>> log_density
    array([-1.52955942, -1.51462041, -1.60244657])
    r   Nneither)closedscott	silvermanautoleftbooleanr   )		bandwidth	algorithmkernelmetricatolrtolbreadth_first	leaf_sizemetric_params_parameter_constraints      ?r   	euclideanT(   c       	             || _         || _        || _        || _        || _        || _        || _        || _        |	| _        y N)	r&   r%   r'   r(   r)   r*   r+   r,   r-   )
selfr%   r&   r'   r(   r)   r*   r+   r,   r-   s
             Q/var/www/html/bid-api/venv/lib/python3.12/site-packages/sklearn/neighbors/_kde.py__init__zKernelDensity.__init__   sE     #"		*"*    c                     |dk(  r'|t         j                  v ry|t        j                  v ryy |t        |   j                  vr"t	        dj                  t        |   |            |S )Nr"   r   r   zinvalid metric for {0}: '{1}')r   valid_metricsr   	TREE_DICT
ValueErrorformat)r4   r&   r(   s      r5   _choose_algorithmzKernelDensity._choose_algorithm   ss     --- 8111" 2 Yy1??? 3::9Y;OQWX  r7   F)prefer_skip_nested_validationc                    | j                  | j                  | j                        }t        | j                  t
              r| j                  dk(  r+|j                  d   d|j                  d   dz   z  z  | _        na| j                  dk(  rR|j                  d   |j                  d   dz   z  dz  d|j                  d   dz   z  z  | _        n| j                  | _        t        | |dt        j                  	      }|t        ||t        j                  d
      }| j                  }|i }t        |   |f| j                  | j                  |d|| _        | S )a  Fit the Kernel Density model on the data.

        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            List of n_features-dimensional data points.  Each row
            corresponds to a single data point.

        y : None
            Ignored. This parameter exists only for compatibility with
            :class:`~sklearn.pipeline.Pipeline`.

        sample_weight : array-like of shape (n_samples,), default=None
            List of sample weights attached to the data X.

            .. versionadded:: 0.20

        Returns
        -------
        self : object
            Returns the instance itself.
        r    r   r      r!   r   C)orderdtypeT)rD   ensure_non_negative)r(   r,   sample_weight)r=   r&   r(   
isinstancer%   strshape
bandwidth_r   npfloat64r   r-   r:   r,   tree_)r4   XyrF   r&   kwargss         r5   fitzKernelDensity.fit   s7   6 **4>>4;;G	dnnc*~~("#''!*qwwqzA~1F"G;.#$771:a#@1#D!''!*q.)# #nnDO$BJJ?$0q

M ##>Fy)
;;nn'	

 

 r7   c           	         t        |        t        | |dt        j                  d      }| j                  j
                  $| j                  j                  j                  d   }n| j                  j                  }| j                  |z  }| j                  j                  || j                  | j                  || j                  | j                  d      }|t        j                  |      z  }|S )a  Compute the log-likelihood of each sample under the model.

        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            An array of points to query.  Last dimension should match dimension
            of training data (n_features).

        Returns
        -------
        density : ndarray of shape (n_samples,)
            Log-likelihood of each sample in `X`. These are normalized to be
            probability densities, so values will be low for high-dimensional
            data.
        rB   F)rC   rD   resetr   T)hr'   r)   r*   r+   
return_log)r   r   rK   rL   rM   rF   datarI   
sum_weightr)   kernel_densityrJ   r'   r*   r+   log)r4   rN   Natol_Nlog_densitys        r5   score_sampleszKernelDensity.score_samples   s      	 $BJJeL::##+

%%a(A

%%AQjj//oo;;,, 0 
 	rvvay r7   c                 J    t        j                  | j                  |            S )a}  Compute the total log-likelihood under the model.

        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            List of n_features-dimensional data points.  Each row
            corresponds to a single data point.

        y : None
            Ignored. This parameter exists only for compatibility with
            :class:`~sklearn.pipeline.Pipeline`.

        Returns
        -------
        logprob : float
            Total log-likelihood of the data in X. This is normalized to be a
            probability density, so the value will be low for high-dimensional
            data.
        )rK   sumr]   )r4   rN   rO   s      r5   scorezKernelDensity.score  s    ( vvd((+,,r7   c                    t        |        | j                  dvr
t               t        j                  | j
                  j                        }t        |      }|j                  dd|      }| j
                  j                  0||j                  d   z  j                  t        j                        }nZt        j                  t        j                  | j
                  j                              }|d   }t        j                  |||z        }| j                  dk(  r2t        j                  |j!                  ||   | j"                              S | j                  dk(  r|j                  d   }	|j!                  ||	f      }
t%        |
d	
      }t'        d|	z  d|z        d|	z  z  | j"                  z  t        j(                  |      z  }||   |
|ddt        j*                  f   z  z   S y)a  Generate random samples from the model.

        Currently, this is implemented only for gaussian and tophat kernels.

        Parameters
        ----------
        n_samples : int, default=1
            Number of samples to generate.

        random_state : int, RandomState instance or None, default=None
            Determines random number generation used to generate
            random samples. Pass an int for reproducible results
            across multiple function calls.
            See :term:`Glossary <random_state>`.

        Returns
        -------
        X : array-like of shape (n_samples, n_features)
            List of samples.
        )r   r   r   r   )sizeNr@   r   r   T)squaredg      ?r/   )r   r'   NotImplementedErrorrK   asarrayrM   rV   r
   uniformrF   rI   astypeint64cumsumsearchsorted
atleast_2dnormalrJ   r   r   sqrtnewaxis)r4   	n_samplesrandom_staterV   rnguicumsum_weightrW   dimrN   s_sq
corrections                r5   samplezKernelDensity.sample4  s   * 	;;44%''zz$**//* .KK19K-::##+TZZ]"**2884AIIbjj1I1I&JKM&r*Jq:~>A;;*$==DGT__!EFF[[H$ **Q-C

C 0
1AQ-DsC$J/C#I>//"''$-  
 7QArzzM!:::: %r7   )NNr3   )r   N)__name__
__module____qualname____doc__r   r   r   setr:   keysVALID_KERNELS	itertoolschainr	   r   dictr.   __annotations__r6   r=   r   rQ   r]   r`   rx   ).0algr	   s   000r5   r   r   &   sC   [~ T1d95-.
 !Y^^%5!6&!ABCc-012OIOOINNDT%UDTSmC&8DT%UVW

 $478$478#xD@A!$D , +.  &+4	4l$L-,3;O &Vs   /C+r   ) r|   r   numbersr   r   numpyrK   scipy.specialr   baser   r   neighbors._baser	   utilsr
   utils._param_validationr   r   utils.extmathr   utils.validationr   r   r   
_ball_treer   _kd_treer   r   r:   r    r7   r5   <module>r      sT     "  " . + & : % S S    #v6	
A;M A;r7   