def gensquexpIPdraw(d,lb,ub,sl,su,sfn,sls,cfn):
#axis = 0 value = sl
#d dimensional objective +1 for s
nt=25
#print sp.hstack([sp.array([[sl]]),lb])
#print sp.hstack([sp.array([[su]]),ub])
[X,Y,S,D] = ESutils.gen_dataset(nt,d+1,sp.hstack([sp.array([[sl]]),lb]).flatten(),sp.hstack([sp.array([[su]]),ub]).flatten(),GPdc.SQUEXP,sp.array([1.5]+[sls]+[0.30]*d))
G = GPdc.GPcore(X,Y,S,D,GPdc.kernel(GPdc.SQUEXP,d+1,sp.array([1.5]+[sls]+[0.30]*d)))
def obj(x,s,d,override=False):
x = x.flatten()
if sfn(x)==0. or override:
noise = 0.
else:
noise = sp.random.normal(scale=sp.sqrt(sfn(x)))
return [G.infer_m(x,[d])[0,0]+noise,cfn(x)]
def dirwrap(x,y):
z = obj(sp.array([[sl]+[i for i in x]]),sl,[sp.NaN],override=True)
return (z,0)
[xmin0,ymin0,ierror] = DIRECT.solve(dirwrap,lb,ub,user_data=[], algmethod=1, maxf=89000, logfilename='/dev/null')
lb2 = xmin0-sp.ones(d)*1e-4
ub2 = xmin0+sp.ones(d)*1e-4
[xmin,ymin,ierror] = DIRECT.solve(dirwrap,lb2,ub2,user_data=[], algmethod=1, maxf=89000, logfilename='/dev/null')
#print "RRRRR"+str([xmin0,xmin,ymin0,ymin,xmin0-xmin,ymin0-ymin])
return [obj,xmin,ymin]
def maximize(self):
"""
Maximizes the given acquisition function.
Returns
-------
np.ndarray(N,D)
Point with highest acquisition value.
"""
if self.verbose:
x, _, _ = DIRECT.solve(self._direct_acquisition_fkt_wrapper(
self.objective_func),
l=[self.lower],
u=[self.upper],
maxT=self.n_iters,
maxf=self.n_func_evals)
else:
fileno = sys.stdout.fileno()
with os.fdopen(os.dup(fileno), 'wb') as stdout:
with os.fdopen(os.open(os.devnull, os.O_WRONLY),
'wb') as devnull:
sys.stdout.flush()
os.dup2(devnull.fileno(), fileno) # redirect
x, _, _ = DIRECT.solve(
self._direct_acquisition_fkt_wrapper(
self.objective_func),
l=[self.lower],
u=[self.upper],
maxT=self.n_iters,
maxf=self.n_func_evals)
sys.stdout.flush()
os.dup2(stdout.fileno(), fileno) # restore
return x
def findnext(self):
if self.nsam==0:
return [0.5*(sp.matrix(self.upper)+sp.matrix(self.lower)),0]
if self.finished:
raise StandardError("opt is finished")
self.cc=0
fudge=2.
EIwrap= lambda x,y : (-self.evalWEI(sp.matrix(x)),0)
[x,EImin,ierror]=DIRECT.solve(EIwrap,self.lower,self.upper,user_data=[],algmethod=1,maxf=4000)
while self.cc==0 and fudge<=self.fudgelimit:
print "non nonzero eis found over full range. trying closer to current min with lengthfactor: "+str(fudge)
u=sp.matrix(self.upper)
l=sp.matrix(self.lower)
dia=u-l
lw=sp.maximum(l,self.best[0]-dia/fudge)
up=sp.minimum(u,self.best[0]+dia/fudge)
[x,EImin,ierror]=DIRECT.solve(EIwrap,lw,up,user_data=[],algmethod=1,maxf=4000)
fudge*=2.
print "nonzero EIs: " +str(self.cc)
if self.cc==0:
print "done. no nonzero EIs"
self.finished=True
#raise StandardError("opt is finished")
return [self.best[0],0.]
return sp.matrix(x),-EImin
def _optimize(self):
"""
Start the optimization process
:return: Optimizer parameters
"""
self.stopCriteria.startTime() # Start the clock
def objfunc(parameters, user_data):
return self._evaluate(np.matrix(
parameters)), 0 # Deal with transformations from/to np.matrix
try:
if self.verbosity < 2:
fileno = sys.stdout.fileno()
with os.fdopen(os.dup(fileno), 'wb') as stdout:
with os.fdopen(os.open(os.devnull, os.O_WRONLY),
'wb') as devnull:
sys.stdout.flush()
os.dup2(devnull.fileno(), fileno) # redirect
x, fx, _ = direct.solve(
objfunc,
l=[self.task.bounds.get_min()],
u=[self.task.bounds.get_max()],
maxT=600, # self.stopCriteria.get_n_maxIters()
maxf=self.stopCriteria.get_n_maxEvals(),
)
sys.stdout.flush()
os.dup2(stdout.fileno(), fileno) # restore
else:
x, fx, _ = direct.solve(
objfunc,
l=[self.task.bounds.get_min()],
u=[self.task.bounds.get_max()],
maxT=600, # self.stopCriteria.get_n_maxIters()
maxf=self.stopCriteria.get_n_maxEvals(),
)
except:
logging.warning('DIRECT had some problem and failed...')
# Delete log file optimizer (pretty much useless)
try:
os.remove('DIRresults.txt')
except:
logging.warning('Unable to remove file: DIRresults.txt')
# Logs
# self._logs.xOpt = x
# self._logs.fOpt = np.array(fx)
# self._logs.time = np.matrix(self.stopCriteria.get_time())
# self._logs.add_evals(x=np.matrix(x).T, fx=np.matrix(fx),
# opt_x=np.matrix(x).T, opt_fx=np.matrix(fx),
# time=np.matrix(self.stopCriteria.get_time())
# )
return x
def run_search(self):
MAP = GPdc.searchMAPhyp(self.X, self.Y, self.S, self.D, self.mprior,
self.sprior, self.kindex)
try:
del (self.G)
except:
pass
self.G = GPdc.GPcore(self.X, self.Y, self.S, self.D,
GPdc.kernel(self.kindex, self.d, MAP))
def directwrap(x, y):
x.resize([1, self.d])
a = self.G.infer_lEI(x, [[sp.NaN]])
#print [x,a]
#print G.infer_diag_post(x,[[sp.NaN]])
return (-a[0, 0], 0)
[xmin, ymin, ierror] = DIRECT.solve(directwrap,
self.lb,
self.ub,
user_data=[],
algmethod=1,
volper=self.volper,
logfilename='/dev/null')
return [xmin, self.s, [sp.NaN]]
def opt_ip(s):
def dwrap(x,y):
X = sp.hstack([[s],x])
return (ojfaugnn(X),0)
[xm,ym,ierror] = DIRECT.solve(dwrap,lb[1:],ub[1:], user_data=[], algmethod=1, maxf=12000, logfilename='/dev/null')
print "DIRECT found: " +str([xm,ym,ierror])
return xm
def gensquexpdraw(d, lb, ub, ignores=-1):
nt = 14
[X, Y, S, D] = ESutils.gen_dataset(nt, d, lb, ub, GPdc.SQUEXP,
sp.array([1.5] + [0.30] * d))
G = GPdc.GPcore(X, Y, S, D,
GPdc.kernel(GPdc.SQUEXP, d, sp.array([1.5] + [0.30] * d)))
def obj(x, s, d, override=False):
#print [x,s,d]
if ignores > 0:
s = ignores
if s == 0. or override:
noise = 0.
else:
noise = sp.random.normal(scale=sp.sqrt(s))
print "EVAL WITH NOISE: " + str(noise) + "FROM S= " + str(s)
return [G.infer_m(x, [d])[0, 0] + noise, 1.]
def dirwrap(x, y):
z = G.infer_m(x, [[sp.NaN]])[0, 0]
#z = obj(x,0.,[sp.NaN])
return (z, 0)
[xmin, ymin, ierror] = DIRECT.solve(dirwrap,
lb,
ub,
user_data=[],
algmethod=1,
maxf=89000,
logfilename='/dev/null')
return [obj, xmin, ymin]
def __solver__(self, p):
#if not p.__isFiniteBoxBounded__(): p.err('this solver requires finite lb, ub: lb <= x <= ub')
p.kernelIterFuncs.pop(SMALL_DELTA_X, None)
p.kernelIterFuncs.pop(SMALL_DELTA_F, None)
def objective(x, userData = None):
r = p.f(x)
has_nan = int(np.any(np.isnan(r)))
return r, has_nan
lb, ub = p.lb, p.ub
# lb[lb < -1e20] = -1e20
# ub[ub > 1e20] = 1e20
maxf = min((p.maxFunEvals, 19999))
maxT = min((p.maxIter, 89999))
fglobal = max((p.fOpt, -1e+100))
xf, fmin, ierror = DIRECT.solve(objective, lb, ub, eps=self.eps, maxf=maxf, maxT=maxT,
algmethod=self.algmethod, fglobal=fglobal, fglper=self.fglper,
volper=self.volper, sigmaper=self.sigmaper,
logfilename=self.logfilename)
p.xf, p.ff = xf, fmin
if p.istop == 0:
p.istop = 1000
p.msg = ierror
def genbiasedmat52ojf(d, lb, ub, sls):
# s normalised to 0 exact, 1
from ESutils import gen_dataset
nt = 20
[X, Y, S, D] = gen_dataset(nt, d + 1, [0.0] + lb, [1.0] + ub, GPdc.MAT52, sp.array([1.5] + [0.30] * d + [sls]))
G = GPdc.GPcore(X, Y, S, D, GPdc.kernel(GPdc.MAT52, d + 1, sp.array([1.5] + [0.30] * d + [sls])))
def ojf(x, **ev):
# print "\nojfinput: {} : {}".format(x,ev)
dx = ev["d"]
s = ev["s"]
if ev["s"] > 0:
noise = sp.random.normal(scale=sp.sqrt(ev["s"]))
else:
noise = 0
xa = ev["xa"]
x = sp.array(x)
xfull = sp.hstack([x, xa])
return G.infer_m(xfull, [dx])[0, 0] + noise, 1.0, dict()
def dirwrap(x, y):
z = G.infer_m(sp.hstack(sp.array(x) + [0.0]), [[sp.NaN]])[0, 0]
return (z, 0)
[xmin, ymin, ierror] = DIRECT.solve(dirwrap, lb, ub, user_data=[], algmethod=1, maxf=89000, logfilename="/dev/null")
logger.info("generated function xmin {} ymin {}".format(xmin, ymin))
return ojf, xmin, ymin
def genmat52ojf(d, lb, ub):
from ESutils import gen_dataset
nt = 14
[X, Y, S, D] = gen_dataset(nt, d, lb, ub, GPdc.MAT52, sp.array([1.5] + [0.55] * d))
G = GPdc.GPcore(X, Y, S, D, GPdc.kernel(GPdc.MAT52, d, sp.array([1.5] + [0.55] * d)))
def ojf(x, **ev):
dx = ev["d"]
s = ev["s"]
if ev["s"] > 0:
noise = sp.random.normal(scale=sp.sqrt(ev["s"]))
else:
noise = 0
return G.infer_m(sp.array(x), [dx])[0, 0] + noise, 1.0, dict()
def dirwrap(x, y):
z = G.infer_m(x, [[sp.NaN]])[0, 0]
# z = obj(x,0.,[sp.NaN])
return (z, 0)
[xmin, ymin, ierror] = DIRECT.solve(dirwrap, lb, ub, user_data=[], algmethod=1, maxf=89000, logfilename="/dev/null")
logger.info("generated function xmin {} ymin {} {}".format(xmin, ymin, ierror))
return ojf, xmin, ymin
def EIMAPaq(optstate,persist,ev=None, ub = None, lb=None, nrandinit=None, mprior=None,sprior=None,kindex = None,directmaxiter=None):
para = copy.deepcopy(para)
if persist==None:
persist = {'n':0,'d':len(ub)}
n = persist['n']
d = persist['d']
if n<nrandinit:
persist['n']+=1
return randomaq(optstate,persist,ev=ev,lb=lb,ub=ub)
logger.info('EIMAPaq')
#logger.debug(sp.vstack([e[0] for e in optstate.ev]))
#raise
x=sp.vstack(optstate.x)
y=sp.vstack(optstate.y)
s= sp.vstack([e['s'] for e in optstate.ev])
dx=[e['d'] for e in optstate.ev]
MAP = GPdc.searchMAPhyp(x,y,s,dx,mprior,sprior, kindex)
logger.info('MAPHYP {}'.format(MAP))
G = GPdc.GPcore(x,y,s,dx,GPdc.kernel(kindex,d,MAP))
def directwrap(xq,y):
xq.resize([1,d])
a = G.infer_lEI(xq,[ev['d']])
return (-a[0,0],0)
[xmin,ymin,ierror] = DIRECT.solve(directwrap,lb,ub,user_data=[], algmethod=0, maxf = directmaxiter, logfilename='/dev/null')
#logger.debug([xmin,ymin,ierror])
persist['n']+=1
return [i for i in xmin],ev,persist,{'MAPHYP':MAP,'logEImin':ymin,'DIRECTmessage':ierror}
def gpmapasrecc(optstate, **para):
if para["onlyafter"] > len(optstate.y) or not len(optstate.y) % para["everyn"] == 0:
return [sp.NaN for i in para["lb"]], {"didnotrun": True}
logger.info("gpmapas reccomender")
d = len(para["lb"])
x = sp.hstack([sp.vstack(optstate.x), sp.vstack([e["xa"] for e in optstate.ev])])
y = sp.vstack(optstate.y)
s = sp.vstack([e["s"] for e in optstate.ev])
dx = [e["d"] for e in optstate.ev]
MAP = GPdc.searchMAPhyp(x, y, s, dx, para["mprior"], para["sprior"], para["kindex"])
logger.info("MAPHYP {}".format(MAP))
G = GPdc.GPcore(x, y, s, dx, GPdc.kernel(para["kindex"], d + 1, MAP))
def directwrap(xq, y):
xq.resize([1, d])
xe = sp.hstack([xq, sp.array([[0.0]])])
# print xe
a = G.infer_m(xe, [[sp.NaN]])
return (a[0, 0], 0)
[xmin, ymin, ierror] = DIRECT.solve(
directwrap, para["lb"], para["ub"], user_data=[], algmethod=1, volper=para["volper"], logfilename="/dev/null"
)
logger.info("reccsearchresult: {}".format([xmin, ymin, ierror]))
return [i for i in xmin], {"MAPHYP": MAP, "ymin": ymin}
def reccomend(self):
def dirwrap(x,y):
m =self.pesobj.G.infer_m(sp.hstack([self.para['sl'],x]),[[sp.NaN]])[0,0]
return (m,0)
[xmin,ymin,ierror] = DIRECT.solve(dirwrap,self.lb[:,1:],self.ub[:,1:],user_data=[], algmethod=1, volper=self.para['volper'], logfilename='/dev/null')
return sp.hstack([sp.array(self.para['sl']),xmin])
def genmat52ojf(d, lb, ub):
from ESutils import gen_dataset
nt = 14
[X, Y, S, D] = gen_dataset(nt, d, lb, ub, GPdc.MAT52,
sp.array([1.5] + [0.55] * d))
G = GPdc.GPcore(X, Y, S, D,
GPdc.kernel(GPdc.MAT52, d, sp.array([1.5] + [0.55] * d)))
def ojf(x, **ev):
dx = ev['d']
s = ev['s']
if ev['s'] > 0:
noise = sp.random.normal(scale=sp.sqrt(ev['s']))
else:
noise = 0
return G.infer_m(sp.array(x), [dx])[0, 0] + noise, 1., dict()
def dirwrap(x, y):
z = G.infer_m(x, [[sp.NaN]])[0, 0]
#z = obj(x,0.,[sp.NaN])
return (z, 0)
[xmin, ymin, ierror] = DIRECT.solve(dirwrap,
lb,
ub,
user_data=[],
algmethod=1,
maxf=89000,
logfilename='/dev/null')
logger.info('generated function xmin {} ymin {} {}'.format(
xmin, ymin, ierror))
return ojf, xmin, ymin
def gpmapasrecc(optstate, **para):
if para['onlyafter'] > len(
optstate.y) or not len(optstate.y) % para['everyn'] == 0:
return [sp.NaN for i in para['lb']], {'didnotrun': True}
logger.info('gpmapas reccomender')
d = len(para['lb'])
x = sp.hstack(
[sp.vstack(optstate.x),
sp.vstack([e['xa'] for e in optstate.ev])])
y = sp.vstack(optstate.y)
s = sp.vstack([e['s'] for e in optstate.ev])
dx = [e['d'] for e in optstate.ev]
MAP = GPdc.searchMAPhyp(x, y, s, dx, para['mprior'], para['sprior'],
para['kindex'])
logger.info('MAPHYP {}'.format(MAP))
G = GPdc.GPcore(x, y, s, dx, GPdc.kernel(para['kindex'], d + 1, MAP))
def directwrap(xq, y):
xq.resize([1, d])
xe = sp.hstack([xq, sp.array([[0.]])])
#print xe
a = G.infer_m(xe, [[sp.NaN]])
return (a[0, 0], 0)
[xmin, ymin, ierror] = DIRECT.solve(directwrap,
para['lb'],
para['ub'],
user_data=[],
algmethod=1,
volper=para['volper'],
logfilename='/dev/null')
logger.info('reccsearchresult: {}'.format([xmin, ymin, ierror]))
return [i for i in xmin], {'MAPHYP': MAP, 'ymin': ymin}
def gensquexpIPdraw(d, lb, ub, sl, su, sfn, sls, cfn):
#axis = 0 value = sl
#d dimensional objective +1 for s
nt = 25
#print sp.hstack([sp.array([[sl]]),lb])
#print sp.hstack([sp.array([[su]]),ub])
[X, Y,
S, D] = ESutils.gen_dataset(nt, d + 1,
sp.hstack([sp.array([[sl]]), lb]).flatten(),
sp.hstack([sp.array([[su]]), ub]).flatten(),
GPdc.SQUEXP,
sp.array([1.5] + [sls] + [0.30] * d))
G = GPdc.GPcore(
X, Y, S, D,
GPdc.kernel(GPdc.SQUEXP, d + 1, sp.array([1.5] + [sls] + [0.30] * d)))
def obj(x, s, d, override=False):
x = x.flatten()
if sfn(x) == 0. or override:
noise = 0.
else:
noise = sp.random.normal(scale=sp.sqrt(sfn(x)))
return [G.infer_m(x, [d])[0, 0] + noise, cfn(x)]
def dirwrap(x, y):
z = obj(sp.array([[sl] + [i for i in x]]), sl, [sp.NaN], override=True)
return (z, 0)
[xmin0, ymin0, ierror] = DIRECT.solve(dirwrap,
lb,
ub,
user_data=[],
algmethod=1,
maxf=89000,
logfilename='/dev/null')
lb2 = xmin0 - sp.ones(d) * 1e-4
ub2 = xmin0 + sp.ones(d) * 1e-4
[xmin, ymin, ierror] = DIRECT.solve(dirwrap,
lb2,
ub2,
user_data=[],
algmethod=1,
maxf=89000,
logfilename='/dev/null')
#print "RRRRR"+str([xmin0,xmin,ymin0,ymin,xmin0-xmin,ymin0-ymin])
return [obj, xmin, ymin]
def planemin(xp):
def dirwrap(x,y):
z,c = ojf(sp.hstack([xp,x]),-1,[sp.NaN],override=True)
return (z,0)
[xm,ym,ierror] = DIRECT.solve(dirwrap,lb,ub,user_data=[], algmethod=1, maxf=80000, logfilename='/dev/null')
ye,c = ojf(sp.hstack([0.,xm]),-1,[sp.NaN],override=True)
r=ye-ymin
return [xm,ym,ye,r]
def genbiasedmat52ojf(d, lb, ub, xls, sls):
#s normalised to 0 exact, 1
from ESutils import gen_dataset
nt = 30
[X, Y, S, D] = gen_dataset(nt, d + 1, lb + [0], ub + [1], GPdc.MAT52,
sp.array([1.5] + [xls] * d + [sls]))
G = GPdc.GPcore(
X, Y, S, D,
GPdc.kernel(GPdc.MAT52, d + 1, sp.array([1.5] + [0.30] * d + [sls])))
def ojf(x, **ev):
#print "\nojfinput: {} : {}".format(x,ev)
dx = ev['d']
s = ev['s']
if ev['s'] > 0:
noise = sp.random.normal(scale=sp.sqrt(ev['s']))
else:
noise = 0
#print 'noise in ojf {}'.format(noise)
xa = ev['xa']
x = sp.array(x)
xfull = sp.hstack([x, xa])
return G.infer_m(xfull, [dx])[0, 0] + noise, 1., dict()
def dirwrap(x, y):
z = G.infer_m(sp.hstack(sp.array(x) + [0.]), [[sp.NaN]])[0, 0]
return (z, 0)
[xmin, ymin, ierror] = DIRECT.solve(dirwrap,
lb,
ub,
user_data=[],
algmethod=1,
maxf=40000,
logfilename='/dev/null')
#print [xmin, ymin]
def spowrap(x):
z = G.infer_m(sp.hstack(sp.array(x) + [0.]), [[sp.NaN]])[0, 0]
return z
y = spm(spowrap,
xmin,
method='l-bfgs-b',
bounds=[(-1, 1)] * d,
options={'ftol': 1e-15})
xmin = y.x
ymin = spowrap(y.x)
#print [xmin,ymin]
if sp.isnan(ymin):
logger.warning('generator got nan optimizing objective. retrying...')
return genbiasedmat52ojf(d, lb, ub, xls, sls)
logger.info(
'generated function xmin {} ymin {} globopt:{} locopt:{}'.format(
xmin, ymin, ierror, y.status))
return ojf, xmin, ymin
def search_hyper(self):
Fwrap= lambda x,y: (-self.eval_kernel_ap(x),0)
upper=[]
lower=[]
for i in self.KF_prior:
upper.append(i[0]+3*i[1])
lower.append(i[0]-3*i[1])
[loghyp,Fmin,ierror]=DIRECT.solve(Fwrap,lower,upper,user_data=[],algmethod=1,maxf=2000)
return [map(lambda x:10**x,loghyp),-Fmin]
def optimize(self, acquisition: Acquisition):
"""
acquisition - The acquisition function to be optimized
"""
x, _, _ = DIRECT.solve(
self._direct_acquisition_fkt_wrapper(acquisition),
l=[self.lower],
u=[self.upper],
maxT=self.n_iters,
maxf=self.n_func_evals)
return x[None, :], None
def _argmax_expected_improvement(self):
def obj(x, data):
return (-self.expected_improvement([x]), 0)
# use DIRECT algorithm
x, _, _ = DIRECT.solve(obj,
self._bound[:, 0],
self._bound[:, 1],
maxf=1000,
algmethod=1)
return x
def search_acq(self,cfn,logsl,logsu,volper=1e-6,dv=[[sp.NaN]]):
def directwrap(Q,extra):
x = sp.array([Q[:-1]])
s = 10**Q[-1]
acq = PESgain(self.G,self.Ga,self.Z,x,dv,[s])
try:
R = -acq/cfn(x,**{'s':s})
except TypeError:
R = -acq/cfn(x,s)
return (R,0)
[xmin, ymin, ierror] = DIRECT.solve(directwrap,sp.hstack([self.lb,logsl]),sp.hstack([self.ub,logsu]),user_data=[], algmethod=1, volper=volper, logfilename='/dev/null')
return [xmin,ymin,ierror]
def reccomend(self):
def dirwrap(x, y):
m = self.pesobj.G.infer_m(x, [[sp.NaN]])[0, 0]
return (m, 0)
[xmin, ymin, ierror] = DIRECT.solve(dirwrap,
self.lb,
self.ub,
user_data=[],
algmethod=1,
volper=self.para['volper'],
logfilename='/dev/null')
return xmin
def opt_ip(s):
def dwrap(x, y):
X = sp.hstack([[s], x])
return (ojfaugnn(X), 0)
[xm, ym, ierror] = DIRECT.solve(dwrap,
lb[1:],
ub[1:],
user_data=[],
algmethod=1,
maxf=12000,
logfilename='/dev/null')
print "DIRECT found: " + str([xm, ym, ierror])
return xm
def reccomend(self):
def dirwrap(x, y):
m = self.pesobj.G.infer_m(sp.hstack([self.para['sl'], x]),
[[sp.NaN]])[0, 0]
return (m, 0)
[xmin, ymin, ierror] = DIRECT.solve(dirwrap,
self.lb[:, 1:],
self.ub[:, 1:],
user_data=[],
algmethod=1,
volper=self.para['volper'],
logfilename='/dev/null')
return sp.hstack([sp.array(self.para['sl']), xmin])
def EIMAPaq(optstate,
persist,
ev=None,
ub=None,
lb=None,
nrandinit=None,
mprior=None,
sprior=None,
kindex=None,
directmaxiter=None):
para = copy.deepcopy(para)
if persist == None:
persist = {'n': 0, 'd': len(ub)}
n = persist['n']
d = persist['d']
if n < nrandinit:
persist['n'] += 1
return randomaq(optstate, persist, ev=ev, lb=lb, ub=ub)
logger.info('EIMAPaq')
#logger.debug(sp.vstack([e[0] for e in optstate.ev]))
#raise
x = sp.vstack(optstate.x)
y = sp.vstack(optstate.y)
s = sp.vstack([e['s'] for e in optstate.ev])
dx = [e['d'] for e in optstate.ev]
MAP = GPdc.searchMAPhyp(x, y, s, dx, mprior, sprior, kindex)
logger.info('MAPHYP {}'.format(MAP))
G = GPdc.GPcore(x, y, s, dx, GPdc.kernel(kindex, d, MAP))
def directwrap(xq, y):
xq.resize([1, d])
a = G.infer_lEI(xq, [ev['d']])
return (-a[0, 0], 0)
[xmin, ymin, ierror] = DIRECT.solve(directwrap,
lb,
ub,
user_data=[],
algmethod=0,
maxf=directmaxiter,
logfilename='/dev/null')
#logger.debug([xmin,ymin,ierror])
persist['n'] += 1
return [i for i in xmin], ev, persist, {
'MAPHYP': MAP,
'logEImin': ymin,
'DIRECTmessage': ierror
}
def search_pes(self,s,volper=1e-6,dv=[[sp.NaN]]):
self.stmp = s
def directwrap(Q,extra):
x = sp.array([Q])
if self.noS:
alls = [k(x,x,dv,dv,gets=True)[1] for k in self.G.kf]
s = sp.exp(sp.mean(sp.log(alls)))
else:
s= self.stmp
acq = PESgain(self.G,self.Ga,self.Z,x,dv,[s])
R = -acq
return (R,0)
[xmin, ymin, ierror] = DIRECT.solve(directwrap,self.lb,self.ub,user_data=[], algmethod=1, volper=volper, logfilename='/dev/null')
return [xmin,ymin,ierror]
def run_search(self):
MAP = GPdc.searchMAPhyp(self.X,self.Y,self.S,self.D,self.mprior,self.sprior, self.kindex)
try:
del(self.G)
except:
pass
self.G = GPdc.GPcore(self.X,self.Y,self.S,self.D,GPdc.kernel(self.kindex,self.d,MAP))
def directwrap(x,y):
x.resize([1,self.d])
a = self.G.infer_LCB(x,[[sp.NaN]],1.)[0,0]
return (a,0)
[xmin,ymin,ierror] = DIRECT.solve(directwrap,self.lb,self.ub,user_data=[], algmethod=1, volper=self.volper, logfilename='/dev/null')
return [xmin,self.s,[sp.NaN]]
def maximize(self):
"""
Maximizes the given acquisition function.
Returns
-------
np.ndarray(N,D)
Point with highest acquisition value.
"""
x, _, _ = DIRECT.solve(
self._direct_acquisition_fkt_wrapper(self.objective_func),
l=[self.X_lower],
u=[self.X_upper],
maxT=self.n_iters,
maxf=self.n_func_evals)
return np.array([x])
def _argmax_expected_improvement(self):
def obj(x):
return -self._expected_improvement([x])
if self.use_direct:
# use DIRECT algorithm
x, _, _ = DIRECT.solve(obj, self._bound[:,0], self._bound[:,1],
maxf=1000, algmethod=1)
else:
# use basinhopping
res = basinhopping(obj, (self._bound[:,0]+self._bound[:,1]),
minimizer_kwargs={'bounds':self._bound})
x = res.x
return x
def maximize(self):
"""
Maximizes the given acquisition function.
Returns
-------
np.ndarray(N,D)
Point with highest acquisition value.
"""
x, _, _ = DIRECT.solve(
self._direct_acquisition_fkt_wrapper(self.objective_func),
l=[self.X_lower],
u=[self.X_upper],
maxT=self.n_iters,
maxf=self.n_func_evals)
return np.array([x])
def gensquexpdraw(d,lb,ub,ignores=-1):
nt=14
[X,Y,S,D] = ESutils.gen_dataset(nt,d,lb,ub,GPdc.SQUEXP,sp.array([1.5]+[0.30]*d))
G = GPdc.GPcore(X,Y,S,D,GPdc.kernel(GPdc.SQUEXP,d,sp.array([1.5]+[0.30]*d)))
def obj(x,s,d,override=False):
#print [x,s,d]
if ignores>0:
s=ignores
if s==0. or override:
noise = 0.
else:
noise = sp.random.normal(scale=sp.sqrt(s))
print "EVAL WITH NOISE: "+str(noise) + "FROM S= "+str(s)
return [G.infer_m(x,[d])[0,0]+noise,1.]
def dirwrap(x,y):
z = G.infer_m(x,[[sp.NaN]])[0,0]
#z = obj(x,0.,[sp.NaN])
return (z,0)
[xmin,ymin,ierror] = DIRECT.solve(dirwrap,lb,ub,user_data=[], algmethod=1, maxf=89000, logfilename='/dev/null')
return [obj,xmin,ymin]
def _candidates_pathwise(self, N, last_selected):
def obj_sd(x, data):
return (-self._sd([x]), 0)
if last_selected == []:
#set one end as last_selected input
x_max = self._x[np.argmax(self._fMAP)]
else:
x_max = last_selected[0]
# use DIRECT algorithm
x_argmax_sd, _, _ = DIRECT.solve(obj_sd,
self._bound[:, 0],
self._bound[:, 1],
maxf=1000,
algmethod=1)
pivots = np.array([
np.linspace(x_max[i], x_argmax_sd[i], N) for i in range(len(x_max))
]).T
pivots = self._bend(pivots)
return list(pivots)
def genbiasedmat52ojf(d, lb, ub, sls):
#s normalised to 0 exact, 1
from ESutils import gen_dataset
nt = 20
[X, Y, S, D] = gen_dataset(nt, d + 1, [0.] + lb, [1.] + ub, GPdc.MAT52,
sp.array([1.5] + [0.30] * d + [sls]))
G = GPdc.GPcore(
X, Y, S, D,
GPdc.kernel(GPdc.MAT52, d + 1, sp.array([1.5] + [0.30] * d + [sls])))
def ojf(x, **ev):
#print "\nojfinput: {} : {}".format(x,ev)
dx = ev['d']
s = ev['s']
if ev['s'] > 0:
noise = sp.random.normal(scale=sp.sqrt(ev['s']))
else:
noise = 0
xa = ev['xa']
x = sp.array(x)
xfull = sp.hstack([x, xa])
return G.infer_m(xfull, [dx])[0, 0] + noise, 1., dict()
def dirwrap(x, y):
z = G.infer_m(sp.hstack(sp.array(x) + [0.]), [[sp.NaN]])[0, 0]
return (z, 0)
[xmin, ymin, ierror] = DIRECT.solve(dirwrap,
lb,
ub,
user_data=[],
algmethod=1,
maxf=89000,
logfilename='/dev/null')
logger.info('generated function xmin {} ymin {}'.format(xmin, ymin))
return ojf, xmin, ymin
def __solver__(self, p):
#if not p.__isFiniteBoxBounded__(): p.err('this solver requires finite lb, ub: lb <= x <= ub')
p.kernelIterFuncs.pop(SMALL_DELTA_X, None)
p.kernelIterFuncs.pop(SMALL_DELTA_F, None)
def objective(x, userData=None):
r = p.f(x)
has_nan = int(np.any(np.isnan(r)))
return r, has_nan
lb, ub = p.lb, p.ub
# lb[lb < -1e20] = -1e20
# ub[ub > 1e20] = 1e20
maxf = min((p.maxFunEvals, 19999))
maxT = min((p.maxIter, 89999))
fglobal = max((p.fOpt, -1e+100))
xf, fmin, ierror = DIRECT.solve(objective,
lb,
ub,
eps=self.eps,
maxf=maxf,
maxT=maxT,
algmethod=self.algmethod,
fglobal=fglobal,
fglper=self.fglper,
volper=self.volper,
sigmaper=self.sigmaper,
logfilename=self.logfilename)
p.xf, p.ff = xf, fmin
if p.istop == 0:
p.istop = 1000
p.msg = ierror
def cost(x, s):
return 1.0
axis = 0
value = 0
sf = 1e-4
def directwrap(Q, extra):
x = sp.array([Q])
s = sf
acq = PES.PESgain(G, Ga, Z, x, [[sp.NaN]], [s])
R = -acq / cost(x, s)
return (R, 0)
[xmin, miny, ierror] = DIRECT.solve(
directwrap,
sp.array([-1.0, -1.0]),
sp.array([1.0, 1.0]),
user_data=[],
algmethod=1,
maxf=2000,
logfilename="/dev/null",
)
print [xmin, miny, ierror]
plt.show()
def DIRECT(acquisition_fkt, X_lower, X_upper):
x, fmin, ierror = _DIRECT.solve(_DIRECT_acquisition_fkt_wrapper(acquisition_fkt), l=[X_lower], u=[X_upper], maxT=2000, maxf=2000)
return np.array([x])
import DIRECT as d0
global trace0
trace0=[]
lb = [0.,0.]
ub = [1.,1.]
def d0wrap(x,y):
#y = x[1] * (x[0] * 0.1 + 1.5) + 0.1
#u = x[0]
#y = (u + 1.5) * (u + 1.5) * (u - 0.5) * (u - 0.5) + (y + 0.75) * (y + 0.25) * (y - 1.25) * (y - 1.75)
y=x[0]+1.054*x[1]
global trace0
trace0.append([x[0], x[1], y])
return y,0
print d0.solve(d0wrap,lb,ub,algmethod=1)
from matplotlib import pyplot as plt
f,a = plt.subplots(1)
for i in range(0,len(trace0)):
a.plot(trace0[i][0],trace0[i][1],'b.')
plt.show()
import DIRECT as d0
global trace0
trace0 = []
def d0wrap(x, y):
#y = x[1] * (x[0] * 0.1 + 1.5) + 0.1
#u = x[0]
#y = (u + 1.5) * (u + 1.5) * (u - 0.5) * (u - 0.5) + (y + 0.75) * (y + 0.25) * (y - 1.25) * (y - 1.75)
y = x[0] + 1.054 * x[1]
global trace0
trace0.append([x[0], x[1], y])
return y, 0
print d0.solve(d0wrap, lb, ub, maxf=200, algmethod=1, eps=1e-19)
indexes = []
distances = []
yerrs = []
for i in xrange(len(trace0)):
mx = 1000
inc = 0
for j in xrange(len(trace1)):
dx = sp.sqrt((trace0[i][0] - trace1[j][0])**2 +
(trace0[i][1] - trace1[j][1])**2)
if dx < mx:
inc = j
mx = dx
dy = abs(trace0[i][2] - trace1[j][2])
indexes.append(inc)
def reccomend(self):
def dirwrap(x,y):
m =self.pesobj.G.infer_m(x,[[sp.NaN]])[0,0]
return (m,0)
[xmin,ymin,ierror] = DIRECT.solve(dirwrap,self.lb,self.ub,user_data=[], algmethod=1, volper=self.para['volper'], logfilename='/dev/null')
return xmin
def solve(self,problem,numIters=100,tol=1e-6):
"""Returns a pair (solved,x) where solved is True if the solver
found a valid solution, and x is the solution vector."""
if isinstance(self.method,(list,tuple)):
#sequential solve
seed = self.seed
for i,m in enumerate(self.method):
if hasattr(numIters,'__iter__'):
itersi = numIters[i]
else:
itersi = numIters
if hasattr(tol,'__iter__'):
toli = tol[i]
else:
toli = tol
print ("Step",i,"method",m,'iters',itersi,'tol',toli)
if m == 'auto':
opt = LocalOptimizer(m)
else:
opt = GlobalOptimizer(m)
#seed with previous seed, if necessary
opt.setSeed(seed)
(succ,xsol)=opt.solve(problem,itersi,toli)
if not succ: return (False,xsol)
seed = xsol[:]
return ((seed is not None),seed)
elif self.method == 'scipy.differential_evolution':
from scipy import optimize
if problem.bounds == None:
raise RuntimeError("Cannot use scipy differential_evolution method without a bounded search space")
flattenedProblem = problem.flatten(objective_scale = 1e-5)
res = optimize.differential_evolution(flattenedProblem.objective,zip(*flattenedProblem.bounds))
print ("scipy.differential_evolution solution:",res.x)
print ("Objective value",res.fun)
print ("Equality error:",[gx(res.x) for gx in problem.equalities])
return (True,res.x)
elif self.method == 'DIRECT':
import DIRECT
if problem.bounds == None:
raise RuntimeError("Cannot use DIRECT method without a bounded search space")
flattenedProblem = problem.flatten(objective_scale = 1e-5)
minval = [float('inf'),None]
def objfunc(x,userdata):
v = flattenedProblem.objective(x)
if v < userdata[0]:
userdata[0] = v
userdata[1] = [float(xi) for xi in x]
return v
(x,fmin,ierror)=DIRECT.solve(objfunc,problem.bounds[0],problem.bounds[1],eps=tol,maxT=numIters,maxf=40000,algmethod=1,user_data=minval)
print ("DIRECT solution:",x)
print ("Objective value",fmin)
print ("Minimum value",minval[0],minval[1])
print ("Error:",ierror)
print ("Equality error:",[gx(x) for gx in problem.equalities])
return (True,minval[1])
elif self.method.startswith('random-restart'):
import random
if problem.bounds == None:
raise RuntimeError("Cannot use random-restart method without a bounded search space")
localmethod = self.method[15:]
lopt = LocalOptimizer(localmethod)
best = self.seed
fbest = (problem.objective(best) if best is not None else float('inf'))
for it in xrange(numIters[0]):
x = [random.uniform(a,b) for a,b in zip(*problem.bounds)]
lopt.setSeed(x)
succ,x = lopt.solve(problem,numIters[1],tol)
if succ:
fx = problem.objective(x)
if fx < fbest:
fbest = fx
best = x
return (best is not None, best)
else:
opt = LocalOptimizer(self.method)
opt.setSeed(self.seed)
return opt.solve(problem,numIters,tol)
def solve(self,problem,numIters=100,tol=1e-6):
"""Returns a pair (solved,x) where solved is True if the solver
found a valid solution, and x is the solution vector."""
if isinstance(self.method,(list,tuple)):
#sequential solve
seed = self.seed
for i,m in enumerate(self.method):
if hasattr(numIters,'__iter__'):
itersi = numIters[i]
else:
itersi = numIters
if hasattr(tol,'__iter__'):
toli = tol[i]
else:
toli = tol
print "Step",i,"method",m,'iters',itersi,'tol',toli
if m == 'auto':
opt = LocalOptimizer(m)
else:
opt = GlobalOptimizer(m)
#seed with previous seed, if necessary
opt.setSeed(seed)
(succ,xsol)=opt.solve(problem,itersi,toli)
if not succ: return (False,xsol)
seed = xsol[:]
return ((seed is not None),seed)
elif self.method == 'scipy.differential_evolution':
from scipy import optimize
if problem.bounds == None:
raise RuntimeError("Cannot use scipy differential_evolution method without a bounded search space")
flattenedProblem = problem.flatten(objective_scale = 1e-5)
res = optimize.differential_evolution(flattenedProblem.objective,zip(*flattenedProblem.bounds))
print "scipy.differential_evolution solution:",res.x
print "Objective value",res.fun
print "Equality error:",[gx(res.x) for gx in problem.equalities]
return (True,res.x)
elif self.method == 'DIRECT':
import DIRECT
if problem.bounds == None:
raise RuntimeError("Cannot use DIRECT method without a bounded search space")
flattenedProblem = problem.flatten(objective_scale = 1e-5)
minval = [float('inf'),None]
def objfunc(x,userdata):
v = flattenedProblem.objective(x)
if v < userdata[0]:
userdata[0] = v
userdata[1] = [float(xi) for xi in x]
return v
(x,fmin,ierror)=DIRECT.solve(objfunc,problem.bounds[0],problem.bounds[1],eps=tol,maxT=numIters,maxf=40000,algmethod=1,user_data=minval)
print "DIRECT solution:",x
print "Objective value",fmin
print "Minimum value",minval[0],minval[1]
print "Error:",ierror
print "Equality error:",[gx(x) for gx in problem.equalities]
return (True,minval[1])
elif self.method.startswith('random-restart'):
import random
if problem.bounds == None:
raise RuntimeError("Cannot use random-restart method without a bounded search space")
localmethod = self.method[15:]
lopt = LocalOptimizer(localmethod)
best = self.seed
fbest = (problem.objective(best) if best is not None else float('inf'))
for it in xrange(numIters[0]):
x = [random.uniform(a,b) for a,b in zip(*problem.bounds)]
lopt.setSeed(x)
succ,x = lopt.solve(problem,numIters[1],tol)
if succ:
fx = problem.objective(x)
if fx < fbest:
fbest = fx
best = x
return (best is not None, best)
else:
opt = LocalOptimizer(self.method)
opt.setSeed(self.seed)
return opt.solve(problem,numIters,tol)
def maximize(self, numberConfigs_unTest):
n_iters = int(numberConfigs_unTest * 2)
x, _, _ = DIRECT.solve(self._direct_acquisition_fkt_wrapper(self.objective_func),
l=[self.lower],
u=[self.upper],
maxT=n_iters,
maxf=numberConfigs_unTest)
#x[0] = nr of workers
#x[1] = learning rate
#x[2] = batch size
#x[3] = synchronism
#x[4] = flavor
#x[5] = size
#learning rate
if x[1] <= 5.5e-5:
x[1] = 1e-5
elif x[1] >= 5.5e-4:
x[1] = 1e-3
else:
x[1] = 1e-4
#batch size
if x[2] < 136:
x[2] = 16
else:
x[2] = 256
x[3] = np.rint(x[3]) #synchronism
x[4] = np.rint(x[4]) #flavor
#number of workers
if x[4] == 0:
#small
if x[0] <= 12:
x[0] = 8
elif x[0] > 12 and x[0] <= 24:
x[0] = 16
elif x[0] > 24 and x[0] <= 40:
x[0] = 32
elif x[0] > 40 and x[0] <= 56:
x[0] = 48
elif x[0] > 56 and x[0] <= 72:
x[0] = 64
else:
x[0] = 80
elif x[4] == 1:
#medium
if x[0] <= 6:
x[0] = 4
elif x[0] > 6 and x[0] <= 12:
x[0] = 8
elif x[0] > 12 and x[0] <= 20:
x[0] = 16
elif x[0] > 20 and x[0] <= 28:
x[0] = 24
elif x[0] > 28 and x[0] <= 36:
x[0] = 32
else:
x[0] = 40
elif x[4] == 2:
#xlarge
if x[0] <= 3:
x[0] = 2
elif x[0] > 3 and x[0] <= 6:
x[0] = 4
elif x[0] > 6 and x[0] <= 10:
x[0] = 8
elif x[0] > 10 and x[0] <= 14:
x[0] = 12
elif x[0] > 14 and x[0] <= 18:
x[0] = 16
else:
x[0] = 20
else:
#2xlarge
if x[0] <= 1.5:
x[0] = 1
elif x[0] > 1.5 and x[0] <= 3:
x[0] = 2
elif x[0] > 3 and x[0] <= 5:
x[0] = 4
elif x[0] > 5 and x[0] <= 7:
x[0] = 6
elif x[0] > 7 and x[0] <= 9:
x[0] = 8
else:
x[0] = 10
#size
s = retransform(x[5], 1000, 60000) #real value
if s <= 3500:
x[5] = transform(1000, 1000, 60000)
elif s > 3500 and s <= 10500:
x[5] = transform(6000, 1000, 60000)
elif s > 10500 and s <= 22500:
x[5] = transform(15000, 1000, 60000)
elif s > 22500 and s <= 4500:
x[5] = transform(30000, 1000, 60000)
else:
x[5] = transform(60000, 1000, 60000)
return x
X.append(x.tolist())
y_ = b.objective_function(x)['function_value']
y.append(y_)
return y_, 0
# Dimension and bounds of the function
bounds = b.get_meta_information()['bounds']
dimensions = len(bounds)
lower = np.array([i[0] for i in bounds])
upper = np.array([i[1] for i in bounds])
start_point = (upper-lower)/2
x, _, _ = DIRECT.solve(wrapper,
l=[lower],
u=[upper],
maxT=n_iters*2,
maxf=n_iters)
X = X[:200]
y = y[:200]
fvals = np.array(y)
incs = []
incumbent_val = []
curr_inc_val = sys.float_info.max
inc = None
for i, f in enumerate(fvals):
if curr_inc_val > f:
curr_inc_val = f
inc = X[i]
import DIRECT as d0
global trace0
trace0 = []
lb = [0., 0.]
ub = [1., 1.]
def d0wrap(x, y):
#y = x[1] * (x[0] * 0.1 + 1.5) + 0.1
#u = x[0]
#y = (u + 1.5) * (u + 1.5) * (u - 0.5) * (u - 0.5) + (y + 0.75) * (y + 0.25) * (y - 1.25) * (y - 1.75)
y = x[0] + 1.054 * x[1]
global trace0
trace0.append([x[0], x[1], y])
return y, 0
print d0.solve(d0wrap, lb, ub, algmethod=1)
from matplotlib import pyplot as plt
f, a = plt.subplots(1)
for i in range(0, len(trace0)):
a.plot(trace0[i][0], trace0[i][1], 'b.')
plt.show()
def gendecayingpositiveojf(d, lb, ub, sim):
# s normalised to 0 exact, 1
from ESutils import gen_dataset
nt = 20
cl = 2.
[X, Y, S, D] = gen_dataset(nt, d, lb, ub, GPdc.MAT52,
sp.array([1] + [0.30] * d))
G0 = GPdc.GPcore(X, Y, S, D,
GPdc.kernel(GPdc.MAT52, d, sp.array([1] + [0.30] * d)))
[X, Y, S, D] = gen_dataset(nt, d, lb, ub, GPdc.MAT52,
sp.array([1] + [0.30] * d))
G1 = GPdc.GPcore(X, Y, S, D,
GPdc.kernel(GPdc.MAT52, d, sp.array([1] + [0.30] * d)))
[X, Y, S, D] = gen_dataset(nt, d, lb, ub, GPdc.MAT52,
sp.array([1] + [0.30] * d))
G2 = GPdc.GPcore(X, Y, S, D,
GPdc.kernel(GPdc.MAT52, d, sp.array([1] + [0.30] * d)))
def p0(x):
v = G0.infer_m(x, [[sp.NaN]])[0, 0]
y = v + 1 if v > 0 else sp.exp(v)
return y
def p1(x):
v = G1.infer_m(x, [[sp.NaN]])[0, 0]
y = v + 1 if v > 0 else sp.exp(v)
return y
def p2(x):
v = G2.infer_m(x, [[sp.NaN]])[0, 0]
y = v + 1 if v > 0 else sp.exp(v)
return y
def ojf(x, **ev):
#print "ex: {} {}".format(x,ev['xa'])
# print "\nojfinput: {} : {}".format(x,ev)
dx = ev['d']
s = ev['s']
if ev['s'] > 0:
noise = sp.random.normal(scale=sp.sqrt(ev['s']))
else:
noise = 0
# print 'noise in ojf {}'.format(noise)
xa = ev['xa']
x = sp.array(x)
y0 = p0(x)
y1 = sim * p1(x) + y0
l = p2(x)
A = (y1 - y0) / (sp.exp(l) - 1)
B = y0 - A
y = A * sp.exp(l * xa) + B
c = sp.exp(-cl * xa)
return y + noise, c, dict()
def dirwrap(x, y):
z = ojf(x, **{'d': [sp.NaN], 's': 0, 'xa': 0})[0]
return (z, 0)
[xmin, ymin, ierror] = DIRECT.solve(dirwrap,
lb,
ub,
user_data=[],
algmethod=1,
maxf=20000,
logfilename='/dev/null')
# print [xmin, ymin]
def spowrap(x):
z = ojf(x, **{'d': [sp.NaN], 's': 0, 'xa': 0})[0]
return z
y = spm(spowrap, xmin, method='nelder-mead', options={'fatol': 1e-12})
xmin = y.x
ymin = spowrap(y.x)
# print [xmin,ymin]
logger.info(
'generated function xmin {} ymin {} yminisnan{} globopt:{} locopt:{}'.
format(xmin, ymin, sp.isnan(ymin), ierror, y.status))
if sp.isnan(ymin):
logger.warning('generator got nan optimizing objective. retrying...')
return gendecayingpositiveojf(d, lb, ub)
return ojf, xmin, ymin
def maximize(self):
x, fmin, ierror = DIRECT.solve(self._direct_acquisition_fkt_wrapper(self.objective_func),
l=[self.X_lower], u=[self.X_upper], maxT=self.n_iters, maxf=self.n_func_evals)
return np.array([x])
A = sp.array([[4.1,2,1],[2,5,-2],[1,-2,5]])
b = sp.array([[0.5,1.,1.5]]).T
c = 1.
def f(x,data):
global tstart
tstart.append(time.clock())
x.resize([3,1])
y=(x-b).T.dot(A.dot((x-b)))+c
global tend
tend.append(time.clock())
return y,0
global tstart
global tend
tstart=[]
tend=[]
lb = sp.ones(3)*-2.
ub = sp.ones(3)*2.
ts=time.clock()
xmin,ymin,mess = DIRECT.solve(f,lb,ub,maxf=20000)
te=time.clock()
print "total time {}".format(te-ts)
print "xmin {}".format(xmin.flatten())
print "ymin {}".format(ymin)
#print mess
tfeval = [tend[i]-tstart[i] for i in xrange(len(tstart))]
tfinter = [tend[i+1]-tstart[i] for i in xrange(len(tstart)-1)]
print "min mean max fevaltime: [{} , {} , {}]".format(min(tfeval),sp.mean(tfeval),max(tfeval))
print "min mean max fintertime: [{} , {} , {}]".format(min(tfinter),sp.mean(tfinter),max(tfinter))
tstart.append(time.clock())
x.resize([3, 1])
y = (x - b).T.dot(A.dot((x - b))) + c
global tend
tend.append(time.clock())
return y, 0
global tstart
global tend
tstart = []
tend = []
lb = sp.ones(3) * -2.
ub = sp.ones(3) * 2.
ts = time.clock()
xmin, ymin, mess = DIRECT.solve(f, lb, ub, maxf=20000)
te = time.clock()
print "total time {}".format(te - ts)
print "xmin {}".format(xmin.flatten())
print "ymin {}".format(ymin)
#print mess
tfeval = [tend[i] - tstart[i] for i in xrange(len(tstart))]
tfinter = [tend[i + 1] - tstart[i] for i in xrange(len(tstart) - 1)]
print "min mean max fevaltime: [{} , {} , {}]".format(min(tfeval),
sp.mean(tfeval),
max(tfeval))
print "min mean max fintertime: [{} , {} , {}]".format(min(tfinter),
sp.mean(tfinter),
max(tfinter))
X.append(x.tolist())
y_ = b.objective_function(x)['function_value']
y.append(y_)
return y_, 0
# Dimension and bounds of the function
bounds = b.get_meta_information()['bounds']
dimensions = len(bounds)
lower = np.array([i[0] for i in bounds])
upper = np.array([i[1] for i in bounds])
start_point = (upper-lower)/2
x, _, _ = DIRECT.solve(wrapper,
l=[lower],
u=[upper],
maxT=n_iters*2,
maxf=n_iters)
X = X[:n_iters]
y = y[:n_iters]
fvals = np.array(y)
incs = []
incumbent_val = []
curr_inc_val = sys.float_info.max
inc = None
for i, f in enumerate(fvals):
if curr_inc_val > f:
curr_inc_val = f
inc = X[i]
def search_acq(self,cfn,sfn,volper=1e-6,dv=[[sp.NaN]]):
def directwrap(Q,extra):
x = sp.array([Q])
if self.noS:
alls = [k(x,x,dv,dv,gets=True)[1] for k in self.G.kf]
s = sp.exp(sp.mean(sp.log(alls)))
else:
s = sfn(x)
acq = PESgain(self.G,self.Ga,self.Z,x,dv,[s])
try:
#print x[0,1:],x[0,0]
R = -acq/cfn(x[0,1:],**{'xa':x[0,0]})
except TypeError:
R = -acq/cfn(x,s)
return (R,0)
#print self.lb
#print self.ub
[xmin, ymin, ierror] = DIRECT.solve(directwrap,self.lb,self.ub,user_data=[], algmethod=1, volper=volper, logfilename='/dev/null')
if False:
from matplotlib import pyplot as plt
import time
D = self.lb.size
ns=200
f,a = plt.subplots(2*D)
if self.noS:
alls = [k(xmin,xmin,dv,dv,gets=True)[1] for k in self.G.kf]
s = sp.exp(sp.mean(sp.log(alls)))
else:
s = sfn(x)
for d in xrange(D):
sup = sp.linspace(self.lb[d],self.ub[d],ns)
X = sp.vstack([xmin]*ns)
for j in xrange(ns):
X[j,d] = sup[j]
[m,v] = self.G.infer_diag_post(X,[[sp.NaN]]*ns)
sq = sp.sqrt(v)
a[d].fill_between(sup,(m-2*sq).flatten(),(m+2.*sq).flatten(),facecolor = 'lightblue',edgecolor='lightblue')
a[d].plot(sup,m.flatten())
ps = sp.empty(ns)
aps = sp.empty(ns)
for j in xrange(ns):
ps[j] = self.query_pes(X[j,:],[s],[[sp.NaN]])
if d==0:
aps[j] = ps[j]/cfn(sp.array([X[j,:].flatten()]),s)
a[d].twinx().plot(sup,ps,'r')
if d==0:
a[d].twinx().plot(sup,aps,'g')
for d in xrange(1,D):
sup = sp.linspace(self.lb[d],self.ub[d],ns)
X = sp.vstack([xmin]*ns)
for j in xrange(ns):
X[j,d] = sup[j]
X[j,0] = 0.
[m,v] = self.G.infer_diag_post(X,[[sp.NaN]]*ns)
sq = sp.sqrt(v)
a[d+D-1].fill_between(sup,(m-2*sq).flatten(),(m+2.*sq).flatten(),facecolor = 'lightblue',edgecolor='lightblue')
a[d+D-1].plot(sup,m.flatten())
ps = sp.empty(ns)
aps = sp.empty(ns)
for j in xrange(ns):
ps[j] = self.query_pes(X[j,:],[s],[[sp.NaN]])
a[d+D-1].twinx().plot(sup,ps,'r')
a[2*D-1].hist(self.X[:,0].flatten(),50,facecolor='g')
print xmin
f.savefig('../figcache/{0}.png'.format(time.time()))
#plt.show()
return [xmin,ymin,ierror]
