eCi5vSrSSKrSSKJrJrJrJrJrJrJ r J r J r J r J r JrJrJr SSKJr S/r"SS5rg)a( This module was copied from the scipy project. In the process of copying, some methods were removed because they depended on other parts of scipy (especially on compiled components), allowing seaborn to have a simple and pure Python implementation. These include: - integrate_gaussian - integrate_box - integrate_box_1d - integrate_kde - logpdf - resample Additionally, the numpy.linalg module was substituted for scipy.linalg, and the examples section (with doctests) was removed from the docstring The original scipy license is copied below: Copyright (c) 2001-2002 Enthought, Inc. 2003-2019, SciPy Developers. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. N)asarray atleast_2dreshapezerosnewaxisdotexppisqrtpower atleast_1dsumonescov)linalg gaussian_kdec\rSrSrSrSSjrSr\rSrSr \r S\ lSS jr S r S r \S 5r\S 5rSrg)rQa 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`, with which the covariance matrix is multiplied. 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]_. 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 Ncf[[U55UlURRS:d [ S5eURR uUlUlUb[U5R[5Ul U=R[UR5-sl URRS:wa [ S5e[UR5UR:wa [ S5eS[URS-5- UlUR#US9 g)Nz.`dataset` input should have multiple elements.z*`weights` input should be one-dimensional.z%`weights` input should be of length n bw_method)rrdatasetsize ValueErrorshapednr astypefloat_weightsrweightsndimlen_neff set_bandwidth)selfrrr#s N/home/james-whalen/.local/lib/python3.13/site-packages/seaborn/external/kde.py__init__gaussian_kde.__init__s!''"23 ||  1$MN N++  &w/66u=DM MMS/ /M||  A% !MNN4==!TVV+ !HII3t}}a/00DJ Y/cp[[U55nURup#X R:waLUS:Xa)X0R:Xa[ XRS45nSnOSUSUR3n[ U5e[ R"URU5n[U4US9n[R"UR5n[XpR5n[Xq5n X0R:a[[!UR5HAn USS2U ["4U - n [%X-SS9S- n X`R&U [)U *5-- nMC OT[!U5HEn XSS2U ["4- n [%X-SS9S- n [%[)U *5UR&-SS9Xj'MG X`R*- nU$) 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. rzpoints have dimension z, dataset has dimension )dtypeNr)axis@)rrrrrrnp common_type covariancerrcholeskyinv_covrrrrangerrr#r _norm_factor) r(pointsrmmsg output_dtyperesult whiteningscaled_dataset scaled_pointsidiffenergys r)evaluategaussian_kde.evaluates(GFO,|| ;Av!vv+ &&!5.qc1I$&&R o%~~doov> t<0OODLL1 Y 5I. ;466]%aGm4}DT[q1C7,,q/#vg,66# 1X%aGm(DDT[q1C7VG T\\ 9B  +++ r,cN[URSURS-- 5$)zGCompute Scott's factor. Returns ------- s : float Scott's factor. r neffrr(s r) scotts_factorgaussian_kde.scotts_factors!TYYTVVAX//r,ct[URURS--S- SURS-- 5$)zSCompute the Silverman factor. Returns ------- s : float The silverman factor. r0g@rFrGrHrJs r)silverman_factorgaussian_kde.silverman_factors3TYYs +C/dffQh@@r,a0Computes 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`.cv^^TcOTS:XaTRTlOTS:XaTRTlOs[R"T5(a([ T[ 5(dSTlU4SjTlO0[T5(aTTlU4SjTlO Sn[U5eTR5 g)aCompute 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 Nscott silvermanz use constantc>T$Nrsr),gaussian_kde.set_bandwidth..GsYr,c&>TRT5$rT) _bw_methodrJsr)rVrWJsT__T-Br,zC`bw_method` should be 'scott', 'silverman', a scalar or a callable.) rKcovariance_factorrNr1isscalar isinstancestrrYcallabler_compute_covariance)r(rr:s`` r)r'gaussian_kde.set_bandwidth*s*    ' !%)%7%7D " + %%)%:%:D " [[ # #Jy#,F,F,DO%6D " i 'DO%BD "#CS/ !   "r,c UR5Ul[US5(dS[[ UR SSUR S95Ul[R"UR5Ul URURS--Ul URURS-- Ul [[R"S[-UR-55Ulg)zSComputes the covariance matrix for each Gaussian kernel using covariance_factor(). _data_inv_covrF)rowvarbiasaweightsrN)rZfactorhasattrrrrr#_data_covariancerinvrbr3r5r detr r7rJs r)r_ gaussian_kde._compute_covarianceRs,,. t_--$.s4<<498< 0F%GD !"(D,A,A!BD //$++q.@))DKKN:  AbD,@!ABr,c$URU5$)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. )rC)r(xs r)pdfgaussian_kde.pdfbs}}Qr,cUR$![a6 [UR5UR- UlURs$f=frT)r"AttributeErrorrrrJs r)r#gaussian_kde.weightsnsB !==  ! L/DM==  !s =A AcUR$![a/ S[URS-5- UlURs$f=f)Nrr)r&rqrr#rJs r)rIgaussian_kde.neffvsC ::  3t||Q//DJ::  s 6AA) rYrhrbr&r7r"r3rZrrrfr5r)NNrT)__name__ __module__ __qualname____firstlineno____doc__r*rC__call__rKrNrZr'r_rnpropertyr#rI__static_attributes__rUr,r)rrQsro`0$6pH0A&!  &#PC  !!r,)rynumpyr1rrrrrrr r r r r rrrr__all__rrUr,r)rs=2N<<<<  kkr,