def testInterpolate(self):
"""
This will test GaussianProcess.interpolate using both the squared
exponential covariogram and the neural network covariogram on data
that was generated with known answers.
The test will check that the code returns the correct values of both
mu (interpolated function value) and sig2 (the variance)
This test uses the GaussianProcess constructor that does not normalize
coordinate values with minima and maxima.
"""
pp = 2000 #number of data points
dd = 10 #number of dimensions
kk = 15 #number of nearest neighbors being used
tol = 1.0e-3 #the largest relative error that will be tolerated
data = np.zeros((pp,dd),dtype = float) #input data points
fn = np.zeros((pp),dtype = float) #input function values
test = np.zeros((dd),dtype = float) #query points
sigma = np.zeros((1),dtype = float) #variance
xx=gp.SquaredExpCovariogramD()
xx.setEllSquared(100.0)
#read in the input data
f = open("tests/data/gp_exp_covar_data.sav")
ff = f.readlines()
f.close()
for i in range(len(ff)):
s = ff[i].split()
fn[i] = float(s[10])
for j in range(10):
data[i][j] = float(s[j])
#first try the squared exponential covariogram (the default)
try:
gg = gp.GaussianProcessD(data,fn,xx)
except pex.Exception as e:
print e.what()
gg.setLambda(0.001)
#now, read in the test points and their corresponding known solutions
f = open("tests/data/gp_exp_covar_solutions.sav")
ff = f.readlines()
f.close()
worstMuErr = -1.0 #keep track of the worst fractional error in mu
worstSigErr = -1.0 #keep track of the worst fractional error in the variance
for z in range(len(ff)):
s = ff[z].split() #s will store the zth line of the solution file
for i in range(dd):
test[i] = float(s[i]) #read in the test point coordinates
mushld = float(s[dd + kk]) #read in what mu should be
sigshld = float(s[dd + kk + 1]) #read in what the variance should be
mu = gg.interpolate(sigma,test,kk)
err = (mu - mushld)
if mushld != 0.0:
err = err/mushld
if err < 0.0:
err = -1.0 * err
if z == 0 or err > worstMuErr:
worstMuErr = err
err = (sigma[0] - sigshld)
if sigshld != 0.0:
err = err/sigshld
if err < 0.0:
err = -1.0 * err
if z == 0 or err > worstSigErr:
worstSigErr = err
print "\nThe errors for squared exponent covariogram\n"
print "worst mu error ",worstMuErr
print "worst sig2 error ",worstSigErr
self.assertTrue(worstMuErr < tol)
self.assertTrue(worstSigErr < tol)
#now try with the Neural Network covariogram
kk = 50
nn=gp.NeuralNetCovariogramD()
nn.setSigma0(1.23)
nn.setSigma1(0.452)
gg.setCovariogram(nn)
gg.setLambda(0.0045)
f = open("tests/data/gp_nn_solutions.sav")
ff = f.readlines()
f.close()
worstMuErr = -1.0
worstSigErr = -1.0
for z in range(len(ff)):
s = ff[z].split()
for i in range(dd):
test[i] = float(s[i])
mushld = float(s[dd + kk])
sigshld = float(s[dd + kk + 1])
mu = gg.interpolate(sigma,test,kk)
err = (mu - mushld)
if mushld != 0.0:
err = err/mushld
if err < 0.0:
err = -1.0 * err
if z == 0 or err > worstMuErr:
worstMuErr = err
err = (sigma[0] - sigshld)
if sigshld != 0.0:
err = err/sigshld
if err < 0.0:
err = -1.0 * err
if z == 0 or err > worstSigErr:
worstSigErr = err
print "\nThe errors for neural net covariogram\n"
print "worst mu error ",worstMuErr
print "worst sig2 error ",worstSigErr
self.assertTrue(worstMuErr < tol)
self.assertTrue(worstSigErr < tol)
def testVector(self):
"""
This will test interpolate using a vector of functions
"""
tol=1.0e-3
data=np.zeros((2000,10), dtype = float)
fn=np.zeros((2000,4), dtype = float)
mu=np.zeros((4), dtype=float)
sig=np.zeros((4), dtype = float)
mushld=np.zeros((4), dtype = float)
vv=np.zeros((10), dtype = float)
vvf=np.zeros((4), dtype = float)
kk=30
f=open("tests/data/gp_vector_data.sav","r")
ff=f.readlines()
f.close()
for i in range(len(ff)):
s=ff[i].split()
for j in range(10):
data[i][j]=float(s[j])
for j in range(4):
fn[i][j]=float(s[j+10])
nn=gp.NeuralNetCovariogramD()
nn.setSigma0(2.25)
nn.setSigma1(0.76)
try:
gg=gp.GaussianProcessD(data,fn,nn);
except pex.Exception as e:
print e.what()
gg.setLambda(0.0045)
worstMuErr=-1.0
worstSigErr=-1.0
f=open("tests/data/gp_vector_solutions.sav","r")
ff=f.readlines()
f.close()
for i in range(len(ff)):
s=ff[i].split()
for j in range(10):
vv[j]=float(s[j])
for j in range(4):
mushld[j]=float(s[j+10])
sigshld=float(s[14])
gg.interpolate(mu,sig,vv,kk)
for j in range(4):
muErr= (mu[j]-mushld[j])/mushld[j]
sigErr = (sig[j]-sigshld)/sigshld
if muErr < 0.0:
muErr = -1.0 * muErr
if sigErr < 0.0:
sigErr = -1.0 * sigErr
if (muErr > worstMuErr):
worstMuErr=muErr
if (sigErr > worstSigErr):
worstSigErr=sigErr
print "\nThe errors for vector interpolation\n"
print "worst mu error ",worstMuErr
print "worst sig2 error ",worstSigErr
self.assertTrue(worstMuErr < tol)
self.assertTrue(worstSigErr < tol)
worstMuErr=-1.0
worstSigErr=-1.0
f=open("tests/data/gp_vector_selfinterpolate_solutions.sav","r")
ff=f.readlines()
f.close()
for i in range(len(ff)):
s=ff[i].split()
try:
gg.selfInterpolate(mu,sig,i,kk);
except pex.Exception as e:
print e.what()
for j in range(4):
mushld[j]=float(s[j])
sigshld=float(s[4])
for j in range(4):
muErr=(mu[j]-mushld[j])/mushld[j]
if muErr < -1.0:
muErr=-1.0 * muErr
if muErr>worstMuErr:
worstMuErr=muErr
sigErr=(sig[j]-sigshld)/sigshld
if sigErr<-1.0:
sigErr = -1.0*sigErr
if sigErr>worstSigErr:
worstSigErr=sigErr
print "\nThe errors for vector self interpolation\n"
print "worst mu error ",worstMuErr
print "worst sig2 error ",worstSigErr
self.assertTrue(worstMuErr < tol)
self.assertTrue(worstSigErr < tol)
queries=np.zeros((100,10), dtype = float)
batchMu=np.zeros((100,4), dtype = float)
batchSig=np.zeros((100,4), dtype = float)
batchMuShld=np.zeros((100,4), dtype = float)
batchSigShld=np.zeros((100,4), dtype = float)
batchData=np.zeros((200,10), dtype = float)
batchFunctions=np.zeros((200,4), dtype = float)
f=open("tests/data/gp_vectorbatch_data.sav","r")
ff=f.readlines()
f.close()
for i in range(len(ff)):
s=ff[i].split()
for j in range(10):
batchData[i][j]=float(s[j])
for j in range(4):
batchFunctions[i][j]=float(s[j+10])
try:
ggbatch=gp.GaussianProcessD(batchData,batchFunctions,nn)
except pex.Exception as e:
print e.what()
ggbatch.setLambda(0.0045)
f=open("tests/data/gp_vectorbatch_solutions.sav","r")
ff=f.readlines()
f.close()
for i in range(len(ff)):
s=ff[i].split()
for j in range(10):
queries[i][j]=float(s[j])
for j in range(4):
batchMuShld[i][j]=float(s[j+10])
sigShld=float(s[14])
for j in range(4):
batchSigShld[i][j]=sigShld
ggbatch.batchInterpolate(batchMu,batchSig,queries)
worstMuErr=-1.0
worstSigErr=-1.0
for i in range(100):
for j in range(4):
muErr=(batchMu[i][j]-batchMuShld[i][j])/batchMuShld[i][j]
sigErr=(batchSig[i][j]-batchSigShld[i][j])/batchSigShld[i][j]
if muErr < 0.0:
muErr = muErr * (-1.0)
if sigErr < 0.0:
sigErr = sigErr * (-1.0)
if muErr>worstMuErr:
worstMuErr=muErr
if sigErr>worstSigErr:
worstSigErr=sigErr
print "\nThe errors for vector batch interpolation with variance\n"
print "worst mu error ",worstMuErr
print "worst sig2 error ",worstSigErr
self.assertTrue(worstMuErr < tol)
self.assertTrue(worstSigErr < tol)
ggbatch.batchInterpolate(batchMu,queries)
worstMuErr=-1.0
worstSigErr=-1.0
for i in range(100):
for j in range(4):
muErr=(batchMu[i][j]-batchMuShld[i][j])/batchMuShld[i][j]
if muErr < 0.0:
muErr = muErr * (-1.0)
if muErr>worstMuErr:
worstMuErr=muErr
print "\nThe errors for vector batch interpolation without variance\n"
print "worst mu error ",worstMuErr
self.assertTrue(worstMuErr < tol)
f=open("tests/data/gp_vector_add_data.sav","r")
ff=f.readlines()
f.close()
for i in range(len(ff)):
s=ff[i].split()
for j in range(10):
vv[j]=float(s[j])
for j in range(4):
vvf[j]=float(s[j+10])
try:
gg.addPoint(vv,vvf)
except pex.Exception as e:
print e.what()
f=open("tests/data/gp_vector_add_solutions.sav","r")
ff=f.readlines()
f.close()
for i in range(len(ff)):
s=ff[i].split()
try:
gg.selfInterpolate(mu,sig,i,kk);
except pex.Exception as e:
print e.what()
for j in range(4):
mushld[j]=float(s[j])
sigshld=float(s[4])
for j in range(4):
muErr=(mu[j]-mushld[j])/mushld[j]
if muErr < 0.0:
muErr=-1.0 * muErr
if muErr>worstMuErr:
worstMuErr=muErr
sigErr=(sig[j]-sigshld)/sigshld
if sigErr<0.0:
sigErr = -1.0*sigErr
if sigErr>worstSigErr:
worstSigErr=sigErr
print "\nThe errors for vector add interpolation\n"
print "worst mu error ",worstMuErr
print "worst sig2 error ",worstSigErr
self.assertTrue(worstMuErr < tol)
self.assertTrue(worstSigErr < tol)
def testMinMax(self):
"""
This test will test GaussianProcess.interpolate using the constructor
that normalizes data point coordinates by minima and maxima.
It will only use the squared exponential covariogram (since testInterpolate() presumably
tested the performance of the neural network covariogram; this test is only concerned
with the alternate constructor)
This test proceeds largely like testInterpolate above
"""
pp = 2000
dd = 10
kk = 50
tol = 1.0e-4
data = np.zeros((pp,dd),dtype = float)
fn = np.zeros((pp),dtype = float)
test = np.zeros((dd),dtype = float)
sigma = np.zeros((1),dtype = float)
mins = np.zeros((dd),dtype = float)
maxs = np.zeros((dd),dtype = float)
nn=gp.NeuralNetCovariogramD()
nn.setSigma0(0.555)
nn.setSigma1(0.112)
f = open("tests/data/gp_exp_covar_data.sav")
ff = f.readlines()
f.close()
for i in range(len(ff)):
s = ff[i].split()
fn[i] = float(s[10])
for j in range(10):
data[i][j] = float(s[j])
for i in range(pp):
for j in range(dd):
if (i == 0) or (data[i][j] < mins[j]):
mins[j] = data[i][j]
if (i == 0) or (data[i][j] > maxs[j]):
maxs[j] = data[i][j]
mins[2] = 0.0
maxs[2] = 10.0
try:
gg = gp.GaussianProcessD(data,mins,maxs,fn,nn)
except pex.Exception as e:
print e.what()
gg.setLambda(0.0045)
f = open("tests/data/gp_minmax_solutions.sav")
ff = f.readlines()
f.close()
worstMuErr = -1.0
worstSigErr = -1.0
for z in range(len(ff)):
s = ff[z].split()
for i in range(dd):
test[i] = float(s[i])
mushld = float(s[dd + kk])
sigshld = float(s[dd + kk + 1])
mu = gg.interpolate(sigma,test,kk)
err = (mu - mushld)
if mushld != 0.0:
err = err/mushld
if err < 0.0:
err = -1.0 * err
if z == 0 or err > worstMuErr:
worstMuErr = err
err = (sigma[0] - sigshld)
if sigshld != 0.0:
err = err/sigshld
if err < 0.0:
err = -1.0 * err
if z == 0 or err > worstSigErr:
worstSigErr = err
print "\nThe errors for Gaussian process using min-max normalization\n"
print "worst mu error ",worstMuErr
print "worst sig2 error ",worstSigErr
self.assertTrue(worstMuErr < tol)
self.assertTrue(worstSigErr < tol)