def parameter_estimation(objective, library, solver, fixed_pars, n_starts):
if re.match(r'(?i)^(ls_)', solver):
options = {'max_nfev': 10}
else:
options = {'maxiter': 10}
if library == 'scipy':
optimizer = pypesto.ScipyOptimizer(method=solver, options=options)
elif library == 'dlib':
optimizer = pypesto.DlibOptimizer(method=solver, options=options)
elif library == 'pyswarm':
optimizer = pypesto.PyswarmOptimizer(options=options)
else:
raise ValueError("This code should not be reached")
optimizer.temp_file = os.path.join('test', 'tmp_{index}.csv')
dim = len(objective.x_ids)
lb = -2 * np.ones((1, dim))
ub = 2 * np.ones((1, dim))
pars = objective.amici_model.getParameters()
problem = pypesto.Problem(objective,
lb,
ub,
x_fixed_indices=fixed_pars,
x_fixed_vals=[pars[idx] for idx in fixed_pars])
optimize_options = pypesto.OptimizeOptions(
allow_failed_starts=False,
startpoint_resample=True,
)
pypesto.minimize(problem, optimizer, n_starts, options=optimize_options)
def check_minimize(objective, library, solver, allow_failed_starts=False):
options = {'maxiter': 100}
optimizer = None
if library == 'scipy':
optimizer = pypesto.ScipyOptimizer(method=solver, options=options)
elif library == 'dlib':
optimizer = pypesto.DlibOptimizer(method=solver, options=options)
elif library == 'pyswarm':
optimizer = pypesto.PyswarmOptimizer(options=options)
lb = 0 * np.ones((1, 2))
ub = 1 * np.ones((1, 2))
problem = pypesto.Problem(objective, lb, ub)
optimize_options = pypesto.OptimizeOptions(
allow_failed_starts=allow_failed_starts)
result = pypesto.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_petab(self, engine):
petab_importer = pypesto.PetabImporter.from_folder(
folder_base + "Zheng_PNAS2012")
objective = petab_importer.create_objective()
problem = petab_importer.create_problem(objective)
result = pypesto.minimize(problem=problem, n_starts=2, engine=engine)
self.assertTrue(len(result.optimize_result.as_list()) == 2)
def test_preeq_guesses():
"""
Test whether optimization with preequilibration guesses works, asserts
that steadystate guesses are written and checks that gradient is still
correct with guesses set
"""
petab_problem = petab.Problem.from_yaml(
folder_base + "Zheng_PNAS2012/Zheng_PNAS2012.yaml")
petab_problem.model_name = "Zheng_PNAS2012"
importer = pypesto.PetabImporter(petab_problem)
obj = importer.create_objective()
problem = importer.create_problem(obj)
optimizer = pypesto.ScipyOptimizer('ls_trf')
result = pypesto.minimize(
problem=problem, optimizer=optimizer, n_starts=2,
)
assert problem.objective.steadystate_guesses['fval'] < np.inf
assert len(obj.steadystate_guesses['data']) == 1
df = obj.check_grad(
result.optimize_result.list[0]['x'],
eps=1e-3,
verbosity=0,
mode=pypesto.objective.constants.MODE_FUN
)
print("relative errors MODE_FUN: ", df.rel_err.values)
print("absolute errors MODE_FUN: ", df.abs_err.values)
assert np.all((df.rel_err.values < RTOL) | (df.abs_err.values < ATOL))
def test_ground_truth():
# use best self-implemented sampler, which has a chance of correctly
# sampling from the distribution
sampler = pypesto.AdaptiveParallelTemperingSampler(
internal_sampler=pypesto.AdaptiveMetropolisSampler(), n_chains=5)
problem = gaussian_problem()
result = pypesto.minimize(problem)
result = pypesto.sample(problem, n_samples=10000,
result=result, sampler=sampler)
# get samples of first chain
samples = result.sample_result.trace_x[0].flatten()
# test against different distributions
statistic, pval = kstest(samples, 'norm')
print(statistic, pval)
assert statistic < 0.1
statistic, pval = kstest(samples, 'uniform')
print(statistic, pval)
assert statistic > 0.1
def _test_basic(self, engine):
# set up problem
objective = test_objective.rosen_for_sensi(max_sensi_order=2)['obj']
lb = 0 * np.ones((1, 2))
ub = 1 * np.ones((1, 2))
problem = pypesto.Problem(objective, lb, ub)
result = pypesto.minimize(problem=problem, n_starts=9, engine=engine)
self.assertTrue(len(result.optimize_result.as_list()) == 9)
def _test_petab(engine):
petab_importer = pypesto.PetabImporter.from_yaml(
folder_base + "Zheng_PNAS2012/Zheng_PNAS2012.yaml")
objective = petab_importer.create_objective()
problem = petab_importer.create_problem(objective)
optimizer = pypesto.ScipyOptimizer(options={'maxiter': 10})
result = pypesto.minimize(problem=problem,
n_starts=3,
engine=engine,
optimizer=optimizer)
assert len(result.optimize_result.as_list()) == 3
def _multistart_on_kernel(fun, lb, ub):
objective = pypesto.Objective(fun=fun)
problem = pypesto.Problem(objective=objective, lb=lb, ub=ub)
optimizer = pypesto.ScipyOptimizer(options={
'maxiter': 10000,
'maxfun': 10000,
'disp': False
})
result = pypesto.minimize(problem=problem,
optimizer=optimizer,
n_starts=100)
return result
def test_3_optimize(self):
# run optimization
for obj_edatas, importer in \
zip(self.obj_edatas, self.petab_importers):
obj = obj_edatas[0]
optimizer = pypesto.ScipyOptimizer(options={'maxiter': 10})
problem = importer.create_problem(obj)
result = pypesto.minimize(
problem=problem, optimizer=optimizer, n_starts=2)
self.assertTrue(np.isfinite(
result.optimize_result.get_for_key('fval')[0]))
def _test_basic(engine):
# set up problem
objective = test_objective.rosen_for_sensi(max_sensi_order=2)['obj']
lb = 0 * np.ones((1, 2))
ub = 1 * np.ones((1, 2))
problem = pypesto.Problem(objective, lb, ub)
optimizer = pypesto.ScipyOptimizer(options={'maxiter': 10})
result = pypesto.minimize(problem=problem,
n_starts=5,
engine=engine,
optimizer=optimizer)
assert len(result.optimize_result.as_list()) == 5
def test_pipeline(sampler, problem):
"""Check that a typical pipeline runs through."""
# optimization
optimizer = pypesto.ScipyOptimizer(options={'maxiter': 10})
result = pypesto.minimize(problem, n_starts=3, optimizer=optimizer)
# sampling
result = pypesto.sample(
problem, sampler=sampler, n_samples=20, result=result)
# some plot
pypesto.visualize.sampling_1d_marginals(result)
plt.close()
def test_optimize(self):
# logging
pypesto.logging.log_to_console(logging.WARN)
filename = ".test_logging.tmp"
pypesto.logging.log_to_file(logging.DEBUG, filename)
logger = logging.getLogger('pypesto')
if os.path.exists(filename):
os.remove(filename)
fh = logging.FileHandler(filename)
fh.setLevel(logging.DEBUG)
logger.addHandler(fh)
logger.info("start test")
# problem definition
def fun(_):
raise Exception("This function cannot be called.")
objective = pypesto.Objective(fun=fun)
problem = pypesto.Problem(objective, -1, 1)
optimizer = pypesto.ScipyOptimizer()
options = {'allow_failed_starts': True}
# optimization
pypesto.minimize(problem, optimizer, 5, options=options)
# assert logging worked
self.assertTrue(os.path.exists(filename))
f = open(filename, 'rb')
content = str(f.read())
f.close()
# tidy up
os.remove(filename)
# check if error message got inserted
self.assertTrue("fail" in content)
def create_optimization_history():
# create the pypesto problem
problem = create_problem()
# create optimizer
optimizer_options = {'maxiter': 200}
optimizer = pypesto.ScipyOptimizer(method='TNC', options=optimizer_options)
# run optimization
optimize_options = pypesto.OptimizeOptions(allow_failed_starts=True)
result_with_trace = pypesto.minimize(
problem=problem,
optimizer=optimizer,
n_starts=5,
startpoint_method=pypesto.startpoint.uniform,
options=optimize_options)
return result_with_trace
def create_optimization_results(objective):
# create optimizer, pypesto problem and options
options = {'maxiter': 200}
optimizer = pypesto.ScipyOptimizer(method='TNC', options=options)
lb = -2 * np.ones((1, 2))
ub = 2 * np.ones((1, 2))
problem = pypesto.Problem(objective, lb, ub)
optimize_options = pypesto.OptimizeOptions(allow_failed_starts=True)
# run optimization
result = pypesto.minimize(problem=problem,
optimizer=optimizer,
n_starts=5,
startpoint_method=pypesto.startpoint.uniform,
options=optimize_options)
return problem, result, optimizer
def test_optimize():
problem = create_problem()
optimizer = pypesto.ScipyOptimizer()
n_starts = 5
result = pypesto.minimize(problem, optimizer, n_starts)
optimizer_result = result.optimize_result.list[0]
assert len(optimizer_result.x) == 5
assert len(optimizer_result.grad) == 5
# maybe not what we want, but that's how it is right now
assert len(problem.ub) == 3
# nans written into unknown components
assert np.isnan(optimizer_result.grad[1])
# fixed values written into parameter vector
assert optimizer_result.x[1] == 1
lb_full = problem.get_full_vector(problem.lb)
assert len(lb_full) == 5
def parameter_estimation(
objective,
library,
solver,
fixed_pars,
n_starts,
):
options = {
'maxiter': 100
}
if library == 'scipy':
optimizer = pypesto.ScipyOptimizer(method=solver,
options=options)
elif library == 'dlib':
optimizer = pypesto.DlibOptimizer(method=solver,
options=options)
optimizer.temp_file = os.path.join('test', 'tmp_{index}.csv')
lb = -2 * np.ones((1, objective.dim))
ub = 2 * np.ones((1, objective.dim))
pars = objective.amici_model.getParameters()
problem = pypesto.Problem(objective, lb, ub,
x_fixed_indices=fixed_pars,
x_fixed_vals=[pars[idx] for idx in fixed_pars]
)
optimize_options = pypesto.OptimizeOptions(
allow_failed_starts=False,
startpoint_resample=True,
)
results = pypesto.minimize(
problem, optimizer, n_starts, options=optimize_options,
)
results = results.optimize_result.list
# OPTIMIZATION WITHOUT PRIOR ___________________________________________________________________________________________
optimizer = pypesto.ScipyOptimizer(method='L-BFGS-B')
# play with optimization options
optimizer.options = {'maxiter': 1e5, 'ftol': 1e-10, 'gtol': 1e-10, 'maxls': 80}
# optimizer.options = {'maxcor': 10, 'ftol': 1e-10, 'gtol': 1e-05, 'eps': 1e-08, 'maxfun': 1e5,
# 'maxiter': 1e5, 'maxls': 20}
problem = importer.create_problem(obj)
engine = pypesto.SingleCoreEngine()
n_starts = 10
start = time.time()
result = pypesto.minimize(problem=problem,
optimizer=optimizer,
n_starts=n_starts,
engine=engine)
end = time.time()
print('\nbest parameter: ', result.optimize_result.as_list('x')[0]['x'])
print('best likelihood value: ',
obj(result.optimize_result.as_list('x')[0]['x']))
# calculate computation time
comp_time = end - start
# calculate converged points
conv_points = compute_converged_points_single(result=result)
print('converted points: ', conv_points)
# SAVE STARTPOINTS _____________________________________________________________________________________________________
'gtol': 1e-4,
}
optimizer = pypesto.ScipyOptimizer(
method='ls_trf',
options=optim_options
)
optimize_options = pypesto.optimize.optimize.OptimizeOptions(
startpoint_resample=True,
allow_failed_starts=True,
)
result = pypesto.minimize(
problem=problem,
optimizer=optimizer,
n_starts=10,
options=optimize_options
)
resultdir = os.path.join(basedir, 'results')
os.makedirs(resultdir, exist_ok=True)
pypesto.visualize.parameters(result, start_indices=range(5))
plt.savefig(
os.path.join(resultdir, f'parameters__{setting}.pdf')
)
pypesto.visualize.waterfall(result, start_indices=range(5))
plt.savefig(
os.path.join(resultdir, f'waterfall__{setting}.pdf')
)
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())
