def test_cma_cordinated_retry(dim=6):
# coordinated retry with CMA-ES optimizer with reduced popsize
# faster for small dimension, use default for dim > 12
return advretry.minimize(obj_f_c,
bounds(dim),
logger=logger(),
optimizer=Cma_cpp(2000, popsize=13))
def test_gclde_cordinated_retry(dim=6):
# coordinated retry with GCLDE->CMA sequence optimizer
return advretry.minimize(obj_f_c,
bounds(dim),
logger=logger(),
optimizer=Sequence(
[GCLDE_cpp(750),
Cma_cpp(750, popsize=13)]))
def test_gclde_cordinated_retry(problem):
# coordinated retry with GCLDE->CMA sequence optimizer
return advretry.minimize(problem.fun,
problem.bounds,
logger=logger(),
optimizer=Sequence(
[GCLDE_cpp(750),
Cma_cpp(750, popsize=13)]))
def test_advretry_cma_python(problem, value_limit, num):
best = math.inf
t0 = time.perf_counter();
for i in range(num):
ret = advretry.minimize(problem.fun, bounds = problem.bounds, num_retries = 4000,
optimizer = Cma_python(2000), value_limit = value_limit)
best = min(ret.fun, best)
print("{0}: time = {1:.1f} best = {2:.1f} f(xmin) = {3:.1f}"
.format(i+1, dtime(t0), best, ret.fun))
def messengerFullLoop():
while True:
problem = MessFull()
logger().info(problem.name + ' de + cmaes c++')
ret = minimize(problem.fun,
bounds=problem.bounds,
num_retries=60000,
value_limit=10.0,
logger=logger())
def test_optimizer_adv(fun, n):
best = math.inf
t0 = time.perf_counter()
for i in range(n):
max_x = i + 12
bounds = Bounds(lowerbound, [max_x + 0.99] * 4)
ret = advretry.minimize(fun,
bounds,
min_evaluations=5000,
num_retries=100)
best = print_result(ret, best, t0, max_x)
def test_advretry(problem, value_limit, num):
best = math.inf
t0 = time.perf_counter()
for i in range(num):
ret = advretry.minimize(problem.fun,
bounds=problem.bounds,
num_retries=4000,
value_limit=value_limit,
statistic_num=5000,
logger=logger())
best = min(ret.fun, best)
print("{0}: time = {1:.1f} best = {2:.1f} f(xmin) = {3:.1f}".format(
i + 1, dtime(t0), best, ret.fun))
def test_optimizer(opt,
problem,
num_retries=120000,
num=100,
value_limit=10.0,
log=logger()):
log.info(problem.name + ' ' + opt.name)
for _ in range(num):
ret = advretry.minimize(problem.fun,
problem.bounds,
value_limit,
num_retries,
log,
optimizer=opt)
def _test_optimizer(opt,
problem,
num_retries=10000,
num=1,
value_limit=100.0,
stop_val=-1E99,
log=logger()):
log.info("Testing coordinated retry " + opt.name + ' ' + problem.name)
for _ in range(num):
ret = minimize(problem.fun,
problem.bounds,
value_limit,
num_retries,
log,
optimizer=opt,
stop_fitness=stop_val)
def test_eggholder_advanced_retry():
dim = 2
testfun = Eggholder()
limit = -956
for _ in range(5):
wrapper = Wrapper(testfun.fun, dim)
ret = advretry.minimize(wrapper.eval, testfun.bounds, num_retries=300)
if limit > ret.fun:
break
assert (limit > ret.fun) # optimization target not reached
assert (ret.nfev == wrapper.get_count()
) # wrong number of function calls returned
assert (almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
assert (almost_equal(ret.fun,
wrapper.get_best_y())) # wrong best y returned
def test_eggholder_advanced_retry():
#windows cannot pickle function objects
if sys.platform.startswith('windows'):
return
dim = 2
testfun = Eggholder()
limit = -956
for i in range(5):
wrapper = Wrapper(testfun.func, dim)
ret = advretry.minimize(wrapper.eval,
testfun.bounds,
num_retries=300,
useCpp=False,
logger=None)
if limit > ret.fun:
break
assert (limit > ret.fun) # optimization target not reached
assert (ret.nfev == wrapper.get_count()
) # wrong number of function calls returned
assert (almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
assert (ret.fun == wrapper.get_best_y()) # wrong best y returned
def smart_retry(opt=De_cpp(1500)):
return advretry.minimize(fitness(),
bounds,
optimizer=opt,
num_retries=50000,
max_eval_fac=20)
def _test_problem(problem, num_retries = 4000, num = 20, value_limit = 12.0,
log = logger(), useCpp = False):
log.info(problem.name + ' cmaes ' + ('c++' if useCpp else 'python'))
for i in range(num):
ret = minimize(problem.fun, bounds=problem.bounds, num_retries = num_retries,
useCpp = useCpp, logger = log, value_limit = value_limit)
def test_minimize_SLSQP(fun, num):
ineq_cons = {'type': 'ineq', 'fun': constraint_ineq}
best = math.inf
t0 = time.perf_counter()
for i in range(num):
guess = random_x(bounds.lb, bounds.ub)
ret = minimize(fun,
x0=guess,
bounds=bounds,
method='SLSQP',
constraints=[ineq_cons])
if ret.success:
best = print_result(ret, best, t0, i)
if __name__ == '__main__':
# try as alternative
# test_minimize_SLSQP(feasable_cost, 10000)
# works much better
# test_minimize_SLSQP(cost_int_penalty, 10000)
t0 = time.perf_counter()
ret = advretry.minimize(feasable_cost_penalty,
bounds,
logger=logger(),
num_retries=320)
#ret = retry.minimize(feasable_cost_penalty, bounds, logger = logger(), num_retries=32)
print_result(ret, 10000, t0, 0)
def test_default_cordinated_retry(problem):
# coordinated retry with default optimizer
return advretry.minimize(problem.fun, problem.bounds, logger=logger())
def test_default_cordinated_retry(dim=6):
# coordinated retry with default optimizer
return advretry.minimize(obj_f_c, bounds(dim), logger=logger())
def test_minimize_SLSQP(fun, num):
ineq_cons = {'type': 'ineq', 'fun': constraint_ineq}
best = math.inf
t0 = time.perf_counter()
for i in range(num):
guess = random_x(bounds.lb, bounds.ub)
ret = minimize(fun,
x0=guess,
bounds=bounds,
method='SLSQP',
constraints=[ineq_cons])
if ret.success:
best = print_result(ret, best, t0, i)
if __name__ == '__main__':
# try as alternative
# test_minimize_SLSQP(weight, 10000)
t0 = time.perf_counter()
ret = advretry.minimize(weight_penalty,
bounds,
logger=logger(),
num_retries=320)
#ret = retry.minimize(weight_penalty, bounds, logger = logger(), num_retries=32)
print_result(ret, 10000, t0, 0)
