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)