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)