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