def run_simulation(
drug_concs,
cell_line='A2058',
):
condition = conditions.loc[conditions.conditionId ==
f'TUMOR-{cell_line}-cellline-01-01', :]
if len(condition) == 0:
raise ValueError(
f'Requested cell-line "{cell_line}" has no condition data.')
# set the fixed parameters
for col in condition.columns:
if col in model.getFixedParameterIds():
model.setFixedParameterById(col, condition[col].values[0])
edata_ref = amici.ExpData(model.get())
for drug, conc in drug_concs.items():
parameter_id = model.getFixedParameterIds()[
model.getFixedParameterNames().index(drug)]
model.setFixedParameterById(parameter_id, conc)
print(f'{drug}: {conc}')
# extract simulation conditions that were specified in the model
edata_cond = amici.ExpData(model.get())
edatas = [edata_ref, edata_cond]
rdatas = amici.runAmiciSimulations(model, solver, edatas)
print(f'time to steadystate {rdatas[0]["t_steadystate"]}')
print(f'relative proliferation '
f'{rdatas[1]["y"][0, 0]/rdatas[0]["y"][0, 0]}')
return amici.getSimulationStatesAsDataFrame(model, edatas, rdatas)
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 edata_fixture():
"""edata is generated to test pre- and postequilibration"""
edata_pre = amici.ExpData(2, 0, 0,
np.array([0., 0.1, 0.2, 0.5, 1., 2., 5., 10.]))
edata_pre.setObservedData([1.5] * 16)
edata_pre.fixedParameters = np.array([5., 20.])
edata_pre.fixedParametersPreequilibration = np.array([0., 10.])
edata_pre.reinitializeFixedParameterInitialStates = True
# edata for postequilibration
edata_post = amici.ExpData(2, 0, 0, np.array([float('inf')] * 3))
edata_post.setObservedData([0.75] * 6)
edata_post.fixedParameters = np.array([7.5, 30.])
# edata with both equilibrations
edata_full = amici.ExpData(
2, 0, 0,
np.array([0., 0., 0., 1., 2., 2., 4.,
float('inf'),
float('inf')]))
edata_full.setObservedData([3.14] * 18)
edata_full.fixedParameters = np.array([1., 2.])
edata_full.fixedParametersPreequilibration = np.array([3., 4.])
edata_full.reinitializeFixedParameterInitialStates = True
return edata_pre, edata_post, edata_full
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 setUp(self):
self.resetdir = os.getcwd()
self.default_path = copy.copy(sys.path)
pysb.SelfExporter.cleanup() # reset pysb
pysb.SelfExporter.do_export = True
sys.path.insert(
0,
os.path.join(os.path.dirname(__file__), '..', 'python', 'examples',
'example_presimulation'))
if 'createModelPresimulation' in sys.modules:
importlib.reload(sys.modules['createModelPresimulation'])
model_module = sys.modules['createModelPresimulation']
else:
model_module = importlib.import_module('createModelPresimulation')
model = copy.deepcopy(model_module.model)
model.name = 'test_model_presimulation_pysb'
amici.pysb2amici(model,
model.name,
verbose=False,
observables=['pPROT_obs'],
constant_parameters=['DRUG_0', 'KIN_0'])
sys.path.insert(0, model.name)
import test_model_presimulation_pysb as modelModulePYSB
self.model = modelModulePYSB.getModel()
self.solver = self.model.getSolver()
self.solver.setSensitivityOrder(amici.SensitivityOrder_first)
self.solver.setSensitivityMethod(amici.SensitivityMethod_forward)
self.edata = get_data(self.model)
self.edata.fixedParametersPresimulation = ()
self.edata_preeq = amici.ExpData(self.edata)
self.edata_preeq.setTimepoints([0])
self.edata_sim = amici.ExpData(self.edata)
self.edata_sim.fixedParametersPreequilibration = ()
self.pscales = [
amici.ParameterScaling_log10, amici.ParameterScaling_ln,
amici.ParameterScaling_none,
amici.parameterScalingFromIntVector([
amici.ParameterScaling_log10, amici.ParameterScaling_ln,
amici.ParameterScaling_none, amici.ParameterScaling_log10,
amici.ParameterScaling_ln, amici.ParameterScaling_none
])
]
self.plists = [
[3, 1, 2, 4],
[0, 1, 2, 3, 4, 5],
[5, 3, 2, 0, 4, 1],
[1, 2, 3, 4, 5],
[1, 1, 1],
]
def preeq_fixture(pysb_example_presimulation_module):
model = pysb_example_presimulation_module.getModel()
model.setReinitializeFixedParameterInitialStates(True)
solver = model.getSolver()
solver.setSensitivityOrder(amici.SensitivityOrder.first)
solver.setSensitivityMethod(amici.SensitivityMethod.forward)
edata = get_data(model)
edata.t_presim = 2
edata.fixedParameters = [10, 2]
edata.fixedParametersPresimulation = [3, 2]
edata.fixedParametersPreequilibration = [3, 0]
edata.setTimepoints([1, 5])
edata_preeq = amici.ExpData(edata)
edata_preeq.t_presim = 0
edata_preeq.setTimepoints([np.infty])
edata_preeq.fixedParameters = \
edata.fixedParametersPreequilibration
edata_preeq.fixedParametersPresimulation = ()
edata_preeq.fixedParametersPreequilibration = ()
edata_presim = amici.ExpData(edata)
edata_presim.t_presim = 0
edata_presim.setTimepoints([edata.t_presim])
edata_presim.fixedParameters = \
edata.fixedParametersPresimulation
edata_presim.fixedParametersPresimulation = ()
edata_presim.fixedParametersPreequilibration = ()
edata_sim = amici.ExpData(edata)
edata_sim.t_presim = 0
edata_sim.setTimepoints(edata.getTimepoints())
edata_sim.fixedParameters = \
edata.fixedParameters
edata_sim.fixedParametersPresimulation = ()
edata_sim.fixedParametersPreequilibration = ()
pscales = [
amici.ParameterScaling.log10, amici.ParameterScaling.ln,
amici.ParameterScaling.none,
amici.parameterScalingFromIntVector([
amici.ParameterScaling.log10, amici.ParameterScaling.ln,
amici.ParameterScaling.none, amici.ParameterScaling.log10,
amici.ParameterScaling.ln, amici.ParameterScaling.none
])
]
plists = [
[3, 1, 2, 4], [0, 1, 2, 3, 4, 5], [5, 3, 2, 0, 4, 1],
[1, 2, 3, 4, 5], [1, 1, 1],
]
return (model, solver, edata, edata_preeq,
edata_presim, edata_sim, pscales, plists)
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)
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 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 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 create_edata_for_condition(
condition: Union[Dict, pd.Series],
amici_model: AmiciModel,
petab_problem: petab.Problem,
observable_ids: List[str],
) -> amici.ExpData:
"""Get :class:`amici.amici.ExpData` for the given PEtab condition.
Sets timepoints, observed data and sigmas.
:param condition:
pandas.DataFrame row with preequilibrationConditionId and
simulationConditionId.
:param amici_model:
AMICI model
:param petab_problem:
Underlying PEtab problem
:param observable_ids:
List of observable IDs
:return:
ExpData instance.
"""
# extract measurement table rows for condition
measurement_df = petab.get_rows_for_condition(
measurement_df=petab_problem.measurement_df, condition=condition)
if amici_model.nytrue != len(observable_ids):
raise AssertionError("Number of AMICI model observables does not "
"match number of PEtab observables.")
# create an ExpData object
edata = amici.ExpData(amici_model)
##########################################################################
# enable initial parameters reinitialization
species_in_condition_table = any(
col for col in petab_problem.condition_df
if petab_problem.sbml_model.getSpecies(col) is not None)
if condition.get(PREEQUILIBRATION_CONDITION_ID) \
and species_in_condition_table:
edata.reinitializeFixedParameterInitialStates = True
##########################################################################
# timepoints
# find replicate numbers of time points
timepoints_w_reps = _get_timepoints_with_replicates(
df_for_condition=measurement_df)
edata.setTimepoints(timepoints_w_reps)
##########################################################################
# measurements and sigmas
y, sigma_y = _get_measurements_and_sigmas(
df_for_condition=measurement_df, timepoints_w_reps=timepoints_w_reps,
observable_ids=observable_ids)
edata.setObservedData(y.flatten())
edata.setObservedDataStdDev(sigma_y.flatten())
return edata
def initialize(self, cell_line):
"""Prepares experiment for requested cell line.
Prepares simulator for experiment. It does though by giving the initial treatment zero
treatment to the cell after which it runs the simulation until it reaches a steady state.
Args:
cell_line: String specifying cell line to simulate.
Returns:
relative_proliferation: The proliferation rate for the zero treatment which is always 1.
Raises:
ValueError: If provided cell line is unknown.
"""
assert not self.initialized, "Simulator has already been initialized."
if self.zero_term is not None:
assert self.line == cell_line, "Need to modify initialization scheme in order to get new zero term."
self.model.setTimepoints([np.infty])
self.load_conditions(cell_line)
self.load_drug_concentrations(ZERO_TREATMENT)
# compute growth term for zero treatment only once
if self.zero_term is None:
edata_ref = amici.ExpData(self.model.get())
edatas = [edata_ref]
rdatas = amici.runAmiciSimulations(self.model, self.solver, edatas)
self.zero_term = rdatas[0]["y"][0, 0]
self.line = cell_line
self.R = 1
self.initialized = True
return self.R
def apply_treatment(self, concentrations, verbose=False):
'''Loads specified drug simulation into model and runs simulation for until next steady state.
Assumes simulator has been initialzed for specific cell line first
Args:
concentrations: Specifies the drug cocktail.
verbose: If set to true, prints drug concentrations.
Returns:
overall_proliferation_rate: Describes the overall proliferation of the cell line at the
at the time at which the stable state has been reached.
Raises:
AssertionError: If simulator has not been initialized.
'''
assert self.initialized, "Simulator has not been initialized before first use."
self.load_drug_concentrations(concentrations, verbose=verbose)
edata_cond = amici.ExpData(self.model.get())
edatas = [edata_cond]
rdatas = amici.runAmiciSimulations(self.model, self.solver, edatas)
cond_term = rdatas[0]["y"][0, 0]
self.R = self.R * (cond_term / self.zero_term)
if verbose:
print(f'time to steadystate {rdatas[0]["t_steadystate"]}')
print(f'relative proliferation' f'{self.R}')
return self.R
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 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 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 get_expdata_for_condition(self, model: 'amici.Model',
condition_idx: int):
"""Get ExpData for the given simulation condition"""
edata = amici.ExpData(model.get())
with h5py.File(self.filename, 'r') as f:
edata.setTimepoints(self._get_timepoints(f, condition_idx))
y = np.array(edata.getObservedData())
y = y.reshape((len(edata.getTimepoints()), model.ny), )
y[:, :] = self._get_measurements(f, condition_idx)
edata.setObservedData(y.flatten())
y = np.array(edata.getObservedDataStdDev())
y = y.reshape((len(edata.getTimepoints()), model.ny), )
y[:, :] = self._get_measurement_sigmas(f, condition_idx)
edata.setObservedDataStdDev(y.flatten())
preeq_cond_idx, sim_cond_idx = \
self._get_fixed_par_indices(f, condition_idx)
edata.fixedParameters = self._get_fixed_parameters(f, sim_cond_idx)
if preeq_cond_idx > 0:
edata.fixedParametersPreequilibration = \
self._get_fixed_parameters(f, preeq_cond_idx)
return edata
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_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 __deepcopy__(self, memodict=None):
other = self.__class__.__new__(self.__class__)
for key in set(self.__dict__.keys()) - \
set(['amici_model', 'amici_solver', 'edatas']):
other.__dict__[key] = copy.deepcopy(self.__dict__[key])
other.amici_model = amici.ModelPtr(self.amici_model.clone())
other.amici_solver = amici.SolverPtr(self.amici_solver.clone())
other.edatas = [amici.ExpData(data) for data in self.edatas]
return other
def __deepcopy__(self, memodict=None):
model = amici.ModelPtr(self.amici_model.clone())
solver = amici.SolverPtr(self.amici_solver.clone())
edata = [amici.ExpData(data) for data in self.edata]
other = AmiciObjective(model, solver, edata)
for attr in self.__dict__:
if attr not in [
'amici_solver', 'amici_model', 'edata',
'preequilibration_edata'
]:
other.__dict__[attr] = copy.deepcopy(self.__dict__[attr])
return other
def __deepcopy__(self, memodict=None):
model = amici.ModelPtr(self.amici_model.clone())
solver = amici.SolverPtr(self.amici_solver.clone())
edatas = [amici.ExpData(data) for data in self.edatas]
other = AmiciObjective(model,
solver,
edatas,
guess_steadystate=self.guess_steadystate)
for attr in self.__dict__:
if attr not in ['amici_solver', 'amici_model', 'edatas']:
other.__dict__[attr] = copy.deepcopy(self.__dict__[attr])
return other
def __deepcopy__(self, memodict: Dict = None) -> 'AmiciObjective':
other = self.__class__.__new__(self.__class__)
for key in set(self.__dict__.keys()) - \
{'amici_model', 'amici_solver', 'edatas'}:
other.__dict__[key] = copy.deepcopy(self.__dict__[key])
# copy objects that do not have __deepcopy__
other.amici_model = self.amici_model.clone()
other.amici_solver = self.amici_solver.clone()
other.edatas = [amici.ExpData(data) for data in self.edatas]
return other
def get_data(model):
solver = model.getSolver()
model.setTimepoints(np.linspace(0, 60, 61))
model.setSteadyStateSensitivityMode(
amici.SteadyStateSensitivityMode.simulationFSA)
rdata = amici.runAmiciSimulation(model, solver)
edata = amici.ExpData(rdata, 0.1, 0.0)
edata.t_presim = 2
edata.fixedParameters = [10, 2]
edata.fixedParametersPresimulation = [3, 2]
edata.fixedParametersPreequilibration = [3, 0]
edata.reinitializeFixedParameterInitialStates = True
return edata
def test_pandas_import_export(sbml_example_presimulation_module, case):
"""TestCase class for testing csv import using pandas"""
# setup
model = sbml_example_presimulation_module.getModel()
model.setTimepoints(np.linspace(0, 60, 61))
solver = model.getSolver()
rdata = amici.runAmiciSimulation(model, solver)
edata = [amici.ExpData(rdata, 0.01, 0)]
# test copy constructor
_ = amici.ExpData(edata[0])
for fp in case:
setattr(edata[0], fp, case[fp])
df_edata = amici.getDataObservablesAsDataFrame(model, edata)
edata_reconstructed = amici.getEdataFromDataFrame(model, df_edata)
for fp in [
'fixedParameters', 'fixedParametersPreequilibration',
'fixedParametersPresimulation'
]:
if fp != 'fixedParameters' or case[fp] != ():
assert getattr(edata[0], fp) == getattr(edata_reconstructed[0], fp)
assert case[fp] == getattr(edata_reconstructed[0], fp)
else:
assert model.getFixedParameters() \
== getattr(edata_reconstructed[0], fp)
assert model.getFixedParameters() == \
getattr(edata_reconstructed[0], fp)
assert getattr(edata[0], fp) == case[fp]
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 __deepcopy__(self, memodict: Dict = None) -> 'AmiciObjective':
other = self.__class__.__new__(self.__class__)
for key in set(self.__dict__.keys()) - \
{'amici_model', 'amici_solver', 'edatas'}:
other.__dict__[key] = copy.deepcopy(self.__dict__[key])
# copy objects that do not have __deepcopy__
other.amici_model = amici.ModelPtr(self.amici_model.clone())
other.amici_solver = amici.SolverPtr(self.amici_solver.clone())
other.edatas = [amici.ExpData(data) for data in self.edatas]
# rebind functions for __call__
other.rebind_fun()
other.rebind_res()
return other
def _simulationspecs_to_edatas(self) -> List:
""" Converts tspan, param_values and initials into amici.ExpData
objects """
n_sims = len(self.param_values)
edatas = [amici.ExpData(self.amici_model.get()) for _ in range(n_sims)]
for isim, edata in enumerate(edatas):
edata.setTimepoints(self.tspan)
edata.parameters = self._pysb2amici_parameters(
self.param_values[isim])
edata.fixedParameters = self._pysb2amici_fixed_parameters(
self.param_values[isim])
edata.x0 = self._pysb2amici_initials(self.initials[max(
isim,
len(self.initials) - 1)])
return edatas
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_scaled(self):
"""
Test SBML import and simulation from AMICI python interface
"""
def assert_fun(x):
return self.assertTrue(x)
sbmlFile = os.path.join(os.path.dirname(__file__), '..', 'python',
'examples', 'example_steadystate',
'model_steadystate_scaled.xml')
sbmlImporter = amici.SbmlImporter(sbmlFile)
observables = amici.assignmentRules2observables(
sbmlImporter.sbml,
filter_function=lambda variable:
variable.getId().startswith('observable_') and
not variable.getId().endswith('_sigma')
)
outdir = 'test_model_steadystate_scaled'
sbmlImporter.sbml2amici('test_model_steadystate_scaled',
outdir,
observables=observables,
constantParameters=['k0'],
sigmas={'observable_x1withsigma':
'observable_x1withsigma_sigma'})
sys.path.insert(0, outdir)
import test_model_steadystate_scaled as modelModule
model = modelModule.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)
self.assertTrue(
np.isclose(
amici.ExpDataView(edata[0])
['observedData'],
amici.ExpDataView(edata_reconstructed[0])
['observedData'],
).all()
)
self.assertTrue(
np.isclose(
amici.ExpDataView(edata[0])
['observedDataStdDev'],
amici.ExpDataView(edata_reconstructed[0])
['observedDataStdDev'],
).all()
)
if len(edata[0].fixedParameters):
self.assertListEqual(
list(edata[0].fixedParameters),
list(edata_reconstructed[0].fixedParameters),
)
else:
self.assertListEqual(
list(model.getFixedParameters()),
list(edata_reconstructed[0].fixedParameters),
)
self.assertListEqual(
list(edata[0].fixedParametersPreequilibration),
list(edata_reconstructed[0].fixedParametersPreequilibration),
)
df_state = amici.getSimulationStatesAsDataFrame(model, edata, rdata)
self.assertTrue(
np.isclose(
rdata[0]['x'],
df_state[list(model.getStateIds())].values
).all()
)
df_obs = amici.getSimulationObservablesAsDataFrame(model, edata, rdata)
self.assertTrue(
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)
