def run_optimization():
print('Calculating...')
t2['N'] = [len(data_calc['t'][n_d])-1 for n_d in range(info['n_data'])]
t2['n_p']=t1['n_part'].get()+1
t2['n_d']=info['n_data']
t2['dt'] = [(info['t_end'][i] - info['t_start'][i])/t2['N'][i] for i in range(info['n_data'])]
p = calc_p_num()
#for n_p in range(t2['n_p']): # add scaling factor x_t = p[-1]*x_1 + p[-2]*x_2
# p.append(1/t2['n_p']) # could set it so that x1 = p[-1],x2=1-p[-1] and they sum to one
t3['nonlinear'] = 0 #nonlinear-equation solving time
if t2['method_var'].get()=='CMA-ES':
xopt,res = cma.fmin2(of, p, 0.5,options={'tolfun':t2['maxiter'].get()})
class result:
x = xopt
fun = res.result[1]
t2['res'] = result
else:
t2['res'] = minimize(of,p,method=t2['method_var'].get(),options={'maxiter':int(t2['maxiter'].get())})
calc_from_res(t2['res'].x)
t2['p_letters'] = calc_p()
write_result(t2['p_letters'],t2['res'])
def solve_for_unitary(self, circuit, options, x0=None):
try:
import cma
except ImportError:
print(
"ERROR: Could not find cma, try running pip install quantum_synthesis[cma]",
file=sys.stderr)
sys.exit(1)
eval_func = lambda v: options.error_func(options.target,
circuit.matrix(v))
jac_func = lambda v: options.error_jac(options.target,
circuit.mat_jac(v))
initial_guess = 'np.random.rand({})'.format(
circuit.num_inputs) * 2 * np.pi if x0 is None else x0
xopt, es = cma.fmin2(eval_func,
initial_guess,
0.25, {
'verb_disp': 0,
'verb_log': 0,
'bounds': [0, 2 * np.pi]
},
restarts=2,
gradf=jac_func)
if circuit.num_inputs > 18:
raise Warning("Finished with {} evaluations".format(es.result[3]))
return (circuit.matrix(xopt), xopt)
def optimize(self, maxiter=20, max_steps=200000):
if self.dim > 1:
self.max_steps = max_steps
init_guess = [0.5] * self.dim
#init_guess = np.random.random(self.dim)
init_std = 0.25
bound = [0.0, 1.0]
print(bound)
xopt, es = cma.fmin2(self.fitness,
init_guess,
init_std,
options={
'bounds':
bound,
'maxiter':
maxiter,
'ftarget':
self.terminate_threshold,
'termination_callback':
self.termination_callback
},
callback=self.cames_callback)
print('optimized: ', repr(xopt))
else:
# 1d case, not used
candidates = np.arange(-1, 1, 0.05)
fitnesses = [self.fitness([candidate]) for candidate in candidates]
xopt = [candidates[np.argmin(fitnesses)]]
return xopt
def CMA(self, method='chi2', fitlow=None, fithigh=None, **kwargs):
"""
Perform maximum-likelihood optimization of the model using the MIGRAD routine from the MINUIT library.
:param method: Likelihood function to be optimized. Available likelihoods are 'chi2' (chi-squared) and 'cstat' (C statistic). Defaults to 'chi2'.
:type method: str
:param fitlow: Lower boundary of the active fitting radial range. If fitlow=None the entire range is used. Defaults to None
:type fitlow: float
:param fithigh: Upper boundary of the active fitting radial range. If fithigh=None the entire range is used. Defaults to None
:type fithigh: float
:param kwargs: List of arguments to be passed to the iminuit library. For instance, setting parameter boundaries, optimization options or fixing parameters.
See the iminuit documentation: https://iminuit.readthedocs.io/en/stable/index.html
"""
prof = self.profile
if prof.profile is None:
print('Error: No valid profile exists in provided object')
return
model = self.mod
if prof.psfmat is not None:
psfmat = np.transpose(prof.psfmat)
else:
psfmat = None
if method == 'chi2':
# Define the fitting algorithm
self.cost = ChiSquared(model, prof.bins, prof.ebins, prof.profile, prof.eprof, psfmat=psfmat, fitlow=fitlow,
fithigh=fithigh)
elif method == 'cstat':
if prof.counts is None:
print('Error: No count profile exists')
return
# Define the fitting algorithm
self.cost = Cstat(model, prof.bins, prof.ebins, prof.counts, prof.area, prof.effexp, prof.bkgcounts,
psfmat=psfmat, fitlow=fitlow, fithigh=fithigh)
else:
print('Unknown method ', method)
return
# Setting bounds for the variable to constrain optimization process
low_bounds, high_bounds = kwargs.get('low_bounds', 'high_bounds')
bounds = BoundTransform([low_bounds, high_bounds])
# Continuous bound handling using CMA-ES package
fitness = ComposedFunction([lambda x: self.cost(*x), bounds.transform])
# Inversion of the initial guess
x0 = bounds.inverse(np.array([kwargs[param] for param in self.mod.parnames]))
# Computing best parameters using CMA-ES
res, es = cma.fmin2(fitness, x0, 1.5, restarts=3)
xopt = bounds.transform(res)
self.mod.SetParameters(xopt)
self.mod.SetErrors(np.ones_like(xopt))
self.errors = np.ones_like(xopt)
self.mlike = es.result[1]
self.minuit = None
self.out = xopt
def find_cmaes_settings(start_sigma) -> Tuple[Any, Any]:
""" Find best settings for baseline image segmentation
using CMA-ES
"""
photos, annots = load_train_data()
photos = [p.astype(np.float32) for p in photos]
objective = partial(cmaes_metric_from_pool, photos=photos, annots=annots)
objective_wrapped = cmaes_utils.get_cmaes_params_warp(objective)
start_values = get_start_params()
return cma.fmin2(objective_wrapped, start_values, start_sigma) # xopt, es
def minimise_with_CMAES(f, lb, ub, maxeval=5000, cf=None, ftol_abs=1e-15):
# set the options
cma_options = {'bounds': [list(lb), list(ub)],
'tolfun': ftol_abs,
'maxfevals': maxeval,
'verb_disp': 0,
'verb_log': 0,
'verbose': -1,
'CMA_stds': np.abs(ub - lb),
}
if cf is None:
x0 = lambda: np.random.uniform(lb, ub)
else:
def inital_point_generator(cf, lb, ub):
def wrapper():
while True:
x = np.random.uniform(lb, ub)
if np.all(x >= lb) and np.all(x <= ub) and cf(x):
return x
return wrapper
class feas_func:
def __init__(self, cf):
self.cf = cf
self.c = 0
def __call__(self, x, f):
if self.c > 10000:
return True
is_feas = self.cf(x)
if not is_feas:
self.c += 1
return is_feas
is_feasible = feas_func(cf)
cma_options['is_feasible'] = is_feasible
x0 = inital_point_generator(cf, lb, ub)
# ignore warnings about flat fitness (i.e starting in a flat EI location)
with warnings.catch_warnings():
warnings.simplefilter('ignore')
# run CMA-ES with bipop (small and large population sizes) for up to
# 9 restarts (or until it runs out of budget)
xopt, _ = cma.fmin2(f, x0=x0, sigma0=0.25, options=cma_options,
bipop=True, restarts=9)
warnings.resetwarnings()
return xopt
def optimize(self):
try:
xopt, es = cma.fmin2(objective_function=self.objective,
x0=self.x0,
sigma0=self.sigma,
options=self.options)
best_arm = convertToArray(xopt)
success = True
except:
logger.warning('Optimization for ' + str(self.algorithm_name) +
' failed with cost function: ' +
str(self.objective.GetCostFunctionName()))
best_arm = NAN
success = False
return best_arm, success, self.objective
def cma(loss, initial_parameters, options=None):
"""Genetic optimizer based on `pycma <https://github.com/CMA-ES/pycma>`_.
Args:
loss (callable): Loss as a function of variational parameters to be
optimized.
initial_parameters (np.ndarray): Initial guess for the variational
parameters.
options (dict): Dictionary with options accepted by the ``cma``.
optimizer. The user can use ``cma.CMAOptions()`` to view the
available options.
"""
import cma
r = cma.fmin2(loss, initial_parameters, 1.7, options=options)
return r[1].result.fbest, r[1].result.xbest
def optimization_method(self, objective: Callable,
x0: Dict) -> OrderedDict:
fitted_params, _ = cma.fmin2(objective_function=objective,
x0=list(x0.values()),
restarts=self.restarts,
restart_from_best=True,
sigma0=self.sigma_cma,
options={
'ftarget':
-np.Inf,
'popsize':
self.popsize,
'maxfevals':
self.popsize * self.iterations_cma
})
return OrderedDict([(k, v) for k, v in zip(x0.keys(), fitted_params)])
def optimize(self, maxiter=20, max_steps=200000, custom_bound=None):
if self.dim > 1 or self.bayesian_opt:
self.max_steps = max_steps
if custom_bound is None:
init_guess = [0.0] * self.dim
init_std = 0.5
bound = [0.0, 1.0]
else:
init_guess = [0.5 *
(custom_bound[0] + custom_bound[1])] * self.dim
init_std = abs(0.5 * (custom_bound[0] - custom_bound[1]))
bound = [custom_bound[0], custom_bound[1]]
if self.bayesian_opt:
xs, ys, _, _, _ = bayesian_optimisation(
maxiter,
self.fitness,
bounds=np.array([bound] * self.dim),
max_steps=max_steps,
random_search=1000,
callback=self.cames_callback)
xopt = xs[np.argmin(ys)]
else:
xopt, es = cma.fmin2(self.fitness,
init_guess,
init_std,
options={
'bounds':
bound,
'maxiter':
maxiter,
'ftarget':
self.terminate_threshold,
'termination_callback':
self.termination_callback
},
callback=self.cames_callback)
print('optimized: ', repr(xopt))
else:
# 1d case, not used
candidates = np.arange(-1, 1, 0.05)
fitnesses = [self.fitness([candidate]) for candidate in candidates]
xopt = [candidates[np.argmin(fitnesses)]]
return xopt
def train(self) -> np.ndarray:
# Initialization of Thetas
print("INITIALIZING THETAS")
init_thetas = []
for k in range(self._num_rand_inits):
init_thetas.append(np.random.rand(self._dim_theta * 2))
init_thetas.append(self._behv_params)
for k in range(self._num_behv_inits - 1):
init_thetas.append(
np.random.multivariate_normal(self._behv_params, self._Sigma))
# Running CMA-ES
print("RUNNING CMA-ES NOW")
x_opt = []
c = 0
# opts = cma.CMAOptions()
# opts.set('maxiter', 5)
top_returns = []
for tht in init_thetas:
print(c)
a, b = cma.fmin2(self._evaluationFunction,
tht,
1,
options={'maxiter': 4})
x_opt.append(a)
top_returns.append(b.result[1])
c = c + 1
# Running GA
print("RUNNING GA NOW")
ga = GA(populationSize=len(x_opt),
evaluationFunction=self._evalGA,
initPopulation=x_opt,
numElite=(self._num_rand_inits + self._num_behv_inits),
min_req_pop=self._min_req_pop,
top_returns=top_returns)
ga.train()
x_opt = ga._population
return x_opt
pass
def infer_parameters(self,
y_0: float,
initial_parameters: List[float],
step_size=0.5) -> np.ndarray:
"""Infers set of parameters that minimises an objective function (so far least squares).
Arguments:
y_0 {float} -- Starting point of inderence in parameter space.
initial_parameters {[type]} -- Starting point of inference in parameter space.
Keyword Arguments:
step_size {float} -- Step-size of optimizer in parameter space. (default: {0.5})
Returns:
optimal_parameters -- Set of parameters that minimise the objective function.
"""
print('Parameters are being infered...\n')
initial_parameters.append(y_0)
self.optimal_parameters, _ = cma.fmin2(self._objective_function,
initial_parameters, step_size)
return self.optimal_parameters
def solve_for_unitary(self, circuit, options, x0=None):
try:
import cma
except ImportError:
print(
"ERROR: Could not find cma, try running pip install quantum_synthesis[cma]",
file=sys.stderr)
sys.exit(1)
eval_func = lambda v: options.error_func(options.target,
circuit.matrix(v))
initial_guess = 'np.random.rand({})*2*np.pi'.format(
circuit.num_inputs) if x0 is None else x0
xopt, _ = cma.fmin2(eval_func,
initial_guess,
0.25, {
'verb_disp': 0,
'verb_log': 0,
'bounds': [0, 2 * np.pi]
},
restarts=2)
return (circuit.matrix(xopt), xopt)
def run(params):
params.optim.save_fig = False
mp.set_start_method('spawn')
params.dataio.prefix = datetime.now().strftime("%m-%d-%Y-%H-%M-%S")
# initialize cost function
if (params.dataio.dataset_type == "nav2d"):
cost_fn = lambda theta: cost_fn_nav2d(theta, params)
# initialize theta params to be optimized
theta_vals_init = init_theta_vals(params)
# call black-box optimizer
print("Running optimizer {0}".format(params.baselines.method))
def callback_fn(x):
return callback_scipyopt(x, params)
if (params.baselines.method == "CMAES"):
xopt, es = cma.fmin2(
cost_fn, theta_vals_init, 2., {
'maxfevals': params.baselines.max_fval_calls,
'verb_disp': 1,
'bounds': [0.1, 1e6]
})
callback_fn(xopt)
else:
result_optimizer = minimize(cost_fn,
x0=theta_vals_init,
method=params.baselines.method,
callback=callback_fn)
# print final errors
theta_vals_final = result_optimizer.x
err_trans, err_rot = traj_error_final(theta_vals_final, params)
print("theta_final: {0}, err_trans: {1}, err_rot: {2}".format(
theta_vals_final, err_trans, err_rot))
def optimize_fir_HDAWG(
y,
baseline_start=100,
baseline_stop=None,
start_sample=0,
stop_sample=None,
cma_options={},
max_taps=40,
hdawg_taps=40,
):
step_response = np.concatenate((np.array([0]), y))
baseline = np.mean(y[baseline_start:baseline_stop])
x0 = [1] + (max_taps - 1) * [0]
def objective_function_fir(x):
y = step_response
zeros = np.zeros(hdawg_taps - max_taps)
x = np.concatenate((x, zeros))
yc = signal.lfilter(convert_FIR_from_HDAWG(x), 1, y)
return np.mean(np.abs(yc[1 + start_sample:stop_sample] -
baseline)) / np.abs(baseline)
return cma.fmin2(objective_function_fir, x0, 0.1, options=cma_options)
def tune_hyperparameters(KrigInfo,
xhyp_ii,
trainvar,
ubhyp=None,
lbhyp=None,
sigmacmaes=None,
scaling=None,
optimbound=None):
"""Estimate the best hyperparameters.
Extracted hyperpamaeter tuning code into a function for
parallelisation.
Args:
KrigInfo (dict): Dictionary that contains Kriging information.
xhyp_ii (nparray): starting point number ii.
ubhyp (nparray): upper bounds of hyperparams.
lbhyp (nparray): lower bounds of hyperparams.
sigmacmaes (float): initial sigma for cma-es.
scaling (list): scaling for cma-es.
optimbound: bounds for optimizer.
Returns:
bestxcand (np.array(float)): Best x candidate array
neglnlikecand (float): Negative ln-likelihood candidate
Raises:
ValueError: If a required parameter for the chosen optimizer is
missing.
"""
if KrigInfo["optimizer"] == "cmaes":
for p in (ubhyp, lbhyp, sigmacmaes, scaling):
if p is None:
raise ValueError(f'{p} must be set if optimizer is cmaes.')
bestxcand, es = cma.fmin2(
likelihood,
xhyp_ii,
sigmacmaes, {
'bounds': [lbhyp.tolist(), ubhyp.tolist()],
'scaling_of_variables': scaling,
'verb_disp': 0,
'verbose': -9
},
args=(KrigInfo, 'default', trainvar))
neglnlikecand = es.result[1]
elif KrigInfo["optimizer"] == "lbfgsb":
if optimbound is None:
raise ValueError('optimbound must be set if optimizer is lbfgsb.')
res = minimize(likelihood,
xhyp_ii,
method='L-BFGS-B',
options={'eps': 1e-03},
bounds=optimbound,
args=(KrigInfo, 'default', trainvar))
bestxcand = res.x
neglnlikecand = res.fun
elif KrigInfo["optimizer"] == "slsqp":
if optimbound is None:
raise ValueError('optimbound must be set if optimizer is slsqp.')
res = minimize(likelihood,
xhyp_ii,
method='SLSQP',
bounds=optimbound,
args=(KrigInfo, 'default', trainvar))
bestxcand = res.x
neglnlikecand = res.fun
elif KrigInfo["optimizer"] == "cobyla":
if optimbound is None:
raise ValueError('optimbound must be set if optimizer is cobyla.')
res = fmin_cobyla(likelihood,
xhyp_ii,
optimbound,
rhobeg=0.5,
rhoend=1e-4,
args=(KrigInfo, 'default', trainvar))
bestxcand = res
neglnlikecand = likelihood(res, KrigInfo, trainvar=trainvar)
else:
msg = (f"{KrigInfo['optimizer']} in KrigInfo['Optimizer'] is not "
f"recognised.")
raise KeyError(msg)
return bestxcand, neglnlikecand
import benchmarks
# https://github.com/CMA-ES/pycma
import cma
import numpy as np
x0 = np.ones((benchmarks.common_dim)) * -1
# dim 1000 kan opgelost worden met popsize 500, en sigma 0.5
options = cma.evolution_strategy.CMAOptions()
#print(options)
opt, es = cma.fmin2(benchmarks.f,
x0,
0.02,
options={
'maxfevals': 1e6,
'popsize': 48
},
bipop=False,
restarts=0)
def minimize(self, method='BFGS', options=None, compile=True):
loss = self.cost_function_fidelity
if method == 'cma':
# Genetic optimizer
import cma
r = cma.fmin2(lambda p: loss(p).numpy(), self.params, 2)
result = r[1].result.fbest
parameters = r[1].result.xbest
elif method == 'sgd':
from qibo.tensorflow.gates import TensorflowGate
circuit = self.circuit(self.training_set[0])
for gate in circuit.queue:
if not isinstance(gate, TensorflowGate):
raise RuntimeError('SGD VQE requires native Tensorflow '
'gates because gradients are not '
'supported in the custom kernels.')
sgd_options = {
"nepochs": 5001,
"nmessage": 1000,
"optimizer": "Adamax",
"learning_rate": 0.5
}
if options is not None:
sgd_options.update(options)
# proceed with the training
from qibo.config import K
vparams = K.Variable(self.params)
optimizer = getattr(K.optimizers, sgd_options["optimizer"])(
learning_rate=sgd_options["learning_rate"])
def opt_step():
with K.GradientTape() as tape:
l = loss(vparams)
grads = tape.gradient(l, [vparams])
optimizer.apply_gradients(zip(grads, [vparams]))
return l, vparams
if compile:
opt_step = K.function(opt_step)
l_optimal, params_optimal = 10, self.params
for e in range(sgd_options["nepochs"]):
l, vparams = opt_step()
if l < l_optimal:
l_optimal, params_optimal = l, vparams
if e % sgd_options["nmessage"] == 0:
print('ite %d : loss %f' % (e, l.numpy()))
result = self.cost_function(params_optimal).numpy()
parameters = params_optimal.numpy()
else:
import numpy as np
from scipy.optimize import minimize
m = minimize(lambda p: loss(p).numpy(),
self.params,
method=method,
options=options)
result = m.fun
parameters = m.x
return result, parameters
import cma
import numpy as np
objective_function = lambda x: (x[0] - 2.0)**2 + (x[1] - 5.0)**2 + (x[2] + 4.0
)**2
xopt, es = cma.fmin2(objective_function, [10.0, 5.0, 20.0], 0.5)
print('this is the solution: ', xopt)
print('so what is this ', es)
print(np.array([[1, 2, 3], [1, 2, 3]]).ndim)
def objective(x, v):
controller = NN(x).controller
trackers = []
for i in range(N_TRAIN_DIRECTIONS):
for traj in paths:
trackers.append(
[x, v, i * 2 * pi / N_TRAIN_DIRECTIONS, traj])
costs = pool.map(function_x, trackers)
return max(costs)
x = 2 * rand(1, 4 * N_NEURONS + 1)[0] - 1
res = fmin2(objective,
x,
.5,
args=(VELOCITY, ),
options={
'popsize': 256,
'bounds': [-1, 1],
'maxiter': 256
}) # 5th is mean of final sample distribution
res = res[1].result[0]
controller = NN(res).controller
trackers = []
for i in range(N_TRAIN_DIRECTIONS):
for t in paths:
traj = Trajectory(t)
orientation = i * 2 * pi / N_TRAIN_DIRECTIONS
trackers.append(
Tracker(VELOCITY, orientation, traj, controller))
traces = map(lambda x: x.run(), trackers)
for i, trace in enumerate(traces):
def batch_qEI(model, lb, ub, maxeval, q, cf):
# n_samples only used if method is 'qEIMCMC'
n_dim = lb.size
# problem bounds
lbq = np.tile(lb, q)
ubq = np.tile(ub, q)
# use the (more) analytical for a batch size of two (as it is fast enough)
if q == 2:
func = cy_qEI
# else it is impractically slow so switch to the MCMC qEI version
else:
def func(m, K, incumbent, obj_sense=-1):
return qEIMCMC(m, K, incumbent, 10**4, obj_sense)
# best seen solution
incumbent = model.Y.min()
# cma-es options setup
cma_options = {
'bounds': [list(lbq), list(ubq)],
'tolfun': 1e-15,
'maxfevals': maxeval,
'verb_log': 0,
'verbose': 1,
'verb_disp': 0,
'CMA_stds': np.abs(ubq - lbq)
}
if cf is None:
x0 = lambda: np.random.uniform(lbq, ubq)
else:
def inital_point_generator(cf, lb, ub, n_dim, q):
def wrapper():
x = np.zeros(n_dim * q, dtype='float')
for i in range(q):
while True:
v = np.random.uniform(lb, ub)
if np.all(v >= lb) and np.all(v <= ub) and cf(v):
x[i * n_dim:(i + 1) * n_dim] = v
break
return x
return wrapper
x0 = inital_point_generator(cf, lb, ub, n_dim, q)
# run CMA-ES with bipop (small and large population sizes) for up
# to 9 restarts (or until it runs out of budget)
xopt, es = cma.fmin2(qei_feval,
x0=x0,
sigma0=0.25,
options=cma_options,
args=(model, incumbent, n_dim, func, cf),
bipop=True,
restarts=9)
return np.reshape(xopt, (q, n_dim))
def run_multi_opt(kriglist,
moboInfo,
ypar,
krigconstlist=None,
cheapconstlist=None):
"""
Run the optimization of multi-objective acquisition function to find the next sampling point.
Args:
kriglist (list): A list containing Kriging instances.
moboInfo (dict): A structure containing necessary information for Bayesian optimization.
ypar (nparray): Array contains the current non-dominated solutions.
krigconstlist (list): List of Kriging object for constraints. Defaults to None.
cheapconstlist (list): List of constraints function. Defaults to None.
Expected output of the constraint functions is 1 if the constraint is satisfied and 0 if not.
The constraint functions MUST have an input of x (the decision variable to be evaluated)
Returns:
xnext (nparray): Suggested next sampling point as discovered by the optimization of the acquisition function
fnext (nparray): Optimized acquisition function
The available optimizers for the acquisition function are 'cmaes', 'lbfgsb', 'cobyla'.
Note that this function runs for both unconstrained and constrained single-objective Bayesian optimization.
"""
acquifuncopt = moboInfo["acquifuncopt"]
acquifunc = moboInfo["acquifunc"]
if acquifunc.lower() == 'ehvi':
acqufunhandle = ehvicalc
else:
raise ValueError("Acquisition function handle is not available")
if acquifuncopt.lower() == 'cmaes':
Xrand = realval(
kriglist[0].KrigInfo["lb"], kriglist[0].KrigInfo["ub"],
np.random.rand(moboInfo["nrestart"], kriglist[0].KrigInfo["nvar"]))
xnextcand = np.zeros(
shape=[moboInfo["nrestart"], kriglist[0].KrigInfo["nvar"]])
fnextcand = np.zeros(shape=[moboInfo["nrestart"]])
sigmacmaes = 1 # np.mean((KrigNewMultiInfo["ub"] - KrigNewMultiInfo["lb"]) / 6)
for im in range(0, moboInfo["nrestart"]):
if krigconstlist is None and cheapconstlist is None: # For unconstrained problem
xnextcand[im, :], es = cma.fmin2(acqufunhandle,
Xrand[im, :],
sigmacmaes, {
'verb_disp': 0,
'verbose': -9
},
args=(ypar, moboInfo,
kriglist))
fnextcand[im] = es.result[1]
else: # For constrained problem
xnextcand[im, :], es = cma.fmin2(multiconstfun,
Xrand[im, :],
sigmacmaes, {
'verb_disp': 0,
'verbose': -9
},
args=(ypar, kriglist,
moboInfo, krigconstlist,
cheapconstlist))
fnextcand[im] = es.result[1]
I = np.argmin(fnextcand)
xnext = xnextcand[I, :]
fnext = fnextcand[I]
elif acquifuncopt.lower() == 'ga':
if krigconstlist is None and cheapconstlist is None:
templst = []
if moboInfo['ehvisampling'] == 'efficient':
for ij in range(np.size(ypar, 0)):
idx = np.where(
(kriglist[0].KrigInfo["y"] == ypar[ij, 0])
& (kriglist[1].KrigInfo["y"] == ypar[ij, 1]))[0][0]
templst.append(idx)
init_seed = kriglist[0].KrigInfo["X_norm"][
templst, :] / 2 + 0.5
else:
init_seed = None
xnext, fnext, _ = uncGA(acqufunhandle,
lb=kriglist[0].KrigInfo["lb"],
ub=kriglist[0].KrigInfo["ub"],
args=(ypar, moboInfo, kriglist),
initialization=init_seed)
else:
templst = []
if moboInfo['ehvisampling'] == 'efficient':
for ij in range(np.size(ypar, 0)):
idx = np.where(
(kriglist[0].KrigInfo["y"] == ypar[ij, 0])
& (kriglist[1].KrigInfo["y"] == ypar[ij, 1]))[0][0]
templst.append(idx)
init_seed = kriglist[0].KrigInfo["X_norm"][
templst, :] / 2 + 0.5
else:
init_seed = None
xnext, fnext, _ = uncGA(multiconstfun,
lb=kriglist[0].KrigInfo["lb"],
ub=kriglist[0].KrigInfo["ub"],
args=(ypar, kriglist, moboInfo,
krigconstlist, cheapconstlist),
initialization=init_seed)
elif acquifuncopt.lower() == 'lbfgsb':
Xrand = realval(
kriglist[0].KrigInfo["lb"], kriglist[0].KrigInfo["ub"],
np.random.rand(moboInfo["nrestart"], kriglist[0].KrigInfo["nvar"]))
xnextcand = np.zeros(
shape=[moboInfo["nrestart"], kriglist[0].KrigInfo["nvar"]])
fnextcand = np.zeros(shape=[moboInfo["nrestart"]])
lbfgsbbound = np.hstack((kriglist[0].KrigInfo["lb"].reshape(-1, 1),
kriglist[0].KrigInfo["ub"].reshape(-1, 1)))
for im in range(0, moboInfo["nrestart"]):
if krigconstlist is None and cheapconstlist is None: # For unconstrained problem
res = minimize(acqufunhandle,
Xrand[im, :],
method='L-BFGS-B',
bounds=lbfgsbbound,
args=(ypar, moboInfo, kriglist))
xnextcand[im, :] = res.x
fnextcand[im] = res.fun
else: # For constrained problem
res = minimize(multiconstfun,
Xrand[im, :],
method='L-BFGS-B',
bounds=lbfgsbbound,
args=(ypar, kriglist, moboInfo, krigconstlist,
cheapconstlist))
xnextcand[im, :] = res.x
fnextcand[im] = res.fun
I = np.argmin(fnextcand)
xnext = xnextcand[I, :]
fnext = fnextcand[I]
elif acquifuncopt.lower() == 'diff_evo':
if moboInfo['ehvisampling'] == 'efficient':
init_seed = efficientsamp(kriglist, ypar, npop=300)
else:
init_seed = 'latinhypercube'
optimbound = np.hstack((kriglist[0].KrigInfo["lb"].reshape(-1, 1),
kriglist[0].KrigInfo["ub"].reshape(-1, 1)))
if krigconstlist is None and cheapconstlist is None: # For unconstrained problem
res = differential_evolution(acqufunhandle,
optimbound,
init=init_seed,
args=(ypar, moboInfo, kriglist))
xnext = res.x
fnext = res.fun
else:
res = differential_evolution(multiconstfun,
optimbound,
init=init_seed,
args=(ypar, kriglist, moboInfo,
krigconstlist, cheapconstlist))
xnext = res.x
fnext = res.fun
elif acquifuncopt.lower() == 'cobyla':
Xrand = realval(
kriglist[0].KrigInfo["lb"], kriglist[0].KrigInfo["ub"],
np.random.rand(moboInfo["nrestart"], kriglist[0].KrigInfo["nvar"]))
xnextcand = np.zeros(
shape=[moboInfo["nrestart"], kriglist[0].KrigInfo["nvar"]])
fnextcand = np.zeros(shape=[moboInfo["nrestart"]])
optimbound = []
for i in range(len(kriglist[0].KrigInfo["ub"])):
optimbound.append(lambda x, cc, kriglist, dd, aa, bb, itemp=i: x[
itemp] - kriglist[0].KrigInfo["lb"][itemp])
optimbound.append(lambda x, cc, kriglist, dd, aa, bb, itemp=i:
kriglist[0].KrigInfo["ub"][itemp] - x[itemp])
for im in range(0, moboInfo["nrestart"]):
if krigconstlist is None and cheapconstlist is None: # For unconstrained problem
res = fmin_cobyla(acqufunhandle,
Xrand[im, :],
optimbound,
rhobeg=0.5,
rhoend=1e-4,
args=(ypar, moboInfo, kriglist))
xnextcand[im, :] = res
fnextcand[im] = acqufunhandle(res, ypar, moboInfo, kriglist)
else:
res = fmin_cobyla(multiconstfun,
Xrand[im, :],
optimbound,
rhobeg=0.5,
rhoend=1e-4,
args=(ypar, kriglist, moboInfo,
krigconstlist, cheapconstlist))
xnextcand[im, :] = res
fnextcand[im] = multiconstfun(res, ypar, kriglist, moboInfo,
krigconstlist, cheapconstlist)
I = np.argmin(fnextcand)
xnext = xnextcand[I, :]
fnext = fnextcand[I]
return xnext, fnext
def run_single_opt(krigobj, soboInfo, krigconstlist=None, cheapconstlist=None):
"""
Run the optimization of multi-objective acquisition function to find the next sampling point.
Args:
krigobj (object): Kriging object.
soboInfo (dict): A structure containing necessary information for Bayesian optimization.
krigconstlist (list): List of Kriging object for constraints. Defaults to None.
cheapconstlist (list): List of constraints function. Defaults to None.
Expected output of the constraint functions is 1 if the constraint is satisfied and 0 if not.
The constraint functions MUST have an input of x (the decision variable to be evaluated)
Returns:
xnext (nparray): Suggested next sampling point as discovered by the optimization of the acquisition function
fnext (nparray): Optimized acquisition function
The available optimizers for the acquisition function are 'cmaes', 'lbfgsb', 'cobyla'.
Note that this function runs for both unconstrained and constrained single-objective Bayesian optimization.
"""
acquifuncopt = soboInfo["acquifuncopt"]
acquifunc = soboInfo["acquifunc"]
if acquifunc.lower() == 'parego':
acquifunc = soboInfo['paregoacquifunc']
else:
pass
if acquifuncopt.lower() == 'cmaes':
Xrand = realval(
krigobj.KrigInfo["lb"], krigobj.KrigInfo["ub"],
np.random.rand(soboInfo["nrestart"], krigobj.KrigInfo["nvar"]))
xnextcand = np.zeros(
shape=[soboInfo["nrestart"], krigobj.KrigInfo["nvar"]])
fnextcand = np.zeros(shape=[soboInfo["nrestart"]])
sigmacmaes = 1 # np.mean((KrigNewMultiInfo["ub"] - KrigNewMultiInfo["lb"]) / 6)
for im in range(0, soboInfo["nrestart"]):
if krigconstlist is None and cheapconstlist is None: # For unconstrained problem
xnextcand[im, :], es = cma.fmin2(krigobj.predict,
Xrand[im, :],
sigmacmaes, {
'verb_disp': 0,
'verbose': -9
},
args=(acquifunc))
fnextcand[im] = es.result[1]
else: # For constrained problem
xnextcand[im, :], es = cma.fmin2(singleconstfun,
Xrand[im, :],
sigmacmaes, {
'verb_disp': 0,
'verbose': -9
},
args=(krigobj, acquifunc,
krigconstlist,
cheapconstlist))
fnextcand[im] = es.result[1]
I = np.argmin(fnextcand)
xnext = xnextcand[I, :]
fnext = fnextcand[I]
elif acquifuncopt.lower() == 'lbfgsb':
Xrand = realval(
krigobj.KrigInfo["lb"], krigobj.KrigInfo["ub"],
np.random.rand(soboInfo["nrestart"], krigobj.KrigInfo["nvar"]))
xnextcand = np.zeros(
shape=[soboInfo["nrestart"], krigobj.KrigInfo["nvar"]])
fnextcand = np.zeros(shape=[soboInfo["nrestart"]])
lbfgsbbound = np.hstack((krigobj.KrigInfo["lb"].reshape(-1, 1),
krigobj.KrigInfo["ub"].reshape(-1, 1)))
for im in range(0, soboInfo["nrestart"]):
if krigconstlist is None and cheapconstlist is None: # For unconstrained problem
res = minimize(krigobj.predict,
Xrand[im, :],
method='L-BFGS-B',
bounds=lbfgsbbound,
args=(acquifunc))
xnextcand[im, :] = res.x
fnextcand[im] = res.fun
else: # For constrained problem (on progress)
res = minimize(singleconstfun,
Xrand[im, :],
method='L-BFGS-B',
bounds=lbfgsbbound,
args=(krigobj, acquifunc, krigconstlist,
cheapconstlist))
xnextcand[im, :] = res.x
fnextcand[im] = res.fun
I = np.argmin(fnextcand)
xnext = xnextcand[I, :]
fnext = fnextcand[I]
elif acquifuncopt.lower() == 'diff_evo':
xnextcand = np.zeros(
shape=[soboInfo["nrestart"], krigobj.KrigInfo["nvar"]])
fnextcand = np.zeros(shape=[soboInfo["nrestart"]])
optimbound = np.hstack((krigobj.KrigInfo["lb"].reshape(-1, 1),
krigobj.KrigInfo["ub"].reshape(-1, 1)))
for im in range(0, soboInfo["nrestart"]):
if krigconstlist is None and cheapconstlist is None: # For unconstrained problem
res = differential_evolution(krigobj.predict,
optimbound,
args=(acquifunc, ))
xnextcand[im, :] = res.x
fnextcand[im] = res.fun
else:
res = differential_evolution(singleconstfun,
optimbound,
args=(krigobj, acquifunc,
krigconstlist,
cheapconstlist))
xnextcand[im, :] = res.x
fnextcand[im] = res.fun
I = np.argmin(fnextcand)
xnext = xnextcand[I, :]
fnext = fnextcand[I]
elif acquifuncopt.lower() == 'cobyla':
Xrand = realval(
krigobj.KrigInfo["lb"], krigobj.KrigInfo["ub"],
np.random.rand(soboInfo["nrestart"], krigobj.KrigInfo["nvar"]))
xnextcand = np.zeros(
shape=[soboInfo["nrestart"], krigobj.KrigInfo["nvar"]])
fnextcand = np.zeros(shape=[soboInfo["nrestart"]])
optimbound = []
for i in range(len(krigobj.KrigInfo["ub"])):
optimbound.append(lambda x, krigobj, aa, bb, cc, itemp=i: x[itemp]
- krigobj.KrigInfo["lb"][itemp])
optimbound.append(lambda x, krigobj, aa, bb, cc, itemp=i: krigobj.
KrigInfo["ub"][itemp] - x[itemp])
for im in range(0, soboInfo["nrestart"]):
if krigconstlist is None and cheapconstlist is None: # For unconstrained problem
res = fmin_cobyla(krigobj.predict,
Xrand[im, :],
optimbound,
rhobeg=0.5,
rhoend=1e-4,
args=(acquifunc))
xnextcand[im, :] = res
fnextcand[im] = krigobj.predict(res, acquifunc)
else:
res = fmin_cobyla(singleconstfun,
Xrand[im, :],
optimbound,
rhobeg=0.5,
rhoend=1e-4,
args=(krigobj, acquifunc, krigconstlist,
cheapconstlist))
xnextcand[im, :] = res
fnextcand[im] = singleconstfun(res, krigobj, acquifunc,
krigconstlist, cheapconstlist)
I = np.argmin(fnextcand)
xnext = xnextcand[I, :]
fnext = fnextcand[I]
return (xnext, fnext)
TRAJ_LEN = 10
MIN_DIST = 2
DIM = GOAL_VEL.shape[1]
num_opt_vars = AGENTS * TRAJ_LEN * DIM # the amount of variables to be optimized via cma
error_calc = ErrorCalculator(TIMESTEP, TRAJ_LEN, MIN_DIST, START_VEL, START_POS, GOAL_VEL, GOAL_POS)
options = cma.CMAOptions()
options.set('ftarget', 1e-1)
options.set('bounds', [-MAX_JERK, MAX_JERK])
# es = cma.CMAEvolutionStrategy(num_opt_vars * [0], 0.5, options)
# es.opts.set('opt', value) # use this for chaning options while running
# es.optimize(error_calc.get_error)
# xbest = es.result[0]
xbest = cma.fmin2(error_calc.getError, num_opt_vars * [0], 0.5, options)[0]
print("\n### FINAL ERROR #############################################")
print(error_calc.getError(xbest))
print("\n### FINAL JERK TRAJECTORY #############################################")
print(error_calc.jerk_traj)
print("\n### FINAL ACC TRAJECTORY #############################################")
print(error_calc.acc_traj)
print("\n### FINAL VEL TRAJECTORY #############################################")
print(error_calc.vel_traj)
print("\n### FINAL POS TRAJECTORY #############################################")
print(error_calc.pos_traj)
path = os.path.join(sys.path[0], "trajectories")
np.save(path + "/jerk_traj.npy", error_calc.jerk_traj)
def train(self):
"""
Learn your (final) policy.
Use evolution strategy algortihm CMA-ES: https://pypi.org/project/cma/
Possible action: [0, 1, 2]
Range observation (tuple):
- position: [-1.2, 0.6]
- velocity: [-0.07, 0.07]
"""
def policy_action(position, velocity, policy):
'''Fonction that returns the action given a state and a policy'''
i_position, i_velocity = get_discretized_env(position, velocity)
# print(i_position, i_velocity)
action = policy[i_position][i_velocity]
return action
def get_discretized_env(position, velocity, velocities=self.velocities, positions=self.positions):
'''Fonction that give the indices to look for in the discretized position and velocity space'''
i = 0
while velocity > velocities[i]:
i += 1
velocity_index = i
j = 0
while position > positions[j]:
j += 1
position_index = j
return position_index, velocity_index
env = Environment()
# For debug purposes
self.min_value = 999999999
def obj_function(policy):
''' Fonction that takes a policy and run it on 200 steps of the environement. It returns the fitness of the policy.
'''
env.reset()
iter_counter = 0
x = policy.reshape(self.positions.shape[0]*self.velocities.shape[0], -1)
x = np.floor(x)
d_policy = x.reshape(self.positions.shape[0], self.velocities.shape[0])
distances = []
distance_mid = []
energy = []
malus = 200
for i in range(200):
# env.render()
# We take an action according to the given policy
position, velocity = env.state
distances.append(np.absolute(0.6 - position))
distance_mid.append(np.absolute(-0.56 - position))
energy.append(0.5*(velocity**2))
if position == 0.6:
# If we enter here we won the game
malus = (i / 200) * 200
value = -sum(distance_mid) -max(energy) + malus + min(distances)*50 - (np.absolute(min(distances) - max(distances))*100)
# For debug purposes :
if value < self.min_value:
self.min_value = value
print('New best value = '+str(self.min_value))
return value
action = policy_action(position, velocity, d_policy)
_, _ = env.act(int(np.floor(action)))
value = -sum(distance_mid)-max(energy) + malus + min(distances)*50 -(np.absolute(min(distances) - max(distances))*100)
# For debug purposes :
if value < self.min_value:
self.min_value = value
print('New best value = '+str(self.min_value))
return value
# We launch a cma-es to find a policy that minimizes the ojective function value
# We decided to fix the ftarget value so it doest take too long too run but we could remove it
# to optimize the function even more
best_policy, _ = cma.fmin2(obj_function, self.init, 2,{
#'BoundaryHandler': 'BoundPenalty',
'BoundaryHandler': 'BoundTransform',
'bounds':[0,3],
'verbose':1,
'ftarget':-100,
'seed': 237591
})
print("Optimization FINISHED")
#self.policy = best_policy
self.b_policy = best_policy
self.policy = np.floor(best_policy).reshape(self.positions.shape[0], self.velocities.shape[0])
print("Best Policy updated"+str(self.policy))
def run_single_opt(krigobj,
soboInfo,
krigconstlist=None,
cheapconstlist=None,
pool=None):
"""
Optimize the single-objective acquisition function to find the next
sampling point.
The available optimizers for the acquisition functions are:
'cmaes', 'lbfgsb', 'diff_evo', 'cobyla'
Note that this function runs for both unconstrained and constrained
single-objective Bayesian optimization.
Args:
krigobj (kriging_model.Kriging): Objective Kriging instance.
soboInfo (dict): A structure containing necessary information
for Bayesian optimization.
krigconstlist ([kriging_model.Kriging], optional): Kriging
instances for constraints. Defaults to None.
cheapconstlist ([func], optional): Constraint functions.
Defaults to None. Expected output of the constraint
functions is 1 if satisfied and 0 if not.
The constraint functions MUST have an input of x (the
decision variable to be evaluated).
pool (mp.Pool, optional): An existing mp.Pool instance can be
specified and passed to solvers/acquisition functions for
multiprocessing, if supported. Default is None.
Returns:
xnext (np.ndarray): n_dv-len array of suggested next sampling
point as discovered by the optimization of the acquisition
function.
fnext (np.ndarray): n_obj-len array of optimized acquisition
function fitness metrics.
"""
acquifuncopt = soboInfo["acquifuncopt"]
acquifunc = soboInfo["acquifunc"]
if acquifunc.lower() == 'parego':
acquifunc = soboInfo['paregoacquifunc']
else:
# Seems like string is passed stright to prediction.prediction
pass
n_restart = soboInfo["nrestart"]
n_var = krigobj.KrigInfo["nvar"]
low_bound = krigobj.KrigInfo["lb"]
up_bound = krigobj.KrigInfo["ub"]
xnextcand = np.zeros(shape=[n_restart, n_var])
fnextcand = np.zeros(shape=[n_restart])
if acquifuncopt.lower() == 'cmaes':
Xrand = realval(low_bound, up_bound, np.random.rand(n_restart, n_var))
sigmacmaes = 1 # np.mean((KrigNewMultiInfo["ub"] - KrigNewMultiInfo["lb"]) / 6)
for im in range(0, n_restart):
if krigconstlist is None and cheapconstlist is None: # For unconstrained problem
xnextcand[im, :], es = cma.fmin2(krigobj.predict,
Xrand[im, :],
sigmacmaes, {
'verb_disp': 0,
'verbose': -9
},
args=(acquifunc))
fnextcand[im] = es.result[1]
else: # For constrained problem
xnextcand[im, :], es = cma.fmin2(singleconstfun,
Xrand[im, :],
sigmacmaes, {
'verb_disp': 0,
'verbose': -9
},
args=(krigobj, acquifunc,
krigconstlist,
cheapconstlist))
fnextcand[im] = es.result[1]
elif acquifuncopt.lower() == 'lbfgsb':
Xrand = realval(low_bound, up_bound, np.random.rand(n_restart, n_var))
lbfgsbbound = np.hstack(
(low_bound.reshape(-1, 1), up_bound.reshape(-1, 1)))
for im in range(0, n_restart):
if krigconstlist is None and cheapconstlist is None: # For unconstrained problem
res = minimize(krigobj.predict,
Xrand[im, :],
method='L-BFGS-B',
bounds=lbfgsbbound,
args=(acquifunc))
xnextcand[im, :] = res.x
fnextcand[im] = res.fun
else: # For constrained problem (on progress)
res = minimize(singleconstfun,
Xrand[im, :],
method='L-BFGS-B',
bounds=lbfgsbbound,
args=(krigobj, acquifunc, krigconstlist,
cheapconstlist))
xnextcand[im, :] = res.x
fnextcand[im] = res.fun
elif acquifuncopt.lower() == 'diff_evo':
if 'de_kwargs' in soboInfo:
de_kwargs = soboInfo['de_kwargs']
else:
de_kwargs = {}
de_kwargs['init'] = de_kwargs.get('init', 'latinhypercube')
optimbound = list(zip(low_bound, up_bound))
de_args = (singleconstfun, optimbound)
if 'constraints' in de_kwargs:
cheapconstlist = None # DE handles cheap constraint functions directly
args = (krigobj, acquifunc, krigconstlist, cheapconstlist, None, 'inf')
de_kwargs['args'] = args
if pool is not None:
workers = pool.map
# TODO: Check - we shouldn't need this fix anymore
# # If MP, set n_cpu to 1 to stop pool in EHVI - pass in existing pool
# soboInfo['n_cpu'] = 1
else:
workers = 1 # Default DE flag
for im in range(n_restart):
r_t = time.time()
res = differential_evolution(*de_args,
**de_kwargs,
workers=workers)
xnextcand[im, :] = res.x
fnextcand[im] = res.fun
print_res(r_t,
res.fun,
res.x,
success=res.success,
msg=res.message,
n_eval=res.nfev,
n_gen=res.nit,
i_restart=im,
n_restart=n_restart)
elif acquifuncopt.lower() == 'cobyla':
Xrand = realval(low_bound, up_bound, np.random.rand(n_restart, n_var))
optimbound = []
for i in range(len(up_bound)):
optimbound.append(lambda x, krigobj, aa, bb, cc, itemp=i: x[itemp]
- krigobj.KrigInfo["lb"][itemp])
optimbound.append(lambda x, krigobj, aa, bb, cc, itemp=i: krigobj.
KrigInfo["ub"][itemp] - x[itemp])
for im in range(0, n_restart):
if krigconstlist is None and cheapconstlist is None: # For unconstrained problem
res = fmin_cobyla(krigobj.predict,
Xrand[im, :],
optimbound,
rhobeg=0.5,
rhoend=1e-4,
args=(acquifunc))
xnextcand[im, :] = res
fnextcand[im] = krigobj.predict(res, acquifunc)
else:
res = fmin_cobyla(singleconstfun,
Xrand[im, :],
optimbound,
rhobeg=0.5,
rhoend=1e-4,
args=(krigobj, acquifunc, krigconstlist,
cheapconstlist))
xnextcand[im, :] = res
fnextcand[im] = singleconstfun(res, krigobj, acquifunc,
krigconstlist, cheapconstlist)
I = np.argmin(fnextcand)
xnext = xnextcand[I, :]
fnext = fnextcand[I]
return (xnext, fnext)
def minimize(self, method='BFGS', options=None, compile=True):
loss = self.cost_function_fidelity
if method == 'cma':
# Genetic optimizer
import cma
r = cma.fmin2(lambda p: K.to_numpy(loss(p)), self.params, 2)
result = r[1].result.fbest
parameters = r[1].result.xbest
elif method == 'sgd':
circuit = self.circuit(self.training_set[0])
for gate in circuit.queue:
if not K.supports_gradients:
from qibo.config import raise_error
raise_error(
RuntimeError,
'Use tensorflow backend in order to compute gradients.'
)
sgd_options = {
"nepochs": 5001,
"nmessage": 1000,
"optimizer": "Adamax",
"learning_rate": 0.5
}
if options is not None:
sgd_options.update(options)
# proceed with the training
vparams = K.Variable(self.params)
optimizer = getattr(K.optimizers, sgd_options["optimizer"])(
learning_rate=sgd_options["learning_rate"])
def opt_step():
with K.GradientTape() as tape:
l = loss(vparams)
grads = tape.gradient(l, [vparams])
optimizer.apply_gradients(zip(grads, [vparams]))
return l, vparams
if compile:
opt_step = K.function(opt_step)
l_optimal, params_optimal = 10, self.params
for e in range(sgd_options["nepochs"]):
l, vparams = opt_step()
if l < l_optimal:
l_optimal, params_optimal = l, vparams
if e % sgd_options["nmessage"] == 0:
print('ite %d : loss %f' % (e, K.to_numpy(l)))
result = K.to_numpy(self.cost_function(params_optimal))
parameters = K.to_numpy(params_optimal)
else:
import numpy as np
from scipy.optimize import minimize
m = minimize(lambda p: K.to_numpy(loss(p)),
self.params,
method=method,
options=options)
result = m.fun
parameters = m.x
return result, parameters
square = np.vectorize(lambda x: x**2)
X = np.random.randint(low=0, high=3, size=10)
#X = [5 for _ in range(200)]
print(X)
def obj_fun(X):
X = square(X)
return X.sum()
print(obj_fun(X))
solution, d = cma.fmin2(
obj_fun, X, 1, {
'BoundaryHandler': 'BoundTransform',
'bounds': [0, 3],
'popsize': 1000,
'CMA_mu': 10,
'ftarget': 2
})
print(d)
solution = np.floor(solution)
print(solution)
# cma.fmin(obj_fun, X, 0.2, {'boundary_handling': 'BoundPenalty',
# 'bounds':[0,3],
# })
def optimize_acqf_cmaes_cf(acq, cf, problem_bounds, budget):
import numpy as np
import cma
import warnings
def inital_point_generator(cf, lb, ub):
def wrapper():
while True:
x = np.random.uniform(lb, ub)
if np.all(x >= lb) and np.all(x <= ub) and cf(x):
return x
return wrapper
def acq_wrapper(acq, cf):
got_cf = cf is not None
def func(X):
if isinstance(X, list):
X = np.reshape(np.array(X), (len(X), -1))
# convert to torch
Xt = torch.from_numpy(X).unsqueeze(-2)
# evaluate and negate because CMA-ES minimise
Y = -acq(Xt) # minus as CMA-ES minimises
# convert back to numpy and then to list (for CMA-ES)
y = Y.double().numpy().ravel().tolist()
# evaluate constraint function for each decision vector
if got_cf:
for i, x in enumerate(X):
if not cf(x):
y[i] = np.inf
# CMA-ES expects a float if it gives one decision vector
if len(y) == 1:
return y[0]
return y
return func
lb = problem_bounds[0].numpy()
ub = problem_bounds[1].numpy()
cma_options = {'bounds': [list(lb), list(ub)],
'tolfun': 1e-7,
'maxfevals': budget,
'verb_disp': 0,
'verb_log': 0,
'verbose': -1,
'CMA_stds': np.abs(ub - lb),
}
x0 = inital_point_generator(cf, lb, ub)
f = acq_wrapper(acq, cf)
# ignore warnings about flat fitness (i.e starting in a flat EI location)
with torch.no_grad(), warnings.catch_warnings():
warnings.simplefilter('ignore')
xopt, es = cma.fmin2(objective_function=None,
parallel_objective=f,
x0=x0, sigma0=0.25, options=cma_options,
bipop=True, restarts=9)
warnings.resetwarnings()
train_xnew = torch.from_numpy(es.best.x).unsqueeze(0)
acq_f = -torch.from_numpy(np.array(es.best.f))
return train_xnew, acq_f
def main(K, population_size, nbre_iteration) :
# K(Kp, Ki, Kd) is a vector of parameters of pid controller
# run the optimisation
# cma.fmin2(objective function, initial solutions, Initial sigma, options={'maxiter': nbre_iteration, 'bounds': [[0, 0, 0], [50, 50, 50]],'popsize':population_size})
best_solution, best_fitness = cma.fmin2(cma_optimize, [K[0], K[1],K[2]], 15, options={'maxiter': nbre_iteration, 'bounds': [[0, 0, 0], [50, 50, 50]],'popsize':population_size})
print("best solution :", best_solution) # print the solutions of the optimization
