From 7d23f50f41297825eb1e1c00f3855e1f7df90d9f Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Wed, 3 Jan 2024 19:34:57 +0100 Subject: [PATCH 01/12] Add AmiciPetabProblem class for handling PEtab-defined simulation conditions Makes it a bit easier to work with PEtab problems interactively or when implementing some PEtab-based objective function (#962). --- python/sdist/amici/petab/petab_problem.py | 253 ++++++++++++++++++++++ 1 file changed, 253 insertions(+) create mode 100644 python/sdist/amici/petab/petab_problem.py diff --git a/python/sdist/amici/petab/petab_problem.py b/python/sdist/amici/petab/petab_problem.py new file mode 100644 index 0000000000..8a205cebdd --- /dev/null +++ b/python/sdist/amici/petab/petab_problem.py @@ -0,0 +1,253 @@ +"""PEtab-problem based simulations.""" +import copy +from typing import Optional, Sequence, Union + +import amici +import pandas as pd +import petab +from petab.C import ( + DATASET_ID, + NOISE_PARAMETERS, + OBSERVABLE_ID, + PREEQUILIBRATION_CONDITION_ID, + SIMULATION, + SIMULATION_CONDITION_ID, + TIME, +) + +from .conditions import create_edatas, fill_in_parameters +from .parameter_mapping import create_parameter_mapping + + +class AmiciPetabProblem: + """Manage experimental conditions based on a PEtab problem definition. + + Create :class:`ExpData` objects from a PEtab problem definition, handle + parameter scales and parameter mapping. + + :param petab_problem: PEtab problem definition. + :param amici_model: AMICI model + :param amici_solver: AMICI solver (Solver with default options will be + used if not provided). + :param problem_parameters: Problem parameters to use for simulation + (default: PEtab nominal values and model values). + :param scaled_parameters: Whether the provided parameters are on PEtab + `parameterScale` or not. + :param simulation_conditions: Simulation conditions to use for simulation. + It Can be used to subset the conditions in the PEtab problem. + All subsequent operations will only be performed based on that subset. + By default, all conditions are used. + :param store_edatas: Whether to create and store all ExpData objects for + all conditions upfront. If set to False, ExpData objects will be + created and disposed of on the fly during simulation. This can save + memory if many conditions are simulated. + """ + + def __init__( + self, + petab_problem: petab.Problem, + amici_model: amici.Model, + problem_parameters: Optional[dict[str, float]] = None, + # move to a separate AmiciPetabProblemSimulator class? + amici_solver: Optional[amici.Solver] = None, + scaled_parameters: Optional[bool] = False, + simulation_conditions: Union[pd.DataFrame, list[dict]] = None, + store_edatas: bool = True, + ): + self._petab_problem = petab_problem + self._amici_model = amici_model + self._amici_solver = amici_solver + self._scaled_parameters = scaled_parameters + + self._simulation_conditions = simulation_conditions or ( + petab_problem.get_simulation_conditions_from_measurement_df() + ) + if not isinstance(self._simulation_conditions, pd.DataFrame): + self._simulation_conditions = pd.DataFrame( + self._simulation_conditions + ) + if ( + preeq_id := PREEQUILIBRATION_CONDITION_ID + in self._simulation_conditions + ): + self._simulation_conditions[ + preeq_id + ] = self._simulation_conditions[preeq_id].fillna("") + + if problem_parameters is None: + # Use PEtab nominal values as default + self._problem_parameters = self._default_parameters() + if scaled_parameters is True: + raise NotImplementedError( + "scaled_parameters=True in combination with default " + "parameters is not implemented yet." + ) + scaled_parameters = False + else: + self._problem_parameters = problem_parameters + self._scaled_parameters = scaled_parameters + + if store_edatas: + self._parameter_mapping = create_parameter_mapping( + petab_problem=self._petab_problem, + simulation_conditions=self._simulation_conditions, + scaled_parameters=self._scaled_parameters, + amici_model=self._amici_model, + ) + + self._create_edatas() + else: + self._parameter_mapping = None + self._edatas = None + + def set_parameters( + self, + problem_parameters: dict[str, float], + scaled_parameters: bool = False, + ): + """Set problem parameters. + + :param problem_parameters: Problem parameters to use for simulation. + :param scaled_parameters: Whether the provided parameters are on PEtab + `parameterScale` or not. + """ + if scaled_parameters != self._scaled_parameters: + # redo parameter mapping if scale changed + self._parameter_mapping = create_parameter_mapping( + petab_problem=self._petab_problem, + simulation_conditions=self._simulation_conditions, + scaled_parameters=scaled_parameters, + amici_model=self._amici_model, + ) + + self._problem_parameters = problem_parameters + self._scaled_parameters = scaled_parameters + + if self._edatas: + fill_in_parameters( + edatas=self._edatas, + problem_parameters=self._problem_parameters, + scaled_parameters=self._scaled_parameters, + parameter_mapping=self._parameter_mapping, + amici_model=self._amici_model, + ) + + def get_edata( + self, condition_id: str, preequilibration_condition_id: str + ) -> amici.ExpData: + """Get ExpData object for a given condition. + + NOTE: If `store_edatas=True` was passed to the constructor and the + returned object is modified, the changes will be reflected in the + internal ExpData objects. Also, if parameter values of + AmiciPetabProblem are changed, all ExpData objects will be updated. + Create a deep copy if you want to avoid this. + + :param condition_id: PEtab Condition ID + :param preequilibration_condition_id: PEtab Preequilibration condition ID + :return: ExpData object + """ + # exists or has to be created? + if self._edatas: + edata_id = condition_id + if preequilibration_condition_id: + edata_id += "+" + preequilibration_condition_id + + for edata in self._edatas: + if edata.id == edata_id: + return edata + + return self._create_edata(condition_id, preequilibration_condition_id) + + def get_edatas(self): + """Get all ExpData objects. + + NOTE: If `store_edatas=True` was passed to the constructor and the + returned objects are modified, the changes will be reflected in the + internal ExpData objects. Also, if parameter values of + AmiciPetabProblem are changed, all ExpData objects will be updated. + Create a deep copy if you want to avoid this. + + :return: List of ExpData objects + """ + if self._edatas: + # shallow copy + return self._edatas.copy() + + # not storing edatas - create and return + self._create_edatas() + result = self._edatas + self._edatas = [] + return result + + def _create_edata( + self, condition_id: str, preequilibration_condition_id: str + ) -> amici.ExpData: + """Create ExpData object for a given condition. + + :param condition_id: PEtab Condition ID + :param preequilibration_condition_id: PEtab Preequilibration condition ID + :return: ExpData object + """ + simulation_condition = pd.DataFrame( + [ + { + SIMULATION_CONDITION_ID: condition_id, + PREEQUILIBRATION_CONDITION_ID: preequilibration_condition_id + or "", + } + ] + ) + edatas = create_edatas( + amici_model=self._amici_model, + petab_problem=self._petab_problem, + simulation_conditions=simulation_condition, + ) + parameter_mapping = create_parameter_mapping( + petab_problem=self._petab_problem, + simulation_conditions=simulation_condition, + scaled_parameters=self._scaled_parameters, + amici_model=self._amici_model, + ) + + # Fill parameters in ExpDatas (in-place) + fill_in_parameters( + edatas=edatas, + problem_parameters=self._problem_parameters, + scaled_parameters=self._scaled_parameters, + parameter_mapping=parameter_mapping, + amici_model=self._amici_model, + ) + + if len(edatas) != 1: + raise AssertionError("Expected exactly one ExpData object.") + return edatas[0] + + @property + def solver(self): + """Get the solver.""" + return self._amici_solver or self._amici_model.getSolver() + + def _create_edatas( + self, + ): + """Create ExpData objects from PEtab problem definition.""" + self._edatas = create_edatas( + amici_model=self._amici_model, + petab_problem=self._petab_problem, + simulation_conditions=self._simulation_conditions, + ) + + fill_in_parameters( + edatas=self._edatas, + problem_parameters=self._problem_parameters, + scaled_parameters=self._scaled_parameters, + parameter_mapping=self._parameter_mapping, + amici_model=self._amici_model, + ) + + def _default_parameters(self) -> dict[str, float]: + return { + t.Index: getattr(t, petab.NOMINAL_VALUE) + for t in self._petab_problem.parameter_df.itertuples() + } From f2f0d127d9f66b4026fccc67c872614f41a07e15 Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Thu, 4 Jan 2024 18:19:03 +0100 Subject: [PATCH 02/12] Remove solver --- python/sdist/amici/petab/petab_problem.py | 25 +++-------------------- 1 file changed, 3 insertions(+), 22 deletions(-) diff --git a/python/sdist/amici/petab/petab_problem.py b/python/sdist/amici/petab/petab_problem.py index 8a205cebdd..df5b59a02b 100644 --- a/python/sdist/amici/petab/petab_problem.py +++ b/python/sdist/amici/petab/petab_problem.py @@ -1,19 +1,11 @@ """PEtab-problem based simulations.""" import copy -from typing import Optional, Sequence, Union +from typing import Optional, Union import amici import pandas as pd import petab -from petab.C import ( - DATASET_ID, - NOISE_PARAMETERS, - OBSERVABLE_ID, - PREEQUILIBRATION_CONDITION_ID, - SIMULATION, - SIMULATION_CONDITION_ID, - TIME, -) +from petab.C import PREEQUILIBRATION_CONDITION_ID, SIMULATION_CONDITION_ID from .conditions import create_edatas, fill_in_parameters from .parameter_mapping import create_parameter_mapping @@ -27,8 +19,6 @@ class AmiciPetabProblem: :param petab_problem: PEtab problem definition. :param amici_model: AMICI model - :param amici_solver: AMICI solver (Solver with default options will be - used if not provided). :param problem_parameters: Problem parameters to use for simulation (default: PEtab nominal values and model values). :param scaled_parameters: Whether the provided parameters are on PEtab @@ -48,15 +38,12 @@ def __init__( petab_problem: petab.Problem, amici_model: amici.Model, problem_parameters: Optional[dict[str, float]] = None, - # move to a separate AmiciPetabProblemSimulator class? - amici_solver: Optional[amici.Solver] = None, scaled_parameters: Optional[bool] = False, simulation_conditions: Union[pd.DataFrame, list[dict]] = None, store_edatas: bool = True, ): - self._petab_problem = petab_problem + self._petab_problem = copy.deepcopy(petab_problem) self._amici_model = amici_model - self._amici_solver = amici_solver self._scaled_parameters = scaled_parameters self._simulation_conditions = simulation_conditions or ( @@ -94,7 +81,6 @@ def __init__( scaled_parameters=self._scaled_parameters, amici_model=self._amici_model, ) - self._create_edatas() else: self._parameter_mapping = None @@ -223,11 +209,6 @@ def _create_edata( raise AssertionError("Expected exactly one ExpData object.") return edatas[0] - @property - def solver(self): - """Get the solver.""" - return self._amici_solver or self._amici_model.getSolver() - def _create_edatas( self, ): From d726c8f363ca46df7d96d3e8b5c888b9f8d5cc82 Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Mon, 8 Jan 2024 12:17:16 +0100 Subject: [PATCH 03/12] .. --- python/sdist/amici/petab/petab_problem.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/python/sdist/amici/petab/petab_problem.py b/python/sdist/amici/petab/petab_problem.py index df5b59a02b..2e3a000f97 100644 --- a/python/sdist/amici/petab/petab_problem.py +++ b/python/sdist/amici/petab/petab_problem.py @@ -55,8 +55,7 @@ def __init__( ) if ( preeq_id := PREEQUILIBRATION_CONDITION_ID - in self._simulation_conditions - ): + ) in self._simulation_conditions: self._simulation_conditions[ preeq_id ] = self._simulation_conditions[preeq_id].fillna("") From 82a9409498acc94c1dc869fd73b1cdbd80a67d81 Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Mon, 8 Jan 2024 14:32:52 +0100 Subject: [PATCH 04/12] test --- python/sdist/amici/petab/conditions.py | 9 +++- python/sdist/amici/petab/petab_problem.py | 58 ++++++++++++++++++++--- python/sdist/setup.cfg | 1 + python/tests/petab/test_petab_problem.py | 53 +++++++++++++++++++++ 4 files changed, 112 insertions(+), 9 deletions(-) create mode 100644 python/tests/petab/test_petab_problem.py diff --git a/python/sdist/amici/petab/conditions.py b/python/sdist/amici/petab/conditions.py index 5b9d87e5cf..f0e7e7721a 100644 --- a/python/sdist/amici/petab/conditions.py +++ b/python/sdist/amici/petab/conditions.py @@ -395,7 +395,11 @@ def create_edatas( if PREEQUILIBRATION_CONDITION_ID in simulation_conditions: measurement_groupvar.append(petab.PREEQUILIBRATION_CONDITION_ID) measurement_dfs = dict( - list(petab_problem.measurement_df.groupby(measurement_groupvar)) + list( + petab_problem.measurement_df.fillna( + {PREEQUILIBRATION_CONDITION_ID: ""} + ).groupby(measurement_groupvar) + ) ) edatas = [] @@ -404,10 +408,11 @@ def create_edatas( if PREEQUILIBRATION_CONDITION_ID in condition: measurement_index = ( condition.get(SIMULATION_CONDITION_ID), - condition.get(PREEQUILIBRATION_CONDITION_ID), + condition.get(PREEQUILIBRATION_CONDITION_ID) or "", ) else: measurement_index = (condition.get(SIMULATION_CONDITION_ID),) + edata = create_edata_for_condition( condition=condition, amici_model=amici_model, diff --git a/python/sdist/amici/petab/petab_problem.py b/python/sdist/amici/petab/petab_problem.py index 2e3a000f97..6be89a6c67 100644 --- a/python/sdist/amici/petab/petab_problem.py +++ b/python/sdist/amici/petab/petab_problem.py @@ -36,14 +36,21 @@ class AmiciPetabProblem: def __init__( self, petab_problem: petab.Problem, - amici_model: amici.Model, + amici_model: Optional[amici.Model] = None, problem_parameters: Optional[dict[str, float]] = None, scaled_parameters: Optional[bool] = False, simulation_conditions: Union[pd.DataFrame, list[dict]] = None, store_edatas: bool = True, ): self._petab_problem = copy.deepcopy(petab_problem) - self._amici_model = amici_model + + if amici_model is not None: + self._amici_model = amici_model + else: + from .petab_import import import_petab_problem + + self._amici_model = import_petab_problem(petab_problem) + self._scaled_parameters = scaled_parameters self._simulation_conditions = simulation_conditions or ( @@ -93,6 +100,7 @@ def set_parameters( """Set problem parameters. :param problem_parameters: Problem parameters to use for simulation. + This may be a subset of all parameters. :param scaled_parameters: Whether the provided parameters are on PEtab `parameterScale` or not. """ @@ -105,7 +113,25 @@ def set_parameters( amici_model=self._amici_model, ) - self._problem_parameters = problem_parameters + if set(self._problem_parameters) - set(problem_parameters): + # not all parameters are provided - update + # bring previously set parameters to the same scale if necessary + if scaled_parameters and not self._scaled_parameters: + self._problem_parameters = ( + self._petab_problem.scale_parameters( + self._problem_parameters, + ) + ) + elif not scaled_parameters and self._scaled_parameters: + self._problem_parameters = ( + self._petab_problem.unscale_parameters( + self._problem_parameters, + ) + ) + self._problem_parameters |= problem_parameters + else: + self._problem_parameters = problem_parameters + self._scaled_parameters = scaled_parameters if self._edatas: @@ -118,7 +144,7 @@ def set_parameters( ) def get_edata( - self, condition_id: str, preequilibration_condition_id: str + self, condition_id: str, preequilibration_condition_id: str = None ) -> amici.ExpData: """Get ExpData object for a given condition. @@ -160,6 +186,12 @@ def get_edatas(self): return self._edatas.copy() # not storing edatas - create and return + self._parameter_mapping = create_parameter_mapping( + petab_problem=self._petab_problem, + simulation_conditions=self._simulation_conditions, + scaled_parameters=self._scaled_parameters, + amici_model=self._amici_model, + ) self._create_edatas() result = self._edatas self._edatas = [] @@ -179,7 +211,7 @@ def _create_edata( { SIMULATION_CONDITION_ID: condition_id, PREEQUILIBRATION_CONDITION_ID: preequilibration_condition_id - or "", + or None, } ] ) @@ -198,7 +230,11 @@ def _create_edata( # Fill parameters in ExpDatas (in-place) fill_in_parameters( edatas=edatas, - problem_parameters=self._problem_parameters, + problem_parameters={ + p: self._problem_parameters[p] + for p in parameter_mapping.free_symbols + if p in self._problem_parameters + }, scaled_parameters=self._scaled_parameters, parameter_mapping=parameter_mapping, amici_model=self._amici_model, @@ -227,7 +263,15 @@ def _create_edatas( ) def _default_parameters(self) -> dict[str, float]: + """Get unscaled default parameters.""" return { t.Index: getattr(t, petab.NOMINAL_VALUE) - for t in self._petab_problem.parameter_df.itertuples() + for t in self._petab_problem.parameter_df[ + self._petab_problem.parameter_df[petab.ESTIMATE] == 1 + ].itertuples() } + + @property + def model(self) -> amici.Model: + """AMICI model.""" + return self._amici_model diff --git a/python/sdist/setup.cfg b/python/sdist/setup.cfg index 5ae8e1e742..bf0e61cdd5 100644 --- a/python/sdist/setup.cfg +++ b/python/sdist/setup.cfg @@ -46,6 +46,7 @@ zip_safe = False petab = petab>=0.2.1 pysb = pysb>=1.13.1 test = + benchmark_models_petab @ git+https://github.com/Benchmarking-Initiative/Benchmark-Models-PEtab.git@master#subdirectory=src/python h5py pytest pytest-cov diff --git a/python/tests/petab/test_petab_problem.py b/python/tests/petab/test_petab_problem.py new file mode 100644 index 0000000000..467b146116 --- /dev/null +++ b/python/tests/petab/test_petab_problem.py @@ -0,0 +1,53 @@ +from amici.petab.petab_problem import AmiciPetabProblem +from benchmark_models_petab import get_problem + + +def test_amici_petab_problem_pregenerate(): + """AmiciPetabProblem with pre-generated ExpDatas""" + petab_problem = get_problem("Boehm_JProteomeRes2014") + + # generate all edatas upon construction + app = AmiciPetabProblem(petab_problem, store_edatas=True) + assert len(app._edatas) == len( + petab_problem.get_simulation_conditions_from_measurement_df() + ) + + for i, (_, condition) in enumerate( + petab_problem.get_simulation_conditions_from_measurement_df().iterrows() + ): + assert app.get_edata(condition.simulationConditionId) is app._edatas[i] + + # ensure parameter are updated + app.set_parameters( + {app.model.getParameterIds()[0]: 0.12345}, scaled_parameters=True + ) + for edata in app._edatas: + assert edata.parameters[0] == 0.12345 + + +def test_amici_petab_problem_on_demand(): + """AmiciPetabProblem with on-demand ExpDatas""" + petab_problem = get_problem("Boehm_JProteomeRes2014") + + # generate all edatas upon construction + app = AmiciPetabProblem(petab_problem, store_edatas=False) + assert not app._edatas + + assert len(app.get_edatas()) == len( + petab_problem.get_simulation_conditions_from_measurement_df() + ) + + # ensure parameter are updated + app.set_parameters( + {app.model.getParameterIds()[0]: 0.12345}, scaled_parameters=True + ) + for edata in app.get_edatas(): + assert edata.parameters[0] == 0.12345 + + some_sim_condition = ( + petab_problem.measurement_df.simulationConditionId.iloc[0] + ) + # different objects + assert app.get_edata(some_sim_condition) is not app.get_edata( + some_sim_condition + ) From 625f2b31242ff63ac12795fb29c94ae9179ec189 Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Tue, 9 Jan 2024 12:21:03 +0100 Subject: [PATCH 05/12] test more --- python/tests/petab/test_petab_problem.py | 44 ++++++++++++++++++++---- 1 file changed, 37 insertions(+), 7 deletions(-) diff --git a/python/tests/petab/test_petab_problem.py b/python/tests/petab/test_petab_problem.py index 467b146116..03b670da60 100644 --- a/python/tests/petab/test_petab_problem.py +++ b/python/tests/petab/test_petab_problem.py @@ -4,36 +4,43 @@ def test_amici_petab_problem_pregenerate(): """AmiciPetabProblem with pre-generated ExpDatas""" + # any example is fine - the only assumption is that we don't have + # preequilibration petab_problem = get_problem("Boehm_JProteomeRes2014") - - # generate all edatas upon construction app = AmiciPetabProblem(petab_problem, store_edatas=True) + + # ensure all edatas are generated upon construction assert len(app._edatas) == len( petab_problem.get_simulation_conditions_from_measurement_df() ) + # ensure the cached edatas are returned for i, (_, condition) in enumerate( petab_problem.get_simulation_conditions_from_measurement_df().iterrows() ): assert app.get_edata(condition.simulationConditionId) is app._edatas[i] # ensure parameter are updated + edatas = app.get_edatas() app.set_parameters( {app.model.getParameterIds()[0]: 0.12345}, scaled_parameters=True ) - for edata in app._edatas: + for edata in edatas: assert edata.parameters[0] == 0.12345 def test_amici_petab_problem_on_demand(): """AmiciPetabProblem with on-demand ExpDatas""" + # any example is fine - the only assumption is that we don't have + # preequilibration petab_problem = get_problem("Boehm_JProteomeRes2014") - - # generate all edatas upon construction app = AmiciPetabProblem(petab_problem, store_edatas=False) + + # ensure no edatas are generated upon construction assert not app._edatas - assert len(app.get_edatas()) == len( + edatas = app.get_edatas() + assert len(edatas) == len( petab_problem.get_simulation_conditions_from_measurement_df() ) @@ -41,13 +48,36 @@ def test_amici_petab_problem_on_demand(): app.set_parameters( {app.model.getParameterIds()[0]: 0.12345}, scaled_parameters=True ) + # previously generated ExpDatas are not updated + for edata in edatas: + assert edata.parameters[0] != 0.12345 + # but newly generated ExpDatas are for edata in app.get_edatas(): assert edata.parameters[0] == 0.12345 some_sim_condition = ( petab_problem.measurement_df.simulationConditionId.iloc[0] ) - # different objects + # different objects for subsequent calls assert app.get_edata(some_sim_condition) is not app.get_edata( some_sim_condition ) + + +def test_amici_petab_problem_pregenerate_equals_on_demand(): + """Check that AmiciPetabProblem produces the same ExpDatas + independent of the `store_edatas` parameter.""" + # any example is fine + petab_problem = get_problem("Boehm_JProteomeRes2014") + app_store_true = AmiciPetabProblem(petab_problem, store_edatas=True) + app_store_false = AmiciPetabProblem(petab_problem, store_edatas=False) + + parameter_update = {app_store_true.model.getParameterIds()[0]: 0.12345} + app_store_true.set_parameters(parameter_update, scaled_parameters=True) + app_store_false.set_parameters(parameter_update, scaled_parameters=True) + + for edata_store_true, edata_store_false in zip( + app_store_true.get_edatas(), app_store_false.get_edatas() + ): + assert edata_store_true is not edata_store_false + assert edata_store_true == edata_store_false From 717918933909689c8c8347feeb17547fd4fec55b Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Tue, 9 Jan 2024 12:54:57 +0100 Subject: [PATCH 06/12] doc --- python/sdist/amici/petab/petab_problem.py | 34 +++++++++++------------ 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/python/sdist/amici/petab/petab_problem.py b/python/sdist/amici/petab/petab_problem.py index 6be89a6c67..bb6806fbd3 100644 --- a/python/sdist/amici/petab/petab_problem.py +++ b/python/sdist/amici/petab/petab_problem.py @@ -14,7 +14,7 @@ class AmiciPetabProblem: """Manage experimental conditions based on a PEtab problem definition. - Create :class:`ExpData` objects from a PEtab problem definition, handle + Create :class:`ExpData` objects from a PEtab problem definition, and handle parameter scales and parameter mapping. :param petab_problem: PEtab problem definition. @@ -24,13 +24,13 @@ class AmiciPetabProblem: :param scaled_parameters: Whether the provided parameters are on PEtab `parameterScale` or not. :param simulation_conditions: Simulation conditions to use for simulation. - It Can be used to subset the conditions in the PEtab problem. - All subsequent operations will only be performed based on that subset. + It can be used to subset the conditions in the PEtab problem. + All subsequent operations will only be performed on that subset. By default, all conditions are used. - :param store_edatas: Whether to create and store all ExpData objects for - all conditions upfront. If set to False, ExpData objects will be - created and disposed of on the fly during simulation. This can save - memory if many conditions are simulated. + :param store_edatas: Whether to create and store all `ExpData` objects for + all conditions upfront. If set to ``False``, `ExpData` objects will be + created and disposed of on the fly during simulation. The latter saves + memory if the given PEtab problem comprises many simulation conditions. """ def __init__( @@ -148,14 +148,14 @@ def get_edata( ) -> amici.ExpData: """Get ExpData object for a given condition. - NOTE: If `store_edatas=True` was passed to the constructor and the + NOTE: If ``store_edatas=True`` was passed to the constructor and the returned object is modified, the changes will be reflected in the - internal ExpData objects. Also, if parameter values of - AmiciPetabProblem are changed, all ExpData objects will be updated. + internal `ExpData` objects. Also, if parameter values of + `AmiciPetabProblem` are changed, all `ExpData` objects will be updated. Create a deep copy if you want to avoid this. - :param condition_id: PEtab Condition ID - :param preequilibration_condition_id: PEtab Preequilibration condition ID + :param condition_id: PEtab condition ID + :param preequilibration_condition_id: PEtab preequilibration condition ID :return: ExpData object """ # exists or has to be created? @@ -173,10 +173,10 @@ def get_edata( def get_edatas(self): """Get all ExpData objects. - NOTE: If `store_edatas=True` was passed to the constructor and the + NOTE: If ``store_edatas=True`` was passed to the constructor and the returned objects are modified, the changes will be reflected in the - internal ExpData objects. Also, if parameter values of - AmiciPetabProblem are changed, all ExpData objects will be updated. + internal `ExpData` objects. Also, if parameter values of + `AmiciPetabProblem` are changed, all `ExpData` objects will be updated. Create a deep copy if you want to avoid this. :return: List of ExpData objects @@ -202,8 +202,8 @@ def _create_edata( ) -> amici.ExpData: """Create ExpData object for a given condition. - :param condition_id: PEtab Condition ID - :param preequilibration_condition_id: PEtab Preequilibration condition ID + :param condition_id: PEtab condition ID + :param preequilibration_condition_id: PEtab preequilibration condition ID :return: ExpData object """ simulation_condition = pd.DataFrame( From ce7a3d9a59b302f96bd42e90262f3a959d59502f Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Tue, 16 Jan 2024 09:46:03 +0100 Subject: [PATCH 07/12] Avoid warning when simulating with default parameters --- python/sdist/amici/petab/simulations.py | 78 ++++++++++--------------- 1 file changed, 30 insertions(+), 48 deletions(-) diff --git a/python/sdist/amici/petab/simulations.py b/python/sdist/amici/petab/simulations.py index bc42ebcfd3..fb64a01ce7 100644 --- a/python/sdist/amici/petab/simulations.py +++ b/python/sdist/amici/petab/simulations.py @@ -106,11 +106,14 @@ def simulate_petab( Experimental data. Parameters are inserted in-place for simulation. :param parameter_mapping: Optional precomputed PEtab parameter mapping for efficiency, as - generated by :py:func:`create_parameter_mapping`. + generated by :py:func:`create_parameter_mapping` with + ``scaled_parameters=True``. :param scaled_parameters: If ``True``, ``problem_parameters`` are assumed to be on the scale provided in the PEtab parameter table and will be unscaled. If ``False``, they are assumed to be in linear scale. + If `parameter_mapping` is provided, this must match the value of + `scaled_parameters` used to generate the mapping. :param log_level: Log level, see :mod:`amici.logging` module. :param num_threads: @@ -139,14 +142,6 @@ def simulate_petab( if solver is None: solver = amici_model.getSolver() - # Switch to scaled parameters. - problem_parameters = _default_scaled_parameters( - petab_problem=petab_problem, - problem_parameters=problem_parameters, - scaled_parameters=scaled_parameters, - ) - scaled_parameters = True - # number of amici simulations will be number of unique # (preequilibrationConditionId, simulationConditionId) pairs. # Can be optimized by checking for identical condition vectors. @@ -164,10 +159,35 @@ def simulate_petab( parameter_mapping = create_parameter_mapping( petab_problem=petab_problem, simulation_conditions=simulation_conditions, - scaled_parameters=scaled_parameters, + # we will always use scaled parameters internally + scaled_parameters=True, amici_model=amici_model, ) + if problem_parameters is None: + # scaled PEtab nominal values + problem_parameters = dict( + zip( + petab_problem.x_ids, + petab_problem.x_nominal_scaled, + ) + ) + # depending on `fill_fixed_parameters` for parameter mapping, the + # parameter mapping may contain values instead of symbols for fixed + # parameters. In this case, we need to filter them here to avoid + # warnings in `fill_in_parameters`. + free_parameters = parameter_mapping.free_symbols + problem_parameters = { + par_id: par_value + for par_id, par_value in problem_parameters.items() + if par_id in free_parameters + } + + elif not scaled_parameters: + problem_parameters = petab_problem.scale_parameters(problem_parameters) + + scaled_parameters = True + # Get edatas if edatas is None: # Generate ExpData with all condition-specific information @@ -460,41 +480,3 @@ def rdatas_to_simulation_df( ) return df.rename(columns={MEASUREMENT: SIMULATION}) - - -def _default_scaled_parameters( - petab_problem: petab.Problem, - problem_parameters: Optional[Dict[str, float]] = None, - scaled_parameters: bool = False, -) -> Optional[Dict[str, float]]: - """ - Helper method to handle an unscaled or unspecified parameter vector. - - The parameter vector defaults to the nominal values in the PEtab - parameter table. - - Unscaled parameter values are scaled. - - :param petab_problem: - The PEtab problem. - :param problem_parameters: - Keys are PEtab parameter IDs, values are parameter values on the scale - defined in the PEtab parameter table. Defaults to the nominal values in - the PEtab parameter table. - :param scaled_parameters: - Whether `problem_parameters` are on the scale defined in the PEtab - parameter table. - - :return: - The scaled parameter vector. - """ - if problem_parameters is None: - problem_parameters = dict( - zip( - petab_problem.x_ids, - petab_problem.x_nominal_scaled, - ) - ) - elif not scaled_parameters: - problem_parameters = petab_problem.scale_parameters(problem_parameters) - return problem_parameters From 4932f8321bef7b69de9218eab7bfc71ceb733fea Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Tue, 16 Jan 2024 09:47:01 +0100 Subject: [PATCH 08/12] petab notebook makeover --- python/examples/example_petab/petab.ipynb | 404 ++++++++-------------- 1 file changed, 153 insertions(+), 251 deletions(-) diff --git a/python/examples/example_petab/petab.ipynb b/python/examples/example_petab/petab.ipynb index 3e8c523829..3417d807dd 100644 --- a/python/examples/example_petab/petab.ipynb +++ b/python/examples/example_petab/petab.ipynb @@ -6,299 +6,115 @@ "source": [ "# Using PEtab\n", "\n", - "This notebook illustrates how to use [PEtab](https://github.com/petab-dev/petab) with AMICI." + "This notebook illustrates how to run model simulations based on [PEtab](https://github.com/petab-dev/petab) problems with AMICI.\n", + "\n", + "PEtab is a format for specifying parameter estimation problems in systems biology. It is based on [SBML](http://sbml.org/) and [TSV](https://en.wikipedia.org/wiki/Tab-separated_values) files. (AMICI also supports PySB-based PEtab problems, that will be covered by PEtab v2). The Python package [pyPESTO](https://pypesto.readthedocs.io/) provides a convenient interface for parameter estimation with PEtab problems and uses AMICI as a backend. However, AMICI can also be used directly to simulate PEtab problems. This is illustrated in this notebook." ] }, { "cell_type": "code", - "execution_count": 1, - "metadata": {}, + "execution_count": 34, + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-16T08:41:40.592406548Z", + "start_time": "2024-01-16T08:41:40.123041782Z" + } + }, "outputs": [], "source": [ - "from amici.petab.petab_import import import_petab_problem\n", - "from amici.petab.simulations import simulate_petab\n", "import petab\n", "\n", - "import os" + "from amici import runAmiciSimulation\n", + "from amici.petab.petab_import import import_petab_problem\n", + "from amici.petab.petab_problem import AmiciPetabProblem\n", + "from amici.petab.simulations import simulate_petab\n", + "from amici.plotting import plot_state_trajectories" ] }, { "cell_type": "markdown", - "metadata": {}, "source": [ - "We use an example model from the [benchmark collection](https://github.com/Benchmarking-Initiative/Benchmark-Models-PEtab):" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Cloning into 'tmp/benchmark-models'...\n", - "remote: Enumerating objects: 142, done.\u001B[K\n", - "remote: Counting objects: 100% (142/142), done.\u001B[K\n", - "remote: Compressing objects: 100% (122/122), done.\u001B[K\n", - "remote: Total 142 (delta 41), reused 104 (delta 18), pack-reused 0\u001B[K\n", - "Receiving objects: 100% (142/142), 648.29 KiB | 1.23 MiB/s, done.\n", - "Resolving deltas: 100% (41/41), done.\n" - ] - } + "## Importing a PEtab problem" ], - "source": [ - "!git clone --depth 1 https://github.com/Benchmarking-Initiative/Benchmark-Models-PEtab.git tmp/benchmark-models || (cd tmp/benchmark-models && git pull)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "total 68\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Alkan_SciSignal2018\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Beer_MolBioSystems2014\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Boehm_JProteomeRes2014\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Borghans_BiophysChem1997\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Brannmark_JBC2010\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Bruno_JExpBio2016\r\n", - "-rwxr-xr-x 1 yannik yannik 654 Mär 17 15:27 checkBenchmarkModels.py\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Chen_MSB2009\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Crauste_CellSystems2017\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Elowitz_Nature2000\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Fiedler_BMC2016\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Fujita_SciSignal2010\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Perelson_Science1996\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Rahman_MBS2016\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Sneyd_PNAS2002\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Weber_BMC2015\r\n", - "drwxr-xr-x 2 yannik yannik 4096 Mär 17 15:27 Zheng_PNAS2012\r\n" - ] - } - ], - "source": [ - "folder_base = \"tmp/benchmark-models/Benchmark-Models/\"\n", - "!ls -l $folder_base" - ] + "metadata": { + "collapsed": false + } }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We import a model to PEtab from a provided yaml file:" + "We use the [Boehm_JProteomeRes2014](https://github.com/Benchmarking-Initiative/Benchmark-Models-PEtab/tree/master/Benchmark-Models/Boehm_JProteomeRes2014) example model from the [benchmark collection](https://github.com/Benchmarking-Initiative/Benchmark-Models-PEtab):" ] }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-16T08:18:36.136056659Z", + "start_time": "2024-01-16T08:18:33.485169485Z" + } + }, "outputs": [], "source": [ "model_name = \"Boehm_JProteomeRes2014\"\n", - "yaml_file = os.path.join(folder_base, model_name, model_name + \".yaml\")\n", - "petab_problem = petab.Problem.from_yaml(yaml_file)" + "# local path or URL to the yaml file for the PEtab problem\n", + "petab_yaml = f\"https://raw.githubusercontent.com/Benchmarking-Initiative/Benchmark-Models-PEtab/master/Benchmark-Models/{model_name}/{model_name}.yaml\"\n", + "# load the problem using the PEtab library\n", + "petab_problem = petab.Problem.from_yaml(petab_yaml)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Next, we import the model to amici, compile it and obtain a function handle:" + "\n", + "Next, we import the model to amici using `import_petab_problem`. `import_petab_problem` has many options to choose between faster importer or more flexible or faster model simulations. We import the model with default settings, and we obtain an AMICI model instance:" ] }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2020-03-17 15:27:27.586 - amici.petab_import - INFO - Importing model ...\n", - "2020-03-17 15:27:27.593 - amici.petab_import - INFO - Model name is 'Boehm_JProteomeRes2014'. Writing model code to '/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014'.\n", - "2020-03-17 15:27:27.598 - amici.petab_import - INFO - Species: 8\n", - "2020-03-17 15:27:27.599 - amici.petab_import - INFO - Global parameters: 9\n", - "2020-03-17 15:27:27.599 - amici.petab_import - INFO - Reactions: 9\n", - "2020-03-17 15:27:27.715 - amici.petab_import - INFO - Observables: 3\n", - "2020-03-17 15:27:27.715 - amici.petab_import - INFO - Sigmas: 3\n", - "2020-03-17 15:27:27.722 - amici.petab_import - DEBUG - Adding output parameters to model: OrderedDict([('noiseParameter1_pSTAT5A_rel', None), ('noiseParameter1_pSTAT5B_rel', None), ('noiseParameter1_rSTAT5A_rel', None)])\n", - "2020-03-17 15:27:27.725 - amici.petab_import - DEBUG - Condition table: (1, 1)\n", - "2020-03-17 15:27:27.726 - amici.petab_import - DEBUG - Fixed parameters are []\n", - "2020-03-17 15:27:27.728 - amici.petab_import - INFO - Overall fixed parameters: 0\n", - "2020-03-17 15:27:27.729 - amici.petab_import - INFO - Variable parameters: 12\n", - "2020-03-17 15:27:27.735 - amici.sbml_import - INFO - Finished processing SBML parameters (1.25E-03s)\n", - "2020-03-17 15:27:27.749 - amici.sbml_import - INFO - Finished processing SBML species (1.26E-02s)\n", - "2020-03-17 15:27:27.829 - amici.sbml_import - INFO - Finished processing SBML reactions (7.41E-02s)\n", - "2020-03-17 15:27:27.833 - amici.sbml_import - INFO - Finished processing SBML compartments (4.23E-04s)\n", - "2020-03-17 15:27:27.898 - amici.sbml_import - INFO - Finished processing SBML rules (6.47E-02s)\n", - "2020-03-17 15:27:28.012 - amici.sbml_import - INFO - Finished processing SBML observables (6.77E-02s)\n", - "2020-03-17 15:27:28.139 - amici.ode_export - INFO - Finished writing J.cpp (1.14E-01s)\n", - "2020-03-17 15:27:28.160 - amici.ode_export - INFO - Finished writing JB.cpp (2.04E-02s)\n", - "2020-03-17 15:27:28.167 - amici.ode_export - INFO - Finished writing JDiag.cpp (6.41E-03s)\n", - "2020-03-17 15:27:28.187 - amici.ode_export - INFO - Finished writing JSparse.cpp (1.91E-02s)\n", - "2020-03-17 15:27:28.217 - amici.ode_export - INFO - Finished writing JSparseB.cpp (2.73E-02s)\n", - "2020-03-17 15:27:28.236 - amici.ode_export - INFO - Finished writing Jy.cpp (1.65E-02s)\n", - "2020-03-17 15:27:28.344 - amici.ode_export - INFO - Finished writing dJydsigmay.cpp (1.07E-01s)\n", - "2020-03-17 15:27:28.389 - amici.ode_export - INFO - Finished writing dJydy.cpp (3.99E-02s)\n", - "2020-03-17 15:27:28.466 - amici.ode_export - INFO - Finished writing dwdp.cpp (7.61E-02s)\n", - "2020-03-17 15:27:28.473 - amici.ode_export - INFO - Finished writing dwdx.cpp (5.87E-03s)\n", - "2020-03-17 15:27:28.497 - amici.ode_export - INFO - Finished writing dxdotdw.cpp (2.32E-02s)\n", - "2020-03-17 15:27:28.533 - amici.ode_export - INFO - Finished writing dxdotdp_explicit.cpp (3.38E-02s)\n", - "2020-03-17 15:27:28.756 - amici.ode_export - INFO - Finished writing dydx.cpp (1.98E-01s)\n", - "2020-03-17 15:27:28.910 - amici.ode_export - INFO - Finished writing dydp.cpp (1.53E-01s)\n", - "2020-03-17 15:27:28.926 - amici.ode_export - INFO - Finished writing dsigmaydp.cpp (1.40E-02s)\n", - "2020-03-17 15:27:28.931 - amici.ode_export - INFO - Finished writing sigmay.cpp (2.46E-03s)\n", - "2020-03-17 15:27:28.950 - amici.ode_export - INFO - Finished writing w.cpp (1.55E-02s)\n", - "2020-03-17 15:27:28.967 - amici.ode_export - INFO - Finished writing x0.cpp (1.57E-02s)\n", - "2020-03-17 15:27:28.975 - amici.ode_export - INFO - Finished writing x0_fixedParameters.cpp (4.78E-03s)\n", - "2020-03-17 15:27:29.027 - amici.ode_export - INFO - Finished writing sx0.cpp (5.01E-02s)\n", - "2020-03-17 15:27:29.069 - amici.ode_export - INFO - Finished writing sx0_fixedParameters.cpp (3.14E-02s)\n", - "2020-03-17 15:27:29.104 - amici.ode_export - INFO - Finished writing xdot.cpp (3.43E-02s)\n", - "2020-03-17 15:27:29.129 - amici.ode_export - INFO - Finished writing y.cpp (2.16E-02s)\n", - "2020-03-17 15:27:29.136 - amici.ode_export - INFO - Finished writing x_rdata.cpp (4.95E-03s)\n", - "2020-03-17 15:27:29.138 - amici.ode_export - INFO - Finished writing total_cl.cpp (6.59E-04s)\n", - "2020-03-17 15:27:29.147 - amici.ode_export - INFO - Finished writing x_solver.cpp (7.72E-03s)\n", - "2020-03-17 15:27:29.166 - amici.ode_export - INFO - Finished generating cpp code (1.14E+00s)\n", - "2020-03-17 15:27:46.200 - amici.ode_export - INFO - Finished compiling cpp code (1.70E+01s)\n", - "2020-03-17 15:27:46.204 - amici.petab_import - INFO - Finished Importing PEtab model (1.86E+01s)\n", - "2020-03-17 15:27:46.209 - amici.petab_import - INFO - Successfully loaded model Boehm_JProteomeRes2014 from /home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "running build_ext\n", - "building 'Boehm_JProteomeRes2014._Boehm_JProteomeRes2014' extension\n", - "swigging swig/Boehm_JProteomeRes2014.i to swig/Boehm_JProteomeRes2014_wrap.cpp\n", - "swig -python -c++ -modern -outdir Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/swig -I/home/yannik/amici/python/sdist/amici/include -o swig/Boehm_JProteomeRes2014_wrap.cpp swig/Boehm_JProteomeRes2014.i\n", - "creating build\n", - "creating build/temp.linux-x86_64-3.7\n", - "creating build/temp.linux-x86_64-3.7/swig\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c swig/Boehm_JProteomeRes2014_wrap.cpp -o build/temp.linux-x86_64-3.7/swig/Boehm_JProteomeRes2014_wrap.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dxdotdw.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdw.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_total_cl.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_total_cl.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_x_rdata.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_x_rdata.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dxdotdp_implicit_colptrs.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdp_implicit_colptrs.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dsigmaydp.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dsigmaydp.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_y.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_y.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dydp.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dydp.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_w.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_w.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_JSparseB_rowvals.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JSparseB_rowvals.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dxdotdw_rowvals.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdw_rowvals.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dwdx_rowvals.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dwdx_rowvals.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_x0.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_x0.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dwdx.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dwdx.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dJydy_colptrs.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dJydy_colptrs.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_JSparseB.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JSparseB.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_JSparseB_colptrs.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JSparseB_colptrs.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dxdotdp_explicit_colptrs.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdp_explicit_colptrs.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_sx0_fixedParameters.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_sx0_fixedParameters.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_JSparse_rowvals.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JSparse_rowvals.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dxdotdp_explicit.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdp_explicit.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dJydy.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dJydy.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dwdp_colptrs.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dwdp_colptrs.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_x0_fixedParameters.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_x0_fixedParameters.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dxdotdw_colptrs.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdw_colptrs.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dJydsigmay.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dJydsigmay.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dxdotdp_implicit_rowvals.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdp_implicit_rowvals.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dwdp.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dwdp.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_sx0.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_sx0.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_JB.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JB.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dwdx_colptrs.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dwdx_colptrs.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c wrapfunctions.cpp -o build/temp.linux-x86_64-3.7/wrapfunctions.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_x_solver.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_x_solver.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_JSparse.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JSparse.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_xdot.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_xdot.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dJydy_rowvals.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dJydy_rowvals.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dwdp_rowvals.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dwdp_rowvals.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_JSparse_colptrs.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JSparse_colptrs.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_J.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_J.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dydx.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dydx.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_JDiag.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JDiag.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_Jy.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_Jy.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_sigmay.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_sigmay.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "gcc -pthread -B /home/yannik/anaconda3/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014 -I/home/yannik/amici/python/sdist/amici/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/gsl -I/home/yannik/amici/python/sdist/amici/ThirdParty/sundials/include -I/home/yannik/amici/python/sdist/amici/ThirdParty/SuiteSparse/include -I/usr/include/hdf5/serial -I/home/yannik/anaconda3/include/python3.7m -c Boehm_JProteomeRes2014_dxdotdp_explicit_rowvals.cpp -o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdp_explicit_rowvals.o -std=c++14\n", - "cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++\n", - "g++ -pthread -shared -B /home/yannik/anaconda3/compiler_compat -L/home/yannik/anaconda3/lib -Wl,-rpath=/home/yannik/anaconda3/lib -Wl,--no-as-needed -Wl,--sysroot=/ build/temp.linux-x86_64-3.7/swig/Boehm_JProteomeRes2014_wrap.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdw.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_total_cl.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_x_rdata.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdp_implicit_colptrs.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dsigmaydp.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_y.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dydp.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_w.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JSparseB_rowvals.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdw_rowvals.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dwdx_rowvals.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_x0.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dwdx.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dJydy_colptrs.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JSparseB.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JSparseB_colptrs.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdp_explicit_colptrs.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_sx0_fixedParameters.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JSparse_rowvals.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdp_explicit.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dJydy.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dwdp_colptrs.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_x0_fixedParameters.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdw_colptrs.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dJydsigmay.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdp_implicit_rowvals.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dwdp.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_sx0.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JB.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dwdx_colptrs.o build/temp.linux-x86_64-3.7/wrapfunctions.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_x_solver.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JSparse.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_xdot.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dJydy_rowvals.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dwdp_rowvals.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JSparse_colptrs.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_J.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dydx.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_JDiag.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_Jy.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_sigmay.o build/temp.linux-x86_64-3.7/Boehm_JProteomeRes2014_dxdotdp_explicit_rowvals.o -L/usr/lib/x86_64-linux-gnu/hdf5/serial -L/home/yannik/amici/python/sdist/amici/libs -lamici -lsundials -lsuitesparse -lcblas -lhdf5_hl_cpp -lhdf5_hl -lhdf5_cpp -lhdf5 -o /home/yannik/amici/python/examples/amici_models/Boehm_JProteomeRes2014/Boehm_JProteomeRes2014/_Boehm_JProteomeRes2014.cpython-37m-x86_64-linux-gnu.so\n" - ] + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-16T08:21:48.905327980Z", + "start_time": "2024-01-16T08:21:48.862592602Z" } - ], + }, + "outputs": [], "source": [ - "amici_model = import_petab_problem(petab_problem)" + "amici_model = import_petab_problem(petab_problem, verbose=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "That's it. Now, we can use the model to perform simulations. For more involved purposes, consider using the objective function provided by [pyPESTO](https://github.com/icb-dcm/pypesto). For simple simulations, a function `simulate_petab` is available:" + "That's it. Now, we can use the model to perform simulations.\n", + "\n", + "## Simulating a PEtab problem\n", + "\n", + "For simple simulations, a function `simulate_petab` is available. This function will simulate the model for all conditions specified in the PEtab problem and compute the objective value (and if requested, the gradient). `simulate_petab` is mostly useful for running individual simulations. If large numbers of model simulations are required, there are more efficient means. In particular, for parameter estimation, consider using the optimized objective function provided by [pyPESTO](https://github.com/icb-dcm/pypesto).\n", + "\n", + "We use the `simulate_petab` function to simulate the model at the nominal parameters (i.e., the parameters specified in the PEtab problem in the `nominalValue` column of the parameter table):" ] }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-16T08:22:20.761641459Z", + "start_time": "2024-01-16T08:22:20.718077654Z" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'llh': -138.22199570334107,\n", - " 'sllh': None,\n", - " 'rdatas': []}" - ] + "text/plain": "{'llh': -138.22199760826,\n 'sllh': None,\n 'rdatas': [],\n 'edatas': []}" }, - "execution_count": 6, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -311,23 +127,24 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This performs a simulation at the nominal parameters. Parameters can also be directly specified, both scaled and unscaled:" + " Parameters can also be directly specified, both scaled and unscaled:" ] }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-16T08:29:28.465673563Z", + "start_time": "2024-01-16T08:29:28.418282657Z" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'llh': -138.22199570334107,\n", - " 'sllh': None,\n", - " 'rdatas': []}" - ] + "text/plain": "{'llh': -138.22199760826,\n 'sllh': None,\n 'rdatas': [],\n 'edatas': []}" }, - "execution_count": 7, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -336,6 +153,9 @@ "parameters = {\n", " x_id: x_val\n", " for x_id, x_val in zip(petab_problem.x_ids, petab_problem.x_nominal_scaled)\n", + " # Fixed parameters cannot be changed in `simulate_petab`, unless we explicitly pass\n", + " # a `parameter_mapping` that was generated with `fill_fixed_parameters=False`\n", + " if x_id not in amici_model.getFixedParameterIds()\n", "}\n", "simulate_petab(\n", " petab_problem,\n", @@ -349,8 +169,90 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For further information, see the [documentation](https://amici.readthedocs.io/en/latest/)." + "## Working with PEtab-defined simulation conditions\n", + "\n", + "`simulate_petab` is convenient for quickly simulating PEtab-based problems, but for certain applications it may be too inflexible.\n", + "For example, it is not easily possible to obtain model outputs for time points other than the measurement timepoints specified in the PEtab problem. In such a case, the `AmiciPetabProblem` class can be used to easily generate AMICI `ExpData` objects representing PEtab-defined simulation conditions:" ] + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "app = AmiciPetabProblem(petab_problem)\n", + "\n", + "# ExpData for all conditions:\n", + "app.get_edatas()\n", + "\n", + "# ExpData for a single condition:\n", + "edata = app.get_edata(\"model1_data1\")" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-01-16T08:40:47.457726797Z", + "start_time": "2024-01-16T08:40:47.418756040Z" + } + }, + "execution_count": 30 + }, + { + "cell_type": "code", + "outputs": [ + { + "data": { + "text/plain": "" + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rdata = runAmiciSimulation(amici_model, solver=amici_model.getSolver(), edata=edata)\n", + "rdata" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-01-16T08:42:01.610656434Z", + "start_time": "2024-01-16T08:42:01.598570108Z" + } + }, + "execution_count": 39 + }, + { + "cell_type": "code", + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_state_trajectories(rdata)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-01-16T08:42:04.775787754Z", + "start_time": "2024-01-16T08:42:04.649209736Z" + } + }, + "execution_count": 40 + }, + { + "cell_type": "markdown", + "source": [ + "For further information, check out the [AMICI documentation](https://amici.readthedocs.io/en/latest/)." + ], + "metadata": { + "collapsed": false + } } ], "metadata": { From d8065465a48b069f76b6d579fdab0bbdb879c2a4 Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Tue, 16 Jan 2024 10:07:49 +0100 Subject: [PATCH 09/12] AmiciPetabProblem -> PetabProblem --- python/examples/example_petab/petab.ipynb | 119 +++++----------------- python/sdist/amici/petab/petab_problem.py | 6 +- python/tests/petab/test_petab_problem.py | 16 +-- 3 files changed, 34 insertions(+), 107 deletions(-) diff --git a/python/examples/example_petab/petab.ipynb b/python/examples/example_petab/petab.ipynb index 3417d807dd..afc4b2a38e 100644 --- a/python/examples/example_petab/petab.ipynb +++ b/python/examples/example_petab/petab.ipynb @@ -13,20 +13,15 @@ }, { "cell_type": "code", - "execution_count": 34, - "metadata": { - "ExecuteTime": { - "end_time": "2024-01-16T08:41:40.592406548Z", - "start_time": "2024-01-16T08:41:40.123041782Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "import petab\n", "\n", "from amici import runAmiciSimulation\n", "from amici.petab.petab_import import import_petab_problem\n", - "from amici.petab.petab_problem import AmiciPetabProblem\n", + "from amici.petab.petab_problem import PetabProblem\n", "from amici.petab.simulations import simulate_petab\n", "from amici.plotting import plot_state_trajectories" ] @@ -49,13 +44,8 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2024-01-16T08:18:36.136056659Z", - "start_time": "2024-01-16T08:18:33.485169485Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "model_name = \"Boehm_JProteomeRes2014\"\n", @@ -75,13 +65,8 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2024-01-16T08:21:48.905327980Z", - "start_time": "2024-01-16T08:21:48.862592602Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "amici_model = import_petab_problem(petab_problem, verbose=False)" @@ -102,23 +87,9 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2024-01-16T08:22:20.761641459Z", - "start_time": "2024-01-16T08:22:20.718077654Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": "{'llh': -138.22199760826,\n 'sllh': None,\n 'rdatas': [],\n 'edatas': []}" - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "simulate_petab(petab_problem, amici_model)" ] @@ -132,23 +103,9 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2024-01-16T08:29:28.465673563Z", - "start_time": "2024-01-16T08:29:28.418282657Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": "{'llh': -138.22199760826,\n 'sllh': None,\n 'rdatas': [],\n 'edatas': []}" - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "parameters = {\n", " x_id: x_val\n", @@ -172,14 +129,14 @@ "## Working with PEtab-defined simulation conditions\n", "\n", "`simulate_petab` is convenient for quickly simulating PEtab-based problems, but for certain applications it may be too inflexible.\n", - "For example, it is not easily possible to obtain model outputs for time points other than the measurement timepoints specified in the PEtab problem. In such a case, the `AmiciPetabProblem` class can be used to easily generate AMICI `ExpData` objects representing PEtab-defined simulation conditions:" + "For example, it is not easily possible to obtain model outputs for time points other than the measurement timepoints specified in the PEtab problem. In such a case, the `PetabProblem` class can be used to easily generate AMICI `ExpData` objects representing PEtab-defined simulation conditions:" ] }, { "cell_type": "code", "outputs": [], "source": [ - "app = AmiciPetabProblem(petab_problem)\n", + "app = PetabProblem(petab_problem)\n", "\n", "# ExpData for all conditions:\n", "app.get_edatas()\n", @@ -188,62 +145,32 @@ "edata = app.get_edata(\"model1_data1\")" ], "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-01-16T08:40:47.457726797Z", - "start_time": "2024-01-16T08:40:47.418756040Z" - } + "collapsed": false }, - "execution_count": 30 + "execution_count": null }, { "cell_type": "code", - "outputs": [ - { - "data": { - "text/plain": "" - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "rdata = runAmiciSimulation(amici_model, solver=amici_model.getSolver(), edata=edata)\n", "rdata" ], "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-01-16T08:42:01.610656434Z", - "start_time": "2024-01-16T08:42:01.598570108Z" - } + "collapsed": false }, - "execution_count": 39 + "execution_count": null }, { "cell_type": "code", - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_state_trajectories(rdata)" ], "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-01-16T08:42:04.775787754Z", - "start_time": "2024-01-16T08:42:04.649209736Z" - } + "collapsed": false }, - "execution_count": 40 + "execution_count": null }, { "cell_type": "markdown", diff --git a/python/sdist/amici/petab/petab_problem.py b/python/sdist/amici/petab/petab_problem.py index bb6806fbd3..82ac70d290 100644 --- a/python/sdist/amici/petab/petab_problem.py +++ b/python/sdist/amici/petab/petab_problem.py @@ -11,7 +11,7 @@ from .parameter_mapping import create_parameter_mapping -class AmiciPetabProblem: +class PetabProblem: """Manage experimental conditions based on a PEtab problem definition. Create :class:`ExpData` objects from a PEtab problem definition, and handle @@ -151,7 +151,7 @@ def get_edata( NOTE: If ``store_edatas=True`` was passed to the constructor and the returned object is modified, the changes will be reflected in the internal `ExpData` objects. Also, if parameter values of - `AmiciPetabProblem` are changed, all `ExpData` objects will be updated. + `PetabProblem` are changed, all `ExpData` objects will be updated. Create a deep copy if you want to avoid this. :param condition_id: PEtab condition ID @@ -176,7 +176,7 @@ def get_edatas(self): NOTE: If ``store_edatas=True`` was passed to the constructor and the returned objects are modified, the changes will be reflected in the internal `ExpData` objects. Also, if parameter values of - `AmiciPetabProblem` are changed, all `ExpData` objects will be updated. + `PetabProblem` are changed, all `ExpData` objects will be updated. Create a deep copy if you want to avoid this. :return: List of ExpData objects diff --git a/python/tests/petab/test_petab_problem.py b/python/tests/petab/test_petab_problem.py index 03b670da60..7b5ee1ca08 100644 --- a/python/tests/petab/test_petab_problem.py +++ b/python/tests/petab/test_petab_problem.py @@ -1,13 +1,13 @@ -from amici.petab.petab_problem import AmiciPetabProblem +from amici.petab.petab_problem import PetabProblem from benchmark_models_petab import get_problem def test_amici_petab_problem_pregenerate(): - """AmiciPetabProblem with pre-generated ExpDatas""" + """PetabProblem with pre-generated ExpDatas""" # any example is fine - the only assumption is that we don't have # preequilibration petab_problem = get_problem("Boehm_JProteomeRes2014") - app = AmiciPetabProblem(petab_problem, store_edatas=True) + app = PetabProblem(petab_problem, store_edatas=True) # ensure all edatas are generated upon construction assert len(app._edatas) == len( @@ -30,11 +30,11 @@ def test_amici_petab_problem_pregenerate(): def test_amici_petab_problem_on_demand(): - """AmiciPetabProblem with on-demand ExpDatas""" + """PetabProblem with on-demand ExpDatas""" # any example is fine - the only assumption is that we don't have # preequilibration petab_problem = get_problem("Boehm_JProteomeRes2014") - app = AmiciPetabProblem(petab_problem, store_edatas=False) + app = PetabProblem(petab_problem, store_edatas=False) # ensure no edatas are generated upon construction assert not app._edatas @@ -65,12 +65,12 @@ def test_amici_petab_problem_on_demand(): def test_amici_petab_problem_pregenerate_equals_on_demand(): - """Check that AmiciPetabProblem produces the same ExpDatas + """Check that PetabProblem produces the same ExpDatas independent of the `store_edatas` parameter.""" # any example is fine petab_problem = get_problem("Boehm_JProteomeRes2014") - app_store_true = AmiciPetabProblem(petab_problem, store_edatas=True) - app_store_false = AmiciPetabProblem(petab_problem, store_edatas=False) + app_store_true = PetabProblem(petab_problem, store_edatas=True) + app_store_false = PetabProblem(petab_problem, store_edatas=False) parameter_update = {app_store_true.model.getParameterIds()[0]: 0.12345} app_store_true.set_parameters(parameter_update, scaled_parameters=True) From 7c2f6b1e376aaf248df95846b3c92d5d750cc90e Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Tue, 16 Jan 2024 16:31:09 +0100 Subject: [PATCH 10/12] clean up scaled_parameters --- python/sdist/amici/petab/petab_problem.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/python/sdist/amici/petab/petab_problem.py b/python/sdist/amici/petab/petab_problem.py index 82ac70d290..37e3f73d0c 100644 --- a/python/sdist/amici/petab/petab_problem.py +++ b/python/sdist/amici/petab/petab_problem.py @@ -38,7 +38,7 @@ def __init__( petab_problem: petab.Problem, amici_model: Optional[amici.Model] = None, problem_parameters: Optional[dict[str, float]] = None, - scaled_parameters: Optional[bool] = False, + scaled_parameters: bool = False, simulation_conditions: Union[pd.DataFrame, list[dict]] = None, store_edatas: bool = True, ): @@ -70,15 +70,13 @@ def __init__( if problem_parameters is None: # Use PEtab nominal values as default self._problem_parameters = self._default_parameters() - if scaled_parameters is True: + if scaled_parameters: raise NotImplementedError( "scaled_parameters=True in combination with default " "parameters is not implemented yet." ) - scaled_parameters = False else: self._problem_parameters = problem_parameters - self._scaled_parameters = scaled_parameters if store_edatas: self._parameter_mapping = create_parameter_mapping( From b449c5bbcfa3cf82e464ab5a9bcb21239b682c44 Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Tue, 16 Jan 2024 16:34:03 +0100 Subject: [PATCH 11/12] Update python/sdist/amici/petab/petab_problem.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Fabian Fröhlich --- python/sdist/amici/petab/petab_problem.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/sdist/amici/petab/petab_problem.py b/python/sdist/amici/petab/petab_problem.py index 37e3f73d0c..8ea177ad03 100644 --- a/python/sdist/amici/petab/petab_problem.py +++ b/python/sdist/amici/petab/petab_problem.py @@ -102,7 +102,7 @@ def set_parameters( :param scaled_parameters: Whether the provided parameters are on PEtab `parameterScale` or not. """ - if scaled_parameters != self._scaled_parameters: + if scaled_parameters != self._scaled_parameters and self._parameter_mapping is not None: # redo parameter mapping if scale changed self._parameter_mapping = create_parameter_mapping( petab_problem=self._petab_problem, From f9d5966485f3a76f051e752815d3dbbe73a32eb7 Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Tue, 16 Jan 2024 16:38:28 +0100 Subject: [PATCH 12/12] fix test + cov --- .github/workflows/test_petab_test_suite.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test_petab_test_suite.yml b/.github/workflows/test_petab_test_suite.yml index df188e7abe..9b48f21d95 100644 --- a/.github/workflows/test_petab_test_suite.yml +++ b/.github/workflows/test_petab_test_suite.yml @@ -72,7 +72,7 @@ jobs: run: | source ./build/venv/bin/activate \ && pytest --cov-report=xml:coverage.xml \ - --cov=./ python/tests/test_*petab*.py + --cov=./ python/tests/test_*petab*.py python/tests/petab/ # run test models - name: Run PEtab test suite