def create_optimization_history():
# create the pypesto problem
problem = create_problem()
# create optimizer
optimizer_options = {'maxiter': 200}
optimizer = optimize.ScipyOptimizer(
method='TNC', options=optimizer_options
)
history_options = pypesto.HistoryOptions(
trace_record=True, trace_save_iter=1
)
# run optimization
optimize_options = optimize.OptimizeOptions(allow_failed_starts=True)
result_with_trace = optimize.minimize(
problem=problem,
optimizer=optimizer,
n_starts=5,
startpoint_method=pypesto.startpoint.uniform,
options=optimize_options,
history_options=history_options,
filename=None,
)
return result_with_trace
def check_minimize(objective, library, solver, allow_failed_starts=False):
options = {
'maxiter': 100
}
optimizer = None
if library == 'scipy':
optimizer = optimize.ScipyOptimizer(method=solver, options=options)
elif library == 'ipopt':
optimizer = optimize.IpoptOptimizer()
elif library == 'dlib':
optimizer = optimize.DlibOptimizer(method=solver, options=options)
elif library == 'pyswarm':
optimizer = optimize.PyswarmOptimizer(options=options)
lb = 0 * np.ones((1, 2))
ub = 1 * np.ones((1, 2))
problem = pypesto.Problem(objective, lb, ub)
optimize_options = optimize.OptimizeOptions(
allow_failed_starts=allow_failed_starts)
result = optimize.minimize(
problem=problem,
optimizer=optimizer,
n_starts=1,
startpoint_method=pypesto.startpoint.uniform,
options=optimize_options
)
assert isinstance(result.optimize_result.list[0]['fval'], float)
def test_unbounded_minimize(optimizer):
"""
Test unbounded optimization using various optimizers and objective modes.
"""
lb_init = 1.1 * np.ones((1, 2))
lb = -np.inf * np.ones(lb_init.shape)
ub_init = 1.11 * np.ones((1, 2))
ub = np.inf * np.ones(ub_init.shape)
problem = pypesto.Problem(
rosen_for_sensi(max_sensi_order=2)['obj'],
lb, ub, lb_init=lb_init, ub_init=ub_init
)
opt = get_optimizer(*optimizer)
options = optimize.OptimizeOptions(allow_failed_starts=False)
if isinstance(optimizer[1], str) and re.match(r'^(?i)(ls_)', optimizer[1]):
return
if optimizer in [('dlib', ''), ('pyswarm', ''), ('cmaes', ''),
*[('nlopt', method) for method in [
nlopt.GN_ESCH, nlopt.GN_ISRES, nlopt.GN_AGS,
nlopt.GD_STOGO, nlopt.GD_STOGO_RAND, nlopt.G_MLSL,
nlopt.G_MLSL_LDS, nlopt.GD_MLSL, nlopt.GD_MLSL_LDS,
nlopt.GN_CRS2_LM, nlopt.GN_ORIG_DIRECT,
nlopt.GN_ORIG_DIRECT_L, nlopt.GN_DIRECT,
nlopt.GN_DIRECT_L, nlopt.GN_DIRECT_L_NOSCAL,
nlopt.GN_DIRECT_L_RAND,
nlopt.GN_DIRECT_L_RAND_NOSCAL]]]:
with pytest.raises(ValueError):
optimize.minimize(
problem=problem,
optimizer=opt,
n_starts=1,
startpoint_method=pypesto.startpoint.uniform,
options=options
)
return
else:
result = optimize.minimize(
problem=problem,
optimizer=opt,
n_starts=1,
startpoint_method=pypesto.startpoint.uniform,
options=options
)
# check that ub/lb were reverted
assert isinstance(result.optimize_result.list[0]['fval'], float)
if optimizer not in [('scipy', 'ls_trf'), ('scipy', 'ls_dogbox')]:
assert np.isfinite(result.optimize_result.list[0]['fval'])
assert result.optimize_result.list[0]['x'] is not None
# check that result is not in bounds, optimum is at (1,1), so you would
# hope that any reasonable optimizer manage to finish with x < ub,
# but I guess some are pretty terrible
assert np.any(result.optimize_result.list[0]['x'] < lb_init) or \
np.any(result.optimize_result.list[0]['x'] > ub_init)
def test_history_beats_optimizer():
"""Test overwriting from history vs whatever the optimizer reports."""
problem = CRProblem(
x_guesses=np.array([0.25, 0.25]).reshape(1, -1)
).get_problem()
max_fval = 10
scipy_options = {"maxfun": max_fval}
result_hist = optimize.minimize(
problem=problem,
optimizer=optimize.ScipyOptimizer(method="TNC", options=scipy_options),
n_starts=1,
options=optimize.OptimizeOptions(history_beats_optimizer=True),
filename=None,
)
result_opt = optimize.minimize(
problem=problem,
optimizer=optimize.ScipyOptimizer(method="TNC", options=scipy_options),
n_starts=1,
options=optimize.OptimizeOptions(history_beats_optimizer=False),
filename=None,
)
for result in (result_hist, result_opt):
# number of function evaluations
assert result.optimize_result.list[0]['n_fval'] <= max_fval + 1
# optimal value in bounds
assert np.all(problem.lb <= result.optimize_result.list[0]['x'])
assert np.all(problem.ub >= result.optimize_result.list[0]['x'])
# entries filled
for key in ('fval', 'x', 'grad'):
val = result.optimize_result.list[0][key]
assert val is not None and np.all(np.isfinite(val))
# TNC funnily reports the last value if not converged
# (this may break if their implementation is changed at some point ...)
assert (
result_hist.optimize_result.list[0]['fval']
< result_opt.optimize_result.list[0]['fval']
)
def create_optimization_results(objective):
# create optimizer, pypesto problem and options
options = {'maxiter': 200}
optimizer = optimize.ScipyOptimizer(method='TNC', options=options)
lb = -2 * np.ones(2)
ub = 2 * np.ones(2)
problem = pypesto.Problem(objective, lb, ub)
optimize_options = optimize.OptimizeOptions(allow_failed_starts=True)
# run optimization
result = optimize.minimize(problem=problem,
optimizer=optimizer,
n_starts=5,
startpoint_method=pypesto.startpoint.uniform,
options=optimize_options)
return problem, result, optimizer
def check_minimize(problem, library, solver, allow_failed_starts=False):
"""Runs a single run of optimization according to the provided inputs
and checks whether optimization yielded a solution."""
optimizer = get_optimizer(library, solver)
optimize_options = optimize.OptimizeOptions(
allow_failed_starts=allow_failed_starts
)
result = optimize.minimize(
problem=problem,
optimizer=optimizer,
n_starts=1,
startpoint_method=pypesto.startpoint.uniform,
options=optimize_options,
filename=None,
)
assert isinstance(result.optimize_result.list[0]['fval'], float)
if (library, solver) not in [
('nlopt', nlopt.GD_STOGO_RAND) # id 9, fails in 40% of cases
]:
assert np.isfinite(result.optimize_result.list[0]['fval'])
assert result.optimize_result.list[0]['x'] is not None
def test_trim_results(problem):
"""
Test trimming of hess/sres from results
"""
optimize_options = optimize.OptimizeOptions(
report_hess=False, report_sres=False
)
prob = pypesto.Problem(
objective=rosen_for_sensi(max_sensi_order=2)['obj'],
lb=0 * np.ones((1, 2)),
ub=1 * np.ones((1, 2)),
)
# hess
optimizer = optimize.FidesOptimizer(verbose=0)
result = optimize.minimize(
problem=prob,
optimizer=optimizer,
n_starts=1,
startpoint_method=pypesto.startpoint.uniform,
options=optimize_options,
filename=None,
)
assert result.optimize_result.list[0].hess is None
# sres
optimizer = optimize.ScipyOptimizer(method='ls_trf')
result = optimize.minimize(
problem=prob,
optimizer=optimizer,
n_starts=1,
startpoint_method=pypesto.startpoint.uniform,
options=optimize_options,
filename=None,
)
assert result.optimize_result.list[0].sres is None
def check_minimize(objective, library, solver, allow_failed_starts=False):
"""Runs a single run of optimization according to the provided inputs
and checks whether optimization yielded a solution."""
optimizer = get_optimizer(library, solver)
lb = 0 * np.ones((1, 2))
ub = 1 * np.ones((1, 2))
problem = pypesto.Problem(objective, lb, ub)
optimize_options = optimize.OptimizeOptions(
allow_failed_starts=allow_failed_starts
)
result = optimize.minimize(
problem=problem,
optimizer=optimizer,
n_starts=1,
startpoint_method=pypesto.startpoint.uniform,
options=optimize_options
)
assert isinstance(result.optimize_result.list[0]['fval'], float)
if (library, solver) not in [('scipy', 'ls_trf'), ('scipy', 'ls_dogbox')]:
assert np.isfinite(result.optimize_result.list[0]['fval'])
assert result.optimize_result.list[0]['x'] is not None
# balancing
if MODEL_NAME in [
'Bachmann_MSB2011', 'Isensee_JCB2018', 'Lucarelli_CellSystems2018',
'Beer_MolBioSystems2014'
]:
# Bachmann nc = 36 (4* 9)
# Lucarelli nc = 16 (4* 4)
# Isensee nc = 123 (4*30 + 3)
# Beer nc = 19 (4* 4 + 3)
engine_threads = 3
objective.n_threads = 4
engine = pypesto.engine.MultiThreadEngine(n_threads=engine_threads)
options = optimize.OptimizeOptions(allow_failed_starts=True,
report_sres=False,
report_hess=False)
# do the optimization
ref = visualize.create_references(
x=np.asarray(petab_problem.x_nominal_scaled)[np.asarray(
petab_problem.x_free_indices)],
fval=problem.objective(
np.asarray(petab_problem.x_nominal_scaled)[np.asarray(
petab_problem.x_free_indices)]))
print(f'Reference fval: {ref[0]["fval"]}')
hdf_results_file = os.path.join('results', prefix + '.hdf5')
result = optimize.minimize(
