From 11d6359a5b51c1edb2115d4ec9cd74147b27a9df Mon Sep 17 00:00:00 2001 From: "Travis A. O'Brien" Date: Sun, 5 Nov 2023 12:39:42 -0500 Subject: [PATCH] Added Berkeley Lab logo example --- examples/fastKDE - Berkely Lab Logo.ipynb | 157 +++++ src/fastkde/test_definitions.py | 714 +++++++++++----------- 2 files changed, 527 insertions(+), 344 deletions(-) create mode 100644 examples/fastKDE - Berkely Lab Logo.ipynb diff --git a/examples/fastKDE - Berkely Lab Logo.ipynb b/examples/fastKDE - Berkely Lab Logo.ipynb new file mode 100644 index 0000000..66e63f3 --- /dev/null +++ b/examples/fastKDE - Berkely Lab Logo.ipynb @@ -0,0 +1,157 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \"Open\n", + "\n", + "\n", + "This notebook demonstrates using fastKDE on a complex mixture of distributions. This remakes Figure 4 of O'Brien et al. (2016)\n", + "\n", + "O’Brien, T. A., Kashinath, K., Cavanaugh, N. R., Collins, W. D. & O’Brien, J. P. *A fast and objective multidimensional kernel density estimation method: fastKDE.* Comput. Stat. Data Anal. 101, 148–160 (2016). [http://dx.doi.org/10.1016/j.csda.2016.02.014](http://dx.doi.org/10.1016/j.csda.2016.02.014)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\" Install libraries if needed. \"\"\"\n", + "try:\n", + " import fastkde\n", + " import xarray\n", + "except:\n", + " # install fastkde\n", + " !pip install --upgrade fastkde\n", + " import fastkde" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\" Import libraries. \"\"\"\n", + "import pylab as PP\n", + "import matplotlib as mpl\n", + "import fastkde\n", + "from fastkde.test_definitions import testMixtureModel\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\" Sample from the Berkeley Lab logo mixture distribution. \"\"\"\n", + "test_mix = testMixtureModel()\n", + "mix_samples1 = test_mix.sampleFromDistribution(int(1e6))\n", + "mix_samples2 = test_mix.sampleFromDistribution(int(1e4))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\" Calculate the PDFs. \"\"\"\n", + "pdf1 = fastkde.pdf(\n", + " mix_samples1[0, :], mix_samples1[1, :], var_names=[\"x\", \"y\"], num_points=513\n", + ")\n", + "pdf2 = fastkde.pdf(\n", + " mix_samples2[0, :], mix_samples2[1, :], var_names=[\"x\", \"y\"], num_points=513\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\" Calculate the values of the true PDF. \"\"\"\n", + "mixPDStandard = test_mix.pdfStandard([pdf1.x, pdf1.y])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\"\"\" Create the figure. \"\"\"\n", + "# Initialize a figure with 3 subplots in a row\n", + "fig, axs = PP.subplots(1, 3, figsize=(9, 2.5))\n", + "\n", + "# Set x/y limits\n", + "xlim = [-39, 39]\n", + "ylim = [-39, 39]\n", + "\n", + "# Draw the standard PDF contours\n", + "topPlot = axs[0].contourf(pdf1.x, pdf1.y, mixPDStandard, 64)\n", + "\n", + "# Draw the KDE contours\n", + "axs[1].contourf(pdf1.x, pdf1.y, pdf1, levels=topPlot.levels)\n", + "axs[2].contourf(pdf2.x, pdf2.y, pdf2, levels=topPlot.levels)\n", + "\n", + "# Set x/y limits and labels\n", + "for i in range(3):\n", + " axs[i].set_xlim(xlim)\n", + " axs[i].set_ylim(ylim)\n", + " axs[i].set_xlabel(\"$x$\")\n", + "axs[0].set_ylabel(\"$y$\")\n", + "\n", + "# Turn off y-ticks for the last 2 plots\n", + "for i in (1, 2):\n", + " axs[i].axes.get_yaxis().set_ticks([])\n", + "\n", + "# add titles\n", + "axs[0].set_title(\"True PDF\")\n", + "axs[1].set_title(f\"fastkde, N={int(1e6):,}\")\n", + "axs[2].set_title(f\"fastkde, N={int(1e4):,}\")\n", + "\n", + "PP.tight_layout()\n", + "PP.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/src/fastkde/test_definitions.py b/src/fastkde/test_definitions.py index e1b3167..956754f 100644 --- a/src/fastkde/test_definitions.py +++ b/src/fastkde/test_definitions.py @@ -6,8 +6,7 @@ from multiprocessing import Pool import numpy as npy -berkeleyLabText = \ -""" +berkeleyLabText = """ .++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -62,97 +61,108 @@ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ,++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++, -""" #Adapted from http://picascii.com/ +""" # Adapted from http://picascii.com/ -def underlyingFunction(x,x0=305,y0=200,yrange=4): + +def underlyingFunction(x, x0=305, y0=200, yrange=4): """A sigmoid with a transition centered on x0""" - return (yrange/2)*npy.tanh(x-x0) + y0 + return (yrange / 2) * npy.tanh(x - x0) + y0 + -def stochasticSample(x0=305,y0=200,yrange=4,numSamples=1e3, \ - xmid=305,xp1=5,xp2=2, \ - yp1 = 0, yp2 = None): +def stochasticSample( + x0=305, y0=200, yrange=4, numSamples=1e3, xmid=305, xp1=5, xp2=2, yp1=0, yp2=None +): if yp2 is None: - #By default, have the range of the noise be larger than the range in y - yp2 = 3*yrange - #Generate random samples of X from the gamma distribution - #Note: I flip the gamma distribution around here so that the upper range has a short tail - x = -(npy.random.gamma(xp1,xp2,int(numSamples))-xp1*xp2) + xmid - #Generate random samples of y from x and add normally distributed noise - y = underlyingFunction(x,x0,y0,yrange) + npy.random.normal(loc=yp1,scale=yp2,size=numSamples) - - #Concatenate the paired samples together - xy = npy.concatenate((x[npy.newaxis,:],y[npy.newaxis,:]),axis=0) + # By default, have the range of the noise be larger than the range in y + yp2 = 3 * yrange + # Generate random samples of X from the gamma distribution + # Note: I flip the gamma distribution around here so that the upper range has a short tail + x = -(npy.random.gamma(xp1, xp2, int(numSamples)) - xp1 * xp2) + xmid + # Generate random samples of y from x and add normally distributed noise + y = underlyingFunction(x, x0, y0, yrange) + npy.random.normal( + loc=yp1, scale=yp2, size=numSamples + ) + + # Concatenate the paired samples together + xy = npy.concatenate((x[npy.newaxis, :], y[npy.newaxis, :]), axis=0) return xy -def conditionalPDF(y,x, \ - x0=305,y0=200,yrange=4, \ - xmid=305,xp1=5,xp2=2, \ - yp1 = 0, yp2 = None): + +def conditionalPDF( + y, x, x0=305, y0=200, yrange=4, xmid=305, xp1=5, xp2=2, yp1=0, yp2=None +): if yp2 is None: - #By default, have the range of the noise be larger than the range in y - yp2 = 3*yrange - - mu = underlyingFunction(x,x0,y0,yrange) - - return stat.norm.pdf(y,loc=mu,scale=yp2) - -def marginalX(y,x, \ - x0=305,y0=200,yrange=4, \ - xmid=305,xp1=5,xp2=2, \ - yp1 = 0, yp2 = None): - xbar = xp1*xp2 - return stat.gamnpy.ma.pdf(x0 - x + xbar,a=xp1,scale=xp2) - -def jointXY(y,x, \ - x0=305,y0=200,yrange=4, \ - xmid=305,xp1=5,xp2=2, \ - yp1 = 0, yp2 = None): - #Return the product of the conditional and the marginal - return marginalX(y,x,x0,y0,yrange,xmid,xp1,xp2,yp1,yp2) * \ - conditionalPDF(y,x,x0,y0,yrange,xmid,xp1,xp2,yp1,yp2) - -def getModeCurve(conditional,axes): + # By default, have the range of the noise be larger than the range in y + yp2 = 3 * yrange + + mu = underlyingFunction(x, x0, y0, yrange) + + return stat.norm.pdf(y, loc=mu, scale=yp2) + + +def marginalX(y, x, x0=305, y0=200, yrange=4, xmid=305, xp1=5, xp2=2, yp1=0, yp2=None): + xbar = xp1 * xp2 + return stat.gamnpy.ma.pdf(x0 - x + xbar, a=xp1, scale=xp2) + + +def jointXY(y, x, x0=305, y0=200, yrange=4, xmid=305, xp1=5, xp2=2, yp1=0, yp2=None): + # Return the product of the conditional and the marginal + return marginalX(y, x, x0, y0, yrange, xmid, xp1, xp2, yp1, yp2) * conditionalPDF( + y, x, x0, y0, yrange, xmid, xp1, xp2, yp1, yp2 + ) + + +def getModeCurve(conditional, axes): """Extract the mode curve from a 2D conditional (assumes conditioning on axis 0)""" - modeCurve = npy.array([ axes[1][conditional[:,i].argmax()] for i in range(conditional.shape[1])]) - #Remove points whre all of the PDF is missing - allMising = npy.prod((conditional.mask),axis=0) - modeCurve = npy.ma.masked_where(allMising == 1,modeCurve) + modeCurve = npy.array( + [axes[1][conditional[:, i].argmax()] for i in range(conditional.shape[1])] + ) + # Remove points whre all of the PDF is missing + allMising = npy.prod((conditional.mask), axis=0) + modeCurve = npy.ma.masked_where(allMising == 1, modeCurve) return modeCurve -def asciiToPoints(text,convertCharacter = " "): +def asciiToPoints(text, convertCharacter=" "): """Given ascii art text, convert the whitespace into a list of point""" - - #Get the lines from the text - textLines = text.split('\n')[1:-1] - - #Convert the text into a point array - pointArray = npy.array([ [ 1 if char == convertCharacter else 0 for char in line] for line in textLines]).T[:,::-1] - + + # Get the lines from the text + textLines = text.split("\n")[1:-1] + + # Convert the text into a point array + pointArray = npy.array( + [[1 if char == convertCharacter else 0 for char in line] for line in textLines] + ).T[:, ::-1] + return npy.where(pointArray == 1) - -def powLaw(x,a,c): - return c*x**a -#A simple timer for comparing ECF calculation methods -class Timer(): + +def powLaw(x, a, c): + return c * x**a + + +# A simple timer for comparing ECF calculation methods +class Timer: """A simple timer class - + Example: ```python myTimer = Timer() with myTimer: doSomething() - + print myTimer.duration ``` """ + def __enter__(self): self.start = time.time() + def __exit__(self, *args): self.duration = time.time() - self.start -def genCovMat(varianceList,correlationDict): + +def genCovMat(varianceList, correlationDict): """Generates a covariance matrix, given a list of variances for all variables and a dict of correlation coefficients for all pairs of variables. @@ -169,103 +179,119 @@ def genCovMat(varianceList,correlationDict): covMat = genCovMat(varianceList,correlationDict) ``` """ - - #Generate a list of all possible unique variable pairs + + # Generate a list of all possible unique variable pairs numVars = len(varianceList) pairList = correlationDict.keys() - for i,j in pairList: - #Check that the indices are different from one another for this pair - assert i != j,'The (i,j) tuple keys for correlationDict must all be different' - assert i >= 0 and j >= 0,'i and j must be >= 0' - assert i < numVars and j < numVars,'i and j must be < {}'.format(numVars) - #Check that the correlation coefficients are valid - assert abs(correlationDict[(i,j)]) <= 1, "All correlation coefficients must have a magnitude less than or equal to 1" - - #Make sure we have enough correlation pairs - numPairsNeeded = (numVars**2 - numVars)/2 - assert len(pairList) == numPairsNeeded,"{} correlation pairs were provided; {} are needed".format(len(pairList),numPairsNeeded) - - #Initialize the covariance matrix - covMat = npy.zeros([numVars,numVars]) - - #Insert the variances + for i, j in pairList: + # Check that the indices are different from one another for this pair + assert i != j, "The (i,j) tuple keys for correlationDict must all be different" + assert i >= 0 and j >= 0, "i and j must be >= 0" + assert i < numVars and j < numVars, "i and j must be < {}".format(numVars) + # Check that the correlation coefficients are valid + assert ( + abs(correlationDict[(i, j)]) <= 1 + ), "All correlation coefficients must have a magnitude less than or equal to 1" + + # Make sure we have enough correlation pairs + numPairsNeeded = (numVars**2 - numVars) / 2 + assert ( + len(pairList) == numPairsNeeded + ), "{} correlation pairs were provided; {} are needed".format( + len(pairList), numPairsNeeded + ) + + # Initialize the covariance matrix + covMat = npy.zeros([numVars, numVars]) + + # Insert the variances for i in range(numVars): - covMat[i,i] = varianceList[i] - - #Insert the covariances - for i,j in pairList: - covMat[i,j] = covMat[j,i] = correlationDict[(i,j)]*npy.sqrt(varianceList[i])*npy.sqrt(varianceList[j]) - + covMat[i, i] = varianceList[i] + + # Insert the covariances + for i, j in pairList: + covMat[i, j] = covMat[j, i] = ( + correlationDict[(i, j)] + * npy.sqrt(varianceList[i]) + * npy.sqrt(varianceList[j]) + ) + return covMat -def estimatePDFWrapper(arg,**kwargs): + +def estimatePDFWrapper(arg, **kwargs): """A timed wrapper for doing a PDF estimate and evaluating its error""" - j,numSamplesMax,sampleList,scKWArgs,conditionVar,pdfTestObj = arg + j, numSamplesMax, sampleList, scKWArgs, conditionVar, pdfTestObj = arg - #Seed the random number generator + # Seed the random number generator npy.random.seed(j) - #Pull samples from the distribution + # Pull samples from the distribution mySamples = pdfTestObj.sampleFromDistribution(numSamplesMax) - ISEVals = [] timingVals = [] for numSamples in sampleList: - #Extract the current sample set - mySample = mySamples[...,:numSamples] + # Extract the current sample set + mySample = mySamples[..., :numSamples] - #Initialize the timer + # Initialize the timer myTimer = Timer() - #Do the KDE estimate and time it + # Do the KDE estimate and time it with myTimer: - _pdf = fastKDE.fastKDE(mySample, \ - **scKWArgs) + _pdf = fastKDE.fastKDE(mySample, **scKWArgs) if conditionVar is not None: - cpdf = _pdf.estimateConditionals(conditionVar,mySample,peakFrac = 0.01) + cpdf = _pdf.estimateConditionals(conditionVar, mySample, peakFrac=0.01) - #Calculate the integrated squared error + # Calculate the integrated squared error deltaXs = [npy.diff(ax) for ax in _pdf.axes] - deltaXs = [npy.concatenate((dx,[dx[-1]])) for dx in deltaXs] - deltaXProducts = npy.prod(npy.meshgrid(*tuple(deltaXs)),axis=0) + deltaXs = [npy.concatenate((dx, [dx[-1]])) for dx in deltaXs] + deltaXProducts = npy.prod(npy.meshgrid(*tuple(deltaXs)), axis=0) if conditionVar is None: - ISE = npy.ma.sum(deltaXProducts*(pdfTestObj.pdfStandard(_pdf.axes) - _pdf.pdf)**2) + ISE = npy.ma.sum( + deltaXProducts * (pdfTestObj.pdfStandard(_pdf.axes) - _pdf.pdf) ** 2 + ) else: - ISE = npy.ma.sum(deltaXProducts*(pdfTestObj.pdfStandard(_pdf.axes) - cpdf)**2)/len(cpdf.compressed()) + ISE = npy.ma.sum( + deltaXProducts * (pdfTestObj.pdfStandard(_pdf.axes) - cpdf) ** 2 + ) / len(cpdf.compressed()) ISEVals.append(ISE) timingVals.append(myTimer.duration) - return timingVals,ISEVals,mySamples + return timingVals, ISEVals, mySamples class testDistribution(object): """A generic distribution--meant to be overridden--for testing the fast KDE method""" - - def __init__(self,**kwargs): - #Save all incoming keyword arguments - for key,val in kwargs.items(): - self.__setitem__(key,val) - - self.pdfName = 'None' - - def sampleFromDistribution(self,numSamples=2097152): + + def __init__(self, **kwargs): + # Save all incoming keyword arguments + for key, val in kwargs.items(): + self.__setitem__(key, val) + + self.pdfName = "None" + + def sampleFromDistribution(self, numSamples=2097152): pass - - def pdfStandard(self,axes): + + def pdfStandard(self, axes): pass - - def doTesting(self, \ - numSamplesMax=2097152, \ - numRepetitions = 30, \ - scKWArgs = {'fracContiguousHyperVolumes' : 1, \ - 'numPoints' : 257, \ - 'positiveShift' : False}, \ - numProcs = 1): - + + def doTesting( + self, + numSamplesMax=2097152, + numRepetitions=30, + scKWArgs={ + "fracContiguousHyperVolumes": 1, + "numPoints": 257, + "positiveShift": False, + }, + numProcs=1, + ): self.numProcs = int(numProcs) try: @@ -273,301 +299,301 @@ def doTesting(self, \ except AttributeError: conditionVar = None - #Set the number of test samples to be a power of 2 + # Set the number of test samples to be a power of 2 powmax = int(npy.floor(npy.log2(numSamplesMax))) numSamplesMax = 2**powmax - - #Set the list of numbers-of-samples - sampleList = 2**(npy.arange(4,powmax+1)) + 1 - - #Save the sampling list + + # Set the list of numbers-of-samples + sampleList = 2 ** (npy.arange(4, powmax + 1)) + 1 + + # Save the sampling list self.sampleList = sampleList if self.numProcs == 1: - returnList = [\ - estimatePDFWrapper(( \ - j, \ - numSamplesMax, \ - sampleList, \ - scKWArgs, \ - conditionVar, \ - self)) - for j in range(numRepetitions) ] + returnList = [ + estimatePDFWrapper( + (j, numSamplesMax, sampleList, scKWArgs, conditionVar, self) + ) + for j in range(numRepetitions) + ] else: - #Do the PDF estimation using multiple processors + # Do the PDF estimation using multiple processors estimationPool = Pool(self.numProcs) - returnList = \ - estimationPool.map(estimatePDFWrapper, zip( \ - range(numRepetitions), \ - [numSamplesMax]*numRepetitions, \ - [sampleList]*numRepetitions, \ - [scKWArgs]*numRepetitions, \ - [conditionVar]*numRepetitions, \ - [self]*numRepetitions)) - - #Save the longest sample of each repetition - #self.sampleObjs = [ ra[2] for ra in returnList] - #Save the timing values - self.masterTiming = npy.array( [ ra[0] for ra in returnList ]) - #Save the ISE values - self.masterISE = npy.array( [ ra[1] for ra in returnList ]) - - self.meanISE = npy.average(self.masterISE,axis=0) - self.meanTiming = npy.average(self.masterTiming,axis=0) - self.stdISE = npy.std(self.masterISE,axis=0) - self.stdTiming = npy.std(self.masterTiming,axis=0) - - - popt,pcov = opt.curve_fit(powLaw,self.sampleList,self.meanISE,p0=(1,-1),sigma=self.stdISE) - + returnList = estimationPool.map( + estimatePDFWrapper, + zip( + range(numRepetitions), + [numSamplesMax] * numRepetitions, + [sampleList] * numRepetitions, + [scKWArgs] * numRepetitions, + [conditionVar] * numRepetitions, + [self] * numRepetitions, + ), + ) + + # Save the longest sample of each repetition + # self.sampleObjs = [ ra[2] for ra in returnList] + # Save the timing values + self.masterTiming = npy.array([ra[0] for ra in returnList]) + # Save the ISE values + self.masterISE = npy.array([ra[1] for ra in returnList]) + + self.meanISE = npy.average(self.masterISE, axis=0) + self.meanTiming = npy.average(self.masterTiming, axis=0) + self.stdISE = npy.std(self.masterISE, axis=0) + self.stdTiming = npy.std(self.masterTiming, axis=0) + + popt, pcov = opt.curve_fit( + powLaw, self.sampleList, self.meanISE, p0=(1, -1), sigma=self.stdISE + ) + self._popt = popt self._pcov = pcov self.ISESlope = popt[0] self.ISENorm = popt[1] - self.ISEFit = popt[1]*npy.array(self.sampleList)**popt[0] - - def generatePlots(self,saveType = None,show=True): + self.ISEFit = popt[1] * npy.array(self.sampleList) ** popt[0] + + def generatePlots(self, saveType=None, show=True): """Generate plots of the error rate and the timing""" - - fig = PP.figure(figsize=(8,8)) - ax = fig.add_subplot(111,xscale='log',yscale='log') - - ax.errorbar(self.sampleList,self.meanISE,yerr=self.stdISE) - ax.plot(self.sampleList,self.ISEFit,linewidth=3,alpha=0.5,color='gray') - - ax.set_xlabel('# of Samples') - ax.set_ylabel('I.S.E.') - - ax.legend(['{} ISE'.format(self.pdfName),r'N$^{'+'{:0.02f}'.format(self.ISESlope)+'}$']) - + + fig = PP.figure(figsize=(8, 8)) + ax = fig.add_subplot(111, xscale="log", yscale="log") + + ax.errorbar(self.sampleList, self.meanISE, yerr=self.stdISE) + ax.plot(self.sampleList, self.ISEFit, linewidth=3, alpha=0.5, color="gray") + + ax.set_xlabel("# of Samples") + ax.set_ylabel("I.S.E.") + + ax.legend( + [ + "{} ISE".format(self.pdfName), + r"N$^{" + "{:0.02f}".format(self.ISESlope) + "}$", + ] + ) + if show: PP.show() - + + class testNormal1D(testDistribution): - - def __init__(self,**kwargs): - - #Call the class constructor - super(testNormal1D,self).__init__(**kwargs) - + def __init__(self, **kwargs): + # Call the class constructor + super(testNormal1D, self).__init__(**kwargs) + try: self.mu except AttributeError: self.mu = 0.0 - + try: self.sig except AttributeError: self.sig = 1.0 - - self.pdfName = 'Normal' - - - def sampleFromDistribution(self,numSamples=2097152): + + self.pdfName = "Normal" + + def sampleFromDistribution(self, numSamples=2097152): """Samples from a random normal distribution""" sig = self.sig - mu = self.mu - randsample = sig*npy.random.normal(size = numSamples) + mu - return randsample[npy.newaxis,:] - - def pdfStandard(self,axes): + mu = self.mu + randsample = sig * npy.random.normal(size=numSamples) + mu + return randsample[npy.newaxis, :] + + def pdfStandard(self, axes): """Returns the value of the normal distribution at location `axes`""" x = axes[0] sig = self.sig mu = self.mu - pdfVal = (1./(sig*npy.sqrt(2*npy.pi)))*npy.exp(-(x-mu)**2/(2.*sig**2)) - + pdfVal = (1.0 / (sig * npy.sqrt(2 * npy.pi))) * npy.exp( + -((x - mu) ** 2) / (2.0 * sig**2) + ) + return pdfVal - + + class testNormal2D(testDistribution): - - def __init__(self,**kwargs): - - #Call the class constructor - super(testNormal2D,self).__init__(**kwargs) - + def __init__(self, **kwargs): + # Call the class constructor + super(testNormal2D, self).__init__(**kwargs) + try: self.mu except AttributeError: - self.mu = npy.array([0.0,0.0]) - + self.mu = npy.array([0.0, 0.0]) + try: self.sig except AttributeError: - self.sig = npy.array([1.0,3.0]) - + self.sig = npy.array([1.0, 3.0]) + try: self.rho except AttributeError: self.rho = 0.7 - - self.pdfName = 'Bivariate Normal' - - - def sampleFromDistribution(self,numSamples=2097152): + + self.pdfName = "Bivariate Normal" + + def sampleFromDistribution(self, numSamples=2097152): """Samples from a bivariate normal distribution""" - sx,sy = self.sig + sx, sy = self.sig mu = self.mu r = self.rho - covMat = [[sx**2,r*sx*sy],[r*sx*sy,sy**2]] + covMat = [[sx**2, r * sx * sy], [r * sx * sy, sy**2]] - randsample = npy.random.multivariate_normal(mu,covMat,(numSamples,)).T + randsample = npy.random.multivariate_normal(mu, covMat, (numSamples,)).T return randsample - - def pdfStandard(self,axes): + + def pdfStandard(self, axes): """Returns the value of the bivariate normal distribution at location `axes`""" - sx,sy = self.sig + sx, sy = self.sig mu = self.mu r = self.rho - - C = [[sx**2,r*sx*sy],[r*sx*sy,sy**2]] - - xarrays = npy.array(npy.meshgrid(axes[0],axes[1])).T - - return stat.multivariate_normal.pdf(xarrays,mu,C).T - + + C = [[sx**2, r * sx * sy], [r * sx * sy, sy**2]] + + xarrays = npy.array(npy.meshgrid(axes[0], axes[1])).T + + return stat.multivariate_normal.pdf(xarrays, mu, C).T + class testNormalND(testDistribution): - - def __init__(self,**kwargs): - - #Call the class constructor - super(testNormalND,self).__init__(**kwargs) - + def __init__(self, **kwargs): + # Call the class constructor + super(testNormalND, self).__init__(**kwargs) + try: self.mu except AttributeError: - self.mu = [0.0,50.0,-50.0] - + self.mu = [0.0, 50.0, -50.0] + try: self.covMat except AttributeError: varianceList = [0.1, 10.0, 100.0] - correlationDict = { (0,1) : 0.9, \ - (0,2) : 0.0, \ - (1,2) : -0.4 } - self.covMat = genCovMat(varianceList,correlationDict) - + correlationDict = {(0, 1): 0.9, (0, 2): 0.0, (1, 2): -0.4} + self.covMat = genCovMat(varianceList, correlationDict) + self.rank = len(self.mu) - - self.pdfName = 'Multivariate Normal' - - - def sampleFromDistribution(self,numSamples=2097152): + + self.pdfName = "Multivariate Normal" + + def sampleFromDistribution(self, numSamples=2097152): """Samples from a multivariate normal distribution""" mu = self.mu covMat = self.covMat - #randsample = npy.random.multivariate_normal(mu,covMat,(numSamples,)).T - randsample = stat.multivariate_normal.rvs(mu,covMat,(numSamples,)).T + # randsample = npy.random.multivariate_normal(mu,covMat,(numSamples,)).T + randsample = stat.multivariate_normal.rvs(mu, covMat, (numSamples,)).T return randsample - - def pdfStandard(self,axes): + + def pdfStandard(self, axes): """Returns the value of the multivariate normal distribution at location `axes`""" - + mu = self.mu C = self.covMat k = self.rank - - lastFirst = npy.zeros(k+1,dtype=int) + + lastFirst = npy.zeros(k + 1, dtype=int) lastFirst[-1] = 0 - #lastFirst[:-1] = roll(npy.arange(k) + 1,1) + # lastFirst[:-1] = roll(npy.arange(k) + 1,1) lastFirst[:-1] = npy.arange(k) + 1 - xarrays = npy.transpose(npy.array(npy.meshgrid(*axes,indexing='ij')),axes=lastFirst) - - return stat.multivariate_normal.pdf(xarrays,mu,C).T - + xarrays = npy.transpose( + npy.array(npy.meshgrid(*axes, indexing="ij")), axes=lastFirst + ) + + return stat.multivariate_normal.pdf(xarrays, mu, C).T + class testMixtureModel(testDistribution): - - def __init__(self,**kwargs): - - #Call the class constructor - super(testMixtureModel,self).__init__(**kwargs) - + def __init__(self, **kwargs): + # Call the class constructor + super(testMixtureModel, self).__init__(**kwargs) + try: self.muList except AttributeError: - xp,yp = asciiToPoints(berkeleyLabText) - xbar = 0.9*npy.median(xp) + xp, yp = asciiToPoints(berkeleyLabText) + xbar = 0.9 * npy.median(xp) ybar = npy.median(yp) - - #Transform to center + # Transform to center xp = xp - xbar yp = yp - ybar - - #Rotate the image - theta = 37. * npy.pi/180. - xpd = xp*npy.cos(theta) - yp*npy.sin(theta) - ypd = xp*npy.sin(theta) + yp*npy.cos(theta) + + # Rotate the image + theta = 37.0 * npy.pi / 180.0 + xpd = xp * npy.cos(theta) - yp * npy.sin(theta) + ypd = xp * npy.sin(theta) + yp * npy.cos(theta) xp = xpd yp = ypd - - #Calculate the variance + + # Calculate the variance varx = npy.var(xp) vary = npy.var(yp) - - self.muList = list(zip(xp,yp)) - self.covList = list(0.3*npy.ones(len(self.muList))) - + + self.muList = list(zip(xp, yp)) + self.covList = list(0.3 * npy.ones(len(self.muList))) + for i in range(int(len(xp))): - self.muList.append((0.0,0.0)) - self.covList.append(genCovMat([varx,vary],{(0,1) : 0.0})) - - self.pdfName = 'Mixture of Standard Normals' - - - def sampleFromDistribution(self,numSamples=2097152): + self.muList.append((0.0, 0.0)) + self.covList.append(genCovMat([varx, vary], {(0, 1): 0.0})) + + self.pdfName = "Mixture of Standard Normals" + + def sampleFromDistribution(self, numSamples=2097152): """Samples from a multivariate normal distribution""" numNormals = len(self.muList) - - #Generate a sequence of random draws, representing randomly (uniformly) choosing - #from among the given normal distributions - iDraws = npy.random.randint(0,numNormals,size=numSamples) - - #From these draws, construct the lengths of samples for each multivariate normal - numDraws = [ len(npy.nonzero(iDraws == i)[0]) for i in range(numNormals) ] - - #randsample = npy.random.multivariate_normal(mu,covMat,(numSamples,)).T + + # Generate a sequence of random draws, representing randomly (uniformly) choosing + # from among the given normal distributions + iDraws = npy.random.randint(0, numNormals, size=numSamples) + + # From these draws, construct the lengths of samples for each multivariate normal + numDraws = [len(npy.nonzero(iDraws == i)[0]) for i in range(numNormals)] + + # randsample = npy.random.multivariate_normal(mu,covMat,(numSamples,)).T sampleList = [] - for mu,cov,N in zip(self.muList,self.covList,numDraws): + for mu, cov, N in zip(self.muList, self.covList, numDraws): if N > 0: - sample = stat.multivariate_normal.rvs(mu,cov,N) + sample = stat.multivariate_normal.rvs(mu, cov, N) if len(npy.shape(sample)) == 1: - sample = sample[npy.newaxis,:] + sample = sample[npy.newaxis, :] sampleList.append(sample) - - #Concatenate the samples - randsample = npy.concatenate(sampleList,axis=0) - #Shuffle the samples in-place + # Concatenate the samples + randsample = npy.concatenate(sampleList, axis=0) + + # Shuffle the samples in-place npy.random.shuffle(randsample) - #Return the transpose [var,sample] + # Return the transpose [var,sample] return randsample.T - - def pdfStandard(self,axes): + + def pdfStandard(self, axes): """Returns the value of the multivariate normal distribution at location `axes`""" - + k = len(axes) - - #Create the x grid to feed to multivariate_normal - lastFirst = npy.zeros(k+1,dtype=int) + + # Create the x grid to feed to multivariate_normal + lastFirst = npy.zeros(k + 1, dtype=int) lastFirst[-1] = 0 lastFirst[:-1] = npy.arange(k) + 1 - xarrays = npy.transpose(npy.array(npy.meshgrid(*axes,indexing='ij')),axes=lastFirst) - - pdfStandard = npy.zeros(npy.shape(xarrays[...,0])) - - #Go through the distribution centers + xarrays = npy.transpose( + npy.array(npy.meshgrid(*axes, indexing="ij")), axes=lastFirst + ) + + pdfStandard = npy.zeros(npy.shape(xarrays[..., 0])) + + # Go through the distribution centers numNormals = float(len(self.muList)) - for mu,cov in zip(self.muList,self.covList): - pdfStandard += stat.multivariate_normal.pdf(xarrays,mu,cov)/numNormals - + for mu, cov in zip(self.muList, self.covList): + pdfStandard += stat.multivariate_normal.pdf(xarrays, mu, cov) / numNormals + return pdfStandard.T + # def doTesting(self, \ # scKWArgs = {'fracContiguousHyperVolumes' : 1, \ # 'numPoints' : 513}, \ @@ -578,35 +604,35 @@ def pdfStandard(self,axes): # super(testMixtureModel,self).doTesting(scKWArgs=scKWArgs,**kwargs) - class transitionPDF(testDistribution): """A test for transition PDF convergence""" - def __init__(self,**kwargs): - #Save all incoming keyword arguments - for key,val in kwargs.items(): - self.__setitem__(key,val) - - self.pdfName = 'Transition' - - def sampleFromDistribution(self,numSamples=2097152): + + def __init__(self, **kwargs): + # Save all incoming keyword arguments + for key, val in kwargs.items(): + self.__setitem__(key, val) + + self.pdfName = "Transition" + + def sampleFromDistribution(self, numSamples=2097152): return stochasticSample(numSamples=numSamples) - - def pdfStandard(self,axes): - xx,yy = npy.meshgrid(*axes) - return jointXY(yy,xx) + + def pdfStandard(self, axes): + xx, yy = npy.meshgrid(*axes) + return jointXY(yy, xx) + class testConditional(transitionPDF): """A test for transition PDF convergence of the conditional""" - def __init__(self,**kwargs): - #Save all incoming keyword arguments - for key,val in kwargs.items(): - self.__setitem__(key,val) - - self.pdfName = 'Conditional' - self.conditionVar = 0 - - def pdfStandard(self,axes): - xx,yy = npy.meshgrid(*axes) - return conditionalPDF(yy,xx) + def __init__(self, **kwargs): + # Save all incoming keyword arguments + for key, val in kwargs.items(): + self.__setitem__(key, val) + + self.pdfName = "Conditional" + self.conditionVar = 0 + def pdfStandard(self, axes): + xx, yy = npy.meshgrid(*axes) + return conditionalPDF(yy, xx)