def test_trim_history():
"""
Test whether the history gets correctly trimmed to be monotonically
decreasing.
"""
problem = CRProblem()
pypesto_problem = problem.get_problem()
optimizer = pypesto.optimize.ScipyOptimizer()
history_options = pypesto.HistoryOptions(trace_record=True)
result = pypesto.optimize.minimize(
problem=pypesto_problem,
optimizer=optimizer,
n_starts=1,
history_options=history_options,
engine=MultiProcessEngine(),
filename=None,
)
fval_trace = result.optimize_result.list[0].history.get_fval_trace()
fval_trace_trimmed = result.optimize_result.list[0].history.get_fval_trace(
trim=True)
fval_trimmed_man = []
fval_current = np.inf
for fval_i in fval_trace:
if fval_i <= fval_current:
fval_trimmed_man.append(fval_i)
fval_current = fval_i
assert fval_trace_trimmed == fval_trimmed_man
def test_trace_grad(self):
self.obj.history.options = pypesto.HistoryOptions(
trace_record=True,
trace_record_grad=True,
)
self.check_history()
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 test_trace_schi2(self):
self.obj.history.options = pypesto.HistoryOptions(
trace_record=True,
trace_record_chi2=True,
trace_record_schi2=False,
)
self.check_history()
def test_trace_all(self):
history = pypesto.MemoryHistory(options=pypesto.HistoryOptions(
trace_record=True,
trace_record_grad=True,
trace_record_hess=True,
trace_record_res=True,
trace_record_sres=True,
trace_record_chi2=True,
trace_record_schi2=True,
))
self.obj.history = history
self.check_history()
def test_ensemble_from_optimization():
"""
Test reading an ensemble from optimization result.
"""
objective = pypesto.Objective(fun=so.rosen,
grad=so.rosen_der,
hess=so.rosen_hess)
dim_full = 10
lb = -5 * np.ones((dim_full, 1))
ub = 5 * np.ones((dim_full, 1))
n_starts = 5
problem = pypesto.Problem(objective=objective, lb=lb, ub=ub)
optimizer = optimize.ScipyOptimizer(options={'maxiter': 10})
history_options = pypesto.HistoryOptions(trace_record=True)
result = optimize.minimize(
problem=problem,
optimizer=optimizer,
n_starts=n_starts,
history_options=history_options,
)
# change fvals of each start
for i_start, optimizer_result in enumerate(result.optimize_result.list):
optimizer_result['fval'] = i_start + 1
for i_iter in range(len(optimizer_result['history']._trace['fval'])):
optimizer_result['history']._trace['fval'][i_iter] = (
len(optimizer_result['history']._trace['fval']) + i_start -
i_iter)
# test_endpoints
ensemble_ep = Ensemble.from_optimization_endpoints(result=result,
cutoff=4,
max_size=10)
ensemble_hist = Ensemble.from_optimization_history(result=result,
cutoff=4,
max_size=10,
max_per_start=5)
# compare vector_tags with the expected values:
ep_tags = [(int(result.optimize_result.list[i]['id']), -1)
for i in [0, 1, 2, 3]]
hist_tags = [(
int(result.optimize_result.list[i]['id']),
len(result.optimize_result.list[i]['history']._trace['fval']) - 1 - j,
) for i in range(4) for j in reversed(range(4 - i))]
assert hist_tags == ensemble_hist.vector_tags
assert ep_tags == ensemble_ep.vector_tags
def test_result_from_hdf5_history(hdf5_file):
problem = create_petab_problem()
history_options_hdf5 = pypesto.HistoryOptions(
trace_record=True,
storage_file=hdf5_file,
)
# optimize with history saved to hdf5
result = optimize.minimize(
problem=problem,
n_starts=1,
history_options=history_options_hdf5,
)
result_from_hdf5 = optimization_result_from_history(filename=hdf5_file,
problem=problem)
# Currently 'exitflag', 'time' and 'message' are not loaded.
arguments = [
ID,
X,
FVAL,
GRAD,
HESS,
RES,
SRES,
N_FVAL,
N_GRAD,
N_HESS,
N_RES,
N_SRES,
X0,
FVAL0,
]
for key in arguments:
if result.optimize_result.list[0][key] is None:
assert result_from_hdf5.optimize_result.list[0][key] is None
elif isinstance(result.optimize_result.list[0][key], np.ndarray):
assert np.allclose(
result.optimize_result.list[0][key],
result_from_hdf5.optimize_result.list[0][key],
), key
else:
assert (result.optimize_result.list[0][key] ==
result_from_hdf5.optimize_result.list[0][key]), key
def test_storage_trace(hdf5_file):
objective1 = pypesto.Objective(fun=so.rosen,
grad=so.rosen_der,
hess=so.rosen_hess)
objective2 = pypesto.Objective(fun=so.rosen,
grad=so.rosen_der,
hess=so.rosen_hess)
dim_full = 10
lb = -5 * np.ones((dim_full, 1))
ub = 5 * np.ones((dim_full, 1))
n_starts = 5
startpoints = pypesto.startpoint.latin_hypercube(n_starts=n_starts,
lb=lb,
ub=ub)
problem1 = pypesto.Problem(objective=objective1,
lb=lb,
ub=ub,
x_guesses=startpoints)
problem2 = pypesto.Problem(objective=objective2,
lb=lb,
ub=ub,
x_guesses=startpoints)
optimizer1 = optimize.ScipyOptimizer(options={'maxiter': 10})
optimizer2 = optimize.ScipyOptimizer(options={'maxiter': 10})
history_options_hdf5 = pypesto.HistoryOptions(trace_record=True,
storage_file=hdf5_file)
# optimize with history saved to hdf5
result_hdf5 = optimize.minimize(
problem=problem1,
optimizer=optimizer1,
n_starts=n_starts,
history_options=history_options_hdf5,
)
# optimizing with history saved in memory
history_options_memory = pypesto.HistoryOptions(trace_record=True)
result_memory = optimize.minimize(
problem=problem2,
optimizer=optimizer2,
n_starts=n_starts,
history_options=history_options_memory,
filename=None,
)
history_entries = [X, FVAL, GRAD, HESS, RES, SRES, CHI2, SCHI2]
assert len(result_hdf5.optimize_result.list) == len(
result_memory.optimize_result.list)
for mem_res in result_memory.optimize_result.list:
for hdf_res in result_hdf5.optimize_result.list:
if mem_res['id'] == hdf_res['id']:
for entry in history_entries:
hdf5_entry_trace = getattr(hdf_res['history'],
f'get_{entry}_trace')()
for iteration in range(len(hdf5_entry_trace)):
# comparing nan and None difficult
if (hdf5_entry_trace[iteration] is None or np.isnan(
hdf5_entry_trace[iteration]).all()):
continue
np.testing.assert_array_equal(
getattr(mem_res['history'],
f'get_{entry}_trace')()[iteration],
hdf5_entry_trace[iteration],
)
def check_history(self):
self.problem = pypesto.Problem(self.obj, self.lb, self.ub)
optimize_options = pypesto.OptimizeOptions(
allow_failed_starts=False
)
history_options = pypesto.HistoryOptions(
trace_record=True,
trace_record_hess=False,
trace_save_iter=1,
storage_file='tmp/traces/conversion_example_{id}.csv',
)
result = pypesto.minimize(
problem=self.problem,
optimizer=self.optimizer,
n_starts=1,
startpoint_method=pypesto.startpoint.uniform,
options=optimize_options,
history_options=history_options
)
# disable trace from here on
self.obj.history.options.trace_record = False
for start in result.optimize_result.list:
trace = start.history._trace
it_final = int(trace[('fval', np.NaN)].idxmin())
it_start = int(np.where(np.logical_not(
np.isnan(trace['fval'].values)
))[0][0])
self.assertTrue(np.isclose(
trace['x'].values[0, :], start.x0
).all())
self.assertTrue(np.isclose(
trace['x'].values[it_final, :], start.x
).all())
self.assertTrue(np.isclose(
trace['fval'].values[it_start, 0], start.fval0
))
funs = {
'fval': self.obj.get_fval,
'grad': self.obj.get_grad,
'hess': self.obj.get_hess,
'res': self.obj.get_res,
'sres': self.obj.get_sres,
'chi2': lambda x: res_to_chi2(self.obj.get_res(x)),
'schi2': lambda x: sres_to_schi2(*self.obj(
x,
(0, 1,),
pypesto.objective.constants.MODE_RES
))
}
for var, fun in funs.items():
for it in range(5):
if var in ['fval', 'chi2']:
if not np.isnan(trace[var].values[it, 0]):
self.assertTrue(np.isclose(
trace[var].values[it, 0],
fun(trace['x'].values[it, :])
))
elif var in ['hess', 'sres', 'res']:
if trace[var].values[it, 0] is not None:
self.assertTrue(np.isclose(
trace[var].values[it, 0],
fun(trace['x'].values[it, :])
).all())
elif self.obj.history.options[f'trace_record_{var}'] \
and not \
np.isnan(trace[var].values[it, :]).all():
self.assertTrue(np.isclose(
trace[var].values[it, :],
fun(trace['x'].values[it, :])
).all())
def test_hdf5_history_mp():
"""Test whether hdf5-History works with a MultiProcessEngine."""
objective1 = pypesto.Objective(fun=so.rosen,
grad=so.rosen_der,
hess=so.rosen_hess)
objective2 = pypesto.Objective(fun=so.rosen,
grad=so.rosen_der,
hess=so.rosen_hess)
dim_full = 10
lb = -5 * np.ones((dim_full, 1))
ub = 5 * np.ones((dim_full, 1))
n_starts = 5
startpoints = pypesto.startpoint.latin_hypercube(n_starts=n_starts,
lb=lb,
ub=ub)
problem1 = pypesto.Problem(objective=objective1,
lb=lb,
ub=ub,
x_guesses=startpoints)
problem2 = pypesto.Problem(objective=objective2,
lb=lb,
ub=ub,
x_guesses=startpoints)
optimizer1 = pypesto.optimize.ScipyOptimizer(options={'maxiter': 10})
optimizer2 = pypesto.optimize.ScipyOptimizer(options={'maxiter': 10})
with tempfile.TemporaryDirectory(dir=".") as tmpdirname:
_, fn = tempfile.mkstemp(".hdf5", dir=f"{tmpdirname}")
history_options_mp = pypesto.HistoryOptions(trace_record=True,
storage_file=fn)
history_options_mem = pypesto.HistoryOptions(trace_record=True)
# optimize with Memory History
result_hdf5_mem = pypesto.optimize.minimize(
problem=problem1,
optimizer=optimizer1,
n_starts=n_starts,
history_options=history_options_mem,
engine=MultiProcessEngine(),
filename=None,
)
# optimizing with history saved in hdf5 and MultiProcessEngine
result_memory_mp = pypesto.optimize.minimize(
problem=problem2,
optimizer=optimizer2,
n_starts=n_starts,
history_options=history_options_mp,
engine=MultiProcessEngine(),
filename=None,
)
history_entries = [X, FVAL, GRAD, HESS, RES, SRES, CHI2, SCHI2]
assert len(result_hdf5_mem.optimize_result.list) == len(
result_memory_mp.optimize_result.list)
for mp_res in result_memory_mp.optimize_result.list:
for mem_res in result_hdf5_mem.optimize_result.list:
if mp_res['id'] == mem_res['id']:
for entry in history_entries:
hdf5_entry_trace = getattr(mp_res['history'],
f'get_{entry}_trace')()
mem_entry_trace = getattr(mem_res['history'],
f'get_{entry}_trace')()
for iteration in range(len(hdf5_entry_trace)):
# comparing nan and None difficult
if (hdf5_entry_trace[iteration] is None
or np.isnan(
hdf5_entry_trace[iteration]).all()):
continue
np.testing.assert_array_equal(
mem_entry_trace[iteration],
hdf5_entry_trace[iteration],
)
ax.plot_surface(X=x, Y=y, Z=z)
plt.xlabel('x axis')
plt.ylabel('y axis')
ax.set_title('cost function values')
###### Opimization
# create different optimizers
optimizer_bfgs = optimize.ScipyOptimizer(method='l-bfgs-b')
optimizer_tnc = optimize.ScipyOptimizer(method='TNC')
optimizer_dogleg = optimize.ScipyOptimizer(method='dogleg')
# set number of starts
n_starts = 20
# save optimizer trace
history_options = pypesto.HistoryOptions(trace_record=True)
# Run optimizaitons for different optimzers
result1_bfgs = optimize.minimize(problem=problem1,
optimizer=optimizer_bfgs,
n_starts=n_starts,
history_options=history_options)
result1_tnc = optimize.minimize(problem=problem1,
optimizer=optimizer_tnc,
n_starts=n_starts,
history_options=history_options)
result1_dogleg = optimize.minimize(problem=problem1,
optimizer=optimizer_dogleg,
n_starts=n_starts,
history_options=history_options)