_MhbddlZddlZddlmZmZddlmZddlmZm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZddlZddlmZddlmZmZdgZejZ Gd dZ!d Z"dS) N)linalgspecial)check_random_state)asarray atleast_2dreshapezerosnewaxisexppisqrtravelpower atleast_1dsqueezesum transposeonescov)_mvn)gaussian_kernel_estimategaussian_kernel_estimate_log gaussian_kdeceZdZdZddZdZeZdZdZddZ dZ dd Z d Z d Z e Zd e_dd ZdZedZdZdZdZedZedZdS)ra&Representation of a kernel-density estimate using Gaussian kernels. Kernel density estimation is a way to estimate the probability density function (PDF) of a random variable in a non-parametric way. `gaussian_kde` works for both uni-variate and multi-variate data. It includes automatic bandwidth determination. The estimation works best for a unimodal distribution; bimodal or multi-modal distributions tend to be oversmoothed. Parameters ---------- dataset : array_like Datapoints to estimate from. In case of univariate data this is a 1-D array, otherwise a 2-D array with shape (# of dims, # of data). bw_method : str, scalar or callable, optional The method used to calculate the estimator bandwidth. This can be 'scott', 'silverman', a scalar constant or a callable. If a scalar, this will be used directly as `kde.factor`. If a callable, it should take a `gaussian_kde` instance as only parameter and return a scalar. If None (default), 'scott' is used. See Notes for more details. weights : array_like, optional weights of datapoints. This must be the same shape as dataset. If None (default), the samples are assumed to be equally weighted Attributes ---------- dataset : ndarray The dataset with which `gaussian_kde` was initialized. d : int Number of dimensions. n : int Number of datapoints. neff : int Effective number of datapoints. .. versionadded:: 1.2.0 factor : float The bandwidth factor, obtained from `kde.covariance_factor`. The square of `kde.factor` multiplies the covariance matrix of the data in the kde estimation. covariance : ndarray The covariance matrix of `dataset`, scaled by the calculated bandwidth (`kde.factor`). inv_cov : ndarray The inverse of `covariance`. Methods ------- evaluate __call__ integrate_gaussian integrate_box_1d integrate_box integrate_kde pdf logpdf resample set_bandwidth covariance_factor Notes ----- Bandwidth selection strongly influences the estimate obtained from the KDE (much more so than the actual shape of the kernel). Bandwidth selection can be done by a "rule of thumb", by cross-validation, by "plug-in methods" or by other means; see [3]_, [4]_ for reviews. `gaussian_kde` uses a rule of thumb, the default is Scott's Rule. Scott's Rule [1]_, implemented as `scotts_factor`, is:: n**(-1./(d+4)), with ``n`` the number of data points and ``d`` the number of dimensions. In the case of unequally weighted points, `scotts_factor` becomes:: neff**(-1./(d+4)), with ``neff`` the effective number of datapoints. Silverman's Rule [2]_, implemented as `silverman_factor`, is:: (n * (d + 2) / 4.)**(-1. / (d + 4)). or in the case of unequally weighted points:: (neff * (d + 2) / 4.)**(-1. / (d + 4)). Good general descriptions of kernel density estimation can be found in [1]_ and [2]_, the mathematics for this multi-dimensional implementation can be found in [1]_. With a set of weighted samples, the effective number of datapoints ``neff`` is defined by:: neff = sum(weights)^2 / sum(weights^2) as detailed in [5]_. `gaussian_kde` does not currently support data that lies in a lower-dimensional subspace of the space in which it is expressed. For such data, consider performing principal component analysis / dimensionality reduction and using `gaussian_kde` with the transformed data. References ---------- .. [1] D.W. Scott, "Multivariate Density Estimation: Theory, Practice, and Visualization", John Wiley & Sons, New York, Chicester, 1992. .. [2] B.W. Silverman, "Density Estimation for Statistics and Data Analysis", Vol. 26, Monographs on Statistics and Applied Probability, Chapman and Hall, London, 1986. .. [3] B.A. Turlach, "Bandwidth Selection in Kernel Density Estimation: A Review", CORE and Institut de Statistique, Vol. 19, pp. 1-33, 1993. .. [4] D.M. Bashtannyk and R.J. Hyndman, "Bandwidth selection for kernel conditional density estimation", Computational Statistics & Data Analysis, Vol. 36, pp. 279-298, 2001. .. [5] Gray P. G., 1969, Journal of the Royal Statistical Society. Series A (General), 132, 272 Examples -------- Generate some random two-dimensional data: >>> import numpy as np >>> from scipy import stats >>> def measure(n): ... "Measurement model, return two coupled measurements." ... m1 = np.random.normal(size=n) ... m2 = np.random.normal(scale=0.5, size=n) ... return m1+m2, m1-m2 >>> m1, m2 = measure(2000) >>> xmin = m1.min() >>> xmax = m1.max() >>> ymin = m2.min() >>> ymax = m2.max() Perform a kernel density estimate on the data: >>> X, Y = np.mgrid[xmin:xmax:100j, ymin:ymax:100j] >>> positions = np.vstack([X.ravel(), Y.ravel()]) >>> values = np.vstack([m1, m2]) >>> kernel = stats.gaussian_kde(values) >>> Z = np.reshape(kernel(positions).T, X.shape) Plot the results: >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots() >>> ax.imshow(np.rot90(Z), cmap=plt.cm.gist_earth_r, ... extent=[xmin, xmax, ymin, ymax]) >>> ax.plot(m1, m2, 'k.', markersize=2) >>> ax.set_xlim([xmin, xmax]) >>> ax.set_ylim([ymin, ymax]) >>> plt.show() Nctt||_|jjdkst d|jj\|_|_|t| t|_ |xj t|j zc_ |j jdkrt dt|j |jkrt ddt|j dzz |_|j|jkrd}t | ||dS#t$j$r}d}t%j||d}~wwxYw) Nrz.`dataset` input should have multiple elements.z*`weights` input should be one-dimensional.z%`weights` input should be of length na1Number of dimensions is greater than number of samples. This results in a singular data covariance matrix, which cannot be treated using the algorithms implemented in `gaussian_kde`. Note that `gaussian_kde` interprets each *column* of `dataset` to be a point; consider transposing the input to `dataset`. bw_methodabThe data appears to lie in a lower-dimensional subspace of the space in which it is expressed. This has resulted in a singular data covariance matrix, which cannot be treated using the algorithms implemented in `gaussian_kde`. Consider performing principal component analysis / dimensionality reduction and using `gaussian_kde` with the transformed data.)rrdatasetsize ValueErrorshapednrastypefloat_weightsrweightsndimlen_neff set_bandwidthr LinAlgError)selfr rr)msges P/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/scipy/stats/_kde.py__init__zgaussian_kde.__init__sk!''"2"233 | 1$$MNN N+  &w//66u==DM MMS// /MM| A%% !MNNN4=!!TV++ !HIII3t}a/000DJ 6DF??-C S// ! 1     3 3 3 3 3! 1 1 1?C$S))q 0 1s6EE9E44E9ctt|}|j\}}||jkrG|dkr%||jkrt ||jdf}d}nd|d|j}t |t |j|\}}t||j j |j dddf|j |j |}|dddfS)aEvaluate the estimated pdf on a set of points. Parameters ---------- points : (# of dimensions, # of points)-array Alternatively, a (# of dimensions,) vector can be passed in and treated as a single point. Returns ------- values : (# of points,)-array The values at each point. Raises ------ ValueError : if the dimensionality of the input points is different than the dimensionality of the KDE. rpoints have dimension , dataset has dimension Nr) rrr#r$rr"_get_output_dtype covariancerr Tr)cho_cov)r/pointsr$mr0 output_dtypespecresults r2evaluatezgaussian_kde.evaluates(GFOO,,|1 ;;Avv!tv++ $&!559990499 oo%.tGG d)$/ LNDLD1 HdlL22aaad|ctt|}t|}|j|jfkrt d|j|j|j|jfkrt d|j|ddt f}|j|z}tj |}|j |z }tj ||}tj tj|d}tdt z|jddz |z}t#||zddz } t#t%| |jzd|z } | S)aW Multiply estimated density by a multivariate Gaussian and integrate over the whole space. Parameters ---------- mean : aray_like A 1-D array, specifying the mean of the Gaussian. cov : array_like A 2-D array, specifying the covariance matrix of the Gaussian. Returns ------- result : scalar The value of the integral. Raises ------ ValueError If the mean or covariance of the input Gaussian differs from the KDE's dimensionality. zmean does not have dimension z#covariance does not have dimension Nrr@axis)rrrr#r$r"r r8r cho_factorr cho_solvenpproddiagonalrr rr r)) r/meanrsum_cov sum_cov_choldifftdiffsqrt_det norm_constenergiesr?s r2integrate_gaussianzgaussian_kde.integrate_gaussiansR0'$--((oo :$& " "ETVEEFF F 9( ( (K46KKLL LAAAwJ/C' (11 |d" t4472;|A77881r67=#3c#9::XE te|!,,,s2S(^^DL0q999JF rAcv|jdkrtdtt|jd}t||jz |z }t||jz |z }t j|jtj |tj |z z}|S)a Computes the integral of a 1D pdf between two bounds. Parameters ---------- low : scalar Lower bound of integration. high : scalar Upper bound of integration. Returns ------- value : scalar The result of the integral. Raises ------ ValueError If the KDE is over more than one dimension. rz'integrate_box_1d() only handles 1D pdfsr) r$r"rr r8r rHrr)rndtr)r/lowhighstdevnormalized_lownormalized_highvalues r2integrate_box_1dzgaussian_kde.integrate_box_1dLs, 6Q;;FGG Gd4?++,,Q/dl 2e;<< !4 =>>t| _55 ^445677 rAc|d|i}ni}t5tj|||j|j|jfi|\}}dddn #1swxYwY|r#d|jdz}tj|d|S)aComputes the integral of a pdf over a rectangular interval. Parameters ---------- low_bounds : array_like A 1-D array containing the lower bounds of integration. high_bounds : array_like A 1-D array containing the upper bounds of integration. maxpts : int, optional The maximum number of points to use for integration. Returns ------- value : scalar The result of the integral. Nmaxptsz4An integral in _mvn.mvnun requires more points than ir) stacklevel) MVN_LOCKrmvnun_weightedr r)r8r$warningswarn)r/ low_bounds high_boundsr^ extra_kwdsr[informr0s r2 integrate_boxzgaussian_kde.integrate_boxos$  "F+JJJ  O O / K04 dl04OOCMOOME6 O O O O O O O O O O O O O O O  -XRVXXC M#! , , , , s)AA  A c|j|jkrtd|j|jkr|}|}n|}|}|j|jz}t j|}d}t |jD]}|jdd|tf}|j|z } t j || } t| | zddz } |tt| |j zd|j |zz }tjtj|d} t!dt"z|jddz | z} || z}|S)a Computes the integral of the product of this kernel density estimate with another. Parameters ---------- other : gaussian_kde instance The other kde. Returns ------- value : scalar The result of the integral. Raises ------ ValueError If the KDEs have different dimensionality. z$KDEs are not the same dimensionalitygNrrDrCr)r$r"r%r8rrFranger r rGrr r)rHrIrJrr r#)r/othersmalllargerLrMr?irKrNrOrRrPrQs r2 integrate_kdezgaussian_kde.integrate_kdesZ* 7df  CDD D 7TV  EEEEE"U%55(11 uw Q QA=Aw/D=4'D$\488E4%>D)$// 99 46)U # #T_4:    %%df44<%HH QQQZ(t|rAcBt|jd|jdzz S)zoCompute Scott's factor. Returns ------- s : float Scott's factor. rrsr$r/s r2 scotts_factorzgaussian_kde.scotts_factors TYTVAX///rAc^t|j|jdzzdz d|jdzz S)z{Compute the Silverman factor. Returns ------- s : float The silverman factor. rCg@r}r~rrs r2silverman_factorzgaussian_kde.silverman_factors0TYs +C/dfQh@@@rAa0Computes the coefficient (`kde.factor`) that multiplies the data covariance matrix to obtain the kernel covariance matrix. The default is `scotts_factor`. A subclass can overwrite this method to provide a different method, or set it through a call to `kde.set_bandwidth`.c^ndkr j_ndkr j_nmtjr't t sd_fd_n2tr_fd_nd}t| dS)aXCompute the estimator bandwidth with given method. The new bandwidth calculated after a call to `set_bandwidth` is used for subsequent evaluations of the estimated density. Parameters ---------- bw_method : str, scalar or callable, optional The method used to calculate the estimator bandwidth. This can be 'scott', 'silverman', a scalar constant or a callable. If a scalar, this will be used directly as `kde.factor`. If a callable, it should take a `gaussian_kde` instance as only parameter and return a scalar. If None (default), nothing happens; the current `kde.covariance_factor` method is kept. Notes ----- .. versionadded:: 0.11 Examples -------- >>> import numpy as np >>> import scipy.stats as stats >>> x1 = np.array([-7, -5, 1, 4, 5.]) >>> kde = stats.gaussian_kde(x1) >>> xs = np.linspace(-10, 10, num=50) >>> y1 = kde(xs) >>> kde.set_bandwidth(bw_method='silverman') >>> y2 = kde(xs) >>> kde.set_bandwidth(bw_method=kde.factor / 3.) >>> y3 = kde(xs) >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots() >>> ax.plot(x1, np.full(x1.shape, 1 / (4. * x1.size)), 'bo', ... label='Data points (rescaled)') >>> ax.plot(xs, y1, label='Scott (default)') >>> ax.plot(xs, y2, label='Silverman') >>> ax.plot(xs, y3, label='Const (1/3 * Silverman)') >>> ax.legend() >>> plt.show() Nscott silvermanz use constantcSNrsr2z,gaussian_kde.set_bandwidth..5sYrAc.Sr) _bw_methodrsr2rz,gaussian_kde.set_bandwidth..8sT__T-B-BrAzC`bw_method` should be 'scott', 'silverman', a scalar or a callable.) rcovariance_factorrrHisscalar isinstancestrrcallabler"_compute_covariance)r/rr0s`` r2r-zgaussian_kde.set_bandwidthsX    ' ! !%)%7D " " + % %%)%:D " " [ # # "Jy#,F,F ",DO%6%6%6%6D " " i  "'DO%B%B%B%BD " "#CS// !   """""rAc J||_t|dsOtt |jdd|j|_tj |jd|_ |j|jdzz|_ |j |jz tj|_dtjtj|jtjdt&zzz|_dS) zcComputes the covariance matrix for each Gaussian kernel using covariance_factor(). _data_cho_covrFrowvarbiasaweightsT)lowerrN)rfactorhasattrrrr r)_data_covariancercholeskyrr8r&rHfloat64r:logdiagr r rlog_detrs r2rz gaussian_kde._compute_covariance@s,,.. t_-- =$.s4<498< 0F0F0F%G%GD !"(1F7;"="="=D /$+q.@*T[8@@LL  *,'!B$--)8!9!9:::=#%%@ rAc||_tt|jdd|j|_tj|j|jdzz S)NrFrr) rrrrr r)rrinvrs r2inv_covzgaussian_kde.inv_covRsj,,.. *3t|A05 ,N,N,N!O!Oz$/004;>AArAc,||S)z Evaluate the estimated pdf on a provided set of points. Notes ----- This is an alias for `gaussian_kde.evaluate`. See the ``evaluate`` docstring for more details. )r@)r/xs r2pdfzgaussian_kde.pdf^s}}QrAct|}|j\}}||jkrG|dkr%||jkrt||jdf}d}nd|d|j}t |t |j|\}}t||jj |j dddf|j |j |}|dddfS)zT Evaluate the log of the estimated pdf on a provided set of points. rr5r6Nr) rr#r$rr"r7r8rr r9r)r:) r/rr;r$r<r0r=r>r?s r2logpdfzgaussian_kde.logpdfjsA|1 ;;Avv!tv++ $&!559990499 oo%.tGG d-d3 LNDLD1 HdlL22aaad|rActj|}tj|jtjsd}t |t |j}|}|||dkz||dk<t tj |t |krd}t ||dk||kz}tj |rd||d|d}t ||j|}|j }t|| |S)a)Return a marginal KDE distribution Parameters ---------- dimensions : int or 1-d array_like The dimensions of the multivariate distribution corresponding with the marginal variables, that is, the indices of the dimensions that are being retained. The other dimensions are marginalized out. Returns ------- marginal_kde : gaussian_kde An object representing the marginal distribution. Notes ----- .. versionadded:: 1.10.0 zaElements of `dimensions` must be integers - the indices of the marginal variables being retained.rz,All elements of `dimensions` must be unique.z Dimensions z# are invalid for a distribution in z dimensions.)rr))rHr issubdtypedtypeintegerr"r+r copyuniqueanyr)rr) r/ dimensionsdimsr0r% original_dims i_invalidr r)s r2marginalzgaussian_kde.marginals=*}Z((}TZ44 "?CS// !    T$(^+TAX ry  3t99 , ,ACS// !AX$!), 6)   "<y!9<<,-<<>c~ |jS#t$r)dt|jdzz |_|jcYSwxYw)Nrr)r,rrr)rs r2rszgaussian_kde.neffsR :    3t|Q///DJ:    s  0<<)NNr)__name__ __module__ __qualname____doc__r3r@__call__rSr\rhror{rrrr-rpropertyrrrrr)rsrrAr2rr+sZZv$1$1$1$1L&&&PH333j!!!FB000d!!!!F000AAA&!  =#=#=#=#~@@@$ B BX B    0/-/-/-b!!X!XrActj||}tj|j}|dkrd}n$|dkrd}n|dvrd}nt |d|||fS)z Calculates the output dtype and the "spec" (=C type name). This was necessary in order to deal with the fused types in the Cython routine `gaussian_kernel_estimate`. See gh-10824 for details. r~r'double) z long doublez has unexpected item size: )rH common_typeritemsizer")r8r;r=rr>s r2r7r7s>*f55Lx %%.H1}} Q X  FFHFF   rA)# threadingrbscipyrrscipy._lib._utilrnumpyrrrr r r r r rrrrrrrrrHr_statsrr__all__Lockr`rr7rrAr2rs*"!!!!!!!//////JJJJJJJJ   9>  V V V V V V V V rrA