|
|
|
|
# -------------------------------------------------------------------------
|
|
|
|
|
# Name: kdetools
|
|
|
|
|
# Purpose:
|
|
|
|
|
#
|
|
|
|
|
# Author: pab
|
|
|
|
|
#
|
|
|
|
|
# Created: 01.11.2008
|
|
|
|
|
# Copyright: (c) pab 2008
|
|
|
|
|
# Licence: LGPL
|
|
|
|
|
# -------------------------------------------------------------------------
|
|
|
|
|
#!/usr/bin/env python # @IgnorePep8
|
|
|
|
|
from __future__ import absolute_import, division
|
|
|
|
|
import copy
|
|
|
|
|
import numpy as np
|
|
|
|
|
import scipy
|
|
|
|
|
import warnings
|
|
|
|
|
from itertools import product
|
|
|
|
|
from scipy import interpolate, linalg, optimize, sparse, special, stats
|
|
|
|
|
from scipy.special import gamma
|
|
|
|
|
from numpy import pi, sqrt, atleast_2d, exp, newaxis # @UnresolvedImport
|
|
|
|
|
|
|
|
|
|
from .misc import meshgrid, nextpow2, tranproc # , trangood
|
|
|
|
|
from .containers import PlotData
|
|
|
|
|
from .dctpack import dct, dctn, idctn
|
|
|
|
|
from .plotbackend import plotbackend as plt
|
|
|
|
|
try:
|
|
|
|
|
from . import fig
|
|
|
|
|
except ImportError:
|
|
|
|
|
warnings.warn('fig import only supported on Windows')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _invnorm(q):
|
|
|
|
|
return special.ndtri(q)
|
|
|
|
|
|
|
|
|
|
_stats_epan = (1. / 5, 3. / 5, np.inf)
|
|
|
|
|
_stats_biwe = (1. / 7, 5. / 7, 45. / 2)
|
|
|
|
|
_stats_triw = (1. / 9, 350. / 429, np.inf)
|
|
|
|
|
_stats_rect = (1. / 3, 1. / 2, np.inf)
|
|
|
|
|
_stats_tria = (1. / 6, 2. / 3, np.inf)
|
|
|
|
|
_stats_lapl = (2, 1. / 4, np.inf)
|
|
|
|
|
_stats_logi = (pi ** 2 / 3, 1. / 6, 1 / 42)
|
|
|
|
|
_stats_gaus = (1, 1. / (2 * sqrt(pi)), 3. / (8 * sqrt(pi)))
|
|
|
|
|
|
|
|
|
|
__all__ = ['sphere_volume', 'TKDE', 'KDE', 'Kernel', 'accum', 'qlevels',
|
|
|
|
|
'iqrange', 'gridcount', 'kde_demo1', 'kde_demo2', 'test_docstrings']
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def sphere_volume(d, r=1.0):
|
|
|
|
|
"""
|
|
|
|
|
Returns volume of d-dimensional sphere with radius r
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
d : scalar or array_like
|
|
|
|
|
dimension of sphere
|
|
|
|
|
r : scalar or array_like
|
|
|
|
|
radius of sphere (default 1)
|
|
|
|
|
|
|
|
|
|
Example
|
|
|
|
|
-------
|
|
|
|
|
>>> sphere_volume(2., r=2.)
|
|
|
|
|
12.566370614359172
|
|
|
|
|
>>> sphere_volume(2., r=1.)
|
|
|
|
|
3.1415926535897931
|
|
|
|
|
|
|
|
|
|
Reference
|
|
|
|
|
---------
|
|
|
|
|
Wand,M.P. and Jones, M.C. (1995)
|
|
|
|
|
'Kernel smoothing'
|
|
|
|
|
Chapman and Hall, pp 105
|
|
|
|
|
"""
|
|
|
|
|
return (r ** d) * 2.0 * pi ** (d / 2.0) / (d * gamma(d / 2.0))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class KDEgauss(object):
|
|
|
|
|
|
|
|
|
|
""" Kernel-Density Estimator base class.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
data : (# of dims, # of data)-array
|
|
|
|
|
datapoints to estimate from
|
|
|
|
|
hs : array-like (optional)
|
|
|
|
|
smooting parameter vector/matrix.
|
|
|
|
|
(default compute from data using kernel.get_smoothing function)
|
|
|
|
|
alpha : real scalar (optional)
|
|
|
|
|
sensitivity parameter (default 0 regular KDE)
|
|
|
|
|
A good choice might be alpha = 0.5 ( or 1/D)
|
|
|
|
|
alpha = 0 Regular KDE (hs is constant)
|
|
|
|
|
0 < alpha <= 1 Adaptive KDE (Make hs change)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Members
|
|
|
|
|
-------
|
|
|
|
|
d : int
|
|
|
|
|
number of dimensions
|
|
|
|
|
n : int
|
|
|
|
|
number of datapoints
|
|
|
|
|
|
|
|
|
|
Methods
|
|
|
|
|
-------
|
|
|
|
|
kde.eval_grid_fast(x0, x1,..., xd) : array
|
|
|
|
|
evaluate the estimated pdf on meshgrid(x0, x1,..., xd)
|
|
|
|
|
kde(x0, x1,..., xd) : array
|
|
|
|
|
same as kde.eval_grid_fast(x0, x1,..., xd)
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
def __init__(self, data, hs=None, kernel=None, alpha=0.0, xmin=None,
|
|
|
|
|
xmax=None, inc=512):
|
|
|
|
|
self.dataset = atleast_2d(data)
|
|
|
|
|
self.hs = hs
|
|
|
|
|
self.kernel = kernel if kernel else Kernel('gauss')
|
|
|
|
|
self.alpha = alpha
|
|
|
|
|
self.xmin = xmin
|
|
|
|
|
self.xmax = xmax
|
|
|
|
|
self.inc = inc
|
|
|
|
|
self.initialize()
|
|
|
|
|
|
|
|
|
|
def initialize(self):
|
|
|
|
|
self.d, self.n = self.dataset.shape
|
|
|
|
|
self._set_xlimits()
|
|
|
|
|
self._initialize()
|
|
|
|
|
|
|
|
|
|
def _initialize(self):
|
|
|
|
|
self._compute_smoothing()
|
|
|
|
|
|
|
|
|
|
def _compute_smoothing(self):
|
|
|
|
|
"""Computes the smoothing matrix."""
|
|
|
|
|
get_smoothing = self.kernel.get_smoothing
|
|
|
|
|
h = self.hs
|
|
|
|
|
if h is None:
|
|
|
|
|
h = get_smoothing(self.dataset)
|
|
|
|
|
h = np.atleast_1d(h)
|
|
|
|
|
hsiz = h.shape
|
|
|
|
|
|
|
|
|
|
if (len(hsiz) == 1) or (self.d == 1):
|
|
|
|
|
if max(hsiz) == 1:
|
|
|
|
|
h = h * np.ones(self.d)
|
|
|
|
|
else:
|
|
|
|
|
h.shape = (self.d,) # make sure it has the correct dimension
|
|
|
|
|
|
|
|
|
|
# If h negative calculate automatic values
|
|
|
|
|
ind, = np.where(h <= 0)
|
|
|
|
|
for i in ind.tolist():
|
|
|
|
|
h[i] = get_smoothing(self.dataset[i])
|
|
|
|
|
deth = h.prod()
|
|
|
|
|
self.inv_hs = np.diag(1.0 / h)
|
|
|
|
|
else: # fully general smoothing matrix
|
|
|
|
|
deth = linalg.det(h)
|
|
|
|
|
if deth <= 0:
|
|
|
|
|
raise ValueError(
|
|
|
|
|
'bandwidth matrix h must be positive definit!')
|
|
|
|
|
self.inv_hs = linalg.inv(h)
|
|
|
|
|
self.hs = h
|
|
|
|
|
self._norm_factor = deth * self.n
|
|
|
|
|
|
|
|
|
|
def _set_xlimits(self):
|
|
|
|
|
amin = self.dataset.min(axis=-1)
|
|
|
|
|
amax = self.dataset.max(axis=-1)
|
|
|
|
|
iqr = iqrange(self.dataset, axis=-1)
|
|
|
|
|
sigma = np.minimum(np.std(self.dataset, axis=-1, ddof=1), iqr / 1.34)
|
|
|
|
|
# xyzrange = amax - amin
|
|
|
|
|
# offset = xyzrange / 4.0
|
|
|
|
|
offset = 2 * sigma
|
|
|
|
|
if self.xmin is None:
|
|
|
|
|
self.xmin = amin - offset
|
|
|
|
|
else:
|
|
|
|
|
self.xmin = self.xmin * np.ones((self.d, 1))
|
|
|
|
|
if self.xmax is None:
|
|
|
|
|
self.xmax = amax + offset
|
|
|
|
|
else:
|
|
|
|
|
self.xmax = self.xmax * np.ones((self.d, 1))
|
|
|
|
|
|
|
|
|
|
def eval_grid_fast(self, *args, **kwds):
|
|
|
|
|
"""Evaluate the estimated pdf on a grid.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
arg_0,arg_1,... arg_d-1 : vectors
|
|
|
|
|
Alternatively, if no vectors is passed in then
|
|
|
|
|
arg_i = linspace(self.xmin[i], self.xmax[i], self.inc)
|
|
|
|
|
output : string optional
|
|
|
|
|
'value' if value output
|
|
|
|
|
'data' if object output
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
values : array-like
|
|
|
|
|
The values evaluated at meshgrid(*args).
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
if len(args) == 0:
|
|
|
|
|
args = []
|
|
|
|
|
for i in range(self.d):
|
|
|
|
|
args.append(np.linspace(self.xmin[i], self.xmax[i], self.inc))
|
|
|
|
|
self.args = args
|
|
|
|
|
return self._eval_grid_fun(self._eval_grid_fast, *args, **kwds)
|
|
|
|
|
|
|
|
|
|
def _eval_grid_fast(self, *args, **kwds):
|
|
|
|
|
X = np.vstack(args)
|
|
|
|
|
d, inc = X.shape
|
|
|
|
|
# dx = X[:, 1] - X[:, 0]
|
|
|
|
|
R = X.max(axis=-1) - X.min(axis=-1)
|
|
|
|
|
|
|
|
|
|
t_star = (self.hs / R) ** 2
|
|
|
|
|
I = (np.asfarray(np.arange(0, inc)) * pi) ** 2
|
|
|
|
|
In = []
|
|
|
|
|
|
|
|
|
|
for i in range(d):
|
|
|
|
|
In.append(I * t_star[i] * 0.5)
|
|
|
|
|
|
|
|
|
|
Inc = meshgrid(*In) if d > 1 else In
|
|
|
|
|
|
|
|
|
|
kw = np.zeros((inc,) * d)
|
|
|
|
|
for i in range(d):
|
|
|
|
|
kw += exp(-Inc[i])
|
|
|
|
|
y = kwds.get('y', 1.0)
|
|
|
|
|
d, n = self.dataset.shape
|
|
|
|
|
# Find the binned kernel weights, c.
|
|
|
|
|
c = gridcount(self.dataset, X, y=y) / n
|
|
|
|
|
# Perform the convolution.
|
|
|
|
|
at = dctn(c) * kw
|
|
|
|
|
z = idctn(at) * at.size / np.prod(R)
|
|
|
|
|
return z * (z > 0.0)
|
|
|
|
|
|
|
|
|
|
def _eval_grid_fun(self, eval_grd, *args, **kwds):
|
|
|
|
|
output = kwds.pop('output', 'value')
|
|
|
|
|
f = eval_grd(*args, **kwds)
|
|
|
|
|
if output == 'value':
|
|
|
|
|
return f
|
|
|
|
|
else:
|
|
|
|
|
titlestr = 'Kernel density estimate (%s)' % self.kernel.name
|
|
|
|
|
kwds2 = dict(title=titlestr)
|
|
|
|
|
kwds2['plot_kwds'] = dict(plotflag=1)
|
|
|
|
|
kwds2.update(**kwds)
|
|
|
|
|
args = self.args
|
|
|
|
|
if self.d == 1:
|
|
|
|
|
args = args[0]
|
|
|
|
|
wdata = PlotData(f, args, **kwds2)
|
|
|
|
|
if self.d > 1:
|
|
|
|
|
PL = np.r_[10:90:20, 95, 99, 99.9]
|
|
|
|
|
try:
|
|
|
|
|
ql = qlevels(f, p=PL)
|
|
|
|
|
wdata.clevels = ql
|
|
|
|
|
wdata.plevels = PL
|
|
|
|
|
except:
|
|
|
|
|
pass
|
|
|
|
|
return wdata
|
|
|
|
|
|
|
|
|
|
def _check_shape(self, points):
|
|
|
|
|
points = atleast_2d(points)
|
|
|
|
|
d, m = points.shape
|
|
|
|
|
if d != self.d:
|
|
|
|
|
if d == 1 and m == self.d:
|
|
|
|
|
# points was passed in as a row vector
|
|
|
|
|
points = np.reshape(points, (self.d, 1))
|
|
|
|
|
else:
|
|
|
|
|
msg = "points have dimension %s, dataset has dimension %s"
|
|
|
|
|
raise ValueError(msg % (d, self.d))
|
|
|
|
|
return points
|
|
|
|
|
|
|
|
|
|
def eval_points(self, points, **kwds):
|
|
|
|
|
"""Evaluate 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.
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
points = self._check_shape(points)
|
|
|
|
|
return self._eval_points(points, **kwds)
|
|
|
|
|
|
|
|
|
|
def _eval_points(self, points, **kwds):
|
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
|
__call__ = eval_grid_fast
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class _KDE(object):
|
|
|
|
|
|
|
|
|
|
""" Kernel-Density Estimator base class.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
data : (# of dims, # of data)-array
|
|
|
|
|
datapoints to estimate from
|
|
|
|
|
hs : array-like (optional)
|
|
|
|
|
smooting parameter vector/matrix.
|
|
|
|
|
(default compute from data using kernel.get_smoothing function)
|
|
|
|
|
kernel : kernel function object.
|
|
|
|
|
kernel must have get_smoothing method
|
|
|
|
|
alpha : real scalar (optional)
|
|
|
|
|
sensitivity parameter (default 0 regular KDE)
|
|
|
|
|
A good choice might be alpha = 0.5 ( or 1/D)
|
|
|
|
|
alpha = 0 Regular KDE (hs is constant)
|
|
|
|
|
0 < alpha <= 1 Adaptive KDE (Make hs change)
|
|
|
|
|
|
|
|
|
|
Members
|
|
|
|
|
-------
|
|
|
|
|
d : int
|
|
|
|
|
number of dimensions
|
|
|
|
|
n : int
|
|
|
|
|
number of datapoints
|
|
|
|
|
|
|
|
|
|
Methods
|
|
|
|
|
-------
|
|
|
|
|
kde.eval_grid_fast(x0, x1,..., xd) : array
|
|
|
|
|
evaluate the estimated pdf on meshgrid(x0, x1,..., xd)
|
|
|
|
|
kde.eval_grid(x0, x1,..., xd) : array
|
|
|
|
|
evaluate the estimated pdf on meshgrid(x0, x1,..., xd)
|
|
|
|
|
kde.eval_points(points) : array
|
|
|
|
|
evaluate the estimated pdf on a provided set of points
|
|
|
|
|
kde(x0, x1,..., xd) : array
|
|
|
|
|
same as kde.eval_grid(x0, x1,..., xd)
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
def __init__(self, data, hs=None, kernel=None, alpha=0.0, xmin=None,
|
|
|
|
|
xmax=None, inc=512):
|
|
|
|
|
self.dataset = atleast_2d(data)
|
|
|
|
|
self.hs = hs
|
|
|
|
|
self.kernel = kernel if kernel else Kernel('gauss')
|
|
|
|
|
self.alpha = alpha
|
|
|
|
|
self.xmin = xmin
|
|
|
|
|
self.xmax = xmax
|
|
|
|
|
self.inc = inc
|
|
|
|
|
self.initialize()
|
|
|
|
|
|
|
|
|
|
def initialize(self):
|
|
|
|
|
self.d, self.n = self.dataset.shape
|
|
|
|
|
if self.n > 1:
|
|
|
|
|
self._set_xlimits()
|
|
|
|
|
self._initialize()
|
|
|
|
|
|
|
|
|
|
def _initialize(self):
|
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
|
def _set_xlimits(self):
|
|
|
|
|
amin = self.dataset.min(axis=-1)
|
|
|
|
|
amax = self.dataset.max(axis=-1)
|
|
|
|
|
iqr = iqrange(self.dataset, axis=-1)
|
|
|
|
|
self._sigma = np.minimum(
|
|
|
|
|
np.std(self.dataset, axis=-1, ddof=1), iqr / 1.34)
|
|
|
|
|
# xyzrange = amax - amin
|
|
|
|
|
# offset = xyzrange / 4.0
|
|
|
|
|
offset = self._sigma
|
|
|
|
|
if self.xmin is None:
|
|
|
|
|
self.xmin = amin - offset
|
|
|
|
|
else:
|
|
|
|
|
self.xmin = self.xmin * np.ones((self.d, 1))
|
|
|
|
|
if self.xmax is None:
|
|
|
|
|
self.xmax = amax + offset
|
|
|
|
|
else:
|
|
|
|
|
self.xmax = self.xmax * np.ones((self.d, 1))
|
|
|
|
|
|
|
|
|
|
def get_args(self, xmin=None, xmax=None):
|
|
|
|
|
if xmin is None:
|
|
|
|
|
xmin = self.xmin
|
|
|
|
|
else:
|
|
|
|
|
xmin = [min(i, j) for i, j in zip(xmin, self.xmin)]
|
|
|
|
|
if xmax is None:
|
|
|
|
|
xmax = self.xmax
|
|
|
|
|
else:
|
|
|
|
|
xmax = [max(i, j) for i, j in zip(xmax, self.xmax)]
|
|
|
|
|
args = []
|
|
|
|
|
for i in range(self.d):
|
|
|
|
|
args.append(np.linspace(xmin[i], xmax[i], self.inc))
|
|
|
|
|
return args
|
|
|
|
|
|
|
|
|
|
def eval_grid_fast(self, *args, **kwds):
|
|
|
|
|
"""Evaluate the estimated pdf on a grid.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
arg_0,arg_1,... arg_d-1 : vectors
|
|
|
|
|
Alternatively, if no vectors is passed in then
|
|
|
|
|
arg_i = linspace(self.xmin[i], self.xmax[i], self.inc)
|
|
|
|
|
output : string optional
|
|
|
|
|
'value' if value output
|
|
|
|
|
'data' if object output
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
values : array-like
|
|
|
|
|
The values evaluated at meshgrid(*args).
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
if len(args) == 0:
|
|
|
|
|
args = self.get_args()
|
|
|
|
|
self.args = args
|
|
|
|
|
return self._eval_grid_fun(self._eval_grid_fast, *args, **kwds)
|
|
|
|
|
|
|
|
|
|
def _eval_grid_fast(self, *args, **kwds):
|
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
|
def eval_grid(self, *args, **kwds):
|
|
|
|
|
"""Evaluate the estimated pdf on a grid.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
arg_0,arg_1,... arg_d-1 : vectors
|
|
|
|
|
Alternatively, if no vectors is passed in then
|
|
|
|
|
arg_i = linspace(self.xmin[i], self.xmax[i], self.inc)
|
|
|
|
|
output : string optional
|
|
|
|
|
'value' if value output
|
|
|
|
|
'data' if object output
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
values : array-like
|
|
|
|
|
The values evaluated at meshgrid(*args).
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
if len(args) == 0:
|
|
|
|
|
args = []
|
|
|
|
|
for i in range(self.d):
|
|
|
|
|
args.append(np.linspace(self.xmin[i], self.xmax[i], self.inc))
|
|
|
|
|
self.args = args
|
|
|
|
|
return self._eval_grid_fun(self._eval_grid, *args, **kwds)
|
|
|
|
|
|
|
|
|
|
def _eval_grid(self, *args):
|
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
|
def _eval_grid_fun(self, eval_grd, *args, **kwds):
|
|
|
|
|
output = kwds.pop('output', 'value')
|
|
|
|
|
f = eval_grd(*args, **kwds)
|
|
|
|
|
if output == 'value':
|
|
|
|
|
return f
|
|
|
|
|
else:
|
|
|
|
|
titlestr = 'Kernel density estimate (%s)' % self.kernel.name
|
|
|
|
|
kwds2 = dict(title=titlestr)
|
|
|
|
|
|
|
|
|
|
kwds2['plot_kwds'] = kwds.pop('plot_kwds', dict(plotflag=1))
|
|
|
|
|
kwds2.update(**kwds)
|
|
|
|
|
args = self.args
|
|
|
|
|
if self.d == 1:
|
|
|
|
|
args = args[0]
|
|
|
|
|
wdata = PlotData(f, args, **kwds2)
|
|
|
|
|
if self.d > 1:
|
|
|
|
|
PL = np.r_[10:90:20, 95, 99, 99.9]
|
|
|
|
|
try:
|
|
|
|
|
ql = qlevels(f, p=PL)
|
|
|
|
|
wdata.clevels = ql
|
|
|
|
|
wdata.plevels = PL
|
|
|
|
|
except:
|
|
|
|
|
pass
|
|
|
|
|
return wdata
|
|
|
|
|
|
|
|
|
|
def _check_shape(self, points):
|
|
|
|
|
points = atleast_2d(points)
|
|
|
|
|
d, m = points.shape
|
|
|
|
|
if d != self.d:
|
|
|
|
|
if d == 1 and m == self.d:
|
|
|
|
|
# points was passed in as a row vector
|
|
|
|
|
points = np.reshape(points, (self.d, 1))
|
|
|
|
|
else:
|
|
|
|
|
msg = "points have dimension %s, dataset has dimension %s"
|
|
|
|
|
raise ValueError(msg % (d, self.d))
|
|
|
|
|
return points
|
|
|
|
|
|
|
|
|
|
def eval_points(self, points, **kwds):
|
|
|
|
|
"""Evaluate 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.
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
points = self._check_shape(points)
|
|
|
|
|
return self._eval_points(points, **kwds)
|
|
|
|
|
|
|
|
|
|
def _eval_points(self, points, **kwds):
|
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
|
__call__ = eval_grid
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class TKDE(_KDE):
|
|
|
|
|
|
|
|
|
|
""" Transformation Kernel-Density Estimator.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
dataset : (# of dims, # of data)-array
|
|
|
|
|
datapoints to estimate from
|
|
|
|
|
hs : array-like (optional)
|
|
|
|
|
smooting parameter vector/matrix.
|
|
|
|
|
(default compute from data using kernel.get_smoothing function)
|
|
|
|
|
kernel : kernel function object.
|
|
|
|
|
kernel must have get_smoothing method
|
|
|
|
|
alpha : real scalar (optional)
|
|
|
|
|
sensitivity parameter (default 0 regular KDE)
|
|
|
|
|
A good choice might be alpha = 0.5 ( or 1/D)
|
|
|
|
|
alpha = 0 Regular KDE (hs is constant)
|
|
|
|
|
0 < alpha <= 1 Adaptive KDE (Make hs change)
|
|
|
|
|
xmin, xmax : vectors
|
|
|
|
|
specifying the default argument range for the kde.eval_grid methods.
|
|
|
|
|
For the kde.eval_grid_fast methods the values must cover the range of
|
|
|
|
|
the data. (default min(data)-range(data)/4, max(data)-range(data)/4)
|
|
|
|
|
If a single value of xmin or xmax is given then the boundary is the is
|
|
|
|
|
the same for all dimensions.
|
|
|
|
|
inc : scalar integer
|
|
|
|
|
defining the default dimension of the output from kde.eval_grid methods
|
|
|
|
|
(default 512)
|
|
|
|
|
(For kde.eval_grid_fast: A value below 50 is very fast to compute but
|
|
|
|
|
may give some inaccuracies. Values between 100 and 500 give very
|
|
|
|
|
accurate results)
|
|
|
|
|
L2 : array-like
|
|
|
|
|
vector of transformation parameters (default 1 no transformation)
|
|
|
|
|
t(xi;L2) = xi^L2*sign(L2) for L2(i) ~= 0
|
|
|
|
|
t(xi;L2) = log(xi) for L2(i) == 0
|
|
|
|
|
If single value of L2 is given then the transformation is the same in
|
|
|
|
|
all directions.
|
|
|
|
|
|
|
|
|
|
Members
|
|
|
|
|
-------
|
|
|
|
|
d : int
|
|
|
|
|
number of dimensions
|
|
|
|
|
n : int
|
|
|
|
|
number of datapoints
|
|
|
|
|
|
|
|
|
|
Methods
|
|
|
|
|
-------
|
|
|
|
|
kde.eval_grid_fast(x0, x1,..., xd) : array
|
|
|
|
|
evaluate the estimated pdf on meshgrid(x0, x1,..., xd)
|
|
|
|
|
kde.eval_grid(x0, x1,..., xd) : array
|
|
|
|
|
evaluate the estimated pdf on meshgrid(x0, x1,..., xd)
|
|
|
|
|
kde.eval_points(points) : array
|
|
|
|
|
evaluate the estimated pdf on a provided set of points
|
|
|
|
|
kde(x0, x1,..., xd) : array
|
|
|
|
|
same as kde.eval_grid(x0, x1,..., xd)
|
|
|
|
|
|
|
|
|
|
Example
|
|
|
|
|
-------
|
|
|
|
|
N = 20
|
|
|
|
|
data = np.random.rayleigh(1, size=(N,))
|
|
|
|
|
>>> data = np.array([
|
|
|
|
|
... 0.75355792, 0.72779194, 0.94149169, 0.07841119,2.32291887,
|
|
|
|
|
... 1.10419995, 0.77055114, 0.60288273, 1.36883635, 1.74754326,
|
|
|
|
|
... 1.09547561, 1.01671133, 0.73211143, 0.61891719, 0.75903487,
|
|
|
|
|
... 1.8919469 , 0.72433808, 1.92973094, 0.44749838, 1.36508452])
|
|
|
|
|
|
|
|
|
|
>>> import wafo.kdetools as wk
|
|
|
|
|
>>> x = np.linspace(0.01, max(data.ravel()) + 1, 10)
|
|
|
|
|
>>> kde = wk.TKDE(data, hs=0.5, L2=0.5)
|
|
|
|
|
>>> f = kde(x)
|
|
|
|
|
>>> f
|
|
|
|
|
array([ 1.03982714, 0.45839018, 0.39514782, 0.32860602, 0.26433318,
|
|
|
|
|
0.20717946, 0.15907684, 0.1201074 , 0.08941027, 0.06574882])
|
|
|
|
|
|
|
|
|
|
>>> kde.eval_grid(x)
|
|
|
|
|
array([ 1.03982714, 0.45839018, 0.39514782, 0.32860602, 0.26433318,
|
|
|
|
|
0.20717946, 0.15907684, 0.1201074 , 0.08941027, 0.06574882])
|
|
|
|
|
|
|
|
|
|
>>> kde.eval_grid_fast(x)
|
|
|
|
|
array([ 1.04018924, 0.45838973, 0.39514689, 0.32860532, 0.26433301,
|
|
|
|
|
0.20717976, 0.15907697, 0.1201077 , 0.08941129, 0.06574899])
|
|
|
|
|
|
|
|
|
|
import pylab as plb
|
|
|
|
|
h1 = plb.plot(x, f) # 1D probability density plot
|
|
|
|
|
t = np.trapz(f, x)
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
def __init__(self, data, hs=None, kernel=None, alpha=0.0, xmin=None,
|
|
|
|
|
xmax=None, inc=512, L2=None):
|
|
|
|
|
self.L2 = L2
|
|
|
|
|
super(TKDE, self).__init__(data, hs, kernel, alpha, xmin, xmax, inc)
|
|
|
|
|
|
|
|
|
|
def _initialize(self):
|
|
|
|
|
self._check_xmin()
|
|
|
|
|
tdataset = self._dat2gaus(self.dataset)
|
|
|
|
|
xmin = self.xmin
|
|
|
|
|
if xmin is not None:
|
|
|
|
|
xmin = self._dat2gaus(np.reshape(xmin, (-1, 1)))
|
|
|
|
|
xmax = self.xmax
|
|
|
|
|
if xmax is not None:
|
|
|
|
|
xmax = self._dat2gaus(np.reshape(xmax, (-1, 1)))
|
|
|
|
|
self.tkde = KDE(tdataset, self.hs, self.kernel, self.alpha, xmin, xmax,
|
|
|
|
|
self.inc)
|
|
|
|
|
if self.inc is None:
|
|
|
|
|
self.inc = self.tkde.inc
|
|
|
|
|
|
|
|
|
|
def _check_xmin(self):
|
|
|
|
|
if self.L2 is not None:
|
|
|
|
|
amin = self.dataset.min(axis=-1)
|
|
|
|
|
# default no transformation
|
|
|
|
|
L2 = np.atleast_1d(self.L2) * np.ones(self.d)
|
|
|
|
|
self.xmin = np.where(L2 != 1, np.maximum(
|
|
|
|
|
self.xmin, amin / 100.0), self.xmin).reshape((-1, 1))
|
|
|
|
|
|
|
|
|
|
def _dat2gaus(self, points):
|
|
|
|
|
if self.L2 is None:
|
|
|
|
|
return points # default no transformation
|
|
|
|
|
|
|
|
|
|
# default no transformation
|
|
|
|
|
L2 = np.atleast_1d(self.L2) * np.ones(self.d)
|
|
|
|
|
|
|
|
|
|
tpoints = copy.copy(points)
|
|
|
|
|
for i, v2 in enumerate(L2.tolist()):
|
|
|
|
|
tpoints[i] = np.log(points[i]) if v2 == 0 else points[i] ** v2
|
|
|
|
|
return tpoints
|
|
|
|
|
|
|
|
|
|
def _gaus2dat(self, tpoints):
|
|
|
|
|
if self.L2 is None:
|
|
|
|
|
return tpoints # default no transformation
|
|
|
|
|
|
|
|
|
|
# default no transformation
|
|
|
|
|
L2 = np.atleast_1d(self.L2) * np.ones(self.d)
|
|
|
|
|
|
|
|
|
|
points = copy.copy(tpoints)
|
|
|
|
|
for i, v2 in enumerate(L2.tolist()):
|
|
|
|
|
points[i] = np.exp(
|
|
|
|
|
tpoints[i]) if v2 == 0 else tpoints[i] ** (1.0 / v2)
|
|
|
|
|
return points
|
|
|
|
|
|
|
|
|
|
def _scale_pdf(self, pdf, points):
|
|
|
|
|
if self.L2 is None:
|
|
|
|
|
return pdf
|
|
|
|
|
# default no transformation
|
|
|
|
|
L2 = np.atleast_1d(self.L2) * np.ones(self.d)
|
|
|
|
|
for i, v2 in enumerate(L2.tolist()):
|
|
|
|
|
factor = v2 * np.sign(v2) if v2 else 1
|
|
|
|
|
pdf *= np.where(v2 == 1, 1, points[i] ** (v2 - 1) * factor)
|
|
|
|
|
if (np.abs(np.diff(pdf)).max() > 10).any():
|
|
|
|
|
msg = ''' Numerical problems may have occured due to the power
|
|
|
|
|
transformation. Check the KDE for spurious spikes'''
|
|
|
|
|
warnings.warn(msg)
|
|
|
|
|
return pdf
|
|
|
|
|
|
|
|
|
|
def eval_grid_fast2(self, *args, **kwds):
|
|
|
|
|
"""Evaluate the estimated pdf on a grid.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
arg_0,arg_1,... arg_d-1 : vectors
|
|
|
|
|
Alternatively, if no vectors is passed in then
|
|
|
|
|
arg_i = gauss2dat(linspace(dat2gauss(self.xmin[i]),
|
|
|
|
|
dat2gauss(self.xmax[i]), self.inc))
|
|
|
|
|
output : string optional
|
|
|
|
|
'value' if value output
|
|
|
|
|
'data' if object output
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
values : array-like
|
|
|
|
|
The values evaluated at meshgrid(*args).
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
return self._eval_grid_fun(self._eval_grid_fast, *args, **kwds)
|
|
|
|
|
|
|
|
|
|
def _eval_grid_fast(self, *args, **kwds):
|
|
|
|
|
if self.L2 is None:
|
|
|
|
|
f = self.tkde.eval_grid_fast(*args, **kwds)
|
|
|
|
|
self.args = self.tkde.args
|
|
|
|
|
return f
|
|
|
|
|
targs = []
|
|
|
|
|
if len(args):
|
|
|
|
|
targs0 = self._dat2gaus(list(args))
|
|
|
|
|
xmin = [min(t) for t in targs0]
|
|
|
|
|
xmax = [max(t) for t in targs0]
|
|
|
|
|
targs = self.tkde.get_args(xmin, xmax)
|
|
|
|
|
tf = self.tkde.eval_grid_fast(*targs)
|
|
|
|
|
self.args = self._gaus2dat(list(self.tkde.args))
|
|
|
|
|
points = meshgrid(*self.args) if self.d > 1 else self.args
|
|
|
|
|
f = self._scale_pdf(tf, points)
|
|
|
|
|
if len(args):
|
|
|
|
|
ipoints = meshgrid(*args) if self.d > 1 else args
|
|
|
|
|
# shape0 = points[0].shape
|
|
|
|
|
# shape0i = ipoints[0].shape
|
|
|
|
|
for i in range(self.d):
|
|
|
|
|
points[i].shape = (-1,)
|
|
|
|
|
# ipoints[i].shape = (-1,)
|
|
|
|
|
points = np.asarray(points).T
|
|
|
|
|
# ipoints = np.asarray(ipoints).T
|
|
|
|
|
fi = interpolate.griddata(points, f.ravel(), tuple(ipoints),
|
|
|
|
|
method='linear',
|
|
|
|
|
fill_value=0.0)
|
|
|
|
|
# fi.shape = shape0i
|
|
|
|
|
self.args = args
|
|
|
|
|
r = kwds.get('r', 0)
|
|
|
|
|
if r == 0:
|
|
|
|
|
return fi * (fi > 0)
|
|
|
|
|
else:
|
|
|
|
|
return fi
|
|
|
|
|
return f
|
|
|
|
|
|
|
|
|
|
def _eval_grid(self, *args, **kwds):
|
|
|
|
|
if self.L2 is None:
|
|
|
|
|
return self.tkde.eval_grid(*args, **kwds)
|
|
|
|
|
targs = self._dat2gaus(list(args))
|
|
|
|
|
tf = self.tkde.eval_grid(*targs, **kwds)
|
|
|
|
|
points = meshgrid(*args) if self.d > 1 else self.args
|
|
|
|
|
f = self._scale_pdf(tf, points)
|
|
|
|
|
return f
|
|
|
|
|
|
|
|
|
|
def _eval_points(self, points):
|
|
|
|
|
"""Evaluate 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.
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
if self.L2 is None:
|
|
|
|
|
return self.tkde.eval_points(points)
|
|
|
|
|
|
|
|
|
|
tpoints = self._dat2gaus(points)
|
|
|
|
|
tf = self.tkde.eval_points(tpoints)
|
|
|
|
|
f = self._scale_pdf(tf, points)
|
|
|
|
|
return f
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class KDE(_KDE):
|
|
|
|
|
|
|
|
|
|
""" Kernel-Density Estimator.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
data : (# of dims, # of data)-array
|
|
|
|
|
datapoints to estimate from
|
|
|
|
|
hs : array-like (optional)
|
|
|
|
|
smooting parameter vector/matrix.
|
|
|
|
|
(default compute from data using kernel.get_smoothing function)
|
|
|
|
|
kernel : kernel function object.
|
|
|
|
|
kernel must have get_smoothing method
|
|
|
|
|
alpha : real scalar (optional)
|
|
|
|
|
sensitivity parameter (default 0 regular KDE)
|
|
|
|
|
A good choice might be alpha = 0.5 ( or 1/D)
|
|
|
|
|
alpha = 0 Regular KDE (hs is constant)
|
|
|
|
|
0 < alpha <= 1 Adaptive KDE (Make hs change)
|
|
|
|
|
xmin, xmax : vectors
|
|
|
|
|
specifying the default argument range for the kde.eval_grid methods.
|
|
|
|
|
For the kde.eval_grid_fast methods the values must cover the range of
|
|
|
|
|
the data.
|
|
|
|
|
(default min(data)-range(data)/4, max(data)-range(data)/4)
|
|
|
|
|
If a single value of xmin or xmax is given then the boundary is the is
|
|
|
|
|
the same for all dimensions.
|
|
|
|
|
inc : scalar integer (default 512)
|
|
|
|
|
defining the default dimension of the output from kde.eval_grid methods
|
|
|
|
|
(For kde.eval_grid_fast: A value below 50 is very fast to compute but
|
|
|
|
|
may give some inaccuracies. Values between 100 and 500 give very
|
|
|
|
|
accurate results)
|
|
|
|
|
|
|
|
|
|
Members
|
|
|
|
|
-------
|
|
|
|
|
d : int
|
|
|
|
|
number of dimensions
|
|
|
|
|
n : int
|
|
|
|
|
number of datapoints
|
|
|
|
|
|
|
|
|
|
Methods
|
|
|
|
|
-------
|
|
|
|
|
kde.eval_grid_fast(x0, x1,..., xd) : array
|
|
|
|
|
evaluate the estimated pdf on meshgrid(x0, x1,..., xd)
|
|
|
|
|
kde.eval_grid(x0, x1,..., xd) : array
|
|
|
|
|
evaluate the estimated pdf on meshgrid(x0, x1,..., xd)
|
|
|
|
|
kde.eval_points(points) : array
|
|
|
|
|
evaluate the estimated pdf on a provided set of points
|
|
|
|
|
kde(x0, x1,..., xd) : array
|
|
|
|
|
same as kde.eval_grid(x0, x1,..., xd)
|
|
|
|
|
|
|
|
|
|
Example
|
|
|
|
|
-------
|
|
|
|
|
N = 20
|
|
|
|
|
data = np.random.rayleigh(1, size=(N,))
|
|
|
|
|
>>> data = np.array([
|
|
|
|
|
... 0.75355792, 0.72779194, 0.94149169, 0.07841119, 2.32291887,
|
|
|
|
|
... 1.10419995, 0.77055114, 0.60288273, 1.36883635, 1.74754326,
|
|
|
|
|
... 1.09547561, 1.01671133, 0.73211143, 0.61891719, 0.75903487,
|
|
|
|
|
... 1.8919469 , 0.72433808, 1.92973094, 0.44749838, 1.36508452])
|
|
|
|
|
|
|
|
|
|
>>> x = np.linspace(0, max(data.ravel()) + 1, 10)
|
|
|
|
|
>>> import wafo.kdetools as wk
|
|
|
|
|
>>> kde = wk.KDE(data, hs=0.5, alpha=0.5)
|
|
|
|
|
>>> f = kde(x)
|
|
|
|
|
>>> f
|
|
|
|
|
array([ 0.17252055, 0.41014271, 0.61349072, 0.57023834, 0.37198073,
|
|
|
|
|
0.21409279, 0.12738463, 0.07460326, 0.03956191, 0.01887164])
|
|
|
|
|
|
|
|
|
|
>>> kde.eval_grid(x)
|
|
|
|
|
array([ 0.17252055, 0.41014271, 0.61349072, 0.57023834, 0.37198073,
|
|
|
|
|
0.21409279, 0.12738463, 0.07460326, 0.03956191, 0.01887164])
|
|
|
|
|
|
|
|
|
|
>>> kde0 = wk.KDE(data, hs=0.5, alpha=0.0)
|
|
|
|
|
>>> kde0.eval_points(x)
|
|
|
|
|
array([ 0.2039735 , 0.40252503, 0.54595078, 0.52219649, 0.3906213 ,
|
|
|
|
|
0.26381501, 0.16407362, 0.08270612, 0.02991145, 0.00720821])
|
|
|
|
|
|
|
|
|
|
>>> kde0.eval_grid(x)
|
|
|
|
|
array([ 0.2039735 , 0.40252503, 0.54595078, 0.52219649, 0.3906213 ,
|
|
|
|
|
0.26381501, 0.16407362, 0.08270612, 0.02991145, 0.00720821])
|
|
|
|
|
>>> f = kde0.eval_grid(x, output='plotobj')
|
|
|
|
|
>>> f.data
|
|
|
|
|
array([ 0.2039735 , 0.40252503, 0.54595078, 0.52219649, 0.3906213 ,
|
|
|
|
|
0.26381501, 0.16407362, 0.08270612, 0.02991145, 0.00720821])
|
|
|
|
|
|
|
|
|
|
>>> f = kde0.eval_grid_fast()
|
|
|
|
|
>>> np.allclose(np.interp(x, kde0.args[0], f),
|
|
|
|
|
... [ 0.20397743, 0.40252228, 0.54594119, 0.52219025, 0.39062189,
|
|
|
|
|
... 0.2638171 , 0.16407487, 0.08270755, 0.04784434, 0.04784434])
|
|
|
|
|
True
|
|
|
|
|
>>> f1 = kde0.eval_grid_fast(output='plot')
|
|
|
|
|
>>> np.allclose(np.interp(x, f1.args, f1.data),
|
|
|
|
|
... [ 0.20397743, 0.40252228, 0.54594119, 0.52219025, 0.39062189,
|
|
|
|
|
... 0.2638171 , 0.16407487, 0.08270755, 0.04784434, 0.04784434])
|
|
|
|
|
True
|
|
|
|
|
>>> h = f1.plot()
|
|
|
|
|
|
|
|
|
|
import pylab as plb
|
|
|
|
|
h1 = plb.plot(x, f) # 1D probability density plot
|
|
|
|
|
t = np.trapz(f, x)
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
def __init__(self, data, hs=None, kernel=None, alpha=0.0, xmin=None,
|
|
|
|
|
xmax=None, inc=512):
|
|
|
|
|
super(KDE, self).__init__(data, hs, kernel, alpha, xmin, xmax, inc)
|
|
|
|
|
|
|
|
|
|
def _initialize(self):
|
|
|
|
|
self._compute_smoothing()
|
|
|
|
|
self._lambda = np.ones(self.n)
|
|
|
|
|
if self.alpha > 0:
|
|
|
|
|
# pilt = KDE(self.dataset, hs=self.hs, kernel=self.kernel, alpha=0)
|
|
|
|
|
# f = pilt.eval_points(self.dataset) # get a pilot estimate by
|
|
|
|
|
# regular KDE (alpha=0)
|
|
|
|
|
f = self.eval_points(self.dataset) # pilot estimate
|
|
|
|
|
g = np.exp(np.mean(np.log(f)))
|
|
|
|
|
self._lambda = (f / g) ** (-self.alpha)
|
|
|
|
|
|
|
|
|
|
if self.inc is None:
|
|
|
|
|
unused_tau, tau = self.kernel.effective_support()
|
|
|
|
|
xyzrange = 8 * self._sigma
|
|
|
|
|
L1 = 10
|
|
|
|
|
self.inc = 2 ** nextpow2(
|
|
|
|
|
max(48, (L1 * xyzrange / (tau * self.hs)).max()))
|
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
|
def _compute_smoothing(self):
|
|
|
|
|
"""Computes the smoothing matrix."""
|
|
|
|
|
get_smoothing = self.kernel.get_smoothing
|
|
|
|
|
h = self.hs
|
|
|
|
|
if h is None:
|
|
|
|
|
h = get_smoothing(self.dataset)
|
|
|
|
|
h = np.atleast_1d(h)
|
|
|
|
|
hsiz = h.shape
|
|
|
|
|
|
|
|
|
|
if (len(hsiz) == 1) or (self.d == 1):
|
|
|
|
|
if max(hsiz) == 1:
|
|
|
|
|
h = h * np.ones(self.d)
|
|
|
|
|
else:
|
|
|
|
|
h.shape = (self.d,) # make sure it has the correct dimension
|
|
|
|
|
|
|
|
|
|
# If h negative calculate automatic values
|
|
|
|
|
ind, = np.where(h <= 0)
|
|
|
|
|
for i in ind.tolist():
|
|
|
|
|
h[i] = get_smoothing(self.dataset[i])
|
|
|
|
|
deth = h.prod()
|
|
|
|
|
self.inv_hs = np.diag(1.0 / h)
|
|
|
|
|
else: # fully general smoothing matrix
|
|
|
|
|
deth = linalg.det(h)
|
|
|
|
|
if deth <= 0:
|
|
|
|
|
raise ValueError(
|
|
|
|
|
'bandwidth matrix h must be positive definit!')
|
|
|
|
|
self.inv_hs = linalg.inv(h)
|
|
|
|
|
self.hs = h
|
|
|
|
|
self._norm_factor = deth * self.n
|
|
|
|
|
|
|
|
|
|
def _eval_grid_fast(self, *args, **kwds):
|
|
|
|
|
X = np.vstack(args)
|
|
|
|
|
d, inc = X.shape
|
|
|
|
|
dx = X[:, 1] - X[:, 0]
|
|
|
|
|
|
|
|
|
|
Xn = []
|
|
|
|
|
nfft0 = 2 * inc
|
|
|
|
|
nfft = (nfft0,) * d
|
|
|
|
|
x0 = np.linspace(-inc, inc, nfft0 + 1)
|
|
|
|
|
for i in range(d):
|
|
|
|
|
Xn.append(x0[:-1] * dx[i])
|
|
|
|
|
|
|
|
|
|
Xnc = meshgrid(*Xn) if d > 1 else Xn
|
|
|
|
|
|
|
|
|
|
shape0 = Xnc[0].shape
|
|
|
|
|
for i in range(d):
|
|
|
|
|
Xnc[i].shape = (-1,)
|
|
|
|
|
|
|
|
|
|
Xn = np.dot(self.inv_hs, np.vstack(Xnc))
|
|
|
|
|
|
|
|
|
|
# Obtain the kernel weights.
|
|
|
|
|
kw = self.kernel(Xn)
|
|
|
|
|
|
|
|
|
|
# plt.plot(kw)
|
|
|
|
|
# plt.draw()
|
|
|
|
|
# plt.show()
|
|
|
|
|
norm_fact0 = (kw.sum() * dx.prod() * self.n)
|
|
|
|
|
norm_fact = (self._norm_factor * self.kernel.norm_factor(d, self.n))
|
|
|
|
|
if np.abs(norm_fact0 - norm_fact) > 0.05 * norm_fact:
|
|
|
|
|
warnings.warn(
|
|
|
|
|
'Numerical inaccuracy due to too low discretization. ' +
|
|
|
|
|
'Increase the discretization of the evaluation grid ' +
|
|
|
|
|
'(inc=%d)!' % inc)
|
|
|
|
|
norm_fact = norm_fact0
|
|
|
|
|
|
|
|
|
|
kw = kw / norm_fact
|
|
|
|
|
r = kwds.get('r', 0)
|
|
|
|
|
if r != 0:
|
|
|
|
|
kw *= np.vstack(Xnc) ** r if d > 1 else Xnc[0]
|
|
|
|
|
kw.shape = shape0
|
|
|
|
|
kw = np.fft.ifftshift(kw)
|
|
|
|
|
fftn = np.fft.fftn
|
|
|
|
|
ifftn = np.fft.ifftn
|
|
|
|
|
|
|
|
|
|
y = kwds.get('y', 1.0)
|
|
|
|
|
# if self.alpha>0:
|
|
|
|
|
# y = y / self._lambda**d
|
|
|
|
|
|
|
|
|
|
# Find the binned kernel weights, c.
|
|
|
|
|
c = gridcount(self.dataset, X, y=y)
|
|
|
|
|
# Perform the convolution.
|
|
|
|
|
z = np.real(ifftn(fftn(c, s=nfft) * fftn(kw)))
|
|
|
|
|
|
|
|
|
|
ix = (slice(0, inc),) * d
|
|
|
|
|
if r == 0:
|
|
|
|
|
return z[ix] * (z[ix] > 0.0)
|
|
|
|
|
else:
|
|
|
|
|
return z[ix]
|
|
|
|
|
|
|
|
|
|
def _eval_grid(self, *args, **kwds):
|
|
|
|
|
|
|
|
|
|
grd = meshgrid(*args) if len(args) > 1 else list(args)
|
|
|
|
|
shape0 = grd[0].shape
|
|
|
|
|
d = len(grd)
|
|
|
|
|
for i in range(d):
|
|
|
|
|
grd[i] = grd[i].ravel()
|
|
|
|
|
f = self.eval_points(np.vstack(grd), **kwds)
|
|
|
|
|
return f.reshape(shape0)
|
|
|
|
|
|
|
|
|
|
def _eval_points(self, points, **kwds):
|
|
|
|
|
"""Evaluate 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.
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
d, m = points.shape
|
|
|
|
|
|
|
|
|
|
result = np.zeros((m,))
|
|
|
|
|
|
|
|
|
|
r = kwds.get('r', 0)
|
|
|
|
|
if r == 0:
|
|
|
|
|
def fun(xi):
|
|
|
|
|
return 1
|
|
|
|
|
else:
|
|
|
|
|
def fun(xi):
|
|
|
|
|
return (xi ** r).sum(axis=0)
|
|
|
|
|
|
|
|
|
|
if m >= self.n:
|
|
|
|
|
y = kwds.get('y', np.ones(self.n))
|
|
|
|
|
# there are more points than data, so loop over data
|
|
|
|
|
for i in range(self.n):
|
|
|
|
|
diff = self.dataset[:, i, np.newaxis] - points
|
|
|
|
|
tdiff = np.dot(self.inv_hs / self._lambda[i], diff)
|
|
|
|
|
result += y[i] * \
|
|
|
|
|
fun(diff) * self.kernel(tdiff) / self._lambda[i] ** d
|
|
|
|
|
else:
|
|
|
|
|
y = kwds.get('y', 1)
|
|
|
|
|
# loop over points
|
|
|
|
|
for i in range(m):
|
|
|
|
|
diff = self.dataset - points[:, i, np.newaxis]
|
|
|
|
|
tdiff = np.dot(self.inv_hs, diff / self._lambda[np.newaxis, :])
|
|
|
|
|
tmp = y * fun(diff) * self.kernel(tdiff) / self._lambda ** d
|
|
|
|
|
result[i] = tmp.sum(axis=-1)
|
|
|
|
|
|
|
|
|
|
result /= (self._norm_factor * self.kernel.norm_factor(d, self.n))
|
|
|
|
|
|
|
|
|
|
return result
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class KRegression(_KDE):
|
|
|
|
|
|
|
|
|
|
""" Kernel-Regression
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
data : (# of dims, # of data)-array
|
|
|
|
|
datapoints to estimate from
|
|
|
|
|
y : # of data - array
|
|
|
|
|
response variable
|
|
|
|
|
p : scalar integer (0 or 1)
|
|
|
|
|
Nadaraya-Watson estimator if p=0,
|
|
|
|
|
local linear estimator if p=1.
|
|
|
|
|
hs : array-like (optional)
|
|
|
|
|
smooting parameter vector/matrix.
|
|
|
|
|
(default compute from data using kernel.get_smoothing function)
|
|
|
|
|
kernel : kernel function object.
|
|
|
|
|
kernel must have get_smoothing method
|
|
|
|
|
alpha : real scalar (optional)
|
|
|
|
|
sensitivity parameter (default 0 regular KDE)
|
|
|
|
|
A good choice might be alpha = 0.5 ( or 1/D)
|
|
|
|
|
alpha = 0 Regular KDE (hs is constant)
|
|
|
|
|
0 < alpha <= 1 Adaptive KDE (Make hs change)
|
|
|
|
|
xmin, xmax : vectors
|
|
|
|
|
specifying the default argument range for the kde.eval_grid methods.
|
|
|
|
|
For the kde.eval_grid_fast methods the values must cover the range of
|
|
|
|
|
the data. (default min(data)-range(data)/4, max(data)-range(data)/4)
|
|
|
|
|
If a single value of xmin or xmax is given then the boundary is the is
|
|
|
|
|
the same for all dimensions.
|
|
|
|
|
inc : scalar integer (default 128)
|
|
|
|
|
defining the default dimension of the output from kde.eval_grid methods
|
|
|
|
|
(For kde.eval_grid_fast: A value below 50 is very fast to compute but
|
|
|
|
|
may give some inaccuracies. Values between 100 and 500 give very
|
|
|
|
|
accurate results)
|
|
|
|
|
|
|
|
|
|
Members
|
|
|
|
|
-------
|
|
|
|
|
d : int
|
|
|
|
|
number of dimensions
|
|
|
|
|
n : int
|
|
|
|
|
number of datapoints
|
|
|
|
|
|
|
|
|
|
Methods
|
|
|
|
|
-------
|
|
|
|
|
kde.eval_grid_fast(x0, x1,..., xd) : array
|
|
|
|
|
evaluate the estimated pdf on meshgrid(x0, x1,..., xd)
|
|
|
|
|
kde.eval_grid(x0, x1,..., xd) : array
|
|
|
|
|
evaluate the estimated pdf on meshgrid(x0, x1,..., xd)
|
|
|
|
|
kde.eval_points(points) : array
|
|
|
|
|
evaluate the estimated pdf on a provided set of points
|
|
|
|
|
kde(x0, x1,..., xd) : array
|
|
|
|
|
same as kde.eval_grid(x0, x1,..., xd)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Example
|
|
|
|
|
-------
|
|
|
|
|
>>> N = 100
|
|
|
|
|
>>> ei = np.random.normal(loc=0, scale=0.075, size=(N,))
|
|
|
|
|
|
|
|
|
|
>>> x = np.linspace(0, 1, N)
|
|
|
|
|
>>> import wafo.kdetools as wk
|
|
|
|
|
|
|
|
|
|
>>> y = 2*np.exp(-x**2/(2*0.3**2))+3*np.exp(-(x-1)**2/(2*0.7**2)) + ei
|
|
|
|
|
>>> kreg = wk.KRegression(x, y)
|
|
|
|
|
>>> f = kreg(output='plotobj', title='Kernel regression', plotflag=1)
|
|
|
|
|
>>> h = f.plot(label='p=0')
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
def __init__(self, data, y, p=0, hs=None, kernel=None, alpha=0.0,
|
|
|
|
|
xmin=None, xmax=None, inc=128, L2=None):
|
|
|
|
|
|
|
|
|
|
self.tkde = TKDE(data, hs=hs, kernel=kernel,
|
|
|
|
|
alpha=alpha, xmin=xmin, xmax=xmax, inc=inc, L2=L2)
|
|
|
|
|
self.y = y
|
|
|
|
|
self.p = p
|
|
|
|
|
|
|
|
|
|
def eval_grid_fast(self, *args, **kwds):
|
|
|
|
|
self._grdfun = self.tkde.eval_grid_fast
|
|
|
|
|
return self.tkde._eval_grid_fun(self._eval_gridfun, *args, **kwds)
|
|
|
|
|
|
|
|
|
|
def eval_grid(self, *args, **kwds):
|
|
|
|
|
self._grdfun = self.tkde.eval_grid
|
|
|
|
|
return self.tkde._eval_grid_fun(self._eval_gridfun, *args, **kwds)
|
|
|
|
|
|
|
|
|
|
def _eval_gridfun(self, *args, **kwds):
|
|
|
|
|
grdfun = self._grdfun
|
|
|
|
|
s0 = grdfun(*args, r=0)
|
|
|
|
|
t0 = grdfun(*args, r=0, y=self.y)
|
|
|
|
|
if self.p == 0:
|
|
|
|
|
return (t0 / (s0 + _TINY)).clip(min=-_REALMAX, max=_REALMAX)
|
|
|
|
|
elif self.p == 1:
|
|
|
|
|
s1 = grdfun(*args, r=1)
|
|
|
|
|
s2 = grdfun(*args, r=2)
|
|
|
|
|
t1 = grdfun(*args, r=1, y=self.y)
|
|
|
|
|
return ((s2 * t0 - s1 * t1) /
|
|
|
|
|
(s2 * s0 - s1 ** 2)).clip(min=-_REALMAX, max=_REALMAX)
|
|
|
|
|
__call__ = eval_grid_fast
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class BKRegression(object):
|
|
|
|
|
|
|
|
|
|
'''
|
|
|
|
|
Kernel-Regression on binomial data
|
|
|
|
|
|
|
|
|
|
method : {'beta', 'wilson'}
|
|
|
|
|
method is one of the following
|
|
|
|
|
'beta', return Bayesian Credible interval using beta-distribution.
|
|
|
|
|
'wilson', return Wilson score interval
|
|
|
|
|
a, b : scalars
|
|
|
|
|
parameters of the beta distribution defining the apriori distribution
|
|
|
|
|
of p, i.e., the Bayes estimator for p: p = (y+a)/(n+a+b).
|
|
|
|
|
Setting a=b=0.5 gives Jeffreys interval.
|
|
|
|
|
'''
|
|
|
|
|
|
|
|
|
|
def __init__(self, *args, **kwds):
|
|
|
|
|
self.method = kwds.pop('method', 'beta')
|
|
|
|
|
self.a = max(kwds.pop('a', 0.5), _TINY)
|
|
|
|
|
self.b = max(kwds.pop('b', 0.5), _TINY)
|
|
|
|
|
self.kreg = KRegression(*args, **kwds)
|
|
|
|
|
# defines bin width (i.e. smoothing) in empirical estimate
|
|
|
|
|
self.hs_e = None
|
|
|
|
|
# self.x = self.kreg.tkde.dataset
|
|
|
|
|
# self.y = self.kreg.y
|
|
|
|
|
|
|
|
|
|
def _set_smoothing(self, hs):
|
|
|
|
|
self.kreg.tkde.hs = hs
|
|
|
|
|
self.kreg.tkde.initialize()
|
|
|
|
|
|
|
|
|
|
x = property(fget=lambda cls: cls.kreg.tkde.dataset.squeeze())
|
|
|
|
|
y = property(fget=lambda cls: cls.kreg.y)
|
|
|
|
|
kernel = property(fget=lambda cls: cls.kreg.tkde.kernel)
|
|
|
|
|
hs = property(fset=_set_smoothing, fget=lambda cls: cls.kreg.tkde.hs)
|
|
|
|
|
|
|
|
|
|
def _get_max_smoothing(self, fun=None):
|
|
|
|
|
"""Return maximum value for smoothing parameter."""
|
|
|
|
|
x = self.x
|
|
|
|
|
y = self.y
|
|
|
|
|
if fun is None:
|
|
|
|
|
get_smoothing = self.kernel.get_smoothing
|
|
|
|
|
else:
|
|
|
|
|
get_smoothing = getattr(self.kernel, fun)
|
|
|
|
|
|
|
|
|
|
hs1 = get_smoothing(x)
|
|
|
|
|
# hx = np.median(np.abs(x-np.median(x)))/0.6745*(4.0/(3*n))**0.2
|
|
|
|
|
if (y == 1).any():
|
|
|
|
|
hs2 = get_smoothing(x[y == 1])
|
|
|
|
|
# hy = np.median(np.abs(y-np.mean(y)))/0.6745*(4.0/(3*n))**0.2
|
|
|
|
|
else:
|
|
|
|
|
hs2 = 4 * hs1
|
|
|
|
|
# hy = 4*hx
|
|
|
|
|
|
|
|
|
|
hopt = sqrt(hs1 * hs2)
|
|
|
|
|
return hopt, hs1, hs2
|
|
|
|
|
|
|
|
|
|
def get_grid(self, hs_e=None):
|
|
|
|
|
if hs_e is None:
|
|
|
|
|
if self.hs_e is None:
|
|
|
|
|
hs1 = self._get_max_smoothing('hste')[0]
|
|
|
|
|
hs2 = self._get_max_smoothing('hos')[0]
|
|
|
|
|
self.hs_e = sqrt(hs1 * hs2)
|
|
|
|
|
hs_e = self.hs_e
|
|
|
|
|
x = self.x
|
|
|
|
|
xmin, xmax = x.min(), x.max()
|
|
|
|
|
ni = max(2 * int((xmax - xmin) / hs_e) + 3, 5)
|
|
|
|
|
sml = hs_e # *0.1
|
|
|
|
|
xi = np.linspace(xmin - sml, xmax + sml, ni)
|
|
|
|
|
return xi
|
|
|
|
|
|
|
|
|
|
def prb_ci(self, n, p, alpha=0.05, **kwds):
|
|
|
|
|
"""Return Confidence Interval for the binomial probability p.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
n : array-like
|
|
|
|
|
number of Bernoulli trials
|
|
|
|
|
p : array-like
|
|
|
|
|
estimated probability of success in each trial
|
|
|
|
|
alpha : scalar
|
|
|
|
|
confidence level
|
|
|
|
|
method : {'beta', 'wilson'}
|
|
|
|
|
method is one of the following
|
|
|
|
|
'beta', return Bayesian Credible interval using beta-distribution.
|
|
|
|
|
'wilson', return Wilson score interval
|
|
|
|
|
a, b : scalars
|
|
|
|
|
parameters of the beta distribution defining the apriori
|
|
|
|
|
distribution of p, i.e.,
|
|
|
|
|
the Bayes estimator for p: p = (y+a)/(n+a+b).
|
|
|
|
|
Setting a=b=0.5 gives Jeffreys interval.
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
if self.method.startswith('w'):
|
|
|
|
|
# Wilson score
|
|
|
|
|
z0 = -_invnorm(alpha / 2)
|
|
|
|
|
den = 1 + (z0 ** 2. / n)
|
|
|
|
|
xc = (p + (z0 ** 2) / (2 * n)) / den
|
|
|
|
|
halfwidth = (z0 * sqrt((p * (1 - p) / n) +
|
|
|
|
|
(z0 ** 2 / (4 * (n ** 2))))) / den
|
|
|
|
|
plo = (xc - halfwidth).clip(min=0) # wilson score
|
|
|
|
|
pup = (xc + halfwidth).clip(max=1.0) # wilson score
|
|
|
|
|
else:
|
|
|
|
|
# Jeffreys intervall a=b=0.5
|
|
|
|
|
# st.beta.isf(alpha/2, y+a, n-y+b) y = n*p, n-y = n*(1-p)
|
|
|
|
|
a = self.a
|
|
|
|
|
b = self.b
|
|
|
|
|
st = stats
|
|
|
|
|
pup = np.where(
|
|
|
|
|
p == 1, 1, st.beta.isf(alpha / 2, n * p + a, n * (1 - p) + b))
|
|
|
|
|
plo = np.where(p == 0, 0,
|
|
|
|
|
st.beta.isf(1 - alpha / 2,
|
|
|
|
|
n * p + a, n * (1 - p) + b))
|
|
|
|
|
return plo, pup
|
|
|
|
|
|
|
|
|
|
def prb_empirical(self, xi=None, hs_e=None, alpha=0.05, color='r', **kwds):
|
|
|
|
|
"""Returns empirical binomial probabiltity.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
x : ndarray
|
|
|
|
|
position vector
|
|
|
|
|
y : ndarray
|
|
|
|
|
binomial response variable (zeros and ones)
|
|
|
|
|
alpha : scalar
|
|
|
|
|
confidence level
|
|
|
|
|
color:
|
|
|
|
|
used in plot
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
P(x) : PlotData object
|
|
|
|
|
empirical probability
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
if xi is None:
|
|
|
|
|
xi = self.get_grid(hs_e)
|
|
|
|
|
|
|
|
|
|
x = self.x
|
|
|
|
|
y = self.y
|
|
|
|
|
|
|
|
|
|
c = gridcount(x, xi) # + self.a + self.b # count data
|
|
|
|
|
if (y == 1).any():
|
|
|
|
|
c0 = gridcount(x[y == 1], xi) # + self.a # count success
|
|
|
|
|
else:
|
|
|
|
|
c0 = np.zeros(xi.shape)
|
|
|
|
|
prb = np.where(c == 0, 0, c0 / (c + _TINY)) # assume prb==0 for c==0
|
|
|
|
|
CI = np.vstack(self.prb_ci(c, prb, alpha, **kwds))
|
|
|
|
|
|
|
|
|
|
prb_e = PlotData(prb, xi, plotmethod='plot', plot_args=['.'],
|
|
|
|
|
plot_kwds=dict(markersize=6, color=color, picker=5))
|
|
|
|
|
prb_e.dataCI = CI.T
|
|
|
|
|
prb_e.count = c
|
|
|
|
|
return prb_e
|
|
|
|
|
|
|
|
|
|
def prb_smoothed(self, prb_e, hs, alpha=0.05, color='r', label=''):
|
|
|
|
|
"""Return smoothed binomial probability.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
prb_e : PlotData object with empirical binomial probabilites
|
|
|
|
|
hs : smoothing parameter
|
|
|
|
|
alpha : confidence level
|
|
|
|
|
color : color of plot object
|
|
|
|
|
label : label for plot object
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
x_e = prb_e.args
|
|
|
|
|
n_e = len(x_e)
|
|
|
|
|
dx_e = x_e[1] - x_e[0]
|
|
|
|
|
n = self.x.size
|
|
|
|
|
|
|
|
|
|
x_s = np.linspace(x_e[0], x_e[-1], 10 * n_e + 1)
|
|
|
|
|
self.hs = hs
|
|
|
|
|
|
|
|
|
|
prb_s = self.kreg(x_s, output='plotobj', title='', plot_kwds=dict(
|
|
|
|
|
color=color, linewidth=2)) # dict(plotflag=7))
|
|
|
|
|
m_nan = np.isnan(prb_s.data)
|
|
|
|
|
if m_nan.any(): # assume 0/0 division
|
|
|
|
|
prb_s.data[m_nan] = 0.0
|
|
|
|
|
|
|
|
|
|
# prb_s.data[np.isnan(prb_s.data)] = 0
|
|
|
|
|
# expected number of data in each bin
|
|
|
|
|
c_s = self.kreg.tkde.eval_grid_fast(x_s) * dx_e * n
|
|
|
|
|
plo, pup = self.prb_ci(c_s, prb_s.data, alpha)
|
|
|
|
|
|
|
|
|
|
prb_s.dataCI = np.vstack((plo, pup)).T
|
|
|
|
|
prb_s.prediction_error_avg = np.trapz(
|
|
|
|
|
pup - plo, x_s) / (x_s[-1] - x_s[0])
|
|
|
|
|
|
|
|
|
|
if label:
|
|
|
|
|
prb_s.plot_kwds['label'] = label
|
|
|
|
|
prb_s.children = [PlotData([plo, pup], x_s,
|
|
|
|
|
plotmethod='fill_between',
|
|
|
|
|
plot_kwds=dict(alpha=0.2, color=color)),
|
|
|
|
|
prb_e]
|
|
|
|
|
|
|
|
|
|
# empirical oversmooths the data
|
|
|
|
|
# p_s = prb_s.eval_points(self.x)
|
|
|
|
|
# dp_s = np.diff(prb_s.data)
|
|
|
|
|
# k = (dp_s[:-1]*dp_s[1:]<0).sum() # numpeaks
|
|
|
|
|
# p_e = self.y
|
|
|
|
|
# n_s = interpolate.interp1d(x_s, c_s)(self.x)
|
|
|
|
|
# plo, pup = self.prb_ci(n_s, p_s, alpha)
|
|
|
|
|
# sigmai = (pup-plo)
|
|
|
|
|
# aicc = (((p_e-p_s)/sigmai)**2).sum()+ 2*k*(k+1)/np.maximum(n-k+1,1)
|
|
|
|
|
|
|
|
|
|
p_e = prb_e.eval_points(x_s)
|
|
|
|
|
p_s = prb_s.data
|
|
|
|
|
dp_s = np.sign(np.diff(p_s))
|
|
|
|
|
k = (dp_s[:-1] != dp_s[1:]).sum() # numpeaks
|
|
|
|
|
|
|
|
|
|
# sigmai = (pup-plo)+_EPS
|
|
|
|
|
# aicc = (((p_e-p_s)/sigmai)**2).sum()+ 2*k*(k+1)/np.maximum(n_e-k+1,1)
|
|
|
|
|
# + np.abs((p_e-pup).clip(min=0)-(p_e-plo).clip(max=0)).sum()
|
|
|
|
|
sigmai = _logit(pup) - _logit(plo) + _EPS
|
|
|
|
|
aicc = ((((_logit(p_e) - _logit(p_s)) / sigmai) ** 2).sum() +
|
|
|
|
|
2 * k * (k + 1) / np.maximum(n_e - k + 1, 1) +
|
|
|
|
|
np.abs((p_e - pup).clip(min=0) -
|
|
|
|
|
(p_e - plo).clip(max=0)).sum())
|
|
|
|
|
|
|
|
|
|
prb_s.aicc = aicc
|
|
|
|
|
# prb_s.labels.title = ''
|
|
|
|
|
# prb_s.labels.title='perr=%1.3f,aicc=%1.3f, n=%d, hs=%1.3f' %
|
|
|
|
|
# (prb_s.prediction_error_avg,aicc,n,hs)
|
|
|
|
|
|
|
|
|
|
return prb_s
|
|
|
|
|
|
|
|
|
|
def prb_search_best(self, prb_e=None, hsvec=None, hsfun='hste',
|
|
|
|
|
alpha=0.05, color='r', label=''):
|
|
|
|
|
"""Return best smoothed binomial probability.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
prb_e : PlotData object with empirical binomial probabilites
|
|
|
|
|
hsvec : arraylike (default np.linspace(hsmax*0.1,hsmax,55))
|
|
|
|
|
vector smoothing parameters
|
|
|
|
|
hsfun :
|
|
|
|
|
method for calculating hsmax
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
if prb_e is None:
|
|
|
|
|
prb_e = self.prb_empirical(
|
|
|
|
|
hs_e=self.hs_e, alpha=alpha, color=color)
|
|
|
|
|
if hsvec is None:
|
|
|
|
|
hsmax = self._get_max_smoothing(hsfun)[0] # @UnusedVariable
|
|
|
|
|
hsmax = max(hsmax, self.hs_e)
|
|
|
|
|
hsvec = np.linspace(hsmax * 0.2, hsmax, 55)
|
|
|
|
|
|
|
|
|
|
hs_best = hsvec[-1] + 0.1
|
|
|
|
|
prb_best = self.prb_smoothed(prb_e, hs_best, alpha, color, label)
|
|
|
|
|
aicc = np.zeros(np.size(hsvec))
|
|
|
|
|
for i, hi in enumerate(hsvec):
|
|
|
|
|
f = self.prb_smoothed(prb_e, hi, alpha, color, label)
|
|
|
|
|
aicc[i] = f.aicc
|
|
|
|
|
if f.aicc <= prb_best.aicc:
|
|
|
|
|
prb_best = f
|
|
|
|
|
hs_best = hi
|
|
|
|
|
prb_best.score = PlotData(aicc, hsvec)
|
|
|
|
|
prb_best.hs = hs_best
|
|
|
|
|
self._set_smoothing(hs_best)
|
|
|
|
|
return prb_best
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class _Kernel(object):
|
|
|
|
|
|
|
|
|
|
def __init__(self, r=1.0, stats=None):
|
|
|
|
|
self.r = r # radius of kernel
|
|
|
|
|
self.stats = stats
|
|
|
|
|
|
|
|
|
|
def norm_factor(self, d=1, n=None):
|
|
|
|
|
return 1.0
|
|
|
|
|
|
|
|
|
|
def norm_kernel(self, x):
|
|
|
|
|
X = np.atleast_2d(x)
|
|
|
|
|
return self._kernel(X) / self.norm_factor(*X.shape)
|
|
|
|
|
|
|
|
|
|
def kernel(self, x):
|
|
|
|
|
return self._kernel(np.atleast_2d(x))
|
|
|
|
|
|
|
|
|
|
def deriv4_6_8_10(self, t, numout=4):
|
|
|
|
|
raise Exception('Method not implemented for this kernel!')
|
|
|
|
|
|
|
|
|
|
def effective_support(self):
|
|
|
|
|
"""Return the effective support of kernel.
|
|
|
|
|
|
|
|
|
|
The kernel must be symmetric and compactly supported on [-tau tau]
|
|
|
|
|
if the kernel has infinite support then the kernel must have the
|
|
|
|
|
effective support in [-tau tau], i.e., be negligible outside the range
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
return self._effective_support()
|
|
|
|
|
|
|
|
|
|
def _effective_support(self):
|
|
|
|
|
return - self.r, self.r
|
|
|
|
|
__call__ = kernel
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class _KernelMulti(_Kernel):
|
|
|
|
|
# p=0; %Sphere = rect for 1D
|
|
|
|
|
# p=1; %Multivariate Epanechnikov kernel.
|
|
|
|
|
# p=2; %Multivariate Bi-weight Kernel
|
|
|
|
|
# p=3; %Multi variate Tri-weight Kernel
|
|
|
|
|
# p=4; %Multi variate Four-weight Kernel
|
|
|
|
|
|
|
|
|
|
def __init__(self, r=1.0, p=1, stats=None):
|
|
|
|
|
self.r = r
|
|
|
|
|
self.p = p
|
|
|
|
|
self.stats = stats
|
|
|
|
|
|
|
|
|
|
def norm_factor(self, d=1, n=None):
|
|
|
|
|
r = self.r
|
|
|
|
|
p = self.p
|
|
|
|
|
c = 2 ** p * np.prod(np.r_[1:p + 1]) * sphere_volume(d, r) / np.prod(
|
|
|
|
|
np.r_[(d + 2):(2 * p + d + 1):2]) # normalizing constant
|
|
|
|
|
return c
|
|
|
|
|
|
|
|
|
|
def _kernel(self, x):
|
|
|
|
|
r = self.r
|
|
|
|
|
p = self.p
|
|
|
|
|
x2 = x ** 2
|
|
|
|
|
return ((1.0 - x2.sum(axis=0) / r ** 2).clip(min=0.0)) ** p
|
|
|
|
|
|
|
|
|
|
mkernel_epanechnikov = _KernelMulti(p=1, stats=_stats_epan)
|
|
|
|
|
mkernel_biweight = _KernelMulti(p=2, stats=_stats_biwe)
|
|
|
|
|
mkernel_triweight = _KernelMulti(p=3, stats=_stats_triw)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class _KernelProduct(_KernelMulti):
|
|
|
|
|
# p=0; %rectangular
|
|
|
|
|
# p=1; %1D product Epanechnikov kernel.
|
|
|
|
|
# p=2; %1D product Bi-weight Kernel
|
|
|
|
|
# p=3; %1D product Tri-weight Kernel
|
|
|
|
|
# p=4; %1D product Four-weight Kernel
|
|
|
|
|
|
|
|
|
|
def norm_factor(self, d=1, n=None):
|
|
|
|
|
r = self.r
|
|
|
|
|
p = self.p
|
|
|
|
|
c = (2 ** p * np.prod(np.r_[1:p + 1]) * sphere_volume(1, r) /
|
|
|
|
|
np.prod(np.r_[(1 + 2):(2 * p + 2):2]))
|
|
|
|
|
return c ** d
|
|
|
|
|
|
|
|
|
|
def _kernel(self, x):
|
|
|
|
|
r = self.r # radius
|
|
|
|
|
pdf = (1 - (x / r) ** 2).clip(min=0.0)
|
|
|
|
|
return pdf.prod(axis=0)
|
|
|
|
|
|
|
|
|
|
mkernel_p1epanechnikov = _KernelProduct(p=1, stats=_stats_epan)
|
|
|
|
|
mkernel_p1biweight = _KernelProduct(p=2, stats=_stats_biwe)
|
|
|
|
|
mkernel_p1triweight = _KernelProduct(p=3, stats=_stats_triw)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class _KernelRectangular(_Kernel):
|
|
|
|
|
|
|
|
|
|
def _kernel(self, x):
|
|
|
|
|
return np.where(np.all(np.abs(x) <= self.r, axis=0), 1, 0.0)
|
|
|
|
|
|
|
|
|
|
def norm_factor(self, d=1, n=None):
|
|
|
|
|
r = self.r
|
|
|
|
|
return (2 * r) ** d
|
|
|
|
|
mkernel_rectangular = _KernelRectangular(stats=_stats_rect)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class _KernelTriangular(_Kernel):
|
|
|
|
|
|
|
|
|
|
def _kernel(self, x):
|
|
|
|
|
pdf = (1 - np.abs(x)).clip(min=0.0)
|
|
|
|
|
return pdf.prod(axis=0)
|
|
|
|
|
mkernel_triangular = _KernelTriangular(stats=_stats_tria)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class _KernelGaussian(_Kernel):
|
|
|
|
|
|
|
|
|
|
def _kernel(self, x):
|
|
|
|
|
sigma = self.r / 4.0
|
|
|
|
|
x2 = (x / sigma) ** 2
|
|
|
|
|
return exp(-0.5 * x2.sum(axis=0))
|
|
|
|
|
|
|
|
|
|
def norm_factor(self, d=1, n=None):
|
|
|
|
|
sigma = self.r / 4.0
|
|
|
|
|
return (2 * pi * sigma) ** (d / 2.0)
|
|
|
|
|
|
|
|
|
|
def deriv4_6_8_10(self, t, numout=4):
|
|
|
|
|
"""Returns 4th, 6th, 8th and 10th derivatives of the kernel
|
|
|
|
|
function."""
|
|
|
|
|
phi0 = exp(-0.5 * t ** 2) / sqrt(2 * pi)
|
|
|
|
|
p4 = [1, 0, -6, 0, +3]
|
|
|
|
|
p4val = np.polyval(p4, t) * phi0
|
|
|
|
|
if numout == 1:
|
|
|
|
|
return p4val
|
|
|
|
|
out = [p4val]
|
|
|
|
|
pn = p4
|
|
|
|
|
for unusedix in range(numout - 1):
|
|
|
|
|
pnp1 = np.polyadd(-np.r_[pn, 0], np.polyder(pn))
|
|
|
|
|
pnp2 = np.polyadd(-np.r_[pnp1, 0], np.polyder(pnp1))
|
|
|
|
|
out.append(np.polyval(pnp2, t) * phi0)
|
|
|
|
|
pn = pnp2
|
|
|
|
|
return out
|
|
|
|
|
|
|
|
|
|
mkernel_gaussian = _KernelGaussian(r=4.0, stats=_stats_gaus)
|
|
|
|
|
|
|
|
|
|
# def mkernel_gaussian(X):
|
|
|
|
|
# x2 = X ** 2
|
|
|
|
|
# d = X.shape[0]
|
|
|
|
|
# return (2 * pi) ** (-d / 2) * exp(-0.5 * x2.sum(axis=0))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class _KernelLaplace(_Kernel):
|
|
|
|
|
|
|
|
|
|
def _kernel(self, x):
|
|
|
|
|
absX = np.abs(x)
|
|
|
|
|
return exp(-absX.sum(axis=0))
|
|
|
|
|
|
|
|
|
|
def norm_factor(self, d=1, n=None):
|
|
|
|
|
return 2 ** d
|
|
|
|
|
mkernel_laplace = _KernelLaplace(r=7.0, stats=_stats_lapl)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class _KernelLogistic(_Kernel):
|
|
|
|
|
|
|
|
|
|
def _kernel(self, x):
|
|
|
|
|
s = exp(-x)
|
|
|
|
|
return np.prod(1.0 / (s + 1) ** 2, axis=0)
|
|
|
|
|
mkernel_logistic = _KernelLogistic(r=7.0, stats=_stats_logi)
|
|
|
|
|
|
|
|
|
|
_MKERNEL_DICT = dict(
|
|
|
|
|
epan=mkernel_epanechnikov,
|
|
|
|
|
biwe=mkernel_biweight,
|
|
|
|
|
triw=mkernel_triweight,
|
|
|
|
|
p1ep=mkernel_p1epanechnikov,
|
|
|
|
|
p1bi=mkernel_p1biweight,
|
|
|
|
|
p1tr=mkernel_p1triweight,
|
|
|
|
|
rect=mkernel_rectangular,
|
|
|
|
|
tria=mkernel_triangular,
|
|
|
|
|
lapl=mkernel_laplace,
|
|
|
|
|
logi=mkernel_logistic,
|
|
|
|
|
gaus=mkernel_gaussian
|
|
|
|
|
)
|
|
|
|
|
_KERNEL_EXPONENT_DICT = dict(
|
|
|
|
|
re=0, sp=0, ep=1, bi=2, tr=3, fo=4, fi=5, si=6, se=7)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class Kernel(object):
|
|
|
|
|
|
|
|
|
|
"""Multivariate kernel.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
name : string
|
|
|
|
|
defining the kernel. Valid options are:
|
|
|
|
|
'epanechnikov' - Epanechnikov kernel.
|
|
|
|
|
'biweight' - Bi-weight kernel.
|
|
|
|
|
'triweight' - Tri-weight kernel.
|
|
|
|
|
'p1epanechnikov' - product of 1D Epanechnikov kernel.
|
|
|
|
|
'p1biweight' - product of 1D Bi-weight kernel.
|
|
|
|
|
'p1triweight' - product of 1D Tri-weight kernel.
|
|
|
|
|
'triangular' - Triangular kernel.
|
|
|
|
|
'gaussian' - Gaussian kernel
|
|
|
|
|
'rectangular' - Rectangular kernel.
|
|
|
|
|
'laplace' - Laplace kernel.
|
|
|
|
|
'logistic' - Logistic kernel.
|
|
|
|
|
Note that only the first 4 letters of the kernel name is needed.
|
|
|
|
|
|
|
|
|
|
Examples
|
|
|
|
|
--------
|
|
|
|
|
N = 20
|
|
|
|
|
data = np.random.rayleigh(1, size=(N,))
|
|
|
|
|
>>> data = np.array([
|
|
|
|
|
... 0.75355792, 0.72779194, 0.94149169, 0.07841119, 2.32291887,
|
|
|
|
|
... 1.10419995, 0.77055114, 0.60288273, 1.36883635, 1.74754326,
|
|
|
|
|
... 1.09547561, 1.01671133, 0.73211143, 0.61891719, 0.75903487,
|
|
|
|
|
... 1.8919469 , 0.72433808, 1.92973094, 0.44749838, 1.36508452])
|
|
|
|
|
|
|
|
|
|
>>> import wafo.kdetools as wk
|
|
|
|
|
>>> gauss = wk.Kernel('gaussian')
|
|
|
|
|
>>> gauss.stats()
|
|
|
|
|
(1, 0.28209479177387814, 0.21157109383040862)
|
|
|
|
|
>>> np.allclose(gauss.hscv(data), 0.21779575)
|
|
|
|
|
True
|
|
|
|
|
>>> np.allclose(gauss.hstt(data), 0.16341135)
|
|
|
|
|
True
|
|
|
|
|
>>> np.allclose(gauss.hste(data), 0.19179399)
|
|
|
|
|
True
|
|
|
|
|
>>> np.allclose(gauss.hldpi(data), 0.22502733)
|
|
|
|
|
True
|
|
|
|
|
>>> wk.Kernel('laplace').stats()
|
|
|
|
|
(2, 0.25, inf)
|
|
|
|
|
|
|
|
|
|
>>> triweight = wk.Kernel('triweight')
|
|
|
|
|
>>> np.allclose(triweight.stats(),
|
|
|
|
|
... (0.1111111111111111, 0.81585081585081587, np.inf))
|
|
|
|
|
True
|
|
|
|
|
>>> np.allclose(triweight(np.linspace(-1,1,11)),
|
|
|
|
|
... [ 0., 0.046656, 0.262144, 0.592704, 0.884736, 1.,
|
|
|
|
|
... 0.884736, 0.592704, 0.262144, 0.046656, 0.])
|
|
|
|
|
True
|
|
|
|
|
>>> np.allclose(triweight.hns(data), 0.82, rtol=1e-2)
|
|
|
|
|
True
|
|
|
|
|
>>> np.allclose(triweight.hos(data), 0.88, rtol=1e-2)
|
|
|
|
|
True
|
|
|
|
|
>>> np.allclose(triweight.hste(data), 0.57, rtol=1e-2)
|
|
|
|
|
True
|
|
|
|
|
>>> np.allclose(triweight.hscv(data), 0.648, rtol=1e-2)
|
|
|
|
|
True
|
|
|
|
|
|
|
|
|
|
See also
|
|
|
|
|
--------
|
|
|
|
|
mkernel
|
|
|
|
|
|
|
|
|
|
References
|
|
|
|
|
----------
|
|
|
|
|
B. W. Silverman (1986)
|
|
|
|
|
'Density estimation for statistics and data analysis'
|
|
|
|
|
Chapman and Hall, pp. 43, 76
|
|
|
|
|
|
|
|
|
|
Wand, M. P. and Jones, M. C. (1995)
|
|
|
|
|
'Density estimation for statistics and data analysis'
|
|
|
|
|
Chapman and Hall, pp 31, 103, 175
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
def __init__(self, name, fun='hste'): # 'hns'):
|
|
|
|
|
self.kernel = _MKERNEL_DICT[name[:4]]
|
|
|
|
|
# self.name = self.kernel.__name__.replace('mkernel_', '').title()
|
|
|
|
|
try:
|
|
|
|
|
self.get_smoothing = getattr(self, fun)
|
|
|
|
|
except:
|
|
|
|
|
self.get_smoothing = self.hste
|
|
|
|
|
|
|
|
|
|
def _get_name(self):
|
|
|
|
|
return self.kernel.__class__.__name__.replace('_Kernel', '').title()
|
|
|
|
|
name = property(_get_name)
|
|
|
|
|
|
|
|
|
|
def get_smoothing(self, *args, **kwds):
|
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
|
def stats(self):
|
|
|
|
|
"""Return some 1D statistics of the kernel.
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
mu2 : real scalar
|
|
|
|
|
2'nd order moment, i.e.,int(x^2*kernel(x))
|
|
|
|
|
R : real scalar
|
|
|
|
|
integral of squared kernel, i.e., int(kernel(x)^2)
|
|
|
|
|
Rdd : real scalar
|
|
|
|
|
integral of squared double derivative of kernel,
|
|
|
|
|
i.e., int( (kernel''(x))^2 ).
|
|
|
|
|
|
|
|
|
|
Reference
|
|
|
|
|
---------
|
|
|
|
|
Wand,M.P. and Jones, M.C. (1995)
|
|
|
|
|
'Kernel smoothing'
|
|
|
|
|
Chapman and Hall, pp 176.
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
return self.kernel.stats
|
|
|
|
|
|
|
|
|
|
def deriv4_6_8_10(self, t, numout=4):
|
|
|
|
|
return self.kernel.deriv4_6_8_10(t, numout)
|
|
|
|
|
|
|
|
|
|
def effective_support(self):
|
|
|
|
|
return self.kernel.effective_support()
|
|
|
|
|
|
|
|
|
|
def hns(self, data):
|
|
|
|
|
"""Returns Normal Scale Estimate of Smoothing Parameter.
|
|
|
|
|
|
|
|
|
|
Parameter
|
|
|
|
|
---------
|
|
|
|
|
data : 2D array
|
|
|
|
|
shape d x n (d = # dimensions )
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
h : array-like
|
|
|
|
|
one dimensional optimal value for smoothing parameter
|
|
|
|
|
given the data and kernel. size D
|
|
|
|
|
|
|
|
|
|
HNS only gives an optimal value with respect to mean integrated
|
|
|
|
|
square error, when the true underlying distribution
|
|
|
|
|
is Gaussian. This works reasonably well if the data resembles a
|
|
|
|
|
Gaussian distribution. However if the distribution is asymmetric,
|
|
|
|
|
multimodal or have long tails then HNS may return a to large
|
|
|
|
|
smoothing parameter, i.e., the KDE may be oversmoothed and mask
|
|
|
|
|
important features of the data. (=> large bias).
|
|
|
|
|
One way to remedy this is to reduce H by multiplying with a constant
|
|
|
|
|
factor, e.g., 0.85. Another is to try different values for H and make a
|
|
|
|
|
visual check by eye.
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
data = rndnorm(0, 1,20,1)
|
|
|
|
|
h = hns(data,'epan')
|
|
|
|
|
|
|
|
|
|
See also:
|
|
|
|
|
---------
|
|
|
|
|
hste, hbcv, hboot, hos, hldpi, hlscv, hscv, hstt, kde
|
|
|
|
|
|
|
|
|
|
Reference:
|
|
|
|
|
---------
|
|
|
|
|
B. W. Silverman (1986)
|
|
|
|
|
'Density estimation for statistics and data analysis'
|
|
|
|
|
Chapman and Hall, pp 43-48
|
|
|
|
|
Wand,M.P. and Jones, M.C. (1995)
|
|
|
|
|
'Kernel smoothing'
|
|
|
|
|
Chapman and Hall, pp 60--63
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
A = np.atleast_2d(data)
|
|
|
|
|
n = A.shape[1]
|
|
|
|
|
|
|
|
|
|
# R= int(mkernel(x)^2), mu2= int(x^2*mkernel(x))
|
|
|
|
|
mu2, R, unusedRdd = self.stats()
|
|
|
|
|
AMISEconstant = (8 * sqrt(pi) * R / (3 * mu2 ** 2 * n)) ** (1. / 5)
|
|
|
|
|
iqr = iqrange(A, axis=1) # interquartile range
|
|
|
|
|
stdA = np.std(A, axis=1, ddof=1)
|
|
|
|
|
# use of interquartile range guards against outliers.
|
|
|
|
|
# the use of interquartile range is better if
|
|
|
|
|
# the distribution is skew or have heavy tails
|
|
|
|
|
# This lessen the chance of oversmoothing.
|
|
|
|
|
return np.where(iqr > 0,
|
|
|
|
|
np.minimum(stdA, iqr / 1.349), stdA) * AMISEconstant
|
|
|
|
|
|
|
|
|
|
def hos(self, data):
|
|
|
|
|
"""Returns Oversmoothing Parameter.
|
|
|
|
|
|
|
|
|
|
Parameter
|
|
|
|
|
---------
|
|
|
|
|
data = data matrix, size N x D (D = # dimensions )
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
h : vector size 1 x D
|
|
|
|
|
one dimensional maximum smoothing value for smoothing parameter
|
|
|
|
|
given the data and kernel.
|
|
|
|
|
|
|
|
|
|
The oversmoothing or maximal smoothing principle relies on the fact
|
|
|
|
|
that there is a simple upper bound for the AMISE-optimal bandwidth for
|
|
|
|
|
estimation of densities with a fixed value of a particular scale
|
|
|
|
|
measure. While HOS will give too large bandwidth for optimal estimation
|
|
|
|
|
of a general density it provides an excellent starting point for
|
|
|
|
|
subjective choice of bandwidth. A sensible strategy is to plot an
|
|
|
|
|
estimate with bandwidth HOS and then sucessively look at plots based on
|
|
|
|
|
convenient fractions of HOS to see what features are present in the
|
|
|
|
|
data for various amount of smoothing. The relation to HNS is given by:
|
|
|
|
|
|
|
|
|
|
HOS = HNS/0.93
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
--------
|
|
|
|
|
data = rndnorm(0, 1,20,1)
|
|
|
|
|
h = hos(data,'epan');
|
|
|
|
|
|
|
|
|
|
See also hste, hbcv, hboot, hldpi, hlscv, hscv, hstt, kde, kdefun
|
|
|
|
|
|
|
|
|
|
Reference
|
|
|
|
|
---------
|
|
|
|
|
B. W. Silverman (1986)
|
|
|
|
|
'Density estimation for statistics and data analysis'
|
|
|
|
|
Chapman and Hall, pp 43-48
|
|
|
|
|
|
|
|
|
|
Wand,M.P. and Jones, M.C. (1986)
|
|
|
|
|
'Kernel smoothing'
|
|
|
|
|
Chapman and Hall, pp 60--63
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
return self.hns(data) / 0.93
|
|
|
|
|
|
|
|
|
|
def hmns(self, data):
|
|
|
|
|
"""Returns Multivariate Normal Scale Estimate of Smoothing Parameter.
|
|
|
|
|
|
|
|
|
|
CALL: h = hmns(data,kernel)
|
|
|
|
|
|
|
|
|
|
h = M dimensional optimal value for smoothing parameter
|
|
|
|
|
given the data and kernel. size D x D
|
|
|
|
|
data = data matrix, size D x N (D = # dimensions )
|
|
|
|
|
kernel = 'epanechnikov' - Epanechnikov kernel.
|
|
|
|
|
'biweight' - Bi-weight kernel.
|
|
|
|
|
'triweight' - Tri-weight kernel.
|
|
|
|
|
'gaussian' - Gaussian kernel
|
|
|
|
|
|
|
|
|
|
Note that only the first 4 letters of the kernel name is needed.
|
|
|
|
|
|
|
|
|
|
HMNS only gives a optimal value with respect to mean integrated
|
|
|
|
|
square error, when the true underlying distribution is Multivariate
|
|
|
|
|
Gaussian. This works reasonably well if the data resembles a
|
|
|
|
|
Multivariate Gaussian distribution. However if the distribution is
|
|
|
|
|
asymmetric, multimodal or have long tails then HNS is maybe more
|
|
|
|
|
appropriate.
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
data = rndnorm(0, 1,20,2)
|
|
|
|
|
h = hmns(data,'epan')
|
|
|
|
|
|
|
|
|
|
See also
|
|
|
|
|
--------
|
|
|
|
|
|
|
|
|
|
hns, hste, hbcv, hboot, hos, hldpi, hlscv, hscv, hstt
|
|
|
|
|
|
|
|
|
|
Reference
|
|
|
|
|
----------
|
|
|
|
|
B. W. Silverman (1986)
|
|
|
|
|
'Density estimation for statistics and data analysis'
|
|
|
|
|
Chapman and Hall, pp 43-48, 87
|
|
|
|
|
|
|
|
|
|
Wand,M.P. and Jones, M.C. (1995)
|
|
|
|
|
'Kernel smoothing'
|
|
|
|
|
Chapman and Hall, pp 60--63, 86--88
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
# TODO: implement more kernels
|
|
|
|
|
|
|
|
|
|
A = np.atleast_2d(data)
|
|
|
|
|
d, n = A.shape
|
|
|
|
|
|
|
|
|
|
if d == 1:
|
|
|
|
|
return self.hns(data)
|
|
|
|
|
name = self.name[:4].lower()
|
|
|
|
|
if name == 'epan': # Epanechnikov kernel
|
|
|
|
|
a = (8.0 * (d + 4.0) * (2 * sqrt(pi)) ** d /
|
|
|
|
|
sphere_volume(d)) ** (1. / (4.0 + d))
|
|
|
|
|
elif name == 'biwe': # Bi-weight kernel
|
|
|
|
|
a = 2.7779
|
|
|
|
|
if d > 2:
|
|
|
|
|
raise ValueError('not implemented for d>2')
|
|
|
|
|
elif name == 'triw': # Triweight
|
|
|
|
|
a = 3.12
|
|
|
|
|
if d > 2:
|
|
|
|
|
raise ValueError('not implemented for d>2')
|
|
|
|
|
elif name == 'gaus': # Gaussian kernel
|
|
|
|
|
a = (4.0 / (d + 2.0)) ** (1. / (d + 4.0))
|
|
|
|
|
else:
|
|
|
|
|
raise ValueError('Unknown kernel.')
|
|
|
|
|
|
|
|
|
|
covA = scipy.cov(A)
|
|
|
|
|
|
|
|
|
|
return a * linalg.sqrtm(covA).real * n ** (-1. / (d + 4))
|
|
|
|
|
|
|
|
|
|
def hste(self, data, h0=None, inc=128, maxit=100, releps=0.01, abseps=0.0):
|
|
|
|
|
'''HSTE 2-Stage Solve the Equation estimate of smoothing parameter.
|
|
|
|
|
|
|
|
|
|
CALL: hs = hste(data,kernel,h0)
|
|
|
|
|
|
|
|
|
|
hs = one dimensional value for smoothing parameter
|
|
|
|
|
given the data and kernel. size 1 x D
|
|
|
|
|
data = data matrix, size N x D (D = # dimensions )
|
|
|
|
|
kernel = 'gaussian' - Gaussian kernel (default)
|
|
|
|
|
( currently the only supported kernel)
|
|
|
|
|
h0 = initial starting guess for hs (default h0=hns(A,kernel))
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
x = rndnorm(0,1,50,1);
|
|
|
|
|
hs = hste(x,'gauss');
|
|
|
|
|
|
|
|
|
|
See also hbcv, hboot, hos, hldpi, hlscv, hscv, hstt, kde, kdefun
|
|
|
|
|
|
|
|
|
|
Reference
|
|
|
|
|
---------
|
|
|
|
|
B. W. Silverman (1986)
|
|
|
|
|
'Density estimation for statistics and data analysis'
|
|
|
|
|
Chapman and Hall, pp 57--61
|
|
|
|
|
|
|
|
|
|
Wand,M.P. and Jones, M.C. (1986)
|
|
|
|
|
'Kernel smoothing'
|
|
|
|
|
Chapman and Hall, pp 74--75
|
|
|
|
|
'''
|
|
|
|
|
# TODO: NB: this routine can be made faster:
|
|
|
|
|
# TODO: replace the iteration in the end with a Newton Raphson scheme
|
|
|
|
|
|
|
|
|
|
A = np.atleast_2d(data)
|
|
|
|
|
d, n = A.shape
|
|
|
|
|
|
|
|
|
|
# R= int(mkernel(x)^2), mu2= int(x^2*mkernel(x))
|
|
|
|
|
mu2, R, unusedRdd = self.stats()
|
|
|
|
|
|
|
|
|
|
AMISEconstant = (8 * sqrt(pi) * R / (3 * mu2 ** 2 * n)) ** (1. / 5)
|
|
|
|
|
STEconstant = R / (mu2 ** (2) * n)
|
|
|
|
|
|
|
|
|
|
sigmaA = self.hns(A) / AMISEconstant
|
|
|
|
|
if h0 is None:
|
|
|
|
|
h0 = sigmaA * AMISEconstant
|
|
|
|
|
|
|
|
|
|
h = np.asarray(h0, dtype=float)
|
|
|
|
|
|
|
|
|
|
nfft = inc * 2
|
|
|
|
|
amin = A.min(axis=1) # Find the minimum value of A.
|
|
|
|
|
amax = A.max(axis=1) # Find the maximum value of A.
|
|
|
|
|
arange = amax - amin # Find the range of A.
|
|
|
|
|
|
|
|
|
|
# xa holds the x 'axis' vector, defining a grid of x values where
|
|
|
|
|
# the k.d. function will be evaluated.
|
|
|
|
|
|
|
|
|
|
ax1 = amin - arange / 8.0
|
|
|
|
|
bx1 = amax + arange / 8.0
|
|
|
|
|
|
|
|
|
|
kernel2 = Kernel('gauss')
|
|
|
|
|
mu2, R, unusedRdd = kernel2.stats()
|
|
|
|
|
STEconstant2 = R / (mu2 ** (2) * n)
|
|
|
|
|
fft = np.fft.fft
|
|
|
|
|
ifft = np.fft.ifft
|
|
|
|
|
|
|
|
|
|
for dim in range(d):
|
|
|
|
|
s = sigmaA[dim]
|
|
|
|
|
ax = ax1[dim]
|
|
|
|
|
bx = bx1[dim]
|
|
|
|
|
|
|
|
|
|
xa = np.linspace(ax, bx, inc)
|
|
|
|
|
xn = np.linspace(0, bx - ax, inc)
|
|
|
|
|
|
|
|
|
|
c = gridcount(A[dim], xa)
|
|
|
|
|
|
|
|
|
|
# Step 1
|
|
|
|
|
psi6NS = -15 / (16 * sqrt(pi) * s ** 7)
|
|
|
|
|
psi8NS = 105 / (32 * sqrt(pi) * s ** 9)
|
|
|
|
|
|
|
|
|
|
# Step 2
|
|
|
|
|
k40, k60 = kernel2.deriv4_6_8_10(0, numout=2)
|
|
|
|
|
g1 = (-2 * k40 / (mu2 * psi6NS * n)) ** (1.0 / 7)
|
|
|
|
|
g2 = (-2 * k60 / (mu2 * psi8NS * n)) ** (1.0 / 9)
|
|
|
|
|
|
|
|
|
|
# Estimate psi6 given g2.
|
|
|
|
|
# kernel weights.
|
|
|
|
|
kw4, kw6 = kernel2.deriv4_6_8_10(xn / g2, numout=2)
|
|
|
|
|
# Apply fftshift to kw.
|
|
|
|
|
kw = np.r_[kw6, 0, kw6[-1:0:-1]]
|
|
|
|
|
z = np.real(ifft(fft(c, nfft) * fft(kw))) # convolution.
|
|
|
|
|
psi6 = np.sum(c * z[:inc]) / (n * (n - 1) * g2 ** 7)
|
|
|
|
|
|
|
|
|
|
# Estimate psi4 given g1.
|
|
|
|
|
kw4 = kernel2.deriv4_6_8_10(xn / g1, numout=1) # kernel weights.
|
|
|
|
|
kw = np.r_[kw4, 0, kw4[-1:0:-1]] # Apply 'fftshift' to kw.
|
|
|
|
|
z = np.real(ifft(fft(c, nfft) * fft(kw))) # convolution.
|
|
|
|
|
psi4 = np.sum(c * z[:inc]) / (n * (n - 1) * g1 ** 5)
|
|
|
|
|
|
|
|
|
|
h1 = h[dim]
|
|
|
|
|
h_old = 0
|
|
|
|
|
count = 0
|
|
|
|
|
|
|
|
|
|
while ((abs(h_old - h1) > max(releps * h1, abseps)) and
|
|
|
|
|
(count < maxit)):
|
|
|
|
|
count += 1
|
|
|
|
|
h_old = h1
|
|
|
|
|
|
|
|
|
|
# Step 3
|
|
|
|
|
gamma = ((2 * k40 * mu2 * psi4 * h1 ** 5) /
|
|
|
|
|
(-psi6 * R)) ** (1.0 / 7)
|
|
|
|
|
|
|
|
|
|
# Now estimate psi4 given gamma.
|
|
|
|
|
# kernel weights.
|
|
|
|
|
kw4 = kernel2.deriv4_6_8_10(xn / gamma, numout=1)
|
|
|
|
|
kw = np.r_[kw4, 0, kw4[-1:0:-1]] # Apply 'fftshift' to kw.
|
|
|
|
|
z = np.real(ifft(fft(c, nfft) * fft(kw))) # convolution.
|
|
|
|
|
|
|
|
|
|
psi4Gamma = np.sum(c * z[:inc]) / (n * (n - 1) * gamma ** 5)
|
|
|
|
|
|
|
|
|
|
# Step 4
|
|
|
|
|
h1 = (STEconstant2 / psi4Gamma) ** (1.0 / 5)
|
|
|
|
|
|
|
|
|
|
# Kernel other than Gaussian scale bandwidth
|
|
|
|
|
h1 = h1 * (STEconstant / STEconstant2) ** (1.0 / 5)
|
|
|
|
|
|
|
|
|
|
if count >= maxit:
|
|
|
|
|
warnings.warn('The obtained value did not converge.')
|
|
|
|
|
|
|
|
|
|
h[dim] = h1
|
|
|
|
|
# end for dim loop
|
|
|
|
|
return h
|
|
|
|
|
|
|
|
|
|
def hisj(self, data, inc=512, L=7):
|
|
|
|
|
'''
|
|
|
|
|
HISJ Improved Sheather-Jones estimate of smoothing parameter.
|
|
|
|
|
|
|
|
|
|
Unlike many other implementations, this one is immune to problems
|
|
|
|
|
caused by multimodal densities with widely separated modes. The
|
|
|
|
|
estimation does not deteriorate for multimodal densities, because
|
|
|
|
|
it do not assume a parametric model for the data.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
data - a vector of data from which the density estimate is constructed
|
|
|
|
|
inc - the number of mesh points used in the uniform discretization
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
bandwidth - the optimal bandwidth
|
|
|
|
|
|
|
|
|
|
Reference
|
|
|
|
|
---------
|
|
|
|
|
Kernel density estimation via diffusion
|
|
|
|
|
Z. I. Botev, J. F. Grotowski, and D. P. Kroese (2010)
|
|
|
|
|
Annals of Statistics, Volume 38, Number 5, pages 2916-2957.
|
|
|
|
|
'''
|
|
|
|
|
A = np.atleast_2d(data)
|
|
|
|
|
d, n = A.shape
|
|
|
|
|
|
|
|
|
|
# R= int(mkernel(x)^2), mu2= int(x^2*mkernel(x))
|
|
|
|
|
mu2, R, unusedRdd = self.stats()
|
|
|
|
|
STEconstant = R / (n * mu2 ** 2)
|
|
|
|
|
|
|
|
|
|
amin = A.min(axis=1) # Find the minimum value of A.
|
|
|
|
|
amax = A.max(axis=1) # Find the maximum value of A.
|
|
|
|
|
arange = amax - amin # Find the range of A.
|
|
|
|
|
|
|
|
|
|
# xa holds the x 'axis' vector, defining a grid of x values where
|
|
|
|
|
# the k.d. function will be evaluated.
|
|
|
|
|
|
|
|
|
|
ax1 = amin - arange / 8.0
|
|
|
|
|
bx1 = amax + arange / 8.0
|
|
|
|
|
|
|
|
|
|
kernel2 = Kernel('gauss')
|
|
|
|
|
mu2, R, unusedRdd = kernel2.stats()
|
|
|
|
|
STEconstant2 = R / (mu2 ** (2) * n)
|
|
|
|
|
|
|
|
|
|
def fixed_point(t, N, I, a2):
|
|
|
|
|
''' this implements the function t-zeta*gamma^[L](t)'''
|
|
|
|
|
|
|
|
|
|
prod = np.prod
|
|
|
|
|
# L = 7
|
|
|
|
|
logI = np.log(I)
|
|
|
|
|
f = 2 * pi ** (2 * L) * \
|
|
|
|
|
(a2 * exp(L * logI - I * pi ** 2 * t)).sum()
|
|
|
|
|
for s in range(L - 1, 1, -1):
|
|
|
|
|
K0 = prod(np.r_[1:2 * s:2]) / sqrt(2 * pi)
|
|
|
|
|
const = (1 + (1. / 2) ** (s + 1. / 2)) / 3
|
|
|
|
|
time = (2 * const * K0 / N / f) ** (2. / (3 + 2 * s))
|
|
|
|
|
f = 2 * pi ** (2 * s) * \
|
|
|
|
|
(a2 * exp(s * logI - I * pi ** 2 * time)).sum()
|
|
|
|
|
return t - (2 * N * sqrt(pi) * f) ** (-2. / 5)
|
|
|
|
|
|
|
|
|
|
h = np.empty(d)
|
|
|
|
|
for dim in range(d):
|
|
|
|
|
ax = ax1[dim]
|
|
|
|
|
bx = bx1[dim]
|
|
|
|
|
xa = np.linspace(ax, bx, inc)
|
|
|
|
|
R = bx - ax
|
|
|
|
|
|
|
|
|
|
c = gridcount(A[dim], xa)
|
|
|
|
|
N = len(set(A[dim]))
|
|
|
|
|
# a = dct(c/c.sum(), norm=None)
|
|
|
|
|
a = dct(c / len(A[dim]), norm=None)
|
|
|
|
|
|
|
|
|
|
# now compute the optimal bandwidth^2 using the referenced method
|
|
|
|
|
I = np.asfarray(np.arange(1, inc)) ** 2
|
|
|
|
|
a2 = (a[1:] / 2) ** 2
|
|
|
|
|
|
|
|
|
|
def fun(t):
|
|
|
|
|
return fixed_point(t, N, I, a2)
|
|
|
|
|
x = np.linspace(0, 0.1, 150)
|
|
|
|
|
ai = x[0]
|
|
|
|
|
f0 = fun(ai)
|
|
|
|
|
for bi in x[1:]:
|
|
|
|
|
f1 = fun(bi)
|
|
|
|
|
if f1 * f0 <= 0:
|
|
|
|
|
# print('ai = %g, bi = %g' % (ai,bi))
|
|
|
|
|
break
|
|
|
|
|
else:
|
|
|
|
|
ai = bi
|
|
|
|
|
# y = np.asarray([fun(j) for j in x])
|
|
|
|
|
# plt.figure(1)
|
|
|
|
|
# plt.plot(x,y)
|
|
|
|
|
# plt.show()
|
|
|
|
|
|
|
|
|
|
# use fzero to solve the equation t=zeta*gamma^[5](t)
|
|
|
|
|
try:
|
|
|
|
|
t_star = optimize.brentq(fun, a=ai, b=bi)
|
|
|
|
|
except:
|
|
|
|
|
t_star = 0.28 * N ** (-2. / 5)
|
|
|
|
|
warnings.warn('Failure in obtaining smoothing parameter')
|
|
|
|
|
|
|
|
|
|
# smooth the discrete cosine transform of initial data using t_star
|
|
|
|
|
# a_t = a*exp(-np.arange(inc)**2*pi**2*t_star/2)
|
|
|
|
|
# now apply the inverse discrete cosine transform
|
|
|
|
|
# density = idct(a_t)/R;
|
|
|
|
|
|
|
|
|
|
# take the rescaling of the data into account
|
|
|
|
|
bandwidth = sqrt(t_star) * R
|
|
|
|
|
|
|
|
|
|
# Kernel other than Gaussian scale bandwidth
|
|
|
|
|
h[dim] = bandwidth * (STEconstant / STEconstant2) ** (1.0 / 5)
|
|
|
|
|
# end for dim loop
|
|
|
|
|
return h
|
|
|
|
|
|
|
|
|
|
def hstt(self, data, h0=None, inc=128, maxit=100, releps=0.01, abseps=0.0):
|
|
|
|
|
'''HSTT Scott-Tapia-Thompson estimate of smoothing parameter.
|
|
|
|
|
|
|
|
|
|
CALL: hs = hstt(data,kernel)
|
|
|
|
|
|
|
|
|
|
hs = one dimensional value for smoothing parameter
|
|
|
|
|
given the data and kernel. size 1 x D
|
|
|
|
|
data = data matrix, size N x D (D = # dimensions )
|
|
|
|
|
kernel = 'epanechnikov' - Epanechnikov kernel. (default)
|
|
|
|
|
'biweight' - Bi-weight kernel.
|
|
|
|
|
'triweight' - Tri-weight kernel.
|
|
|
|
|
'triangular' - Triangular kernel.
|
|
|
|
|
'gaussian' - Gaussian kernel
|
|
|
|
|
'rectangular' - Rectangular kernel.
|
|
|
|
|
'laplace' - Laplace kernel.
|
|
|
|
|
'logistic' - Logistic kernel.
|
|
|
|
|
|
|
|
|
|
HSTT returns Scott-Tapia-Thompson (STT) estimate of smoothing
|
|
|
|
|
parameter. This is a Solve-The-Equation rule (STE).
|
|
|
|
|
Simulation studies shows that the STT estimate of HS
|
|
|
|
|
is a good choice under a variety of models. A comparison with
|
|
|
|
|
likelihood cross-validation (LCV) indicates that LCV performs slightly
|
|
|
|
|
better for short tailed densities.
|
|
|
|
|
However, STT method in contrast to LCV is insensitive to outliers.
|
|
|
|
|
|
|
|
|
|
Example
|
|
|
|
|
-------
|
|
|
|
|
x = rndnorm(0,1,50,1);
|
|
|
|
|
hs = hstt(x,'gauss');
|
|
|
|
|
|
|
|
|
|
See also
|
|
|
|
|
--------
|
|
|
|
|
hste, hbcv, hboot, hos, hldpi, hlscv, hscv, kde, kdebin
|
|
|
|
|
|
|
|
|
|
Reference
|
|
|
|
|
---------
|
|
|
|
|
B. W. Silverman (1986)
|
|
|
|
|
'Density estimation for statistics and data analysis'
|
|
|
|
|
Chapman and Hall, pp 57--61
|
|
|
|
|
'''
|
|
|
|
|
A = np.atleast_2d(data)
|
|
|
|
|
d, n = A.shape
|
|
|
|
|
|
|
|
|
|
# R= int(mkernel(x)^2), mu2= int(x^2*mkernel(x))
|
|
|
|
|
mu2, R, unusedRdd = self.stats()
|
|
|
|
|
|
|
|
|
|
AMISEconstant = (8 * sqrt(pi) * R / (3 * mu2 ** 2 * n)) ** (1. / 5)
|
|
|
|
|
STEconstant = R / (mu2 ** (2) * n)
|
|
|
|
|
|
|
|
|
|
sigmaA = self.hns(A) / AMISEconstant
|
|
|
|
|
if h0 is None:
|
|
|
|
|
h0 = sigmaA * AMISEconstant
|
|
|
|
|
|
|
|
|
|
h = np.asarray(h0, dtype=float)
|
|
|
|
|
|
|
|
|
|
nfft = inc * 2
|
|
|
|
|
amin = A.min(axis=1) # Find the minimum value of A.
|
|
|
|
|
amax = A.max(axis=1) # Find the maximum value of A.
|
|
|
|
|
arange = amax - amin # Find the range of A.
|
|
|
|
|
|
|
|
|
|
# xa holds the x 'axis' vector, defining a grid of x values where
|
|
|
|
|
# the k.d. function will be evaluated.
|
|
|
|
|
|
|
|
|
|
ax1 = amin - arange / 8.0
|
|
|
|
|
bx1 = amax + arange / 8.0
|
|
|
|
|
|
|
|
|
|
fft = np.fft.fft
|
|
|
|
|
ifft = np.fft.ifft
|
|
|
|
|
for dim in range(d):
|
|
|
|
|
s = sigmaA[dim]
|
|
|
|
|
datan = A[dim] / s
|
|
|
|
|
ax = ax1[dim] / s
|
|
|
|
|
bx = bx1[dim] / s
|
|
|
|
|
|
|
|
|
|
xa = np.linspace(ax, bx, inc)
|
|
|
|
|
xn = np.linspace(0, bx - ax, inc)
|
|
|
|
|
|
|
|
|
|
c = gridcount(datan, xa)
|
|
|
|
|
|
|
|
|
|
count = 1
|
|
|
|
|
h_old = 0
|
|
|
|
|
h1 = h[dim] / s
|
|
|
|
|
delta = (bx - ax) / (inc - 1)
|
|
|
|
|
while ((abs(h_old - h1) > max(releps * h1, abseps)) and
|
|
|
|
|
(count < maxit)):
|
|
|
|
|
count += 1
|
|
|
|
|
h_old = h1
|
|
|
|
|
|
|
|
|
|
kw4 = self.kernel(xn / h1) / (n * h1 * self.norm_factor(d=1))
|
|
|
|
|
kw = np.r_[kw4, 0, kw4[-1:0:-1]] # Apply 'fftshift' to kw.
|
|
|
|
|
f = np.real(ifft(fft(c, nfft) * fft(kw))) # convolution.
|
|
|
|
|
|
|
|
|
|
# Estimate psi4=R(f'') using simple finite differences and
|
|
|
|
|
# quadrature.
|
|
|
|
|
ix = np.arange(1, inc - 1)
|
|
|
|
|
z = ((f[ix + 1] - 2 * f[ix] + f[ix - 1]) / delta ** 2) ** 2
|
|
|
|
|
psi4 = delta * z.sum()
|
|
|
|
|
h1 = (STEconstant / psi4) ** (1. / 5)
|
|
|
|
|
|
|
|
|
|
if count >= maxit:
|
|
|
|
|
warnings.warn('The obtained value did not converge.')
|
|
|
|
|
|
|
|
|
|
h[dim] = h1 * s
|
|
|
|
|
# end % for dim loop
|
|
|
|
|
return h
|
|
|
|
|
|
|
|
|
|
def hscv(self, data, hvec=None, inc=128, maxit=100, fulloutput=False):
|
|
|
|
|
'''
|
|
|
|
|
HSCV Smoothed cross-validation estimate of smoothing parameter.
|
|
|
|
|
|
|
|
|
|
CALL: [hs,hvec,score] = hscv(data,kernel,hvec)
|
|
|
|
|
|
|
|
|
|
hs = smoothing parameter
|
|
|
|
|
hvec = vector defining possible values of hs
|
|
|
|
|
(default linspace(0.25*h0,h0,100), h0=0.62)
|
|
|
|
|
score = score vector
|
|
|
|
|
data = data vector
|
|
|
|
|
kernel = 'gaussian' - Gaussian kernel the only supported
|
|
|
|
|
|
|
|
|
|
Note that only the first 4 letters of the kernel name is needed.
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
data = rndnorm(0,1,20,1)
|
|
|
|
|
[hs hvec score] = hscv(data,'epan');
|
|
|
|
|
plot(hvec,score)
|
|
|
|
|
See also hste, hbcv, hboot, hos, hldpi, hlscv, hstt, kde, kdefun
|
|
|
|
|
|
|
|
|
|
Wand,M.P. and Jones, M.C. (1986)
|
|
|
|
|
'Kernel smoothing'
|
|
|
|
|
Chapman and Hall, pp 75--79
|
|
|
|
|
'''
|
|
|
|
|
# TODO: Add support for other kernels than Gaussian
|
|
|
|
|
A = np.atleast_2d(data)
|
|
|
|
|
d, n = A.shape
|
|
|
|
|
|
|
|
|
|
# R= int(mkernel(x)^2), mu2= int(x^2*mkernel(x))
|
|
|
|
|
mu2, R, unusedRdd = self.stats()
|
|
|
|
|
|
|
|
|
|
AMISEconstant = (8 * sqrt(pi) * R / (3 * mu2 ** 2 * n)) ** (1. / 5)
|
|
|
|
|
STEconstant = R / (mu2 ** (2) * n)
|
|
|
|
|
|
|
|
|
|
sigmaA = self.hns(A) / AMISEconstant
|
|
|
|
|
if hvec is None:
|
|
|
|
|
H = AMISEconstant / 0.93
|
|
|
|
|
hvec = np.linspace(0.25 * H, H, maxit)
|
|
|
|
|
hvec = np.asarray(hvec, dtype=float)
|
|
|
|
|
|
|
|
|
|
steps = len(hvec)
|
|
|
|
|
score = np.zeros(steps)
|
|
|
|
|
|
|
|
|
|
nfft = inc * 2
|
|
|
|
|
amin = A.min(axis=1) # Find the minimum value of A.
|
|
|
|
|
amax = A.max(axis=1) # Find the maximum value of A.
|
|
|
|
|
arange = amax - amin # Find the range of A.
|
|
|
|
|
|
|
|
|
|
# xa holds the x 'axis' vector, defining a grid of x values where
|
|
|
|
|
# the k.d. function will be evaluated.
|
|
|
|
|
|
|
|
|
|
ax1 = amin - arange / 8.0
|
|
|
|
|
bx1 = amax + arange / 8.0
|
|
|
|
|
|
|
|
|
|
kernel2 = Kernel('gauss')
|
|
|
|
|
mu2, R, unusedRdd = kernel2.stats()
|
|
|
|
|
STEconstant2 = R / (mu2 ** (2) * n)
|
|
|
|
|
fft = np.fft.fft
|
|
|
|
|
ifft = np.fft.ifft
|
|
|
|
|
|
|
|
|
|
h = np.zeros(d)
|
|
|
|
|
hvec = hvec * (STEconstant2 / STEconstant) ** (1. / 5.)
|
|
|
|
|
|
|
|
|
|
k40, k60, k80, k100 = kernel2.deriv4_6_8_10(0, numout=4)
|
|
|
|
|
psi8 = 105 / (32 * sqrt(pi))
|
|
|
|
|
psi12 = 3465. / (512 * sqrt(pi))
|
|
|
|
|
g1 = (-2. * k60 / (mu2 * psi8 * n)) ** (1. / 9.)
|
|
|
|
|
g2 = (-2. * k100 / (mu2 * psi12 * n)) ** (1. / 13.)
|
|
|
|
|
|
|
|
|
|
for dim in range(d):
|
|
|
|
|
s = sigmaA[dim]
|
|
|
|
|
ax = ax1[dim] / s
|
|
|
|
|
bx = bx1[dim] / s
|
|
|
|
|
datan = A[dim] / s
|
|
|
|
|
|
|
|
|
|
xa = np.linspace(ax, bx, inc)
|
|
|
|
|
xn = np.linspace(0, bx - ax, inc)
|
|
|
|
|
|
|
|
|
|
c = gridcount(datan, xa)
|
|
|
|
|
|
|
|
|
|
kw4, kw6 = kernel2.deriv4_6_8_10(xn / g1, numout=2)
|
|
|
|
|
kw = np.r_[kw6, 0, kw6[-1:0:-1]]
|
|
|
|
|
z = np.real(ifft(fft(c, nfft) * fft(kw)))
|
|
|
|
|
psi6 = np.sum(c * z[:inc]) / (n ** 2 * g1 ** 7)
|
|
|
|
|
|
|
|
|
|
kw4, kw6, kw8, kw10 = kernel2.deriv4_6_8_10(xn / g2, numout=4)
|
|
|
|
|
kw = np.r_[kw10, 0, kw10[-1:0:-1]]
|
|
|
|
|
z = np.real(ifft(fft(c, nfft) * fft(kw)))
|
|
|
|
|
psi10 = np.sum(c * z[:inc]) / (n ** 2 * g2 ** 11)
|
|
|
|
|
|
|
|
|
|
g3 = (-2. * k40 / (mu2 * psi6 * n)) ** (1. / 7.)
|
|
|
|
|
g4 = (-2. * k80 / (mu2 * psi10 * n)) ** (1. / 11.)
|
|
|
|
|
|
|
|
|
|
kw4 = kernel2.deriv4_6_8_10(xn / g3, numout=1)
|
|
|
|
|
kw = np.r_[kw4, 0, kw4[-1:0:-1]]
|
|
|
|
|
z = np.real(ifft(fft(c, nfft) * fft(kw)))
|
|
|
|
|
psi4 = np.sum(c * z[:inc]) / (n ** 2 * g3 ** 5)
|
|
|
|
|
|
|
|
|
|
kw4, kw6, kw8 = kernel2.deriv4_6_8_10(xn / g3, numout=3)
|
|
|
|
|
kw = np.r_[kw8, 0, kw8[-1:0:-1]]
|
|
|
|
|
z = np.real(ifft(fft(c, nfft) * fft(kw)))
|
|
|
|
|
psi8 = np.sum(c * z[:inc]) / (n ** 2 * g4 ** 9)
|
|
|
|
|
|
|
|
|
|
const = (441. / (64 * pi)) ** (1. / 18.) * \
|
|
|
|
|
(4 * pi) ** (-1. / 5.) * \
|
|
|
|
|
psi4 ** (-2. / 5.) * psi8 ** (-1. / 9.)
|
|
|
|
|
|
|
|
|
|
M = np.atleast_2d(datan)
|
|
|
|
|
|
|
|
|
|
Y = (M - M.T).ravel()
|
|
|
|
|
|
|
|
|
|
for i in range(steps):
|
|
|
|
|
g = const * n ** (-23. / 45) * hvec[i] ** (-2)
|
|
|
|
|
sig1 = sqrt(2 * hvec[i] ** 2 + 2 * g ** 2)
|
|
|
|
|
sig2 = sqrt(hvec[i] ** 2 + 2 * g ** 2)
|
|
|
|
|
sig3 = sqrt(2 * g ** 2)
|
|
|
|
|
term2 = np.sum(kernel2(Y / sig1) / sig1 - 2 * kernel2(
|
|
|
|
|
Y / sig2) / sig2 + kernel2(Y / sig3) / sig3)
|
|
|
|
|
|
|
|
|
|
score[i] = 1. / (n * hvec[i] * 2. * sqrt(pi)) + term2 / n ** 2
|
|
|
|
|
|
|
|
|
|
idx = score.argmin()
|
|
|
|
|
# Kernel other than Gaussian scale bandwidth
|
|
|
|
|
h[dim] = hvec[idx] * (STEconstant / STEconstant2) ** (1 / 5)
|
|
|
|
|
if idx == 0:
|
|
|
|
|
warnings.warn(
|
|
|
|
|
'Optimum is probably lower than hs=%g for dim=%d' %
|
|
|
|
|
(h[dim] * s, dim))
|
|
|
|
|
elif idx == maxit - 1:
|
|
|
|
|
warnings.warn(
|
|
|
|
|
'Optimum is probably higher than hs=%g for dim=%d' %
|
|
|
|
|
(h[dim] * s, dim))
|
|
|
|
|
|
|
|
|
|
hvec = hvec * (STEconstant / STEconstant2) ** (1 / 5)
|
|
|
|
|
if fulloutput:
|
|
|
|
|
return h * sigmaA, score, hvec, sigmaA
|
|
|
|
|
else:
|
|
|
|
|
return h * sigmaA
|
|
|
|
|
|
|
|
|
|
def hldpi(self, data, L=2, inc=128):
|
|
|
|
|
'''HLDPI L-stage Direct Plug-In estimate of smoothing parameter.
|
|
|
|
|
|
|
|
|
|
CALL: hs = hldpi(data,kernel,L)
|
|
|
|
|
|
|
|
|
|
hs = one dimensional value for smoothing parameter
|
|
|
|
|
given the data and kernel. size 1 x D
|
|
|
|
|
data = data matrix, size N x D (D = # dimensions )
|
|
|
|
|
kernel = 'epanechnikov' - Epanechnikov kernel.
|
|
|
|
|
'biweight' - Bi-weight kernel.
|
|
|
|
|
'triweight' - Tri-weight kernel.
|
|
|
|
|
'triangluar' - Triangular kernel.
|
|
|
|
|
'gaussian' - Gaussian kernel
|
|
|
|
|
'rectangular' - Rectanguler kernel.
|
|
|
|
|
'laplace' - Laplace kernel.
|
|
|
|
|
'logistic' - Logistic kernel.
|
|
|
|
|
L = 0,1,2,3,... (default 2)
|
|
|
|
|
|
|
|
|
|
Note that only the first 4 letters of the kernel name is needed.
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
x = rndnorm(0,1,50,1);
|
|
|
|
|
hs = hldpi(x,'gauss',1);
|
|
|
|
|
|
|
|
|
|
See also hste, hbcv, hboot, hos, hlscv, hscv, hstt, kde, kdefun
|
|
|
|
|
|
|
|
|
|
Wand,M.P. and Jones, M.C. (1995)
|
|
|
|
|
'Kernel smoothing'
|
|
|
|
|
Chapman and Hall, pp 67--74
|
|
|
|
|
'''
|
|
|
|
|
A = np.atleast_2d(data)
|
|
|
|
|
d, n = A.shape
|
|
|
|
|
|
|
|
|
|
# R= int(mkernel(x)^2), mu2= int(x^2*mkernel(x))
|
|
|
|
|
mu2, R, unusedRdd = self.stats()
|
|
|
|
|
|
|
|
|
|
AMISEconstant = (8 * sqrt(pi) * R / (3 * n * mu2 ** 2)) ** (1. / 5)
|
|
|
|
|
STEconstant = R / (n * mu2 ** 2)
|
|
|
|
|
|
|
|
|
|
sigmaA = self.hns(A) / AMISEconstant
|
|
|
|
|
|
|
|
|
|
nfft = inc * 2
|
|
|
|
|
amin = A.min(axis=1) # Find the minimum value of A.
|
|
|
|
|
amax = A.max(axis=1) # Find the maximum value of A.
|
|
|
|
|
arange = amax - amin # Find the range of A.
|
|
|
|
|
|
|
|
|
|
# xa holds the x 'axis' vector, defining a grid of x values where
|
|
|
|
|
# the k.d. function will be evaluated.
|
|
|
|
|
|
|
|
|
|
ax1 = amin - arange / 8.0
|
|
|
|
|
bx1 = amax + arange / 8.0
|
|
|
|
|
|
|
|
|
|
kernel2 = Kernel('gauss')
|
|
|
|
|
mu2, unusedR, unusedRdd = kernel2.stats()
|
|
|
|
|
|
|
|
|
|
fft = np.fft.fft
|
|
|
|
|
ifft = np.fft.ifft
|
|
|
|
|
|
|
|
|
|
h = np.zeros(d)
|
|
|
|
|
for dim in range(d):
|
|
|
|
|
s = sigmaA[dim]
|
|
|
|
|
datan = A[dim] # / s
|
|
|
|
|
ax = ax1[dim] # / s
|
|
|
|
|
bx = bx1[dim] # / s
|
|
|
|
|
|
|
|
|
|
xa = np.linspace(ax, bx, inc)
|
|
|
|
|
xn = np.linspace(0, bx - ax, inc)
|
|
|
|
|
|
|
|
|
|
c = gridcount(datan, xa)
|
|
|
|
|
|
|
|
|
|
r = 2 * L + 4
|
|
|
|
|
rd2 = L + 2
|
|
|
|
|
|
|
|
|
|
# Eq. 3.7 in Wand and Jones (1995)
|
|
|
|
|
PSI_r = (-1) ** (rd2) * np.prod(
|
|
|
|
|
np.r_[rd2 + 1:r + 1]) / (sqrt(pi) * (2 * s) ** (r + 1))
|
|
|
|
|
PSI = PSI_r
|
|
|
|
|
if L > 0:
|
|
|
|
|
# High order derivatives of the Gaussian kernel
|
|
|
|
|
Kd = kernel2.deriv4_6_8_10(0, numout=L)
|
|
|
|
|
|
|
|
|
|
# L-stage iterations to estimate PSI_4
|
|
|
|
|
for ix in range(L, 0, -1):
|
|
|
|
|
gi = (-2 * Kd[ix - 1] /
|
|
|
|
|
(mu2 * PSI * n)) ** (1. / (2 * ix + 5))
|
|
|
|
|
|
|
|
|
|
# Obtain the kernel weights.
|
|
|
|
|
KW0 = kernel2.deriv4_6_8_10(xn / gi, numout=ix)
|
|
|
|
|
if ix > 1:
|
|
|
|
|
KW0 = KW0[-1]
|
|
|
|
|
# Apply 'fftshift' to kw.
|
|
|
|
|
kw = np.r_[KW0, 0, KW0[inc - 1:0:-1]]
|
|
|
|
|
|
|
|
|
|
# Perform the convolution.
|
|
|
|
|
z = np.real(ifft(fft(c, nfft) * fft(kw)))
|
|
|
|
|
|
|
|
|
|
PSI = np.sum(c * z[:inc]) / (n ** 2 * gi ** (2 * ix + 3))
|
|
|
|
|
# end
|
|
|
|
|
# end
|
|
|
|
|
h[dim] = (STEconstant / PSI) ** (1. / 5)
|
|
|
|
|
return h
|
|
|
|
|
|
|
|
|
|
def norm_factor(self, d=1, n=None):
|
|
|
|
|
return self.kernel.norm_factor(d, n)
|
|
|
|
|
|
|
|
|
|
def eval_points(self, points):
|
|
|
|
|
return self.kernel(np.atleast_2d(points))
|
|
|
|
|
__call__ = eval_points
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def mkernel(X, kernel):
|
|
|
|
|
"""MKERNEL Multivariate Kernel Function.
|
|
|
|
|
|
|
|
|
|
Paramaters
|
|
|
|
|
----------
|
|
|
|
|
X : array-like
|
|
|
|
|
matrix size d x n (d = # dimensions, n = # evaluation points)
|
|
|
|
|
kernel : string
|
|
|
|
|
defining kernel
|
|
|
|
|
'epanechnikov' - Epanechnikov kernel.
|
|
|
|
|
'biweight' - Bi-weight kernel.
|
|
|
|
|
'triweight' - Tri-weight kernel.
|
|
|
|
|
'p1epanechnikov' - product of 1D Epanechnikov kernel.
|
|
|
|
|
'p1biweight' - product of 1D Bi-weight kernel.
|
|
|
|
|
'p1triweight' - product of 1D Tri-weight kernel.
|
|
|
|
|
'triangular' - Triangular kernel.
|
|
|
|
|
'gaussian' - Gaussian kernel
|
|
|
|
|
'rectangular' - Rectangular kernel.
|
|
|
|
|
'laplace' - Laplace kernel.
|
|
|
|
|
'logistic' - Logistic kernel.
|
|
|
|
|
Note that only the first 4 letters of the kernel name is needed.
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
z : ndarray
|
|
|
|
|
kernel function values evaluated at X
|
|
|
|
|
|
|
|
|
|
See also
|
|
|
|
|
--------
|
|
|
|
|
kde, kdefun, kdebin
|
|
|
|
|
|
|
|
|
|
References
|
|
|
|
|
----------
|
|
|
|
|
B. W. Silverman (1986)
|
|
|
|
|
'Density estimation for statistics and data analysis'
|
|
|
|
|
Chapman and Hall, pp. 43, 76
|
|
|
|
|
|
|
|
|
|
Wand, M. P. and Jones, M. C. (1995)
|
|
|
|
|
'Density estimation for statistics and data analysis'
|
|
|
|
|
Chapman and Hall, pp 31, 103, 175
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
fun = _MKERNEL_DICT[kernel[:4]]
|
|
|
|
|
return fun(np.atleast_2d(X))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def accumsum(accmap, a, size, dtype=None):
|
|
|
|
|
if dtype is None:
|
|
|
|
|
dtype = a.dtype
|
|
|
|
|
size = np.atleast_1d(size)
|
|
|
|
|
if len(size) > 1:
|
|
|
|
|
binx = accmap[:, 0]
|
|
|
|
|
biny = accmap[:, 1]
|
|
|
|
|
out = sparse.coo_matrix(
|
|
|
|
|
(a.ravel(), (binx, biny)), shape=size, dtype=dtype).tocsr()
|
|
|
|
|
else:
|
|
|
|
|
binx = accmap.ravel()
|
|
|
|
|
zero = np.zeros(len(binx))
|
|
|
|
|
out = sparse.coo_matrix(
|
|
|
|
|
(a.ravel(), (binx, zero)), shape=(size, 1), dtype=dtype).tocsr()
|
|
|
|
|
return out
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def accumsum2(accmap, a, size):
|
|
|
|
|
return np.bincount(accmap.ravel(), a.ravel(), np.array(size).max())
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def accum(accmap, a, func=None, size=None, fill_value=0, dtype=None):
|
|
|
|
|
"""An accumulation function similar to Matlab's `accumarray` function.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
accmap : ndarray
|
|
|
|
|
This is the "accumulation map". It maps input (i.e. indices into
|
|
|
|
|
`a`) to their destination in the output array. The first `a.ndim`
|
|
|
|
|
dimensions of `accmap` must be the same as `a.shape`. That is,
|
|
|
|
|
`accmap.shape[:a.ndim]` must equal `a.shape`. For example, if `a`
|
|
|
|
|
has shape (15,4), then `accmap.shape[:2]` must equal (15,4). In this
|
|
|
|
|
case `accmap[i,j]` gives the index into the output array where
|
|
|
|
|
element (i,j) of `a` is to be accumulated. If the output is, say,
|
|
|
|
|
a 2D, then `accmap` must have shape (15,4,2). The value in the
|
|
|
|
|
last dimension give indices into the output array. If the output is
|
|
|
|
|
1D, then the shape of `accmap` can be either (15,4) or (15,4,1)
|
|
|
|
|
a : ndarray
|
|
|
|
|
The input data to be accumulated.
|
|
|
|
|
func : callable or None
|
|
|
|
|
The accumulation function. The function will be passed a list
|
|
|
|
|
of values from `a` to be accumulated.
|
|
|
|
|
If None, numpy.sum is assumed.
|
|
|
|
|
size : ndarray or None
|
|
|
|
|
The size of the output array. If None, the size will be determined
|
|
|
|
|
from `accmap`.
|
|
|
|
|
fill_value : scalar
|
|
|
|
|
The default value for elements of the output array.
|
|
|
|
|
dtype : numpy data type, or None
|
|
|
|
|
The data type of the output array. If None, the data type of
|
|
|
|
|
`a` is used.
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
out : ndarray
|
|
|
|
|
The accumulated results.
|
|
|
|
|
|
|
|
|
|
The shape of `out` is `size` if `size` is given. Otherwise the
|
|
|
|
|
shape is determined by the (lexicographically) largest indices of
|
|
|
|
|
the output found in `accmap`.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Examples
|
|
|
|
|
--------
|
|
|
|
|
>>> from numpy import array, prod
|
|
|
|
|
>>> a = array([[1,2,3],[4,-1,6],[-1,8,9]])
|
|
|
|
|
>>> a
|
|
|
|
|
array([[ 1, 2, 3],
|
|
|
|
|
[ 4, -1, 6],
|
|
|
|
|
[-1, 8, 9]])
|
|
|
|
|
>>> # Sum the diagonals.
|
|
|
|
|
>>> accmap = array([[0,1,2],[2,0,1],[1,2,0]])
|
|
|
|
|
>>> s = accum(accmap, a)
|
|
|
|
|
>>> s
|
|
|
|
|
array([ 9, 7, 15])
|
|
|
|
|
>>> # A 2D output, from sub-arrays with shapes and positions like this:
|
|
|
|
|
>>> # [ (2,2) (2,1)]
|
|
|
|
|
>>> # [ (1,2) (1,1)]
|
|
|
|
|
>>> accmap = array([
|
|
|
|
|
... [[0,0],[0,0],[0,1]],
|
|
|
|
|
... [[0,0],[0,0],[0,1]],
|
|
|
|
|
... [[1,0],[1,0],[1,1]]])
|
|
|
|
|
>>> # Accumulate using a product.
|
|
|
|
|
>>> accum(accmap, a, func=prod, dtype=float)
|
|
|
|
|
array([[ -8., 18.],
|
|
|
|
|
[ -8., 9.]])
|
|
|
|
|
>>> # Same accmap, but create an array of lists of values.
|
|
|
|
|
>>> accum(accmap, a, func=lambda x: x, dtype='O')
|
|
|
|
|
array([[[1, 2, 4, -1], [3, 6]],
|
|
|
|
|
[[-1, 8], [9]]], dtype=object)
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
# Check for bad arguments and handle the defaults.
|
|
|
|
|
if accmap.shape[:a.ndim] != a.shape:
|
|
|
|
|
raise ValueError(
|
|
|
|
|
"The initial dimensions of accmap must be the same as a.shape")
|
|
|
|
|
if func is None:
|
|
|
|
|
func = np.sum
|
|
|
|
|
if dtype is None:
|
|
|
|
|
dtype = a.dtype
|
|
|
|
|
if accmap.shape == a.shape:
|
|
|
|
|
accmap = np.expand_dims(accmap, -1)
|
|
|
|
|
adims = tuple(range(a.ndim))
|
|
|
|
|
if size is None:
|
|
|
|
|
size = 1 + np.squeeze(np.apply_over_axes(np.max, accmap, axes=adims))
|
|
|
|
|
size = np.atleast_1d(size)
|
|
|
|
|
|
|
|
|
|
# Create an array of python lists of values.
|
|
|
|
|
vals = np.empty(size, dtype='O')
|
|
|
|
|
for s in product(*[range(k) for k in size]):
|
|
|
|
|
vals[s] = []
|
|
|
|
|
for s in product(*[range(k) for k in a.shape]):
|
|
|
|
|
indx = tuple(accmap[s])
|
|
|
|
|
val = a[s]
|
|
|
|
|
vals[indx].append(val)
|
|
|
|
|
|
|
|
|
|
# Create the output array.
|
|
|
|
|
out = np.empty(size, dtype=dtype)
|
|
|
|
|
for s in product(*[range(k) for k in size]):
|
|
|
|
|
if vals[s] == []:
|
|
|
|
|
out[s] = fill_value
|
|
|
|
|
else:
|
|
|
|
|
out[s] = func(vals[s])
|
|
|
|
|
return out
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def qlevels(pdf, p=(10, 30, 50, 70, 90, 95, 99, 99.9), x1=None, x2=None):
|
|
|
|
|
"""QLEVELS Calculates quantile levels which encloses P% of PDF.
|
|
|
|
|
|
|
|
|
|
CALL: [ql PL] = qlevels(pdf,PL,x1,x2);
|
|
|
|
|
|
|
|
|
|
ql = the discrete quantile levels.
|
|
|
|
|
pdf = joint point density function matrix or vector
|
|
|
|
|
PL = percent level (default [10:20:90 95 99 99.9])
|
|
|
|
|
x1,x2 = vectors of the spacing of the variables
|
|
|
|
|
(Default unit spacing)
|
|
|
|
|
|
|
|
|
|
QLEVELS numerically integrates PDF by decreasing height and find the
|
|
|
|
|
quantile levels which encloses P% of the distribution. If X1 and
|
|
|
|
|
(or) X2 is unspecified it is assumed that dX1 and dX2 is constant.
|
|
|
|
|
NB! QLEVELS normalizes the integral of PDF to N/(N+0.001) before
|
|
|
|
|
calculating QL in order to reflect the sampling of PDF is finite.
|
|
|
|
|
Currently only able to handle 1D and 2D PDF's if dXi is not constant
|
|
|
|
|
(i=1,2).
|
|
|
|
|
|
|
|
|
|
Example
|
|
|
|
|
-------
|
|
|
|
|
>>> import wafo.stats as ws
|
|
|
|
|
>>> x = np.linspace(-8,8,2001);
|
|
|
|
|
>>> PL = np.r_[10:90:20, 90, 95, 99, 99.9]
|
|
|
|
|
>>> qlevels(ws.norm.pdf(x),p=PL, x1=x);
|
|
|
|
|
array([ 0.39591707, 0.37058719, 0.31830968, 0.23402133, 0.10362052,
|
|
|
|
|
0.05862129, 0.01449505, 0.00178806])
|
|
|
|
|
|
|
|
|
|
# compared with the exact values
|
|
|
|
|
>>> ws.norm.pdf(ws.norm.ppf((100-PL)/200))
|
|
|
|
|
array([ 0.39580488, 0.370399 , 0.31777657, 0.23315878, 0.10313564,
|
|
|
|
|
0.05844507, 0.01445974, 0.00177719])
|
|
|
|
|
|
|
|
|
|
See also
|
|
|
|
|
--------
|
|
|
|
|
qlevels2, tranproc
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
norm = 1 # normalize cdf to unity
|
|
|
|
|
pdf = np.atleast_1d(pdf)
|
|
|
|
|
if any(pdf.ravel() < 0):
|
|
|
|
|
raise ValueError(
|
|
|
|
|
'This is not a pdf since one or more values of pdf is negative')
|
|
|
|
|
|
|
|
|
|
fsiz = pdf.shape
|
|
|
|
|
fsizmin = min(fsiz)
|
|
|
|
|
if fsizmin == 0:
|
|
|
|
|
return []
|
|
|
|
|
|
|
|
|
|
N = np.prod(fsiz)
|
|
|
|
|
d = len(fsiz)
|
|
|
|
|
if x1 is None or ((x2 is None) and d > 2):
|
|
|
|
|
fdfi = pdf.ravel()
|
|
|
|
|
else:
|
|
|
|
|
if d == 1: # pdf in one dimension
|
|
|
|
|
dx22 = np.ones(1)
|
|
|
|
|
else: # % pdf in two dimensions
|
|
|
|
|
dx2 = np.diff(x2.ravel()) * 0.5
|
|
|
|
|
dx22 = np.r_[0, dx2] + np.r_[dx2, 0]
|
|
|
|
|
|
|
|
|
|
dx1 = np.diff(x1.ravel()) * 0.5
|
|
|
|
|
dx11 = np.r_[0, dx1] + np.r_[dx1, 0]
|
|
|
|
|
dx1x2 = dx22[:, None] * dx11
|
|
|
|
|
fdfi = (pdf * dx1x2).ravel()
|
|
|
|
|
|
|
|
|
|
p = np.atleast_1d(p)
|
|
|
|
|
|
|
|
|
|
if np.any((p < 0) | (100 < p)):
|
|
|
|
|
raise ValueError('PL must satisfy 0 <= PL <= 100')
|
|
|
|
|
|
|
|
|
|
p2 = p / 100.0
|
|
|
|
|
ind = np.argsort(pdf.ravel()) # sort by height of pdf
|
|
|
|
|
ind = ind[::-1]
|
|
|
|
|
fi = pdf.flat[ind]
|
|
|
|
|
|
|
|
|
|
# integration in the order of decreasing height of pdf
|
|
|
|
|
Fi = np.cumsum(fdfi[ind])
|
|
|
|
|
|
|
|
|
|
if norm: # %normalize Fi to make sure int pdf dx1 dx2 approx 1
|
|
|
|
|
Fi = Fi / Fi[-1] * N / (N + 1.5e-8)
|
|
|
|
|
|
|
|
|
|
maxFi = np.max(Fi)
|
|
|
|
|
if maxFi > 1:
|
|
|
|
|
warnings.warn('this is not a pdf since cdf>1! normalizing')
|
|
|
|
|
|
|
|
|
|
Fi = Fi / Fi[-1] * N / (N + 1.5e-8)
|
|
|
|
|
|
|
|
|
|
elif maxFi < .95:
|
|
|
|
|
msg = '''The given pdf is too sparsely sampled since cdf<.95.
|
|
|
|
|
Thus QL is questionable'''
|
|
|
|
|
warnings.warn(msg)
|
|
|
|
|
|
|
|
|
|
# make sure Fi is strictly increasing by not considering duplicate values
|
|
|
|
|
ind, = np.where(np.diff(np.r_[Fi, 1]) > 0)
|
|
|
|
|
# calculating the inverse of Fi to find the index
|
|
|
|
|
ui = tranproc(Fi[ind], fi[ind], p2)
|
|
|
|
|
# to the desired quantile level
|
|
|
|
|
# ui=smooth(Fi(ind),fi(ind),1,p2(:),1) % alternative
|
|
|
|
|
# res=ui-ui2
|
|
|
|
|
|
|
|
|
|
if np.any(ui >= max(pdf.ravel())):
|
|
|
|
|
warnings.warn('The lowest percent level is too close to 0%')
|
|
|
|
|
|
|
|
|
|
if np.any(ui <= min(pdf.ravel())):
|
|
|
|
|
msg = '''The given pdf is too sparsely sampled or
|
|
|
|
|
the highest percent level is too close to 100%'''
|
|
|
|
|
warnings.warn(msg)
|
|
|
|
|
ui[ui < 0] = 0.0
|
|
|
|
|
|
|
|
|
|
return ui
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def qlevels2(data, p=(10, 30, 50, 70, 90, 95, 99, 99.9), method=1):
|
|
|
|
|
"""QLEVELS2 Calculates quantile levels which encloses P% of data.
|
|
|
|
|
|
|
|
|
|
CALL: [ql PL] = qlevels2(data,PL,method);
|
|
|
|
|
|
|
|
|
|
ql = the discrete quantile levels, size D X Np
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
data : data matrix, size D x N (D = # of dimensions)
|
|
|
|
|
p : percent level vector, length Np (default [10:20:90 95 99 99.9])
|
|
|
|
|
method : integer
|
|
|
|
|
1 Interpolation so that F(X_(k)) == (k-0.5)/n. (default)
|
|
|
|
|
2 Interpolation so that F(X_(k)) == k/(n+1).
|
|
|
|
|
3 Based on the empirical distribution.
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
|
|
|
|
|
QLEVELS2 sort the columns of data in ascending order and find the
|
|
|
|
|
quantile levels for each column which encloses P% of the data.
|
|
|
|
|
|
|
|
|
|
Examples : Finding quantile levels enclosing P% of data:
|
|
|
|
|
--------
|
|
|
|
|
>>> import wafo.stats as ws
|
|
|
|
|
>>> PL = np.r_[10:90:20, 90, 95, 99, 99.9]
|
|
|
|
|
>>> xs = ws.norm.rvs(size=2500000)
|
|
|
|
|
>>> np.allclose(qlevels2(ws.norm.pdf(xs), p=PL),
|
|
|
|
|
... [0.3958, 0.3704, 0.3179, 0.2331, 0.1031, 0.05841, 0.01451, 0.001751],
|
|
|
|
|
... rtol=1e-1)
|
|
|
|
|
True
|
|
|
|
|
|
|
|
|
|
# compared with the exact values
|
|
|
|
|
>>> ws.norm.pdf(ws.norm.ppf((100-PL)/200))
|
|
|
|
|
array([ 0.39580488, 0.370399 , 0.31777657, 0.23315878, 0.10313564,
|
|
|
|
|
0.05844507, 0.01445974, 0.00177719])
|
|
|
|
|
|
|
|
|
|
# Finding the median of xs:
|
|
|
|
|
>>> '%2.2f' % np.abs(qlevels2(xs,50)[0])
|
|
|
|
|
'0.00'
|
|
|
|
|
|
|
|
|
|
See also
|
|
|
|
|
--------
|
|
|
|
|
qlevels
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
q = 100 - np.atleast_1d(p)
|
|
|
|
|
return percentile(data, q, axis=-1, method=method)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
_PKDICT = {1: lambda k, w, n: (k - w) / (n - 1),
|
|
|
|
|
2: lambda k, w, n: (k - w / 2) / n,
|
|
|
|
|
3: lambda k, w, n: k / n,
|
|
|
|
|
4: lambda k, w, n: k / (n + 1),
|
|
|
|
|
5: lambda k, w, n: (k - w / 3) / (n + 1 / 3),
|
|
|
|
|
6: lambda k, w, n: (k - w * 3 / 8) / (n + 1 / 4)}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _compute_qth_weighted_percentile(a, q, axis, out, method, weights,
|
|
|
|
|
overwrite_input):
|
|
|
|
|
# normalise weight vector such that sum of the weight vector equals to n
|
|
|
|
|
q = np.atleast_1d(q) / 100.0
|
|
|
|
|
if (q < 0).any() or (q > 1).any():
|
|
|
|
|
raise ValueError("percentile must be in the range [0,100]")
|
|
|
|
|
|
|
|
|
|
shape0 = a.shape
|
|
|
|
|
if axis is None:
|
|
|
|
|
sorted_ = a.ravel()
|
|
|
|
|
else:
|
|
|
|
|
taxes = range(a.ndim)
|
|
|
|
|
taxes[-1], taxes[axis] = taxes[axis], taxes[-1]
|
|
|
|
|
sorted_ = np.transpose(a, taxes).reshape(-1, shape0[axis])
|
|
|
|
|
|
|
|
|
|
ind = sorted_.argsort(axis=-1)
|
|
|
|
|
if overwrite_input:
|
|
|
|
|
sorted_.sort(axis=-1)
|
|
|
|
|
else:
|
|
|
|
|
sorted_ = np.sort(sorted_, axis=-1)
|
|
|
|
|
|
|
|
|
|
w = np.atleast_1d(weights)
|
|
|
|
|
n = len(w)
|
|
|
|
|
w = w * n / w.sum()
|
|
|
|
|
|
|
|
|
|
# Work on each column separately because of weight vector
|
|
|
|
|
m = sorted_.shape[0]
|
|
|
|
|
nq = len(q)
|
|
|
|
|
y = np.zeros((m, nq))
|
|
|
|
|
pk_fun = _PKDICT.get(method, 1)
|
|
|
|
|
for i in range(m):
|
|
|
|
|
sortedW = w[ind[i]] # rearrange the weight according to ind
|
|
|
|
|
k = sortedW.cumsum() # cumulative weight
|
|
|
|
|
# different algorithm to compute percentile
|
|
|
|
|
pk = pk_fun(k, sortedW, n)
|
|
|
|
|
# Interpolation between pk and sorted_ for given value of q
|
|
|
|
|
y[i] = np.interp(q, pk, sorted_[i])
|
|
|
|
|
if axis is None:
|
|
|
|
|
return np.squeeze(y)
|
|
|
|
|
else:
|
|
|
|
|
shape1 = list(shape0)
|
|
|
|
|
shape1[axis], shape1[-1] = shape1[-1], nq
|
|
|
|
|
return np.squeeze(np.transpose(y.reshape(shape1), taxes))
|
|
|
|
|
|
|
|
|
|
# method=1: p(k) = k/(n-1)
|
|
|
|
|
# method=2: p(k) = (k+0.5)/n.
|
|
|
|
|
# method=3: p(k) = (k+1)/n
|
|
|
|
|
# method=4: p(k) = (k+1)/(n+1)
|
|
|
|
|
# method=5: p(k) = (k+2/3)/(n+1/3)
|
|
|
|
|
# method=6: p(k) = (k+5/8)/(n+1/4)
|
|
|
|
|
|
|
|
|
|
_KDICT = {1: lambda p, n: p * (n - 1),
|
|
|
|
|
2: lambda p, n: p * n - 0.5,
|
|
|
|
|
3: lambda p, n: p * n - 1,
|
|
|
|
|
4: lambda p, n: p * (n + 1) - 1,
|
|
|
|
|
5: lambda p, n: p * (n + 1. / 3) - 2. / 3,
|
|
|
|
|
6: lambda p, n: p * (n + 1. / 4) - 5. / 8}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _compute_qth_percentile(sorted_, q, axis, out, method):
|
|
|
|
|
if not np.isscalar(q):
|
|
|
|
|
p = [_compute_qth_percentile(sorted_, qi, axis, None, method)
|
|
|
|
|
for qi in q]
|
|
|
|
|
if out is not None:
|
|
|
|
|
out.flat = p
|
|
|
|
|
return p
|
|
|
|
|
|
|
|
|
|
q = q / 100.0
|
|
|
|
|
if (q < 0) or (q > 1):
|
|
|
|
|
raise ValueError("percentile must be in the range [0,100]")
|
|
|
|
|
|
|
|
|
|
indexer = [slice(None)] * sorted_.ndim
|
|
|
|
|
Nx = sorted_.shape[axis]
|
|
|
|
|
k_fun = _KDICT.get(method, 1)
|
|
|
|
|
index = np.clip(k_fun(q, Nx), 0, Nx - 1)
|
|
|
|
|
i = int(index)
|
|
|
|
|
if i == index:
|
|
|
|
|
indexer[axis] = slice(i, i + 1)
|
|
|
|
|
weights1 = np.array(1)
|
|
|
|
|
sumval = 1.0
|
|
|
|
|
else:
|
|
|
|
|
indexer[axis] = slice(i, i + 2)
|
|
|
|
|
j = i + 1
|
|
|
|
|
weights1 = np.array([(j - index), (index - i)], float)
|
|
|
|
|
wshape = [1] * sorted_.ndim
|
|
|
|
|
wshape[axis] = 2
|
|
|
|
|
weights1.shape = wshape
|
|
|
|
|
sumval = weights1.sum()
|
|
|
|
|
|
|
|
|
|
# Use add.reduce in both cases to coerce data type as well as
|
|
|
|
|
# check and use out array.
|
|
|
|
|
return np.add.reduce(sorted_[indexer] * weights1,
|
|
|
|
|
axis=axis, out=out) / sumval
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def percentile(a, q, axis=None, out=None, overwrite_input=False, method=1,
|
|
|
|
|
weights=None):
|
|
|
|
|
"""Compute the qth percentile of the data along the specified axis.
|
|
|
|
|
|
|
|
|
|
Returns the qth percentile of the array elements.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
a : array_like
|
|
|
|
|
Input array or object that can be converted to an array.
|
|
|
|
|
q : float in range of [0,100] (or sequence of floats)
|
|
|
|
|
percentile to compute which must be between 0 and 100 inclusive
|
|
|
|
|
axis : {None, int}, optional
|
|
|
|
|
Axis along which the percentiles are computed. The default (axis=None)
|
|
|
|
|
is to compute the median along a flattened version of the array.
|
|
|
|
|
out : ndarray, optional
|
|
|
|
|
Alternative output array in which to place the result. It must
|
|
|
|
|
have the same shape and buffer length as the expected output,
|
|
|
|
|
but the type (of the output) will be cast if necessary.
|
|
|
|
|
overwrite_input : {False, True}, optional
|
|
|
|
|
If True, then allow use of memory of input array (a) for
|
|
|
|
|
calculations. The input array will be modified by the call to
|
|
|
|
|
median. This will save memory when you do not need to preserve
|
|
|
|
|
the contents of the input array. Treat the input as undefined,
|
|
|
|
|
but it will probably be fully or partially sorted. Default is
|
|
|
|
|
False. Note that, if `overwrite_input` is True and the input
|
|
|
|
|
is not already an ndarray, an error will be raised.
|
|
|
|
|
method : scalar integer
|
|
|
|
|
defining the interpolation method. Valid options are
|
|
|
|
|
1 : p[k] = k/(n-1). In this case, p[k] = mode[F(x[k])].
|
|
|
|
|
This is used by S. (default)
|
|
|
|
|
2 : p[k] = (k+0.5)/n. That is a piecewise linear function where
|
|
|
|
|
the knots are the values midway through the steps of the
|
|
|
|
|
empirical cdf. This is popular amongst hydrologists.
|
|
|
|
|
Matlab also uses this formula.
|
|
|
|
|
3 : p[k] = (k+1)/n. That is, linear interpolation of the empirical cdf.
|
|
|
|
|
4 : p[k] = (k+1)/(n+1). Thus p[k] = E[F(x[k])].
|
|
|
|
|
This is used by Minitab and by SPSS.
|
|
|
|
|
5 : p[k] = (k+2/3)/(n+1/3). Then p[k] =~ median[F(x[k])].
|
|
|
|
|
The resulting quantile estimates are approximately
|
|
|
|
|
median-unbiased regardless of the distribution of x.
|
|
|
|
|
6 : p[k] = (k+5/8)/(n+1/4). The resulting quantile estimates are
|
|
|
|
|
approximately unbiased for the expected order statistics
|
|
|
|
|
if x is normally distributed.
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
pcntile : ndarray
|
|
|
|
|
A new array holding the result (unless `out` is specified, in
|
|
|
|
|
which case that array is returned instead). If the input contains
|
|
|
|
|
integers, or floats of smaller precision than 64, then the output
|
|
|
|
|
data-type is float64. Otherwise, the output data-type is the same
|
|
|
|
|
as that of the input.
|
|
|
|
|
|
|
|
|
|
See Also
|
|
|
|
|
--------
|
|
|
|
|
mean, median
|
|
|
|
|
|
|
|
|
|
Notes
|
|
|
|
|
-----
|
|
|
|
|
Given a vector V of length N, the qth percentile of V is the qth ranked
|
|
|
|
|
value in a sorted copy of V. A weighted average of the two nearest
|
|
|
|
|
neighbors is used if the normalized ranking does not match q exactly.
|
|
|
|
|
The same as the median if q is 0.5; the same as the min if q is 0;
|
|
|
|
|
and the same as the max if q is 1
|
|
|
|
|
|
|
|
|
|
Examples
|
|
|
|
|
--------
|
|
|
|
|
>>> import wafo.kdetools as wk
|
|
|
|
|
>>> a = np.array([[10, 7, 4], [3, 2, 1]])
|
|
|
|
|
>>> a
|
|
|
|
|
array([[10, 7, 4],
|
|
|
|
|
[ 3, 2, 1]])
|
|
|
|
|
>>> wk.percentile(a, 50)
|
|
|
|
|
3.5
|
|
|
|
|
>>> wk.percentile(a, 50, axis=0)
|
|
|
|
|
array([ 6.5, 4.5, 2.5])
|
|
|
|
|
>>> wk.percentile(a, 50, axis=0, weights=np.ones(2))
|
|
|
|
|
array([ 6.5, 4.5, 2.5])
|
|
|
|
|
>>> wk.percentile(a, 50, axis=1)
|
|
|
|
|
array([ 7., 2.])
|
|
|
|
|
>>> wk.percentile(a, 50, axis=1, weights=np.ones(3))
|
|
|
|
|
array([ 7., 2.])
|
|
|
|
|
>>> m = wk.percentile(a, 50, axis=0)
|
|
|
|
|
>>> out = np.zeros_like(m)
|
|
|
|
|
>>> wk.percentile(a, 50, axis=0, out=m)
|
|
|
|
|
array([ 6.5, 4.5, 2.5])
|
|
|
|
|
>>> m
|
|
|
|
|
array([ 6.5, 4.5, 2.5])
|
|
|
|
|
>>> b = a.copy()
|
|
|
|
|
>>> wk.percentile(b, 50, axis=1, overwrite_input=True)
|
|
|
|
|
array([ 7., 2.])
|
|
|
|
|
>>> assert not np.all(a==b)
|
|
|
|
|
>>> b = a.copy()
|
|
|
|
|
>>> wk.percentile(b, 50, axis=None, overwrite_input=True)
|
|
|
|
|
3.5
|
|
|
|
|
>>> np.all(a==b)
|
|
|
|
|
True
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
a = np.asarray(a)
|
|
|
|
|
try:
|
|
|
|
|
if q == 0:
|
|
|
|
|
return a.min(axis=axis, out=out)
|
|
|
|
|
elif q == 100:
|
|
|
|
|
return a.max(axis=axis, out=out)
|
|
|
|
|
except:
|
|
|
|
|
pass
|
|
|
|
|
if weights is not None:
|
|
|
|
|
return _compute_qth_weighted_percentile(a, q, axis, out, method,
|
|
|
|
|
weights, overwrite_input)
|
|
|
|
|
elif overwrite_input:
|
|
|
|
|
if axis is None:
|
|
|
|
|
sorted_ = np.sort(a, axis=axis)
|
|
|
|
|
else:
|
|
|
|
|
a.sort(axis=axis)
|
|
|
|
|
sorted_ = a
|
|
|
|
|
else:
|
|
|
|
|
sorted_ = np.sort(a, axis=axis)
|
|
|
|
|
if axis is None:
|
|
|
|
|
axis = 0
|
|
|
|
|
|
|
|
|
|
return _compute_qth_percentile(sorted_, q, axis, out, method)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def iqrange(data, axis=None):
|
|
|
|
|
"""Returns the Inter Quartile Range of data.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
data : array-like
|
|
|
|
|
Input array or object that can be converted to an array.
|
|
|
|
|
axis : {None, int}, optional
|
|
|
|
|
Axis along which the percentiles are computed. The default (axis=None)
|
|
|
|
|
is to compute the median along a flattened version of the array.
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
r : array-like
|
|
|
|
|
abs(np.percentile(data, 75, axis)-np.percentile(data, 25, axis))
|
|
|
|
|
|
|
|
|
|
Notes
|
|
|
|
|
-----
|
|
|
|
|
IQRANGE is a robust measure of spread. The use of interquartile range
|
|
|
|
|
guards against outliers if the distribution have heavy tails.
|
|
|
|
|
|
|
|
|
|
Example
|
|
|
|
|
-------
|
|
|
|
|
>>> a = np.arange(101)
|
|
|
|
|
>>> iqrange(a)
|
|
|
|
|
50.0
|
|
|
|
|
|
|
|
|
|
See also
|
|
|
|
|
--------
|
|
|
|
|
np.std
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
return np.abs(np.percentile(data, 75, axis=axis) -
|
|
|
|
|
np.percentile(data, 25, axis=axis))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def bitget(int_type, offset):
|
|
|
|
|
"""Returns the value of the bit at the offset position in int_type.
|
|
|
|
|
|
|
|
|
|
Example
|
|
|
|
|
-------
|
|
|
|
|
>>> bitget(5, np.r_[0:4])
|
|
|
|
|
array([1, 0, 1, 0])
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
return np.bitwise_and(int_type, 1 << offset) >> offset
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def gridcount(data, X, y=1):
|
|
|
|
|
'''
|
|
|
|
|
Returns D-dimensional histogram using linear binning.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
data = column vectors with D-dimensional data, shape D x Nd
|
|
|
|
|
X = row vectors defining discretization, shape D x N
|
|
|
|
|
Must include the range of the data.
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
c = gridcount, shape N x N x ... x N
|
|
|
|
|
|
|
|
|
|
GRIDCOUNT obtains the grid counts using linear binning.
|
|
|
|
|
There are 2 strategies: simple- or linear- binning.
|
|
|
|
|
Suppose that an observation occurs at x and that the nearest point
|
|
|
|
|
below and above is y and z, respectively. Then simple binning strategy
|
|
|
|
|
assigns a unit weight to either y or z, whichever is closer. Linear
|
|
|
|
|
binning, on the other hand, assigns the grid point at y with the weight
|
|
|
|
|
of (z-x)/(z-y) and the gridpoint at z a weight of (y-x)/(z-y).
|
|
|
|
|
|
|
|
|
|
In terms of approximation error of using gridcounts as pdf-estimate,
|
|
|
|
|
linear binning is significantly more accurate than simple binning.
|
|
|
|
|
|
|
|
|
|
NOTE: The interval [min(X);max(X)] must include the range of the data.
|
|
|
|
|
The order of C is permuted in the same order as
|
|
|
|
|
meshgrid for D==2 or D==3.
|
|
|
|
|
|
|
|
|
|
Example
|
|
|
|
|
-------
|
|
|
|
|
>>> import numpy as np
|
|
|
|
|
>>> import wafo.kdetools as wk
|
|
|
|
|
>>> import pylab as plb
|
|
|
|
|
>>> N = 200
|
|
|
|
|
>>> data = np.random.rayleigh(1,N)
|
|
|
|
|
>>> x = np.linspace(0,max(data)+1,50)
|
|
|
|
|
>>> dx = x[1]-x[0]
|
|
|
|
|
|
|
|
|
|
>>> c = wk.gridcount(data,x)
|
|
|
|
|
|
|
|
|
|
>>> h = plb.plot(x,c,'.') # 1D histogram
|
|
|
|
|
>>> pdf = c/dx/N
|
|
|
|
|
>>> h1 = plb.plot(x, pdf) # 1D probability density plot
|
|
|
|
|
>>> '%1.2f' % np.trapz(pdf, x)
|
|
|
|
|
'1.00'
|
|
|
|
|
|
|
|
|
|
See also
|
|
|
|
|
--------
|
|
|
|
|
bincount, accum, kdebin
|
|
|
|
|
|
|
|
|
|
Reference
|
|
|
|
|
----------
|
|
|
|
|
Wand,M.P. and Jones, M.C. (1995)
|
|
|
|
|
'Kernel smoothing'
|
|
|
|
|
Chapman and Hall, pp 182-192
|
|
|
|
|
'''
|
|
|
|
|
dat = np.atleast_2d(data)
|
|
|
|
|
x = np.atleast_2d(X)
|
|
|
|
|
y = np.atleast_1d(y).ravel()
|
|
|
|
|
d = dat.shape[0]
|
|
|
|
|
d1, inc = x.shape
|
|
|
|
|
|
|
|
|
|
if d != d1:
|
|
|
|
|
raise ValueError('Dimension 0 of data and X do not match.')
|
|
|
|
|
|
|
|
|
|
dx = np.diff(x[:, :2], axis=1)
|
|
|
|
|
xlo = x[:, 0]
|
|
|
|
|
xup = x[:, -1]
|
|
|
|
|
|
|
|
|
|
datlo = dat.min(axis=1)
|
|
|
|
|
datup = dat.max(axis=1)
|
|
|
|
|
if ((datlo < xlo) | (xup < datup)).any():
|
|
|
|
|
raise ValueError('X does not include whole range of the data!')
|
|
|
|
|
|
|
|
|
|
csiz = np.repeat(inc, d)
|
|
|
|
|
use_sparse = False
|
|
|
|
|
if use_sparse:
|
|
|
|
|
acfun = accumsum # faster than accum
|
|
|
|
|
else:
|
|
|
|
|
acfun = accumsum2 # accum
|
|
|
|
|
|
|
|
|
|
binx = np.asarray(np.floor((dat - xlo[:, newaxis]) / dx), dtype=int)
|
|
|
|
|
w = dx.prod()
|
|
|
|
|
abs = np.abs # @ReservedAssignment
|
|
|
|
|
if d == 1:
|
|
|
|
|
x.shape = (-1,)
|
|
|
|
|
c = np.asarray((acfun(binx, (x[binx + 1] - dat) * y, size=(inc, )) +
|
|
|
|
|
acfun(binx + 1, (dat - x[binx]) * y, size=(inc, ))) /
|
|
|
|
|
w).ravel()
|
|
|
|
|
else: # d>2
|
|
|
|
|
|
|
|
|
|
Nc = csiz.prod()
|
|
|
|
|
c = np.zeros((Nc,))
|
|
|
|
|
|
|
|
|
|
fact2 = np.asarray(np.reshape(inc * np.arange(d), (d, -1)), dtype=int)
|
|
|
|
|
fact1 = np.asarray(
|
|
|
|
|
np.reshape(csiz.cumprod() / inc, (d, -1)), dtype=int)
|
|
|
|
|
# fact1 = fact1(ones(n,1),:);
|
|
|
|
|
bt0 = [0, 0]
|
|
|
|
|
X1 = X.ravel()
|
|
|
|
|
for ir in range(2 ** (d - 1)):
|
|
|
|
|
bt0[0] = np.reshape(bitget(ir, np.arange(d)), (d, -1))
|
|
|
|
|
bt0[1] = 1 - bt0[0]
|
|
|
|
|
for ix in range(2):
|
|
|
|
|
one = np.mod(ix, 2)
|
|
|
|
|
two = np.mod(ix + 1, 2)
|
|
|
|
|
# Convert to linear index
|
|
|
|
|
# linear index to c
|
|
|
|
|
b1 = np.sum((binx + bt0[one]) * fact1, axis=0)
|
|
|
|
|
bt2 = bt0[two] + fact2
|
|
|
|
|
b2 = binx + bt2 # linear index to X
|
|
|
|
|
c += acfun(
|
|
|
|
|
b1, abs(np.prod(X1[b2] - dat, axis=0)) * y, size=(Nc,))
|
|
|
|
|
|
|
|
|
|
c = np.reshape(c / w, csiz, order='F')
|
|
|
|
|
|
|
|
|
|
T = range(d)
|
|
|
|
|
T[1], T[0] = T[0], T[1]
|
|
|
|
|
# make sure c is stored in the same way as meshgrid
|
|
|
|
|
c = c.transpose(*T)
|
|
|
|
|
return c
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def kde_demo1():
|
|
|
|
|
"""KDEDEMO1 Demonstrate the smoothing parameter impact on KDE.
|
|
|
|
|
|
|
|
|
|
KDEDEMO1 shows the true density (dotted) compared to KDE based on 7
|
|
|
|
|
observations (solid) and their individual kernels (dashed) for 3
|
|
|
|
|
different values of the smoothing parameter, hs.
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
import scipy.stats as st
|
|
|
|
|
x = np.linspace(-4, 4, 101)
|
|
|
|
|
x0 = x / 2.0
|
|
|
|
|
data = np.random.normal(loc=0, scale=1.0, size=7)
|
|
|
|
|
kernel = Kernel('gauss')
|
|
|
|
|
hs = kernel.hns(data)
|
|
|
|
|
hVec = [hs / 2, hs, 2 * hs]
|
|
|
|
|
|
|
|
|
|
for ix, h in enumerate(hVec):
|
|
|
|
|
plt.figure(ix)
|
|
|
|
|
kde = KDE(data, hs=h, kernel=kernel)
|
|
|
|
|
f2 = kde(x, output='plot', title='h_s = %2.2f' % h, ylab='Density')
|
|
|
|
|
f2.plot('k-')
|
|
|
|
|
|
|
|
|
|
plt.plot(x, st.norm.pdf(x, 0, 1), 'k:')
|
|
|
|
|
n = len(data)
|
|
|
|
|
plt.plot(data, np.zeros(data.shape), 'bx')
|
|
|
|
|
y = kernel(x0) / (n * h * kernel.norm_factor(d=1, n=n))
|
|
|
|
|
for i in range(n):
|
|
|
|
|
plt.plot(data[i] + x0 * h, y, 'b--')
|
|
|
|
|
plt.plot([data[i], data[i]], [0, np.max(y)], 'b')
|
|
|
|
|
|
|
|
|
|
plt.axis([x.min(), x.max(), 0, 0.5])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def kde_demo2():
|
|
|
|
|
'''Demonstrate the difference between transformation- and ordinary-KDE.
|
|
|
|
|
|
|
|
|
|
KDEDEMO2 shows that the transformation KDE is a better estimate for
|
|
|
|
|
Rayleigh distributed data around 0 than the ordinary KDE.
|
|
|
|
|
'''
|
|
|
|
|
import scipy.stats as st
|
|
|
|
|
data = st.rayleigh.rvs(scale=1, size=300)
|
|
|
|
|
|
|
|
|
|
x = np.linspace(1.5e-2, 5, 55)
|
|
|
|
|
|
|
|
|
|
kde = KDE(data)
|
|
|
|
|
f = kde(output='plot', title='Ordinary KDE (hs=%g)' % kde.hs)
|
|
|
|
|
plt.figure(0)
|
|
|
|
|
f.plot()
|
|
|
|
|
|
|
|
|
|
plt.plot(x, st.rayleigh.pdf(x, scale=1), ':')
|
|
|
|
|
|
|
|
|
|
# plotnorm((data).^(L2)) % gives a straight line => L2 = 0.5 reasonable
|
|
|
|
|
|
|
|
|
|
tkde = TKDE(data, L2=0.5)
|
|
|
|
|
ft = tkde(x, output='plot', title='Transformation KDE (hs=%g)' %
|
|
|
|
|
tkde.tkde.hs)
|
|
|
|
|
plt.figure(1)
|
|
|
|
|
ft.plot()
|
|
|
|
|
|
|
|
|
|
plt.plot(x, st.rayleigh.pdf(x, scale=1), ':')
|
|
|
|
|
|
|
|
|
|
plt.figure(0)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def kde_demo3():
|
|
|
|
|
'''Demonstrate the difference between transformation and ordinary-KDE in 2D
|
|
|
|
|
|
|
|
|
|
KDEDEMO3 shows that the transformation KDE is a better estimate for
|
|
|
|
|
Rayleigh distributed data around 0 than the ordinary KDE.
|
|
|
|
|
'''
|
|
|
|
|
import scipy.stats as st
|
|
|
|
|
data = st.rayleigh.rvs(scale=1, size=(2, 300))
|
|
|
|
|
|
|
|
|
|
# x = np.linspace(1.5e-3, 5, 55)
|
|
|
|
|
|
|
|
|
|
kde = KDE(data)
|
|
|
|
|
f = kde(output='plot', title='Ordinary KDE', plotflag=1)
|
|
|
|
|
plt.figure(0)
|
|
|
|
|
f.plot()
|
|
|
|
|
|
|
|
|
|
plt.plot(data[0], data[1], '.')
|
|
|
|
|
|
|
|
|
|
# plotnorm((data).^(L2)) % gives a straight line => L2 = 0.5 reasonable
|
|
|
|
|
|
|
|
|
|
tkde = TKDE(data, L2=0.5)
|
|
|
|
|
ft = tkde.eval_grid_fast(
|
|
|
|
|
output='plot', title='Transformation KDE', plotflag=1)
|
|
|
|
|
|
|
|
|
|
plt.figure(1)
|
|
|
|
|
ft.plot()
|
|
|
|
|
|
|
|
|
|
plt.plot(data[0], data[1], '.')
|
|
|
|
|
|
|
|
|
|
plt.figure(0)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def kde_demo4(N=50):
|
|
|
|
|
'''Demonstrate that the improved Sheather-Jones plug-in (hisj) is superior
|
|
|
|
|
for 1D multimodal distributions
|
|
|
|
|
|
|
|
|
|
KDEDEMO4 shows that the improved Sheather-Jones plug-in smoothing is a
|
|
|
|
|
better compared to normal reference rules (in this case the hns)
|
|
|
|
|
'''
|
|
|
|
|
import scipy.stats as st
|
|
|
|
|
|
|
|
|
|
data = np.hstack((st.norm.rvs(loc=5, scale=1, size=(N,)),
|
|
|
|
|
st.norm.rvs(loc=-5, scale=1, size=(N,))))
|
|
|
|
|
|
|
|
|
|
# x = np.linspace(1.5e-3, 5, 55)
|
|
|
|
|
|
|
|
|
|
kde = KDE(data, kernel=Kernel('gauss', 'hns'))
|
|
|
|
|
f = kde(output='plot', title='Ordinary KDE', plotflag=1)
|
|
|
|
|
|
|
|
|
|
kde1 = KDE(data, kernel=Kernel('gauss', 'hisj'))
|
|
|
|
|
f1 = kde1(output='plot', label='Ordinary KDE', plotflag=1)
|
|
|
|
|
|
|
|
|
|
plt.figure(0)
|
|
|
|
|
f.plot('r', label='hns=%g' % kde.hs)
|
|
|
|
|
# plt.figure(2)
|
|
|
|
|
f1.plot('b', label='hisj=%g' % kde1.hs)
|
|
|
|
|
x = np.linspace(-4, 4)
|
|
|
|
|
for loc in [-5, 5]:
|
|
|
|
|
plt.plot(x + loc, st.norm.pdf(x, 0, scale=1) / 2, 'k:',
|
|
|
|
|
label='True density')
|
|
|
|
|
plt.legend()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def kde_demo5(N=500):
|
|
|
|
|
'''Demonstrate that the improved Sheather-Jones plug-in (hisj) is superior
|
|
|
|
|
for 2D multimodal distributions
|
|
|
|
|
|
|
|
|
|
KDEDEMO5 shows that the improved Sheather-Jones plug-in smoothing is better
|
|
|
|
|
compared to normal reference rules (in this case the hns)
|
|
|
|
|
'''
|
|
|
|
|
import scipy.stats as st
|
|
|
|
|
|
|
|
|
|
data = np.hstack((st.norm.rvs(loc=5, scale=1, size=(2, N,)),
|
|
|
|
|
st.norm.rvs(loc=-5, scale=1, size=(2, N,))))
|
|
|
|
|
kde = KDE(data, kernel=Kernel('gauss', 'hns'))
|
|
|
|
|
f = kde(output='plot', title='Ordinary KDE (hns=%g %g)' %
|
|
|
|
|
tuple(kde.hs.tolist()), plotflag=1)
|
|
|
|
|
|
|
|
|
|
kde1 = KDE(data, kernel=Kernel('gauss', 'hisj'))
|
|
|
|
|
f1 = kde1(output='plot', title='Ordinary KDE (hisj=%g %g)' %
|
|
|
|
|
tuple(kde1.hs.tolist()), plotflag=1)
|
|
|
|
|
|
|
|
|
|
plt.figure(0)
|
|
|
|
|
plt.clf()
|
|
|
|
|
f.plot()
|
|
|
|
|
plt.plot(data[0], data[1], '.')
|
|
|
|
|
plt.figure(1)
|
|
|
|
|
plt.clf()
|
|
|
|
|
f1.plot()
|
|
|
|
|
plt.plot(data[0], data[1], '.')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def kreg_demo1(hs=None, fast=False, fun='hisj'):
|
|
|
|
|
""""""
|
|
|
|
|
N = 100
|
|
|
|
|
# ei = np.random.normal(loc=0, scale=0.075, size=(N,))
|
|
|
|
|
ei = np.array([
|
|
|
|
|
-0.08508516, 0.10462496, 0.07694448, -0.03080661, 0.05777525,
|
|
|
|
|
0.06096313, -0.16572389, 0.01838912, -0.06251845, -0.09186784,
|
|
|
|
|
-0.04304887, -0.13365788, -0.0185279, -0.07289167, 0.02319097,
|
|
|
|
|
0.06887854, -0.08938374, -0.15181813, 0.03307712, 0.08523183,
|
|
|
|
|
-0.0378058, -0.06312874, 0.01485772, 0.06307944, -0.0632959,
|
|
|
|
|
0.18963205, 0.0369126, -0.01485447, 0.04037722, 0.0085057,
|
|
|
|
|
-0.06912903, 0.02073998, 0.1174351, 0.17599277, -0.06842139,
|
|
|
|
|
0.12587608, 0.07698113, -0.0032394, -0.12045792, -0.03132877,
|
|
|
|
|
0.05047314, 0.02013453, 0.04080741, 0.00158392, 0.10237899,
|
|
|
|
|
-0.09069682, 0.09242174, -0.15445323, 0.09190278, 0.07138498,
|
|
|
|
|
0.03002497, 0.02495252, 0.01286942, 0.06449978, 0.03031802,
|
|
|
|
|
0.11754861, -0.02322272, 0.00455867, -0.02132251, 0.09119446,
|
|
|
|
|
-0.03210086, -0.06509545, 0.07306443, 0.04330647, 0.078111,
|
|
|
|
|
-0.04146907, 0.05705476, 0.02492201, -0.03200572, -0.02859788,
|
|
|
|
|
-0.05893749, 0.00089538, 0.0432551, 0.04001474, 0.04888828,
|
|
|
|
|
-0.17708392, 0.16478644, 0.1171006, 0.11664846, 0.01410477,
|
|
|
|
|
-0.12458953, -0.11692081, 0.0413047, -0.09292439, -0.07042327,
|
|
|
|
|
0.14119701, -0.05114335, 0.04994696, -0.09520663, 0.04829406,
|
|
|
|
|
-0.01603065, -0.1933216, 0.19352763, 0.11819496, 0.04567619,
|
|
|
|
|
-0.08348306, 0.00812816, -0.00908206, 0.14528945, 0.02901065])
|
|
|
|
|
x = np.linspace(0, 1, N)
|
|
|
|
|
|
|
|
|
|
y0 = 2 * np.exp(-x ** 2 / (2 * 0.3 ** 2)) + \
|
|
|
|
|
3 * np.exp(-(x - 1) ** 2 / (2 * 0.7 ** 2))
|
|
|
|
|
y = y0 + ei
|
|
|
|
|
kernel = Kernel('gauss', fun=fun)
|
|
|
|
|
hopt = kernel.hisj(x)
|
|
|
|
|
kreg = KRegression(
|
|
|
|
|
x, y, p=0, hs=hs, kernel=kernel, xmin=-2 * hopt, xmax=1 + 2 * hopt)
|
|
|
|
|
if fast:
|
|
|
|
|
kreg.__call__ = kreg.eval_grid_fast
|
|
|
|
|
|
|
|
|
|
f = kreg(output='plot', title='Kernel regression', plotflag=1)
|
|
|
|
|
plt.figure(0)
|
|
|
|
|
f.plot(label='p=0')
|
|
|
|
|
|
|
|
|
|
kreg.p = 1
|
|
|
|
|
f1 = kreg(output='plot', title='Kernel regression', plotflag=1)
|
|
|
|
|
f1.plot(label='p=1')
|
|
|
|
|
# print(f1.data)
|
|
|
|
|
plt.plot(x, y, '.', label='data')
|
|
|
|
|
plt.plot(x, y0, 'k', label='True model')
|
|
|
|
|
plt.legend()
|
|
|
|
|
|
|
|
|
|
plt.show()
|
|
|
|
|
|
|
|
|
|
print(kreg.tkde.tkde.inv_hs)
|
|
|
|
|
print(kreg.tkde.tkde.hs)
|
|
|
|
|
|
|
|
|
|
_TINY = np.finfo(float).machar.tiny
|
|
|
|
|
_REALMIN = np.finfo(float).machar.xmin
|
|
|
|
|
_REALMAX = np.finfo(float).machar.xmax
|
|
|
|
|
_EPS = np.finfo(float).eps
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _logit(p):
|
|
|
|
|
pc = p.clip(min=0, max=1)
|
|
|
|
|
return (np.log(pc) - np.log1p(-pc)).clip(min=-40, max=40)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _logitinv(x):
|
|
|
|
|
return 1.0 / (np.exp(-x) + 1)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _get_data(n=100, symmetric=False, loc1=1.1, scale1=0.6, scale2=1.0):
|
|
|
|
|
import scipy.stats as st
|
|
|
|
|
# from sg_filter import SavitzkyGolay
|
|
|
|
|
dist = st.norm
|
|
|
|
|
|
|
|
|
|
norm1 = scale2 * (dist.pdf(-loc1, loc=-loc1, scale=scale1) +
|
|
|
|
|
dist.pdf(-loc1, loc=loc1, scale=scale1))
|
|
|
|
|
|
|
|
|
|
def fun1(x):
|
|
|
|
|
return ((dist.pdf(x, loc=-loc1, scale=scale1) +
|
|
|
|
|
dist.pdf(x, loc=loc1, scale=scale1)) / norm1).clip(max=1.0)
|
|
|
|
|
|
|
|
|
|
x = np.sort(6 * np.random.rand(n, 1) - 3, axis=0)
|
|
|
|
|
|
|
|
|
|
y = (fun1(x) > np.random.rand(n, 1)).ravel()
|
|
|
|
|
# y = (np.cos(x)>2*np.random.rand(n, 1)-1).ravel()
|
|
|
|
|
x = x.ravel()
|
|
|
|
|
|
|
|
|
|
if symmetric:
|
|
|
|
|
xi = np.hstack((x.ravel(), -x.ravel()))
|
|
|
|
|
yi = np.hstack((y, y))
|
|
|
|
|
i = np.argsort(xi)
|
|
|
|
|
x = xi[i]
|
|
|
|
|
y = yi[i]
|
|
|
|
|
return x, y, fun1
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def kreg_demo2(n=100, hs=None, symmetric=False, fun='hisj', plotlog=False):
|
|
|
|
|
x, y, fun1 = _get_data(n, symmetric)
|
|
|
|
|
kreg_demo3(x, y, fun1, hs=None, fun='hisj', plotlog=False)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def kreg_demo3(x, y, fun1, hs=None, fun='hisj', plotlog=False):
|
|
|
|
|
st = stats
|
|
|
|
|
|
|
|
|
|
alpha = 0.1
|
|
|
|
|
z0 = -_invnorm(alpha / 2)
|
|
|
|
|
|
|
|
|
|
n = x.size
|
|
|
|
|
hopt, hs1, hs2 = _get_regression_smooting(x, y, fun='hos')
|
|
|
|
|
if hs is None:
|
|
|
|
|
hs = hopt
|
|
|
|
|
|
|
|
|
|
forward = _logit
|
|
|
|
|
reverse = _logitinv
|
|
|
|
|
# forward = np.log
|
|
|
|
|
# reverse = np.exp
|
|
|
|
|
|
|
|
|
|
xmin, xmax = x.min(), x.max()
|
|
|
|
|
ni = max(2 * int((xmax - xmin) / hopt) + 3, 5)
|
|
|
|
|
print(ni)
|
|
|
|
|
print(xmin, xmax)
|
|
|
|
|
sml = hopt * 0.1
|
|
|
|
|
xi = np.linspace(xmin - sml, xmax + sml, ni)
|
|
|
|
|
xiii = np.linspace(xmin - sml, xmax + sml, 4 * ni + 1)
|
|
|
|
|
|
|
|
|
|
c = gridcount(x, xi)
|
|
|
|
|
if (y == 1).any():
|
|
|
|
|
c0 = gridcount(x[y == 1], xi)
|
|
|
|
|
else:
|
|
|
|
|
c0 = np.zeros(xi.shape)
|
|
|
|
|
yi = np.where(c == 0, 0, c0 / c)
|
|
|
|
|
|
|
|
|
|
kreg = KRegression(x, y, hs=hs, p=0)
|
|
|
|
|
fiii = kreg(xiii)
|
|
|
|
|
yiii = interpolate.interp1d(xi, yi)(xiii)
|
|
|
|
|
fit = fun1(xiii).clip(max=1.0)
|
|
|
|
|
df = np.diff(fiii)
|
|
|
|
|
eerr = np.abs((yiii - fiii)).std() + 0.5 * (df[:-1] * df[1:] < 0).sum() / n
|
|
|
|
|
err = (fiii - fit).std()
|
|
|
|
|
f = kreg(
|
|
|
|
|
xiii, output='plotobj',
|
|
|
|
|
title='%s err=%1.3f,eerr=%1.3f, n=%d, hs=%1.3f, hs1=%1.3f, hs2=%1.3f' %
|
|
|
|
|
(fun, err, eerr, n, hs, hs1, hs2), plotflag=1)
|
|
|
|
|
|
|
|
|
|
# yi[yi==0] = 1.0/(c[c!=0].min()+4)
|
|
|
|
|
# yi[yi==1] = 1-1.0/(c[c!=0].min()+4)
|
|
|
|
|
# yi[yi==0] = fi[yi==0]
|
|
|
|
|
# yi[yi==0] = np.exp(stineman_interp(xi[yi==0], xi[yi>0],np.log(yi[yi>0])))
|
|
|
|
|
# yi[yi==0] = fun1(xi[yi==0])
|
|
|
|
|
try:
|
|
|
|
|
yi[yi == 0] = yi[yi > 0].min() / sqrt(n)
|
|
|
|
|
except:
|
|
|
|
|
yi[yi == 0] = 1. / n
|
|
|
|
|
yi[yi == 1] = 1 - (1 - yi[yi < 1].max()) / sqrt(n)
|
|
|
|
|
|
|
|
|
|
logity = forward(yi)
|
|
|
|
|
|
|
|
|
|
gkreg = KRegression(xi, logity, hs=hs, xmin=xmin - hopt, xmax=xmax + hopt)
|
|
|
|
|
fg = gkreg.eval_grid(
|
|
|
|
|
xi, output='plotobj', title='Kernel regression', plotflag=1)
|
|
|
|
|
sa = (fg.data - logity).std()
|
|
|
|
|
sa2 = iqrange(fg.data - logity) / 1.349
|
|
|
|
|
# print('sa=%g %g' % (sa, sa2))
|
|
|
|
|
sa = min(sa, sa2)
|
|
|
|
|
|
|
|
|
|
# plt.figure(1)
|
|
|
|
|
# plt.plot(xi, slogity-logity,'r.')
|
|
|
|
|
# plt.plot(xi, logity-,'b.')
|
|
|
|
|
# plt.plot(xi, fg.data-logity, 'b.')
|
|
|
|
|
# plt.show()
|
|
|
|
|
# return
|
|
|
|
|
|
|
|
|
|
fg = gkreg.eval_grid(
|
|
|
|
|
xiii, output='plotobj', title='Kernel regression', plotflag=1)
|
|
|
|
|
pi = reverse(fg.data)
|
|
|
|
|
|
|
|
|
|
dx = xi[1] - xi[0]
|
|
|
|
|
ckreg = KDE(x, hs=hs)
|
|
|
|
|
# ci = ckreg.eval_grid_fast(xi)*n*dx
|
|
|
|
|
ciii = ckreg.eval_grid_fast(xiii) * dx * x.size # n*(1+symmetric)
|
|
|
|
|
|
|
|
|
|
# sa1 = np.sqrt(1./(ciii*pi*(1-pi)))
|
|
|
|
|
# plo3 = reverse(fg.data-z0*sa)
|
|
|
|
|
# pup3 = reverse(fg.data+z0*sa)
|
|
|
|
|
fg.data = pi
|
|
|
|
|
pi = f.data
|
|
|
|
|
|
|
|
|
|
# ref Casella and Berger (1990) "Statistical inference" pp444
|
|
|
|
|
# a = 2*pi + z0**2/(ciii+1e-16)
|
|
|
|
|
# b = 2*(1+z0**2/(ciii+1e-16))
|
|
|
|
|
# plo2 = ((a-sqrt(a**2-2*pi**2*b))/b).clip(min=0,max=1)
|
|
|
|
|
# pup2 = ((a+sqrt(a**2-2*pi**2*b))/b).clip(min=0,max=1)
|
|
|
|
|
# Jeffreys intervall a=b=0.5
|
|
|
|
|
# st.beta.isf(alpha/2, x+a, n-x+b)
|
|
|
|
|
ab = 0.07 # 0.055
|
|
|
|
|
pi1 = pi # fun1(xiii)
|
|
|
|
|
pup2 = np.where(pi == 1,
|
|
|
|
|
1,
|
|
|
|
|
st.beta.isf(alpha / 2,
|
|
|
|
|
ciii * pi1 + ab,
|
|
|
|
|
ciii * (1 - pi1) + ab))
|
|
|
|
|
plo2 = np.where(pi == 0,
|
|
|
|
|
0,
|
|
|
|
|
st.beta.isf(1 - alpha / 2,
|
|
|
|
|
ciii * pi1 + ab,
|
|
|
|
|
ciii * (1 - pi1) + ab))
|
|
|
|
|
|
|
|
|
|
averr = np.trapz(pup2 - plo2, xiii) / \
|
|
|
|
|
(xiii[-1] - xiii[0]) + 0.5 * (df[:-1] * df[1:] < 0).sum()
|
|
|
|
|
|
|
|
|
|
# f2 = kreg_demo4(x, y, hs, hopt)
|
|
|
|
|
# Wilson score
|
|
|
|
|
den = 1 + (z0 ** 2. / ciii)
|
|
|
|
|
xc = (pi1 + (z0 ** 2) / (2 * ciii)) / den
|
|
|
|
|
halfwidth = (z0 * sqrt((pi1 * (1 - pi1) / ciii) +
|
|
|
|
|
(z0 ** 2 / (4 * (ciii ** 2))))) / den
|
|
|
|
|
plo = (xc - halfwidth).clip(min=0) # wilson score
|
|
|
|
|
pup = (xc + halfwidth).clip(max=1.0) # wilson score
|
|
|
|
|
# pup = (pi + z0*np.sqrt(pi*(1-pi)/ciii)).clip(min=0,max=1) # dont use
|
|
|
|
|
# plo = (pi - z0*np.sqrt(pi*(1-pi)/ciii)).clip(min=0,max=1)
|
|
|
|
|
|
|
|
|
|
# mi = kreg.eval_grid(x)
|
|
|
|
|
# sigma = (stineman_interp(x, xiii, pup)-stineman_interp(x, xiii, plo))/4
|
|
|
|
|
# aic = np.abs((y-mi)/sigma).std()+ 0.5*(df[:-1]*df[1:]<0).sum()/n
|
|
|
|
|
# aic = np.abs((yiii-fiii)/(pup-plo)).std() + \
|
|
|
|
|
# 0.5*(df[:-1]*df[1:]<0).sum() + \
|
|
|
|
|
# ((yiii-pup).clip(min=0)-(yiii-plo).clip(max=0)).sum()
|
|
|
|
|
|
|
|
|
|
k = (df[:-1] * df[1:] < 0).sum() # numpeaks
|
|
|
|
|
sigmai = (pup - plo)
|
|
|
|
|
aic = (((yiii - fiii) / sigmai) ** 2).sum() + \
|
|
|
|
|
2 * k * (k + 1) / np.maximum(ni - k + 1, 1) + \
|
|
|
|
|
np.abs((yiii - pup).clip(min=0) - (yiii - plo).clip(max=0)).sum()
|
|
|
|
|
|
|
|
|
|
# aic = (((yiii-fiii)/sigmai)**2).sum()+ 2*k*(k+1)/(ni-k+1) + \
|
|
|
|
|
# np.abs((yiii-pup).clip(min=0)-(yiii-plo).clip(max=0)).sum()
|
|
|
|
|
|
|
|
|
|
# aic = averr + ((yiii-pup).clip(min=0)-(yiii-plo).clip(max=0)).sum()
|
|
|
|
|
|
|
|
|
|
fg.plot(label='KReg grid aic=%2.3f' % (aic))
|
|
|
|
|
f.plot(label='KReg averr=%2.3f ' % (averr))
|
|
|
|
|
labtxt = '%d CI' % (int(100 * (1 - alpha)))
|
|
|
|
|
plt.fill_between(xiii, pup, plo, alpha=0.20,
|
|
|
|
|
color='r', linestyle='--', label=labtxt)
|
|
|
|
|
plt.fill_between(xiii, pup2, plo2, alpha=0.20, color='b',
|
|
|
|
|
linestyle=':', label='%d CI2' % (int(100 * (1 - alpha))))
|
|
|
|
|
plt.plot(xiii, fun1(xiii), 'r', label='True model')
|
|
|
|
|
plt.scatter(xi, yi, label='data')
|
|
|
|
|
print('maxp = %g' % (np.nanmax(f.data)))
|
|
|
|
|
print('hs = %g' % (kreg.tkde.tkde.hs))
|
|
|
|
|
plt.legend()
|
|
|
|
|
h = plt.gca()
|
|
|
|
|
if plotlog:
|
|
|
|
|
plt.setp(h, yscale='log')
|
|
|
|
|
# plt.show()
|
|
|
|
|
return hs1, hs2
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def kreg_demo4(x, y, hs, hopt, alpha=0.05):
|
|
|
|
|
st = stats
|
|
|
|
|
|
|
|
|
|
n = x.size
|
|
|
|
|
xmin, xmax = x.min(), x.max()
|
|
|
|
|
ni = max(2 * int((xmax - xmin) / hopt) + 3, 5)
|
|
|
|
|
|
|
|
|
|
sml = hopt * 0.1
|
|
|
|
|
xi = np.linspace(xmin - sml, xmax + sml, ni)
|
|
|
|
|
xiii = np.linspace(xmin - sml, xmax + sml, 4 * ni + 1)
|
|
|
|
|
|
|
|
|
|
kreg = KRegression(x, y, hs=hs, p=0)
|
|
|
|
|
|
|
|
|
|
dx = xi[1] - xi[0]
|
|
|
|
|
ciii = kreg.tkde.eval_grid_fast(xiii) * dx * x.size
|
|
|
|
|
# ckreg = KDE(x,hs=hs)
|
|
|
|
|
# ciiii = ckreg.eval_grid_fast(xiii)*dx* x.size #n*(1+symmetric)
|
|
|
|
|
|
|
|
|
|
f = kreg(xiii, output='plotobj') # , plot_kwds=dict(plotflag=7))
|
|
|
|
|
pi = f.data
|
|
|
|
|
|
|
|
|
|
# Jeffreys intervall a=b=0.5
|
|
|
|
|
# st.beta.isf(alpha/2, x+a, n-x+b)
|
|
|
|
|
ab = 0.07 # 0.5
|
|
|
|
|
pi1 = pi
|
|
|
|
|
pup = np.where(pi1 == 1, 1, st.beta.isf(
|
|
|
|
|
alpha / 2, ciii * pi1 + ab, ciii * (1 - pi1) + ab))
|
|
|
|
|
plo = np.where(pi1 == 0, 0, st.beta.isf(
|
|
|
|
|
1 - alpha / 2, ciii * pi1 + ab, ciii * (1 - pi1) + ab))
|
|
|
|
|
|
|
|
|
|
# Wilson score
|
|
|
|
|
# z0 = -_invnorm(alpha/2)
|
|
|
|
|
# den = 1+(z0**2./ciii);
|
|
|
|
|
# xc=(pi1+(z0**2)/(2*ciii))/den;
|
|
|
|
|
# halfwidth=(z0*sqrt((pi1*(1-pi1)/ciii)+(z0**2/(4*(ciii**2)))))/den
|
|
|
|
|
# plo2 = (xc-halfwidth).clip(min=0) # wilson score
|
|
|
|
|
# pup2 = (xc+halfwidth).clip(max=1.0) # wilson score
|
|
|
|
|
# f.dataCI = np.vstack((plo,pup)).T
|
|
|
|
|
f.prediction_error_avg = np.trapz(pup - plo, xiii) / (xiii[-1] - xiii[0])
|
|
|
|
|
fiii = f.data
|
|
|
|
|
|
|
|
|
|
c = gridcount(x, xi)
|
|
|
|
|
if (y == 1).any():
|
|
|
|
|
c0 = gridcount(x[y == 1], xi)
|
|
|
|
|
else:
|
|
|
|
|
c0 = np.zeros(xi.shape)
|
|
|
|
|
yi = np.where(c == 0, 0, c0 / c)
|
|
|
|
|
|
|
|
|
|
f.children = [PlotData([plo, pup], xiii, plotmethod='fill_between',
|
|
|
|
|
plot_kwds=dict(alpha=0.2, color='r')),
|
|
|
|
|
PlotData(yi, xi, plotmethod='scatter',
|
|
|
|
|
plot_kwds=dict(color='r', s=5))]
|
|
|
|
|
|
|
|
|
|
yiii = interpolate.interp1d(xi, yi)(xiii)
|
|
|
|
|
df = np.diff(fiii)
|
|
|
|
|
k = (df[:-1] * df[1:] < 0).sum() # numpeaks
|
|
|
|
|
sigmai = (pup - plo)
|
|
|
|
|
aicc = (((yiii - fiii) / sigmai) ** 2).sum() + \
|
|
|
|
|
2 * k * (k + 1) / np.maximum(ni - k + 1, 1) + \
|
|
|
|
|
np.abs((yiii - pup).clip(min=0) - (yiii - plo).clip(max=0)).sum()
|
|
|
|
|
|
|
|
|
|
f.aicc = aicc
|
|
|
|
|
f.labels.title = 'perr=%1.3f,aicc=%1.3f, n=%d, hs=%1.3f' % (
|
|
|
|
|
f.prediction_error_avg, aicc, n, hs)
|
|
|
|
|
|
|
|
|
|
return f
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def check_kreg_demo3():
|
|
|
|
|
|
|
|
|
|
plt.ion()
|
|
|
|
|
k = 0
|
|
|
|
|
for n in [50, 100, 300, 600, 4000]:
|
|
|
|
|
x, y, fun1 = _get_data(
|
|
|
|
|
n, symmetric=True, loc1=1.0, scale1=0.6, scale2=1.25)
|
|
|
|
|
k0 = k
|
|
|
|
|
|
|
|
|
|
for fun in ['hste', ]:
|
|
|
|
|
hsmax, _hs1, _hs2 = _get_regression_smooting(x, y, fun=fun)
|
|
|
|
|
for hi in np.linspace(hsmax * 0.25, hsmax, 9):
|
|
|
|
|
plt.figure(k)
|
|
|
|
|
k += 1
|
|
|
|
|
unused = kreg_demo3(x, y, fun1, hs=hi, fun=fun, plotlog=False)
|
|
|
|
|
|
|
|
|
|
# kreg_demo2(n=n,symmetric=True,fun='hste', plotlog=False)
|
|
|
|
|
fig.tile(range(k0, k))
|
|
|
|
|
plt.ioff()
|
|
|
|
|
plt.show()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def check_kreg_demo4():
|
|
|
|
|
plt.ion()
|
|
|
|
|
# test_docstrings()
|
|
|
|
|
# kde_demo2()
|
|
|
|
|
# kreg_demo1(fast=True)
|
|
|
|
|
# kde_gauss_demo()
|
|
|
|
|
# kreg_demo2(n=120,symmetric=True,fun='hste', plotlog=True)
|
|
|
|
|
k = 0
|
|
|
|
|
for _i, n in enumerate([100, 300, 600, 4000]):
|
|
|
|
|
x, y, fun1 = _get_data(
|
|
|
|
|
n, symmetric=True, loc1=0.1, scale1=0.6, scale2=0.75)
|
|
|
|
|
# k0 = k
|
|
|
|
|
hopt1, _h1, _h2 = _get_regression_smooting(x, y, fun='hos')
|
|
|
|
|
hopt2, _h1, _h2 = _get_regression_smooting(x, y, fun='hste')
|
|
|
|
|
hopt = sqrt(hopt1 * hopt2)
|
|
|
|
|
# hopt = _get_regression_smooting(x,y,fun='hos')[0]
|
|
|
|
|
for _j, fun in enumerate(['hste']): # , 'hisj', 'hns', 'hstt'
|
|
|
|
|
hsmax, _hs1, _hs2 = _get_regression_smooting(x, y, fun=fun)
|
|
|
|
|
|
|
|
|
|
fmax = kreg_demo4(x, y, hsmax + 0.1, hopt)
|
|
|
|
|
for hi in np.linspace(hsmax * 0.1, hsmax, 55):
|
|
|
|
|
f = kreg_demo4(x, y, hi, hopt)
|
|
|
|
|
if f.aicc <= fmax.aicc:
|
|
|
|
|
fmax = f
|
|
|
|
|
plt.figure(k)
|
|
|
|
|
k += 1
|
|
|
|
|
fmax.plot()
|
|
|
|
|
plt.plot(x, fun1(x), 'r')
|
|
|
|
|
|
|
|
|
|
# kreg_demo2(n=n,symmetric=True,fun='hste', plotlog=False)
|
|
|
|
|
fig.tile(range(0, k))
|
|
|
|
|
plt.ioff()
|
|
|
|
|
plt.show()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def check_regression_bin():
|
|
|
|
|
plt.ion()
|
|
|
|
|
# test_docstrings()
|
|
|
|
|
# kde_demo2()
|
|
|
|
|
# kreg_demo1(fast=True)
|
|
|
|
|
# kde_gauss_demo()
|
|
|
|
|
# kreg_demo2(n=120,symmetric=True,fun='hste', plotlog=True)
|
|
|
|
|
k = 0
|
|
|
|
|
for _i, n in enumerate([100, 300, 600, 4000]):
|
|
|
|
|
x, y, fun1 = _get_data(
|
|
|
|
|
n, symmetric=True, loc1=0.1, scale1=0.6, scale2=0.75)
|
|
|
|
|
fbest = regressionbin(x, y, alpha=0.05, color='g', label='Transit_D')
|
|
|
|
|
|
|
|
|
|
figk = plt.figure(k)
|
|
|
|
|
ax = figk.gca()
|
|
|
|
|
k += 1
|
|
|
|
|
fbest.labels.title = 'N = %d' % n
|
|
|
|
|
fbest.plot(axis=ax)
|
|
|
|
|
ax.plot(x, fun1(x), 'r')
|
|
|
|
|
ax.legend(frameon=False, markerscale=4)
|
|
|
|
|
# ax = plt.gca()
|
|
|
|
|
ax.set_yticklabels(ax.get_yticks() * 100.0)
|
|
|
|
|
ax.grid(True)
|
|
|
|
|
|
|
|
|
|
fig.tile(range(0, k))
|
|
|
|
|
plt.ioff()
|
|
|
|
|
plt.show()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def check_bkregression():
|
|
|
|
|
plt.ion()
|
|
|
|
|
k = 0
|
|
|
|
|
for _i, n in enumerate([50, 100, 300, 600]):
|
|
|
|
|
x, y, fun1 = _get_data(
|
|
|
|
|
n, symmetric=True, loc1=0.1, scale1=0.6, scale2=0.75)
|
|
|
|
|
bkreg = BKRegression(x, y)
|
|
|
|
|
fbest = bkreg.prb_search_best(
|
|
|
|
|
hsfun='hste', alpha=0.05, color='g', label='Transit_D')
|
|
|
|
|
|
|
|
|
|
figk = plt.figure(k)
|
|
|
|
|
ax = figk.gca()
|
|
|
|
|
k += 1
|
|
|
|
|
# fbest.score.plot(axis=ax)
|
|
|
|
|
# axsize = ax.axis()
|
|
|
|
|
# ax.vlines(fbest.hs,axsize[2]+1,axsize[3])
|
|
|
|
|
# ax.set(yscale='log')
|
|
|
|
|
fbest.labels.title = 'N = %d' % n
|
|
|
|
|
fbest.plot(axis=ax)
|
|
|
|
|
ax.plot(x, fun1(x), 'r')
|
|
|
|
|
ax.legend(frameon=False, markerscale=4)
|
|
|
|
|
# ax = plt.gca()
|
|
|
|
|
ax.set_yticklabels(ax.get_yticks() * 100.0)
|
|
|
|
|
ax.grid(True)
|
|
|
|
|
|
|
|
|
|
fig.tile(range(0, k))
|
|
|
|
|
plt.ioff()
|
|
|
|
|
plt.show()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _get_regression_smooting(x, y, fun='hste'):
|
|
|
|
|
hs1 = Kernel('gauss', fun=fun).get_smoothing(x)
|
|
|
|
|
# hx = np.median(np.abs(x-np.median(x)))/0.6745*(4.0/(3*n))**0.2
|
|
|
|
|
if (y == 1).any():
|
|
|
|
|
hs2 = Kernel('gauss', fun=fun).get_smoothing(x[y == 1])
|
|
|
|
|
# hy = np.median(np.abs(y-np.mean(y)))/0.6745*(4.0/(3*n))**0.2
|
|
|
|
|
else:
|
|
|
|
|
hs2 = 4 * hs1
|
|
|
|
|
# hy = 4*hx
|
|
|
|
|
|
|
|
|
|
# hy2 = Kernel('gauss', fun=fun).get_smoothing(y)
|
|
|
|
|
# kernel = Kernel('gauss',fun=fun)
|
|
|
|
|
# hopt = (hs1+2*hs2)/3
|
|
|
|
|
# hopt = (hs1+4*hs2)/5 #kernel.get_smoothing(x)
|
|
|
|
|
# hopt = hs2
|
|
|
|
|
hopt = sqrt(hs1 * hs2)
|
|
|
|
|
return hopt, hs1, hs2
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def empirical_bin_prb(x, y, hopt, color='r'):
|
|
|
|
|
"""Returns empirical binomial probabiltity.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
x : ndarray
|
|
|
|
|
position ve
|
|
|
|
|
y : ndarray
|
|
|
|
|
binomial response variable (zeros and ones)
|
|
|
|
|
|
|
|
|
|
Returns
|
|
|
|
|
-------
|
|
|
|
|
P(x) : PlotData object
|
|
|
|
|
empirical probability
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
xmin, xmax = x.min(), x.max()
|
|
|
|
|
ni = max(2 * int((xmax - xmin) / hopt) + 3, 5)
|
|
|
|
|
|
|
|
|
|
sml = hopt # *0.1
|
|
|
|
|
xi = np.linspace(xmin - sml, xmax + sml, ni)
|
|
|
|
|
|
|
|
|
|
c = gridcount(x, xi)
|
|
|
|
|
if (y == 1).any():
|
|
|
|
|
c0 = gridcount(x[y == 1], xi)
|
|
|
|
|
else:
|
|
|
|
|
c0 = np.zeros(xi.shape)
|
|
|
|
|
yi = np.where(c == 0, 0, c0 / c)
|
|
|
|
|
return PlotData(yi, xi, plotmethod='scatter',
|
|
|
|
|
plot_kwds=dict(color=color, s=5))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def smoothed_bin_prb(x, y, hs, hopt, alpha=0.05, color='r', label='',
|
|
|
|
|
bin_prb=None):
|
|
|
|
|
'''
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
x,y
|
|
|
|
|
hs : smoothing parameter
|
|
|
|
|
hopt : spacing in empirical_bin_prb
|
|
|
|
|
alpha : confidence level
|
|
|
|
|
color : color of plot object
|
|
|
|
|
bin_prb : PlotData object with empirical bin prb
|
|
|
|
|
'''
|
|
|
|
|
if bin_prb is None:
|
|
|
|
|
bin_prb = empirical_bin_prb(x, y, hopt, color)
|
|
|
|
|
|
|
|
|
|
xi = bin_prb.args
|
|
|
|
|
yi = bin_prb.data
|
|
|
|
|
ni = len(xi)
|
|
|
|
|
dxi = xi[1] - xi[0]
|
|
|
|
|
|
|
|
|
|
n = x.size
|
|
|
|
|
|
|
|
|
|
xiii = np.linspace(xi[0], xi[-1], 10 * ni + 1)
|
|
|
|
|
|
|
|
|
|
kreg = KRegression(x, y, hs=hs, p=0)
|
|
|
|
|
# expected number of data in each bin
|
|
|
|
|
ciii = kreg.tkde.eval_grid_fast(xiii) * dxi * n
|
|
|
|
|
|
|
|
|
|
f = kreg(xiii, output='plotobj') # , plot_kwds=dict(plotflag=7))
|
|
|
|
|
pi = f.data
|
|
|
|
|
|
|
|
|
|
st = stats
|
|
|
|
|
# Jeffreys intervall a=b=0.5
|
|
|
|
|
# st.beta.isf(alpha/2, x+a, n-x+b)
|
|
|
|
|
ab = 0.07 # 0.5
|
|
|
|
|
pi1 = pi
|
|
|
|
|
pup = np.where(pi1 == 1, 1, st.beta.isf(
|
|
|
|
|
alpha / 2, ciii * pi1 + ab, ciii * (1 - pi1) + ab))
|
|
|
|
|
plo = np.where(pi1 == 0, 0, st.beta.isf(
|
|
|
|
|
1 - alpha / 2, ciii * pi1 + ab, ciii * (1 - pi1) + ab))
|
|
|
|
|
|
|
|
|
|
# Wilson score
|
|
|
|
|
# z0 = -_invnorm(alpha/2)
|
|
|
|
|
# den = 1+(z0**2./ciii);
|
|
|
|
|
# xc=(pi1+(z0**2)/(2*ciii))/den;
|
|
|
|
|
# halfwidth=(z0*sqrt((pi1*(1-pi1)/ciii)+(z0**2/(4*(ciii**2)))))/den
|
|
|
|
|
# plo2 = (xc-halfwidth).clip(min=0) # wilson score
|
|
|
|
|
# pup2 = (xc+halfwidth).clip(max=1.0) # wilson score
|
|
|
|
|
# f.dataCI = np.vstack((plo,pup)).T
|
|
|
|
|
f.prediction_error_avg = np.trapz(pup - plo, xiii) / (xiii[-1] - xiii[0])
|
|
|
|
|
fiii = f.data
|
|
|
|
|
|
|
|
|
|
f.plot_kwds['color'] = color
|
|
|
|
|
f.plot_kwds['linewidth'] = 2
|
|
|
|
|
if label:
|
|
|
|
|
f.plot_kwds['label'] = label
|
|
|
|
|
f.children = [PlotData([plo, pup], xiii, plotmethod='fill_between',
|
|
|
|
|
plot_kwds=dict(alpha=0.2, color=color)),
|
|
|
|
|
bin_prb]
|
|
|
|
|
|
|
|
|
|
yiii = interpolate.interp1d(xi, yi)(xiii)
|
|
|
|
|
df = np.diff(fiii)
|
|
|
|
|
k = (df[:-1] * df[1:] < 0).sum() # numpeaks
|
|
|
|
|
sigmai = (pup - plo)
|
|
|
|
|
aicc = (((yiii - fiii) / sigmai) ** 2).sum() + \
|
|
|
|
|
2 * k * (k + 1) / np.maximum(ni - k + 1, 1) + \
|
|
|
|
|
np.abs((yiii - pup).clip(min=0) - (yiii - plo).clip(max=0)).sum()
|
|
|
|
|
|
|
|
|
|
f.aicc = aicc
|
|
|
|
|
f.fun = kreg
|
|
|
|
|
f.labels.title = 'perr=%1.3f,aicc=%1.3f, n=%d, hs=%1.3f' % (
|
|
|
|
|
f.prediction_error_avg, aicc, n, hs)
|
|
|
|
|
|
|
|
|
|
return f
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def regressionbin(x, y, alpha=0.05, color='r', label=''):
|
|
|
|
|
"""Return kernel regression estimate for binomial data.
|
|
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
|
----------
|
|
|
|
|
x : arraylike
|
|
|
|
|
positions
|
|
|
|
|
y : arraylike
|
|
|
|
|
of 0 and 1
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
hopt1, _h1, _h2 = _get_regression_smooting(x, y, fun='hos')
|
|
|
|
|
hopt2, _h1, _h2 = _get_regression_smooting(x, y, fun='hste')
|
|
|
|
|
hopt = sqrt(hopt1 * hopt2)
|
|
|
|
|
|
|
|
|
|
fbest = smoothed_bin_prb(x, y, hopt2 + 0.1, hopt, alpha, color, label)
|
|
|
|
|
bin_prb = fbest.children[-1]
|
|
|
|
|
for fun in ['hste']: # , 'hisj', 'hns', 'hstt'
|
|
|
|
|
hsmax, _hs1, _hs2 = _get_regression_smooting(x, y, fun=fun)
|
|
|
|
|
for hi in np.linspace(hsmax * 0.1, hsmax, 55):
|
|
|
|
|
f = smoothed_bin_prb(x, y, hi, hopt, alpha, color, label, bin_prb)
|
|
|
|
|
if f.aicc <= fbest.aicc:
|
|
|
|
|
fbest = f
|
|
|
|
|
# hbest = hi
|
|
|
|
|
return fbest
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def kde_gauss_demo(n=50):
|
|
|
|
|
"""KDEDEMO Demonstrate the KDEgauss.
|
|
|
|
|
|
|
|
|
|
KDEDEMO1 shows the true density (dotted) compared to KDE based on 7
|
|
|
|
|
observations (solid) and their individual kernels (dashed) for 3
|
|
|
|
|
different values of the smoothing parameter, hs.
|
|
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
st = stats
|
|
|
|
|
# x = np.linspace(-4, 4, 101)
|
|
|
|
|
# data = np.random.normal(loc=0, scale=1.0, size=n)
|
|
|
|
|
# data = np.random.exponential(scale=1.0, size=n)
|
|
|
|
|
# n1 = 128
|
|
|
|
|
# I = (np.arange(n1)*pi)**2 *0.01*0.5
|
|
|
|
|
# kw = exp(-I)
|
|
|
|
|
# plt.plot(idctn(kw))
|
|
|
|
|
# return
|
|
|
|
|
# dist = st.norm
|
|
|
|
|
dist = st.expon
|
|
|
|
|
data = dist.rvs(loc=0, scale=1.0, size=n)
|
|
|
|
|
d, _N = np.atleast_2d(data).shape
|
|
|
|
|
|
|
|
|
|
if d == 1:
|
|
|
|
|
plot_options = [dict(color='red'), dict(
|
|
|
|
|
color='green'), dict(color='black')]
|
|
|
|
|
else:
|
|
|
|
|
plot_options = [dict(colors='red'), dict(colors='green'),
|
|
|
|
|
dict(colors='black')]
|
|
|
|
|
|
|
|
|
|
plt.figure(1)
|
|
|
|
|
kde0 = KDE(data, kernel=Kernel('gauss', 'hste'))
|
|
|
|
|
f0 = kde0.eval_grid_fast(output='plot', ylab='Density')
|
|
|
|
|
f0.plot(**plot_options[0])
|
|
|
|
|
|
|
|
|
|
kde1 = TKDE(data, kernel=Kernel('gauss', 'hisj'), L2=.5)
|
|
|
|
|
f1 = kde1.eval_grid_fast(output='plot', ylab='Density')
|
|
|
|
|
f1.plot(**plot_options[1])
|
|
|
|
|
|
|
|
|
|
kde2 = KDEgauss(data)
|
|
|
|
|
f2 = kde2(output='plot', ylab='Density')
|
|
|
|
|
x = f2.args
|
|
|
|
|
f2.plot(**plot_options[2])
|
|
|
|
|
|
|
|
|
|
fmax = dist.pdf(x, 0, 1).max()
|
|
|
|
|
if d == 1:
|
|
|
|
|
plt.plot(x, dist.pdf(x, 0, 1), 'k:')
|
|
|
|
|
plt.axis([x.min(), x.max(), 0, fmax])
|
|
|
|
|
plt.show()
|
|
|
|
|
print(fmax / f2.data.max())
|
|
|
|
|
format_ = ''.join(('%g, ') * d)
|
|
|
|
|
format_ = 'hs0=%s hs1=%s hs2=%s' % (format_, format_, format_)
|
|
|
|
|
print(format_ % tuple(kde0.hs.tolist() +
|
|
|
|
|
kde1.tkde.hs.tolist() + kde2.hs.tolist()))
|
|
|
|
|
print('inc0 = %d, inc1 = %d, inc2 = %d' % (kde0.inc, kde1.inc, kde2.inc))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_kde():
|
|
|
|
|
data = np.array([
|
|
|
|
|
0.75355792, 0.72779194, 0.94149169, 0.07841119, 2.32291887,
|
|
|
|
|
1.10419995, 0.77055114, 0.60288273, 1.36883635, 1.74754326,
|
|
|
|
|
1.09547561, 1.01671133, 0.73211143, 0.61891719, 0.75903487,
|
|
|
|
|
1.8919469, 0.72433808, 1.92973094, 0.44749838, 1.36508452])
|
|
|
|
|
|
|
|
|
|
x = np.linspace(0.01, max(data.ravel()) + 1, 10)
|
|
|
|
|
kde = TKDE(data, hs=0.5, L2=0.5)
|
|
|
|
|
_f = kde(x)
|
|
|
|
|
# f = array([1.03982714, 0.45839018, 0.39514782, 0.32860602, 0.26433318,
|
|
|
|
|
# 0.20717946, 0.15907684, 0.1201074 , 0.08941027, 0.06574882])
|
|
|
|
|
|
|
|
|
|
_f1 = kde.eval_grid(x)
|
|
|
|
|
# array([ 1.03982714, 0.45839018, 0.39514782, 0.32860602, 0.26433318,
|
|
|
|
|
# 0.20717946, 0.15907684, 0.1201074 , 0.08941027, 0.06574882])
|
|
|
|
|
|
|
|
|
|
_f2 = kde.eval_grid_fast(x)
|
|
|
|
|
# array([ 1.06437223, 0.46203314, 0.39593137, 0.32781899, 0.26276433,
|
|
|
|
|
# 0.20532206, 0.15723498, 0.11843998, 0.08797755, 0. ])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_docstrings():
|
|
|
|
|
import doctest
|
|
|
|
|
print('Testing docstrings in %s' % __file__)
|
|
|
|
|
doctest.testmod(optionflags=doctest.NORMALIZE_WHITESPACE)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
|
|
test_docstrings()
|
|
|
|
|
# test_kde()
|
|
|
|
|
# check_bkregression()
|
|
|
|
|
# check_regression_bin()
|
|
|
|
|
# check_kreg_demo3()
|
|
|
|
|
# check_kreg_demo4()
|
|
|
|
|
|
|
|
|
|
# test_smoothn_1d()
|
|
|
|
|
# test_smoothn_2d()
|
|
|
|
|
|
|
|
|
|
# kde_demo2()
|
|
|
|
|
# kreg_demo1(fast=True)
|
|
|
|
|
# kde_gauss_demo()
|
|
|
|
|
# kreg_demo2(n=120,symmetric=True,fun='hste', plotlog=True)
|
|
|
|
|
# plt.show('hold')
|
