def test_presimulation(sbml_example_presimulation_module):
"""Test 'presimulation' test model"""
model = sbml_example_presimulation_module.getModel()
solver = model.getSolver()
solver.setNewtonMaxSteps(0)
model.setTimepoints(np.linspace(0, 60, 61))
model.setSteadyStateSensitivityMode(
amici.SteadyStateSensitivityMode.simulationFSA
)
solver.setSensitivityOrder(amici.SensitivityOrder.first)
model.setReinitializeFixedParameterInitialStates(True)
rdata = amici.runAmiciSimulation(model, solver)
edata = amici.ExpData(rdata, 0.1, 0.0)
edata.fixedParameters = [10, 2]
edata.fixedParametersPresimulation = [10, 2]
edata.fixedParametersPreequilibration = [3, 0]
assert isinstance(
amici.runAmiciSimulation(model, solver, edata),
amici.ReturnDataView)
solver.setRelativeTolerance(1e-12)
solver.setAbsoluteTolerance(1e-12)
check_derivatives(model, solver, edata, assert_fun, epsilon=1e-4)
def test_likelihoods(model_test_likelihoods):
"""Test the custom noise distributions used to define cost functions."""
model = model_test_likelihoods.getModel()
model.setTimepoints(np.linspace(0, 60, 60))
solver = model.getSolver()
solver.setSensitivityOrder(amici.SensitivityOrder.first)
# run model once to create an edata
rdata = amici.runAmiciSimulation(model, solver)
sigmas = rdata['y'].max(axis=0) * 0.05
edata = amici.ExpData(rdata, sigmas, [])
# just make all observables positive since some are logarithmic
while min(edata.getObservedData()) < 0:
edata = amici.ExpData(rdata, sigmas, [])
# and now run for real and also compute likelihood values
rdata = amici.runAmiciSimulations(model, solver, [edata])[0]
# check if the values make overall sense
assert np.isfinite(rdata['llh'])
assert np.all(np.isfinite(rdata['sllh']))
assert np.any(rdata['sllh'])
rdata_df = amici.getSimulationObservablesAsDataFrame(model,
edata,
rdata,
by_id=True)
edata_df = amici.getDataObservablesAsDataFrame(model, edata, by_id=True)
# check correct likelihood value
llh_exp = -sum([
normal_nllh(edata_df['o1'], rdata_df['o1'], sigmas[0]),
log_normal_nllh(edata_df['o2'], rdata_df['o2'], sigmas[1]),
log10_normal_nllh(edata_df['o3'], rdata_df['o3'], sigmas[2]),
laplace_nllh(edata_df['o4'], rdata_df['o4'], sigmas[3]),
log_laplace_nllh(edata_df['o5'], rdata_df['o5'], sigmas[4]),
log10_laplace_nllh(edata_df['o6'], rdata_df['o6'], sigmas[5]),
custom_nllh(edata_df['o7'], rdata_df['o7'], sigmas[6]),
])
assert np.isclose(rdata['llh'], llh_exp)
# check gradient
for sensi_method in [
amici.SensitivityMethod.forward, amici.SensitivityMethod.adjoint
]:
solver = model.getSolver()
solver.setSensitivityMethod(sensi_method)
solver.setSensitivityOrder(amici.SensitivityOrder.first)
solver.setRelativeTolerance(1e-12)
solver.setAbsoluteTolerance(1e-12)
check_derivatives(model,
solver,
edata,
assert_fun,
atol=1e-2,
rtol=1e-2,
epsilon=1e-5,
check_least_squares=False)
def test_steadystate_simulation(model_steadystate_module):
model = model_steadystate_module.getModel()
model.setTimepoints(np.linspace(0, 60, 60))
solver = model.getSolver()
solver.setSensitivityOrder(amici.SensitivityOrder.first)
rdata = amici.runAmiciSimulation(model, solver)
edata = [amici.ExpData(rdata, 1, 0)]
rdata = amici.runAmiciSimulations(model, solver, edata)
# check roundtripping of DataFrame conversion
df_edata = amici.getDataObservablesAsDataFrame(model, edata)
edata_reconstructed = amici.getEdataFromDataFrame(model, df_edata)
assert np.isclose(
amici.ExpDataView(edata[0])['observedData'],
amici.ExpDataView(edata_reconstructed[0])['observedData']).all()
assert np.isclose(
amici.ExpDataView(edata[0])['observedDataStdDev'],
amici.ExpDataView(edata_reconstructed[0])['observedDataStdDev']).all()
if len(edata[0].fixedParameters):
assert list(edata[0].fixedParameters) \
== list(edata_reconstructed[0].fixedParameters)
else:
assert list(model.getFixedParameters()) \
== list(edata_reconstructed[0].fixedParameters)
assert list(edata[0].fixedParametersPreequilibration) == \
list(edata_reconstructed[0].fixedParametersPreequilibration)
df_state = amici.getSimulationStatesAsDataFrame(model, edata, rdata)
assert np.isclose(rdata[0]['x'],
df_state[list(model.getStateIds())].values).all()
df_obs = amici.getSimulationObservablesAsDataFrame(model, edata, rdata)
assert np.isclose(rdata[0]['y'],
df_obs[list(model.getObservableIds())].values).all()
amici.getResidualsAsDataFrame(model, edata, rdata)
solver.setRelativeTolerance(1e-12)
solver.setAbsoluteTolerance(1e-12)
check_derivatives(model,
solver,
edata[0],
assert_fun,
atol=1e-3,
rtol=1e-3,
epsilon=1e-4)
# Run some additional tests which need a working Model,
# but don't need precomputed expectations.
_test_set_parameters_by_dict(model_steadystate_module)
def test_sympy_exp_monkeypatch():
"""
This model contains a removeable discontinuity at t=0 that requires
monkeypatching sympy.Pow._eval_derivative in order to be able to compute
non-nan sensitivities
"""
url = 'https://www.ebi.ac.uk/biomodels/model/download/BIOMD0000000529.2?' \
'filename=BIOMD0000000529_url.xml'
importer = amici.SbmlImporter(urlopen(url).read().decode('utf-8'),
from_file=False)
module_name = 'BIOMD0000000529'
outdir = 'BIOMD0000000529'
importer.sbml2amici(module_name, outdir)
model_module = amici.import_model_module(module_name=module_name,
module_path=outdir)
model = model_module.getModel()
model.setTimepoints(np.linspace(0, 8, 250))
model.requireSensitivitiesForAllParameters()
model.setAlwaysCheckFinite(True)
model.setParameterScale(
amici.parameterScalingFromIntVector([
amici.ParameterScaling.none
if re.match(r'n[0-9]+$', par_id) else amici.ParameterScaling.log10
for par_id in model.getParameterIds()
]))
solver = model.getSolver()
solver.setSensitivityMethod(amici.SensitivityMethod.forward)
solver.setSensitivityOrder(amici.SensitivityOrder.first)
rdata = amici.runAmiciSimulation(model, solver)
# print sensitivity-related results
assert rdata['status'] == amici.AMICI_SUCCESS
check_derivatives(model,
solver,
None,
assert_fun,
atol=1e-2,
rtol=1e-2,
epsilon=1e-3)
def runTest(self):
"""
test runner routine that loads data expectedResults.h5 hdf file and
runs individual models/settings as subTests
"""
expected_results = h5py.File(self.expectedResultsFile, 'r')
for subTest in expected_results.keys():
for case in list(expected_results[subTest].keys()):
if case.startswith('sensi2'):
model_name = subTest + '_o2'
else:
model_name = subTest
with self.subTest(modelName=model_name, caseName=case):
print(f'running {model_name}::{case}')
def assert_fun(x):
return self.assertTrue(x)
model_swig_folder = \
os.path.join(os.path.dirname(__file__), '..',
'build', 'tests', 'cpputest',
f'external_{model_name}-prefix',
'src', f'external_{model_name}-build',
'swig')
sys.path.insert(0, model_swig_folder)
test_model_module = importlib.import_module(model_name)
self.model = test_model_module.getModel()
self.solver = self.model.getSolver()
amici.readModelDataFromHDF5(
self.expectedResultsFile, self.model.get(),
f'/{subTest}/{case}/options'
)
amici.readSolverSettingsFromHDF5(
self.expectedResultsFile, self.solver.get(),
f'/{subTest}/{case}/options'
)
edata = None
if 'data' in expected_results[subTest][case].keys():
edata = amici.readSimulationExpData(
self.expectedResultsFile,
f'/{subTest}/{case}/data', self.model.get()
)
rdata = amici.runAmiciSimulation(self.model, self.solver,
edata)
check_derivative_opts = dict()
if model_name == 'model_nested_events':
check_derivative_opts['rtol'] = 1e-2
elif model_name == 'model_events':
check_derivative_opts['atol'] = 1e-3
if edata \
and self.solver.getSensitivityMethod() \
and self.solver.getSensitivityOrder() \
and len(self.model.getParameterList()) \
and not model_name.startswith('model_neuron') \
and not case.endswith('byhandpreeq'):
check_derivatives(self.model, self.solver, edata,
assert_fun, **check_derivative_opts)
verify_simulation_opts = dict()
if model_name.startswith('model_neuron'):
verify_simulation_opts['atol'] = 1e-5
verify_simulation_opts['rtol'] = 1e-2
if model_name.startswith('model_robertson') and \
case == 'sensiforwardSPBCG':
verify_simulation_opts['atol'] = 1e-3
verify_simulation_opts['rtol'] = 1e-3
verify_simulation_results(
rdata, expected_results[subTest][case]['results'],
assert_fun, **verify_simulation_opts
)
if model_name == 'model_steadystate' and \
case == 'sensiforwarderrorint':
edata = amici.amici.ExpData(self.model.get())
if edata and model_name != 'model_neuron_o2' and not (
model_name == 'model_robertson' and
case == 'sensiforwardSPBCG'
):
# Test runAmiciSimulations: ensure running twice
# with same ExpData yields same results
if isinstance(edata, amici.amici.ExpData):
edatas = [edata, edata]
else:
edatas = [edata.get(), edata.get()]
rdatas = amici.runAmiciSimulations(
self.model, self.solver, edatas, num_threads=2
)
verify_simulation_results(
rdatas[0],
expected_results[subTest][case]['results'],
assert_fun, **verify_simulation_opts
)
verify_simulation_results(
rdatas[1],
expected_results[subTest][case]['results'],
assert_fun, **verify_simulation_opts
)
self.assertRaises(
RuntimeError,
self.model.getParameterByName,
'thisParameterDoesNotExist'
)
rdata = amici.runAmiciSimulation(model, solver, edata)
check_derivative_opts = dict()
if model_name == 'model_nested_events':
check_derivative_opts['rtol'] = 1e-2
elif model_name == 'model_events':
check_derivative_opts['atol'] = 1e-3
if edata \
and solver.getSensitivityMethod() \
and solver.getSensitivityOrder() \
and len(model.getParameterList()) \
and not model_name.startswith('model_neuron') \
and not case.endswith('byhandpreeq'):
check_derivatives(model, solver, edata, assert_fun,
**check_derivative_opts)
verify_simulation_opts = dict()
if model_name.startswith('model_neuron'):
verify_simulation_opts['atol'] = 1e-5
verify_simulation_opts['rtol'] = 1e-2
if model_name.startswith('model_robertson') and \
case == 'sensiforwardSPBCG':
verify_simulation_opts['atol'] = 1e-3
verify_simulation_opts['rtol'] = 1e-3
verify_simulation_results(rdata,
expected_results[sub_test][case]['results'],
**verify_simulation_opts)
def test_special_likelihoods(model_special_likelihoods):
"""Test special likelihood functions."""
model = model_special_likelihoods.getModel()
model.setTimepoints(np.linspace(0, 60, 10))
solver = model.getSolver()
solver.setSensitivityOrder(amici.SensitivityOrder.first)
# Test in region with positive density
# run model once to create an edata
rdata = amici.runAmiciSimulation(model, solver)
edata = amici.ExpData(rdata, 0.001, 0)
# make sure measurements are smaller for non-degenerate probability
y = edata.getObservedData()
y = tuple([val * np.random.uniform(0, 1) for val in y])
edata.setObservedData(y)
# set sigmas
sigma = 0.2
sigmas = sigma * np.ones(len(y))
edata.setObservedDataStdDev(sigmas)
# and now run for real and also compute likelihood values
rdata = amici.runAmiciSimulations(model, solver, [edata])[0]
# check if the values make overall sense
assert np.isfinite(rdata['llh'])
assert np.all(np.isfinite(rdata['sllh']))
assert np.any(rdata['sllh'])
rdata_df = amici.getSimulationObservablesAsDataFrame(model,
edata,
rdata,
by_id=True)
edata_df = amici.getDataObservablesAsDataFrame(model, edata, by_id=True)
# check correct likelihood value
llh_exp = -sum([
binomial_nllh(edata_df['o1'], rdata_df['o1'], sigma),
negative_binomial_nllh(edata_df['o2'], rdata_df['o2'], sigma),
])
assert np.isclose(rdata['llh'], llh_exp)
# check gradient
for sensi_method in [
amici.SensitivityMethod.forward, amici.SensitivityMethod.adjoint
]:
solver = model.getSolver()
solver.setSensitivityMethod(sensi_method)
solver.setSensitivityOrder(amici.SensitivityOrder.first)
check_derivatives(model,
solver,
edata,
assert_fun,
atol=1e-1,
rtol=1e-1,
check_least_squares=False)
# Test for m > y, i.e. in region with 0 density
rdata = amici.runAmiciSimulation(model, solver)
edata = amici.ExpData(rdata, 0.001, 0)
# make sure measurements are smaller for non-degenerate probability
y = edata.getObservedData()
y = tuple([val * np.random.uniform(0.5, 3) for val in y])
edata.setObservedData(y)
edata.setObservedDataStdDev(sigmas)
# and now run for real and also compute likelihood values
rdata = amici.runAmiciSimulations(model, solver, [edata])[0]
# m > y -> outside binomial domain -> 0 density
assert rdata['llh'] == -np.inf
# check for non-informative gradient
assert all(np.isnan(rdata['sllh']))
def test_compare_to_pysb_simulation(example):
pysb = pytest.importorskip("pysb")
atol = 1e-8
rtol = 1e-8
with amici.add_path(os.path.dirname(pysb.examples.__file__)):
with amici.add_path(
os.path.join(os.path.dirname(__file__), '..', 'tests',
'pysb_test_models')):
if example == 'earm_1_3' \
and platform.sys.version_info[0] == 3 \
and platform.sys.version_info[1] < 7:
return
# load example
pysb.SelfExporter.cleanup() # reset pysb
pysb.SelfExporter.do_export = True
module = importlib.import_module(example)
pysb_model = module.model
pysb_model.name = pysb_model.name.replace('pysb.examples.', '')
# avoid naming clash for custom pysb models
pysb_model.name += '_amici'
# pysb part
tspan = np.linspace(0, 100, 101)
sim = ScipyOdeSimulator(pysb_model,
tspan=tspan,
integrator_options={
'rtol': rtol,
'atol': atol
},
compiler='python')
pysb_simres = sim.run()
# amici part
outdir = pysb_model.name
if pysb_model.name in ['move_connected_amici']:
with pytest.raises(Exception):
pysb2amici(pysb_model,
outdir,
verbose=logging.INFO,
compute_conservation_laws=True)
compute_conservation_laws = False
else:
compute_conservation_laws = True
pysb2amici(pysb_model,
outdir,
verbose=logging.INFO,
compute_conservation_laws=compute_conservation_laws,
observables=list(pysb_model.observables.keys()))
amici_model_module = amici.import_model_module(
pysb_model.name, outdir)
model_pysb = amici_model_module.getModel()
model_pysb.setTimepoints(tspan)
solver = model_pysb.getSolver()
solver.setMaxSteps(int(1e6))
solver.setAbsoluteTolerance(atol)
solver.setRelativeTolerance(rtol)
rdata = amici.runAmiciSimulation(model_pysb, solver)
# check agreement of species simulation
assert np.isclose(rdata['x'], pysb_simres.species, 1e-4,
1e-4).all()
if example not in [
'fricker_2010_apoptosis', 'fixed_initial',
'bngwiki_egfr_simple_deletemolecules'
]:
if example in [
'tyson_oscillator', 'bax_pore_sequential', 'bax_pore',
'kinase_cascade', 'bngwiki_egfr_simple',
'bngwiki_enzymatic_cycle_mm', 'bngwiki_simple'
]:
solver.setAbsoluteTolerance(1e-14)
solver.setRelativeTolerance(1e-14)
epsilon = 1e-4
else:
solver.setAbsoluteTolerance(1e-10)
solver.setRelativeTolerance(1e-10)
epsilon = 1e-3
model_pysb.setParameterScale(
parameterScalingFromIntVector([
ParameterScaling.log10
if p > 0 else ParameterScaling.none
for p in model_pysb.getParameters()
]))
check_derivatives(model_pysb,
solver,
epsilon=epsilon,
rtol=1e-2,
atol=1e-2,
skip_zero_pars=True)
shutil.rmtree(outdir, ignore_errors=True)