def _testKernelMaxEI(self):
# test different methods of optimizing kernel
S5 = Shekel5()
hv = 0.1
testkernels = [GaussianKernel_iso([hv]),
GaussianKernel_ard([hv, hv, hv, hv]),
MaternKernel3([hv, 1.0])]
# MaternKernel5([hv, 1.0])]
for kernel in testkernels:
# print
# print kernel.__class__
# train GPs
X = lhcSample(S5.bounds, 10, seed=0)
Y = [S5.f(x) for x in X]
GP = GaussianProcess(kernel, X, Y)
eif = EI(GP)
dopt, doptx = direct(eif.negf, S5.bounds, maxiter=10)
copt, coptx = cdirect(eif.negf, S5.bounds, maxiter=10)
mopt, moptx = maximizeEI(GP, S5.bounds, maxiter=10)
# print dopt, doptx
# print copt, coptx
# print mopt, moptx
self.failUnlessAlmostEqual(dopt, copt, 4)
self.failUnlessAlmostEqual(-dopt, mopt, 4)
self.failUnlessAlmostEqual(-copt, mopt, 4)
self.failUnless(sum(abs(doptx-coptx)) < .01)
self.failUnless(sum(abs(moptx-coptx)) < .01)
self.failUnless(sum(abs(moptx-doptx)) < .01)
# train GP w/prior
pX = lhcSample(S5.bounds, 100, seed=101)
pY = [S5.f(x) for x in pX]
prior = RBFNMeanPrior()
prior.train(pX, pY, bounds=S5.bounds, k=10, seed=102)
GP = GaussianProcess(kernel, X, Y, prior=prior)
eif = EI(GP)
pdopt, pdoptx = direct(eif.negf, S5.bounds, maxiter=10)
pcopt, pcoptx = cdirect(eif.negf, S5.bounds, maxiter=10)
pmopt, pmoptx = maximizeEI(GP, S5.bounds, maxiter=10)
self.failIfAlmostEqual(pdopt, dopt, 3)
self.failUnlessAlmostEqual(pdopt, pcopt, 4)
self.failUnlessAlmostEqual(-pdopt, pmopt, 4)
self.failUnlessAlmostEqual(-pcopt, pmopt, 4)
self.failUnless(sum(abs(pdoptx-pcoptx)) < .01)
self.failUnless(sum(abs(pmoptx-pcoptx)) < .01)
self.failUnless(sum(abs(pmoptx-pdoptx)) < .01)
def testNoise(self):
tf = Branin()
X = lhcSample(tf.bounds, 10, seed=0)
Y = [tf.f(x) for x in X]
GP1 = GaussianProcess(MaternKernel3([1.0, 1.0]), X, Y, noise=1e-4)
self.failUnlessEqual(GP1.noise, 1e-4)
eif1 = EI(GP1)
dopt1, _ = direct(eif1.negf, tf.bounds, maxiter=10)
copt1, _ = cdirect(eif1.negf, tf.bounds, maxiter=10)
mopt1, _ = maximizeEI(GP1, tf.bounds, maxiter=10)
self.failUnlessAlmostEqual(dopt1, copt1, 4)
self.failUnlessAlmostEqual(-dopt1, mopt1, 4)
self.failUnlessAlmostEqual(-copt1, mopt1, 4)
GP2 = GaussianProcess(MaternKernel3([1.0, 1.0]), X, Y, noise=0.01)
self.failUnlessEqual(GP2.noise, 0.01)
eif2 = EI(GP2)
dopt2, _ = direct(eif2.negf, tf.bounds, maxiter=10)
copt2, _ = cdirect(eif2.negf, tf.bounds, maxiter=10)
mopt2, _ = maximizeEI(GP2, tf.bounds, maxiter=10)
self.failUnlessAlmostEqual(dopt2, copt2, 4)
self.failUnlessAlmostEqual(-dopt2, mopt2, 4)
self.failUnlessAlmostEqual(-copt2, mopt2, 4)
self.failIfAlmostEqual(dopt1, dopt2, 4)
self.failIfAlmostEqual(copt1, copt2, 4)
self.failIfAlmostEqual(mopt1, mopt2, 4)
GP3 = GaussianProcess(MaternKernel3([1.0, 1.0]), X, Y, noise=0.1)
self.failUnlessEqual(GP3.noise, 0.1)
eif3 = EI(GP3)
dopt3, _ = direct(eif3.negf, tf.bounds, maxiter=10)
copt3, _ = cdirect(eif3.negf, tf.bounds, maxiter=10)
mopt3, _ = maximizeEI(GP3, tf.bounds, maxiter=10)
self.failUnlessAlmostEqual(dopt3, copt3, 4)
self.failUnlessAlmostEqual(-dopt3, mopt3, 4)
self.failUnlessAlmostEqual(-copt3, mopt3, 4)
self.failIfAlmostEqual(dopt1, dopt3, 4)
self.failIfAlmostEqual(copt1, copt3, 4)
self.failIfAlmostEqual(mopt1, mopt3, 4)
self.failIfAlmostEqual(dopt2, dopt3, 4)
self.failIfAlmostEqual(copt2, copt3, 4)
self.failIfAlmostEqual(mopt2, mopt3, 4)
def testNoise(self):
tf = Branin()
X = lhcSample(tf.bounds, 10, seed=0)
Y = [tf.f(x) for x in X]
GP1 = GaussianProcess(MaternKernel3([1.0, 1.0]), X, Y, noise=1e-4)
self.failUnlessEqual(GP1.noise, 1e-4)
eif1 = EI(GP1)
dopt1, _ = direct(eif1.negf, tf.bounds, maxiter=10)
copt1, _ = cdirect(eif1.negf, tf.bounds, maxiter=10)
mopt1, _ = maximizeEI(GP1, tf.bounds, maxiter=10)
self.failUnlessAlmostEqual(dopt1, copt1, 4)
self.failUnlessAlmostEqual(-dopt1, mopt1, 4)
self.failUnlessAlmostEqual(-copt1, mopt1, 4)
GP2 = GaussianProcess(MaternKernel3([1.0, 1.0]), X, Y, noise=0.01)
self.failUnlessEqual(GP2.noise, 0.01)
eif2 = EI(GP2)
dopt2, _ = direct(eif2.negf, tf.bounds, maxiter=10)
copt2, _ = cdirect(eif2.negf, tf.bounds, maxiter=10)
mopt2, _ = maximizeEI(GP2, tf.bounds, maxiter=10)
self.failUnlessAlmostEqual(dopt2, copt2, 4)
self.failUnlessAlmostEqual(-dopt2, mopt2, 4)
self.failUnlessAlmostEqual(-copt2, mopt2, 4)
self.failIfAlmostEqual(dopt1, dopt2, 4)
self.failIfAlmostEqual(copt1, copt2, 4)
self.failIfAlmostEqual(mopt1, mopt2, 4)
GP3 = GaussianProcess(MaternKernel3([1.0, 1.0]), X, Y, noise=0.1)
self.failUnlessEqual(GP3.noise, 0.1)
eif3 = EI(GP3)
dopt3, _ = direct(eif3.negf, tf.bounds, maxiter=10)
copt3, _ = cdirect(eif3.negf, tf.bounds, maxiter=10)
mopt3, _ = maximizeEI(GP3, tf.bounds, maxiter=10)
self.failUnlessAlmostEqual(dopt3, copt3, 4)
self.failUnlessAlmostEqual(-dopt3, mopt3, 4)
self.failUnlessAlmostEqual(-copt3, mopt3, 4)
self.failIfAlmostEqual(dopt1, dopt3, 4)
self.failIfAlmostEqual(copt1, copt3, 4)
self.failIfAlmostEqual(mopt1, mopt3, 4)
self.failIfAlmostEqual(dopt2, dopt3, 4)
self.failIfAlmostEqual(copt2, copt3, 4)
self.failIfAlmostEqual(mopt2, mopt3, 4)
def testXi(self):
S5 = Shekel5()
GP1 = GaussianProcess(GaussianKernel_iso([.2]))
# self.failUnlessEqual(GP1.xi, 0.0)
X = lhcSample(S5.bounds, 10, seed=0)
Y = [S5.f(x) for x in X]
GP1.addData(X, Y)
eif1 = EI(GP1, xi=0.0)
dopt1, _ = direct(eif1.negf, S5.bounds, maxiter=10)
copt1, _ = cdirect(eif1.negf, S5.bounds, maxiter=10)
mopt1, _ = maximizeEI(GP1, S5.bounds, xi=0.0, maxiter=10)
self.failUnlessAlmostEqual(dopt1, copt1, 4)
self.failUnlessAlmostEqual(-dopt1, mopt1, 4)
self.failUnlessAlmostEqual(-copt1, mopt1, 4)
GP2 = GaussianProcess(GaussianKernel_iso([.3]), X, Y)
eif2 = EI(GP2, xi=0.01)
self.failUnlessEqual(eif2.xi, 0.01)
dopt2, _ = direct(eif2.negf, S5.bounds, maxiter=10)
copt2, _ = cdirect(eif2.negf, S5.bounds, maxiter=10)
mopt2, _ = maximizeEI(GP2, S5.bounds, xi=0.01, maxiter=10)
self.failUnlessAlmostEqual(dopt2, copt2, 4)
self.failUnlessAlmostEqual(-dopt2, mopt2, 4)
self.failUnlessAlmostEqual(-copt2, mopt2, 4)
self.failIfAlmostEqual(dopt1, dopt2, 4)
self.failIfAlmostEqual(copt1, copt2, 4)
self.failIfAlmostEqual(mopt1, mopt2, 4)
GP3 = GaussianProcess(GaussianKernel_iso([.3]), X, Y)
eif3 = EI(GP3, xi=0.1)
dopt3, _ = direct(eif3.negf, S5.bounds, maxiter=10)
copt3, _ = cdirect(eif3.negf, S5.bounds, maxiter=10)
mopt3, _ = maximizeEI(GP3, S5.bounds, xi=0.1, maxiter=10)
self.failUnlessAlmostEqual(dopt3, copt3, 4)
self.failUnlessAlmostEqual(-dopt3, mopt3, 4)
self.failUnlessAlmostEqual(-copt3, mopt3, 4)
self.failIfAlmostEqual(dopt1, dopt3, 4)
self.failIfAlmostEqual(copt1, copt3, 4)
self.failIfAlmostEqual(mopt1, mopt3, 4)
self.failIfAlmostEqual(dopt2, dopt3, 4)
self.failIfAlmostEqual(copt2, copt3, 4)
self.failIfAlmostEqual(mopt2, mopt3, 4)
def testXi(self):
S5 = Shekel5()
GP1 = GaussianProcess(GaussianKernel_iso([.2]))
# self.failUnlessEqual(GP1.xi, 0.0)
X = lhcSample(S5.bounds, 10, seed=0)
Y = [S5.f(x) for x in X]
GP1.addData(X, Y)
eif1 = EI(GP1, xi=0.0)
dopt1, _ = direct(eif1.negf, S5.bounds, maxiter=10)
copt1, _ = cdirect(eif1.negf, S5.bounds, maxiter=10)
mopt1, _ = maximizeEI(GP1, S5.bounds, xi=0.0, maxiter=10)
self.failUnlessAlmostEqual(dopt1, copt1, 4)
self.failUnlessAlmostEqual(-dopt1, mopt1, 4)
self.failUnlessAlmostEqual(-copt1, mopt1, 4)
GP2 = GaussianProcess(GaussianKernel_iso([.3]), X, Y)
eif2 = EI(GP2, xi=0.01)
self.failUnlessEqual(eif2.xi, 0.01)
dopt2, _ = direct(eif2.negf, S5.bounds, maxiter=10)
copt2, _ = cdirect(eif2.negf, S5.bounds, maxiter=10)
mopt2, _ = maximizeEI(GP2, S5.bounds, xi=0.01, maxiter=10)
self.failUnlessAlmostEqual(dopt2, copt2, 4)
self.failUnlessAlmostEqual(-dopt2, mopt2, 4)
self.failUnlessAlmostEqual(-copt2, mopt2, 4)
self.failIfAlmostEqual(dopt1, dopt2, 4)
self.failIfAlmostEqual(copt1, copt2, 4)
self.failIfAlmostEqual(mopt1, mopt2, 4)
GP3 = GaussianProcess(GaussianKernel_iso([.3]), X, Y)
eif3 = EI(GP3, xi=0.1)
dopt3, _ = direct(eif3.negf, S5.bounds, maxiter=10)
copt3, _ = cdirect(eif3.negf, S5.bounds, maxiter=10)
mopt3, _ = maximizeEI(GP3, S5.bounds, xi=0.1, maxiter=10)
self.failUnlessAlmostEqual(dopt3, copt3, 4)
self.failUnlessAlmostEqual(-dopt3, mopt3, 4)
self.failUnlessAlmostEqual(-copt3, mopt3, 4)
self.failIfAlmostEqual(dopt1, dopt3, 4)
self.failIfAlmostEqual(copt1, copt3, 4)
self.failIfAlmostEqual(mopt1, mopt3, 4)
self.failIfAlmostEqual(dopt2, dopt3, 4)
self.failIfAlmostEqual(copt2, copt3, 4)
self.failIfAlmostEqual(mopt2, mopt3, 4)
def _testMinimization(self):
for TestFunction in TestFunctions:
tf = TestFunction(maximize=False)
opt, _ = cdirect(tf.f, tf.bounds, maxiter=50)
print '[%s] found minimum %f. declared minimum was %f.' % (tf.name, opt, tf.minimum)
self.failUnlessAlmostEqual(opt, tf.minimum, 2)
def testXi(self):
S5 = Shekel5()
GP1 = GaussianProcess(GaussianKernel_iso([.2]))
# self.failUnlessEqual(GP1.xi, 0.0)
X = lhcSample(S5.bounds, 10, seed=0)
Y = [S5.f(x) for x in X]
GP1.addData(X, Y)
ucbf1 = UCB(GP1, len(S5.bounds), scale=0.5)
dopt1, _ = direct(ucbf1.negf, S5.bounds, maxiter=10)
copt1, _ = cdirect(ucbf1.negf, S5.bounds, maxiter=10)
mopt1, _ = maximizeUCB(GP1, S5.bounds, scale=0.5, maxiter=10)
self.failUnlessAlmostEqual(dopt1, copt1, 4)
self.failUnlessAlmostEqual(-dopt1, mopt1, 4)
self.failUnlessAlmostEqual(-copt1, mopt1, 4)
GP2 = GaussianProcess(GaussianKernel_iso([.3]), X, Y)
ucbf2 = UCB(GP2, len(S5.bounds), scale=0.01)
dopt2, _ = direct(ucbf2.negf, S5.bounds, maxiter=10)
copt2, _ = cdirect(ucbf2.negf, S5.bounds, maxiter=10)
mopt2, _ = maximizeUCB(GP2, S5.bounds, scale=.01, maxiter=10)
self.failUnlessAlmostEqual(dopt2, copt2, 4)
self.failUnlessAlmostEqual(-dopt2, mopt2, 4)
self.failUnlessAlmostEqual(-copt2, mopt2, 4)
self.failIfAlmostEqual(dopt1, dopt2, 4)
self.failIfAlmostEqual(copt1, copt2, 4)
self.failIfAlmostEqual(mopt1, mopt2, 4)
GP3 = GaussianProcess(GaussianKernel_iso([.3]), X, Y)
ucbf3 = UCB(GP3, len(S5.bounds), scale=.9)
dopt3, _ = direct(ucbf3.negf, S5.bounds, maxiter=10)
copt3, _ = cdirect(ucbf3.negf, S5.bounds, maxiter=10)
mopt3, _ = maximizeUCB(GP3, S5.bounds, scale=0.9, maxiter=10)
self.failUnlessAlmostEqual(dopt3, copt3, 4)
self.failUnlessAlmostEqual(-dopt3, mopt3, 4)
self.failUnlessAlmostEqual(-copt3, mopt3, 4)
self.failIfAlmostEqual(dopt1, dopt3, 4)
self.failIfAlmostEqual(copt1, copt3, 4)
self.failIfAlmostEqual(mopt1, mopt3, 4)
self.failIfAlmostEqual(dopt2, dopt3, 4)
self.failIfAlmostEqual(copt2, copt3, 4)
self.failIfAlmostEqual(mopt2, mopt3, 4)
def testXi(self):
S5 = Shekel5()
GP1 = GaussianProcess(GaussianKernel_iso([.2]))
# self.failUnlessEqual(GP1.xi, 0.0)
X = lhcSample(S5.bounds, 10, seed=0)
Y = [S5.f(x) for x in X]
GP1.addData(X, Y)
ucbf1 = UCB(GP1, len(S5.bounds), scale=0.5)
dopt1, _ = direct(ucbf1.negf, S5.bounds, maxiter=10)
copt1, _ = cdirect(ucbf1.negf, S5.bounds, maxiter=10)
mopt1, _ = maximizeUCB(GP1, S5.bounds, scale=0.5, maxiter=10)
self.failUnlessAlmostEqual(dopt1, copt1, 4)
self.failUnlessAlmostEqual(-dopt1, mopt1, 4)
self.failUnlessAlmostEqual(-copt1, mopt1, 4)
GP2 = GaussianProcess(GaussianKernel_iso([.3]), X, Y)
ucbf2 = UCB(GP2, len(S5.bounds), scale=0.01)
dopt2, _ = direct(ucbf2.negf, S5.bounds, maxiter=10)
copt2, _ = cdirect(ucbf2.negf, S5.bounds, maxiter=10)
mopt2, _ = maximizeUCB(GP2, S5.bounds, scale=.01, maxiter=10)
self.failUnlessAlmostEqual(dopt2, copt2, 4)
self.failUnlessAlmostEqual(-dopt2, mopt2, 4)
self.failUnlessAlmostEqual(-copt2, mopt2, 4)
self.failIfAlmostEqual(dopt1, dopt2, 4)
self.failIfAlmostEqual(copt1, copt2, 4)
self.failIfAlmostEqual(mopt1, mopt2, 4)
GP3 = GaussianProcess(GaussianKernel_iso([.3]), X, Y)
ucbf3 = UCB(GP3, len(S5.bounds), scale=.9)
dopt3, _ = direct(ucbf3.negf, S5.bounds, maxiter=10)
copt3, _ = cdirect(ucbf3.negf, S5.bounds, maxiter=10)
mopt3, _ = maximizeUCB(GP3, S5.bounds, scale=0.9, maxiter=10)
self.failUnlessAlmostEqual(dopt3, copt3, 4)
self.failUnlessAlmostEqual(-dopt3, mopt3, 4)
self.failUnlessAlmostEqual(-copt3, mopt3, 4)
self.failIfAlmostEqual(dopt1, dopt3, 4)
self.failIfAlmostEqual(copt1, copt3, 4)
self.failIfAlmostEqual(mopt1, mopt3, 4)
self.failIfAlmostEqual(dopt2, dopt3, 4)
self.failIfAlmostEqual(copt2, copt3, 4)
self.failIfAlmostEqual(mopt2, mopt3, 4)
def testShekel(self):
S = Shekel5(maximize=False)
opt, optx = cdirect(S.f, S.bounds, maxiter=20)
self.assertAlmostEqual(opt, S.minimum, 3)
for x, a in zip(optx, S.argmin):
self.assertAlmostEqual(x, a, 3)
def testShekel(self):
S = Shekel5(maximize=False)
opt, optx = cdirect(S.f, S.bounds, maxiter=20)
self.assertAlmostEqual(opt, S.minimum, 3)
for x, a in zip(optx, S.argmin):
self.assertAlmostEqual(x, a, 3)
def testArgs(self):
# test passing args into DIRECT
def foo(x, a1, a2):
return -sum(sin(array(x)*a1)+array(x)*a2)
bounds = [[0., 5.]] * 3
args1 = [3.0, 0.0]
opt, optx = cdirect(foo, bounds, args=args1, maxiter=10)
# print 'args = %s, opt=%s, optx=%s' % (args1, opt, optx)
self.assertAlmostEqual(opt, -3.00, 2)
self.assertAlmostEqual(optx[0], 2.618, 2)
args2 = [-2.0, 2.0]
opt, optx = cdirect(foo, bounds, args=args2, maxiter=10)
# print 'args = %s, opt=%s, optx=%s' % (args2, opt, optx)
self.assert_(abs(-opt-31) < 1.)
self.assert_(abs(optx[0]-5) < .5)
def testArgs(self):
# test passing args into DIRECT
def foo(x, a1, a2):
return -sum(sin(array(x) * a1) + array(x) * a2)
bounds = [[0., 5.]] * 3
args1 = [3.0, 0.0]
opt, optx = cdirect(foo, bounds, args=args1, maxiter=10)
# print 'args = %s, opt=%s, optx=%s' % (args1, opt, optx)
self.assertAlmostEqual(opt, -3.00, 2)
self.assertAlmostEqual(optx[0], 2.618, 2)
args2 = [-2.0, 2.0]
opt, optx = cdirect(foo, bounds, args=args2, maxiter=10)
# print 'args = %s, opt=%s, optx=%s' % (args2, opt, optx)
self.assert_(abs(-opt - 31) < 1.)
self.assert_(abs(optx[0] - 5) < .5)
def Gdelta(GP, testfunc, firstY, delta=0.01, maxiter=10, **kwargs):
"""
given a GP, find the max and argmax of G_delta, the confidence-bounded
prediction of the max of the response surface
"""
assert testfunc.maximize
mb = MuBound(GP, delta)
_, optx = cdirect(mb.objective, testfunc.bounds, maxiter=maxiter, **kwargs)
opt = max(testfunc.f(optx), firstY)
return (opt-firstY) / (-testfunc.minimum-firstY)
def Gdelta(GP, testfunc, firstY, delta=0.01, maxiter=10, **kwargs):
"""
given a GP, find the max and argmax of G_delta, the confidence-bounded
prediction of the max of the response surface
"""
assert testfunc.maximize
mb = MuBound(GP, delta)
_, optx = cdirect(mb.objective, testfunc.bounds, maxiter=maxiter, **kwargs)
opt = max(testfunc.f(optx), firstY)
return (opt - firstY) / (-testfunc.minimum - firstY)
def testMaxEIPrior(self):
# make sure that the prior works with the different methods of EI
# maximization
S5 = Shekel5()
pX = lhcSample(S5.bounds, 100, seed=511)
pY = [S5.f(x) for x in pX]
prior = RBFNMeanPrior()
prior.train(pX, pY, bounds=S5.bounds, k=10, seed=504)
hv = .1
hyper = [hv, hv, hv, hv]
kernel = GaussianKernel_ard(hyper)
# train GPs
X = lhcSample(S5.bounds, 10, seed=512)
Y = [S5.f(x) for x in X]
# validation
valX = list(x.copy() for x in X)
valY = copy(Y)
GP = GaussianProcess(kernel, X, Y, prior=prior)
eif = EI(GP)
copt, _ = cdirect(eif.negf, S5.bounds, maxiter=20)
mopt, _ = maximizeEI(GP, S5.bounds, maxiter=20)
self.failUnlessAlmostEqual(-copt, mopt, 2)
for i in xrange(len(GP.X)):
self.failUnless(all(valX[i]==GP.X[i]))
self.failUnless(valY[i]==GP.Y[i])
GP.prior.mu(GP.X[0])
self.failUnless(all(valX[0]==GP.X[0]))
# print GP.X
for i in xrange(len(GP.X)):
self.failUnless(all(valX[i]==GP.X[i]))
self.failUnless(valY[i]==GP.Y[i])
GP.prior.mu(GP.X[0])
self.failUnless(all(valX[0]==GP.X[0]))
def test1DcUCB(self):
f = lambda x: float(sin(x * 5.))
X = lhcSample([[0., 1.]], 5, seed=22)
Y = [f(x) for x in X]
kernel = GaussianKernel_ard(array([1.0]))
GP = GaussianProcess(kernel)
GP.addData(X, Y)
# should use optimizeGP.cpp
ucbf = UCB(GP, 1)
dopt, doptx = direct(ucbf.negf, [[0., 1.]], maxiter=10)
copt, coptx = cdirect(ucbf.negf, [[0., 1.]], maxiter=10)
mopt, moptx = maximizeUCB(GP, [[0., 1.]], maxiter=10)
self.failUnlessAlmostEqual(dopt, copt, 4)
self.failUnlessAlmostEqual(-dopt, mopt, 4)
self.failUnlessAlmostEqual(-copt, mopt, 4)
self.failUnless(sum(abs(doptx - coptx)) < .01)
self.failUnless(sum(abs(moptx - coptx)) < .01)
self.failUnless(sum(abs(moptx - doptx)) < .01)
def test1DcUCB(self):
f = lambda x: float(sin(x*5.))
X = lhcSample([[0., 1.]], 5, seed=22)
Y = [f(x) for x in X]
kernel = GaussianKernel_ard(array([1.0]))
GP = GaussianProcess(kernel)
GP.addData(X, Y)
# should use optimizeGP.cpp
ucbf = UCB(GP, 1)
dopt, doptx = direct(ucbf.negf, [[0., 1.]], maxiter=10)
copt, coptx = cdirect(ucbf.negf, [[0., 1.]], maxiter=10)
mopt, moptx = maximizeUCB(GP, [[0., 1.]], maxiter=10)
self.failUnlessAlmostEqual(dopt, copt, 4)
self.failUnlessAlmostEqual(-dopt, mopt, 4)
self.failUnlessAlmostEqual(-copt, mopt, 4)
self.failUnless(sum(abs(doptx-coptx)) < .01)
self.failUnless(sum(abs(moptx-coptx)) < .01)
self.failUnless(sum(abs(moptx-doptx)) < .01)
def cdirectGP(model,
bounds,
maxiter,
maxtime,
maxsample,
acqfunc=None,
xi=-1,
beta=-1,
scale=-1,
delta=-1,
**kwargs):
try:
if acqfunc == 'ei':
acquisition = 0
parm = xi
elif acqfunc == 'pi':
acquisition = 1
parm = xi
elif acqfunc == 'ucb':
acquisition = 2
t = len(model.Y) + 1
NA = len(bounds)
parm = sqrt(scale * 2.0 * log(t**(NA / 2 + 2) * pi**2 /
(3.0 * delta)))
else:
raise NotImplementedError('unknown acquisition function %s' %
acqfunc)
if isinstance(model.kernel, GaussianKernel_ard):
kerneltype = 0
elif isinstance(model.kernel, GaussianKernel_iso):
kerneltype = 1
elif isinstance(model.kernel, MaternKernel3):
kerneltype = 2
elif isinstance(model.kernel, MaternKernel5):
print('Matern 5')
kerneltype = 3
else:
raise NotImplementedError('kernel not implemented in C++: %s' %
model.kernel.__class__)
lpath = ctypes.util.find_library('ego')
while lpath is None:
for lp in [
'cpp/libs/libego.dylib',
'/Users/eric/Dropbox/EGOcode/ego/libs/libego.so'
]:
if os.path.exists(lp):
lpath = lp
if lpath is None:
print(
'\n[python] could not find ego library! Did you forget to export DYLD_LIBRARY_PATH?'
)
lib = cdll[lpath]
lib.acqmaxGP.restype = POINTER(c_double)
lib.acqmaxGP.argtypes = [
c_int,
POINTER(c_double),
POINTER(c_double),
POINTER(c_double),
POINTER(c_double),
POINTER(c_double), c_int, c_int, c_int,
POINTER(c_double), c_int,
POINTER(c_double),
POINTER(c_double), c_double,
POINTER(c_double),
POINTER(c_double), c_double, c_double, c_int, c_int, c_int
]
NX = len(model.Y)
NA = len(bounds)
npbases = 0 if model.prior is None else len(model.prior.means)
pbtheta = 0 if model.prior is None else model.prior.theta
if model.prior is None:
c_pmeans = array([0], dtype=c_double)
c_pbeta = array([0], dtype=c_double)
c_pblowerb = array([0], dtype=c_double)
c_pbwidth = array([0], dtype=c_double)
else:
c_pmeans = array(array(model.prior.means).reshape(-1),
dtype=c_double)
c_pbeta = array(model.prior.beta, dtype=c_double)
c_pblowerb = array(model.prior.lowerb, dtype=c_double)
c_pbwidth = array(model.prior.width, dtype=c_double)
c_lower = array([b[0] for b in bounds], dtype=c_double)
c_upper = array([b[1] for b in bounds], dtype=c_double)
c_hyper = array(model.kernel.hyperparams, dtype=c_double)
# TODO: use cholesky on the C++ side
if isinstance(model, PrefGaussianProcess) and model.C is not None:
c_invR = array(linalg.inv(model.R +
linalg.inv(model.C)).reshape(-1),
dtype=c_double)
else:
c_invR = array(linalg.inv(model.R).reshape(-1), dtype=c_double)
c_X = array(array(model.X).reshape(-1), dtype=c_double)
c_Y = array(model.Y, dtype=c_double)
# print c_int(NA)
# print c_lower.ctypes.data_as(POINTER(c_double))
# print c_upper.ctypes.data_as(POINTER(c_double))
# print c_invR.ctypes.data_as(POINTER(c_double))
# print c_X.ctypes.data_as(POINTER(c_double))
# print c_Y.ctypes.data_as(POINTER(c_double))
# print c_int(NX)
# print c_int(acqfunc)
# print c_int(kerneltype)
# print c_hyper.ctypes.data_as(POINTER(c_double))
# print c_int(npbases)
# print c_pmeans.ctypes.data_as(POINTER(c_double))
# print c_pbeta.ctypes.data_as(POINTER(c_double))
# print c_double(pbtheta)
# print c_pblowerb.ctypes.data_as(POINTER(c_double))
# print c_pbwidth.ctypes.data_as(POINTER(c_double))
# print c_double(xi)
# print c_double(model.noise)
# print c_int(maxiter)
# print c_int(maxtime)
# print c_int(maxsample)
# print '[python] calling C++ %s (%d) with X.shape = %s' % (acqfunc, acquisition, model.X.shape)
result = lib.acqmaxGP(c_int(NA),
c_lower.ctypes.data_as(POINTER(c_double)),
c_upper.ctypes.data_as(POINTER(c_double)),
c_invR.ctypes.data_as(POINTER(c_double)),
c_X.ctypes.data_as(POINTER(c_double)),
c_Y.ctypes.data_as(POINTER(c_double)), c_int(NX),
c_int(acquisition), c_int(kerneltype),
c_hyper.ctypes.data_as(POINTER(c_double)),
c_int(npbases),
c_pmeans.ctypes.data_as(POINTER(c_double)),
c_pbeta.ctypes.data_as(POINTER(c_double)),
c_double(pbtheta),
c_pblowerb.ctypes.data_as(POINTER(c_double)),
c_pbwidth.ctypes.data_as(POINTER(c_double)),
c_double(parm), c_double(model.noise),
c_int(maxiter), c_int(maxtime), c_int(maxsample))
# print '[python] result =', result.__class__
# print '[python] result =', result[0]
opt = -result[0]
optx = array([x for x in result[1:NA + 1]])
# free the pointer
libc = CDLL(ctypes.util.find_library('libc'))
libc.free.argtypes = [c_void_p]
libc.free.restype = None
libc.free(result)
except:
try:
print(
'[python] C++ MaxEI implementation unavailable, attempting C++ DIRECT on Python objective function.'
)
opt, optx = cdirect(ei.negf,
bounds,
maxiter=maxiter,
maxtime=maxtime,
maxsample=maxsample,
**kwargs)
except:
# couldn't access cDIRECT, use Python DIRECT
print('[python] C++ DIRECT unavailable, attempting Python DIRECT')
opt, optx = direct(ei.negf,
bounds,
maxiter=maxiter,
maxtime=maxtime,
maxsample=maxsample,
**kwargs)
opt = -opt
if False:
# do a few random searches to see if we can get a better result.
# mostly necessary for 1D or 2D optimizations which terminate too
# soon.
ei = EI(model)
for s in lhcSample(bounds, 500):
if -ei.negf(s) > opt:
opt = -ei.negf(s)
optx = s
return opt, optx
def cdirectGP(model, bounds, maxiter, maxtime, maxsample, acqfunc=None, xi=-1, beta=-1, scale=-1, delta=-1, **kwargs):
try:
if acqfunc == "ei":
acquisition = 0
parm = xi
elif acqfunc == "pi":
acquisition = 1
parm = xi
elif acqfunc == "ucb":
acquisition = 2
t = len(model.Y) + 1
NA = len(bounds)
parm = sqrt(scale * 2.0 * log(t ** (NA / 2 + 2) * pi ** 2 / (3.0 * delta)))
else:
raise NotImplementedError("unknown acquisition function %s" % acqfunc)
if isinstance(model.kernel, GaussianKernel_ard):
kerneltype = 0
elif isinstance(model.kernel, GaussianKernel_iso):
kerneltype = 1
elif isinstance(model.kernel, MaternKernel3):
kerneltype = 2
elif isinstance(model.kernel, MaternKernel5):
print "Matern 5"
kerneltype = 3
else:
raise NotImplementedError("kernel not implemented in C++: %s" % model.kernel.__class__)
lpath = ctypes.util.find_library("ego")
if lpath is None:
import ASAW_config
lpath = ASAW_config.get_ego_lib_dir() + "libego.so"
# print '\n[python] could not find ego library! Did you forget to export DYLD_LIBRARY_PATH?'
lib = cdll[lpath]
lib.acqmaxGP.restype = POINTER(c_double)
lib.acqmaxGP.argtypes = [
c_int,
POINTER(c_double),
POINTER(c_double),
POINTER(c_double),
POINTER(c_double),
POINTER(c_double),
c_int,
c_int,
c_int,
POINTER(c_double),
c_int,
POINTER(c_double),
POINTER(c_double),
c_double,
POINTER(c_double),
POINTER(c_double),
c_double,
c_double,
c_int,
c_int,
c_int,
]
NX = len(model.Y)
NA = len(bounds)
npbases = 0 if model.prior is None else len(model.prior.means)
pbtheta = 0 if model.prior is None else model.prior.theta
if model.prior is None:
c_pmeans = array([0], dtype=c_double)
c_pbeta = array([0], dtype=c_double)
c_pblowerb = array([0], dtype=c_double)
c_pbwidth = array([0], dtype=c_double)
else:
c_pmeans = array(array(model.prior.means).reshape(-1), dtype=c_double)
c_pbeta = array(model.prior.beta, dtype=c_double)
c_pblowerb = array(model.prior.lowerb, dtype=c_double)
c_pbwidth = array(model.prior.width, dtype=c_double)
c_lower = array([b[0] for b in bounds], dtype=c_double)
c_upper = array([b[1] for b in bounds], dtype=c_double)
c_hyper = array(model.kernel.hyperparams, dtype=c_double)
# TODO: use cholesky on the C++ side
if isinstance(model, PrefGaussianProcess) and model.C is not None:
c_invR = array(linalg.inv(model.R + linalg.inv(model.C)).reshape(-1), dtype=c_double)
else:
c_invR = array(linalg.inv(model.R).reshape(-1), dtype=c_double)
c_X = array(array(model.X).reshape(-1), dtype=c_double)
c_Y = array(model.Y, dtype=c_double)
# print c_int(NA)
# print c_lower.ctypes.data_as(POINTER(c_double))
# print c_upper.ctypes.data_as(POINTER(c_double))
# print c_invR.ctypes.data_as(POINTER(c_double))
# print c_X.ctypes.data_as(POINTER(c_double))
# print c_Y.ctypes.data_as(POINTER(c_double))
# print c_int(NX)
# print c_int(acqfunc)
# print c_int(kerneltype)
# print c_hyper.ctypes.data_as(POINTER(c_double))
# print c_int(npbases)
# print c_pmeans.ctypes.data_as(POINTER(c_double))
# print c_pbeta.ctypes.data_as(POINTER(c_double))
# print c_double(pbtheta)
# print c_pblowerb.ctypes.data_as(POINTER(c_double))
# print c_pbwidth.ctypes.data_as(POINTER(c_double))
# print c_double(xi)
# print c_double(model.noise)
# print c_int(maxiter)
# print c_int(maxtime)
# print c_int(maxsample)
# print '[python] calling C++ %s (%d) with X.shape = %s' % (acqfunc, acquisition, model.X.shape)
result = lib.acqmaxGP(
c_int(NA),
c_lower.ctypes.data_as(POINTER(c_double)),
c_upper.ctypes.data_as(POINTER(c_double)),
c_invR.ctypes.data_as(POINTER(c_double)),
c_X.ctypes.data_as(POINTER(c_double)),
c_Y.ctypes.data_as(POINTER(c_double)),
c_int(NX),
c_int(acquisition),
c_int(kerneltype),
c_hyper.ctypes.data_as(POINTER(c_double)),
c_int(npbases),
c_pmeans.ctypes.data_as(POINTER(c_double)),
c_pbeta.ctypes.data_as(POINTER(c_double)),
c_double(pbtheta),
c_pblowerb.ctypes.data_as(POINTER(c_double)),
c_pbwidth.ctypes.data_as(POINTER(c_double)),
c_double(parm),
c_double(model.noise),
c_int(maxiter),
c_int(maxtime),
c_int(maxsample),
)
# print '[python] result =', result.__class__
# print '[python] result =', result[0]
opt = -result[0]
optx = array([x for x in result[1 : NA + 1]])
# free the pointer
libc = CDLL(ctypes.util.find_library("libc"))
libc.free.argtypes = [c_void_p]
libc.free.restype = None
libc.free(result)
except:
try:
print "[python] C++ MaxEI implementation unavailable, attempting C++ DIRECT on Python objective function."
opt, optx = cdirect(ei.negf, bounds, maxiter=maxiter, maxtime=maxtime, maxsample=maxsample, **kwargs)
except:
# couldn't access cDIRECT, use Python DIRECT
print "[python] C++ DIRECT unavailable, attempting Python DIRECT"
opt, optx = direct(ei.negf, bounds, maxiter=maxiter, maxtime=maxtime, maxsample=maxsample, **kwargs)
opt = -opt
if False:
# do a few random searches to see if we can get a better result.
# mostly necessary for 1D or 2D optimizations which terminate too
# soon.
ei = EI(model)
for s in lhcSample(bounds, 500):
if -ei.negf(s) > opt:
opt = -ei.negf(s)
optx = s
return opt, optx
