def test_presimulation(self):
sbmlFile = os.path.join(os.path.dirname(__file__), '..', 'python',
'examples', 'example_presimulation',
'model_presimulation.xml')
sbmlImporter = amici.SbmlImporter(sbmlFile)
constantParameters = ['DRUG_0', 'KIN_0']
observables = amici.assignmentRules2observables(
sbmlImporter.sbml, # the libsbml model object
filter_function=lambda variable: variable.getName() == 'pPROT')
outdir = 'test_model_presimulation'
sbmlImporter.sbml2amici('test_model_presimulation',
outdir,
verbose=False,
observables=observables,
constantParameters=constantParameters)
sys.path.insert(0, outdir)
import test_model_presimulation as modelModule
model = modelModule.getModel()
solver = model.getSolver()
model.setTimepoints(amici.DoubleVector(np.linspace(0, 60, 61)))
model.setReinitializeFixedParameterInitialStates(True)
rdata = amici.runAmiciSimulation(model, solver)
edata = amici.ExpData(rdata, 0.1, 0.0)
edata.fixedParameters = amici.DoubleVector([10, 2])
edata.fixedParametersPresimulation = amici.DoubleVector([10, 2])
edata.fixedParametersPreequilibration = amici.DoubleVector([3, 0])
self.assertIsInstance(amici.runAmiciSimulation(model, solver, edata),
dict)
def test_data_replicates(preeq_fixture):
"""Test data replicates"""
model, solver, edata, edata_preeq, \
edata_presim, edata_sim, pscales, plists = preeq_fixture
sensi_meth = amici.SensitivityMethod.forward
solver.setSensitivityMethod(sensi_meth)
# add infty timepoint
y = edata.getObservedData()
stdy = edata.getObservedDataStdDev()
ts = np.hstack([*edata.getTimepoints(), np.inf])
edata.setTimepoints(sorted(ts))
edata.setObservedData(np.hstack([y, y[0]]))
edata.setObservedDataStdDev(np.hstack([stdy, stdy[0]]))
rdata_single = amici.runAmiciSimulation(model, solver, edata)
# duplicate data and timepoints
y = edata.getObservedData()
stdy = edata.getObservedDataStdDev()
ts = np.hstack([*edata.getTimepoints(), *edata.getTimepoints()])
idx = np.argsort(ts)
edata.setTimepoints(sorted(ts))
edata.setObservedData(np.hstack([y, y])[idx])
edata.setObservedDataStdDev(np.hstack([stdy, stdy])[idx])
rdata_double = amici.runAmiciSimulation(model, solver, edata)
for variable in ['llh', 'sllh']:
assert np.isclose(
2*rdata_single[variable],
rdata_double[variable],
1e-6, 1e-6
).all(), dict(variable=variable, sensi_meth=sensi_meth)
def getReturnDataForCondition(model, solver, condition, simulationParameters,
sigmay):
model.setParameters(amici.DoubleVector(simulationParameters))
# simulate without measurements
edata = amici.ExpData(model.get())
edata.fixedParameters = amici.DoubleVector(condition)
edata.my = amici.DoubleVector(
np.full(shape=model.nt() * model.nytrue, fill_value=np.nan))
rdata = amici.runAmiciSimulation(model, solver, edata)
# fixedParametersPreequilibration =
# confirm gradient is 0 for real measurements and save expected llh
measurement = rdata['y']
measurement = np.random.normal(loc=rdata['y'], scale=sigmay)
measurement = np.random.normal(loc=rdata['y'], scale=sigmay[0][0])
# print(measurement)
edata.my = amici.DoubleVector(measurement.flatten())
edata.sigmay = amici.DoubleVector(sigmay.flatten())
model.requireSensitivitiesForAllParameters()
rdata = amici.runAmiciSimulation(model, solver, edata)
# return generated noisy measurents
rdata['y'] = measurement
return rdata
def test_raise_presimulation_with_adjoints(preeq_fixture):
"""Test data replicates"""
model, solver, edata, edata_preeq, \
edata_presim, edata_sim, pscales, plists = preeq_fixture
# preequilibration and presimulation with adjoints:
# this needs to fail unless we remove presimulation
solver.setSensitivityMethod(amici.SensitivityMethod.adjoint)
rdata = amici.runAmiciSimulation(model, solver, edata)
assert rdata['status'] == amici.AMICI_ERROR
# presimulation and postequilibration with adjoints:
# this also needs to fail
y = edata.getObservedData()
stdy = edata.getObservedDataStdDev()
# add infty timepoint
ts = np.hstack([*edata.getTimepoints(), np.inf])
edata.setTimepoints(sorted(ts))
edata.setObservedData(np.hstack([y, y[0]]))
edata.setObservedDataStdDev(np.hstack([stdy, stdy[0]]))
edata.t_presim = 0
edata.fixedParametersPresimulation = ()
# no presim any more, this should work
rdata = amici.runAmiciSimulation(model, solver, edata)
assert rdata['status'] == amici.AMICI_SUCCESS
def check_trajectories_with_forward_sensitivities(
amici_model: AmiciModel,
result_expected_x: np.ndarray,
result_expected_sx: np.ndarray,
):
"""
Check whether the forward sensitivities of the AMICI simulation match
a known solution (ideally an analytically calculated one).
"""
# Show that we can do arbitrary precision here (test 8 digits)
solver = amici_model.getSolver()
solver.setAbsoluteTolerance(1e-15)
solver.setSensitivityOrder(SensitivityOrder.first)
solver.setSensitivityMethod(SensitivityMethod.forward)
rdata = runAmiciSimulation(amici_model, solver=solver)
np.testing.assert_almost_equal(rdata['x'], result_expected_x, decimal=5)
np.testing.assert_almost_equal(rdata['sx'], result_expected_sx, decimal=5)
# Show that we can do arbitrary precision here (test 8 digits)
solver = amici_model.getSolver()
solver.setSensitivityOrder(SensitivityOrder.first)
solver.setSensitivityMethod(SensitivityMethod.forward)
solver.setAbsoluteTolerance(1e-15)
solver.setRelativeTolerance(1e-13)
solver.setAbsoluteToleranceFSA(1e-15)
solver.setRelativeToleranceFSA(1e-13)
rdata = runAmiciSimulation(amici_model, solver=solver)
np.testing.assert_almost_equal(rdata['x'], result_expected_x, decimal=8)
np.testing.assert_almost_equal(rdata['sx'], result_expected_sx, decimal=8)
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_parameter_in_expdata(preeq_fixture):
"""Test parameter in ExpData"""
model, solver, edata, edata_preeq, edata_presim, \
edata_sim, pscales, plists = preeq_fixture
rdata = amici.runAmiciSimulation(model, solver, edata)
# get initial states will compute initial states if nothing is set,
# this needs go first as we need unmodified model. Also set to
# preequilibration fixpars first as this is where initial states would be
# computed otherwise
model.setFixedParameters(edata.fixedParametersPreequilibration)
edata.x0 = model.getInitialStates()
edata.sx0 = model.getInitialStateSensitivities()
# perturb model initial states
model.setInitialStates(rdata['x_ss'] * 4)
model.setInitialStateSensitivities(rdata['sx_ss'].flatten() / 2)
# set ExpData plist
edata.plist = model.getParameterList()
# perturb model parameter list
model.setParameterList([
i for i in reversed(model.getParameterList())
])
# set ExpData parameters
edata.parameters = model.getParameters()
# perturb model parameters
model.setParameters(tuple(
p * 2 for p in model.getParameters()
))
# set ExpData pscale
edata.pscale = model.getParameterScale()
# perturb model pscale, needs to be done after getting parameters,
# otherwise we will mess up parameter value
model.setParameterScale(amici.parameterScalingFromIntVector([
amici.ParameterScaling.log10
if scaling == amici.ParameterScaling.none
else amici.ParameterScaling.none
for scaling in model.getParameterScale()
]))
rdata_edata = amici.runAmiciSimulation(
model, solver, edata
)
for variable in ['x', 'sx']:
assert np.isclose(
rdata[variable][0, :],
rdata_edata[variable][0, :],
1e-6, 1e-6
).all(), variable
def test_manual_preequilibration(preeq_fixture):
"""Manual preequilibration"""
model, solver, edata, edata_preeq, \
edata_presim, edata_sim, pscales, plists = preeq_fixture
settings = itertools.product(pscales, plists)
for pscale, plist in settings:
model.setInitialStates([])
model.setInitialStateSensitivities([])
model.setParameterList(plist)
model.setParameterScale(pscale)
# combined
rdata_auto = amici.runAmiciSimulation(model, solver, edata)
assert rdata_auto.status == amici.AMICI_SUCCESS
# manual preequilibration
rdata_preeq = amici.runAmiciSimulation(model, solver, edata_preeq)
assert rdata_preeq.status == amici.AMICI_SUCCESS
# manual reinitialization + presimulation
x0 = rdata_preeq['x'][0, :]
x0[1] = edata_presim.fixedParameters[0]
x0[2] = edata_presim.fixedParameters[1]
sx0 = rdata_preeq['sx'][0, :, :]
sx0[:, 1] = 0
sx0[:, 2] = 0
model.setInitialStates(x0)
model.setInitialStateSensitivities(sx0.flatten())
rdata_presim = amici.runAmiciSimulation(model, solver, edata_presim)
assert rdata_presim.status == amici.AMICI_SUCCESS
# manual reinitialization + simulation
x0 = rdata_presim['x'][0, :]
x0[1] = edata_sim.fixedParameters[0]
x0[2] = edata_sim.fixedParameters[1]
sx0 = rdata_presim['sx'][0, :, :]
sx0[:, 1] = 0
sx0[:, 2] = 0
model.setInitialStates(x0)
model.setInitialStateSensitivities(sx0.flatten())
rdata_sim = amici.runAmiciSimulation(model, solver, edata_sim)
assert rdata_sim.status == amici.AMICI_SUCCESS
for variable in ['x', 'sx']:
assert np.isclose(
rdata_auto[variable],
rdata_sim[variable],
1e-6, 1e-6
).all(), dict(pscale=pscale, plist=plist, variable=variable)
def test_parameter_in_expdata(preeq_fixture):
"""Test parameter in ExpData"""
model, solver, edata, edata_preeq, edata_presim, \
edata_sim, pscales, plists = preeq_fixture
rdata = amici.runAmiciSimulation(model, solver, edata)
# set ExpData plist
edata.plist = model.getParameterList()
# perturb model parameter list
model.setParameterList([
i for i in reversed(model.getParameterList())
])
# set ExpData parameters
edata.parameters = model.getParameters()
# perturb model parameters
model.setParameters(tuple(
p * 2 for p in model.getParameters()
))
# set ExpData pscale
edata.pscale = model.getParameterScale()
# perturb model pscale, needs to be done after getting parameters,
# otherwise we will mess up parameter value
model.setParameterScale(amici.parameterScalingFromIntVector([
amici.ParameterScaling_log10
if scaling == amici.ParameterScaling_none
else amici.ParameterScaling_none
for scaling in model.getParameterScale()
]))
edata.x0 = rdata['x_ss']
edata.sx0 = rdata['sx_ss'].flatten()
# perturb model initial states
model.setInitialStates(rdata['x_ss'] * 4)
model.setInitialStateSensitivities(rdata['sx_ss'].flatten() / 2)
rdata_edata = amici.runAmiciSimulation(
model, solver, edata
)
for variable in ['x', 'sx']:
assert np.isclose(
rdata[variable][0, :],
rdata_edata[variable][0, :],
1e-6, 1e-6
).all(), variable
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)
edata = [amici.ExpData(rdata, 1, 0)]
# just make all observables positive since some are logarithmic
for ed in edata:
y = ed.getObservedData()
y = tuple([max(val, 1e-4) for val in y])
ed.setObservedData(y)
# and now run for real and also compute likelihood values
rdata = amici.runAmiciSimulations(model, solver, edata)[0]
# output for easy debugging
for key in ['llh', 'sllh']:
print(key, rdata[key])
# it would be good to compute the expected llh+sllh by hand,
# here, we only check if they make overall sense
assert np.isfinite(rdata['llh'])
assert np.all(np.isfinite(rdata['sllh']))
assert np.any(rdata['sllh'])
def edata_objects(conversion_reaction_model):
testmodel = conversion_reaction_model
# set timepoints for which we want to simulate the model
testmodel.setTimepoints(np.linspace(0, 4, 10))
testmodel.setParameters(np.array([4.0, 0.4]))
# Create solver instance
solver = testmodel.getSolver()
# create edatas
rdatas = []
edatas = []
fixedParameters = [
np.array([2.0, 0.0]),
np.array([0.0, 4.0]),
np.array([1.0, 1.0]),
]
# create rdatas and edatas from those
for fp in fixedParameters:
testmodel.setFixedParameters(amici.DoubleVector(fp))
rdata = amici.runAmiciSimulation(testmodel, solver)
rdatas.append(rdata)
edatas.append(amici.ExpData(rdata, 1.0, 0))
return testmodel, solver, edatas
def simulate_AMICI(sbml_name: str):
"""
Compiles, simulates and plots the SBML in AMICI.
:param yaml_name:
:return:
"""
model_name = os.path.splitext(sbml_name)[0]
model_output_dir = 'AMICI_models'
sbml_importer = amici.SbmlImporter(sbml_name)
sbml_importer.sbml2amici(model_name, model_output_dir)
# import model
sys.path.insert(0, os.path.abspath(model_output_dir))
model_module = importlib.import_module(model_name)
# create model + solver instance
amici_model = model_module.getModel()
solver = amici_model.getSolver()
# Define time points ans run simulation using default model parameters/solver options
amici_model.setTimepoints(np.linspace(0, 5, 101))
rdata = amici.runAmiciSimulation(amici_model, solver)
return amici_model, rdata
def setUp(self):
self.default_path = copy.copy(sys.path)
self.resetdir = os.getcwd()
if os.path.dirname(__file__) != '':
os.chdir(os.path.dirname(__file__))
sbmlFile = os.path.join(os.path.dirname(__file__), '..', 'python',
'examples', 'example_presimulation',
'model_presimulation.xml')
sbmlImporter = amici.SbmlImporter(sbmlFile)
constantParameters = ['DRUG_0', 'KIN_0']
observables = amici.assignmentRules2observables(
sbmlImporter.sbml, # the libsbml model object
filter_function=lambda variable: variable.getName() == 'pPROT'
)
outdir = 'test_model_presimulation'
sbmlImporter.sbml2amici('test_model_presimulation',
outdir,
verbose=False,
observables=observables,
constantParameters=constantParameters)
sys.path.insert(0, outdir)
import test_model_presimulation as modelModule
self.model = modelModule.getModel()
self.model.setTimepoints(np.linspace(0, 60, 61))
self.solver = self.model.getSolver()
rdata = amici.runAmiciSimulation(self.model, self.solver)
self.edata = [amici.ExpData(rdata, 0.01, 0)]
# test copy constructor
self.edata_copy = amici.ExpData(self.edata[0])
def main():
arg, suffix = parse_args()
model_dir = os.path.join(os.curdir, 'CS_Signalling_ERBB_RAS_AKT',
'CS_Signalling_ERBB_RAS_AKT_petab' + suffix)
model_name = 'CS_Signalling_ERBB_RAS_AKT_petab'
if arg == 'import':
run_import(model_name)
return
elif arg == 'compile':
compile_model(model_name, model_dir)
return
else:
model_module = amici.import_model_module(model_name, model_dir)
model = model_module.getModel()
solver = model.getSolver()
# TODO
edata = amici.ExpData(model)
edata.setTimepoints([1e8])
edata.setObservedData([1.0])
edata.setObservedDataStdDev([1.0])
prepare_simulation(arg, model, solver, edata)
rdata = amici.runAmiciSimulation(model, solver, edata)
check_results(rdata)
def load_model_objective(example_name):
# name of the model that will also be the name of the python module
model_name = 'model_' + example_name
# sbml file
sbml_file = os.path.join('doc', 'example', example_name,
model_name + '.xml')
# directory to which the generated model code is written
model_output_dir = os.path.join('doc', 'example', 'tmp', model_name)
# import sbml model, compile and generate amici module
sbml_importer = amici.SbmlImporter(sbml_file)
sbml_importer.sbml2amici(model_name, model_output_dir, verbose=False)
# load amici module (the usual starting point later for the analysis)
sys.path.insert(0, os.path.abspath(model_output_dir))
model_module = importlib.import_module(model_name)
model = model_module.getModel()
model.requireSensitivitiesForAllParameters()
model.setTimepoints(np.linspace(0, 10, 11))
model.setParameterScale(amici.ParameterScaling_log10)
model.setParameters([-0.3, -0.7])
solver = model.getSolver()
solver.setSensitivityMethod(amici.SensitivityMethod_forward)
solver.setSensitivityOrder(amici.SensitivityOrder_first)
# generate experimental data
rdata = amici.runAmiciSimulation(model, solver, None)
edata = amici.ExpData(rdata, 0.05, 0.0)
return (pypesto.AmiciObjective(model, solver, [edata], 2), model)
def test_sbml_testsuite_case(test_number, result_path):
test_id = format_test_id(test_number)
try:
current_test_path = os.path.join(TEST_PATH, test_id)
# parse expected results
results_file = os.path.join(current_test_path,
test_id + '-results.csv')
results = np.genfromtxt(results_file, delimiter=',')
# setup model
model, solver, wrapper = compile_model(current_test_path, test_id)
settings = read_settings_file(current_test_path, test_id)
atol, rtol = apply_settings(settings, solver, model)
# simulate model
rdata = amici.runAmiciSimulation(model, solver)
# verify
simulated_x, x_ids = verify_results(settings, rdata, results, wrapper,
model, atol, rtol)
print(f'TestCase {test_id} passed.')
# record results
write_result_file(simulated_x, model, test_id, result_path, x_ids)
except amici.sbml_import.SBMLException as err:
pytest.skip(str(err))
def test_sbml_testsuite_case(test_number, result_path):
test_id = format_test_id(test_number)
try:
current_test_path = os.path.join(TEST_PATH, test_id)
# parse expected results
results_file = os.path.join(current_test_path,
test_id + '-results.csv')
results = pd.read_csv(results_file, delimiter=',')
results.rename(
columns={c: c.replace(' ', '')
for c in results.columns},
inplace=True)
# setup model
model, solver, wrapper = compile_model(current_test_path, test_id)
settings = read_settings_file(current_test_path, test_id)
atol, rtol = apply_settings(settings, solver, model)
# simulate model
rdata = amici.runAmiciSimulation(model, solver)
# verify
simulated = verify_results(settings, rdata, results, wrapper, model,
atol, rtol)
# record results
write_result_file(simulated, test_id, result_path)
except amici.sbml_import.SBMLException as err:
pytest.skip(str(err))
def test_parameter_reordering(self):
rdata_ordered = amici.runAmiciSimulation(self.model, self.solver,
self.edata)
for plist in self.plists:
with self.subTest(plist=plist):
self.model.setParameterList(plist)
rdata_reordered = amici.runAmiciSimulation(
self.model, self.solver, self.edata)
for ip, p_index in enumerate(plist):
self.assertTrue(
np.isclose(rdata_ordered['sx'][:, p_index, :],
rdata_reordered['sx'][:, ip, :], 1e-6,
1e-6).all())
def grad(x0, symbol='llh', x0full=None, plist=[], verbose=False):
"""Gradient which is to be checked"""
old_parameters = model.getParameters()
old_plist = model.getParameterList()
p = x0
if len(plist):
model.setParameterList(amici.IntVector(plist))
p = x0full[:]
p[plist] = x0
else:
model.requireSensitivitiesForAllParameters()
verbose and print('g: p=%s' % p)
model.setParameters(amici.DoubleVector(p))
rdata = amici.runAmiciSimulation(model, solver, edata)
model.setParameters(old_parameters)
model.setParameterList(old_plist)
res = rdata['s%s' % symbol]
if not isinstance(res, float):
if len(res.shape) == 2:
res = np.sum(res, axis=(0, ))
if len(res.shape) == 3:
res = np.sum(res, axis=(0, 2))
return res
def runTest(self):
'''
test runner routine that loads data expectedResults.h5 hdf file and runs individual models/settings
as subTests
'''
expectedResults = h5py.File(self.expectedResultsFile, 'r')
for subTest in expectedResults.keys():
for case in list(expectedResults[subTest].keys()):
if re.search('^sensi2', case) != None:
modelName = subTest + '_o2'
else:
modelName = subTest
with self.subTest(modelName=modelName, caseName=case):
print('running subTest modelName = ' + modelName +
', caseName = ' + case)
modelSwigFolder = os.path.join(
os.path.dirname(__file__), '..', 'build', 'tests',
'cpputest', 'external_' + modelName + '-prefix', 'src',
'external_' + modelName + '-build', 'swig')
sys.path.insert(0, modelSwigFolder)
testModelModule = importlib.import_module(modelName)
self.model = testModelModule.getModel()
self.solver = self.model.getSolver()
amici.readModelDataFromHDF5(
self.expectedResultsFile, self.model.get(),
"/" + subTest + "/" + case + "/options")
amici.readSolverSettingsFromHDF5(
self.expectedResultsFile, self.solver.get(),
"/" + subTest + "/" + case + "/options")
edata = None
if 'data' in expectedResults[subTest][case].keys():
edata = amici.readSimulationExpData(
self.expectedResultsFile,
"/" + subTest + "/" + case + "/data",
self.model.get())
rdata = amici.runAmiciSimulation(self.model, self.solver,
edata)
if edata and self.solver.getSensitivityMethod(
) and self.solver.getSensitivityOrder():
if not modelName.startswith('model_neuron'):
if (self.solver.getSensitivityOrder()
and len(self.model.getParameterList())):
checkDerivatives(self.model, self.solver,
edata)
if modelName == 'model_neuron_o2':
self.solver.setRelativeTolerance(1e-12)
verifySimulationResults(
rdata,
expectedResults[subTest][case]['results'],
atol=1e-6,
rtol=1e-2)
else:
verifySimulationResults(
rdata, expectedResults[subTest][case]['results'])
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 get_results(model, edata):
solver = model.getSolver()
solver.setSensitivityOrder(1)
edata.reinitializeFixedParameterInitialStates = True
model.setTimepoints(np.linspace(0, 60, 61))
model.setSteadyStateSensitivityMode(
amici.SteadyStateSensitivityMode.simulationFSA)
return amici.runAmiciSimulation(model, solver, edata)
def test_presimulation(self):
def assert_fun(x):
return self.assertTrue(x)
sbmlFile = os.path.join(os.path.dirname(__file__), '..', 'python',
'examples', 'example_presimulation',
'model_presimulation.xml')
sbmlImporter = amici.SbmlImporter(sbmlFile)
constantParameters = ['DRUG_0', 'KIN_0']
observables = amici.assignmentRules2observables(
sbmlImporter.sbml, # the libsbml model object
filter_function=lambda variable: variable.getName() == 'pPROT_obs'
)
outdir = 'test_model_presimulation'
sbmlImporter.sbml2amici('test_model_presimulation',
outdir,
verbose=False,
observables=observables,
constantParameters=constantParameters)
sys.path.insert(0, outdir)
import test_model_presimulation as modelModule
model = modelModule.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]
self.assertIsInstance(
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_models(model):
amici_model, parameters, timepoints, x_pected, sx_pected = model
result_expected_x = np.array(
[x_pected(t, **parameters) for t in timepoints])
result_expected_sx = np.array(
[sx_pected(t, **parameters) for t in timepoints])
# --- Test the state trajectories without sensitivities -------------------
# Does the AMICI simulation match the analytical solution?
solver = amici_model.getSolver()
rdata = runAmiciSimulation(amici_model, solver=solver)
solver.setAbsoluteTolerance(1e-15)
np.testing.assert_almost_equal(rdata['x'], result_expected_x, decimal=5)
# Show that we can do arbitrary precision here (test 8 digits)
solver = amici_model.getSolver()
solver.setAbsoluteTolerance(1e-15)
solver.setRelativeTolerance(1e-12)
rdata = runAmiciSimulation(amici_model, solver=solver)
np.testing.assert_almost_equal(rdata['x'], result_expected_x, decimal=8)
# --- Test the state trajectories with sensitivities ----------------------
# Does the AMICI simulation match the analytical solution?
solver = amici_model.getSolver()
solver.setSensitivityOrder(SensitivityOrder.first)
solver.setSensitivityMethod(SensitivityMethod.forward)
solver.setAbsoluteTolerance(1e-15)
rdata = runAmiciSimulation(amici_model, solver=solver)
np.testing.assert_almost_equal(rdata['x'], result_expected_x, decimal=5)
np.testing.assert_almost_equal(rdata['sx'], result_expected_sx, decimal=5)
# Show that we can do arbitrary precision here (test 8 digits)
solver = amici_model.getSolver()
solver.setSensitivityOrder(SensitivityOrder.first)
solver.setSensitivityMethod(SensitivityMethod.forward)
solver.setAbsoluteTolerance(1e-15)
solver.setRelativeTolerance(1e-13)
solver.setAbsoluteToleranceFSA(1e-15)
solver.setRelativeToleranceFSA(1e-13)
rdata = runAmiciSimulation(amici_model, solver=solver)
np.testing.assert_almost_equal(rdata['x'], result_expected_x, decimal=8)
np.testing.assert_almost_equal(rdata['sx'], result_expected_sx, decimal=8)
def test_parameter_reordering(preeq_fixture):
"""Test parameter reordering"""
model, solver, edata, edata_preeq, \
edata_presim, edata_sim, pscales, plists = preeq_fixture
rdata_ordered = amici.runAmiciSimulation(model, solver, edata)
for plist in plists:
model.setParameterList(plist)
rdata_reordered = amici.runAmiciSimulation(model, solver, edata)
for ip, p_index in enumerate(plist):
assert np.isclose(
rdata_ordered['sx'][:, p_index, :],
rdata_reordered['sx'][:, ip, :],
1e-6, 1e-6
).all(), plist
def main():
arg = sys.argv[1]
model = model_module.getModel()
solver = model.getSolver()
# TODO
edata = amici.ExpData(model)
edata.setTimepoints([1e8])
edata.setObservedData([1.0])
edata.setObservedDataStdDev([1.0])
if arg == 'forward_simulation':
solver.setSensitivityMethod(amici.SensitivityMethod.none)
solver.setSensitivityOrder(amici.SensitivityOrder.none)
elif arg == 'forward_sensitivities':
model.setParameterList(list(range(100)))
solver.setSensitivityMethod(amici.SensitivityMethod.forward)
solver.setSensitivityOrder(amici.SensitivityOrder.first)
elif arg == 'adjoint_sensitivities':
solver.setSensitivityMethod(amici.SensitivityMethod.adjoint)
solver.setSensitivityOrder(amici.SensitivityOrder.first)
elif arg == 'forward_simulation_non_optimal_parameters':
tmpPar = model.getParameters()
model.setParameters([0.1 for _ in tmpPar])
solver.setSensitivityMethod(amici.SensitivityMethod.none)
solver.setSensitivityOrder(amici.SensitivityOrder.none)
elif arg == 'adjoint_sensitivities_non_optimal_parameters':
tmpPar = model.getParameters()
model.setParameters([0.1 for _ in tmpPar])
solver.setSensitivityMethod(amici.SensitivityMethod.adjoint)
solver.setSensitivityOrder(amici.SensitivityOrder.first)
elif arg == 'forward_steadystate_sensitivities_non_optimal_parameters':
tmpPar = model.getParameters()
model.setParameters([0.1 for _ in tmpPar])
solver.setSensitivityMethod(amici.SensitivityMethod.forward)
solver.setSensitivityOrder(amici.SensitivityOrder.first)
edata.setTimepoints([float('inf')])
elif arg == 'adjoint_steadystate_sensitivities_non_optimal_parameters':
tmpPar = model.getParameters()
model.setParameters([0.1 for _ in tmpPar])
solver.setSensitivityMethod(amici.SensitivityMethod.adjoint)
solver.setSensitivityOrder(amici.SensitivityOrder.first)
edata.setTimepoints([float('inf')])
else:
print("Unknown argument:", arg)
sys.exit(1)
rdata = amici.runAmiciSimulation(model, solver, edata)
diagnostics = [
'numsteps', 'numstepsB', 'numrhsevals', 'numrhsevalsB',
'numerrtestfails', 'numerrtestfailsB', 'numnonlinsolvconvfails',
'numnonlinsolvconvfailsB'
]
for d in diagnostics:
print(d, rdata[d])
assert rdata['status'] == amici.AMICI_SUCCESS
def test_units(model_units_module):
"""
Test whether SBML import works for models using sbml:units annotations.
"""
model = model_units_module.getModel()
model.setTimepoints(np.linspace(0, 1, 101))
solver = model.getSolver()
rdata = amici.runAmiciSimulation(model, solver)
assert rdata['status'] == amici.AMICI_SUCCESS
def getReturnDataForCondition(model, solver, fixed_parameters,
dynamic_parameters, sigmay,
sigma_parameter_observable_idx,
sigma_parameter_idx):
model.setParameters(amici.DoubleVector(dynamic_parameters))
# Simulate without measurements for noise-free trajectories
edata = amici.ExpData(model.get())
edata.fixedParameters = fixed_parameters
edata.my = np.full(shape=model.nt() * model.nytrue, fill_value=np.nan)
rdata = amici.runAmiciSimulation(model, solver, edata)
# fixedParametersPreequilibration =
# synthetic_data = rdata['y'] # noise-free
# Add noise to simulation
synthetic_data = np.random.normal(loc=rdata['y'], scale=sigmay)
print("\tSigma mean per observable:", sigmay.mean(axis=0))
# Apply correct sigma parameter
synthetic_data[:, sigma_parameter_observable_idx] = \
np.random.normal(loc=rdata['y'][:, sigma_parameter_observable_idx],
scale=dynamic_parameters[sigma_parameter_idx])
# due to noise, there may be negative measurements. we don't want them.
synthetic_data = np.abs(synthetic_data)
print("\tMean abs. relative measurement error per observable:")
print("\t",
np.mean(np.abs((synthetic_data - rdata['y']) / rdata['y']), axis=0))
# Use synthetic data to get expected llh
edata.my = synthetic_data.flatten()
edata.sigmay = sigmay.flatten()
solver.setSensitivityMethod(amici.SensitivityMethod_forward)
solver.setSensitivityOrder(amici.SensitivityOrder_first)
model.requireSensitivitiesForAllParameters()
rdata = amici.runAmiciSimulation(model, solver, edata)
# TODO: confirm gradient is 0 for real measurements and save expected llh
# return generated noisy measurements
rdata._swigptr.y = amici.DoubleVector(synthetic_data.flatten())
return rdata
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 check_trajectories_without_sensitivities(
amici_model: AmiciModel,
result_expected_x: np.ndarray,
):
"""
Check whether the AMICI simulation matches a known solution
(ideally an analytically calculated one).
"""
# Does the AMICI simulation match the analytical solution?
solver = amici_model.getSolver()
solver.setAbsoluteTolerance(1e-15)
rdata = runAmiciSimulation(amici_model, solver=solver)
np.testing.assert_almost_equal(rdata['x'], result_expected_x, decimal=5)
# Show that we can do arbitrary precision here (test 8 digits)
solver = amici_model.getSolver()
solver.setAbsoluteTolerance(1e-15)
solver.setRelativeTolerance(1e-12)
rdata = runAmiciSimulation(amici_model, solver=solver)
np.testing.assert_almost_equal(rdata['x'], result_expected_x, decimal=8)
