B {d B@sddlmZmZmZmZddlmZmZddlm Z e ddl Z ddl Z ddl Z ddlZddlmZddlmZddlmZmZddlmZGdd d eZdS) )divisionprint_functionabsolute_importunicode_literals)intopen)standard_libraryN) BaseEstimator)check_random_state)standardize_nd_sampleshift_and_scale_nd_samplec@seZdZdZd#ddZeddZejd dZed d Zed d Z ddZ d$ddZ ddZ d%ddZ ddZddZed&ddZddZdd Zd!d"ZdS)' GaussianKDEa GaussianKDE Kernel denstiy estimate using gaussian kernels and a local kernel bandwidth. Implements the ``sklearn.BaseEstimator`` class and can be used in a cross- validation gridsearch (``sklearn.model_selection``). Parameters ---------- glob_bw : float or str, optional The global bandwidth of the kernel, must be a float ``> 0`` or one of ``['silverman'|'scott']``. If ``alpha`` is not ``None``, this is the bandwidth used for the first estimate KDE from which the local bandwidth is calculated. ``If ['silverman'|'scott']`` a rule of thumb is used to estimate the global bandwidth. (default: 'silverman') alpha : float or None, optional If ``None``, only the global bandwidth ``glob_bw`` is used. If ``0 <= alpha <= 1``, an adaptive local kernel bandwith is used as described in [1]_. (default: 0.5) diag_cov : bool, optional If ``True``, scale fit sample by variance only, which means using a diagonal covariance matrix. (default: False) Notes ----- The unweighted kernel density estimator is defined as .. math: \hat{f}(x) = \sum_i rac{1}{h\lambda_i}\cdot K\left( rac{x - X_i}{h\lambda_i} ight) where the product :math:`h\lambda_i` takes the role of a local variance :math`\sigma_i^2`. The kernel bandwith is choosen locally to account for variations in the density of the data. Areas with large density gets smaller kernels and vice versa. This smoothes the tails and gets high resolution in high statistics regions. The local bandwidth parameter is defined as .. math: \lambda_i = (\hat{f}(X_i) / g)^{-lpha} where :math:`\log g = n^{-1}\sum_i \log\hat{f}(X_i)` is some normalization and :math:`\hat{f}(X_i)` the KDE estimate at the data point :math:`X_i`. The local bandwidth is multiplied to the global bandwidth for each kernel. Furthermore different scales in data is accounted for by scaling it via its covariance matrix to an equal spread. First a global kernel bandwidth is applied to the transformed data and then based on that density a local bandwidth parameter is applied. All credit for the method goes to [1]_ and to S. Schoenen and L. Raedel for huge parts of the implementation :+1:. For information on Silverman or Scott rule, see [2]_ or [3]_. References ---------- .. [1] B. Wang and X. Wang, "Bandwidth Selection for Weighted Kernel Density Estimation", Sep. 2007, DOI: 10.1214/154957804100000000. .. [2] D.W. Scott, "Multivariate Density Estimation: Theory, Practice, and Visualization", John Wiley & Sons, New York, Chicester, 1992. .. [3] B.W. Silverman, "Density Estimation for Statistics and Data Analysis", Vol. 26, Monographs on Statistics and Applied Probability, Chapman and Hall, London, 1986. silverman?FcCstt|tkr|dkr.tdn|dkr.tdd|_d|_d|_d|_d|_d|_d|_ d|_ ||_ ||_ ||_ dS)N)rscottz,glob_bw can be one of ['silverman'|'scott'].rzGlobal bandwidth must be > 0.)typestr ValueError _n_kernels _n_features_std_X_mean_cov _kde_values _inv_loc_bw _adaptivealpha_glob_bw _diag_cov)selfglob_bwrdiag_covr"X/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/awkde/awkde.py__init__Xs$ zGaussianKDE.__init__cCs|jS)N)_alpha)rr"r"r#rqszGaussianKDE.alphacCsP|dkrd|_n|dks |dkr(tdd|_||_|jdk rL|jrL|dS)z The adaptive width can easily be changed after the model has been fit, because the computation only needs the cached ``_kde_values``. NFrzalpha must be in [0, 1]T)rrr%r_calc_local_bandwidth)rrr"r"r#ruscCs|jS)N)r)rr"r"r#r szGaussianKDE.glob_bwcCs|jS)N)r)rr"r"r#r!szGaussianKDE.diag_covcCs|jj|jj_||S)N)predict__doc____call____func__)rXr"r"r#r*szGaussianKDE.__call__NcCs|dk rtd|dk r tdt|jdkr6td|j\|_|_t|dd|jd\|_|_ |_ | |j |_ |j r|j|jdd |_||j |j fS) a Prepare KDE to describe the data. Data is transformed via global covariance matrix to equalize scales in different features. Then a symmetric kernel with cov = diag(1) is used to describe the pdf at each point. Parameters ----------- X : array-like, shape (n_samples, n_features) Data points defining each kernel position. Each row is a point, each column is a feature. bounds : array-like, shape (n_features, 2) Boundary condition for each dimension. The method of mirrored points is used to improve prediction close to bounds. If no bound shall be given in a specific direction use ``None``, eg. ``[[0, None], ...]``. If ``bounds`` is ``None`` no bounds are used in any direction. (default: ``None``) weights : array-like, shape (n_samples), optional Per event weights to consider for ``X``. If ``None`` all weights are set to one. (default: ``None``) Returns ------- mean : array-like, shape (n_features) The (weighted) mean of the given data. cov : array-like, shape (n_features, n_features) The (weighted) covariance matrix of the given data. Raises ------ ``NotImplementedError`` if ``bounds`` or ``weights`` are not ``None``. NzTODO: Boundary conditions.z$TODO: Implement weighted statistics.z,`X` must have shape (n_samples, n_features).T)cholesky ret_statsdiagF)adaptive)NotImplementedErrorlenshaperrrr rrrr _get_glob_bwrr _evaluaterr')rr,Zboundsweightsr"r"r#fits#zGaussianKDE.fitcCsb|jdkrtdt|}|j\}}||jkr8tdt||j|jdd|j d}|j ||j dS)a Evaluate KDE at given points X. Parameters ----------- X : array-like, shape (n_samples, n_features) Data points we want to evaluate the KDE at. Each row is a point, each column is a feature. Returns ------- prob : array-like, shape (len(X)) The probability from the KDE pdf for each point in X. Nz$KDE has not been fitted to data yet.z/Dimensions of given points and KDE don't match.TF)ZmeanZcovr.r/r0)r1) rrnp atleast_2dr4rr rrrr6r)rr,_n_featr"r"r#r(s      zGaussianKDE.predictcCs|jdkrtdt|}|jd|j|d}|j|}t||j}|jrZ||j |9}| |d}t | |d|}t ||j|jS)a Get random samples from the KDE model. Parameters ---------- n_samples : int, optional Number of samples to generate. (default: 1) random_state : RandomState, optional Turn seed into a `np.random.RandomState` instance. Method from `sklearn.utils`. Can be None, int or RndState. (default: None) Returns ------- X : array_like, shape (n_samples, n_features) Generated samples from the fitted model. Nz$KDE has not been fitted to data yet.r)sizer&g?)rrr randintrr9onesrrrZreshaper:normalr rr)rZ n_samplesZ random_stateZrndgenidxZmeansinvbwsampler"r"r#rCs   zGaussianKDE.samplecCsr|jdkrtdt|}|j\}}||jkr8td|t|}t|dkr^tj St t |SdS)a Compute the total ln-probability of points X under the KDE model. Parameters ---------- X : array-like, shape (n_samples, n_features) Data points included in the score calculation. Each row is a point, each column is a feature. Returns ------- lnprob : float Total ln-likelihood of the data ``X`` given the KDE model. Nz$KDE has not been fitted to data yet.z/Dimensions of given points and KDE don't match.r) rrr9r:r4rr(anyinfsumlog)rr,r;r<Zprobsr"r"r#scores    zGaussianKDE.scorec Cs|jdkrtd|}dd|jD|d<t|j|d<dd|jD|d<|jdk rjt|j|d <nd|d <tjd d krd }nd }t t j ||}t j||ddWdQRXdS)a Write out the relevant parameters for the KDE model as a JSON file, which can be used to reconstruct the whole model with ``from_json``. Parameters ---------- fpath : string File path where to save the JSON dump. Nz$KDE has not been fitted to data yet.cSsg|] }t|qSr")list).0Xir"r"r# Csz'GaussianKDE.to_json.. kde_X_std kde_X_meancSsg|] }t|qSr")rI)rJrKr"r"r#rLEs kde_X_covkde_Yrwbwr-)objfpindent)rr get_paramsrIrrrsys version_inforospathabspathjsondump)rfpathoutmodefr"r"r#to_json5s  zGaussianKDE.to_jsonc Csrttj|d}t|}WdQRX||d|d|dd}t|d|_|jj \|_ |_ t |d|_ t|d |_t|j |j krtd |jj |j |j fkrtd |d dk r|ddkrtd t |d |_|d|_t|j|j kr td|rntd|td|jtd|jtd|jtd|j td|j |S)an Build a awKDE object from a JSON dict with the needed parts. Parameters ---------- fpath : string Path to the JSON file. Must have keys: - 'alpha', 'diag_cov', 'glob_bw': See GaussianKDE docstring. - 'kde_Y': KDE function values at points 'kde_X_std' used for the adaptive kernel computation. - 'kde_X_std': Standardized sample in shape ``(nsamples, nfeatures)``. - 'kde_X_mean': Mean vector of the standardized sample. - 'kde_X_cov': Covariance matrix of the stadardized sample. verb : bool, optional If ``True`` print model summary. (default: ``False``) Returns ------- kde : KDE.GaussianKDE KDE object in fitted state, ready to evaluate or sample from. rbNr rr!)r rr!rMrNrOz8'kde_X_mean' has not the same dimension as the X values.z3'kde_X_cov' has not shape (n_features, n_features).rPz*Saved 'alpha' is None, but 'kde_Y' is not.z/'kde_Y' has not the same length as 'kde_X_std'.zLoaded KDE model from {}z- glob_bw : {:.3f}z- alpha : {:.3f}z- adaptive : {}z- Nr. of kernels : {:d}z- Nr. of data dim : {:d})rrZr[r\r]loadr9r:rr4rrZ atleast_1drrr3rrrprintformatrr%r)clsr_verbrbdZkder"r"r# from_jsonVs6    zGaussianKDE.from_jsoncCsf|j}|j}t||j}|r*||j9}||ttjdtj |j |}t |j |||S)a- Evaluate KDE at given points, returning the log-probability. Parameters ----------- X : array-like, shape (n_samples, n_features) Data points we want to evaluate the KDE at. Each row is a point, each column is a feature. adaptive : bool, optional Wether to evaluate with fixed or with adaptive kernel. (default: True) Returns ------- prob : array-like, shape (len(X)) The probability from the KDE PDF for each point in X. r-)rrr9r?rrsqrtZlinalgZdetpirbackendZ kernel_sumr)rr,r1nrjrBZnormr"r"r#r6s *zGaussianKDE._evaluatecCsZ|j}|j}|dkr4t||ddd|dS|dkrPt|d|dS|jSdS)z9Simple wrapper to handle string args given for global bw.rg@g@grN)rrr9powerr)rr dimZnsamr"r"r#r5s zGaussianKDE._get_glob_bwcCs4ttt|j|j}|j||j|_dS)z7 Build the local bandwidth from cached ``_kde_values``.N)r9exprFrGrrr%r)rgr"r"r#r'sz!GaussianKDE._calc_local_bandwidth)rrF)NN)N)F)__name__ __module__ __qualname__r)r$propertyrsetterr r!r*r8r(rCrHrc classmethodrkr6r5r'r"r"r"r#r s"C     > %! @ r ) __future__rrrrbuiltinsrrfuturerZinstall_aliasesrZrXr]numpyr9Z sklearn.baser Z sklearn.utilsr Z awkde.toolsr r Z awkde.backendrnr r"r"r"r#s