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 testShekel(self):
S = Shekel5(maximize=False)
opt, optx = direct(S.f, S.bounds, maxiter=20, debug=False)
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 = direct(S.f, S.bounds, maxiter=20, debug=False)
self.assertAlmostEqual(opt, S.minimum, 3)
for x, a in zip(optx, S.argmin):
self.assertAlmostEqual(x, a, 3)
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 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 = direct(foo, bounds, args=args1, maxiter=20)
# print 'args = %s, opt=%s, optx=%s' % (args1, opt, optx)
self.assertAlmostEqual(opt, -3.0, 1)
self.assertAlmostEqual(optx[0], 2.6234, 1)
args2 = [-2.0, 2.0]
opt, optx = direct(foo, bounds, args=args2, maxiter=10)
# print 'args = %s, opt=%s, optx=%s' % (args2, opt, optx)
# self.failUnlessAlmostEqual(opt, -31.0540, 4)
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 = direct(foo, bounds, args=args1, maxiter=20)
# print 'args = %s, opt=%s, optx=%s' % (args1, opt, optx)
self.assertAlmostEqual(opt, -3.0, 1)
self.assertAlmostEqual(optx[0], 2.6234, 1)
args2 = [-2.0, 2.0]
opt, optx = direct(foo, bounds, args=args2, maxiter=10)
# print 'args = %s, opt=%s, optx=%s' % (args2, opt, optx)
# self.failUnlessAlmostEqual(opt, -31.0540, 4)
self.assert_(abs(optx[0]-5) < .5)
def maximizeEI(model,
bounds,
useCDIRECT=True,
xi=0.01,
maxiter=50,
maxtime=30,
maxsample=10000,
**kwargs):
"""
Try to maximize EI in the most efficient way possible. The methods
will be attempted in this order:
1. If there is a C implementation of the EI objective for the
kernel, it will be used (currently only works for Gaussian
kernel with ARD).
2. If the C implementation of DIRECT is available, it will be used.
3. Otherwise, the Python implementation of DIRECT will be used.
"""
if not useCDIRECT:
print('using DIRECT')
ei = EI(model, xi, **kwargs)
opt, optx = direct(ei.negf,
bounds,
maxiter=maxiter,
maxtime=maxtime,
maxsample=maxsample,
**kwargs)
return -opt, optx
if isinstance(model, GaussianProcess):
return cdirectGP(model,
bounds,
maxiter,
maxtime,
maxsample,
acqfunc='ei',
xi=xi,
**kwargs)
elif isinstance(model, RandomForest):
return cdirectRF(model,
bounds,
maxiter,
maxtime,
maxsample,
acqfunc='ei',
xi=xi,
**kwargs)
def maximizeMean(model, bounds, maxiter=50, maxtime=30, maxsample=10000):
"""
Maximize the GP-mean using DIRECT
Python DIRECT is used.
"""
print "Using Python DIRECT."
def gp_mean_obj(x, gp=model):
mu, sig2 = gp.posterior(x)
return -mu
opt, optx = direct(
gp_mean_obj, bounds, args=None, debug=False, maxiter=maxiter, maxtime=maxtime, maxsample=maxsample
)
return optx, opt
def maximizePI(model, bounds, xi=0.01, maxiter=50, maxtime=30, maxsample=10000, useCDIRECT=True, **kwargs):
"""
Maximize the probability of improvement, as described in [Lizotte 2008].
"""
if not useCDIRECT:
print "using DIRECT"
pi = PI(model, xi, **kwargs)
opt, optx = direct(pi.negf, bounds, maxiter=maxiter, maxtime=maxtime, maxsample=maxsample, **kwargs)
return -opt, optx
if isinstance(model, GaussianProcess):
return cdirectGP(model, bounds, maxiter, maxtime, maxsample, acqfunc="pi", xi=xi, **kwargs)
elif isinstance(model, RandomForest):
return cdirectRF(model, bounds, maxiter, maxtime, maxsample, acqfunc="pi", xi=xi, **kwargs)
else:
raise ValueError
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)
X = lhcSample(S5.bounds, 10, seed=512)
Y = [S5.f(x) for x in X]
GP = GaussianProcess(kernel, X, Y, prior=prior)
# validation
valX = list(x.copy() for x in X)
valY = copy(Y)
eif = EI(GP)
dopt, _ = direct(eif.negf, S5.bounds, maxiter=20)
copt, _ = cdirect(eif.negf, S5.bounds, maxiter=20)
mopt, _ = maximizeEI(GP, S5.bounds, maxiter=20)
self.failUnlessAlmostEqual(dopt, copt, 2)
self.failUnlessAlmostEqual(-dopt, 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 maximizePI(model,
bounds,
xi=0.01,
maxiter=50,
maxtime=30,
maxsample=10000,
useCDIRECT=True,
**kwargs):
"""
Maximize the probability of improvement, as described in [Lizotte 2008].
"""
if not useCDIRECT:
print('using DIRECT')
pi = PI(model, xi, **kwargs)
opt, optx = direct(pi.negf,
bounds,
maxiter=maxiter,
maxtime=maxtime,
maxsample=maxsample,
**kwargs)
return -opt, optx
if isinstance(model, GaussianProcess):
return cdirectGP(model,
bounds,
maxiter,
maxtime,
maxsample,
acqfunc='pi',
xi=xi,
**kwargs)
elif isinstance(model, RandomForest):
return cdirectRF(model,
bounds,
maxiter,
maxtime,
maxsample,
acqfunc='pi',
xi=xi,
**kwargs)
else:
raise ValueError
def maximizeUCB(model, bounds, delta=0.1, scale=0.2, useCDIRECT=True, maxiter=50, maxtime=30, maxsample=10000, **kwargs):
"""
Maximize the upper confidence bound (UCB), as described in
[Srinivas 2009a].
"""
if not useCDIRECT:
print 'using DIRECT'
ucb = UCB(model, len(bounds), delta=delta, scale=scale, **kwargs)
opt, optx = direct(ucb.negf, bounds, **kwargs)
return -opt, optx
if isinstance(model, GaussianProcess):
return cdirectGP(model, bounds, maxiter, maxtime, maxsample, acqfunc='ucb', delta=delta, scale=scale, **kwargs)
elif isinstance(model, RandomForest):
return cdirectRF(model, bounds, maxiter, maxtime, maxsample, acqfunc='ucb', delta=delta, scale=scale, **kwargs)
else:
raise ValueError
def maximizeUCB(model,
bounds,
delta=0.1,
scale=0.2,
useCDIRECT=True,
maxiter=50,
maxtime=30,
maxsample=10000,
**kwargs):
"""
Maximize the upper confidence bound (UCB), as described in
[Srinivas 2009a].
"""
if not useCDIRECT:
print('using DIRECT')
ucb = UCB(model, len(bounds), delta=delta, scale=scale, **kwargs)
opt, optx = direct(ucb.negf, bounds, **kwargs)
return -opt, optx
if isinstance(model, GaussianProcess):
return cdirectGP(model,
bounds,
maxiter,
maxtime,
maxsample,
acqfunc='ucb',
delta=delta,
scale=scale,
**kwargs)
elif isinstance(model, RandomForest):
return cdirectRF(model,
bounds,
maxiter,
maxtime,
maxsample,
acqfunc='ucb',
delta=delta,
scale=scale,
**kwargs)
else:
raise ValueError
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 maximizeEI(model, bounds, useCDIRECT=True, xi=0.01, maxiter=50, maxtime=30, maxsample=10000, **kwargs):
"""
Try to maximize EI in the most efficient way possible. The methods
will be attempted in this order:
1. If there is a C implementation of the EI objective for the
kernel, it will be used (currently only works for Gaussian
kernel with ARD).
2. If the C implementation of DIRECT is available, it will be used.
3. Otherwise, the Python implementation of DIRECT will be used.
"""
if not useCDIRECT:
print "using DIRECT"
ei = EI(model, xi, **kwargs)
opt, optx = direct(ei.negf, bounds, maxiter=maxiter, maxtime=maxtime, maxsample=maxsample, **kwargs)
return -opt, optx
if isinstance(model, GaussianProcess):
return cdirectGP(model, bounds, maxiter, maxtime, maxsample, acqfunc="ei", xi=xi, **kwargs)
elif isinstance(model, RandomForest):
return cdirectRF(model, bounds, maxiter, maxtime, maxsample, acqfunc="ei", xi=xi, **kwargs)
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