def runSingleSplit_pycma(fid, dim, iids=[1, 2, 3, 4, 5], num_reps=5):
"""
Function running single-split CMA-ES.
:param fid: The function id (from bbob)
:param dim: The dimension to run the bbob-problem in
:param rep1: The configuration to run before the splitpoint
:param rep2: The configuration to run after the splitpoint
:param split_idx: The splitpoint-index at which to switch between rep1 and rep2
:param iids: The instances of the bbob-function to run
:param num_reps: The amount of repetitions to run
:return: The ERT over all num_reps runs on all instances in iids
"""
obs = create_observer("Pycma", None, None)
suite = cocoex.Suite("bbob", "", f"dimensions:{dim}")
HittingTimes = []
for i, iid in enumerate(iids):
for j in range(num_reps):
fitness_function = suite.get_problem_by_function_dimension_instance(
fid, dim, iid)
fitness_function.observe_with(obs)
f = fitnessFunc(fitness_function)
cma = CMAEvolutionStrategy([0] * 5, 0.5)
cma.optimize(f)
HittingTimes.append(cma.result.evaluations)
print(cma.result.xbest)
fitness_function.free()
return np.mean(HittingTimes)
def create_optimizer(self):
from cma import CMAEvolutionStrategy
opts = {'bounds': self.bounds}
stddevs = (self.param_space.param_uppers - self.param_space.
param_lowers) * self.stddev + self.param_space.param_lowers
optimizer = CMAEvolutionStrategy(self.init_guess,
np.amin(stddevs),
inopts=opts)
_ = optimizer.optimize(self._priv_evaluator)
self.is_converged = True
def otimizar(self):
lw = [0.0, 0.0, 0.0]
up = [1.0, 1.0, 1.0]
x0 = 3 * [0.1]
sigma = 0.25
# Otimizando
c = CMAEvolutionStrategy(x0, sigma, {'bounds': [lw, up]})
self.iniciar_tempo()
c.optimize(self.func_objetivo, iterations=self.num_chamadas)
self.finalizar_tempo()
# Extraindo os melhores hiperparametros
C_ = 2 ** (-5 + c.best.x[0] * 20)
gamma_ = 2 ** (-15 + c.best.x[1] * 18)
epsilon_ = abs(c.best.x[2])
# Treinando SVM final com os parâmetros encontrados
self.svm = SVM(gamma_, C_, epsilon_)
self.svm.treinar(self.X_treinamento, self.Y_treinamento)
self.svm.testar(self.X_teste, self.Y_teste)
def example_cma():
def yangs4(x):
# f = (a-b).c
a = np.sum(np.square(np.sin(x)))
b = np.exp(-np.sum(np.square(x)))
c = np.exp(-np.sum(np.square(np.sin(np.sqrt(np.abs(x))))))
return (a - b) * c
n = 5
x0 = n * [0.1]
sigma0 = 0.1
# evolution strategy
es = CMAEvolutionStrategy(x0, sigma0)
optSol = es.optimize(yangs4)
def cma(fun, budget):
sigma0 = 0.02
range_ = fun.upper_bounds - fun.lower_bounds
center = fun.lower_bounds + range_ / 2
x0 = center
options = dict(scaling=range_ / range_[0],
maxfevals=budget,
verb_log=0,
verb_disp=1,
verbose=1)
es = CMAEvolutionStrategy(x0, sigma0 * range_[0], options)
res = es.optimize(fun).result()
xbest, ybest, nbeval, *rest = res
return xbest, ybest, nbeval
def main():
bias0 = [0.0, -3.0] * total_biases
weight0 = [0.0, -3.0] * total_weights
x0 = bias0
x0.extend(weight0)
# assert(len(x0) == 108)
sigma0 = 0.1
# evolution strategy
es = CMAEvolutionStrategy(x0, sigma0)
optSol = es.optimize(regression_problem)
print(optSol)
sol = [-3.18979598e-02, 1.21945777e+00, 3.80408518e-02,
7.99747577e-01, 9.51714572e-02, 8.10528673e-01, -5.97132372e-02,
1.04204663e+00, 1.74305244e-02, 9.93532532e-01, -8.67464165e-02,
9.51615254e-01, -3.77311791e-02, 9.97444596e-01, -5.84591048e-03,
1.08793924e+00, -5.59697903e-02, 9.51347690e-01, 3.33323542e-02,
1.00693954e+00]
def attack(self, image, target_class, limit):
"""
TODO: Write Comment
"""
bounds, initial = self.get_bounds(image, limit)
def predict_fn(xs):
return self.predict_classes(xs, image, target_class)
def callback_fn(x, convergence=None):
if self.es == 0:
if self.attack_success(x.result[0], image, target_class):
raise Exception(
'Attack Completed :) Earlier than expected')
else:
return self.attack_success(x, image, target_class)
if self.es == 0:
opts = CMAOptions()
if not self.verbose:
opts.set('verbose', -9)
opts.set('verb_disp', 40000)
opts.set('verb_log', 40000)
opts.set('verb_time', False)
opts.set('bounds', bounds)
if self.type_attack == 0:
std = 63
else:
std = limit
es = CMAEvolutionStrategy(initial, std / 4, opts)
try:
es.optimize(
predict_fn,
maxfun=max(
1,
400 //
len(bounds)) *
len(bounds) *
100,
callback=callback_fn)
except Exception as e:
if self.verbose:
print(e)
pass
adv_x = es.result[0]
else:
es = differential_evolution(
predict_fn,
bounds,
disp=self.verbose,
maxiter=100,
popsize=max(
1,
400 // len(bounds)),
recombination=1,
atol=-1,
callback=callback_fn,
polish=False)
adv_x = es.x
if self.attack_success(adv_x, image, target_class):
return True, self.perturb_image(adv_x, image)[0]
else:
return False, image