From 2f5d9fcdc022afb6cde72c3e61446fe7388c970f Mon Sep 17 00:00:00 2001 From: Alex Malz Date: Wed, 27 Dec 2017 23:05:25 -0500 Subject: [PATCH 1/7] started revamping api/documentation --- docs/notebooks/demo.ipynb | 139 ++++------ qp/__init__.py | 1 + qp/metrics.py | 206 ++++++++++++++ qp/pdf.py | 65 ++--- qp/utils.py | 566 ++++++++++++++------------------------ 5 files changed, 501 insertions(+), 476 deletions(-) create mode 100644 qp/metrics.py diff --git a/docs/notebooks/demo.ipynb b/docs/notebooks/demo.ipynb index 049b685d..bc51155c 100644 --- a/docs/notebooks/demo.ipynb +++ b/docs/notebooks/demo.ipynb @@ -18,9 +18,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -48,7 +46,6 @@ "cell_type": "code", "execution_count": null, "metadata": { - "collapsed": false, "scrolled": true }, "outputs": [], @@ -69,9 +66,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "dist = sps.norm(loc=0, scale=1)\n", @@ -93,9 +88,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "np.random.seed(42)\n", @@ -118,7 +111,6 @@ "cell_type": "code", "execution_count": null, "metadata": { - "collapsed": false, "scrolled": true }, "outputs": [], @@ -140,9 +132,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "histogram = P.histogramize(N=10, binrange=demo_limits)\n", @@ -165,9 +155,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "print P.approximate(np.array([0.314]), using='quantiles')" @@ -183,9 +171,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "print P.integrate([0., 1.], using='quantiles')" @@ -202,7 +188,6 @@ "cell_type": "code", "execution_count": null, "metadata": { - "collapsed": false, "scrolled": true }, "outputs": [], @@ -221,9 +206,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "print P.scheme\n", @@ -243,9 +226,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "grid = np.linspace(-3., 3., 20)\n", @@ -267,7 +248,6 @@ "cell_type": "code", "execution_count": null, "metadata": { - "collapsed": false, "scrolled": true }, "outputs": [], @@ -278,9 +258,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "print G.last,'approximation, ', G.scheme, 'interpolation'" @@ -289,9 +267,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "# 10-point grid for a coarse approximation:\n", @@ -312,9 +288,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "MM = qp.PDF(truth=dist, limits=demo_limits)\n", @@ -345,7 +319,6 @@ "cell_type": "code", "execution_count": null, "metadata": { - "collapsed": false, "scrolled": false }, "outputs": [], @@ -368,22 +341,21 @@ "cell_type": "code", "execution_count": null, "metadata": { - "collapsed": false, "scrolled": false }, "outputs": [], "source": [ - "qD1 = qp.utils.calculate_kl_divergence(P, Q, limits=(-1.,1.), vb=True)\n", - "qD2 = qp.utils.calculate_kl_divergence(P, Q, limits=(-2.,2.), vb=True)\n", - "qD3 = qp.utils.calculate_kl_divergence(P, Q, limits=(-3.,3.), vb=True)\n", + "qD1 = qp.metrics.calculate_kld(P, Q, limits=(-1.,1.), vb=True)\n", + "qD2 = qp.metrics.calculate_kld(P, Q, limits=(-2.,2.), vb=True)\n", + "qD3 = qp.metrics.calculate_kld(P, Q, limits=(-3.,3.), vb=True)\n", "print 'Quantile approximation: KLD over 1,2,3 sigma ranges = ', qD1, qD2, qD3\n", - "hD1 = qp.utils.calculate_kl_divergence(P, H, limits=(-1.,1.), vb=True)\n", - "hD2 = qp.utils.calculate_kl_divergence(P, H, limits=(-2.,2.), vb=True)\n", - "hD3 = qp.utils.calculate_kl_divergence(P, H, limits=(-3.,3.), vb=True)\n", + "hD1 = qp.metrics.calculate_kld(P, H, limits=(-1.,1.), vb=True)\n", + "hD2 = qp.metrics.calculate_kld(P, H, limits=(-2.,2.), vb=True)\n", + "hD3 = qp.metrics.calculate_kld(P, H, limits=(-3.,3.), vb=True)\n", "print 'Histogram approximation: KLD over 1,2,3 sigma ranges = ', hD1, hD2, hD3\n", - "sD1 = qp.utils.calculate_kl_divergence(P, S, limits=(-1.,1.), vb=True)\n", - "sD2 = qp.utils.calculate_kl_divergence(P, S, limits=(-2.,2.), vb=True)\n", - "sD3 = qp.utils.calculate_kl_divergence(P, S, limits=(-3.,3.), vb=True)\n", + "sD1 = qp.metrics.calculate_kld(P, S, limits=(-1.,1.), vb=True)\n", + "sD2 = qp.metrics.calculate_kld(P, S, limits=(-2.,2.), vb=True)\n", + "sD3 = qp.metrics.calculate_kld(P, S, limits=(-3.,3.), vb=True)\n", "print 'Sampled approximation: KLD over 1,2,3 sigma ranges = ', sD1, sD2, sD3" ] }, @@ -407,22 +379,21 @@ "cell_type": "code", "execution_count": null, "metadata": { - "collapsed": false, "scrolled": true }, "outputs": [], "source": [ - "qRMSE1 = qp.utils.calculate_rmse(P, Q, limits=(-1.,1.), vb=False)\n", - "qRMSE2 = qp.utils.calculate_rmse(P, Q, limits=(-2.,2.), vb=False)\n", - "qRMSE3 = qp.utils.calculate_rmse(P, Q, limits=(-3.,3.), vb=False)\n", + "qRMSE1 = qp.metrics.calculate_rmse(P, Q, limits=(-1.,1.), vb=False)\n", + "qRMSE2 = qp.metrics.calculate_rmse(P, Q, limits=(-2.,2.), vb=False)\n", + "qRMSE3 = qp.metrics.calculate_rmse(P, Q, limits=(-3.,3.), vb=False)\n", "\n", - "hRMSE1 = qp.utils.calculate_rmse(P, H, limits=(-1.,1.), vb=False)\n", - "hRMSE2 = qp.utils.calculate_rmse(P, H, limits=(-2.,2.), vb=False)\n", - "hRMSE3 = qp.utils.calculate_rmse(P, H, limits=(-3.,3.), vb=False)\n", + "hRMSE1 = qp.metrics.calculate_rmse(P, H, limits=(-1.,1.), vb=False)\n", + "hRMSE2 = qp.metrics.calculate_rmse(P, H, limits=(-2.,2.), vb=False)\n", + "hRMSE3 = qp.metrics.calculate_rmse(P, H, limits=(-3.,3.), vb=False)\n", "\n", - "sRMSE1 = qp.utils.calculate_rmse(P, S, limits=(-1.,1.), vb=False)\n", - "sRMSE2 = qp.utils.calculate_rmse(P, S, limits=(-2.,2.), vb=False)\n", - "sRMSE3 = qp.utils.calculate_rmse(P, S, limits=(-3.,3.), vb=False)\n", + "sRMSE1 = qp.metrics.calculate_rmse(P, S, limits=(-1.,1.), vb=False)\n", + "sRMSE2 = qp.metrics.calculate_rmse(P, S, limits=(-2.,2.), vb=False)\n", + "sRMSE3 = qp.metrics.calculate_rmse(P, S, limits=(-3.,3.), vb=False)\n", "\n", "print 'Quantile approximation: RMSE over 1,2,3 sigma ranges = ', qRMSE1, qRMSE2, qRMSE3\n", "print 'Histogram approximation: RMSE over 1,2,3 sigma ranges = ', hRMSE1, hRMSE2, hRMSE3\n", @@ -446,9 +417,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "pdfs = [P, Q, H, S]\n", @@ -457,7 +426,7 @@ "for pdf in pdfs:\n", " moments = []\n", " for n in which_moments:\n", - " moments.append(qp.utils.calculate_moment(pdf, n))\n", + " moments.append(qp.metrics.calculate_moment(pdf, n))\n", " all_moments.append(moments)\n", " \n", "print('moments: '+str(which_moments))\n", @@ -493,9 +462,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "component_1 = {}\n", @@ -523,9 +490,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "Cq = qp.PDF(truth=C_dist, limits = composite_lims)\n", @@ -543,9 +508,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "Ch = qp.PDF(truth=C_dist, limits = composite_lims)\n", @@ -563,9 +526,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "Cs = qp.PDF(truth=C_dist, limits = composite_lims)\n", @@ -576,53 +537,49 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ - "qD = qp.utils.calculate_kl_divergence(C, Cq, limits=composite_lims, dx=0.001, vb=True)\n", - "hD = qp.utils.calculate_kl_divergence(C, Ch, limits=composite_lims, dx=0.001, vb=True)\n", - "sD = qp.utils.calculate_kl_divergence(C, Cs, limits=composite_lims, dx=0.001, vb=True)\n", + "qD = qp.metrics.calculate_kld(C, Cq, limits=composite_lims, dx=0.001, vb=True)\n", + "hD = qp.metrics.calculate_kld(C, Ch, limits=composite_lims, dx=0.001, vb=True)\n", + "sD = qp.metrics.calculate_kld(C, Cs, limits=composite_lims, dx=0.001, vb=True)\n", "print(qD, hD, sD)" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": { "collapsed": true }, - "outputs": [], - "source": [] + "source": [ + "PDF Ensembles" + ] }, { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 2", + "display_name": "no really, Python 2", "language": "python", "name": "python2" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 3 + "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.3" + "pygments_lexer": "ipython2", + "version": "2.7.14" } }, "nbformat": 4, diff --git a/qp/__init__.py b/qp/__init__.py index 9a01534f..d6a7bc7e 100644 --- a/qp/__init__.py +++ b/qp/__init__.py @@ -2,3 +2,4 @@ from composite import * from ensemble import * from utils import * +from metrics import * diff --git a/qp/metrics.py b/qp/metrics.py new file mode 100644 index 00000000..5a293f3b --- /dev/null +++ b/qp/metrics.py @@ -0,0 +1,206 @@ +import numpy as np + +import qp + +def calculate_moment(p, N, using=None, limits=None, dx=0.01, vb=False): + """ + Calculates a moment of a qp.PDF object + + Parameters + ---------- + p: qp.PDF object + the PDF whose moment will be calculated + N: int + order of the moment to be calculated + limits: tuple of floats + endpoints of integration interval over which to calculate moments + dx: float + resolution of integration grid + vb: Boolean + print progress to stdout? + + Returns + ------- + M: float + value of the moment + """ + if limits is None: + limits = p.limits + if using is None: + using = p.first + # Make a grid from the limits and resolution + d = int((limits[-1] - limits[0]) / dx) + grid = np.linspace(limits[0], limits[1], d) + dx = (limits[-1] - limits[0]) / (d - 1) + # Evaluate the functions on the grid + pe = p.evaluate(grid, using=using, vb=vb)[1] + # pe = normalize_gridded(pe)[1] + # calculate the moment + grid_to_N = grid ** N + M = quick_moment(pe, grid_to_N, dx) + return M + +def quick_moment(p_eval, grid_to_N, dx): + """ + Calculates a moment of an evaluated PDF + + Parameters + ---------- + p_eval: numpy.ndarray, float + the values of a probability distribution + grid: numpy.ndarray, float + the grid upon which p_eval was evaluated + dx: float + the difference between regular grid points + N: int + order of the moment to be calculated + + Returns + ------- + M: float + value of the moment + """ + M = np.dot(grid_to_N, p_eval) * dx + return M + +def calculate_kld(p, q, limits=qp.utils.lims, dx=0.01, vb=False): + """ + Calculates the Kullback-Leibler Divergence between two qp.PDF objects. + + Parameters + ---------- + p: PDF object + probability distribution whose distance _from_ `q` will be calculated. + q: PDF object + probability distribution whose distance _to_ `p` will be calculated. + limits: tuple of floats + endpoints of integration interval in which to calculate KLD + dx: float + resolution of integration grid + vb: boolean + report on progress to stdout? + + Returns + ------- + Dpq: float + the value of the Kullback-Leibler Divergence from `q` to `p` + + Notes + ----- + TO DO: change this to calculate_kld + TO DO: have this take number of points not dx! + """ + # Make a grid from the limits and resolution + N = int((limits[-1] - limits[0]) / dx) + grid = np.linspace(limits[0], limits[1], N) + dx = (limits[-1] - limits[0]) / (N - 1) + # Evaluate the functions on the grid and normalize + pe = p.evaluate(grid, vb=vb, norm=True) + pn = pe[1] + qe = q.evaluate(grid, vb=vb, norm=True) + qn = qe[1] + # Normalize the evaluations, so that the integrals can be done + # (very approximately!) by simple summation: + # pn = pe / np.sum(pe) + #denominator = max(np.sum(qe), epsilon) + # qn = qe / np.sum(qe)#denominator + # Compute the log of the normalized PDFs + # logquotient = safelog(pn / qn) + # logp = safelog(pn) + # logq = safelog(qn) + # Calculate the KLD from q to p + Dpq = quick_kld(pn, qn, dx=dx)# np.dot(pn * logquotient, np.ones(len(grid)) * dx) + if Dpq < 0.: + print('broken KLD: '+str((Dpq, pn, qn, dx))) + Dpq = qp.utils.epsilon + return Dpq + +def quick_kld(p_eval, q_eval, dx=0.01): + """ + Calculates the Kullback-Leibler Divergence between two evaluations of PDFs. + + Parameters + ---------- + p_eval: numpy.ndarray, float + evaluations of probability distribution whose distance _from_ `q` will be calculated + q_eval: numpy.ndarray, float + evaluations of probability distribution whose distance _to_ `p` will be calculated. + dx: float + resolution of integration grid + + Returns + ------- + Dpq: float + the value of the Kullback-Leibler Divergence from `q` to `p` + + Notes + ----- + TO DO: change this to quick_kld + """ + logquotient = qp.utils.safelog(p_eval) - qp.utils.safelog(q_eval) + # logp = safelog(pn) + # logq = safelog(qn) + # Calculate the KLD from q to p + Dpq = dx * np.sum(p_eval * logquotient) + return Dpq + +def calculate_rmse(p, q, limits=qp.utils.lims, dx=0.01, vb=False): + """ + Calculates the Root Mean Square Error between two qp.PDF objects. + + Parameters + ---------- + p: PDF object + probability distribution function whose distance between its truth and the approximation of `q` will be calculated. + q: PDF object + probability distribution function whose distance between its approximation and the truth of `p` will be calculated. + limits: tuple of floats + endpoints of integration interval in which to calculate RMS + dx: float + resolution of integration grid + vb: boolean + report on progress to stdout? + + Returns + ------- + rms: float + the value of the RMS error between `q` and `p` + + Notes + ----- + TO DO: change dx to N + """ + # Make a grid from the limits and resolution + N = int((limits[-1] - limits[0]) / dx) + grid = np.linspace(limits[0], limits[1], N) + dx = (limits[-1] - limits[0]) / (N - 1) + # Evaluate the functions on the grid + pe = p.evaluate(grid, vb=vb)[1] + qe = q.evaluate(grid, vb=vb)[1] + # Calculate the RMS between p and q + rms = quick_rmse(pe, qe, N)# np.sqrt(dx * np.sum((pe - qe) ** 2)) + return rms + +def quick_rmse(p_eval, q_eval, N): + """ + Calculates the Root Mean Square Error between two evaluations of PDFs. + + Parameters + ---------- + p_eval: numpy.ndarray, float + evaluation of probability distribution function whose distance between + its truth and the approximation of `q` will be calculated. + q_eval: numpy.ndarray, float + evaluation of probability distribution function whose distance between + its approximation and the truth of `p` will be calculated. + N: int + number of points at which PDFs were evaluated + + Returns + ------- + rms: float + the value of the RMS error between `q` and `p` + """ + # Calculate the RMS between p and q + rms = np.sqrt(np.sum((p_eval - q_eval) ** 2) / N) + return rms diff --git a/qp/pdf.py b/qp/pdf.py index 263dea38..38a67e25 100644 --- a/qp/pdf.py +++ b/qp/pdf.py @@ -65,7 +65,7 @@ def __init__(self, truth=None, quantiles=None, histogram=None, self.quantiles = quantiles self.histogram = qp.utils.normalize_histogram(histogram, vb=vb) self.samples = samples - self.gridded = qp.utils.normalize_integral(qp.utils.normalize_gridded(gridded, vb=vb)) + self.gridded = qp.utils.normalize_integral(qp.utils.normalize_gridded(gridded)) self.mix_mod = None self.limits = limits @@ -147,7 +147,7 @@ def evaluate(self, loc, using=None, norm=False, vb=True): evaluated = self.approximate(loc, using=using, vb=vb) val = evaluated[1] - gridded = qp.utils.normalize_gridded((loc, val), vb=vb) + gridded = qp.utils.normalize_gridded((loc, val)) if norm: gridded = qp.utils.normalize_integral(gridded, vb=vb) @@ -295,16 +295,17 @@ def quantize(self, quants=None, N=9, limits=None, vb=True): try: while (order>0) and (not np.array_equal(quantiles, np.sort(quantiles))): if vb: print('order is '+str(order)) - b = spi.InterpolatedUnivariateSpline(icdf, grid, k=order, ext=1) + b = spi.InterpolatedUnivariateSpline(icdf, grid, k=order, ext=1, check_finite=True) quantiles = b(quantpoints) order -= 1 assert(not np.any(np.isnan(quantiles))) - assert(type(quantiles) is not dfitpack.error) except AssertionError: print('ERROR: splines failed because '+str(AssertionError)+', defaulting to optimization for '+str((icdf, grid))) locs = np.array([bisect.bisect_right(icdf[:-1], quantpoints[n]) for n in range(N)]) quantiles = self.truth.ppf(quantpoints, ivals=grid[locs]) assert(not np.any(np.isnan(quantiles))) + except Exception, e: + print('ERROR in `scipy.interpolate.InterpolatedUnivariateSpline`') if vb: print('output quantiles = '+str(quantiles)) else: quantiles = self.truth.ppf(quantpoints) @@ -513,8 +514,8 @@ def sample(self, N=1000, infty=default_infty, using=None, vb=True): if self.quantiles is None: self.quantiles = self.quantize(vb=vb) - (x, y) = qp.utils.evaluate_quantiles(self.quantiles, vb=vb) - (endpoints, weights) = qp.utils.normalize_quantiles(self.quantiles, (x, y), vb=vb) + # (x, y) = qp.utils.evaluate_quantiles(self.quantiles, vb=vb) + (endpoints, weights) = qp.utils.normalize_quantiles(self.quantiles, vb=vb) # endpoints = np.insert(self.quantiles[1], [0, -1], self.limits) # weights = qp.utils.evaluate_quantiles(self.quantiles)[1]# self.evaluate((endpoints[1:]+endpoints[:-1])/2.) # interpolator = self.interpolate(using='quantiles', vb=False) @@ -586,14 +587,12 @@ def interpolate(self, using=None, vb=True): order = self.scheme if vb: print('input quantiles are '+str(self.quantiles[1])) - (x, y) = qp.utils.evaluate_quantiles(self.quantiles, vb=vb) - if vb: print('evaluated quantile PDF: '+str((x, y))) + # (x, y) = qp.utils.evaluate_quantiles(self.quantiles, vb=vb) + # if vb: print('evaluated quantile PDF: '+str((x, y))) # [x_crit_lo, x_crit_hi] = [x[0], x[-1]] # [y_crit_lo, y_crit_hi] = [y[0], y[-1]] - (x, y) = qp.utils.normalize_quantiles(self.quantiles, (x, y), vb=vb) + (x, y) = qp.utils.normalize_quantiles(self.quantiles, vb=vb) if vb: print('complete evaluated quantile PDF: '+str((x, y))) - alternate = spi.interp1d(x, y, kind='linear', bounds_error=False, fill_value=default_eps) - backup = qp.utils.make_kludge_interpolator((x, y), outside=default_eps) z = np.insert(self.quantiles[1], 0, min(x)) z = np.append(z, max(x)) @@ -652,12 +651,14 @@ def quantile_interpolator(xf): except AssertionError: print('ERROR: spline interpolation failed with '+str((xf[in_inds], yf[in_inds]))) try: + alternate = spi.interp1d(x, y, kind='linear', bounds_error=False, fill_value=default_eps) yf[in_inds] = alternate(xf[in_inds]) assert(np.all(yf >= default_eps)) if vb: print 'Created a linear interpolator for the '+using+' parametrization.' except AssertionError: print 'ERROR: linear interpolation failed for the '+using+' parametrization with '+str((xf[in_inds], yf[in_inds])) + backup = qp.utils.make_kludge_interpolator((x, y), threshold=default_eps) yf[in_inds] = backup(xf[in_inds]) if vb: print 'Doing linear interpolation by hand for the '+using+' parametrization.' @@ -802,7 +803,7 @@ def approximate(self, points, using=None, scheme=None, vb=True): interpolated = interpolator(points) # except: # print('error in '+using+' interpolation of '+str(points)) - interpolated = qp.utils.normalize_gridded((points, interpolated), vb=vb) + interpolated = qp.utils.normalize_gridded((points, interpolated)) # interpolated[interpolated<0.] = 0. return interpolated#(points, interpolated) @@ -868,10 +869,10 @@ def plot(self, limits=None, loc='plot.pdf', vb=True): print 'Plotted mixture model.' if self.quantiles is not None: - (z, p) = self.evaluate(self.quantiles[1], using='quantiles', vb=vb) - print('first: '+str((z,p))) - (x, y) = qp.utils.normalize_quantiles(self.quantiles, (z, p)) - print('second: '+str((x,y))) + # (z, p) = self.evaluate(self.quantiles[1], using='quantiles', vb=vb) + # print('first: '+str((z,p))) + (x, y) = qp.utils.normalize_quantiles(self.quantiles) + print('second: '+str((x, y))) [min_x, max_x] = [min(x), max(x)] extrema = [min(extrema[0], min_x), max(extrema[1], max_x)] [min_x, max_x] = extrema @@ -958,23 +959,25 @@ def kld(self, using=None, limits=None, dx=0.01): Example:: d = p.kld(limits=(-1., 1.), dx=1./100)) """ + print('This function is deprecated; use `qp.utils.calculate_kld`.') + return # print('This function is deprecated; use `qp.utils.calculate_kl_divergence`.') # return - if self.truth is None: - print('Truth not available for comparison.') - return - else: - if using is None: - using = self.last - if limits is None: - limits = self.limits - D = int((limits[-1] - limits[0]) / dx) - grid = np.linspace(limits[0], limits[1], D) - KL = qp.utils.quick_kl_divergence(self.evaluate(grid, using='truth'), self.evaluate(grid, using=using), dx=dx) - self.klds[using] = KL - return(KL) - - def rms(self, limits=(0., 1.), dx=0.01): + # if self.truth is None: + # print('Truth not available for comparison.') + # return + # else: + # if using is None: + # using = self.last + # if limits is None: + # limits = self.limits + # D = int((limits[-1] - limits[0]) / dx) + # grid = np.linspace(limits[0], limits[1], D) + # KL = qp.utils.quick_kl_divergence(self.evaluate(grid, using='truth'), self.evaluate(grid, using=using), dx=dx) + # self.klds[using] = KL + # return(KL) + + def rmse(self, limits=(0., 1.), dx=0.01): """ Calculates root mean square difference between quantile approximation and truth. diff --git a/qp/utils.py b/qp/utils.py index c9af2bf2..527d65a5 100644 --- a/qp/utils.py +++ b/qp/utils.py @@ -1,14 +1,7 @@ -""" -Notes ------ -TO DO: change dx --> dz (or delta) -""" - import numpy as np import scipy as sp from scipy import stats as sps import sys -# import bisect global epsilon epsilon = sys.float_info.epsilon @@ -17,20 +10,50 @@ global lims lims = (epsilon, 1.) +def sandwich(in_arr, ends): + """ + Adds given values to the ends of a 1D array + + Parameters + ---------- + in_arr: numpy.ndarray, float + original array + ends: numpy.ndarray or tuple or list, float or numpy.ndarray, float + values to be added to the beginning and end + + Returns + ------- + out_arr: numpy.ndarray, float + array with front and back concatenations + """ + if type(ends[0]) == np.ndarray: + prepend = len(ends[0]) + else: + prepend = 1 + if type(ends[-1]) == np.ndarray: + append = -1 * len(ends[-1]) + else: + append = -1 + out_arr = np.zeros(prepend + len(in_arr) - append) + out_arr[:prepend] = ends[0] + out_arr[prepend:append] = in_arr + out_arr[append:] = ends[-1] + return out_arr + def safelog(arr, threshold=epsilon): """ - Takes the natural logarithm of an array that might contain zeroes. + Takes the natural logarithm of an array of potentially non-positive numbers Parameters ---------- - arr: ndarray + arr: numpy.ndarray, float values to be logged threshold: float small, positive value to replace zeros and negative numbers Returns ------- - logged: ndarray + logged: numpy.ndarray logarithms, with approximation in place of zeros and negative numbers """ shape = np.shape(arr) @@ -40,433 +63,268 @@ def safelog(arr, threshold=epsilon): def normalize_integral(in_data, vb=False): """ - Normalizes integrals over full range from grid + Normalizes integrals of PDF evaluations on a grid Parameters ---------- - in_data: None or tuple, ndarray, float - tuple of points at which function is evaluated and the PDF at those points - vb: boolean - print progress to stdout? + in_data: None or tuple, numpy.ndarray, float + tuple of points x at which function is evaluated and the PDF y at those + points + vb: boolean, optional + be careful and print progress to stdout? Returns ------- - (x, y): tuple, ndarray, float - tuple of input x and normalized y + out_data: tuple, numpy.ndarray, float + tuple of ordered input x and normalized y """ if in_data is None: return in_data (x, y) = in_data - # a = x.argsort() - # x.sort() - # ys = y[a] + # if vb: + a = x.argsort() + # try: + # assert np.array_equal(x[a], x.sort()) + # except AssertionError: + x.sort() + y = y[a] dx = x[1:] - x[:-1] - dy = (y[1:] + y[:-1]) / 2. - norm = np.dot(dy, dx) + my = (y[1:] + y[:-1]) / 2. + norm = np.dot(my, dx) y = y / norm if vb: - # print('almost normalized integrals') - dy = (y[1:] + y[:-1]) / 2. - if not np.isclose(np.dot(dy, dx), 1.): - print('broken integral = '+str(np.dot(dy, dx))) + try: + my = (y[1:] + y[:-1]) / 2. + assert np.isclose(np.dot(my, dx), 1.) + except AssertionError: + print('`qp.utils.normalize_integral`: broken integral = '+str((my, dx))) assert False - return(x, y) - -def normalize_gridded(in_data, vb=True): - """ - Normalizes gridded parametrizations assuming evenly spaced grid - - Parameters - ---------- - in_data: None or tuple, ndarray, float - tuple of points at which function is evaluated and the PDF at those points - vb: boolean - print progress to stdout? + out_data = (x, y) + return out_data - Returns - ------- - (x, y): tuple, ndarray, float - tuple of input x and normalized y +def evaluate_samples(in_data, bw_method=None, vb=False): """ - if in_data is None: - return in_data - (x, y) = in_data - y[y < epsilon] = epsilon - y[y > infty] = infty - return (x, y) - -def normalize_histogram(in_data, vb=True): - """ - Normalizes histogram parametrizations - - Parameters - ---------- - in_data: None or tuple, ndarray, float - tuple of (n+1) bin endpoints and (n) CDF between endpoints - vb: boolean - print progress to stdout? - - Returns - ------- - (x, y): tuple, ndarray, float - tuple of input x and normalized y - """ - if in_data is None: - return in_data - (x, y) = in_data - delta = x[1:] - x[:-1] - # if vb: print(np.sum(y * delta)) - y[y < epsilon] = epsilon - y /= np.dot(y, delta) - # if vb: print(np.sum(y * delta)) - return (x, y) - -def normalize_quantiles((q, z), (x, y), vb=True): - """ - Adds valid endpoints to quantile parametrization - - Parameters - ---------- - q: numpy.ndarray, float - CDF values corresponding to quantiles - z: numpy.ndarray, float - original quantiles - x: numpy.ndarray, float - averaged quantile values - y: numpy.ndarray, float - probability evaluated at averaged quantiles - vb: boolean - print progress to stdout? - - Returns - ------- - (x, y): tuple, ndarray, float - tuple of input x and normalized y - - Notes - ----- - Finds actual endpoints via linear interpolation from evaluation - """ - # nq = np.insert(q, [0, -1], (0., 1.)) - q = np.insert(q, 0, 0.) - q = np.append(q, 1.) - # nq = (q[1:] + q[:-1]) / 2. - dq = q[1:] - q[:-1] - # if vb: - # if not np.all(nq>0.)... - xmin = z[0] - 2 * (dq[0] + dq[1] / 2. - y[0] * (x[0] - z[0])) / y[0] - xmax = z[-1] + 2 * (dq[-1] + dq[-2]/2. - y[-1] * (z[-1] - x[-1])) / y[-1] - if vb: print('x before: '+str(x)) - x = np.insert(x, 0, xmin) - x = np.append(x, xmax) - if vb: print('x after: '+str(x)) - y = np.insert(y, 0, epsilon) - y = np.append(y, epsilon) - return(x, y) - -def evaluate_quantiles((qs, xs), vb=True): - """ - Produces PDF values given quantile information + Produces PDF values given samples Parameters ---------- - qs: ndarray, float - CDF values - xs: ndarray, float - quantile values - vb: Boolean - print progress to stdout? + in_data: numpy.ndarray, float + samples x from the PDF + bw_method: string or scalar or callable function, optional + `scipy.stats.gaussian_kde` bandwidth methods: 'scott', 'silverman' + vb: boolean, optional + be careful and print progress to stdout? Returns ------- - (x, y): tuple, float - quantile values and corresponding PDF - - Notes - ----- - TO DO: make this use linear interpolation instead of piecewise constant + out_data: tuple, float + sorted samples x and corresponding PDF values y """ - # q = np.append(q, np.array([1.])) - # qs = np.append(np.array([0.]), q) - # norm = max(qs) - min(qs) - dq = qs[1:] - qs[:-1] - # xs = np.append(x, np.array([infty])) - # xs = np.append(np.array([-1. * infty]), x) - dx = xs[1:] - xs[:-1] + x = in_data + x.sort() + kde = sps.gaussian_kde(x, bw_method) if vb: - if not np.all(dx>0.): - print('broken delta quantile values: '+str(xs)) - assert(np.all(dx>0.)) - mx = (xs[1:] + xs[:-1]) / 2. - y = dq / dx - # print(np.dot(y, dx)) - # y *= norm - return ((mx, y)) - -def evaluate_histogram((xp, y)): - """ - Produces PDF values given histogram information - - Parameters - ---------- - xp: ndarray, float - bin endpoints - y: ndarray, float - CDFs over bins - - Returns - ------- - (x, y): tuple, float - bin midpoints and CDFs over bins + print('`qp.utils.evaluate_samples` made a KDE with bandwidth = '+str(kde.factor)) + y = kde(x) + out_data = (x, y) + return out_data - Notes - ----- - This shouldn't be necessary at all, see qp.PDF.interpolate notes - """ - x = (xp[1:] + xp[:-1]) / 2. - return((x, y)) - -def evaluate_samples(x): +def evaluate_histogram(in_data, threshold=epsilon, vb=False): """ Produces PDF values given samples Parameters ---------- - x: ndarray, float - samples from the PDF + in_data: None or tuple, numpy.ndarray, float + tuple of (n+1) bin endpoints x and (n) CDF y between endpoints + threshold: float, optional - Returns - ------- - (sx, y): tuple, float - sorted sample values and corresponding PDF values - """ - sx = np.sort(x) - # bandwidth = np.mean(sx[1:]-sx[:-1]) - kde = sps.gaussian_kde(x)# , bw_method=bandwidth) - y = kde(sx) - return ((sx, y)) - -def calculate_moment(p, N, using=None, limits=None, dx=0.01, vb=False): - """ - Calculates a moment of a qp.PDF object - - Parameters - ---------- - p: qp.PDF object - the PDF whose moment will be calculated - N: int - order of the moment to be calculated - limits: tuple of floats - endpoints of integration interval over which to calculate moments - dx: float - resolution of integration grid - vb: Boolean - print progress to stdout? + vb: boolean, optional + be careful and print progress to stdout? Returns ------- - M: float - value of the moment + out_data: tuple, float + sorted samples x and corresponding PDF values y """ - if limits is None: - limits = p.limits - if using is None: - using = p.first - # Make a grid from the limits and resolution - d = int((limits[-1] - limits[0]) / dx) - grid = np.linspace(limits[0], limits[1], d) - dx = (limits[-1] - limits[0]) / (d - 1) - # Evaluate the functions on the grid - pe = p.evaluate(grid, using=using, vb=vb)[1] - # pe = normalize_gridded(pe)[1] - # calculate the moment - grid_to_N = grid ** N - M = quick_moment(pe, grid_to_N, dx) - return M - -def quick_moment(p_eval, grid_to_N, dx): + (x, y) = in_data + dx = threshold + xs = np.zeros(2 * len(y)) + ys = xs + xs[::2] = x[:-1] + dx + xs[1::2] = x[1:] - dx + ys = np.repeat(y, 2) + xs = sandwich(xs, (x[0] - dx, x[-1] + dx)) + ys = sandwich(ys, (threshold, threshold)) + if vb: + try: + assert np.all(ys >= threshold) + except AssertionError: + print('broken self-evaluations in `qp.utils.evaluate_histogram`: '+str((xs, ys))) + assert False + out_data = (xs, ys) + return out_data + +def normalize_histogram(in_data, threshold=epsilon, vb=False): """ - Calculates a moment of an evaluated PDF + Normalizes histogram parametrizations Parameters ---------- - p_eval: numpy.ndarray, float - the values of a probability distribution - grid: numpy.ndarray, float - the grid upon which p_eval was evaluated - dx: float - the difference between regular grid points - N: int - order of the moment to be calculated + in_data: None or tuple, numpy.ndarray, float + tuple of (n+1) bin endpoints x and (n) CDF y between endpoints + threshold: float, optional + optional minimum threshold + vb: boolean, optional + be careful and print progress to stdout? Returns ------- - M: float - value of the moment + out_data: tuple, numpy.ndarray, float + tuple of input x and normalized y """ - M = np.dot(grid_to_N, p_eval) * dx - return M + if in_data is None: + return in_data + (x, y) = in_data + dx = x[1:] - x[:-1] + y[y < threshold] = threshold + y /= np.dot(y, dx) + if vb: + try: + assert np.isclose(np.dot(y, dx), 1.) + except AssertionError: + print('`qp.utils.normalize_histogram`: broken integral = '+str(np.dot(y, dx))) + assert False + out_data = (x, y) + return out_data -def calculate_kl_divergence(p, q, limits=lims, dx=0.01, vb=False): +def normalize_gridded(in_data, thresholds=(epsilon, infty)): """ - Calculates the Kullback-Leibler Divergence between two qp.PDF objects. + Removes extreme values from gridded parametrizations Parameters ---------- - p: PDF object - probability distribution whose distance _from_ `q` will be calculated. - q: PDF object - probability distribution whose distance _to_ `p` will be calculated. - limits: tuple of floats - endpoints of integration interval in which to calculate KLD - dx: float - resolution of integration grid - vb: boolean - report on progress to stdout? + in_data: None or tuple, numpy.ndarray, float + tuple of points x at which function is evaluated and the PDF y at those + points + thresholds: tuple, float, optional + optional min/max thresholds for normalization Returns ------- - Dpq: float - the value of the Kullback-Leibler Divergence from `q` to `p` - - Notes - ----- - TO DO: change this to calculate_kld - TO DO: have this take number of points not dx! - """ - # Make a grid from the limits and resolution - N = int((limits[-1] - limits[0]) / dx) - grid = np.linspace(limits[0], limits[1], N) - dx = (limits[-1] - limits[0]) / (N - 1) - # Evaluate the functions on the grid and normalize - pe = p.evaluate(grid, vb=vb, norm=True) - pn = pe[1] - qe = q.evaluate(grid, vb=vb, norm=True) - qn = qe[1] - # Normalize the evaluations, so that the integrals can be done - # (very approximately!) by simple summation: - # pn = pe / np.sum(pe) - #denominator = max(np.sum(qe), epsilon) - # qn = qe / np.sum(qe)#denominator - # Compute the log of the normalized PDFs - # logquotient = safelog(pn / qn) - # logp = safelog(pn) - # logq = safelog(qn) - # Calculate the KLD from q to p - Dpq = quick_kl_divergence(pn, qn, dx=dx)# np.dot(pn * logquotient, np.ones(len(grid)) * dx) - if Dpq < 0.: - print('broken KLD: '+str((Dpq, pn, qn, dx))) - Dpq = epsilon - return Dpq - -def quick_kl_divergence(p_eval, q_eval, dx=0.01): + out_data: tuple, numpy.ndarray, float + tuple of input x and normalized y """ - Calculates the Kullback-Leibler Divergence between two evaluations of PDFs. - - Parameters - ---------- - p_eval: numpy.ndarray, float - evaluations of probability distribution whose distance _from_ `q` will be calculated - q_eval: numpy.ndarray, float - evaluations of probability distribution whose distance _to_ `p` will be calculated. - dx: float - resolution of integration grid - - Returns - ------- - Dpq: float - the value of the Kullback-Leibler Divergence from `q` to `p` + if in_data is None: + return in_data + (x, y) = in_data + y[y < thresholds[0]] = thresholds[0] + y[y > thresholds[-1]] = thresholds[-1] + out_data = (x, y) + return out_data - Notes - ----- - TO DO: change this to quick_kld +def evaluate_quantiles(in_data, threshold=epsilon, vb=False): """ - logquotient = safelog(p_eval) - safelog(q_eval) - # logp = safelog(pn) - # logq = safelog(qn) - # Calculate the KLD from q to p - Dpq = dx * np.sum(p_eval * logquotient) - return Dpq - -def calculate_rmse(p, q, limits=lims, dx=0.01, vb=False): - """ - Calculates the Root Mean Square Error between two qp.PDF objects. + Estimates PDF values given quantile information Parameters ---------- - p: PDF object - probability distribution function whose distance between its truth and the approximation of `q` will be calculated. - q: PDF object - probability distribution function whose distance between its approximation and the truth of `p` will be calculated. - limits: tuple of floats - endpoints of integration interval in which to calculate RMS - dx: float - resolution of integration grid - vb: boolean - report on progress to stdout? + in_data: tuple, numpy.ndarray, float + tuple of CDF values iy and values x at which those CDFs are achieved + threshold: float, optional + optional minimum threshold for CDF difference + vb: boolean, optional + be careful and print progress to stdout? Returns ------- - rms: float - the value of the RMS error between `q` and `p` - - Notes - ----- - TO DO: change dx to N + out_data: tuple, numpy.ndarray, float + values xs and corresponding PDF values ys """ - # Make a grid from the limits and resolution - N = int((limits[-1] - limits[0]) / dx) - grid = np.linspace(limits[0], limits[1], N) - dx = (limits[-1] - limits[0]) / (N - 1) - # Evaluate the functions on the grid - pe = p.evaluate(grid, vb=vb)[1] - qe = q.evaluate(grid, vb=vb)[1] - # Calculate the RMS between p and q - rms = quick_rmse(pe, qe, N)# np.sqrt(dx * np.sum((pe - qe) ** 2)) - return rms - -def quick_rmse(p_eval, q_eval, N): + (iy, x) = in_data + dx = x[1:] - x[:-1] + if vb: + try: + assert np.all(dx > threshold) + except AssertionError: + print('broken quantile locations in `qp.utils.evaluate_quantiles`: '+str(x)) + assert False + diy = iy[1:] - iy[:-1] + if vb: + try: + assert np.all(diy > threshold) + except AssertionError: + print('broken CDF values in `qp.utils.evaluate_quantiles`: '+str(iy)) + assert False + y = diy / dx + (xs, ys) = evaluate_histogram((x, y), threshold=threshold, vb=vb) + if vb: print('input shape: '+str((len(x), len(y)))+', output shape: '+str((len(xs), len(ys)))) + # try: + # assert (np.all(xs > threshold) and np.all(ys > threshold)) + # except AssertionError: + # print('broken quantile self-evaluations in `qp.utils.evaluate_quantiles`: '+str((xs, ys))) + # assert False + # ys = ys[1:-1] + # xs = xs[1:-1] + # ys = sandwich(ys, (threshold, threshold)) + # x_min = xs[0] - 2 * iy[0] / y[0] + # x_max = xs[-1] + 2 * iy[-1] / y[-1] + # xs = sandwich(xs, (x_min, x_max)) + out_data = (xs[1:-1], ys[1:-1]) + return out_data + +def normalize_quantiles(in_data, threshold=epsilon, vb=False): """ - Calculates the Root Mean Square Error between two evaluations of PDFs. + Evaluates PDF from quantiles including endpoints from linear extrapolation Parameters ---------- - p_eval: numpy.ndarray, float - evaluation of probability distribution function whose distance between its truth and the approximation of `q` will be calculated. - q_eval: numpy.ndarray, float - evaluation of probability distribution function whose distance between its approximation and the truth of `p` will be calculated. - N: int - number of points at which PDFs were evaluated + in_data: tuple, numpy.ndarray, float + tuple of CDF values iy corresponding to quantiles and the points x at + which those CDF values are achieved + threshold: float, optional + optional minimum threshold for PDF + vb: boolean, optional + be careful and print progress to stdout? Returns ------- - rms: float - the value of the RMS error between `q` and `p` + out_data: tuple, ndarray, float + tuple of values x at which CDF is achieved, including extrema, and + normalized PDF values y at x """ - # Calculate the RMS between p and q - rms = np.sqrt(np.sum((p_eval - q_eval) ** 2) / N) - return rms - -def make_kludge_interpolator((x, y), outside=epsilon): + (iy, x) = in_data + (xs, ys) = evaluate_quantiles((iy, x), vb=vb) + # xs = xs[1:-1] + # ys = ys[1:-1] + x_min = xs[0] - 2 * iy[0] / ys[0] + x_max = xs[-1] + 2 * (1. - iy[-1]) / ys[-1] + xs = sandwich(xs, (x_min, x_max)) + ys = sandwich(ys, (threshold, threshold)) + out_data = (xs, ys) + return out_data + +def make_kludge_interpolator(in_data, threshold=epsilon): """ Linear interpolation by hand for debugging Parameters ---------- - (x, y): tuple, numpy.ndarray, float - where interpolator is fit - outside: float - value to use outside interpolation range + in_data: tuple, numpy.ndarray, float + values x and PDF values y at which interpolator is fit + threshold: float, optional + minimum value to use outside interpolation range Returns ------- kludge_interpolator: function evaluates linear interpolant based on input points """ + (x, y) = in_data dx = x[1:] - x[:-1] dy = y[1:] - y[:-1] def kludge_interpolator(xf): - yf = np.ones(np.shape(xf)) * epsilon + yf = np.ones(np.shape(xf)) * threshold for i in range(len(x)): inside = ((xf >= x[i]) & (xf <= x[i+1])).nonzero()[0] yf[inside] = y[i] + (y[i+1] - y[i]) * (xf[inside] - x[i]) / dx[i] From 47121a5d711e9f550e2ebc305bea37e80c385d26 Mon Sep 17 00:00:00 2001 From: Alex Malz Date: Thu, 28 Dec 2017 13:22:14 -0500 Subject: [PATCH 2/7] changing syntax for metric calculations --- docs/notebooks/kld.ipynb | 74 +++++++++++++--------------------------- 1 file changed, 24 insertions(+), 50 deletions(-) diff --git a/docs/notebooks/kld.ipynb b/docs/notebooks/kld.ipynb index f29cda6e..5c0fe98c 100644 --- a/docs/notebooks/kld.ipynb +++ b/docs/notebooks/kld.ipynb @@ -48,9 +48,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "import matplotlib\n", @@ -67,9 +65,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "P = qp.PDF(truth=sps.norm(loc=0.0, scale=1.0))" @@ -78,9 +74,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "x, sigma = 2.0, 1.0\n", @@ -90,13 +84,11 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "infinity = 100.0\n", - "D = qp.utils.calculate_kl_divergence(P, Q, limits=(-infinity,infinity), vb=False)\n", + "D = qp.metrics.calculate_kld(P, Q, limits=(-infinity,infinity), vb=False)\n", "print D" ] }, @@ -119,14 +111,12 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "x, sigma = 0.0, 4.37\n", "Q = qp.PDF(truth=sps.norm(loc=x, scale=sigma))\n", - "D = qp.utils.calculate_kl_divergence(P, Q, limits=(-infinity,infinity), vb=False)\n", + "D = qp.metrics.calculate_kld(P, Q, limits=(-infinity,infinity), vb=False)\n", "print D" ] }, @@ -213,9 +203,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "widths = np.logspace(-2.0,2.0,13)\n", @@ -227,17 +215,15 @@ "\n", "for k,sigma in enumerate(widths):\n", " Q = qp.PDF(truth=sps.norm(loc=x, scale=sigma))\n", - " D[k] = qp.utils.calculate_kl_divergence(P, Q, limits=(-infinity,infinity), vb=False)\n", - " E[k] = qp.utils.calculate_rmse(P, Q, limits=(-infinity,infinity), vb=False)\n", + " D[k] = qp.metrics.calculate_kld(P, Q, limits=(-infinity,infinity), vb=False)\n", + " E[k] = qp.metrics.calculate_rmse(P, Q, limits=(-infinity,infinity), vb=False)\n", "print zip(widths, D)" ] }, { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "x = widths\n", @@ -297,9 +283,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "separations = np.linspace(0.0,15.0,16)\n", @@ -311,17 +295,15 @@ "\n", "for k,x0 in enumerate(separations):\n", " Q = qp.PDF(truth=sps.norm(loc=x0, scale=sigma))\n", - " D[k] = qp.utils.calculate_kl_divergence(P, Q, limits=(-infinity,infinity), vb=False)\n", - " E[k] = qp.utils.calculate_rmse(P, Q, limits=(-infinity,infinity), vb=False)\n", + " D[k] = qp.metrics.calculate_kld(P, Q, limits=(-infinity,infinity), vb=False)\n", + " E[k] = qp.metrics.calculate_rmse(P, Q, limits=(-infinity,infinity), vb=False)\n", "print zip(separations, D)" ] }, { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "fig, ax = plt.subplots()\n", @@ -349,9 +331,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "import sys\n", @@ -377,9 +357,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "infinity = 100.0\n", @@ -394,8 +372,8 @@ " \n", " for k,x0 in enumerate(separations):\n", " Q = qp.PDF(truth=sps.norm(loc=x0, scale=sigma))\n", - " D[j,k] = qp.utils.calculate_kl_divergence(P, Q, limits=(-infinity,infinity), vb=False)\n", - " E[j,k] = qp.utils.calculate_rmse(P, Q, limits=(-infinity,infinity), vb=False)\n", + " D[j,k] = qp.metrics.calculate_kld(P, Q, limits=(-infinity,infinity), vb=False)\n", + " E[j,k] = qp.metrics.calculate_rmse(P, Q, limits=(-infinity,infinity), vb=False)\n", " tensions[j,k] = x0 / np.sqrt(sigma*sigma + 1.0)\n", " " ] @@ -403,9 +381,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "x = tensions[0,:]\n", @@ -461,16 +437,14 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 2", + "display_name": "no really, Python 2", "language": "python", "name": "python2" }, @@ -484,9 +458,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", - "version": "2.7.13" + "version": "2.7.14" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } From b275bf9b264ceae078a28240723ef7811aeaa071 Mon Sep 17 00:00:00 2001 From: Alex Malz Date: Thu, 28 Dec 2017 16:49:20 -0500 Subject: [PATCH 3/7] eliminating PDF.truth attribute but making a mess in the process --- docs/notebooks/demo.ipynb | 157 ++++++++++++++++++------- qp/__init__.py | 5 +- qp/ensemble.py | 22 ++-- qp/pdf.py | 236 ++++++++++++++++++++------------------ 4 files changed, 250 insertions(+), 170 deletions(-) diff --git a/docs/notebooks/demo.ipynb b/docs/notebooks/demo.ipynb index bc51155c..406e552f 100644 --- a/docs/notebooks/demo.ipynb +++ b/docs/notebooks/demo.ipynb @@ -51,7 +51,7 @@ "outputs": [], "source": [ "# ! cat qp/pdf.py\n", - "P = qp.PDF()" + "P = qp.PDF(vb=True)" ] }, { @@ -72,7 +72,7 @@ "dist = sps.norm(loc=0, scale=1)\n", "print(type(dist))\n", "demo_limits = (-5., 5.)\n", - "P = qp.PDF(truth=dist, limits=demo_limits)\n", + "P = qp.PDF(funcform=dist, limits=demo_limits)\n", "P.plot()" ] }, @@ -93,7 +93,7 @@ "source": [ "np.random.seed(42)\n", "\n", - "samples = P.sample(1000, using='truth', vb=False)\n", + "samples = P.sample(1000, using='mix_mod', vb=False)\n", "S = qp.PDF(samples=samples, limits=demo_limits)\n", "S.plot()" ] @@ -161,6 +161,15 @@ "print P.approximate(np.array([0.314]), using='quantiles')" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "P.mix_mod" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -230,7 +239,7 @@ "outputs": [], "source": [ "grid = np.linspace(-3., 3., 20)\n", - "gridded = P.evaluate(grid, using='truth', vb=False)\n", + "gridded = P.evaluate(grid, using='mix_mod', vb=False)\n", "\n", "G = qp.PDF(gridded=gridded, limits=demo_limits)\n", "G.sample(100, vb=False)\n", @@ -291,7 +300,7 @@ "metadata": {}, "outputs": [], "source": [ - "MM = qp.PDF(truth=dist, limits=demo_limits)\n", + "MM = qp.PDF(funcform=dist, limits=demo_limits)\n", "MM.sample(1000, vb=False)\n", "MM.mix_mod_fit(n_components=5)\n", "MM.plot()" @@ -326,37 +335,43 @@ "P.plot()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Quantitative Comparisons" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "symm_lims = np.array([-1., 1.])\n", + "all_lims = [symm_lims, 2.*symm_lims, 3.*symm_lims]" + ] + }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ - "### Quantitative Comparisons\n", - "\n", "Next, let's compare the different parametrizations to the truth using the Kullback-Leibler Divergence (KLD). The KLD is a measure of how close two probability distributions are to one another -- a smaller value indicates closer agreement. It is measured in units of bits of information, the information lost in going from the second distribution to the first distribution. The KLD calculator here takes in a shared grid upon which to evaluate the true distribution and the interpolated approximation of that distribution and returns the KLD of the approximation relative to the truth, which is not in general the same as the KLD of the truth relative to the approximation. Below, we'll calculate the KLD of the approximation relative to the truth over different ranges, showing that it increases as it includes areas where the true distribution and interpolated distributions diverge." ] }, { "cell_type": "code", "execution_count": null, - "metadata": { - "scrolled": false - }, + "metadata": {}, "outputs": [], "source": [ - "qD1 = qp.metrics.calculate_kld(P, Q, limits=(-1.,1.), vb=True)\n", - "qD2 = qp.metrics.calculate_kld(P, Q, limits=(-2.,2.), vb=True)\n", - "qD3 = qp.metrics.calculate_kld(P, Q, limits=(-3.,3.), vb=True)\n", - "print 'Quantile approximation: KLD over 1,2,3 sigma ranges = ', qD1, qD2, qD3\n", - "hD1 = qp.metrics.calculate_kld(P, H, limits=(-1.,1.), vb=True)\n", - "hD2 = qp.metrics.calculate_kld(P, H, limits=(-2.,2.), vb=True)\n", - "hD3 = qp.metrics.calculate_kld(P, H, limits=(-3.,3.), vb=True)\n", - "print 'Histogram approximation: KLD over 1,2,3 sigma ranges = ', hD1, hD2, hD3\n", - "sD1 = qp.metrics.calculate_kld(P, S, limits=(-1.,1.), vb=True)\n", - "sD2 = qp.metrics.calculate_kld(P, S, limits=(-2.,2.), vb=True)\n", - "sD3 = qp.metrics.calculate_kld(P, S, limits=(-3.,3.), vb=True)\n", - "print 'Sampled approximation: KLD over 1,2,3 sigma ranges = ', sD1, sD2, sD3" + "for PDF in [Q, H, S]:\n", + " D = []\n", + " for lims in all_lims:\n", + " D.append(qp.metrics.calculate_kld(P, PDF, limits=lims, vb=False))\n", + " print(PDF.truth+' approximation: KLD over 1, 2, 3, sigma ranges = '+str(D))" ] }, { @@ -383,21 +398,11 @@ }, "outputs": [], "source": [ - "qRMSE1 = qp.metrics.calculate_rmse(P, Q, limits=(-1.,1.), vb=False)\n", - "qRMSE2 = qp.metrics.calculate_rmse(P, Q, limits=(-2.,2.), vb=False)\n", - "qRMSE3 = qp.metrics.calculate_rmse(P, Q, limits=(-3.,3.), vb=False)\n", - "\n", - "hRMSE1 = qp.metrics.calculate_rmse(P, H, limits=(-1.,1.), vb=False)\n", - "hRMSE2 = qp.metrics.calculate_rmse(P, H, limits=(-2.,2.), vb=False)\n", - "hRMSE3 = qp.metrics.calculate_rmse(P, H, limits=(-3.,3.), vb=False)\n", - "\n", - "sRMSE1 = qp.metrics.calculate_rmse(P, S, limits=(-1.,1.), vb=False)\n", - "sRMSE2 = qp.metrics.calculate_rmse(P, S, limits=(-2.,2.), vb=False)\n", - "sRMSE3 = qp.metrics.calculate_rmse(P, S, limits=(-3.,3.), vb=False)\n", - "\n", - "print 'Quantile approximation: RMSE over 1,2,3 sigma ranges = ', qRMSE1, qRMSE2, qRMSE3\n", - "print 'Histogram approximation: RMSE over 1,2,3 sigma ranges = ', hRMSE1, hRMSE2, hRMSE3\n", - "print 'Sampled approximation: RMSE over 1,2,3 sigma ranges = ', sRMSE1, sRMSE2, sRMSE3" + "for PDF in [Q, H, S]:\n", + " D = []\n", + " for lims in all_lims:\n", + " D.append(qp.metrics.calculate_rmse(P, PDF, limits=lims, vb=False))\n", + " print(PDF.truth+' approximation: RMSE over 1, 2, 3, sigma ranges = '+str(D))" ] }, { @@ -476,7 +481,7 @@ "composite_lims = (-5., 5.)\n", "\n", "C_dist = qp.composite(dist_info)\n", - "C = qp.PDF(truth=C_dist, limits=composite_lims)\n", + "C = qp.PDF(funcform=C_dist, limits=composite_lims)\n", "C.plot()" ] }, @@ -493,7 +498,7 @@ "metadata": {}, "outputs": [], "source": [ - "Cq = qp.PDF(truth=C_dist, limits = composite_lims)\n", + "Cq = qp.PDF(funcform=C_dist, limits = composite_lims)\n", "Cq.quantize(N=20, limits=composite_lims, vb=False)\n", "Cq.plot()" ] @@ -511,7 +516,7 @@ "metadata": {}, "outputs": [], "source": [ - "Ch = qp.PDF(truth=C_dist, limits = composite_lims)\n", + "Ch = qp.PDF(funcform=C_dist, limits = composite_lims)\n", "Ch.histogramize(N=20, binrange=composite_lims, vb=True)\n", "Ch.plot()" ] @@ -520,7 +525,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Finally, samples from this distribution may also be taken, and a PDF may be reconstructed from them. Note: this uses `scipy.stats.gaussian_kde`, which determines its bandwidth/kernel size using [Scott's Rule](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.gaussian_kde.html), which clearly leaves something to be desired! " + "Finally, samples from this distribution may also be taken, and a PDF may be reconstructed from them. Note: this uses [`scipy.stats.gaussian_kde`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.gaussian_kde.html), which determines its bandwidth/kernel size using Scott's Rule, Silverman's Rule, a fixed bandwidth, or a callable function that returns a bandwidth." ] }, { @@ -529,8 +534,8 @@ "metadata": {}, "outputs": [], "source": [ - "Cs = qp.PDF(truth=C_dist, limits = composite_lims)\n", - "Cs.sample(N=20, using='truth', vb=False)\n", + "Cs = qp.PDF(funcform=C_dist, limits = composite_lims)\n", + "Cs.sample(N=20, using='mix_mod', vb=False)\n", "Cs.plot()" ] }, @@ -552,9 +557,73 @@ "collapsed": true }, "source": [ - "PDF Ensembles" + "### PDF Ensembles" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "N = 10\n", + "in_dists = []\n", + "for i in range(N):\n", + " dist = sps.norm(loc=sps.uniform.rvs(), scale=sps.uniform.rvs())\n", + " in_dists.append(dist)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "E = qp.Ensemble(N, funcform=in_dists, vb=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "eval_range = np.linspace(-5., 5., 100)\n", + "E.evaluate(eval_range, using='mix_mod', vb=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "E.quantize(N=10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "E.integrate(demo_limits, using='mix_mod')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Scratch" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, diff --git a/qp/__init__.py b/qp/__init__.py index d6a7bc7e..60cb3a38 100644 --- a/qp/__init__.py +++ b/qp/__init__.py @@ -1,5 +1,6 @@ -from pdf import * from composite import * from ensemble import * -from utils import * from metrics import * +# from parametrization import * +from pdf import * +from utils import * diff --git a/qp/ensemble.py b/qp/ensemble.py index 2846c5a6..e4923029 100644 --- a/qp/ensemble.py +++ b/qp/ensemble.py @@ -17,7 +17,7 @@ class Ensemble(object): - def __init__(self, N, truth=None, quantiles=None, histogram=None, gridded=None, samples=None, limits=None, scheme='linear', vb=True, procs=None):# where='ensemble.db', procs=None):# + def __init__(self, N, funcform=None, quantiles=None, histogram=None, gridded=None, samples=None, limits=None, scheme='linear', vb=True, procs=None):# where='ensemble.db', procs=None):# """ Creates an object comprised of many qp.PDF objects to efficiently perform operations on all of them @@ -26,8 +26,7 @@ def __init__(self, N, truth=None, quantiles=None, histogram=None, gridded=None, ---------- N: int number of pdfs in the ensemble - truth: list of scipy.stats.rv_continuous objects or qp.composite objects - , optional + funcform: list of scipy.stats.rv_continuous objects or qp.composite objects, optional List of length (npdfs) containing the continuous, parametric forms of the PDFs quantiles: tuple of ndarrays, optional Pair of arrays of lengths (nquants) and (npdfs, nquants) containing @@ -75,7 +74,7 @@ def __init__(self, N, truth=None, quantiles=None, histogram=None, gridded=None, self.n_pdfs = N self.pdf_range = range(N) - if truth is None and quantiles is None and histogram is None and gridded is None and samples is None: + if funcform is None and quantiles is None and histogram is None and gridded is None and samples is None: print 'Warning: initializing an Ensemble object without inputs' return @@ -84,10 +83,10 @@ def __init__(self, N, truth=None, quantiles=None, histogram=None, gridded=None, else: self.limits = limits - if truth is None: - self.truth = [None] * N + if funcform is None: + self.mix_mod = [None] * N else: - self.truth = truth + self.mix_mod = funcform if samples is None: self.samples = [None] * N else: @@ -104,7 +103,7 @@ def __init__(self, N, truth=None, quantiles=None, histogram=None, gridded=None, self.gridded = (None, [None] * N) else: self.gridded = (None, [(gridded[0], gridded[1][i]) for i in self.pdf_range]) - self.mix_mod = None + # self.mix_mod = None self.evaluated = None self.scheme = scheme @@ -121,7 +120,8 @@ def make_pdfs(self): def make_pdfs_helper(i): # with open(self.logfilename, 'wb') as logfile: # logfile.write('making pdf '+str(i)+'\n') - return qp.PDF(truth=self.truth[i], quantiles=self.quantiles[i], + return qp.PDF( funcform=self.mix_mod[i], + quantiles=self.quantiles[i], histogram=self.histogram[i], gridded=self.gridded[-1][i], samples=self.samples[i], limits=self.limits, scheme=self.scheme, vb=False) @@ -275,7 +275,7 @@ def mixmod_helper(i): return self.mix_mod - def evaluate(self, loc, using=None, norm=False, vb=True): + def evaluate(self, loc, using=None, norm=False, vb=False): """ Evaluates all PDFs @@ -327,6 +327,8 @@ def integrate(self, limits, using, dx=0.001): integral: numpy.ndarray, float value of the integral """ + if len(np.shape(limits)) == 1: + limits = [limits] * self.n_pdfs def integrate_helper(i): try: return self.pdfs[i].integrate(limits[i], using=using, dx=dx, vb=False) diff --git a/qp/pdf.py b/qp/pdf.py index 38a67e25..c02987b8 100644 --- a/qp/pdf.py +++ b/qp/pdf.py @@ -25,7 +25,8 @@ class PDF(object): - def __init__(self, truth=None, quantiles=None, histogram=None, + def __init__(self, funcform=None, + quantiles=None, histogram=None, gridded=None, samples=None, limits=default_lims, scheme='linear', vb=True): """ @@ -34,8 +35,8 @@ def __init__(self, truth=None, quantiles=None, histogram=None, Parameters ---------- - truth: scipy.stats.rv_continuous object or qp.composite object, optional - Continuous, parametric form of the PDF + # truth: scipy.stats.rv_continuous object or qp.composite object, optional + # Continuous, parametric form of the PDF quantiles: tuple of ndarrays, optional Pair of arrays of lengths (nquants, nquants) containing CDF values and quantiles @@ -61,25 +62,28 @@ def __init__(self, truth=None, quantiles=None, histogram=None, TO DO: change dx --> dz (or delta) TO DO: consider changing quantiles input to just be the z-values since interpolation gives the p(z) values anyway """ - self.truth = truth + # self.truth = truth self.quantiles = quantiles self.histogram = qp.utils.normalize_histogram(histogram, vb=vb) self.samples = samples self.gridded = qp.utils.normalize_integral(qp.utils.normalize_gridded(gridded)) - self.mix_mod = None + self.mix_mod = funcform + self.mixmod = self.mix_mod self.limits = limits - self.scheme = scheme + self.interpolator = [None, None] + if vb: print('interpolator set to '+str(self.interpolator)) - if vb and self.truth is None and self.quantiles is None and self.histogram is None and self.gridded is None and self.samples is None: - print 'Warning: initializing a PDF object without inputs' - return + # if vb and self.quantiles is None and self.histogram is None and self.gridded is None and self.samples is None:# and self.truth is None: + # print 'Warning: initializing a PDF object without inputs' + # return # Record how the PDF object was initialized: - if self.truth is not None: - self.initialized = self.truth - self.first = 'truth' + if self.mix_mod is not None: + self.initialized = self.mix_mod + self.first = 'mix_mod' elif self.gridded is not None: + # if self.gridded is not None: self.initialized = self.gridded self.first = 'gridded' self.limits = (min(self.limits[0], np.min(self.gridded[0])), max(self.limits[-1], np.max(self.gridded[0]))) @@ -95,12 +99,15 @@ def __init__(self, truth=None, quantiles=None, histogram=None, self.initialized = self.quantiles self.first = 'quantiles' self.limits = (min(self.limits[0], np.min(self.quantiles[-1])), max(self.limits[-1], np.max(self.quantiles[-1]))) + else: + print 'Warning: initializing a PDF object without inputs' + return # The most recent parametrization used is, at this point, the # first one: + self.truth = self.first self.last = self.first - self.interpolator = [None, None] - self.klds = {} + # self.klds = {} return @@ -127,16 +134,16 @@ def evaluate(self, loc, using=None, norm=False, vb=True): the input locations and the value of the PDF (or its approximation) at the requested location(s) """ if using is None: - using = self.first + using = self.last - if using == 'truth': - if self.truth is not None: - if vb: print 'Evaluating the true distribution.' - val = self.truth.pdf(loc) - self.evaluated = (loc, val) - else: - raise ValueError('true PDF is not set, use an approximation instead (the most recent one was '+self.last+')') - elif using == 'mix_mod': + # if using == 'truth': + # if self.truth is not None: + # if vb: print 'Evaluating the true distribution.' + # val = self.truth.pdf(loc) + # self.evaluated = (loc, val) + # else: + # raise ValueError('true PDF is not set, use an approximation instead (the most recent one was '+self.last+')') + if using == 'mix_mod': if self.mix_mod is None: self.mix_mod = self.mix_mod_fit(vb=vb) if vb: print 'Evaluating the fitted mixture model distribution.' @@ -230,8 +237,8 @@ def quantize(self, quants=None, N=9, limits=None, vb=True): if limits is None: limits = self.limits - if self.truth is not None: - if isinstance(self.truth, qp.composite): + if self.mixmod is not None: + if isinstance(self.mixmod, qp.composite): if type(self.scheme) != int: order = 5 else: @@ -241,13 +248,13 @@ def quantize(self, quants=None, N=9, limits=None, vb=True): min_delta = np.min(extrapoints[1:] - extrapoints[:-1]) grid = np.linspace(limits[0], limits[-1], N + 1) - icdf = self.truth.cdf(grid) + icdf = self.mixmod.cdf(grid) unit_ext = 1. / (order + 1.) low_extended = 0 while icdf[0] >= quantpoints[0]: low_extended += 1 subgrid = np.linspace(limits[0] - 1., limits[0] - unit_ext, order) - subcdf = self.truth.cdf(subgrid) + subcdf = self.mixmod.cdf(subgrid) grid = np.concatenate((subgrid, grid)) icdf = np.concatenate((subcdf, icdf)) limits = (limits[0] - 1., limits[-1]) @@ -257,7 +264,7 @@ def quantize(self, quants=None, N=9, limits=None, vb=True): while icdf[-1] <= quantpoints[-1]: high_extended += 1 subgrid = np.linspace(limits[-1] + unit_ext, limits[-1] + 1., order) - subcdf = self.truth.cdf(subgrid) + subcdf = self.mixmod.cdf(subgrid) grid = np.concatenate((grid, subgrid)) icdf = np.concatenate((icdf, subcdf)) limits = (limits[0], limits[-1] + 1.) @@ -273,7 +280,7 @@ def quantize(self, quants=None, N=9, limits=None, vb=True): delta_i = new_deltas[i] / (order + 1.) subgrid = np.linspace(grid[i] + delta_i, grid[i+1] - delta_i, order) grid = np.sort(np.insert(grid, i, subgrid)) - subcdf = self.truth.cdf(subgrid) + subcdf = self.mixmod.cdf(subgrid) icdf = np.sort(np.insert(icdf, i, subcdf)) new_deltas = icdf[1:] - icdf[:-1] if vb: @@ -302,13 +309,13 @@ def quantize(self, quants=None, N=9, limits=None, vb=True): except AssertionError: print('ERROR: splines failed because '+str(AssertionError)+', defaulting to optimization for '+str((icdf, grid))) locs = np.array([bisect.bisect_right(icdf[:-1], quantpoints[n]) for n in range(N)]) - quantiles = self.truth.ppf(quantpoints, ivals=grid[locs]) + quantiles = self.mixmod.ppf(quantpoints, ivals=grid[locs]) assert(not np.any(np.isnan(quantiles))) except Exception, e: print('ERROR in `scipy.interpolate.InterpolatedUnivariateSpline`') if vb: print('output quantiles = '+str(quantiles)) else: - quantiles = self.truth.ppf(quantpoints) + quantiles = self.mixmod.ppf(quantpoints) else: print('New quantiles can only be computed from a truth distribution in this version.') return @@ -363,14 +370,14 @@ def histogramize(self, binends=None, N=10, binrange=None, vb=True): histogram = np.zeros(N) if vb: print 'Calculating histogram: ', binends - if self.truth is not None: - cdf = self.truth.cdf(binends) + if self.mixmod is not None: + cdf = self.mixmod.cdf(binends) heights = cdf[1:] - cdf[:-1] histogram = qp.utils.normalize_histogram((binends, heights), vb=vb) # for b in range(N): # histogram[b] = (cdf[b+1]-cdf[b])/(binends[b+1]-binends[b]) else: - print 'New histograms can only be computed from a truth distribution in this version.' + print 'New histograms can only be computed from a mixmod format in this version.' return if vb: print 'Result: ', histogram @@ -491,9 +498,9 @@ def sample(self, N=1000, infty=default_infty, using=None, vb=True): if vb: print 'Sampling from '+using+' parametrization.' - if using == 'truth': - samples = self.truth.rvs(size=N) - elif using == 'mix_mod': + # if using == 'truth': + # samples = self.truth.rvs(size=N) + if using == 'mix_mod': samples = self.mix_mod.rvs(size=N) elif using == 'gridded': @@ -573,8 +580,9 @@ def interpolate(self, using=None, vb=True): using = self.last if using == 'truth' or using == 'mix_mod': + interpolator = self.mix_mod.pdf print 'A functional form needs no interpolation. Try converting to an approximate parametrization first.' - return + # return if using == 'quantiles': # First find the quantiles if none exist: @@ -848,12 +856,12 @@ def plot(self, limits=None, loc='plot.pdf', vb=True): styles['samples'] = '-.'#(0,(1,2)) x = np.linspace(self.limits[0], self.limits[-1], 100) - if self.truth is not None: - [min_x, max_x] = [self.truth.ppf(np.array([0.001])), self.truth.ppf(np.array([0.999]))] + if self.mixmod is not None: + [min_x, max_x] = [self.mixmod.ppf(np.array([0.001])), self.mixmod.ppf(np.array([0.999]))] extrema = [min(extrema[0], min_x), max(extrema[1], max_x)] [min_x, max_x] = extrema x = np.linspace(min_x, max_x, 100) - y = self.truth.pdf(x) + y = self.mixmod.pdf(x) plt.plot(x, y, color=colors['truth'], linestyle=styles['truth'], lw=5.0, alpha=0.25, label='True PDF') if vb: print 'Plotted truth.' @@ -935,76 +943,76 @@ def plot(self, limits=None, loc='plot.pdf', vb=True): return - def kld(self, using=None, limits=None, dx=0.01): - """ - Calculates Kullback-Leibler divergence of quantile approximation from truth. - - Parameters - ---------- - using: string - parametrization to use - limits: tuple of floats, optional - endpoints of integration interval in which to calculate KLD - dx: float - resolution of integration grid - - Returns - ------- - KL: float - value of Kullback-Leibler divergence from approximation to truth - if truth is available; otherwise nothing. - - Notes - ----- - Example:: - d = p.kld(limits=(-1., 1.), dx=1./100)) - """ - print('This function is deprecated; use `qp.utils.calculate_kld`.') - return - # print('This function is deprecated; use `qp.utils.calculate_kl_divergence`.') - # return - # if self.truth is None: - # print('Truth not available for comparison.') - # return - # else: - # if using is None: - # using = self.last - # if limits is None: - # limits = self.limits - # D = int((limits[-1] - limits[0]) / dx) - # grid = np.linspace(limits[0], limits[1], D) - # KL = qp.utils.quick_kl_divergence(self.evaluate(grid, using='truth'), self.evaluate(grid, using=using), dx=dx) - # self.klds[using] = KL - # return(KL) - - def rmse(self, limits=(0., 1.), dx=0.01): - """ - Calculates root mean square difference between quantile approximation - and truth. - - Parameters - ---------- - limits: tuple of floats - endpoints of integration interval in which to calculate KLD - dx: float - resolution of integration grid - - Returns - ------- - RMS: float - value of root mean square difference between approximation of truth - if truth is available; otherwise nothing. - - Notes - ----- - Example:: - d = p.rms(limits=(-1., 1.), dx=1./100)) - """ - print('This function is deprecated; use `qp.utils.calculate_rmse`.') - return - # if self.truth is None: - # print('Truth not available for comparison.') - # return - # else: - # RMS = qp.utils.calculate_rms(self, self, limits=limits, dx=dx) - # return(RMS) + # def kld(self, using=None, limits=None, dx=0.01): + # """ + # Calculates Kullback-Leibler divergence of quantile approximation from truth. + # + # Parameters + # ---------- + # using: string + # parametrization to use + # limits: tuple of floats, optional + # endpoints of integration interval in which to calculate KLD + # dx: float + # resolution of integration grid + # + # Returns + # ------- + # KL: float + # value of Kullback-Leibler divergence from approximation to truth + # if truth is available; otherwise nothing. + # + # Notes + # ----- + # Example:: + # d = p.kld(limits=(-1., 1.), dx=1./100)) + # """ + # print('This function is deprecated; use `qp.utils.calculate_kld`.') + # return + # # print('This function is deprecated; use `qp.utils.calculate_kl_divergence`.') + # # return + # # if self.truth is None: + # # print('Truth not available for comparison.') + # # return + # # else: + # # if using is None: + # # using = self.last + # # if limits is None: + # # limits = self.limits + # # D = int((limits[-1] - limits[0]) / dx) + # # grid = np.linspace(limits[0], limits[1], D) + # # KL = qp.utils.quick_kl_divergence(self.evaluate(grid, using='truth'), self.evaluate(grid, using=using), dx=dx) + # # self.klds[using] = KL + # # return(KL) + # + # def rmse(self, limits=(0., 1.), dx=0.01): + # """ + # Calculates root mean square difference between quantile approximation + # and truth. + # + # Parameters + # ---------- + # limits: tuple of floats + # endpoints of integration interval in which to calculate KLD + # dx: float + # resolution of integration grid + # + # Returns + # ------- + # RMS: float + # value of root mean square difference between approximation of truth + # if truth is available; otherwise nothing. + # + # Notes + # ----- + # Example:: + # d = p.rms(limits=(-1., 1.), dx=1./100)) + # """ + # print('This function is deprecated; use `qp.utils.calculate_rmse`.') + # return + # # if self.truth is None: + # # print('Truth not available for comparison.') + # # return + # # else: + # # RMS = qp.utils.calculate_rms(self, self, limits=limits, dx=dx) + # # return(RMS) From f1c5fddc1fd16c5bf1edf422787ad9c425fc25fb Mon Sep 17 00:00:00 2001 From: Alex Malz Date: Thu, 28 Dec 2017 16:52:37 -0500 Subject: [PATCH 4/7] forgot to update the other demo --- docs/notebooks/kld.ipynb | 95 +++++++++++++++++++++++++++++++++------- qp/pdf.py | 2 +- 2 files changed, 80 insertions(+), 17 deletions(-) diff --git a/docs/notebooks/kld.ipynb b/docs/notebooks/kld.ipynb index 5c0fe98c..f67c1bbb 100644 --- a/docs/notebooks/kld.ipynb +++ b/docs/notebooks/kld.ipynb @@ -47,9 +47,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/aimalz/.local/lib/python2.7/site-packages/matplotlib/__init__.py:1401: UserWarning: This call to matplotlib.use() has no effect\n", + "because the backend has already been chosen;\n", + "matplotlib.use() must be called *before* pylab, matplotlib.pyplot,\n", + "or matplotlib.backends is imported for the first time.\n", + "\n", + " warnings.warn(_use_error_msg)\n" + ] + } + ], "source": [ "import matplotlib\n", "matplotlib.use('TkAgg')\n", @@ -64,28 +77,52 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "interpolator set to [None, None]\n" + ] + } + ], "source": [ - "P = qp.PDF(truth=sps.norm(loc=0.0, scale=1.0))" + "P = qp.PDF(funcform=sps.norm(loc=0.0, scale=1.0))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "interpolator set to [None, None]\n" + ] + } + ], "source": [ "x, sigma = 2.0, 1.0\n", - "Q = qp.PDF(truth=sps.norm(loc=x, scale=sigma))" + "Q = qp.PDF(funcform=sps.norm(loc=x, scale=sigma))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.99999999989\n" + ] + } + ], "source": [ "infinity = 100.0\n", "D = qp.metrics.calculate_kld(P, Q, limits=(-infinity,infinity), vb=False)\n", @@ -112,10 +149,19 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "interpolator set to [None, None]\n", + "1.00094526906\n" + ] + } + ], "source": [ "x, sigma = 0.0, 4.37\n", - "Q = qp.PDF(truth=sps.norm(loc=x, scale=sigma))\n", + "Q = qp.PDF(funcform=sps.norm(loc=x, scale=sigma))\n", "D = qp.metrics.calculate_kld(P, Q, limits=(-infinity,infinity), vb=False)\n", "print D" ] @@ -204,7 +250,24 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "interpolator set to [None, None]\n", + "interpolator set to [None, None]\n", + "interpolator set to [None, None]\n", + "interpolator set to [None, None]\n", + "interpolator set to [None, None]\n", + "interpolator set to [None, None]\n", + "interpolator set to [None, None]\n", + "interpolator set to [None, None]\n", + "interpolator set to [None, None]\n", + "interpolator set to [None, None]\n" + ] + } + ], "source": [ "widths = np.logspace(-2.0,2.0,13)\n", "D = np.empty_like(widths)\n", @@ -214,7 +277,7 @@ "infinity = 1000.0\n", "\n", "for k,sigma in enumerate(widths):\n", - " Q = qp.PDF(truth=sps.norm(loc=x, scale=sigma))\n", + " Q = qp.PDF(funcform=sps.norm(loc=x, scale=sigma))\n", " D[k] = qp.metrics.calculate_kld(P, Q, limits=(-infinity,infinity), vb=False)\n", " E[k] = qp.metrics.calculate_rmse(P, Q, limits=(-infinity,infinity), vb=False)\n", "print zip(widths, D)" @@ -294,7 +357,7 @@ "infinity = 100.0\n", "\n", "for k,x0 in enumerate(separations):\n", - " Q = qp.PDF(truth=sps.norm(loc=x0, scale=sigma))\n", + " Q = qp.PDF(funcform=sps.norm(loc=x0, scale=sigma))\n", " D[k] = qp.metrics.calculate_kld(P, Q, limits=(-infinity,infinity), vb=False)\n", " E[k] = qp.metrics.calculate_rmse(P, Q, limits=(-infinity,infinity), vb=False)\n", "print zip(separations, D)" @@ -371,7 +434,7 @@ "for j,sigma in enumerate(widths):\n", " \n", " for k,x0 in enumerate(separations):\n", - " Q = qp.PDF(truth=sps.norm(loc=x0, scale=sigma))\n", + " Q = qp.PDF(funcform=sps.norm(loc=x0, scale=sigma))\n", " D[j,k] = qp.metrics.calculate_kld(P, Q, limits=(-infinity,infinity), vb=False)\n", " E[j,k] = qp.metrics.calculate_rmse(P, Q, limits=(-infinity,infinity), vb=False)\n", " tensions[j,k] = x0 / np.sqrt(sigma*sigma + 1.0)\n", diff --git a/qp/pdf.py b/qp/pdf.py index c02987b8..63dfda68 100644 --- a/qp/pdf.py +++ b/qp/pdf.py @@ -72,7 +72,7 @@ def __init__(self, funcform=None, self.limits = limits self.scheme = scheme self.interpolator = [None, None] - if vb: print('interpolator set to '+str(self.interpolator)) + # if vb: print('interpolator set to '+str(self.interpolator)) # if vb and self.quantiles is None and self.histogram is None and self.gridded is None and self.samples is None:# and self.truth is None: # print 'Warning: initializing a PDF object without inputs' From 8ed510e758fc1eb947309faf719b21a473ef872b Mon Sep 17 00:00:00 2001 From: Alex Malz Date: Thu, 28 Dec 2017 17:33:36 -0500 Subject: [PATCH 5/7] removed stacking from qp --- docs/notebooks/demo.ipynb | 1205 ++++++++++++++++++++++++++++++++++++- qp/ensemble.py | 68 +-- 2 files changed, 1238 insertions(+), 35 deletions(-) diff --git a/docs/notebooks/demo.ipynb b/docs/notebooks/demo.ipynb index 406e552f..724a286b 100644 --- a/docs/notebooks/demo.ipynb +++ b/docs/notebooks/demo.ipynb @@ -577,7 +577,1128 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.78202054, 0.81910725, 0.84584937, 0.86869953, 0.89005703,\n", + " 0.91141452, 0.93426468, 0.9610068 , 0.99809351]))\n", + "input quantiles are [ 0.78202054 0.81910725 0.84584937 0.86869953 0.89005703 0.91141452\n", + " 0.93426468 0.9610068 0.99809351]\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "complete evaluated quantile PDF: (array([ 0.70784713, 0.78202054, 0.81910725, 0.81910725, 0.84584937,\n", + " 0.84584937, 0.86869953, 0.86869953, 0.89005703, 0.89005703,\n", + " 0.91141452, 0.91141452, 0.93426468, 0.93426468, 0.9610068 ,\n", + " 0.9610068 , 0.99809351, 1.07226692]), array([ 2.22044605e-16, 2.69638403e+00, 2.69638403e+00,\n", + " 3.73941878e+00, 3.73941878e+00, 4.37633721e+00,\n", + " 4.37633721e+00, 4.68219730e+00, 4.68219730e+00,\n", + " 4.68219730e+00, 4.68219730e+00, 4.37633721e+00,\n", + " 4.37633721e+00, 3.73941878e+00, 3.73941878e+00,\n", + " 2.69638403e+00, 2.69638403e+00, 2.22044605e-16]))\n", + "order is 5\n", + "divided into (array([57]), array([58, 59]), array([60]))\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "evaluated inside (array([ 0.85858586, 0.95959596]), array([ 4.4138218, 3.3677309]))\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.2966362 , 0.08228443, 0.35551287, 0.58897649, 0.80718932,\n", + " 1.02540215, 1.25886577, 1.5320942 , 1.91101483]))evaluated below (array([ 0.75757576]), array([ 1.39751068]))\n", + "\n", + "evaluated above (array([ 1.06060606]), array([ 0.32770206]))\n", + "input quantiles are [-0.2966362 0.08228443 0.35551287 0.58897649 0.80718932 1.02540215\n", + " 1.25886577 1.5320942 1.91101483]\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "complete evaluated quantile PDF: (array([-1.05447745, -0.2966362 , 0.08228443, 0.08228443, 0.35551287,\n", + " 0.35551287, 0.58897649, 0.58897649, 0.80718932, 0.80718932,\n", + " 1.02540215, 1.02540215, 1.25886577, 1.25886577, 1.5320942 ,\n", + " 1.5320942 , 1.91101483, 2.66885609]), array([ 2.22044605e-16, 2.63907511e-01, 2.63907511e-01,\n", + " 3.65994121e-01, 3.65994121e-01, 4.28332258e-01,\n", + " 4.28332258e-01, 4.58268192e-01, 4.58268192e-01,\n", + " 4.58268192e-01, 4.58268192e-01, 4.28332258e-01,\n", + " 4.28332258e-01, 3.65994121e-01, 3.65994121e-01,\n", + " 2.63907511e-01, 2.63907511e-01, 2.22044605e-16]))\n", + "order is 5\n", + "divided into (array([40, 41, 42, 43, 44, 45, 46]), array([47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,\n", + " 64, 65, 66, 67, 68]), array([69, 70, 71, 72, 73, 74, 75]))\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "evaluated inside (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", + " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", + " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", + " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667,\n", + " 1.76767677, 1.86868687]), array([ 0.21737113, 0.24923911, 0.2820813 , 0.31489295, 0.34667479,\n", + " 0.37643304, 0.40317944, 0.42593824, 0.44382821, 0.45614871,\n", + " 0.46240587, 0.46234979, 0.45598269, 0.44355893, 0.42557638,\n", + " 0.40273907, 0.37593098, 0.34612842, 0.31431978, 0.28149891,\n", + " 0.24866518, 0.21682346]))\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.160167 , 0.38573089, 0.54837833, 0.68735456, 0.81725231,\n", + " 0.94715006, 1.0861263 , 1.24877373, 1.47433762]))evaluated below (array([-0.95959596, -0.85858586, -0.75757576, -0.65656566, -0.55555556,\n", + " -0.45454545, -0.35353535]), array([ 0.0255429 , 0.05273567, 0.07992845, 0.10712122, 0.13431399,\n", + " 0.16150677, 0.18869954]))\n", + "\n", + "input quantiles are [ 0.160167 0.38573089 0.54837833 0.68735456 0.81725231 0.94715006\n", + " 1.0861263 1.24877373 1.47433762]evaluated above (array([ 1.96969697, 2.07070707, 2.17171717, 2.27272727, 2.37373737,\n", + " 2.47474747, 2.57575758]), array([ 0.18821955, 0.16102677, 0.133834 , 0.10664123, 0.07944845,\n", + " 0.05225568, 0.02506291]))\n", + "\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "complete evaluated quantile PDF: (array([-0.29096079, 0.160167 , 0.38573089, 0.38573089, 0.54837833,\n", + " 0.54837833, 0.68735456, 0.68735456, 0.81725231, 0.81725231,\n", + " 0.94715006, 0.94715006, 1.0861263 , 1.0861263 , 1.24877373,\n", + " 1.24877373, 1.47433762, 1.92546541]), array([ 2.22044605e-16, 4.43333367e-01, 4.43333367e-01,\n", + " 6.14826782e-01, 6.14826782e-01, 7.19547470e-01,\n", + " 7.19547470e-01, 7.69836295e-01, 7.69836295e-01,\n", + " 7.69836295e-01, 7.69836295e-01, 7.19547470e-01,\n", + " 7.19547470e-01, 6.14826782e-01, 6.14826782e-01,\n", + " 4.43333367e-01, 4.43333367e-01, 2.22044605e-16]))\n", + "order is 5\n", + "divided into (array([47, 48, 49, 50, 51]), array([52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64]), array([65, 66, 67, 68]))\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "evaluated inside (array([ 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", + " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", + " 1.26262626, 1.36363636, 1.46464646]), array([ 0.42412498, 0.51690141, 0.60584365, 0.68304285, 0.74079776,\n", + " 0.77282717, 0.77555359, 0.74867101, 0.69518996, 0.62096562,\n", + " 0.53357031, 0.44089914, 0.35092118]))input quantiles are [-0.83837651 -0.40009051 -0.08405547 0.18598482 0.43838498 0.69078514\n", + " 0.96082543 1.27686047 1.71514647]\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.83837651, -0.40009051, -0.08405547, 0.18598482, 0.43838498,\n", + " 0.69078514, 0.96082543, 1.27686047, 1.71514647]))evaluated below (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515]), array([ 0.02919974, 0.1059378 , 0.18267587, 0.25941393, 0.336152 ]))\n", + "\n", + "evaluated above (array([ 1.56565657, 1.66666667, 1.76767677, 1.86868687]), array([ 0.27334924, 0.19661117, 0.11987311, 0.04313505]))\n", + "\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "complete evaluated quantile PDF: (array([-1.71494851, -0.83837651, -0.40009051, -0.40009051, -0.08405547,\n", + " -0.08405547, 0.18598482, 0.18598482, 0.43838498, 0.43838498,\n", + " 0.69078514, 0.69078514, 0.96082543, 0.96082543, 1.27686047,\n", + " 1.27686047, 1.71514647, 2.59171847]), array([ 2.22044605e-16, 2.28161521e-01, 2.28161521e-01,\n", + " 3.16420609e-01, 3.16420609e-01, 3.70315112e-01,\n", + " 3.70315112e-01, 3.96196256e-01, 3.96196256e-01,\n", + " 3.96196256e-01, 3.96196256e-01, 3.70315112e-01,\n", + " 3.70315112e-01, 3.16420609e-01, 3.16420609e-01,\n", + " 2.28161521e-01, 2.28161521e-01, 2.22044605e-16]))\n", + "order is 5\n", + "divided into (array([33, 34, 35, 36, 37, 38, 39, 40, 41]), array([42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,\n", + " 59, 60, 61, 62, 63, 64, 65, 66]), array([67, 68, 69, 70, 71, 72, 73, 74, 75]))\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.4716778 , -0.23109047, -0.05761009, 0.09062251, 0.22917195,\n", + " 0.36772139, 0.51595399, 0.68943438, 0.9300217 ]))evaluated inside (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", + " -0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", + " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", + " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", + " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667]), array([ 0.19482262, 0.21884383, 0.24341678, 0.26798028, 0.29197582,\n", + " 0.31484752, 0.33604216, 0.35500922, 0.37121226, 0.38418021,\n", + " 0.39353248, 0.39898817, 0.40038408, 0.3976788 , 0.39095271,\n", + " 0.38040776, 0.36635886, 0.34921595, 0.32947641, 0.30768512,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0.2843935 , 0.26015563, 0.2355282 , 0.21107062, 0.1873449 ]))\n", + "\n", + "input quantiles are [-0.4716778 -0.23109047 -0.05761009 0.09062251 0.22917195 0.36772139\n", + " 0.51595399 0.68943438 0.9300217 ]evaluated below (array([-1.66666667, -1.56565657, -1.46464646, -1.36363636, -1.26262626,\n", + " -1.16161616, -1.06060606, -0.95959596, -0.85858586]), array([ 0.00971525, 0.03004045, 0.05036565, 0.07069084, 0.09101604,\n", + " 0.11134124, 0.13166644, 0.15199164, 0.17231684]))\n", + "\n", + "evaluated above (array([ 1.76767677, 1.86868687, 1.96969697, 2.07070707, 2.17171717,\n", + " 2.27272727, 2.37373737, 2.47474747, 2.57575758]), array([ 0.16581324, 0.14548804, 0.12516284, 0.10483764, 0.08451244,\n", + " 0.06418724, 0.04386204, 0.02353684, 0.00321164]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "\n", + "complete evaluated quantile PDF: (array([-0.95285245, -0.4716778 , -0.23109047, -0.23109047, -0.05761009,\n", + " -0.05761009, 0.09062251, 0.09062251, 0.22917195, 0.22917195,\n", + " 0.36772139, 0.36772139, 0.51595399, 0.51595399, 0.68943438,\n", + " 0.68943438, 0.9300217 , 1.41119635]), array([ 2.22044605e-16, 4.15649494e-01, 4.15649494e-01,\n", + " 5.76434034e-01, 5.76434034e-01, 6.74615457e-01,\n", + " 6.74615457e-01, 7.21764005e-01, 7.21764005e-01,\n", + " 7.21764005e-01, 7.21764005e-01, 6.74615457e-01,\n", + " 6.74615457e-01, 5.76434034e-01, 5.76434034e-01,\n", + " 4.15649494e-01, 4.15649494e-01, 2.22044605e-16]))Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.22752249, 0.08081044, 0.30314018, 0.49311274, 0.67067553,\n", + " 0.84823831, 1.03821087, 1.26054061, 1.56887354]))\n", + "order is 5\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "divided into (array([41, 42, 43, 44]), array([45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58]), array([59, 60, 61, 62, 63]))\n", + "\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.63410249, -0.34639065, -0.13893017, 0.03833716, 0.20402467,\n", + " 0.36971217, 0.5469795 , 0.75443998, 1.04215182]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "input quantiles are [-0.22752249 0.08081044 0.30314018 0.49311274 0.67067553 0.84823831\n", + " 1.03821087 1.26054061 1.56887354]evaluated inside (array([-0.45454545, -0.35353535, -0.25252525, -0.15151515, -0.05050505,\n", + " 0.05050505, 0.15151515, 0.25252525, 0.35353535, 0.45454545,\n", + " 0.55555556, 0.65656566, 0.75757576, 0.85858586]), array([ 0.33411094, 0.41342215, 0.4949481 , 0.5725297 , 0.64006113,\n", + " 0.69158671, 0.72217601, 0.72882471, 0.71087657, 0.6701044 ,\n", + " 0.61047089, 0.53753679, 0.4573692 , 0.37609858]))input quantiles are [-0.63410249 -0.34639065 -0.13893017 0.03833716 0.20402467 0.36971217\n", + " 0.5469795 0.75443998 1.04215182]\n", + "\n", + "\n", + "\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "evaluated below (array([-0.85858586, -0.75757576, -0.65656566, -0.55555556]), array([ 0.06295026, 0.13040376, 0.19785727, 0.26531077]))\n", + "evaluated above (array([ 0.95959596, 1.06060606, 1.16161616, 1.26262626, 1.36363636]), array([ 0.30157409, 0.23412058, 0.16666708, 0.09921357, 0.03176007]))\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.75426818, 0.77627287, 0.7921398 , 0.8056975 , 0.81836957,\n", + " 0.83104163, 0.84459933, 0.86046626, 0.88247095]))\n", + "complete evaluated quantile PDF: (array([-0.84418835, -0.22752249, 0.08081044, 0.08081044, 0.30314018,\n", + " 0.30314018, 0.49311274, 0.49311274, 0.67067553, 0.67067553,\n", + " 0.84823831, 0.84823831, 1.03821087, 1.03821087, 1.26054061,\n", + " 1.26054061, 1.56887354, 2.1855394 ]), array([ 2.22044605e-16, 3.24324747e-01, 3.24324747e-01,\n", + " 4.49782389e-01, 4.49782389e-01, 5.26391805e-01,\n", + " 5.26391805e-01, 5.63181074e-01, 5.63181074e-01,\n", + " 5.63181074e-01, 5.63181074e-01, 5.26391805e-01,\n", + " 5.26391805e-01, 4.49782389e-01, 4.49782389e-01,\n", + " 3.24324747e-01, 3.24324747e-01, 2.22044605e-16]))input quantiles are [ 0.75426818 0.77627287 0.7921398 0.8056975 0.81836957 0.83104163\n", + " 0.84459933 0.86046626 0.88247095]complete evaluated quantile PDF: (array([-1.20952616, -0.63410249, -0.34639065, -0.34639065, -0.13893017,\n", + " -0.13893017, 0.03833716, 0.03833716, 0.20402467, 0.20402467,\n", + " 0.36971217, 0.36971217, 0.5469795 , 0.5469795 , 0.75443998,\n", + " 0.75443998, 1.04215182, 1.61757549]), array([ 2.22044605e-16, 3.47569988e-01, 3.47569988e-01,\n", + " 4.82019521e-01, 4.82019521e-01, 5.64119744e-01,\n", + " 5.64119744e-01, 6.03545800e-01, 6.03545800e-01,\n", + " 6.03545800e-01, 6.03545800e-01, 5.64119744e-01,\n", + " 5.64119744e-01, 4.82019521e-01, 4.82019521e-01,\n", + " 3.47569988e-01, 3.47569988e-01, 2.22044605e-16]))\n", + "\n", + "order is 5\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "\n", + "divided into (array([42, 43, 44, 45, 46, 47]), array([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,\n", + " 65]), array([66, 67, 68, 69, 70, 71]))complete evaluated quantile PDF: (array([ 0.7102588 , 0.75426818, 0.77627287, 0.77627287, 0.7921398 ,\n", + " 0.7921398 , 0.8056975 , 0.8056975 , 0.81836957, 0.81836957,\n", + " 0.83104163, 0.83104163, 0.84459933, 0.84459933, 0.86046626,\n", + " 0.86046626, 0.88247095, 0.92648033]), array([ 2.22044605e-16, 4.54448593e+00, 4.54448593e+00,\n", + " 6.30241681e+00, 6.30241681e+00, 7.37587919e+00,\n", + " 7.37587919e+00, 7.89137582e+00, 7.89137582e+00,\n", + " 7.89137582e+00, 7.89137582e+00, 7.37587919e+00,\n", + " 7.37587919e+00, 6.30241681e+00, 6.30241681e+00,\n", + " 4.54448593e+00, 4.54448593e+00, 2.22044605e-16]))order is 5\n", + "\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "divided into (array([38, 39, 40, 41, 42, 43]), array([44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59]), array([60, 61, 62, 63, 64, 65]))\n", + "\n", + "order is 5\n", + "evaluated inside (array([-0.15151515, -0.05050505, 0.05050505, 0.15151515, 0.25252525,\n", + " 0.35353535, 0.45454545, 0.55555556, 0.65656566, 0.75757576,\n", + " 0.85858586, 0.95959596, 1.06060606, 1.16161616, 1.26262626,\n", + " 1.36363636, 1.46464646, 1.56565657]), array([ 0.28602048, 0.3351863 , 0.38482262, 0.43264808, 0.4763967 ,\n", + " 0.51381924, 0.54278436, 0.56158655, 0.56909352, 0.56485326,\n", + " 0.54912047, 0.52284566, 0.48758443, 0.44537765, 0.39846372,\n", + " 0.34910432, 0.29957652, 0.25217281]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "divided into (array([], dtype=int64), array([57, 58]), array([], dtype=int64))\n", + "evaluated inside (array([-0.55555556, -0.45454545, -0.35353535, -0.25252525, -0.15151515,\n", + " -0.05050505, 0.05050505, 0.15151515, 0.25252525, 0.35353535,\n", + " 0.45454545, 0.55555556, 0.65656566, 0.75757576, 0.85858586,\n", + " 0.95959596]), array([ 0.31070451, 0.36735297, 0.42415121, 0.47809387, 0.52619741,\n", + " 0.56551778, 0.59343513, 0.60804399, 0.60833168, 0.59427839,\n", + " 0.56685819, 0.52794447, 0.48013393, 0.42636629, 0.36962427,\n", + " 0.31291232]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "\n", + "evaluated inside (array([ 0.75757576, 0.85858586]), array([ 3.81138379, 5.77321742]))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "\n", + "evaluated below (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", + " -0.25252525]), array([ 0.0352149 , 0.07628352, 0.11735215, 0.15842078, 0.1994894 ,\n", + " 0.24055803]))Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.87371033, 0.88669005, 0.89604935, 0.90404653, 0.91152129,\n", + " 0.91899606, 0.92699323, 0.93635253, 0.94933226]))evaluated below (array([-1.16161616, -1.06060606, -0.95959596, -0.85858586, -0.75757576,\n", + " -0.65656566]), array([ 0.02237154, 0.06953814, 0.11670474, 0.16387133, 0.21103793,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0.25820452]))evaluated below (array([], dtype=float64), array([], dtype=float64))\n", + "\n", + "evaluated above (array([], dtype=float64), array([], dtype=float64))\n", + "\n", + "\n", + "evaluated above (array([ 1.66666667, 1.76767677, 1.86868687, 1.96969697, 2.07070707,\n", + " 2.17171717]), array([ 0.21096297, 0.16989434, 0.12882571, 0.08775709, 0.04668846,\n", + " 0.00561984]))evaluated above (array([ 1.06060606, 1.16161616, 1.26262626, 1.36363636, 1.46464646,\n", + " 1.56565657]), array([ 0.26007649, 0.21290989, 0.1657433 , 0.1185767 , 0.0714101 ,\n", + " 0.02424351]))input quantiles are [ 0.87371033 0.88669005 0.89604935 0.90404653 0.91152129 0.91899606\n", + " 0.92699323 0.93635253 0.94933226]\n", + "\n", + "\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "complete evaluated quantile PDF: (array([ 0.84775087, 0.87371033, 0.88669005, 0.88669005, 0.89604935,\n", + " 0.89604935, 0.90404653, 0.90404653, 0.91152129, 0.91152129,\n", + " 0.91899606, 0.91899606, 0.92699323, 0.92699323, 0.93635253,\n", + " 0.93635253, 0.94933226, 0.97529172]), array([ 2.22044605e-16, 7.70432123e+00, 7.70432123e+00,\n", + " 1.06845624e+01, 1.06845624e+01, 1.25044160e+01,\n", + " 1.25044160e+01, 1.33783436e+01, 1.33783436e+01,\n", + " 1.33783436e+01, 1.33783436e+01, 1.25044160e+01,\n", + " 1.25044160e+01, 1.06845624e+01, 1.06845624e+01,\n", + " 7.70432123e+00, 7.70432123e+00, 2.22044605e-16]))\n", + "order is 5\n", + "divided into (array([58]), array([], dtype=int64), array([59]))\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "evaluated inside (array([], dtype=float64), array([], dtype=float64))\n", + "evaluated below (array([ 0.85858586]), array([ 2.48589346]))\n", + "evaluated above (array([ 0.95959596]), array([ 3.60110922]))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.33570561, 0.34266231, 0.34767858, 0.35196481, 0.35597103,\n", + " 0.35997726, 0.36426348, 0.36927975, 0.37623646]))\n", + "input quantiles are [ 0.33570561 0.34266231 0.34767858 0.35196481 0.35597103 0.35997726\n", + " 0.36426348 0.36927975 0.37623646]\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "complete evaluated quantile PDF: (array([ 0.3217922 , 0.33570561, 0.34266231, 0.34266231, 0.34767858,\n", + " 0.34767858, 0.35196481, 0.35196481, 0.35597103, 0.35597103,\n", + " 0.35997726, 0.35997726, 0.36426348, 0.36426348, 0.36927975,\n", + " 0.36927975, 0.37623646, 0.39014987]), array([ 2.22044605e-16, 1.43746220e+01, 1.43746220e+01,\n", + " 1.99351171e+01, 1.99351171e+01, 2.33305762e+01,\n", + " 2.33305762e+01, 2.49611389e+01, 2.49611389e+01,\n", + " 2.49611389e+01, 2.49611389e+01, 2.33305762e+01,\n", + " 2.33305762e+01, 1.99351171e+01, 1.99351171e+01,\n", + " 1.43746220e+01, 1.43746220e+01, 2.22044605e-16]))\n", + "order is 5\n", + "divided into (array([], dtype=int64), array([53]), array([], dtype=int64))\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "evaluated inside (array([ 0.35353535]), array([ 24.93098564]))\n", + "evaluated below (array([], dtype=float64), array([], dtype=float64))\n", + "evaluated above (array([], dtype=float64), array([], dtype=float64))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.78202054, 0.81910725, 0.84584937, 0.86869953, 0.89005703,\n", + " 0.91141452, 0.93426468, 0.9610068 , 0.99809351]))\n", + "input quantiles are [ 0.78202054 0.81910725 0.84584937 0.86869953 0.89005703 0.91141452\n", + " 0.93426468 0.9610068 0.99809351]\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "complete evaluated quantile PDF: (array([ 0.70784713, 0.78202054, 0.81910725, 0.81910725, 0.84584937,\n", + " 0.84584937, 0.86869953, 0.86869953, 0.89005703, 0.89005703,\n", + " 0.91141452, 0.91141452, 0.93426468, 0.93426468, 0.9610068 ,\n", + " 0.9610068 , 0.99809351, 1.07226692]), array([ 2.22044605e-16, 2.69638403e+00, 2.69638403e+00,\n", + " 3.73941878e+00, 3.73941878e+00, 4.37633721e+00,\n", + " 4.37633721e+00, 4.68219730e+00, 4.68219730e+00,\n", + " 4.68219730e+00, 4.68219730e+00, 4.37633721e+00,\n", + " 4.37633721e+00, 3.73941878e+00, 3.73941878e+00,\n", + " 2.69638403e+00, 2.69638403e+00, 2.22044605e-16]))order is 5\n", + "divided into (array([57]), array([58, 59]), array([60]))\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "evaluated inside (array([ 0.85858586, 0.95959596]), array([ 4.4138218, 3.3677309]))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "evaluated below (array([ 0.75757576]), array([ 1.39751068]))\n", + "\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.2966362 , 0.08228443, 0.35551287, 0.58897649, 0.80718932,\n", + " 1.02540215, 1.25886577, 1.5320942 , 1.91101483]))\n", + "evaluated above (array([ 1.06060606]), array([ 0.32770206]))\n", + "input quantiles are [-0.2966362 0.08228443 0.35551287 0.58897649 0.80718932 1.02540215\n", + " 1.25886577 1.5320942 1.91101483]input shape: (9, 8), output shape: (18, 18)\n", + "complete evaluated quantile PDF: (array([-1.05447745, -0.2966362 , 0.08228443, 0.08228443, 0.35551287,\n", + " 0.35551287, 0.58897649, 0.58897649, 0.80718932, 0.80718932,\n", + " 1.02540215, 1.02540215, 1.25886577, 1.25886577, 1.5320942 ,\n", + " 1.5320942 , 1.91101483, 2.66885609]), array([ 2.22044605e-16, 2.63907511e-01, 2.63907511e-01,\n", + " 3.65994121e-01, 3.65994121e-01, 4.28332258e-01,\n", + " 4.28332258e-01, 4.58268192e-01, 4.58268192e-01,\n", + " 4.58268192e-01, 4.58268192e-01, 4.28332258e-01,\n", + " 4.28332258e-01, 3.65994121e-01, 3.65994121e-01,\n", + " 2.63907511e-01, 2.63907511e-01, 2.22044605e-16]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "\n", + "order is 5\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.160167 , 0.38573089, 0.54837833, 0.68735456, 0.81725231,\n", + " 0.94715006, 1.0861263 , 1.24877373, 1.47433762]))divided into (array([40, 41, 42, 43, 44, 45, 46]), array([47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,\n", + " 64, 65, 66, 67, 68]), array([69, 70, 71, 72, 73, 74, 75]))\n", + "\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "evaluated inside (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", + " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", + " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", + " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667,\n", + " 1.76767677, 1.86868687]), array([ 0.21737113, 0.24923911, 0.2820813 , 0.31489295, 0.34667479,\n", + " 0.37643304, 0.40317944, 0.42593824, 0.44382821, 0.45614871,\n", + " 0.46240587, 0.46234979, 0.45598269, 0.44355893, 0.42557638,\n", + " 0.40273907, 0.37593098, 0.34612842, 0.31431978, 0.28149891,\n", + " 0.24866518, 0.21682346]))\n", + "evaluated below (array([-0.95959596, -0.85858586, -0.75757576, -0.65656566, -0.55555556,\n", + " -0.45454545, -0.35353535]), array([ 0.0255429 , 0.05273567, 0.07992845, 0.10712122, 0.13431399,\n", + " 0.16150677, 0.18869954]))\n", + "input quantiles are [ 0.160167 0.38573089 0.54837833 0.68735456 0.81725231 0.94715006\n", + " 1.0861263 1.24877373 1.47433762]evaluated above (array([ 1.96969697, 2.07070707, 2.17171717, 2.27272727, 2.37373737,\n", + " 2.47474747, 2.57575758]), array([ 0.18821955, 0.16102677, 0.133834 , 0.10664123, 0.07944845,\n", + " 0.05225568, 0.02506291]))\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "\n", + "complete evaluated quantile PDF: (array([-0.29096079, 0.160167 , 0.38573089, 0.38573089, 0.54837833,\n", + " 0.54837833, 0.68735456, 0.68735456, 0.81725231, 0.81725231,\n", + " 0.94715006, 0.94715006, 1.0861263 , 1.0861263 , 1.24877373,\n", + " 1.24877373, 1.47433762, 1.92546541]), array([ 2.22044605e-16, 4.43333367e-01, 4.43333367e-01,\n", + " 6.14826782e-01, 6.14826782e-01, 7.19547470e-01,\n", + " 7.19547470e-01, 7.69836295e-01, 7.69836295e-01,\n", + " 7.69836295e-01, 7.69836295e-01, 7.19547470e-01,\n", + " 7.19547470e-01, 6.14826782e-01, 6.14826782e-01,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 4.43333367e-01, 4.43333367e-01, 2.22044605e-16]))\n", + "order is 5\n", + "divided into (array([47, 48, 49, 50, 51]), array([52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64]), array([65, 66, 67, 68]))\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "evaluated inside (array([ 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", + " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", + " 1.26262626, 1.36363636, 1.46464646]), array([ 0.42412498, 0.51690141, 0.60584365, 0.68304285, 0.74079776,\n", + " 0.77282717, 0.77555359, 0.74867101, 0.69518996, 0.62096562,\n", + " 0.53357031, 0.44089914, 0.35092118]))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.83837651, -0.40009051, -0.08405547, 0.18598482, 0.43838498,\n", + " 0.69078514, 0.96082543, 1.27686047, 1.71514647]))evaluated below (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515]), array([ 0.02919974, 0.1059378 , 0.18267587, 0.25941393, 0.336152 ]))\n", + "evaluated above (array([ 1.56565657, 1.66666667, 1.76767677, 1.86868687]), array([ 0.27334924, 0.19661117, 0.11987311, 0.04313505]))\n", + "\n", + "\n", + "input quantiles are [-0.83837651 -0.40009051 -0.08405547 0.18598482 0.43838498 0.69078514\n", + " 0.96082543 1.27686047 1.71514647]input shape: (9, 8), output shape: (18, 18)\n", + "complete evaluated quantile PDF: (array([-1.71494851, -0.83837651, -0.40009051, -0.40009051, -0.08405547,\n", + " -0.08405547, 0.18598482, 0.18598482, 0.43838498, 0.43838498,\n", + " 0.69078514, 0.69078514, 0.96082543, 0.96082543, 1.27686047,\n", + " 1.27686047, 1.71514647, 2.59171847]), array([ 2.22044605e-16, 2.28161521e-01, 2.28161521e-01,\n", + " 3.16420609e-01, 3.16420609e-01, 3.70315112e-01,\n", + " 3.70315112e-01, 3.96196256e-01, 3.96196256e-01,\n", + " 3.96196256e-01, 3.96196256e-01, 3.70315112e-01,\n", + " 3.70315112e-01, 3.16420609e-01, 3.16420609e-01,\n", + " 2.28161521e-01, 2.28161521e-01, 2.22044605e-16]))\n", + "order is 5\n", + "divided into (array([33, 34, 35, 36, 37, 38, 39, 40, 41]), array([42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,\n", + " 59, 60, 61, 62, 63, 64, 65, 66]), array([67, 68, 69, 70, 71, 72, 73, 74, 75]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.4716778 , -0.23109047, -0.05761009, 0.09062251, 0.22917195,\n", + " 0.36772139, 0.51595399, 0.68943438, 0.9300217 ]))evaluated inside (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", + " -0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", + " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", + " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", + " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667]), array([ 0.19482262, 0.21884383, 0.24341678, 0.26798028, 0.29197582,\n", + " 0.31484752, 0.33604216, 0.35500922, 0.37121226, 0.38418021,\n", + " 0.39353248, 0.39898817, 0.40038408, 0.3976788 , 0.39095271,\n", + " 0.38040776, 0.36635886, 0.34921595, 0.32947641, 0.30768512,\n", + " 0.2843935 , 0.26015563, 0.2355282 , 0.21107062, 0.1873449 ]))\n", + "\n", + "evaluated below (array([-1.66666667, -1.56565657, -1.46464646, -1.36363636, -1.26262626,\n", + " -1.16161616, -1.06060606, -0.95959596, -0.85858586]), array([ 0.00971525, 0.03004045, 0.05036565, 0.07069084, 0.09101604,\n", + " 0.11134124, 0.13166644, 0.15199164, 0.17231684]))input quantiles are [-0.4716778 -0.23109047 -0.05761009 0.09062251 0.22917195 0.36772139\n", + " 0.51595399 0.68943438 0.9300217 ]\n", + "\n", + "evaluated above (array([ 1.76767677, 1.86868687, 1.96969697, 2.07070707, 2.17171717,\n", + " 2.27272727, 2.37373737, 2.47474747, 2.57575758]), array([ 0.16581324, 0.14548804, 0.12516284, 0.10483764, 0.08451244,\n", + " 0.06418724, 0.04386204, 0.02353684, 0.00321164]))\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "complete evaluated quantile PDF: (array([-0.95285245, -0.4716778 , -0.23109047, -0.23109047, -0.05761009,\n", + " -0.05761009, 0.09062251, 0.09062251, 0.22917195, 0.22917195,\n", + " 0.36772139, 0.36772139, 0.51595399, 0.51595399, 0.68943438,\n", + " 0.68943438, 0.9300217 , 1.41119635]), array([ 2.22044605e-16, 4.15649494e-01, 4.15649494e-01,\n", + " 5.76434034e-01, 5.76434034e-01, 6.74615457e-01,\n", + " 6.74615457e-01, 7.21764005e-01, 7.21764005e-01,\n", + " 7.21764005e-01, 7.21764005e-01, 6.74615457e-01,\n", + " 6.74615457e-01, 5.76434034e-01, 5.76434034e-01,\n", + " 4.15649494e-01, 4.15649494e-01, 2.22044605e-16]))Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.22752249, 0.08081044, 0.30314018, 0.49311274, 0.67067553,\n", + " 0.84823831, 1.03821087, 1.26054061, 1.56887354]))\n", + "divided into (array([41, 42, 43, 44]), array([45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58]), array([59, 60, 61, 62, 63]))\n", + "\n", + "order is 5\n", + "input quantiles are [-0.22752249 0.08081044 0.30314018 0.49311274 0.67067553 0.84823831\n", + " 1.03821087 1.26054061 1.56887354]Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "\n", + "evaluated inside (array([-0.45454545, -0.35353535, -0.25252525, -0.15151515, -0.05050505,\n", + " 0.05050505, 0.15151515, 0.25252525, 0.35353535, 0.45454545,\n", + " 0.55555556, 0.65656566, 0.75757576, 0.85858586]), array([ 0.33411094, 0.41342215, 0.4949481 , 0.5725297 , 0.64006113,\n", + " 0.69158671, 0.72217601, 0.72882471, 0.71087657, 0.6701044 ,\n", + " 0.61047089, 0.53753679, 0.4573692 , 0.37609858]))\n", + "evaluated below (array([-0.85858586, -0.75757576, -0.65656566, -0.55555556]), array([ 0.06295026, 0.13040376, 0.19785727, 0.26531077]))\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "evaluated above (array([ 0.95959596, 1.06060606, 1.16161616, 1.26262626, 1.36363636]), array([ 0.30157409, 0.23412058, 0.16666708, 0.09921357, 0.03176007]))\n", + "complete evaluated quantile PDF: (array([-0.84418835, -0.22752249, 0.08081044, 0.08081044, 0.30314018,\n", + " 0.30314018, 0.49311274, 0.49311274, 0.67067553, 0.67067553,\n", + " 0.84823831, 0.84823831, 1.03821087, 1.03821087, 1.26054061,\n", + " 1.26054061, 1.56887354, 2.1855394 ]), array([ 2.22044605e-16, 3.24324747e-01, 3.24324747e-01,\n", + " 4.49782389e-01, 4.49782389e-01, 5.26391805e-01,\n", + " 5.26391805e-01, 5.63181074e-01, 5.63181074e-01,\n", + " 5.63181074e-01, 5.63181074e-01, 5.26391805e-01,\n", + " 5.26391805e-01, 4.49782389e-01, 4.49782389e-01,\n", + " 3.24324747e-01, 3.24324747e-01, 2.22044605e-16]))\n", + "order is 5\n", + "divided into (array([42, 43, 44, 45, 46, 47]), array([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,\n", + " 65]), array([66, 67, 68, 69, 70, 71]))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.63410249, -0.34639065, -0.13893017, 0.03833716, 0.20402467,\n", + " 0.36971217, 0.5469795 , 0.75443998, 1.04215182]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "\n", + "evaluated inside (array([-0.15151515, -0.05050505, 0.05050505, 0.15151515, 0.25252525,\n", + " 0.35353535, 0.45454545, 0.55555556, 0.65656566, 0.75757576,\n", + " 0.85858586, 0.95959596, 1.06060606, 1.16161616, 1.26262626,\n", + " 1.36363636, 1.46464646, 1.56565657]), array([ 0.28602048, 0.3351863 , 0.38482262, 0.43264808, 0.4763967 ,\n", + " 0.51381924, 0.54278436, 0.56158655, 0.56909352, 0.56485326,\n", + " 0.54912047, 0.52284566, 0.48758443, 0.44537765, 0.39846372,\n", + " 0.34910432, 0.29957652, 0.25217281]))\n", + "input quantiles are [-0.63410249 -0.34639065 -0.13893017 0.03833716 0.20402467 0.36971217\n", + " 0.5469795 0.75443998 1.04215182]\n", + "evaluated below (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", + " -0.25252525]), array([ 0.0352149 , 0.07628352, 0.11735215, 0.15842078, 0.1994894 ,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0.24055803]))\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "complete evaluated quantile PDF: (array([-1.20952616, -0.63410249, -0.34639065, -0.34639065, -0.13893017,\n", + " -0.13893017, 0.03833716, 0.03833716, 0.20402467, 0.20402467,\n", + " 0.36971217, 0.36971217, 0.5469795 , 0.5469795 , 0.75443998,\n", + " 0.75443998, 1.04215182, 1.61757549]), array([ 2.22044605e-16, 3.47569988e-01, 3.47569988e-01,\n", + " 4.82019521e-01, 4.82019521e-01, 5.64119744e-01,\n", + " 5.64119744e-01, 6.03545800e-01, 6.03545800e-01,\n", + " 6.03545800e-01, 6.03545800e-01, 5.64119744e-01,\n", + " 5.64119744e-01, 4.82019521e-01, 4.82019521e-01,\n", + " 3.47569988e-01, 3.47569988e-01, 2.22044605e-16]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "\n", + "evaluated above (array([ 1.66666667, 1.76767677, 1.86868687, 1.96969697, 2.07070707,\n", + " 2.17171717]), array([ 0.21096297, 0.16989434, 0.12882571, 0.08775709, 0.04668846,\n", + " 0.00561984]))\n", + "order is 5\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.75426818, 0.77627287, 0.7921398 , 0.8056975 , 0.81836957,\n", + " 0.83104163, 0.84459933, 0.86046626, 0.88247095]))\n", + "divided into (array([38, 39, 40, 41, 42, 43]), array([44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59]), array([60, 61, 62, 63, 64, 65]))\n", + "input quantiles are [ 0.75426818 0.77627287 0.7921398 0.8056975 0.81836957 0.83104163\n", + " 0.84459933 0.86046626 0.88247095]\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "evaluated inside (array([-0.55555556, -0.45454545, -0.35353535, -0.25252525, -0.15151515,\n", + " -0.05050505, 0.05050505, 0.15151515, 0.25252525, 0.35353535,\n", + " 0.45454545, 0.55555556, 0.65656566, 0.75757576, 0.85858586,\n", + " 0.95959596]), array([ 0.31070451, 0.36735297, 0.42415121, 0.47809387, 0.52619741,\n", + " 0.56551778, 0.59343513, 0.60804399, 0.60833168, 0.59427839,\n", + " 0.56685819, 0.52794447, 0.48013393, 0.42636629, 0.36962427,\n", + " 0.31291232]))complete evaluated quantile PDF: (array([ 0.7102588 , 0.75426818, 0.77627287, 0.77627287, 0.7921398 ,\n", + " 0.7921398 , 0.8056975 , 0.8056975 , 0.81836957, 0.81836957,\n", + " 0.83104163, 0.83104163, 0.84459933, 0.84459933, 0.86046626,\n", + " 0.86046626, 0.88247095, 0.92648033]), array([ 2.22044605e-16, 4.54448593e+00, 4.54448593e+00,\n", + " 6.30241681e+00, 6.30241681e+00, 7.37587919e+00,\n", + " 7.37587919e+00, 7.89137582e+00, 7.89137582e+00,\n", + " 7.89137582e+00, 7.89137582e+00, 7.37587919e+00,\n", + " 7.37587919e+00, 6.30241681e+00, 6.30241681e+00,\n", + " 4.54448593e+00, 4.54448593e+00, 2.22044605e-16]))\n", + "\n", + "evaluated below (array([-1.16161616, -1.06060606, -0.95959596, -0.85858586, -0.75757576,\n", + " -0.65656566]), array([ 0.02237154, 0.06953814, 0.11670474, 0.16387133, 0.21103793,\n", + " 0.25820452]))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "order is 5\n", + "evaluated above (array([ 1.06060606, 1.16161616, 1.26262626, 1.36363636, 1.46464646,\n", + " 1.56565657]), array([ 0.26007649, 0.21290989, 0.1657433 , 0.1185767 , 0.0714101 ,\n", + " 0.02424351]))\n", + "divided into (array([], dtype=int64), array([57, 58]), array([], dtype=int64))\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.87371033, 0.88669005, 0.89604935, 0.90404653, 0.91152129,\n", + " 0.91899606, 0.92699323, 0.93635253, 0.94933226]))\n", + "input quantiles are [ 0.87371033 0.88669005 0.89604935 0.90404653 0.91152129 0.91899606\n", + " 0.92699323 0.93635253 0.94933226]Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "evaluated inside (array([ 0.75757576, 0.85858586]), array([ 3.81138379, 5.77321742]))\n", + "\n", + "evaluated below (array([], dtype=float64), array([], dtype=float64))\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "evaluated above (array([], dtype=float64), array([], dtype=float64))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "complete evaluated quantile PDF: (array([ 0.84775087, 0.87371033, 0.88669005, 0.88669005, 0.89604935,\n", + " 0.89604935, 0.90404653, 0.90404653, 0.91152129, 0.91152129,\n", + " 0.91899606, 0.91899606, 0.92699323, 0.92699323, 0.93635253,\n", + " 0.93635253, 0.94933226, 0.97529172]), array([ 2.22044605e-16, 7.70432123e+00, 7.70432123e+00,\n", + " 1.06845624e+01, 1.06845624e+01, 1.25044160e+01,\n", + " 1.25044160e+01, 1.33783436e+01, 1.33783436e+01,\n", + " 1.33783436e+01, 1.33783436e+01, 1.25044160e+01,\n", + " 1.25044160e+01, 1.06845624e+01, 1.06845624e+01,\n", + " 7.70432123e+00, 7.70432123e+00, 2.22044605e-16]))\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.33570561, 0.34266231, 0.34767858, 0.35196481, 0.35597103,\n", + " 0.35997726, 0.36426348, 0.36927975, 0.37623646]))order is 5\n", + "\n", + "divided into (array([58]), array([], dtype=int64), array([59]))\n", + "input quantiles are [ 0.33570561 0.34266231 0.34767858 0.35196481 0.35597103 0.35997726\n", + " 0.36426348 0.36927975 0.37623646]\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "evaluated inside (array([], dtype=float64), array([], dtype=float64))\n", + "complete evaluated quantile PDF: (array([ 0.3217922 , 0.33570561, 0.34266231, 0.34266231, 0.34767858,\n", + " 0.34767858, 0.35196481, 0.35196481, 0.35597103, 0.35597103,\n", + " 0.35997726, 0.35997726, 0.36426348, 0.36426348, 0.36927975,\n", + " 0.36927975, 0.37623646, 0.39014987]), array([ 2.22044605e-16, 1.43746220e+01, 1.43746220e+01,\n", + " 1.99351171e+01, 1.99351171e+01, 2.33305762e+01,\n", + " 2.33305762e+01, 2.49611389e+01, 2.49611389e+01,\n", + " 2.49611389e+01, 2.49611389e+01, 2.33305762e+01,\n", + " 2.33305762e+01, 1.99351171e+01, 1.99351171e+01,\n", + " 1.43746220e+01, 1.43746220e+01, 2.22044605e-16]))\n", + "evaluated below (array([ 0.85858586]), array([ 2.48589346]))\n", + "order is 5\n", + "evaluated above (array([ 0.95959596]), array([ 3.60110922]))\n", + "divided into (array([], dtype=int64), array([53]), array([], dtype=int64))\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "evaluated inside (array([ 0.35353535]), array([ 24.93098564]))\n", + "evaluated below (array([], dtype=float64), array([], dtype=float64))\n", + "evaluated above (array([], dtype=float64), array([], dtype=float64))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "divided into (array([57]), array([58, 59]), array([60]))\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.78202054, 0.81910725, 0.84584937, 0.86869953, 0.89005703,\n", + " 0.91141452, 0.93426468, 0.9610068 , 0.99809351]))\n", + "input quantiles are [ 0.78202054 0.81910725 0.84584937 0.86869953 0.89005703 0.91141452\n", + " 0.93426468 0.9610068 0.99809351]\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "complete evaluated quantile PDF: (array([ 0.70784713, 0.78202054, 0.81910725, 0.81910725, 0.84584937,\n", + " 0.84584937, 0.86869953, 0.86869953, 0.89005703, 0.89005703,\n", + " 0.91141452, 0.91141452, 0.93426468, 0.93426468, 0.9610068 ,\n", + " 0.9610068 , 0.99809351, 1.07226692]), array([ 2.22044605e-16, 2.69638403e+00, 2.69638403e+00,\n", + " 3.73941878e+00, 3.73941878e+00, 4.37633721e+00,\n", + " 4.37633721e+00, 4.68219730e+00, 4.68219730e+00,\n", + " 4.68219730e+00, 4.68219730e+00, 4.37633721e+00,\n", + " 4.37633721e+00, 3.73941878e+00, 3.73941878e+00,\n", + " 2.69638403e+00, 2.69638403e+00, 2.22044605e-16]))\n", + "order is 5\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "\n", + "evaluated inside (array([ 0.85858586, 0.95959596]), array([ 4.4138218, 3.3677309]))\n", + "evaluated below (array([ 0.75757576]), array([ 1.39751068]))\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.2966362 , 0.08228443, 0.35551287, 0.58897649, 0.80718932,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 1.02540215, 1.25886577, 1.5320942 , 1.91101483]))input quantiles are [-0.2966362 0.08228443 0.35551287 0.58897649 0.80718932 1.02540215\n", + " 1.25886577 1.5320942 1.91101483]evaluated above (array([ 1.06060606]), array([ 0.32770206]))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "\n", + "complete evaluated quantile PDF: (array([-1.05447745, -0.2966362 , 0.08228443, 0.08228443, 0.35551287,\n", + " 0.35551287, 0.58897649, 0.58897649, 0.80718932, 0.80718932,\n", + " 1.02540215, 1.02540215, 1.25886577, 1.25886577, 1.5320942 ,\n", + " 1.5320942 , 1.91101483, 2.66885609]), array([ 2.22044605e-16, 2.63907511e-01, 2.63907511e-01,\n", + " 3.65994121e-01, 3.65994121e-01, 4.28332258e-01,\n", + " 4.28332258e-01, 4.58268192e-01, 4.58268192e-01,\n", + " 4.58268192e-01, 4.58268192e-01, 4.28332258e-01,\n", + " 4.28332258e-01, 3.65994121e-01, 3.65994121e-01,\n", + " 2.63907511e-01, 2.63907511e-01, 2.22044605e-16]))Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.160167 , 0.38573089, 0.54837833, 0.68735456, 0.81725231,\n", + " 0.94715006, 1.0861263 , 1.24877373, 1.47433762]))\n", + "\n", + "input quantiles are [ 0.160167 0.38573089 0.54837833 0.68735456 0.81725231 0.94715006\n", + " 1.0861263 1.24877373 1.47433762]order is 5\n", + "\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "divided into (array([40, 41, 42, 43, 44, 45, 46]), array([47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,\n", + " 64, 65, 66, 67, 68]), array([69, 70, 71, 72, 73, 74, 75]))complete evaluated quantile PDF: (array([-0.29096079, 0.160167 , 0.38573089, 0.38573089, 0.54837833,\n", + " 0.54837833, 0.68735456, 0.68735456, 0.81725231, 0.81725231,\n", + " 0.94715006, 0.94715006, 1.0861263 , 1.0861263 , 1.24877373,\n", + " 1.24877373, 1.47433762, 1.92546541]), array([ 2.22044605e-16, 4.43333367e-01, 4.43333367e-01,\n", + " 6.14826782e-01, 6.14826782e-01, 7.19547470e-01,\n", + " 7.19547470e-01, 7.69836295e-01, 7.69836295e-01,\n", + " 7.69836295e-01, 7.69836295e-01, 7.19547470e-01,\n", + " 7.19547470e-01, 6.14826782e-01, 6.14826782e-01,\n", + " 4.43333367e-01, 4.43333367e-01, 2.22044605e-16]))\n", + "\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "order is 5\n", + "evaluated inside (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", + " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", + " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", + " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667,\n", + " 1.76767677, 1.86868687]), array([ 0.21737113, 0.24923911, 0.2820813 , 0.31489295, 0.34667479,\n", + " 0.37643304, 0.40317944, 0.42593824, 0.44382821, 0.45614871,\n", + " 0.46240587, 0.46234979, 0.45598269, 0.44355893, 0.42557638,\n", + " 0.40273907, 0.37593098, 0.34612842, 0.31431978, 0.28149891,\n", + " 0.24866518, 0.21682346]))evaluated inside (array([ 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", + " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", + " 1.26262626, 1.36363636, 1.46464646]), array([ 0.42412498, 0.51690141, 0.60584365, 0.68304285, 0.74079776,\n", + " 0.77282717, 0.77555359, 0.74867101, 0.69518996, 0.62096562,\n", + " 0.53357031, 0.44089914, 0.35092118]))divided into (array([47, 48, 49, 50, 51]), array([52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64]), array([65, 66, 67, 68]))\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.83837651, -0.40009051, -0.08405547, 0.18598482, 0.43838498,\n", + " 0.69078514, 0.96082543, 1.27686047, 1.71514647]))\n", + "\n", + "evaluated below (array([-0.95959596, -0.85858586, -0.75757576, -0.65656566, -0.55555556,\n", + " -0.45454545, -0.35353535]), array([ 0.0255429 , 0.05273567, 0.07992845, 0.10712122, 0.13431399,\n", + " 0.16150677, 0.18869954]))input shape: (9, 8), output shape: (18, 18)\n", + "\n", + "input quantiles are [-0.83837651 -0.40009051 -0.08405547 0.18598482 0.43838498 0.69078514\n", + " 0.96082543 1.27686047 1.71514647]evaluated below (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515]), array([ 0.02919974, 0.1059378 , 0.18267587, 0.25941393, 0.336152 ]))\n", + "\n", + "evaluated above (array([ 1.56565657, 1.66666667, 1.76767677, 1.86868687]), array([ 0.27334924, 0.19661117, 0.11987311, 0.04313505]))\n", + "complete evaluated quantile PDF: (array([-1.71494851, -0.83837651, -0.40009051, -0.40009051, -0.08405547,\n", + " -0.08405547, 0.18598482, 0.18598482, 0.43838498, 0.43838498,\n", + " 0.69078514, 0.69078514, 0.96082543, 0.96082543, 1.27686047,\n", + " 1.27686047, 1.71514647, 2.59171847]), array([ 2.22044605e-16, 2.28161521e-01, 2.28161521e-01,\n", + " 3.16420609e-01, 3.16420609e-01, 3.70315112e-01,\n", + " 3.70315112e-01, 3.96196256e-01, 3.96196256e-01,\n", + " 3.96196256e-01, 3.96196256e-01, 3.70315112e-01,\n", + " 3.70315112e-01, 3.16420609e-01, 3.16420609e-01,\n", + " 2.28161521e-01, 2.28161521e-01, 2.22044605e-16]))evaluated above (array([ 1.96969697, 2.07070707, 2.17171717, 2.27272727, 2.37373737,\n", + " 2.47474747, 2.57575758]), array([ 0.18821955, 0.16102677, 0.133834 , 0.10664123, 0.07944845,\n", + " 0.05225568, 0.02506291]))\n", + "\n", + "order is 5\n", + "divided into (array([33, 34, 35, 36, 37, 38, 39, 40, 41]), array([42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,\n", + " 59, 60, 61, 62, 63, 64, 65, 66]), array([67, 68, 69, 70, 71, 72, 73, 74, 75]))\n", + "evaluated below (array([-1.66666667, -1.56565657, -1.46464646, -1.36363636, -1.26262626,\n", + " -1.16161616, -1.06060606, -0.95959596, -0.85858586]), array([ 0.00971525, 0.03004045, 0.05036565, 0.07069084, 0.09101604,\n", + " 0.11134124, 0.13166644, 0.15199164, 0.17231684]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.4716778 , -0.23109047, -0.05761009, 0.09062251, 0.22917195,\n", + " 0.36772139, 0.51595399, 0.68943438, 0.9300217 ]))evaluated inside (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", + " -0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", + " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", + " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", + " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667]), array([ 0.19482262, 0.21884383, 0.24341678, 0.26798028, 0.29197582,\n", + " 0.31484752, 0.33604216, 0.35500922, 0.37121226, 0.38418021,\n", + " 0.39353248, 0.39898817, 0.40038408, 0.3976788 , 0.39095271,\n", + " 0.38040776, 0.36635886, 0.34921595, 0.32947641, 0.30768512,\n", + " 0.2843935 , 0.26015563, 0.2355282 , 0.21107062, 0.1873449 ]))\n", + "\n", + "input quantiles are [-0.4716778 -0.23109047 -0.05761009 0.09062251 0.22917195 0.36772139\n", + " 0.51595399 0.68943438 0.9300217 ]\n", + "\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "\n", + "evaluated above (array([ 1.76767677, 1.86868687, 1.96969697, 2.07070707, 2.17171717,\n", + " 2.27272727, 2.37373737, 2.47474747, 2.57575758]), array([ 0.16581324, 0.14548804, 0.12516284, 0.10483764, 0.08451244,\n", + " 0.06418724, 0.04386204, 0.02353684, 0.00321164]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "complete evaluated quantile PDF: (array([-0.95285245, -0.4716778 , -0.23109047, -0.23109047, -0.05761009,\n", + " -0.05761009, 0.09062251, 0.09062251, 0.22917195, 0.22917195,\n", + " 0.36772139, 0.36772139, 0.51595399, 0.51595399, 0.68943438,\n", + " 0.68943438, 0.9300217 , 1.41119635]), array([ 2.22044605e-16, 4.15649494e-01, 4.15649494e-01,\n", + " 5.76434034e-01, 5.76434034e-01, 6.74615457e-01,\n", + " 6.74615457e-01, 7.21764005e-01, 7.21764005e-01,\n", + " 7.21764005e-01, 7.21764005e-01, 6.74615457e-01,\n", + " 6.74615457e-01, 5.76434034e-01, 5.76434034e-01,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 4.15649494e-01, 4.15649494e-01, 2.22044605e-16]))\n", + "order is 5\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.22752249, 0.08081044, 0.30314018, 0.49311274, 0.67067553,\n", + " 0.84823831, 1.03821087, 1.26054061, 1.56887354]))divided into (array([41, 42, 43, 44]), array([45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58]), array([59, 60, 61, 62, 63]))\n", + "\n", + "input quantiles are [-0.22752249 0.08081044 0.30314018 0.49311274 0.67067553 0.84823831\n", + " 1.03821087 1.26054061 1.56887354]evaluated inside (array([-0.45454545, -0.35353535, -0.25252525, -0.15151515, -0.05050505,\n", + " 0.05050505, 0.15151515, 0.25252525, 0.35353535, 0.45454545,\n", + " 0.55555556, 0.65656566, 0.75757576, 0.85858586]), array([ 0.33411094, 0.41342215, 0.4949481 , 0.5725297 , 0.64006113,\n", + " 0.69158671, 0.72217601, 0.72882471, 0.71087657, 0.6701044 ,\n", + " 0.61047089, 0.53753679, 0.4573692 , 0.37609858]))\n", + "\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "evaluated below (array([-0.85858586, -0.75757576, -0.65656566, -0.55555556]), array([ 0.06295026, 0.13040376, 0.19785727, 0.26531077]))\n", + "complete evaluated quantile PDF: (array([-0.84418835, -0.22752249, 0.08081044, 0.08081044, 0.30314018,\n", + " 0.30314018, 0.49311274, 0.49311274, 0.67067553, 0.67067553,\n", + " 0.84823831, 0.84823831, 1.03821087, 1.03821087, 1.26054061,\n", + " 1.26054061, 1.56887354, 2.1855394 ]), array([ 2.22044605e-16, 3.24324747e-01, 3.24324747e-01,\n", + " 4.49782389e-01, 4.49782389e-01, 5.26391805e-01,\n", + " 5.26391805e-01, 5.63181074e-01, 5.63181074e-01,\n", + " 5.63181074e-01, 5.63181074e-01, 5.26391805e-01,\n", + " 5.26391805e-01, 4.49782389e-01, 4.49782389e-01,\n", + " 3.24324747e-01, 3.24324747e-01, 2.22044605e-16]))evaluated above (array([ 0.95959596, 1.06060606, 1.16161616, 1.26262626, 1.36363636]), array([ 0.30157409, 0.23412058, 0.16666708, 0.09921357, 0.03176007]))\n", + "\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "order is 5\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.63410249, -0.34639065, -0.13893017, 0.03833716, 0.20402467,\n", + " 0.36971217, 0.5469795 , 0.75443998, 1.04215182]))\n", + "divided into (array([42, 43, 44, 45, 46, 47]), array([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,\n", + " 65]), array([66, 67, 68, 69, 70, 71]))\n", + "input quantiles are [-0.63410249 -0.34639065 -0.13893017 0.03833716 0.20402467 0.36971217\n", + " 0.5469795 0.75443998 1.04215182]Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "\n", + "evaluated inside (array([-0.15151515, -0.05050505, 0.05050505, 0.15151515, 0.25252525,\n", + " 0.35353535, 0.45454545, 0.55555556, 0.65656566, 0.75757576,\n", + " 0.85858586, 0.95959596, 1.06060606, 1.16161616, 1.26262626,\n", + " 1.36363636, 1.46464646, 1.56565657]), array([ 0.28602048, 0.3351863 , 0.38482262, 0.43264808, 0.4763967 ,\n", + " 0.51381924, 0.54278436, 0.56158655, 0.56909352, 0.56485326,\n", + " 0.54912047, 0.52284566, 0.48758443, 0.44537765, 0.39846372,\n", + " 0.34910432, 0.29957652, 0.25217281]))input shape: (9, 8), output shape: (18, 18)\n", + "\n", + "evaluated below (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", + " -0.25252525]), array([ 0.0352149 , 0.07628352, 0.11735215, 0.15842078, 0.1994894 ,\n", + " 0.24055803]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "complete evaluated quantile PDF: (array([-1.20952616, -0.63410249, -0.34639065, -0.34639065, -0.13893017,\n", + " -0.13893017, 0.03833716, 0.03833716, 0.20402467, 0.20402467,\n", + " 0.36971217, 0.36971217, 0.5469795 , 0.5469795 , 0.75443998,\n", + " 0.75443998, 1.04215182, 1.61757549]), array([ 2.22044605e-16, 3.47569988e-01, 3.47569988e-01,\n", + " 4.82019521e-01, 4.82019521e-01, 5.64119744e-01,\n", + " 5.64119744e-01, 6.03545800e-01, 6.03545800e-01,\n", + " 6.03545800e-01, 6.03545800e-01, 5.64119744e-01,\n", + " 5.64119744e-01, 4.82019521e-01, 4.82019521e-01,\n", + " 3.47569988e-01, 3.47569988e-01, 2.22044605e-16]))\n", + "\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.75426818, 0.77627287, 0.7921398 , 0.8056975 , 0.81836957,\n", + " 0.83104163, 0.84459933, 0.86046626, 0.88247095]))order is 5\n", + "\n", + "input quantiles are [ 0.75426818 0.77627287 0.7921398 0.8056975 0.81836957 0.83104163\n", + " 0.84459933 0.86046626 0.88247095]divided into (array([38, 39, 40, 41, 42, 43]), array([44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59]), array([60, 61, 62, 63, 64, 65]))\n", + "evaluated above (array([ 1.66666667, 1.76767677, 1.86868687, 1.96969697, 2.07070707,\n", + " 2.17171717]), array([ 0.21096297, 0.16989434, 0.12882571, 0.08775709, 0.04668846,\n", + " 0.00561984]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "\n", + "evaluated inside (array([-0.55555556, -0.45454545, -0.35353535, -0.25252525, -0.15151515,\n", + " -0.05050505, 0.05050505, 0.15151515, 0.25252525, 0.35353535,\n", + " 0.45454545, 0.55555556, 0.65656566, 0.75757576, 0.85858586,\n", + " 0.95959596]), array([ 0.31070451, 0.36735297, 0.42415121, 0.47809387, 0.52619741,\n", + " 0.56551778, 0.59343513, 0.60804399, 0.60833168, 0.59427839,\n", + " 0.56685819, 0.52794447, 0.48013393, 0.42636629, 0.36962427,\n", + " 0.31291232]))\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "\n", + "complete evaluated quantile PDF: (array([ 0.7102588 , 0.75426818, 0.77627287, 0.77627287, 0.7921398 ,\n", + " 0.7921398 , 0.8056975 , 0.8056975 , 0.81836957, 0.81836957,\n", + " 0.83104163, 0.83104163, 0.84459933, 0.84459933, 0.86046626,\n", + " 0.86046626, 0.88247095, 0.92648033]), array([ 2.22044605e-16, 4.54448593e+00, 4.54448593e+00,\n", + " 6.30241681e+00, 6.30241681e+00, 7.37587919e+00,\n", + " 7.37587919e+00, 7.89137582e+00, 7.89137582e+00,\n", + " 7.89137582e+00, 7.89137582e+00, 7.37587919e+00,\n", + " 7.37587919e+00, 6.30241681e+00, 6.30241681e+00,\n", + " 4.54448593e+00, 4.54448593e+00, 2.22044605e-16]))\n", + "evaluated below (array([-1.16161616, -1.06060606, -0.95959596, -0.85858586, -0.75757576,\n", + " -0.65656566]), array([ 0.02237154, 0.06953814, 0.11670474, 0.16387133, 0.21103793,\n", + " 0.25820452]))order is 5\n", + "\n", + "divided into (array([], dtype=int64), array([57, 58]), array([], dtype=int64))\n", + "evaluated above (array([ 1.06060606, 1.16161616, 1.26262626, 1.36363636, 1.46464646,\n", + " 1.56565657]), array([ 0.26007649, 0.21290989, 0.1657433 , 0.1185767 , 0.0714101 ,\n", + " 0.02424351]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "evaluated inside (array([ 0.75757576, 0.85858586]), array([ 3.81138379, 5.77321742]))\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.87371033, 0.88669005, 0.89604935, 0.90404653, 0.91152129,\n", + " 0.91899606, 0.92699323, 0.93635253, 0.94933226]))evaluated below (array([], dtype=float64), array([], dtype=float64))\n", + "evaluated above (array([], dtype=float64), array([], dtype=float64))\n", + "\n", + "input quantiles are [ 0.87371033 0.88669005 0.89604935 0.90404653 0.91152129 0.91899606\n", + " 0.92699323 0.93635253 0.94933226]\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "complete evaluated quantile PDF: (array([ 0.84775087, 0.87371033, 0.88669005, 0.88669005, 0.89604935,\n", + " 0.89604935, 0.90404653, 0.90404653, 0.91152129, 0.91152129,\n", + " 0.91899606, 0.91899606, 0.92699323, 0.92699323, 0.93635253,\n", + " 0.93635253, 0.94933226, 0.97529172]), array([ 2.22044605e-16, 7.70432123e+00, 7.70432123e+00,\n", + " 1.06845624e+01, 1.06845624e+01, 1.25044160e+01,\n", + " 1.25044160e+01, 1.33783436e+01, 1.33783436e+01,\n", + " 1.33783436e+01, 1.33783436e+01, 1.25044160e+01,\n", + " 1.25044160e+01, 1.06845624e+01, 1.06845624e+01,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 7.70432123e+00, 7.70432123e+00, 2.22044605e-16]))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "order is 5\n", + "divided into (array([58]), array([], dtype=int64), array([59]))\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.33570561, 0.34266231, 0.34767858, 0.35196481, 0.35597103,\n", + " 0.35997726, 0.36426348, 0.36927975, 0.37623646]))evaluated inside (array([], dtype=float64), array([], dtype=float64))\n", + "\n", + "evaluated below (array([ 0.85858586]), array([ 2.48589346]))\n", + "evaluated above (array([ 0.95959596]), array([ 3.60110922]))\n", + "input quantiles are [ 0.33570561 0.34266231 0.34767858 0.35196481 0.35597103 0.35997726\n", + " 0.36426348 0.36927975 0.37623646]\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "complete evaluated quantile PDF: (array([ 0.3217922 , 0.33570561, 0.34266231, 0.34266231, 0.34767858,\n", + " 0.34767858, 0.35196481, 0.35196481, 0.35597103, 0.35597103,\n", + " 0.35997726, 0.35997726, 0.36426348, 0.36426348, 0.36927975,\n", + " 0.36927975, 0.37623646, 0.39014987]), array([ 2.22044605e-16, 1.43746220e+01, 1.43746220e+01,\n", + " 1.99351171e+01, 1.99351171e+01, 2.33305762e+01,\n", + " 2.33305762e+01, 2.49611389e+01, 2.49611389e+01,\n", + " 2.49611389e+01, 2.49611389e+01, 2.33305762e+01,\n", + " 2.33305762e+01, 1.99351171e+01, 1.99351171e+01,\n", + " 1.43746220e+01, 1.43746220e+01, 2.22044605e-16]))\n", + "order is 5\n", + "divided into (array([], dtype=int64), array([53]), array([], dtype=int64))\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "evaluated inside (array([ 0.35353535]), array([ 24.93098564]))\n", + "evaluated below (array([], dtype=float64), array([], dtype=float64))\n", + "evaluated above (array([], dtype=float64), array([], dtype=float64))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "input quantiles are [ 0.78202054 0.81910725 0.84584937 0.86869953 0.89005703 0.91141452\n", + " 0.93426468 0.9610068 0.99809351]Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.78202054, 0.81910725, 0.84584937, 0.86869953, 0.89005703,\n", + " 0.91141452, 0.93426468, 0.9610068 , 0.99809351]))\n", + "\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.2966362 , 0.08228443, 0.35551287, 0.58897649, 0.80718932,\n", + " 1.02540215, 1.25886577, 1.5320942 , 1.91101483]))complete evaluated quantile PDF: (array([ 0.70784713, 0.78202054, 0.81910725, 0.81910725, 0.84584937,\n", + " 0.84584937, 0.86869953, 0.86869953, 0.89005703, 0.89005703,\n", + " 0.91141452, 0.91141452, 0.93426468, 0.93426468, 0.9610068 ,\n", + " 0.9610068 , 0.99809351, 1.07226692]), array([ 2.22044605e-16, 2.69638403e+00, 2.69638403e+00,\n", + " 3.73941878e+00, 3.73941878e+00, 4.37633721e+00,\n", + " 4.37633721e+00, 4.68219730e+00, 4.68219730e+00,\n", + " 4.68219730e+00, 4.68219730e+00, 4.37633721e+00,\n", + " 4.37633721e+00, 3.73941878e+00, 3.73941878e+00,\n", + " 2.69638403e+00, 2.69638403e+00, 2.22044605e-16]))\n", + "\n", + "input quantiles are [-0.2966362 0.08228443 0.35551287 0.58897649 0.80718932 1.02540215\n", + " 1.25886577 1.5320942 1.91101483]order is 5\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "divided into (array([57]), array([58, 59]), array([60]))\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "complete evaluated quantile PDF: (array([-1.05447745, -0.2966362 , 0.08228443, 0.08228443, 0.35551287,\n", + " 0.35551287, 0.58897649, 0.58897649, 0.80718932, 0.80718932,\n", + " 1.02540215, 1.02540215, 1.25886577, 1.25886577, 1.5320942 ,\n", + " 1.5320942 , 1.91101483, 2.66885609]), array([ 2.22044605e-16, 2.63907511e-01, 2.63907511e-01,\n", + " 3.65994121e-01, 3.65994121e-01, 4.28332258e-01,\n", + " 4.28332258e-01, 4.58268192e-01, 4.58268192e-01,\n", + " 4.58268192e-01, 4.58268192e-01, 4.28332258e-01,\n", + " 4.28332258e-01, 3.65994121e-01, 3.65994121e-01,\n", + " 2.63907511e-01, 2.63907511e-01, 2.22044605e-16]))\n", + "order is 5\n", + "evaluated inside (array([ 0.85858586, 0.95959596]), array([ 4.4138218, 3.3677309]))\n", + "divided into (array([40, 41, 42, 43, 44, 45, 46]), array([47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,\n", + " 64, 65, 66, 67, 68]), array([69, 70, 71, 72, 73, 74, 75]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "evaluated above (array([ 1.06060606]), array([ 0.32770206]))\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.160167 , 0.38573089, 0.54837833, 0.68735456, 0.81725231,\n", + " 0.94715006, 1.0861263 , 1.24877373, 1.47433762]))\n", + "evaluated below (array([ 0.75757576]), array([ 1.39751068]))\n", + "input quantiles are [ 0.160167 0.38573089 0.54837833 0.68735456 0.81725231 0.94715006\n", + " 1.0861263 1.24877373 1.47433762]\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "\n", + "evaluated inside (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", + " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", + " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", + " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667,\n", + " 1.76767677, 1.86868687]), array([ 0.21737113, 0.24923911, 0.2820813 , 0.31489295, 0.34667479,\n", + " 0.37643304, 0.40317944, 0.42593824, 0.44382821, 0.45614871,\n", + " 0.46240587, 0.46234979, 0.45598269, 0.44355893, 0.42557638,\n", + " 0.40273907, 0.37593098, 0.34612842, 0.31431978, 0.28149891,\n", + " 0.24866518, 0.21682346]))input shape: (9, 8), output shape: (18, 18)\n", + "\n", + "complete evaluated quantile PDF: (array([-0.29096079, 0.160167 , 0.38573089, 0.38573089, 0.54837833,\n", + " 0.54837833, 0.68735456, 0.68735456, 0.81725231, 0.81725231,\n", + " 0.94715006, 0.94715006, 1.0861263 , 1.0861263 , 1.24877373,\n", + " 1.24877373, 1.47433762, 1.92546541]), array([ 2.22044605e-16, 4.43333367e-01, 4.43333367e-01,\n", + " 6.14826782e-01, 6.14826782e-01, 7.19547470e-01,\n", + " 7.19547470e-01, 7.69836295e-01, 7.69836295e-01,\n", + " 7.69836295e-01, 7.69836295e-01, 7.19547470e-01,\n", + " 7.19547470e-01, 6.14826782e-01, 6.14826782e-01,\n", + " 4.43333367e-01, 4.43333367e-01, 2.22044605e-16]))\n", + "evaluated below (array([-0.95959596, -0.85858586, -0.75757576, -0.65656566, -0.55555556,\n", + " -0.45454545, -0.35353535]), array([ 0.0255429 , 0.05273567, 0.07992845, 0.10712122, 0.13431399,\n", + " 0.16150677, 0.18869954]))order is 5\n", + "\n", + "evaluated above (array([ 1.96969697, 2.07070707, 2.17171717, 2.27272727, 2.37373737,\n", + " 2.47474747, 2.57575758]), array([ 0.18821955, 0.16102677, 0.133834 , 0.10664123, 0.07944845,\n", + " 0.05225568, 0.02506291]))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "divided into (array([47, 48, 49, 50, 51]), array([52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64]), array([65, 66, 67, 68]))\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.83837651, -0.40009051, -0.08405547, 0.18598482, 0.43838498,\n", + " 0.69078514, 0.96082543, 1.27686047, 1.71514647]))evaluated inside (array([ 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", + " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", + " 1.26262626, 1.36363636, 1.46464646]), array([ 0.42412498, 0.51690141, 0.60584365, 0.68304285, 0.74079776,\n", + " 0.77282717, 0.77555359, 0.74867101, 0.69518996, 0.62096562,\n", + " 0.53357031, 0.44089914, 0.35092118]))\n", + "input quantiles are [-0.83837651 -0.40009051 -0.08405547 0.18598482 0.43838498 0.69078514\n", + " 0.96082543 1.27686047 1.71514647]\n", + "\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "evaluated below (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515]), array([ 0.02919974, 0.1059378 , 0.18267587, 0.25941393, 0.336152 ]))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "evaluated above (array([ 1.56565657, 1.66666667, 1.76767677, 1.86868687]), array([ 0.27334924, 0.19661117, 0.11987311, 0.04313505]))\n", + "complete evaluated quantile PDF: (array([-1.71494851, -0.83837651, -0.40009051, -0.40009051, -0.08405547,\n", + " -0.08405547, 0.18598482, 0.18598482, 0.43838498, 0.43838498,\n", + " 0.69078514, 0.69078514, 0.96082543, 0.96082543, 1.27686047,\n", + " 1.27686047, 1.71514647, 2.59171847]), array([ 2.22044605e-16, 2.28161521e-01, 2.28161521e-01,\n", + " 3.16420609e-01, 3.16420609e-01, 3.70315112e-01,\n", + " 3.70315112e-01, 3.96196256e-01, 3.96196256e-01,\n", + " 3.96196256e-01, 3.96196256e-01, 3.70315112e-01,\n", + " 3.70315112e-01, 3.16420609e-01, 3.16420609e-01,\n", + " 2.28161521e-01, 2.28161521e-01, 2.22044605e-16]))\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.4716778 , -0.23109047, -0.05761009, 0.09062251, 0.22917195,\n", + " 0.36772139, 0.51595399, 0.68943438, 0.9300217 ]))\n", + "order is 5\n", + "input quantiles are [-0.4716778 -0.23109047 -0.05761009 0.09062251 0.22917195 0.36772139\n", + " 0.51595399 0.68943438 0.9300217 ]\n", + "divided into (array([33, 34, 35, 36, 37, 38, 39, 40, 41]), array([42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,\n", + " 59, 60, 61, 62, 63, 64, 65, 66]), array([67, 68, 69, 70, 71, 72, 73, 74, 75]))input shape: (9, 8), output shape: (18, 18)\n", + "\n", + "complete evaluated quantile PDF: (array([-0.95285245, -0.4716778 , -0.23109047, -0.23109047, -0.05761009,\n", + " -0.05761009, 0.09062251, 0.09062251, 0.22917195, 0.22917195,\n", + " 0.36772139, 0.36772139, 0.51595399, 0.51595399, 0.68943438,\n", + " 0.68943438, 0.9300217 , 1.41119635]), array([ 2.22044605e-16, 4.15649494e-01, 4.15649494e-01,\n", + " 5.76434034e-01, 5.76434034e-01, 6.74615457e-01,\n", + " 6.74615457e-01, 7.21764005e-01, 7.21764005e-01,\n", + " 7.21764005e-01, 7.21764005e-01, 6.74615457e-01,\n", + " 6.74615457e-01, 5.76434034e-01, 5.76434034e-01,\n", + " 4.15649494e-01, 4.15649494e-01, 2.22044605e-16]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "evaluated inside (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", + " -0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", + " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", + " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", + " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667]), array([ 0.19482262, 0.21884383, 0.24341678, 0.26798028, 0.29197582,\n", + " 0.31484752, 0.33604216, 0.35500922, 0.37121226, 0.38418021,\n", + " 0.39353248, 0.39898817, 0.40038408, 0.3976788 , 0.39095271,\n", + " 0.38040776, 0.36635886, 0.34921595, 0.32947641, 0.30768512,\n", + " 0.2843935 , 0.26015563, 0.2355282 , 0.21107062, 0.1873449 ]))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "\n", + "order is 5\n", + "evaluated below (array([-1.66666667, -1.56565657, -1.46464646, -1.36363636, -1.26262626,\n", + " -1.16161616, -1.06060606, -0.95959596, -0.85858586]), array([ 0.00971525, 0.03004045, 0.05036565, 0.07069084, 0.09101604,\n", + " 0.11134124, 0.13166644, 0.15199164, 0.17231684]))\n", + "divided into (array([41, 42, 43, 44]), array([45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58]), array([59, 60, 61, 62, 63]))\n", + "evaluated above (array([ 1.76767677, 1.86868687, 1.96969697, 2.07070707, 2.17171717,\n", + " 2.27272727, 2.37373737, 2.47474747, 2.57575758]), array([ 0.16581324, 0.14548804, 0.12516284, 0.10483764, 0.08451244,\n", + " 0.06418724, 0.04386204, 0.02353684, 0.00321164]))Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.22752249, 0.08081044, 0.30314018, 0.49311274, 0.67067553,\n", + " 0.84823831, 1.03821087, 1.26054061, 1.56887354]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "\n", + "\n", + "evaluated inside (array([-0.45454545, -0.35353535, -0.25252525, -0.15151515, -0.05050505,\n", + " 0.05050505, 0.15151515, 0.25252525, 0.35353535, 0.45454545,\n", + " 0.55555556, 0.65656566, 0.75757576, 0.85858586]), array([ 0.33411094, 0.41342215, 0.4949481 , 0.5725297 , 0.64006113,\n", + " 0.69158671, 0.72217601, 0.72882471, 0.71087657, 0.6701044 ,\n", + " 0.61047089, 0.53753679, 0.4573692 , 0.37609858]))input quantiles are [-0.22752249 0.08081044 0.30314018 0.49311274 0.67067553 0.84823831\n", + " 1.03821087 1.26054061 1.56887354]\n", + "evaluated below (array([-0.85858586, -0.75757576, -0.65656566, -0.55555556]), array([ 0.06295026, 0.13040376, 0.19785727, 0.26531077]))\n", + "\n", + "evaluated above (array([ 0.95959596, 1.06060606, 1.16161616, 1.26262626, 1.36363636]), array([ 0.30157409, 0.23412058, 0.16666708, 0.09921357, 0.03176007]))\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "complete evaluated quantile PDF: (array([-0.84418835, -0.22752249, 0.08081044, 0.08081044, 0.30314018,\n", + " 0.30314018, 0.49311274, 0.49311274, 0.67067553, 0.67067553,\n", + " 0.84823831, 0.84823831, 1.03821087, 1.03821087, 1.26054061,\n", + " 1.26054061, 1.56887354, 2.1855394 ]), array([ 2.22044605e-16, 3.24324747e-01, 3.24324747e-01,\n", + " 4.49782389e-01, 4.49782389e-01, 5.26391805e-01,\n", + " 5.26391805e-01, 5.63181074e-01, 5.63181074e-01,\n", + " 5.63181074e-01, 5.63181074e-01, 5.26391805e-01,\n", + " 5.26391805e-01, 4.49782389e-01, 4.49782389e-01,\n", + " 3.24324747e-01, 3.24324747e-01, 2.22044605e-16]))\n", + "order is 5\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.63410249, -0.34639065, -0.13893017, 0.03833716, 0.20402467,\n", + " 0.36971217, 0.5469795 , 0.75443998, 1.04215182]))divided into (array([42, 43, 44, 45, 46, 47]), array([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,\n", + " 65]), array([66, 67, 68, 69, 70, 71]))\n", + "input quantiles are [-0.63410249 -0.34639065 -0.13893017 0.03833716 0.20402467 0.36971217\n", + " 0.5469795 0.75443998 1.04215182]\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "evaluated inside (array([-0.15151515, -0.05050505, 0.05050505, 0.15151515, 0.25252525,\n", + " 0.35353535, 0.45454545, 0.55555556, 0.65656566, 0.75757576,\n", + " 0.85858586, 0.95959596, 1.06060606, 1.16161616, 1.26262626,\n", + " 1.36363636, 1.46464646, 1.56565657]), array([ 0.28602048, 0.3351863 , 0.38482262, 0.43264808, 0.4763967 ,\n", + " 0.51381924, 0.54278436, 0.56158655, 0.56909352, 0.56485326,\n", + " 0.54912047, 0.52284566, 0.48758443, 0.44537765, 0.39846372,\n", + " 0.34910432, 0.29957652, 0.25217281]))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "complete evaluated quantile PDF: (array([-1.20952616, -0.63410249, -0.34639065, -0.34639065, -0.13893017,\n", + " -0.13893017, 0.03833716, 0.03833716, 0.20402467, 0.20402467,\n", + " 0.36971217, 0.36971217, 0.5469795 , 0.5469795 , 0.75443998,\n", + " 0.75443998, 1.04215182, 1.61757549]), array([ 2.22044605e-16, 3.47569988e-01, 3.47569988e-01,\n", + " 4.82019521e-01, 4.82019521e-01, 5.64119744e-01,\n", + " 5.64119744e-01, 6.03545800e-01, 6.03545800e-01,\n", + " 6.03545800e-01, 6.03545800e-01, 5.64119744e-01,\n", + " 5.64119744e-01, 4.82019521e-01, 4.82019521e-01,\n", + " 3.47569988e-01, 3.47569988e-01, 2.22044605e-16]))evaluated below (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", + " -0.25252525]), array([ 0.0352149 , 0.07628352, 0.11735215, 0.15842078, 0.1994894 ,\n", + " 0.24055803]))\n", + "\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.75426818, 0.77627287, 0.7921398 , 0.8056975 , 0.81836957,\n", + " 0.83104163, 0.84459933, 0.86046626, 0.88247095]))order is 5\n", + "\n", + "divided into (array([38, 39, 40, 41, 42, 43]), array([44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59]), array([60, 61, 62, 63, 64, 65]))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input quantiles are [ 0.75426818 0.77627287 0.7921398 0.8056975 0.81836957 0.83104163\n", + " 0.84459933 0.86046626 0.88247095]evaluated above (array([ 1.66666667, 1.76767677, 1.86868687, 1.96969697, 2.07070707,\n", + " 2.17171717]), array([ 0.21096297, 0.16989434, 0.12882571, 0.08775709, 0.04668846,\n", + " 0.00561984]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "\n", + "evaluated inside (array([-0.55555556, -0.45454545, -0.35353535, -0.25252525, -0.15151515,\n", + " -0.05050505, 0.05050505, 0.15151515, 0.25252525, 0.35353535,\n", + " 0.45454545, 0.55555556, 0.65656566, 0.75757576, 0.85858586,\n", + " 0.95959596]), array([ 0.31070451, 0.36735297, 0.42415121, 0.47809387, 0.52619741,\n", + " 0.56551778, 0.59343513, 0.60804399, 0.60833168, 0.59427839,\n", + " 0.56685819, 0.52794447, 0.48013393, 0.42636629, 0.36962427,\n", + " 0.31291232]))\n", + "\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "evaluated below (array([-1.16161616, -1.06060606, -0.95959596, -0.85858586, -0.75757576,\n", + " -0.65656566]), array([ 0.02237154, 0.06953814, 0.11670474, 0.16387133, 0.21103793,\n", + " 0.25820452]))complete evaluated quantile PDF: (array([ 0.7102588 , 0.75426818, 0.77627287, 0.77627287, 0.7921398 ,\n", + " 0.7921398 , 0.8056975 , 0.8056975 , 0.81836957, 0.81836957,\n", + " 0.83104163, 0.83104163, 0.84459933, 0.84459933, 0.86046626,\n", + " 0.86046626, 0.88247095, 0.92648033]), array([ 2.22044605e-16, 4.54448593e+00, 4.54448593e+00,\n", + " 6.30241681e+00, 6.30241681e+00, 7.37587919e+00,\n", + " 7.37587919e+00, 7.89137582e+00, 7.89137582e+00,\n", + " 7.89137582e+00, 7.89137582e+00, 7.37587919e+00,\n", + " 7.37587919e+00, 6.30241681e+00, 6.30241681e+00,\n", + " 4.54448593e+00, 4.54448593e+00, 2.22044605e-16]))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "\n", + "evaluated above (array([ 1.06060606, 1.16161616, 1.26262626, 1.36363636, 1.46464646,\n", + " 1.56565657]), array([ 0.26007649, 0.21290989, 0.1657433 , 0.1185767 , 0.0714101 ,\n", + " 0.02424351]))order is 5\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.87371033, 0.88669005, 0.89604935, 0.90404653, 0.91152129,\n", + " 0.91899606, 0.92699323, 0.93635253, 0.94933226]))\n", + "\n", + "input quantiles are [ 0.87371033 0.88669005 0.89604935 0.90404653 0.91152129 0.91899606\n", + " 0.92699323 0.93635253 0.94933226]divided into (array([], dtype=int64), array([57, 58]), array([], dtype=int64))\n", + "\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "complete evaluated quantile PDF: (array([ 0.84775087, 0.87371033, 0.88669005, 0.88669005, 0.89604935,\n", + " 0.89604935, 0.90404653, 0.90404653, 0.91152129, 0.91152129,\n", + " 0.91899606, 0.91899606, 0.92699323, 0.92699323, 0.93635253,\n", + " 0.93635253, 0.94933226, 0.97529172]), array([ 2.22044605e-16, 7.70432123e+00, 7.70432123e+00,\n", + " 1.06845624e+01, 1.06845624e+01, 1.25044160e+01,\n", + " 1.25044160e+01, 1.33783436e+01, 1.33783436e+01,\n", + " 1.33783436e+01, 1.33783436e+01, 1.25044160e+01,\n", + " 1.25044160e+01, 1.06845624e+01, 1.06845624e+01,\n", + " 7.70432123e+00, 7.70432123e+00, 2.22044605e-16]))evaluated inside (array([ 0.75757576, 0.85858586]), array([ 3.81138379, 5.77321742]))\n", + "\n", + "evaluated below (array([], dtype=float64), array([], dtype=float64))\n", + "order is 5\n", + "evaluated above (array([], dtype=float64), array([], dtype=float64))\n", + "divided into (array([58]), array([], dtype=int64), array([59]))\n", + "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.33570561, 0.34266231, 0.34767858, 0.35196481, 0.35597103,\n", + " 0.35997726, 0.36426348, 0.36927975, 0.37623646]))evaluated inside (array([], dtype=float64), array([], dtype=float64))\n", + "\n", + "evaluated below (array([ 0.85858586]), array([ 2.48589346]))\n", + "evaluated above (array([ 0.95959596]), array([ 3.60110922]))\n", + "input quantiles are [ 0.33570561 0.34266231 0.34767858 0.35196481 0.35597103 0.35997726\n", + " 0.36426348 0.36927975 0.37623646]\n", + "input shape: (9, 8), output shape: (18, 18)\n", + "complete evaluated quantile PDF: (array([ 0.3217922 , 0.33570561, 0.34266231, 0.34266231, 0.34767858,\n", + " 0.34767858, 0.35196481, 0.35196481, 0.35597103, 0.35597103,\n", + " 0.35997726, 0.35997726, 0.36426348, 0.36426348, 0.36927975,\n", + " 0.36927975, 0.37623646, 0.39014987]), array([ 2.22044605e-16, 1.43746220e+01, 1.43746220e+01,\n", + " 1.99351171e+01, 1.99351171e+01, 2.33305762e+01,\n", + " 2.33305762e+01, 2.49611389e+01, 2.49611389e+01,\n", + " 2.49611389e+01, 2.49611389e+01, 2.33305762e+01,\n", + " 2.33305762e+01, 1.99351171e+01, 1.99351171e+01,\n", + " 1.43746220e+01, 1.43746220e+01, 2.22044605e-16]))\n", + "order is 5\n", + "divided into (array([], dtype=int64), array([53]), array([], dtype=int64))\n", + "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", + "evaluated inside (array([ 0.35353535]), array([ 24.93098564]))\n", + "evaluated below (array([], dtype=float64), array([], dtype=float64))\n", + "evaluated above (array([], dtype=float64), array([], dtype=float64))\n" + ] + } + ], "source": [ "E = qp.Ensemble(N, funcform=in_dists, vb=True)" ] @@ -610,6 +1731,88 @@ "E.integrate(demo_limits, using='mix_mod')" ] }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "def stack(ensemble, loc, using, vb=True):\n", + " \"\"\"\n", + " Produces an average of the PDFs in the ensemble\n", + "\n", + " Parameters\n", + " ----------\n", + " ensemble: qp.Ensemble\n", + " the ensemble of PDFs to stack\n", + " loc: ndarray, float or float\n", + " location(s) at which to evaluate the PDFs\n", + " using: string\n", + " which parametrization to use for the approximation\n", + " vb: boolean\n", + " report on progress\n", + "\n", + " Returns\n", + " -------\n", + " stacked: dict, tuple, ndarray, float\n", + " pair of arrays for locations where approximations were evaluated\n", + " and the values of the stacked PDFs at those points\n", + "\n", + " Notes\n", + " -----\n", + " Stacking refers to taking the sum of PDFs evaluated on a shared grid and normalizing it such that it integrates to unity. This is equivalent to calculating an average probability (based on the PDFs in the ensemble) over the grid. This probably should be done in a script and not by qp! The right way to do it would be to call qp.Ensemble.evaluate() and sum those outputs appropriately.\n", + " TO DO: make this do something more efficient for mixmod, grid, histogram, samples\n", + " \"\"\"\n", + "# loc_range = max(loc) - min(loc)\n", + "# delta = loc_range / len(loc)\n", + "# loc_delta = loc[1:] - loc[:-1]\n", + " evaluated = ensemble.evaluate(loc, using=using, norm=True, vb=vb)\n", + " stack = np.mean(evaluated[1], axis=0)\n", + "# stack /= np.sum(stack) * loc_delta\n", + "# assert(np.isclose(np.sum(stack) * loc_delta, 1.))\n", + "# stacked[using] = (evaluated[0], stack)\n", + " return (evaluated[0], stack)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "stacked = stack(E, eval_range, using='quantiles')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAD7CAYAAACPDORaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nLLpPkwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(stacked[0], stacked[-1])" + ] + }, { "cell_type": "markdown", "metadata": {}, diff --git a/qp/ensemble.py b/qp/ensemble.py index e4923029..fcdede02 100644 --- a/qp/ensemble.py +++ b/qp/ensemble.py @@ -110,7 +110,7 @@ def __init__(self, N, funcform=None, quantiles=None, histogram=None, gridded=Non self.make_pdfs() - self.stacked = {} + # self.stacked = {} self.klds = {} def make_pdfs(self): @@ -523,39 +523,39 @@ def rmse_helper(i): return rmses - def stack(self, loc, using, vb=True): - """ - Produces an average of the PDFs in the ensemble - - Parameters - ---------- - loc: ndarray, float or float - location(s) at which to evaluate the PDFs - using: string - which parametrization to use for the approximation - vb: boolean - report on progress - - Returns - ------- - self.stacked: tuple, ndarray, float - pair of arrays for locations where approximations were evaluated - and the values of the stacked PDFs at those points - - Notes - ----- - Stacking refers to taking the sum of PDFs evaluated on a shared grid and normalizing it such that it integrates to unity. This is equivalent to calculating an average probability (based on the PDFs in the ensemble) over the grid. This probably should be done in a script and not by qp! The right way to do it would be to call qp.Ensemble.evaluate() and sum those outputs appropriately. - TO DO: make this do something more efficient for mixmod, grid, histogram, samples - TO DO: enable stacking on irregular grid - """ - loc_range = max(loc) - min(loc) - delta = loc_range / len(loc) - evaluated = self.evaluate(loc, using=using, norm=True, vb=vb) - stack = np.mean(evaluated[1], axis=0) - stack /= np.sum(stack) * delta - assert(np.isclose(np.sum(stack) * delta, 1.)) - self.stacked[using] = (evaluated[0], stack) - return self.stacked + # def stack(self, loc, using, vb=True): + # """ + # Produces an average of the PDFs in the ensemble + # + # Parameters + # ---------- + # loc: ndarray, float or float + # location(s) at which to evaluate the PDFs + # using: string + # which parametrization to use for the approximation + # vb: boolean + # report on progress + # + # Returns + # ------- + # self.stacked: tuple, ndarray, float + # pair of arrays for locations where approximations were evaluated + # and the values of the stacked PDFs at those points + # + # Notes + # ----- + # Stacking refers to taking the sum of PDFs evaluated on a shared grid and normalizing it such that it integrates to unity. This is equivalent to calculating an average probability (based on the PDFs in the ensemble) over the grid. This probably should be done in a script and not by qp! The right way to do it would be to call qp.Ensemble.evaluate() and sum those outputs appropriately. + # TO DO: make this do something more efficient for mixmod, grid, histogram, samples + # TO DO: enable stacking on irregular grid + # """ + # loc_range = max(loc) - min(loc) + # delta = loc_range / len(loc) + # evaluated = self.evaluate(loc, using=using, norm=True, vb=vb) + # stack = np.mean(evaluated[1], axis=0) + # stack /= np.sum(stack) * delta + # assert(np.isclose(np.sum(stack) * delta, 1.)) + # self.stacked[using] = (evaluated[0], stack) + # return self.stacked # Note: A copious quantity of commented code has been removed in this commit! # For future reference, it can still be found here: From 5ed0e48f80e07c80fd5a4d163f9a519faf13edf2 Mon Sep 17 00:00:00 2001 From: Alex Malz Date: Sun, 25 Mar 2018 11:52:23 -0400 Subject: [PATCH 6/7] just updating plots and paper for new wording --- .../figures/graham_nz_err.pdf | Bin 173036 -> 173045 bytes .../figures/graham_nz_kld.pdf | Bin 165446 -> 165446 bytes .../figures/graham_pz_err.pdf | Bin 170687 -> 170701 bytes .../figures/graham_pz_kld.pdf | Bin 103214 -> 103227 bytes .../figures/schmidt_nz_err.pdf | Bin 173068 -> 173070 bytes .../figures/schmidt_nz_kld.pdf | Bin 165439 -> 165439 bytes .../figures/schmidt_pz_err.pdf | Bin 205585 -> 170667 bytes .../figures/schmidt_pz_kld.pdf | Bin 103165 -> 103256 bytes .../main.bib | 1 - .../main.tex | 9 +++++---- 10 files changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/desc-0000-qp-photo-z_approximation/figures/graham_nz_err.pdf b/docs/desc-0000-qp-photo-z_approximation/figures/graham_nz_err.pdf index b2594bf6485154f3f1c4d157b11e48b90bec01cf..d748b0e358e47336ca6261ff13dd45be1e452cb6 100644 GIT binary patch delta 4839 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 delta 4799 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 B9$EkZ delta 110 zcmX@s!*#5OtD%K)3zJ8qfr)~lv4Vj@kb=IOp@N|~lxd`3WC~@PDi~QpnZ^o6hSMt= vnPjFvYh+TNKBbXKdpd6ulhyP+Ag+58(=u*zLjxc*H#Igk+y0}8$&VQTU#}iN diff --git a/docs/desc-0000-qp-photo-z_approximation/figures/graham_pz_err.pdf b/docs/desc-0000-qp-photo-z_approximation/figures/graham_pz_err.pdf index 2b68c138f8994d01938f7bb1220e6c50a559e065..b2e559bf8dfd15a89513e70764651d2291a5ab42 100644 GIT binary patch delta 4780 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 N0MkiGppA9u{tHMd7R&$u delta 4765 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 diff --git a/docs/desc-0000-qp-photo-z_approximation/figures/graham_pz_kld.pdf b/docs/desc-0000-qp-photo-z_approximation/figures/graham_pz_kld.pdf index ed91efce910e86b0d956f782644e2437c68a6ea5..995121e181d9d7979f251852130e9cf8a15e45f3 100644 GIT binary patch delta 4580 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 delta 4565 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 HRHFVLPmBx6 diff --git a/docs/desc-0000-qp-photo-z_approximation/figures/schmidt_nz_err.pdf b/docs/desc-0000-qp-photo-z_approximation/figures/schmidt_nz_err.pdf index 516df86f02fdc58336a02330ad4fb914fc52c2ac..4efb8c91ad288e04c2684be0a0c416d78c577abc 100644 GIT binary patch delta 4934 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 delta 4824 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 a6N;foC>o6>*5?AR(;*pzgfMz)4F3T|XnV~7 diff --git a/docs/desc-0000-qp-photo-z_approximation/figures/schmidt_nz_kld.pdf b/docs/desc-0000-qp-photo-z_approximation/figures/schmidt_nz_kld.pdf index 17f42967c71f8dced8fe6d3095cd7595c6c1373f..a48c3efe6df48dcc55944f878ac0eb634e277991 100644 GIT binary patch delta 72 zcmdnr!?nMMtD%K)3sZO_zoCMmxq^X0kb=IOk%E!w^t47M_35`8nY5>G0kL{P1X~l+ X18xfgBSTX|BV#ioqwOD?nEaRlK!g@q delta 72 zcmdnr!?nMMtD%K)3sZO_zmbBGse*w*kb=IOp@O0L^t47M_38IP#10VA+sLFnovn%K W0k^rK0T7y-8XH+||JcOj#|!{LaTa9& diff --git a/docs/desc-0000-qp-photo-z_approximation/figures/schmidt_pz_err.pdf b/docs/desc-0000-qp-photo-z_approximation/figures/schmidt_pz_err.pdf index dcd9345a93dd810123c4e3aa6892af5370212a93..d1f89b9ef0932929ad98976a9e3e9e81f5e82de3 100644 GIT binary patch delta 4902 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 L85tcDUAF%LAX_@q delta 39750 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 b*TvPu+11n8!jcH%BOnMPVr7+iB1`l?BZ`ao diff --git a/docs/desc-0000-qp-photo-z_approximation/figures/schmidt_pz_kld.pdf b/docs/desc-0000-qp-photo-z_approximation/figures/schmidt_pz_kld.pdf index 3d4f0cd1c7cd33657d1d6990939073be51707baf..760026d96773b38fe5fe1411c0b9da7d25223938 100644 GIT binary patch delta 4607 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 B9;*NV delta 4472 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 diff --git a/docs/desc-0000-qp-photo-z_approximation/main.bib b/docs/desc-0000-qp-photo-z_approximation/main.bib index 1a7acfa1..e8a559a5 100644 --- a/docs/desc-0000-qp-photo-z_approximation/main.bib +++ b/docs/desc-0000-qp-photo-z_approximation/main.bib @@ -407,7 +407,6 @@ @article{radovich_searching_2017 @article{de_jong_third_2017, title = {The third data release of the {Kilo}-{Degree} {Survey} and associated data products}, volume = {604}, - url = {https://ui.adsabs.harvard.edu/#abs/2017A&A...604A.134D/abstract}, doi = {10.1051/0004-6361/201730747}, journal = {Astronomy and Astrophysics}, author = {de Jong, A. Jelte T. and A, Jelte T. and Kleijn, Gijs A. Verdoes and Erben, Thomas and Hildebrandt, Hendrik and Kuijken, Konrad and Sikkema, Gert and Brescia, Massimo and Bilicki, Maciej and Napolitano, Nicola R. and Amaro, Valeria and Begeman, Kor G. and Boxhoorn, Danny R. and Buddelmeijer, Hugo and Cavuoti, Stefano and Getman, Fedor and Grado, Aniello and Helmich, Ewout and Huang, Zhuoyi and Irisarri, Nancy and La Barbera, Francesco and Longo, Giuseppe and McFarland, John P. and Nakajima, Reiko and Paolillo, Maurizio and Puddu, Emanuella and Radovich, Mario and Rifatto, Agatino and Tortora, Crescenzo and Valentijn, Edwin A. and Vellucci, Civita and Vriend, Willem-Jan and Amon, Alexandra and Blake, Chris and Choi, Ami and Conti, Ian Fenech and Gwyn, Stephen D. J. and Herbonnet, Ricardo and Heymans, Catherine and Hoekstra, Henk and Klaes, Dominik and Merten, Julian and Miller, Lance and Schneider, Peter and Viola, Massimo}, diff --git a/docs/desc-0000-qp-photo-z_approximation/main.tex b/docs/desc-0000-qp-photo-z_approximation/main.tex index 5d45c258..cc3b7bea 100644 --- a/docs/desc-0000-qp-photo-z_approximation/main.tex +++ b/docs/desc-0000-qp-photo-z_approximation/main.tex @@ -465,7 +465,7 @@ \subsection{Comparison Metrics} of a PDF. We note that $M_{0}[P]=1$ for all properly normalized probability distributions, $M_{1}[P]=\bar{z}$ is the \textit{mean}, $M_{2}[P]$ is the -\textit{variance}, and $M_{3}[P]$ is the \textit{kurtosis}. +\textit{variance}, and $M_{3}[P]$ is the \textit{skewness}. Though the first few moments are not in general sufficient to characterize a highly structured probability distribution, they are included in this analysis because they can prove useful in setting ballpark estimates of the influence of @@ -705,7 +705,7 @@ \subsection{Individual \pz s} \includegraphics[width=\columnwidth]{graham_pz_kld.pdf} \includegraphics[width=\columnwidth]{schmidt_pz_kld.pdf} \caption{ - The means of the mean ($\pentagon$), variance ($\bigstar$), and kurtosis + The means of the mean ($\pentagon$), variance ($\bigstar$), and skewness ($\APLstar$) of the log-KLD distributions for each dataset as a function of the number $N_{f}$ of stored parameters for the quantile (dashed purple line), samples (dash-dotted green line), and histogram (dotted orange line) formats @@ -762,7 +762,7 @@ \subsection{Individual \pz s} \includegraphics[width=\columnwidth]{schmidt_pz_err.pdf} \caption{ The median $\log_{10}$-percent errors on the mean ($\pentagon$), variance -($\bigstar$), and kurtosis ($\APLstar$) of the \pz s for each dataset as a +($\bigstar$), and skewness ($\APLstar$) of the \pz s for each dataset as a function of the number $N_{f}$ of stored parameters per \pz\ for the quantile (dashed purple line), samples (dash-dotted green line), and histogram (dotted orange line) formats with interquartile range error bars based on 10 @@ -952,7 +952,7 @@ \subsection{Stacked $\hat{n}(z)$ estimator} \includegraphics[width=\columnwidth]{schmidt_nz_err.pdf} \caption{ The percent error on the mean ($\pentagon$), variance ($\bigstar$), and -kurtosis ($\APLstar$) of the stacked estimator $hat{n}(z)$ of the redshift +skewness ($\APLstar$) of the stacked estimator $hat{n}(z)$ of the redshift distribution for each dataset as a function of the number $N_{f}$ of stored parameters for the quantile (dashed purple line), samples (dash-dotted greenline), and histogram (dotted orangeline) formats with interquartile range @@ -1194,6 +1194,7 @@ \subsection*{Acknowledgments} \input{acknowledgments} + \bibliography{lsstdesc,main} \end{document} From 47604e20fe738d896c43555a2f4efba5006fdbc4 Mon Sep 17 00:00:00 2001 From: Alex Malz Date: Sun, 25 Mar 2018 17:48:03 -0400 Subject: [PATCH 7/7] documenting the new demo of ensembles --- docs/notebooks/demo.ipynb | 1216 +------------------------------------ 1 file changed, 23 insertions(+), 1193 deletions(-) diff --git a/docs/notebooks/demo.ipynb b/docs/notebooks/demo.ipynb index 724a286b..0009129c 100644 --- a/docs/notebooks/demo.ipynb +++ b/docs/notebooks/demo.ipynb @@ -557,7 +557,11 @@ "collapsed": true }, "source": [ - "### PDF Ensembles" + "### PDF Ensembles\n", + "\n", + "`qp` also includes infrastructure for handling ensembles of `PDF` objects with shared metaparameters, such as histogram bin ends, but unique per-object parameters, such as histogram bin heights. A `qp.Ensemble` object takes as input the number of items in the ensemble and, optionally, a list, with contents corresponding to one of the built-in formats.\n", + "\n", + "Let's demonstrate on PDFs with a functional form, which means the list of information for each member of the ensemble is `scipy.stats.rv_continuous` or `qp.composite` objects." ] }, { @@ -570,1137 +574,16 @@ "in_dists = []\n", "for i in range(N):\n", " dist = sps.norm(loc=sps.uniform.rvs(), scale=sps.uniform.rvs())\n", - " in_dists.append(dist)" + " in_dists.append(dist)\n", + " \n", + "E = qp.Ensemble(N, funcform=in_dists, vb=True) " ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.78202054, 0.81910725, 0.84584937, 0.86869953, 0.89005703,\n", - " 0.91141452, 0.93426468, 0.9610068 , 0.99809351]))\n", - "input quantiles are [ 0.78202054 0.81910725 0.84584937 0.86869953 0.89005703 0.91141452\n", - " 0.93426468 0.9610068 0.99809351]\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "complete evaluated quantile PDF: (array([ 0.70784713, 0.78202054, 0.81910725, 0.81910725, 0.84584937,\n", - " 0.84584937, 0.86869953, 0.86869953, 0.89005703, 0.89005703,\n", - " 0.91141452, 0.91141452, 0.93426468, 0.93426468, 0.9610068 ,\n", - " 0.9610068 , 0.99809351, 1.07226692]), array([ 2.22044605e-16, 2.69638403e+00, 2.69638403e+00,\n", - " 3.73941878e+00, 3.73941878e+00, 4.37633721e+00,\n", - " 4.37633721e+00, 4.68219730e+00, 4.68219730e+00,\n", - " 4.68219730e+00, 4.68219730e+00, 4.37633721e+00,\n", - " 4.37633721e+00, 3.73941878e+00, 3.73941878e+00,\n", - " 2.69638403e+00, 2.69638403e+00, 2.22044605e-16]))\n", - "order is 5\n", - "divided into (array([57]), array([58, 59]), array([60]))\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "evaluated inside (array([ 0.85858586, 0.95959596]), array([ 4.4138218, 3.3677309]))\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.2966362 , 0.08228443, 0.35551287, 0.58897649, 0.80718932,\n", - " 1.02540215, 1.25886577, 1.5320942 , 1.91101483]))evaluated below (array([ 0.75757576]), array([ 1.39751068]))\n", - "\n", - "evaluated above (array([ 1.06060606]), array([ 0.32770206]))\n", - "input quantiles are [-0.2966362 0.08228443 0.35551287 0.58897649 0.80718932 1.02540215\n", - " 1.25886577 1.5320942 1.91101483]\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "complete evaluated quantile PDF: (array([-1.05447745, -0.2966362 , 0.08228443, 0.08228443, 0.35551287,\n", - " 0.35551287, 0.58897649, 0.58897649, 0.80718932, 0.80718932,\n", - " 1.02540215, 1.02540215, 1.25886577, 1.25886577, 1.5320942 ,\n", - " 1.5320942 , 1.91101483, 2.66885609]), array([ 2.22044605e-16, 2.63907511e-01, 2.63907511e-01,\n", - " 3.65994121e-01, 3.65994121e-01, 4.28332258e-01,\n", - " 4.28332258e-01, 4.58268192e-01, 4.58268192e-01,\n", - " 4.58268192e-01, 4.58268192e-01, 4.28332258e-01,\n", - " 4.28332258e-01, 3.65994121e-01, 3.65994121e-01,\n", - " 2.63907511e-01, 2.63907511e-01, 2.22044605e-16]))\n", - "order is 5\n", - "divided into (array([40, 41, 42, 43, 44, 45, 46]), array([47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,\n", - " 64, 65, 66, 67, 68]), array([69, 70, 71, 72, 73, 74, 75]))\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "evaluated inside (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", - " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", - " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", - " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667,\n", - " 1.76767677, 1.86868687]), array([ 0.21737113, 0.24923911, 0.2820813 , 0.31489295, 0.34667479,\n", - " 0.37643304, 0.40317944, 0.42593824, 0.44382821, 0.45614871,\n", - " 0.46240587, 0.46234979, 0.45598269, 0.44355893, 0.42557638,\n", - " 0.40273907, 0.37593098, 0.34612842, 0.31431978, 0.28149891,\n", - " 0.24866518, 0.21682346]))\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.160167 , 0.38573089, 0.54837833, 0.68735456, 0.81725231,\n", - " 0.94715006, 1.0861263 , 1.24877373, 1.47433762]))evaluated below (array([-0.95959596, -0.85858586, -0.75757576, -0.65656566, -0.55555556,\n", - " -0.45454545, -0.35353535]), array([ 0.0255429 , 0.05273567, 0.07992845, 0.10712122, 0.13431399,\n", - " 0.16150677, 0.18869954]))\n", - "\n", - "input quantiles are [ 0.160167 0.38573089 0.54837833 0.68735456 0.81725231 0.94715006\n", - " 1.0861263 1.24877373 1.47433762]evaluated above (array([ 1.96969697, 2.07070707, 2.17171717, 2.27272727, 2.37373737,\n", - " 2.47474747, 2.57575758]), array([ 0.18821955, 0.16102677, 0.133834 , 0.10664123, 0.07944845,\n", - " 0.05225568, 0.02506291]))\n", - "\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "complete evaluated quantile PDF: (array([-0.29096079, 0.160167 , 0.38573089, 0.38573089, 0.54837833,\n", - " 0.54837833, 0.68735456, 0.68735456, 0.81725231, 0.81725231,\n", - " 0.94715006, 0.94715006, 1.0861263 , 1.0861263 , 1.24877373,\n", - " 1.24877373, 1.47433762, 1.92546541]), array([ 2.22044605e-16, 4.43333367e-01, 4.43333367e-01,\n", - " 6.14826782e-01, 6.14826782e-01, 7.19547470e-01,\n", - " 7.19547470e-01, 7.69836295e-01, 7.69836295e-01,\n", - " 7.69836295e-01, 7.69836295e-01, 7.19547470e-01,\n", - " 7.19547470e-01, 6.14826782e-01, 6.14826782e-01,\n", - " 4.43333367e-01, 4.43333367e-01, 2.22044605e-16]))\n", - "order is 5\n", - "divided into (array([47, 48, 49, 50, 51]), array([52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64]), array([65, 66, 67, 68]))\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "evaluated inside (array([ 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", - " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", - " 1.26262626, 1.36363636, 1.46464646]), array([ 0.42412498, 0.51690141, 0.60584365, 0.68304285, 0.74079776,\n", - " 0.77282717, 0.77555359, 0.74867101, 0.69518996, 0.62096562,\n", - " 0.53357031, 0.44089914, 0.35092118]))input quantiles are [-0.83837651 -0.40009051 -0.08405547 0.18598482 0.43838498 0.69078514\n", - " 0.96082543 1.27686047 1.71514647]\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.83837651, -0.40009051, -0.08405547, 0.18598482, 0.43838498,\n", - " 0.69078514, 0.96082543, 1.27686047, 1.71514647]))evaluated below (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515]), array([ 0.02919974, 0.1059378 , 0.18267587, 0.25941393, 0.336152 ]))\n", - "\n", - "evaluated above (array([ 1.56565657, 1.66666667, 1.76767677, 1.86868687]), array([ 0.27334924, 0.19661117, 0.11987311, 0.04313505]))\n", - "\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "complete evaluated quantile PDF: (array([-1.71494851, -0.83837651, -0.40009051, -0.40009051, -0.08405547,\n", - " -0.08405547, 0.18598482, 0.18598482, 0.43838498, 0.43838498,\n", - " 0.69078514, 0.69078514, 0.96082543, 0.96082543, 1.27686047,\n", - " 1.27686047, 1.71514647, 2.59171847]), array([ 2.22044605e-16, 2.28161521e-01, 2.28161521e-01,\n", - " 3.16420609e-01, 3.16420609e-01, 3.70315112e-01,\n", - " 3.70315112e-01, 3.96196256e-01, 3.96196256e-01,\n", - " 3.96196256e-01, 3.96196256e-01, 3.70315112e-01,\n", - " 3.70315112e-01, 3.16420609e-01, 3.16420609e-01,\n", - " 2.28161521e-01, 2.28161521e-01, 2.22044605e-16]))\n", - "order is 5\n", - "divided into (array([33, 34, 35, 36, 37, 38, 39, 40, 41]), array([42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,\n", - " 59, 60, 61, 62, 63, 64, 65, 66]), array([67, 68, 69, 70, 71, 72, 73, 74, 75]))\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.4716778 , -0.23109047, -0.05761009, 0.09062251, 0.22917195,\n", - " 0.36772139, 0.51595399, 0.68943438, 0.9300217 ]))evaluated inside (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", - " -0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", - " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", - " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", - " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667]), array([ 0.19482262, 0.21884383, 0.24341678, 0.26798028, 0.29197582,\n", - " 0.31484752, 0.33604216, 0.35500922, 0.37121226, 0.38418021,\n", - " 0.39353248, 0.39898817, 0.40038408, 0.3976788 , 0.39095271,\n", - " 0.38040776, 0.36635886, 0.34921595, 0.32947641, 0.30768512,\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 0.2843935 , 0.26015563, 0.2355282 , 0.21107062, 0.1873449 ]))\n", - "\n", - "input quantiles are [-0.4716778 -0.23109047 -0.05761009 0.09062251 0.22917195 0.36772139\n", - " 0.51595399 0.68943438 0.9300217 ]evaluated below (array([-1.66666667, -1.56565657, -1.46464646, -1.36363636, -1.26262626,\n", - " -1.16161616, -1.06060606, -0.95959596, -0.85858586]), array([ 0.00971525, 0.03004045, 0.05036565, 0.07069084, 0.09101604,\n", - " 0.11134124, 0.13166644, 0.15199164, 0.17231684]))\n", - "\n", - "evaluated above (array([ 1.76767677, 1.86868687, 1.96969697, 2.07070707, 2.17171717,\n", - " 2.27272727, 2.37373737, 2.47474747, 2.57575758]), array([ 0.16581324, 0.14548804, 0.12516284, 0.10483764, 0.08451244,\n", - " 0.06418724, 0.04386204, 0.02353684, 0.00321164]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "\n", - "complete evaluated quantile PDF: (array([-0.95285245, -0.4716778 , -0.23109047, -0.23109047, -0.05761009,\n", - " -0.05761009, 0.09062251, 0.09062251, 0.22917195, 0.22917195,\n", - " 0.36772139, 0.36772139, 0.51595399, 0.51595399, 0.68943438,\n", - " 0.68943438, 0.9300217 , 1.41119635]), array([ 2.22044605e-16, 4.15649494e-01, 4.15649494e-01,\n", - " 5.76434034e-01, 5.76434034e-01, 6.74615457e-01,\n", - " 6.74615457e-01, 7.21764005e-01, 7.21764005e-01,\n", - " 7.21764005e-01, 7.21764005e-01, 6.74615457e-01,\n", - " 6.74615457e-01, 5.76434034e-01, 5.76434034e-01,\n", - " 4.15649494e-01, 4.15649494e-01, 2.22044605e-16]))Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.22752249, 0.08081044, 0.30314018, 0.49311274, 0.67067553,\n", - " 0.84823831, 1.03821087, 1.26054061, 1.56887354]))\n", - "order is 5\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "divided into (array([41, 42, 43, 44]), array([45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58]), array([59, 60, 61, 62, 63]))\n", - "\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.63410249, -0.34639065, -0.13893017, 0.03833716, 0.20402467,\n", - " 0.36971217, 0.5469795 , 0.75443998, 1.04215182]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "input quantiles are [-0.22752249 0.08081044 0.30314018 0.49311274 0.67067553 0.84823831\n", - " 1.03821087 1.26054061 1.56887354]evaluated inside (array([-0.45454545, -0.35353535, -0.25252525, -0.15151515, -0.05050505,\n", - " 0.05050505, 0.15151515, 0.25252525, 0.35353535, 0.45454545,\n", - " 0.55555556, 0.65656566, 0.75757576, 0.85858586]), array([ 0.33411094, 0.41342215, 0.4949481 , 0.5725297 , 0.64006113,\n", - " 0.69158671, 0.72217601, 0.72882471, 0.71087657, 0.6701044 ,\n", - " 0.61047089, 0.53753679, 0.4573692 , 0.37609858]))input quantiles are [-0.63410249 -0.34639065 -0.13893017 0.03833716 0.20402467 0.36971217\n", - " 0.5469795 0.75443998 1.04215182]\n", - "\n", - "\n", - "\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "evaluated below (array([-0.85858586, -0.75757576, -0.65656566, -0.55555556]), array([ 0.06295026, 0.13040376, 0.19785727, 0.26531077]))\n", - "evaluated above (array([ 0.95959596, 1.06060606, 1.16161616, 1.26262626, 1.36363636]), array([ 0.30157409, 0.23412058, 0.16666708, 0.09921357, 0.03176007]))\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.75426818, 0.77627287, 0.7921398 , 0.8056975 , 0.81836957,\n", - " 0.83104163, 0.84459933, 0.86046626, 0.88247095]))\n", - "complete evaluated quantile PDF: (array([-0.84418835, -0.22752249, 0.08081044, 0.08081044, 0.30314018,\n", - " 0.30314018, 0.49311274, 0.49311274, 0.67067553, 0.67067553,\n", - " 0.84823831, 0.84823831, 1.03821087, 1.03821087, 1.26054061,\n", - " 1.26054061, 1.56887354, 2.1855394 ]), array([ 2.22044605e-16, 3.24324747e-01, 3.24324747e-01,\n", - " 4.49782389e-01, 4.49782389e-01, 5.26391805e-01,\n", - " 5.26391805e-01, 5.63181074e-01, 5.63181074e-01,\n", - " 5.63181074e-01, 5.63181074e-01, 5.26391805e-01,\n", - " 5.26391805e-01, 4.49782389e-01, 4.49782389e-01,\n", - " 3.24324747e-01, 3.24324747e-01, 2.22044605e-16]))input quantiles are [ 0.75426818 0.77627287 0.7921398 0.8056975 0.81836957 0.83104163\n", - " 0.84459933 0.86046626 0.88247095]complete evaluated quantile PDF: (array([-1.20952616, -0.63410249, -0.34639065, -0.34639065, -0.13893017,\n", - " -0.13893017, 0.03833716, 0.03833716, 0.20402467, 0.20402467,\n", - " 0.36971217, 0.36971217, 0.5469795 , 0.5469795 , 0.75443998,\n", - " 0.75443998, 1.04215182, 1.61757549]), array([ 2.22044605e-16, 3.47569988e-01, 3.47569988e-01,\n", - " 4.82019521e-01, 4.82019521e-01, 5.64119744e-01,\n", - " 5.64119744e-01, 6.03545800e-01, 6.03545800e-01,\n", - " 6.03545800e-01, 6.03545800e-01, 5.64119744e-01,\n", - " 5.64119744e-01, 4.82019521e-01, 4.82019521e-01,\n", - " 3.47569988e-01, 3.47569988e-01, 2.22044605e-16]))\n", - "\n", - "order is 5\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "\n", - "divided into (array([42, 43, 44, 45, 46, 47]), array([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,\n", - " 65]), array([66, 67, 68, 69, 70, 71]))complete evaluated quantile PDF: (array([ 0.7102588 , 0.75426818, 0.77627287, 0.77627287, 0.7921398 ,\n", - " 0.7921398 , 0.8056975 , 0.8056975 , 0.81836957, 0.81836957,\n", - " 0.83104163, 0.83104163, 0.84459933, 0.84459933, 0.86046626,\n", - " 0.86046626, 0.88247095, 0.92648033]), array([ 2.22044605e-16, 4.54448593e+00, 4.54448593e+00,\n", - " 6.30241681e+00, 6.30241681e+00, 7.37587919e+00,\n", - " 7.37587919e+00, 7.89137582e+00, 7.89137582e+00,\n", - " 7.89137582e+00, 7.89137582e+00, 7.37587919e+00,\n", - " 7.37587919e+00, 6.30241681e+00, 6.30241681e+00,\n", - " 4.54448593e+00, 4.54448593e+00, 2.22044605e-16]))order is 5\n", - "\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "divided into (array([38, 39, 40, 41, 42, 43]), array([44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59]), array([60, 61, 62, 63, 64, 65]))\n", - "\n", - "order is 5\n", - "evaluated inside (array([-0.15151515, -0.05050505, 0.05050505, 0.15151515, 0.25252525,\n", - " 0.35353535, 0.45454545, 0.55555556, 0.65656566, 0.75757576,\n", - " 0.85858586, 0.95959596, 1.06060606, 1.16161616, 1.26262626,\n", - " 1.36363636, 1.46464646, 1.56565657]), array([ 0.28602048, 0.3351863 , 0.38482262, 0.43264808, 0.4763967 ,\n", - " 0.51381924, 0.54278436, 0.56158655, 0.56909352, 0.56485326,\n", - " 0.54912047, 0.52284566, 0.48758443, 0.44537765, 0.39846372,\n", - " 0.34910432, 0.29957652, 0.25217281]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "divided into (array([], dtype=int64), array([57, 58]), array([], dtype=int64))\n", - "evaluated inside (array([-0.55555556, -0.45454545, -0.35353535, -0.25252525, -0.15151515,\n", - " -0.05050505, 0.05050505, 0.15151515, 0.25252525, 0.35353535,\n", - " 0.45454545, 0.55555556, 0.65656566, 0.75757576, 0.85858586,\n", - " 0.95959596]), array([ 0.31070451, 0.36735297, 0.42415121, 0.47809387, 0.52619741,\n", - " 0.56551778, 0.59343513, 0.60804399, 0.60833168, 0.59427839,\n", - " 0.56685819, 0.52794447, 0.48013393, 0.42636629, 0.36962427,\n", - " 0.31291232]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "\n", - "evaluated inside (array([ 0.75757576, 0.85858586]), array([ 3.81138379, 5.77321742]))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "\n", - "evaluated below (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", - " -0.25252525]), array([ 0.0352149 , 0.07628352, 0.11735215, 0.15842078, 0.1994894 ,\n", - " 0.24055803]))Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.87371033, 0.88669005, 0.89604935, 0.90404653, 0.91152129,\n", - " 0.91899606, 0.92699323, 0.93635253, 0.94933226]))evaluated below (array([-1.16161616, -1.06060606, -0.95959596, -0.85858586, -0.75757576,\n", - " -0.65656566]), array([ 0.02237154, 0.06953814, 0.11670474, 0.16387133, 0.21103793,\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 0.25820452]))evaluated below (array([], dtype=float64), array([], dtype=float64))\n", - "\n", - "evaluated above (array([], dtype=float64), array([], dtype=float64))\n", - "\n", - "\n", - "evaluated above (array([ 1.66666667, 1.76767677, 1.86868687, 1.96969697, 2.07070707,\n", - " 2.17171717]), array([ 0.21096297, 0.16989434, 0.12882571, 0.08775709, 0.04668846,\n", - " 0.00561984]))evaluated above (array([ 1.06060606, 1.16161616, 1.26262626, 1.36363636, 1.46464646,\n", - " 1.56565657]), array([ 0.26007649, 0.21290989, 0.1657433 , 0.1185767 , 0.0714101 ,\n", - " 0.02424351]))input quantiles are [ 0.87371033 0.88669005 0.89604935 0.90404653 0.91152129 0.91899606\n", - " 0.92699323 0.93635253 0.94933226]\n", - "\n", - "\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "complete evaluated quantile PDF: (array([ 0.84775087, 0.87371033, 0.88669005, 0.88669005, 0.89604935,\n", - " 0.89604935, 0.90404653, 0.90404653, 0.91152129, 0.91152129,\n", - " 0.91899606, 0.91899606, 0.92699323, 0.92699323, 0.93635253,\n", - " 0.93635253, 0.94933226, 0.97529172]), array([ 2.22044605e-16, 7.70432123e+00, 7.70432123e+00,\n", - " 1.06845624e+01, 1.06845624e+01, 1.25044160e+01,\n", - " 1.25044160e+01, 1.33783436e+01, 1.33783436e+01,\n", - " 1.33783436e+01, 1.33783436e+01, 1.25044160e+01,\n", - " 1.25044160e+01, 1.06845624e+01, 1.06845624e+01,\n", - " 7.70432123e+00, 7.70432123e+00, 2.22044605e-16]))\n", - "order is 5\n", - "divided into (array([58]), array([], dtype=int64), array([59]))\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "evaluated inside (array([], dtype=float64), array([], dtype=float64))\n", - "evaluated below (array([ 0.85858586]), array([ 2.48589346]))\n", - "evaluated above (array([ 0.95959596]), array([ 3.60110922]))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.33570561, 0.34266231, 0.34767858, 0.35196481, 0.35597103,\n", - " 0.35997726, 0.36426348, 0.36927975, 0.37623646]))\n", - "input quantiles are [ 0.33570561 0.34266231 0.34767858 0.35196481 0.35597103 0.35997726\n", - " 0.36426348 0.36927975 0.37623646]\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "complete evaluated quantile PDF: (array([ 0.3217922 , 0.33570561, 0.34266231, 0.34266231, 0.34767858,\n", - " 0.34767858, 0.35196481, 0.35196481, 0.35597103, 0.35597103,\n", - " 0.35997726, 0.35997726, 0.36426348, 0.36426348, 0.36927975,\n", - " 0.36927975, 0.37623646, 0.39014987]), array([ 2.22044605e-16, 1.43746220e+01, 1.43746220e+01,\n", - " 1.99351171e+01, 1.99351171e+01, 2.33305762e+01,\n", - " 2.33305762e+01, 2.49611389e+01, 2.49611389e+01,\n", - " 2.49611389e+01, 2.49611389e+01, 2.33305762e+01,\n", - " 2.33305762e+01, 1.99351171e+01, 1.99351171e+01,\n", - " 1.43746220e+01, 1.43746220e+01, 2.22044605e-16]))\n", - "order is 5\n", - "divided into (array([], dtype=int64), array([53]), array([], dtype=int64))\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "evaluated inside (array([ 0.35353535]), array([ 24.93098564]))\n", - "evaluated below (array([], dtype=float64), array([], dtype=float64))\n", - "evaluated above (array([], dtype=float64), array([], dtype=float64))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.78202054, 0.81910725, 0.84584937, 0.86869953, 0.89005703,\n", - " 0.91141452, 0.93426468, 0.9610068 , 0.99809351]))\n", - "input quantiles are [ 0.78202054 0.81910725 0.84584937 0.86869953 0.89005703 0.91141452\n", - " 0.93426468 0.9610068 0.99809351]\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "complete evaluated quantile PDF: (array([ 0.70784713, 0.78202054, 0.81910725, 0.81910725, 0.84584937,\n", - " 0.84584937, 0.86869953, 0.86869953, 0.89005703, 0.89005703,\n", - " 0.91141452, 0.91141452, 0.93426468, 0.93426468, 0.9610068 ,\n", - " 0.9610068 , 0.99809351, 1.07226692]), array([ 2.22044605e-16, 2.69638403e+00, 2.69638403e+00,\n", - " 3.73941878e+00, 3.73941878e+00, 4.37633721e+00,\n", - " 4.37633721e+00, 4.68219730e+00, 4.68219730e+00,\n", - " 4.68219730e+00, 4.68219730e+00, 4.37633721e+00,\n", - " 4.37633721e+00, 3.73941878e+00, 3.73941878e+00,\n", - " 2.69638403e+00, 2.69638403e+00, 2.22044605e-16]))order is 5\n", - "divided into (array([57]), array([58, 59]), array([60]))\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "evaluated inside (array([ 0.85858586, 0.95959596]), array([ 4.4138218, 3.3677309]))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "evaluated below (array([ 0.75757576]), array([ 1.39751068]))\n", - "\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.2966362 , 0.08228443, 0.35551287, 0.58897649, 0.80718932,\n", - " 1.02540215, 1.25886577, 1.5320942 , 1.91101483]))\n", - "evaluated above (array([ 1.06060606]), array([ 0.32770206]))\n", - "input quantiles are [-0.2966362 0.08228443 0.35551287 0.58897649 0.80718932 1.02540215\n", - " 1.25886577 1.5320942 1.91101483]input shape: (9, 8), output shape: (18, 18)\n", - "complete evaluated quantile PDF: (array([-1.05447745, -0.2966362 , 0.08228443, 0.08228443, 0.35551287,\n", - " 0.35551287, 0.58897649, 0.58897649, 0.80718932, 0.80718932,\n", - " 1.02540215, 1.02540215, 1.25886577, 1.25886577, 1.5320942 ,\n", - " 1.5320942 , 1.91101483, 2.66885609]), array([ 2.22044605e-16, 2.63907511e-01, 2.63907511e-01,\n", - " 3.65994121e-01, 3.65994121e-01, 4.28332258e-01,\n", - " 4.28332258e-01, 4.58268192e-01, 4.58268192e-01,\n", - " 4.58268192e-01, 4.58268192e-01, 4.28332258e-01,\n", - " 4.28332258e-01, 3.65994121e-01, 3.65994121e-01,\n", - " 2.63907511e-01, 2.63907511e-01, 2.22044605e-16]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "\n", - "order is 5\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.160167 , 0.38573089, 0.54837833, 0.68735456, 0.81725231,\n", - " 0.94715006, 1.0861263 , 1.24877373, 1.47433762]))divided into (array([40, 41, 42, 43, 44, 45, 46]), array([47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,\n", - " 64, 65, 66, 67, 68]), array([69, 70, 71, 72, 73, 74, 75]))\n", - "\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "evaluated inside (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", - " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", - " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", - " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667,\n", - " 1.76767677, 1.86868687]), array([ 0.21737113, 0.24923911, 0.2820813 , 0.31489295, 0.34667479,\n", - " 0.37643304, 0.40317944, 0.42593824, 0.44382821, 0.45614871,\n", - " 0.46240587, 0.46234979, 0.45598269, 0.44355893, 0.42557638,\n", - " 0.40273907, 0.37593098, 0.34612842, 0.31431978, 0.28149891,\n", - " 0.24866518, 0.21682346]))\n", - "evaluated below (array([-0.95959596, -0.85858586, -0.75757576, -0.65656566, -0.55555556,\n", - " -0.45454545, -0.35353535]), array([ 0.0255429 , 0.05273567, 0.07992845, 0.10712122, 0.13431399,\n", - " 0.16150677, 0.18869954]))\n", - "input quantiles are [ 0.160167 0.38573089 0.54837833 0.68735456 0.81725231 0.94715006\n", - " 1.0861263 1.24877373 1.47433762]evaluated above (array([ 1.96969697, 2.07070707, 2.17171717, 2.27272727, 2.37373737,\n", - " 2.47474747, 2.57575758]), array([ 0.18821955, 0.16102677, 0.133834 , 0.10664123, 0.07944845,\n", - " 0.05225568, 0.02506291]))\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "\n", - "complete evaluated quantile PDF: (array([-0.29096079, 0.160167 , 0.38573089, 0.38573089, 0.54837833,\n", - " 0.54837833, 0.68735456, 0.68735456, 0.81725231, 0.81725231,\n", - " 0.94715006, 0.94715006, 1.0861263 , 1.0861263 , 1.24877373,\n", - " 1.24877373, 1.47433762, 1.92546541]), array([ 2.22044605e-16, 4.43333367e-01, 4.43333367e-01,\n", - " 6.14826782e-01, 6.14826782e-01, 7.19547470e-01,\n", - " 7.19547470e-01, 7.69836295e-01, 7.69836295e-01,\n", - " 7.69836295e-01, 7.69836295e-01, 7.19547470e-01,\n", - " 7.19547470e-01, 6.14826782e-01, 6.14826782e-01,\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 4.43333367e-01, 4.43333367e-01, 2.22044605e-16]))\n", - "order is 5\n", - "divided into (array([47, 48, 49, 50, 51]), array([52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64]), array([65, 66, 67, 68]))\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "evaluated inside (array([ 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", - " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", - " 1.26262626, 1.36363636, 1.46464646]), array([ 0.42412498, 0.51690141, 0.60584365, 0.68304285, 0.74079776,\n", - " 0.77282717, 0.77555359, 0.74867101, 0.69518996, 0.62096562,\n", - " 0.53357031, 0.44089914, 0.35092118]))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.83837651, -0.40009051, -0.08405547, 0.18598482, 0.43838498,\n", - " 0.69078514, 0.96082543, 1.27686047, 1.71514647]))evaluated below (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515]), array([ 0.02919974, 0.1059378 , 0.18267587, 0.25941393, 0.336152 ]))\n", - "evaluated above (array([ 1.56565657, 1.66666667, 1.76767677, 1.86868687]), array([ 0.27334924, 0.19661117, 0.11987311, 0.04313505]))\n", - "\n", - "\n", - "input quantiles are [-0.83837651 -0.40009051 -0.08405547 0.18598482 0.43838498 0.69078514\n", - " 0.96082543 1.27686047 1.71514647]input shape: (9, 8), output shape: (18, 18)\n", - "complete evaluated quantile PDF: (array([-1.71494851, -0.83837651, -0.40009051, -0.40009051, -0.08405547,\n", - " -0.08405547, 0.18598482, 0.18598482, 0.43838498, 0.43838498,\n", - " 0.69078514, 0.69078514, 0.96082543, 0.96082543, 1.27686047,\n", - " 1.27686047, 1.71514647, 2.59171847]), array([ 2.22044605e-16, 2.28161521e-01, 2.28161521e-01,\n", - " 3.16420609e-01, 3.16420609e-01, 3.70315112e-01,\n", - " 3.70315112e-01, 3.96196256e-01, 3.96196256e-01,\n", - " 3.96196256e-01, 3.96196256e-01, 3.70315112e-01,\n", - " 3.70315112e-01, 3.16420609e-01, 3.16420609e-01,\n", - " 2.28161521e-01, 2.28161521e-01, 2.22044605e-16]))\n", - "order is 5\n", - "divided into (array([33, 34, 35, 36, 37, 38, 39, 40, 41]), array([42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,\n", - " 59, 60, 61, 62, 63, 64, 65, 66]), array([67, 68, 69, 70, 71, 72, 73, 74, 75]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.4716778 , -0.23109047, -0.05761009, 0.09062251, 0.22917195,\n", - " 0.36772139, 0.51595399, 0.68943438, 0.9300217 ]))evaluated inside (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", - " -0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", - " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", - " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", - " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667]), array([ 0.19482262, 0.21884383, 0.24341678, 0.26798028, 0.29197582,\n", - " 0.31484752, 0.33604216, 0.35500922, 0.37121226, 0.38418021,\n", - " 0.39353248, 0.39898817, 0.40038408, 0.3976788 , 0.39095271,\n", - " 0.38040776, 0.36635886, 0.34921595, 0.32947641, 0.30768512,\n", - " 0.2843935 , 0.26015563, 0.2355282 , 0.21107062, 0.1873449 ]))\n", - "\n", - "evaluated below (array([-1.66666667, -1.56565657, -1.46464646, -1.36363636, -1.26262626,\n", - " -1.16161616, -1.06060606, -0.95959596, -0.85858586]), array([ 0.00971525, 0.03004045, 0.05036565, 0.07069084, 0.09101604,\n", - " 0.11134124, 0.13166644, 0.15199164, 0.17231684]))input quantiles are [-0.4716778 -0.23109047 -0.05761009 0.09062251 0.22917195 0.36772139\n", - " 0.51595399 0.68943438 0.9300217 ]\n", - "\n", - "evaluated above (array([ 1.76767677, 1.86868687, 1.96969697, 2.07070707, 2.17171717,\n", - " 2.27272727, 2.37373737, 2.47474747, 2.57575758]), array([ 0.16581324, 0.14548804, 0.12516284, 0.10483764, 0.08451244,\n", - " 0.06418724, 0.04386204, 0.02353684, 0.00321164]))\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "complete evaluated quantile PDF: (array([-0.95285245, -0.4716778 , -0.23109047, -0.23109047, -0.05761009,\n", - " -0.05761009, 0.09062251, 0.09062251, 0.22917195, 0.22917195,\n", - " 0.36772139, 0.36772139, 0.51595399, 0.51595399, 0.68943438,\n", - " 0.68943438, 0.9300217 , 1.41119635]), array([ 2.22044605e-16, 4.15649494e-01, 4.15649494e-01,\n", - " 5.76434034e-01, 5.76434034e-01, 6.74615457e-01,\n", - " 6.74615457e-01, 7.21764005e-01, 7.21764005e-01,\n", - " 7.21764005e-01, 7.21764005e-01, 6.74615457e-01,\n", - " 6.74615457e-01, 5.76434034e-01, 5.76434034e-01,\n", - " 4.15649494e-01, 4.15649494e-01, 2.22044605e-16]))Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.22752249, 0.08081044, 0.30314018, 0.49311274, 0.67067553,\n", - " 0.84823831, 1.03821087, 1.26054061, 1.56887354]))\n", - "divided into (array([41, 42, 43, 44]), array([45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58]), array([59, 60, 61, 62, 63]))\n", - "\n", - "order is 5\n", - "input quantiles are [-0.22752249 0.08081044 0.30314018 0.49311274 0.67067553 0.84823831\n", - " 1.03821087 1.26054061 1.56887354]Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "\n", - "evaluated inside (array([-0.45454545, -0.35353535, -0.25252525, -0.15151515, -0.05050505,\n", - " 0.05050505, 0.15151515, 0.25252525, 0.35353535, 0.45454545,\n", - " 0.55555556, 0.65656566, 0.75757576, 0.85858586]), array([ 0.33411094, 0.41342215, 0.4949481 , 0.5725297 , 0.64006113,\n", - " 0.69158671, 0.72217601, 0.72882471, 0.71087657, 0.6701044 ,\n", - " 0.61047089, 0.53753679, 0.4573692 , 0.37609858]))\n", - "evaluated below (array([-0.85858586, -0.75757576, -0.65656566, -0.55555556]), array([ 0.06295026, 0.13040376, 0.19785727, 0.26531077]))\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "evaluated above (array([ 0.95959596, 1.06060606, 1.16161616, 1.26262626, 1.36363636]), array([ 0.30157409, 0.23412058, 0.16666708, 0.09921357, 0.03176007]))\n", - "complete evaluated quantile PDF: (array([-0.84418835, -0.22752249, 0.08081044, 0.08081044, 0.30314018,\n", - " 0.30314018, 0.49311274, 0.49311274, 0.67067553, 0.67067553,\n", - " 0.84823831, 0.84823831, 1.03821087, 1.03821087, 1.26054061,\n", - " 1.26054061, 1.56887354, 2.1855394 ]), array([ 2.22044605e-16, 3.24324747e-01, 3.24324747e-01,\n", - " 4.49782389e-01, 4.49782389e-01, 5.26391805e-01,\n", - " 5.26391805e-01, 5.63181074e-01, 5.63181074e-01,\n", - " 5.63181074e-01, 5.63181074e-01, 5.26391805e-01,\n", - " 5.26391805e-01, 4.49782389e-01, 4.49782389e-01,\n", - " 3.24324747e-01, 3.24324747e-01, 2.22044605e-16]))\n", - "order is 5\n", - "divided into (array([42, 43, 44, 45, 46, 47]), array([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,\n", - " 65]), array([66, 67, 68, 69, 70, 71]))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.63410249, -0.34639065, -0.13893017, 0.03833716, 0.20402467,\n", - " 0.36971217, 0.5469795 , 0.75443998, 1.04215182]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "\n", - "evaluated inside (array([-0.15151515, -0.05050505, 0.05050505, 0.15151515, 0.25252525,\n", - " 0.35353535, 0.45454545, 0.55555556, 0.65656566, 0.75757576,\n", - " 0.85858586, 0.95959596, 1.06060606, 1.16161616, 1.26262626,\n", - " 1.36363636, 1.46464646, 1.56565657]), array([ 0.28602048, 0.3351863 , 0.38482262, 0.43264808, 0.4763967 ,\n", - " 0.51381924, 0.54278436, 0.56158655, 0.56909352, 0.56485326,\n", - " 0.54912047, 0.52284566, 0.48758443, 0.44537765, 0.39846372,\n", - " 0.34910432, 0.29957652, 0.25217281]))\n", - "input quantiles are [-0.63410249 -0.34639065 -0.13893017 0.03833716 0.20402467 0.36971217\n", - " 0.5469795 0.75443998 1.04215182]\n", - "evaluated below (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", - " -0.25252525]), array([ 0.0352149 , 0.07628352, 0.11735215, 0.15842078, 0.1994894 ,\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 0.24055803]))\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "complete evaluated quantile PDF: (array([-1.20952616, -0.63410249, -0.34639065, -0.34639065, -0.13893017,\n", - " -0.13893017, 0.03833716, 0.03833716, 0.20402467, 0.20402467,\n", - " 0.36971217, 0.36971217, 0.5469795 , 0.5469795 , 0.75443998,\n", - " 0.75443998, 1.04215182, 1.61757549]), array([ 2.22044605e-16, 3.47569988e-01, 3.47569988e-01,\n", - " 4.82019521e-01, 4.82019521e-01, 5.64119744e-01,\n", - " 5.64119744e-01, 6.03545800e-01, 6.03545800e-01,\n", - " 6.03545800e-01, 6.03545800e-01, 5.64119744e-01,\n", - " 5.64119744e-01, 4.82019521e-01, 4.82019521e-01,\n", - " 3.47569988e-01, 3.47569988e-01, 2.22044605e-16]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "\n", - "evaluated above (array([ 1.66666667, 1.76767677, 1.86868687, 1.96969697, 2.07070707,\n", - " 2.17171717]), array([ 0.21096297, 0.16989434, 0.12882571, 0.08775709, 0.04668846,\n", - " 0.00561984]))\n", - "order is 5\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.75426818, 0.77627287, 0.7921398 , 0.8056975 , 0.81836957,\n", - " 0.83104163, 0.84459933, 0.86046626, 0.88247095]))\n", - "divided into (array([38, 39, 40, 41, 42, 43]), array([44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59]), array([60, 61, 62, 63, 64, 65]))\n", - "input quantiles are [ 0.75426818 0.77627287 0.7921398 0.8056975 0.81836957 0.83104163\n", - " 0.84459933 0.86046626 0.88247095]\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "evaluated inside (array([-0.55555556, -0.45454545, -0.35353535, -0.25252525, -0.15151515,\n", - " -0.05050505, 0.05050505, 0.15151515, 0.25252525, 0.35353535,\n", - " 0.45454545, 0.55555556, 0.65656566, 0.75757576, 0.85858586,\n", - " 0.95959596]), array([ 0.31070451, 0.36735297, 0.42415121, 0.47809387, 0.52619741,\n", - " 0.56551778, 0.59343513, 0.60804399, 0.60833168, 0.59427839,\n", - " 0.56685819, 0.52794447, 0.48013393, 0.42636629, 0.36962427,\n", - " 0.31291232]))complete evaluated quantile PDF: (array([ 0.7102588 , 0.75426818, 0.77627287, 0.77627287, 0.7921398 ,\n", - " 0.7921398 , 0.8056975 , 0.8056975 , 0.81836957, 0.81836957,\n", - " 0.83104163, 0.83104163, 0.84459933, 0.84459933, 0.86046626,\n", - " 0.86046626, 0.88247095, 0.92648033]), array([ 2.22044605e-16, 4.54448593e+00, 4.54448593e+00,\n", - " 6.30241681e+00, 6.30241681e+00, 7.37587919e+00,\n", - " 7.37587919e+00, 7.89137582e+00, 7.89137582e+00,\n", - " 7.89137582e+00, 7.89137582e+00, 7.37587919e+00,\n", - " 7.37587919e+00, 6.30241681e+00, 6.30241681e+00,\n", - " 4.54448593e+00, 4.54448593e+00, 2.22044605e-16]))\n", - "\n", - "evaluated below (array([-1.16161616, -1.06060606, -0.95959596, -0.85858586, -0.75757576,\n", - " -0.65656566]), array([ 0.02237154, 0.06953814, 0.11670474, 0.16387133, 0.21103793,\n", - " 0.25820452]))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "order is 5\n", - "evaluated above (array([ 1.06060606, 1.16161616, 1.26262626, 1.36363636, 1.46464646,\n", - " 1.56565657]), array([ 0.26007649, 0.21290989, 0.1657433 , 0.1185767 , 0.0714101 ,\n", - " 0.02424351]))\n", - "divided into (array([], dtype=int64), array([57, 58]), array([], dtype=int64))\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.87371033, 0.88669005, 0.89604935, 0.90404653, 0.91152129,\n", - " 0.91899606, 0.92699323, 0.93635253, 0.94933226]))\n", - "input quantiles are [ 0.87371033 0.88669005 0.89604935 0.90404653 0.91152129 0.91899606\n", - " 0.92699323 0.93635253 0.94933226]Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "evaluated inside (array([ 0.75757576, 0.85858586]), array([ 3.81138379, 5.77321742]))\n", - "\n", - "evaluated below (array([], dtype=float64), array([], dtype=float64))\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "evaluated above (array([], dtype=float64), array([], dtype=float64))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "complete evaluated quantile PDF: (array([ 0.84775087, 0.87371033, 0.88669005, 0.88669005, 0.89604935,\n", - " 0.89604935, 0.90404653, 0.90404653, 0.91152129, 0.91152129,\n", - " 0.91899606, 0.91899606, 0.92699323, 0.92699323, 0.93635253,\n", - " 0.93635253, 0.94933226, 0.97529172]), array([ 2.22044605e-16, 7.70432123e+00, 7.70432123e+00,\n", - " 1.06845624e+01, 1.06845624e+01, 1.25044160e+01,\n", - " 1.25044160e+01, 1.33783436e+01, 1.33783436e+01,\n", - " 1.33783436e+01, 1.33783436e+01, 1.25044160e+01,\n", - " 1.25044160e+01, 1.06845624e+01, 1.06845624e+01,\n", - " 7.70432123e+00, 7.70432123e+00, 2.22044605e-16]))\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.33570561, 0.34266231, 0.34767858, 0.35196481, 0.35597103,\n", - " 0.35997726, 0.36426348, 0.36927975, 0.37623646]))order is 5\n", - "\n", - "divided into (array([58]), array([], dtype=int64), array([59]))\n", - "input quantiles are [ 0.33570561 0.34266231 0.34767858 0.35196481 0.35597103 0.35997726\n", - " 0.36426348 0.36927975 0.37623646]\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "evaluated inside (array([], dtype=float64), array([], dtype=float64))\n", - "complete evaluated quantile PDF: (array([ 0.3217922 , 0.33570561, 0.34266231, 0.34266231, 0.34767858,\n", - " 0.34767858, 0.35196481, 0.35196481, 0.35597103, 0.35597103,\n", - " 0.35997726, 0.35997726, 0.36426348, 0.36426348, 0.36927975,\n", - " 0.36927975, 0.37623646, 0.39014987]), array([ 2.22044605e-16, 1.43746220e+01, 1.43746220e+01,\n", - " 1.99351171e+01, 1.99351171e+01, 2.33305762e+01,\n", - " 2.33305762e+01, 2.49611389e+01, 2.49611389e+01,\n", - " 2.49611389e+01, 2.49611389e+01, 2.33305762e+01,\n", - " 2.33305762e+01, 1.99351171e+01, 1.99351171e+01,\n", - " 1.43746220e+01, 1.43746220e+01, 2.22044605e-16]))\n", - "evaluated below (array([ 0.85858586]), array([ 2.48589346]))\n", - "order is 5\n", - "evaluated above (array([ 0.95959596]), array([ 3.60110922]))\n", - "divided into (array([], dtype=int64), array([53]), array([], dtype=int64))\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "evaluated inside (array([ 0.35353535]), array([ 24.93098564]))\n", - "evaluated below (array([], dtype=float64), array([], dtype=float64))\n", - "evaluated above (array([], dtype=float64), array([], dtype=float64))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "divided into (array([57]), array([58, 59]), array([60]))\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.78202054, 0.81910725, 0.84584937, 0.86869953, 0.89005703,\n", - " 0.91141452, 0.93426468, 0.9610068 , 0.99809351]))\n", - "input quantiles are [ 0.78202054 0.81910725 0.84584937 0.86869953 0.89005703 0.91141452\n", - " 0.93426468 0.9610068 0.99809351]\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "complete evaluated quantile PDF: (array([ 0.70784713, 0.78202054, 0.81910725, 0.81910725, 0.84584937,\n", - " 0.84584937, 0.86869953, 0.86869953, 0.89005703, 0.89005703,\n", - " 0.91141452, 0.91141452, 0.93426468, 0.93426468, 0.9610068 ,\n", - " 0.9610068 , 0.99809351, 1.07226692]), array([ 2.22044605e-16, 2.69638403e+00, 2.69638403e+00,\n", - " 3.73941878e+00, 3.73941878e+00, 4.37633721e+00,\n", - " 4.37633721e+00, 4.68219730e+00, 4.68219730e+00,\n", - " 4.68219730e+00, 4.68219730e+00, 4.37633721e+00,\n", - " 4.37633721e+00, 3.73941878e+00, 3.73941878e+00,\n", - " 2.69638403e+00, 2.69638403e+00, 2.22044605e-16]))\n", - "order is 5\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "\n", - "evaluated inside (array([ 0.85858586, 0.95959596]), array([ 4.4138218, 3.3677309]))\n", - "evaluated below (array([ 0.75757576]), array([ 1.39751068]))\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.2966362 , 0.08228443, 0.35551287, 0.58897649, 0.80718932,\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 1.02540215, 1.25886577, 1.5320942 , 1.91101483]))input quantiles are [-0.2966362 0.08228443 0.35551287 0.58897649 0.80718932 1.02540215\n", - " 1.25886577 1.5320942 1.91101483]evaluated above (array([ 1.06060606]), array([ 0.32770206]))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "\n", - "complete evaluated quantile PDF: (array([-1.05447745, -0.2966362 , 0.08228443, 0.08228443, 0.35551287,\n", - " 0.35551287, 0.58897649, 0.58897649, 0.80718932, 0.80718932,\n", - " 1.02540215, 1.02540215, 1.25886577, 1.25886577, 1.5320942 ,\n", - " 1.5320942 , 1.91101483, 2.66885609]), array([ 2.22044605e-16, 2.63907511e-01, 2.63907511e-01,\n", - " 3.65994121e-01, 3.65994121e-01, 4.28332258e-01,\n", - " 4.28332258e-01, 4.58268192e-01, 4.58268192e-01,\n", - " 4.58268192e-01, 4.58268192e-01, 4.28332258e-01,\n", - " 4.28332258e-01, 3.65994121e-01, 3.65994121e-01,\n", - " 2.63907511e-01, 2.63907511e-01, 2.22044605e-16]))Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.160167 , 0.38573089, 0.54837833, 0.68735456, 0.81725231,\n", - " 0.94715006, 1.0861263 , 1.24877373, 1.47433762]))\n", - "\n", - "input quantiles are [ 0.160167 0.38573089 0.54837833 0.68735456 0.81725231 0.94715006\n", - " 1.0861263 1.24877373 1.47433762]order is 5\n", - "\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "divided into (array([40, 41, 42, 43, 44, 45, 46]), array([47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,\n", - " 64, 65, 66, 67, 68]), array([69, 70, 71, 72, 73, 74, 75]))complete evaluated quantile PDF: (array([-0.29096079, 0.160167 , 0.38573089, 0.38573089, 0.54837833,\n", - " 0.54837833, 0.68735456, 0.68735456, 0.81725231, 0.81725231,\n", - " 0.94715006, 0.94715006, 1.0861263 , 1.0861263 , 1.24877373,\n", - " 1.24877373, 1.47433762, 1.92546541]), array([ 2.22044605e-16, 4.43333367e-01, 4.43333367e-01,\n", - " 6.14826782e-01, 6.14826782e-01, 7.19547470e-01,\n", - " 7.19547470e-01, 7.69836295e-01, 7.69836295e-01,\n", - " 7.69836295e-01, 7.69836295e-01, 7.19547470e-01,\n", - " 7.19547470e-01, 6.14826782e-01, 6.14826782e-01,\n", - " 4.43333367e-01, 4.43333367e-01, 2.22044605e-16]))\n", - "\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "order is 5\n", - "evaluated inside (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", - " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", - " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", - " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667,\n", - " 1.76767677, 1.86868687]), array([ 0.21737113, 0.24923911, 0.2820813 , 0.31489295, 0.34667479,\n", - " 0.37643304, 0.40317944, 0.42593824, 0.44382821, 0.45614871,\n", - " 0.46240587, 0.46234979, 0.45598269, 0.44355893, 0.42557638,\n", - " 0.40273907, 0.37593098, 0.34612842, 0.31431978, 0.28149891,\n", - " 0.24866518, 0.21682346]))evaluated inside (array([ 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", - " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", - " 1.26262626, 1.36363636, 1.46464646]), array([ 0.42412498, 0.51690141, 0.60584365, 0.68304285, 0.74079776,\n", - " 0.77282717, 0.77555359, 0.74867101, 0.69518996, 0.62096562,\n", - " 0.53357031, 0.44089914, 0.35092118]))divided into (array([47, 48, 49, 50, 51]), array([52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64]), array([65, 66, 67, 68]))\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.83837651, -0.40009051, -0.08405547, 0.18598482, 0.43838498,\n", - " 0.69078514, 0.96082543, 1.27686047, 1.71514647]))\n", - "\n", - "evaluated below (array([-0.95959596, -0.85858586, -0.75757576, -0.65656566, -0.55555556,\n", - " -0.45454545, -0.35353535]), array([ 0.0255429 , 0.05273567, 0.07992845, 0.10712122, 0.13431399,\n", - " 0.16150677, 0.18869954]))input shape: (9, 8), output shape: (18, 18)\n", - "\n", - "input quantiles are [-0.83837651 -0.40009051 -0.08405547 0.18598482 0.43838498 0.69078514\n", - " 0.96082543 1.27686047 1.71514647]evaluated below (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515]), array([ 0.02919974, 0.1059378 , 0.18267587, 0.25941393, 0.336152 ]))\n", - "\n", - "evaluated above (array([ 1.56565657, 1.66666667, 1.76767677, 1.86868687]), array([ 0.27334924, 0.19661117, 0.11987311, 0.04313505]))\n", - "complete evaluated quantile PDF: (array([-1.71494851, -0.83837651, -0.40009051, -0.40009051, -0.08405547,\n", - " -0.08405547, 0.18598482, 0.18598482, 0.43838498, 0.43838498,\n", - " 0.69078514, 0.69078514, 0.96082543, 0.96082543, 1.27686047,\n", - " 1.27686047, 1.71514647, 2.59171847]), array([ 2.22044605e-16, 2.28161521e-01, 2.28161521e-01,\n", - " 3.16420609e-01, 3.16420609e-01, 3.70315112e-01,\n", - " 3.70315112e-01, 3.96196256e-01, 3.96196256e-01,\n", - " 3.96196256e-01, 3.96196256e-01, 3.70315112e-01,\n", - " 3.70315112e-01, 3.16420609e-01, 3.16420609e-01,\n", - " 2.28161521e-01, 2.28161521e-01, 2.22044605e-16]))evaluated above (array([ 1.96969697, 2.07070707, 2.17171717, 2.27272727, 2.37373737,\n", - " 2.47474747, 2.57575758]), array([ 0.18821955, 0.16102677, 0.133834 , 0.10664123, 0.07944845,\n", - " 0.05225568, 0.02506291]))\n", - "\n", - "order is 5\n", - "divided into (array([33, 34, 35, 36, 37, 38, 39, 40, 41]), array([42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,\n", - " 59, 60, 61, 62, 63, 64, 65, 66]), array([67, 68, 69, 70, 71, 72, 73, 74, 75]))\n", - "evaluated below (array([-1.66666667, -1.56565657, -1.46464646, -1.36363636, -1.26262626,\n", - " -1.16161616, -1.06060606, -0.95959596, -0.85858586]), array([ 0.00971525, 0.03004045, 0.05036565, 0.07069084, 0.09101604,\n", - " 0.11134124, 0.13166644, 0.15199164, 0.17231684]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.4716778 , -0.23109047, -0.05761009, 0.09062251, 0.22917195,\n", - " 0.36772139, 0.51595399, 0.68943438, 0.9300217 ]))evaluated inside (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", - " -0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", - " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", - " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", - " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667]), array([ 0.19482262, 0.21884383, 0.24341678, 0.26798028, 0.29197582,\n", - " 0.31484752, 0.33604216, 0.35500922, 0.37121226, 0.38418021,\n", - " 0.39353248, 0.39898817, 0.40038408, 0.3976788 , 0.39095271,\n", - " 0.38040776, 0.36635886, 0.34921595, 0.32947641, 0.30768512,\n", - " 0.2843935 , 0.26015563, 0.2355282 , 0.21107062, 0.1873449 ]))\n", - "\n", - "input quantiles are [-0.4716778 -0.23109047 -0.05761009 0.09062251 0.22917195 0.36772139\n", - " 0.51595399 0.68943438 0.9300217 ]\n", - "\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "\n", - "evaluated above (array([ 1.76767677, 1.86868687, 1.96969697, 2.07070707, 2.17171717,\n", - " 2.27272727, 2.37373737, 2.47474747, 2.57575758]), array([ 0.16581324, 0.14548804, 0.12516284, 0.10483764, 0.08451244,\n", - " 0.06418724, 0.04386204, 0.02353684, 0.00321164]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "complete evaluated quantile PDF: (array([-0.95285245, -0.4716778 , -0.23109047, -0.23109047, -0.05761009,\n", - " -0.05761009, 0.09062251, 0.09062251, 0.22917195, 0.22917195,\n", - " 0.36772139, 0.36772139, 0.51595399, 0.51595399, 0.68943438,\n", - " 0.68943438, 0.9300217 , 1.41119635]), array([ 2.22044605e-16, 4.15649494e-01, 4.15649494e-01,\n", - " 5.76434034e-01, 5.76434034e-01, 6.74615457e-01,\n", - " 6.74615457e-01, 7.21764005e-01, 7.21764005e-01,\n", - " 7.21764005e-01, 7.21764005e-01, 6.74615457e-01,\n", - " 6.74615457e-01, 5.76434034e-01, 5.76434034e-01,\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 4.15649494e-01, 4.15649494e-01, 2.22044605e-16]))\n", - "order is 5\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.22752249, 0.08081044, 0.30314018, 0.49311274, 0.67067553,\n", - " 0.84823831, 1.03821087, 1.26054061, 1.56887354]))divided into (array([41, 42, 43, 44]), array([45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58]), array([59, 60, 61, 62, 63]))\n", - "\n", - "input quantiles are [-0.22752249 0.08081044 0.30314018 0.49311274 0.67067553 0.84823831\n", - " 1.03821087 1.26054061 1.56887354]evaluated inside (array([-0.45454545, -0.35353535, -0.25252525, -0.15151515, -0.05050505,\n", - " 0.05050505, 0.15151515, 0.25252525, 0.35353535, 0.45454545,\n", - " 0.55555556, 0.65656566, 0.75757576, 0.85858586]), array([ 0.33411094, 0.41342215, 0.4949481 , 0.5725297 , 0.64006113,\n", - " 0.69158671, 0.72217601, 0.72882471, 0.71087657, 0.6701044 ,\n", - " 0.61047089, 0.53753679, 0.4573692 , 0.37609858]))\n", - "\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "evaluated below (array([-0.85858586, -0.75757576, -0.65656566, -0.55555556]), array([ 0.06295026, 0.13040376, 0.19785727, 0.26531077]))\n", - "complete evaluated quantile PDF: (array([-0.84418835, -0.22752249, 0.08081044, 0.08081044, 0.30314018,\n", - " 0.30314018, 0.49311274, 0.49311274, 0.67067553, 0.67067553,\n", - " 0.84823831, 0.84823831, 1.03821087, 1.03821087, 1.26054061,\n", - " 1.26054061, 1.56887354, 2.1855394 ]), array([ 2.22044605e-16, 3.24324747e-01, 3.24324747e-01,\n", - " 4.49782389e-01, 4.49782389e-01, 5.26391805e-01,\n", - " 5.26391805e-01, 5.63181074e-01, 5.63181074e-01,\n", - " 5.63181074e-01, 5.63181074e-01, 5.26391805e-01,\n", - " 5.26391805e-01, 4.49782389e-01, 4.49782389e-01,\n", - " 3.24324747e-01, 3.24324747e-01, 2.22044605e-16]))evaluated above (array([ 0.95959596, 1.06060606, 1.16161616, 1.26262626, 1.36363636]), array([ 0.30157409, 0.23412058, 0.16666708, 0.09921357, 0.03176007]))\n", - "\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "order is 5\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.63410249, -0.34639065, -0.13893017, 0.03833716, 0.20402467,\n", - " 0.36971217, 0.5469795 , 0.75443998, 1.04215182]))\n", - "divided into (array([42, 43, 44, 45, 46, 47]), array([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,\n", - " 65]), array([66, 67, 68, 69, 70, 71]))\n", - "input quantiles are [-0.63410249 -0.34639065 -0.13893017 0.03833716 0.20402467 0.36971217\n", - " 0.5469795 0.75443998 1.04215182]Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "\n", - "evaluated inside (array([-0.15151515, -0.05050505, 0.05050505, 0.15151515, 0.25252525,\n", - " 0.35353535, 0.45454545, 0.55555556, 0.65656566, 0.75757576,\n", - " 0.85858586, 0.95959596, 1.06060606, 1.16161616, 1.26262626,\n", - " 1.36363636, 1.46464646, 1.56565657]), array([ 0.28602048, 0.3351863 , 0.38482262, 0.43264808, 0.4763967 ,\n", - " 0.51381924, 0.54278436, 0.56158655, 0.56909352, 0.56485326,\n", - " 0.54912047, 0.52284566, 0.48758443, 0.44537765, 0.39846372,\n", - " 0.34910432, 0.29957652, 0.25217281]))input shape: (9, 8), output shape: (18, 18)\n", - "\n", - "evaluated below (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", - " -0.25252525]), array([ 0.0352149 , 0.07628352, 0.11735215, 0.15842078, 0.1994894 ,\n", - " 0.24055803]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "complete evaluated quantile PDF: (array([-1.20952616, -0.63410249, -0.34639065, -0.34639065, -0.13893017,\n", - " -0.13893017, 0.03833716, 0.03833716, 0.20402467, 0.20402467,\n", - " 0.36971217, 0.36971217, 0.5469795 , 0.5469795 , 0.75443998,\n", - " 0.75443998, 1.04215182, 1.61757549]), array([ 2.22044605e-16, 3.47569988e-01, 3.47569988e-01,\n", - " 4.82019521e-01, 4.82019521e-01, 5.64119744e-01,\n", - " 5.64119744e-01, 6.03545800e-01, 6.03545800e-01,\n", - " 6.03545800e-01, 6.03545800e-01, 5.64119744e-01,\n", - " 5.64119744e-01, 4.82019521e-01, 4.82019521e-01,\n", - " 3.47569988e-01, 3.47569988e-01, 2.22044605e-16]))\n", - "\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.75426818, 0.77627287, 0.7921398 , 0.8056975 , 0.81836957,\n", - " 0.83104163, 0.84459933, 0.86046626, 0.88247095]))order is 5\n", - "\n", - "input quantiles are [ 0.75426818 0.77627287 0.7921398 0.8056975 0.81836957 0.83104163\n", - " 0.84459933 0.86046626 0.88247095]divided into (array([38, 39, 40, 41, 42, 43]), array([44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59]), array([60, 61, 62, 63, 64, 65]))\n", - "evaluated above (array([ 1.66666667, 1.76767677, 1.86868687, 1.96969697, 2.07070707,\n", - " 2.17171717]), array([ 0.21096297, 0.16989434, 0.12882571, 0.08775709, 0.04668846,\n", - " 0.00561984]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "\n", - "evaluated inside (array([-0.55555556, -0.45454545, -0.35353535, -0.25252525, -0.15151515,\n", - " -0.05050505, 0.05050505, 0.15151515, 0.25252525, 0.35353535,\n", - " 0.45454545, 0.55555556, 0.65656566, 0.75757576, 0.85858586,\n", - " 0.95959596]), array([ 0.31070451, 0.36735297, 0.42415121, 0.47809387, 0.52619741,\n", - " 0.56551778, 0.59343513, 0.60804399, 0.60833168, 0.59427839,\n", - " 0.56685819, 0.52794447, 0.48013393, 0.42636629, 0.36962427,\n", - " 0.31291232]))\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "\n", - "complete evaluated quantile PDF: (array([ 0.7102588 , 0.75426818, 0.77627287, 0.77627287, 0.7921398 ,\n", - " 0.7921398 , 0.8056975 , 0.8056975 , 0.81836957, 0.81836957,\n", - " 0.83104163, 0.83104163, 0.84459933, 0.84459933, 0.86046626,\n", - " 0.86046626, 0.88247095, 0.92648033]), array([ 2.22044605e-16, 4.54448593e+00, 4.54448593e+00,\n", - " 6.30241681e+00, 6.30241681e+00, 7.37587919e+00,\n", - " 7.37587919e+00, 7.89137582e+00, 7.89137582e+00,\n", - " 7.89137582e+00, 7.89137582e+00, 7.37587919e+00,\n", - " 7.37587919e+00, 6.30241681e+00, 6.30241681e+00,\n", - " 4.54448593e+00, 4.54448593e+00, 2.22044605e-16]))\n", - "evaluated below (array([-1.16161616, -1.06060606, -0.95959596, -0.85858586, -0.75757576,\n", - " -0.65656566]), array([ 0.02237154, 0.06953814, 0.11670474, 0.16387133, 0.21103793,\n", - " 0.25820452]))order is 5\n", - "\n", - "divided into (array([], dtype=int64), array([57, 58]), array([], dtype=int64))\n", - "evaluated above (array([ 1.06060606, 1.16161616, 1.26262626, 1.36363636, 1.46464646,\n", - " 1.56565657]), array([ 0.26007649, 0.21290989, 0.1657433 , 0.1185767 , 0.0714101 ,\n", - " 0.02424351]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "evaluated inside (array([ 0.75757576, 0.85858586]), array([ 3.81138379, 5.77321742]))\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.87371033, 0.88669005, 0.89604935, 0.90404653, 0.91152129,\n", - " 0.91899606, 0.92699323, 0.93635253, 0.94933226]))evaluated below (array([], dtype=float64), array([], dtype=float64))\n", - "evaluated above (array([], dtype=float64), array([], dtype=float64))\n", - "\n", - "input quantiles are [ 0.87371033 0.88669005 0.89604935 0.90404653 0.91152129 0.91899606\n", - " 0.92699323 0.93635253 0.94933226]\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "complete evaluated quantile PDF: (array([ 0.84775087, 0.87371033, 0.88669005, 0.88669005, 0.89604935,\n", - " 0.89604935, 0.90404653, 0.90404653, 0.91152129, 0.91152129,\n", - " 0.91899606, 0.91899606, 0.92699323, 0.92699323, 0.93635253,\n", - " 0.93635253, 0.94933226, 0.97529172]), array([ 2.22044605e-16, 7.70432123e+00, 7.70432123e+00,\n", - " 1.06845624e+01, 1.06845624e+01, 1.25044160e+01,\n", - " 1.25044160e+01, 1.33783436e+01, 1.33783436e+01,\n", - " 1.33783436e+01, 1.33783436e+01, 1.25044160e+01,\n", - " 1.25044160e+01, 1.06845624e+01, 1.06845624e+01,\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 7.70432123e+00, 7.70432123e+00, 2.22044605e-16]))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "order is 5\n", - "divided into (array([58]), array([], dtype=int64), array([59]))\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.33570561, 0.34266231, 0.34767858, 0.35196481, 0.35597103,\n", - " 0.35997726, 0.36426348, 0.36927975, 0.37623646]))evaluated inside (array([], dtype=float64), array([], dtype=float64))\n", - "\n", - "evaluated below (array([ 0.85858586]), array([ 2.48589346]))\n", - "evaluated above (array([ 0.95959596]), array([ 3.60110922]))\n", - "input quantiles are [ 0.33570561 0.34266231 0.34767858 0.35196481 0.35597103 0.35997726\n", - " 0.36426348 0.36927975 0.37623646]\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "complete evaluated quantile PDF: (array([ 0.3217922 , 0.33570561, 0.34266231, 0.34266231, 0.34767858,\n", - " 0.34767858, 0.35196481, 0.35196481, 0.35597103, 0.35597103,\n", - " 0.35997726, 0.35997726, 0.36426348, 0.36426348, 0.36927975,\n", - " 0.36927975, 0.37623646, 0.39014987]), array([ 2.22044605e-16, 1.43746220e+01, 1.43746220e+01,\n", - " 1.99351171e+01, 1.99351171e+01, 2.33305762e+01,\n", - " 2.33305762e+01, 2.49611389e+01, 2.49611389e+01,\n", - " 2.49611389e+01, 2.49611389e+01, 2.33305762e+01,\n", - " 2.33305762e+01, 1.99351171e+01, 1.99351171e+01,\n", - " 1.43746220e+01, 1.43746220e+01, 2.22044605e-16]))\n", - "order is 5\n", - "divided into (array([], dtype=int64), array([53]), array([], dtype=int64))\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "evaluated inside (array([ 0.35353535]), array([ 24.93098564]))\n", - "evaluated below (array([], dtype=float64), array([], dtype=float64))\n", - "evaluated above (array([], dtype=float64), array([], dtype=float64))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "input quantiles are [ 0.78202054 0.81910725 0.84584937 0.86869953 0.89005703 0.91141452\n", - " 0.93426468 0.9610068 0.99809351]Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.78202054, 0.81910725, 0.84584937, 0.86869953, 0.89005703,\n", - " 0.91141452, 0.93426468, 0.9610068 , 0.99809351]))\n", - "\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.2966362 , 0.08228443, 0.35551287, 0.58897649, 0.80718932,\n", - " 1.02540215, 1.25886577, 1.5320942 , 1.91101483]))complete evaluated quantile PDF: (array([ 0.70784713, 0.78202054, 0.81910725, 0.81910725, 0.84584937,\n", - " 0.84584937, 0.86869953, 0.86869953, 0.89005703, 0.89005703,\n", - " 0.91141452, 0.91141452, 0.93426468, 0.93426468, 0.9610068 ,\n", - " 0.9610068 , 0.99809351, 1.07226692]), array([ 2.22044605e-16, 2.69638403e+00, 2.69638403e+00,\n", - " 3.73941878e+00, 3.73941878e+00, 4.37633721e+00,\n", - " 4.37633721e+00, 4.68219730e+00, 4.68219730e+00,\n", - " 4.68219730e+00, 4.68219730e+00, 4.37633721e+00,\n", - " 4.37633721e+00, 3.73941878e+00, 3.73941878e+00,\n", - " 2.69638403e+00, 2.69638403e+00, 2.22044605e-16]))\n", - "\n", - "input quantiles are [-0.2966362 0.08228443 0.35551287 0.58897649 0.80718932 1.02540215\n", - " 1.25886577 1.5320942 1.91101483]order is 5\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "divided into (array([57]), array([58, 59]), array([60]))\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "complete evaluated quantile PDF: (array([-1.05447745, -0.2966362 , 0.08228443, 0.08228443, 0.35551287,\n", - " 0.35551287, 0.58897649, 0.58897649, 0.80718932, 0.80718932,\n", - " 1.02540215, 1.02540215, 1.25886577, 1.25886577, 1.5320942 ,\n", - " 1.5320942 , 1.91101483, 2.66885609]), array([ 2.22044605e-16, 2.63907511e-01, 2.63907511e-01,\n", - " 3.65994121e-01, 3.65994121e-01, 4.28332258e-01,\n", - " 4.28332258e-01, 4.58268192e-01, 4.58268192e-01,\n", - " 4.58268192e-01, 4.58268192e-01, 4.28332258e-01,\n", - " 4.28332258e-01, 3.65994121e-01, 3.65994121e-01,\n", - " 2.63907511e-01, 2.63907511e-01, 2.22044605e-16]))\n", - "order is 5\n", - "evaluated inside (array([ 0.85858586, 0.95959596]), array([ 4.4138218, 3.3677309]))\n", - "divided into (array([40, 41, 42, 43, 44, 45, 46]), array([47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,\n", - " 64, 65, 66, 67, 68]), array([69, 70, 71, 72, 73, 74, 75]))Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "evaluated above (array([ 1.06060606]), array([ 0.32770206]))\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.160167 , 0.38573089, 0.54837833, 0.68735456, 0.81725231,\n", - " 0.94715006, 1.0861263 , 1.24877373, 1.47433762]))\n", - "evaluated below (array([ 0.75757576]), array([ 1.39751068]))\n", - "input quantiles are [ 0.160167 0.38573089 0.54837833 0.68735456 0.81725231 0.94715006\n", - " 1.0861263 1.24877373 1.47433762]\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "\n", - "evaluated inside (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", - " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", - " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", - " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667,\n", - " 1.76767677, 1.86868687]), array([ 0.21737113, 0.24923911, 0.2820813 , 0.31489295, 0.34667479,\n", - " 0.37643304, 0.40317944, 0.42593824, 0.44382821, 0.45614871,\n", - " 0.46240587, 0.46234979, 0.45598269, 0.44355893, 0.42557638,\n", - " 0.40273907, 0.37593098, 0.34612842, 0.31431978, 0.28149891,\n", - " 0.24866518, 0.21682346]))input shape: (9, 8), output shape: (18, 18)\n", - "\n", - "complete evaluated quantile PDF: (array([-0.29096079, 0.160167 , 0.38573089, 0.38573089, 0.54837833,\n", - " 0.54837833, 0.68735456, 0.68735456, 0.81725231, 0.81725231,\n", - " 0.94715006, 0.94715006, 1.0861263 , 1.0861263 , 1.24877373,\n", - " 1.24877373, 1.47433762, 1.92546541]), array([ 2.22044605e-16, 4.43333367e-01, 4.43333367e-01,\n", - " 6.14826782e-01, 6.14826782e-01, 7.19547470e-01,\n", - " 7.19547470e-01, 7.69836295e-01, 7.69836295e-01,\n", - " 7.69836295e-01, 7.69836295e-01, 7.19547470e-01,\n", - " 7.19547470e-01, 6.14826782e-01, 6.14826782e-01,\n", - " 4.43333367e-01, 4.43333367e-01, 2.22044605e-16]))\n", - "evaluated below (array([-0.95959596, -0.85858586, -0.75757576, -0.65656566, -0.55555556,\n", - " -0.45454545, -0.35353535]), array([ 0.0255429 , 0.05273567, 0.07992845, 0.10712122, 0.13431399,\n", - " 0.16150677, 0.18869954]))order is 5\n", - "\n", - "evaluated above (array([ 1.96969697, 2.07070707, 2.17171717, 2.27272727, 2.37373737,\n", - " 2.47474747, 2.57575758]), array([ 0.18821955, 0.16102677, 0.133834 , 0.10664123, 0.07944845,\n", - " 0.05225568, 0.02506291]))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "divided into (array([47, 48, 49, 50, 51]), array([52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64]), array([65, 66, 67, 68]))\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.83837651, -0.40009051, -0.08405547, 0.18598482, 0.43838498,\n", - " 0.69078514, 0.96082543, 1.27686047, 1.71514647]))evaluated inside (array([ 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", - " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", - " 1.26262626, 1.36363636, 1.46464646]), array([ 0.42412498, 0.51690141, 0.60584365, 0.68304285, 0.74079776,\n", - " 0.77282717, 0.77555359, 0.74867101, 0.69518996, 0.62096562,\n", - " 0.53357031, 0.44089914, 0.35092118]))\n", - "input quantiles are [-0.83837651 -0.40009051 -0.08405547 0.18598482 0.43838498 0.69078514\n", - " 0.96082543 1.27686047 1.71514647]\n", - "\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "evaluated below (array([-0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515]), array([ 0.02919974, 0.1059378 , 0.18267587, 0.25941393, 0.336152 ]))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "evaluated above (array([ 1.56565657, 1.66666667, 1.76767677, 1.86868687]), array([ 0.27334924, 0.19661117, 0.11987311, 0.04313505]))\n", - "complete evaluated quantile PDF: (array([-1.71494851, -0.83837651, -0.40009051, -0.40009051, -0.08405547,\n", - " -0.08405547, 0.18598482, 0.18598482, 0.43838498, 0.43838498,\n", - " 0.69078514, 0.69078514, 0.96082543, 0.96082543, 1.27686047,\n", - " 1.27686047, 1.71514647, 2.59171847]), array([ 2.22044605e-16, 2.28161521e-01, 2.28161521e-01,\n", - " 3.16420609e-01, 3.16420609e-01, 3.70315112e-01,\n", - " 3.70315112e-01, 3.96196256e-01, 3.96196256e-01,\n", - " 3.96196256e-01, 3.96196256e-01, 3.70315112e-01,\n", - " 3.70315112e-01, 3.16420609e-01, 3.16420609e-01,\n", - " 2.28161521e-01, 2.28161521e-01, 2.22044605e-16]))\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.4716778 , -0.23109047, -0.05761009, 0.09062251, 0.22917195,\n", - " 0.36772139, 0.51595399, 0.68943438, 0.9300217 ]))\n", - "order is 5\n", - "input quantiles are [-0.4716778 -0.23109047 -0.05761009 0.09062251 0.22917195 0.36772139\n", - " 0.51595399 0.68943438 0.9300217 ]\n", - "divided into (array([33, 34, 35, 36, 37, 38, 39, 40, 41]), array([42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,\n", - " 59, 60, 61, 62, 63, 64, 65, 66]), array([67, 68, 69, 70, 71, 72, 73, 74, 75]))input shape: (9, 8), output shape: (18, 18)\n", - "\n", - "complete evaluated quantile PDF: (array([-0.95285245, -0.4716778 , -0.23109047, -0.23109047, -0.05761009,\n", - " -0.05761009, 0.09062251, 0.09062251, 0.22917195, 0.22917195,\n", - " 0.36772139, 0.36772139, 0.51595399, 0.51595399, 0.68943438,\n", - " 0.68943438, 0.9300217 , 1.41119635]), array([ 2.22044605e-16, 4.15649494e-01, 4.15649494e-01,\n", - " 5.76434034e-01, 5.76434034e-01, 6.74615457e-01,\n", - " 6.74615457e-01, 7.21764005e-01, 7.21764005e-01,\n", - " 7.21764005e-01, 7.21764005e-01, 6.74615457e-01,\n", - " 6.74615457e-01, 5.76434034e-01, 5.76434034e-01,\n", - " 4.15649494e-01, 4.15649494e-01, 2.22044605e-16]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "evaluated inside (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", - " -0.25252525, -0.15151515, -0.05050505, 0.05050505, 0.15151515,\n", - " 0.25252525, 0.35353535, 0.45454545, 0.55555556, 0.65656566,\n", - " 0.75757576, 0.85858586, 0.95959596, 1.06060606, 1.16161616,\n", - " 1.26262626, 1.36363636, 1.46464646, 1.56565657, 1.66666667]), array([ 0.19482262, 0.21884383, 0.24341678, 0.26798028, 0.29197582,\n", - " 0.31484752, 0.33604216, 0.35500922, 0.37121226, 0.38418021,\n", - " 0.39353248, 0.39898817, 0.40038408, 0.3976788 , 0.39095271,\n", - " 0.38040776, 0.36635886, 0.34921595, 0.32947641, 0.30768512,\n", - " 0.2843935 , 0.26015563, 0.2355282 , 0.21107062, 0.1873449 ]))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "\n", - "order is 5\n", - "evaluated below (array([-1.66666667, -1.56565657, -1.46464646, -1.36363636, -1.26262626,\n", - " -1.16161616, -1.06060606, -0.95959596, -0.85858586]), array([ 0.00971525, 0.03004045, 0.05036565, 0.07069084, 0.09101604,\n", - " 0.11134124, 0.13166644, 0.15199164, 0.17231684]))\n", - "divided into (array([41, 42, 43, 44]), array([45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58]), array([59, 60, 61, 62, 63]))\n", - "evaluated above (array([ 1.76767677, 1.86868687, 1.96969697, 2.07070707, 2.17171717,\n", - " 2.27272727, 2.37373737, 2.47474747, 2.57575758]), array([ 0.16581324, 0.14548804, 0.12516284, 0.10483764, 0.08451244,\n", - " 0.06418724, 0.04386204, 0.02353684, 0.00321164]))Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.22752249, 0.08081044, 0.30314018, 0.49311274, 0.67067553,\n", - " 0.84823831, 1.03821087, 1.26054061, 1.56887354]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "\n", - "\n", - "evaluated inside (array([-0.45454545, -0.35353535, -0.25252525, -0.15151515, -0.05050505,\n", - " 0.05050505, 0.15151515, 0.25252525, 0.35353535, 0.45454545,\n", - " 0.55555556, 0.65656566, 0.75757576, 0.85858586]), array([ 0.33411094, 0.41342215, 0.4949481 , 0.5725297 , 0.64006113,\n", - " 0.69158671, 0.72217601, 0.72882471, 0.71087657, 0.6701044 ,\n", - " 0.61047089, 0.53753679, 0.4573692 , 0.37609858]))input quantiles are [-0.22752249 0.08081044 0.30314018 0.49311274 0.67067553 0.84823831\n", - " 1.03821087 1.26054061 1.56887354]\n", - "evaluated below (array([-0.85858586, -0.75757576, -0.65656566, -0.55555556]), array([ 0.06295026, 0.13040376, 0.19785727, 0.26531077]))\n", - "\n", - "evaluated above (array([ 0.95959596, 1.06060606, 1.16161616, 1.26262626, 1.36363636]), array([ 0.30157409, 0.23412058, 0.16666708, 0.09921357, 0.03176007]))\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "complete evaluated quantile PDF: (array([-0.84418835, -0.22752249, 0.08081044, 0.08081044, 0.30314018,\n", - " 0.30314018, 0.49311274, 0.49311274, 0.67067553, 0.67067553,\n", - " 0.84823831, 0.84823831, 1.03821087, 1.03821087, 1.26054061,\n", - " 1.26054061, 1.56887354, 2.1855394 ]), array([ 2.22044605e-16, 3.24324747e-01, 3.24324747e-01,\n", - " 4.49782389e-01, 4.49782389e-01, 5.26391805e-01,\n", - " 5.26391805e-01, 5.63181074e-01, 5.63181074e-01,\n", - " 5.63181074e-01, 5.63181074e-01, 5.26391805e-01,\n", - " 5.26391805e-01, 4.49782389e-01, 4.49782389e-01,\n", - " 3.24324747e-01, 3.24324747e-01, 2.22044605e-16]))\n", - "order is 5\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([-0.63410249, -0.34639065, -0.13893017, 0.03833716, 0.20402467,\n", - " 0.36971217, 0.5469795 , 0.75443998, 1.04215182]))divided into (array([42, 43, 44, 45, 46, 47]), array([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,\n", - " 65]), array([66, 67, 68, 69, 70, 71]))\n", - "input quantiles are [-0.63410249 -0.34639065 -0.13893017 0.03833716 0.20402467 0.36971217\n", - " 0.5469795 0.75443998 1.04215182]\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "evaluated inside (array([-0.15151515, -0.05050505, 0.05050505, 0.15151515, 0.25252525,\n", - " 0.35353535, 0.45454545, 0.55555556, 0.65656566, 0.75757576,\n", - " 0.85858586, 0.95959596, 1.06060606, 1.16161616, 1.26262626,\n", - " 1.36363636, 1.46464646, 1.56565657]), array([ 0.28602048, 0.3351863 , 0.38482262, 0.43264808, 0.4763967 ,\n", - " 0.51381924, 0.54278436, 0.56158655, 0.56909352, 0.56485326,\n", - " 0.54912047, 0.52284566, 0.48758443, 0.44537765, 0.39846372,\n", - " 0.34910432, 0.29957652, 0.25217281]))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "complete evaluated quantile PDF: (array([-1.20952616, -0.63410249, -0.34639065, -0.34639065, -0.13893017,\n", - " -0.13893017, 0.03833716, 0.03833716, 0.20402467, 0.20402467,\n", - " 0.36971217, 0.36971217, 0.5469795 , 0.5469795 , 0.75443998,\n", - " 0.75443998, 1.04215182, 1.61757549]), array([ 2.22044605e-16, 3.47569988e-01, 3.47569988e-01,\n", - " 4.82019521e-01, 4.82019521e-01, 5.64119744e-01,\n", - " 5.64119744e-01, 6.03545800e-01, 6.03545800e-01,\n", - " 6.03545800e-01, 6.03545800e-01, 5.64119744e-01,\n", - " 5.64119744e-01, 4.82019521e-01, 4.82019521e-01,\n", - " 3.47569988e-01, 3.47569988e-01, 2.22044605e-16]))evaluated below (array([-0.75757576, -0.65656566, -0.55555556, -0.45454545, -0.35353535,\n", - " -0.25252525]), array([ 0.0352149 , 0.07628352, 0.11735215, 0.15842078, 0.1994894 ,\n", - " 0.24055803]))\n", - "\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.75426818, 0.77627287, 0.7921398 , 0.8056975 , 0.81836957,\n", - " 0.83104163, 0.84459933, 0.86046626, 0.88247095]))order is 5\n", - "\n", - "divided into (array([38, 39, 40, 41, 42, 43]), array([44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59]), array([60, 61, 62, 63, 64, 65]))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "input quantiles are [ 0.75426818 0.77627287 0.7921398 0.8056975 0.81836957 0.83104163\n", - " 0.84459933 0.86046626 0.88247095]evaluated above (array([ 1.66666667, 1.76767677, 1.86868687, 1.96969697, 2.07070707,\n", - " 2.17171717]), array([ 0.21096297, 0.16989434, 0.12882571, 0.08775709, 0.04668846,\n", - " 0.00561984]))Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "\n", - "evaluated inside (array([-0.55555556, -0.45454545, -0.35353535, -0.25252525, -0.15151515,\n", - " -0.05050505, 0.05050505, 0.15151515, 0.25252525, 0.35353535,\n", - " 0.45454545, 0.55555556, 0.65656566, 0.75757576, 0.85858586,\n", - " 0.95959596]), array([ 0.31070451, 0.36735297, 0.42415121, 0.47809387, 0.52619741,\n", - " 0.56551778, 0.59343513, 0.60804399, 0.60833168, 0.59427839,\n", - " 0.56685819, 0.52794447, 0.48013393, 0.42636629, 0.36962427,\n", - " 0.31291232]))\n", - "\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "evaluated below (array([-1.16161616, -1.06060606, -0.95959596, -0.85858586, -0.75757576,\n", - " -0.65656566]), array([ 0.02237154, 0.06953814, 0.11670474, 0.16387133, 0.21103793,\n", - " 0.25820452]))complete evaluated quantile PDF: (array([ 0.7102588 , 0.75426818, 0.77627287, 0.77627287, 0.7921398 ,\n", - " 0.7921398 , 0.8056975 , 0.8056975 , 0.81836957, 0.81836957,\n", - " 0.83104163, 0.83104163, 0.84459933, 0.84459933, 0.86046626,\n", - " 0.86046626, 0.88247095, 0.92648033]), array([ 2.22044605e-16, 4.54448593e+00, 4.54448593e+00,\n", - " 6.30241681e+00, 6.30241681e+00, 7.37587919e+00,\n", - " 7.37587919e+00, 7.89137582e+00, 7.89137582e+00,\n", - " 7.89137582e+00, 7.89137582e+00, 7.37587919e+00,\n", - " 7.37587919e+00, 6.30241681e+00, 6.30241681e+00,\n", - " 4.54448593e+00, 4.54448593e+00, 2.22044605e-16]))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "\n", - "evaluated above (array([ 1.06060606, 1.16161616, 1.26262626, 1.36363636, 1.46464646,\n", - " 1.56565657]), array([ 0.26007649, 0.21290989, 0.1657433 , 0.1185767 , 0.0714101 ,\n", - " 0.02424351]))order is 5\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.87371033, 0.88669005, 0.89604935, 0.90404653, 0.91152129,\n", - " 0.91899606, 0.92699323, 0.93635253, 0.94933226]))\n", - "\n", - "input quantiles are [ 0.87371033 0.88669005 0.89604935 0.90404653 0.91152129 0.91899606\n", - " 0.92699323 0.93635253 0.94933226]divided into (array([], dtype=int64), array([57, 58]), array([], dtype=int64))\n", - "\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "complete evaluated quantile PDF: (array([ 0.84775087, 0.87371033, 0.88669005, 0.88669005, 0.89604935,\n", - " 0.89604935, 0.90404653, 0.90404653, 0.91152129, 0.91152129,\n", - " 0.91899606, 0.91899606, 0.92699323, 0.92699323, 0.93635253,\n", - " 0.93635253, 0.94933226, 0.97529172]), array([ 2.22044605e-16, 7.70432123e+00, 7.70432123e+00,\n", - " 1.06845624e+01, 1.06845624e+01, 1.25044160e+01,\n", - " 1.25044160e+01, 1.33783436e+01, 1.33783436e+01,\n", - " 1.33783436e+01, 1.33783436e+01, 1.25044160e+01,\n", - " 1.25044160e+01, 1.06845624e+01, 1.06845624e+01,\n", - " 7.70432123e+00, 7.70432123e+00, 2.22044605e-16]))evaluated inside (array([ 0.75757576, 0.85858586]), array([ 3.81138379, 5.77321742]))\n", - "\n", - "evaluated below (array([], dtype=float64), array([], dtype=float64))\n", - "order is 5\n", - "evaluated above (array([], dtype=float64), array([], dtype=float64))\n", - "divided into (array([58]), array([], dtype=int64), array([59]))\n", - "Calculating 9 quantiles: [ 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "Resulting 9 quantiles: (array([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]), array([ 0.33570561, 0.34266231, 0.34767858, 0.35196481, 0.35597103,\n", - " 0.35997726, 0.36426348, 0.36927975, 0.37623646]))evaluated inside (array([], dtype=float64), array([], dtype=float64))\n", - "\n", - "evaluated below (array([ 0.85858586]), array([ 2.48589346]))\n", - "evaluated above (array([ 0.95959596]), array([ 3.60110922]))\n", - "input quantiles are [ 0.33570561 0.34266231 0.34767858 0.35196481 0.35597103 0.35997726\n", - " 0.36426348 0.36927975 0.37623646]\n", - "input shape: (9, 8), output shape: (18, 18)\n", - "complete evaluated quantile PDF: (array([ 0.3217922 , 0.33570561, 0.34266231, 0.34266231, 0.34767858,\n", - " 0.34767858, 0.35196481, 0.35196481, 0.35597103, 0.35597103,\n", - " 0.35997726, 0.35997726, 0.36426348, 0.36426348, 0.36927975,\n", - " 0.36927975, 0.37623646, 0.39014987]), array([ 2.22044605e-16, 1.43746220e+01, 1.43746220e+01,\n", - " 1.99351171e+01, 1.99351171e+01, 2.33305762e+01,\n", - " 2.33305762e+01, 2.49611389e+01, 2.49611389e+01,\n", - " 2.49611389e+01, 2.49611389e+01, 2.33305762e+01,\n", - " 2.33305762e+01, 1.99351171e+01, 1.99351171e+01,\n", - " 1.43746220e+01, 1.43746220e+01, 2.22044605e-16]))\n", - "order is 5\n", - "divided into (array([], dtype=int64), array([53]), array([], dtype=int64))\n", - "Created a k=`4`B-spline interpolator for the quantiles parametrization.\n", - "evaluated inside (array([ 0.35353535]), array([ 24.93098564]))\n", - "evaluated below (array([], dtype=float64), array([], dtype=float64))\n", - "evaluated above (array([], dtype=float64), array([], dtype=float64))\n" - ] - } - ], "source": [ - "E = qp.Ensemble(N, funcform=in_dists, vb=True)" + "As with individual `qp.PDF` objects, we can evaluate the PDFs at given points, convert to other formats, and integrate." ] }, { @@ -1731,9 +614,16 @@ "E.integrate(demo_limits, using='mix_mod')" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Previous versions of `qp` included a built-in function for \"stacking\" the member PDFs of a `qp.Ensemble` object. This functionality has been removed to discourage use of this procedure in science applications. However, we provide a simple function one may use should this functionality be desired." + ] + }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1754,85 +644,25 @@ "\n", " Returns\n", " -------\n", - " stacked: dict, tuple, ndarray, float\n", + " stacked: tuple, ndarray, float\n", " pair of arrays for locations where approximations were evaluated\n", " and the values of the stacked PDFs at those points\n", - "\n", - " Notes\n", - " -----\n", - " Stacking refers to taking the sum of PDFs evaluated on a shared grid and normalizing it such that it integrates to unity. This is equivalent to calculating an average probability (based on the PDFs in the ensemble) over the grid. This probably should be done in a script and not by qp! The right way to do it would be to call qp.Ensemble.evaluate() and sum those outputs appropriately.\n", - " TO DO: make this do something more efficient for mixmod, grid, histogram, samples\n", " \"\"\"\n", - "# loc_range = max(loc) - min(loc)\n", - "# delta = loc_range / len(loc)\n", - "# loc_delta = loc[1:] - loc[:-1]\n", " evaluated = ensemble.evaluate(loc, using=using, norm=True, vb=vb)\n", " stack = np.mean(evaluated[1], axis=0)\n", - "# stack /= np.sum(stack) * loc_delta\n", - "# assert(np.isclose(np.sum(stack) * loc_delta, 1.))\n", - "# stacked[using] = (evaluated[0], stack)\n", - " return (evaluated[0], stack)" + " stacked = (evaluated[0], stack)\n", + " return stacked" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "stacked = stack(E, eval_range, using='quantiles')" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAD7CAYAAACPDORaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nLLpPkwAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ + "stacked = stack(E, eval_range, using='quantiles')\n", "plt.plot(stacked[0], stacked[-1])" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Scratch" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": {