From 3d552a94d47f114a8efe8b19d7f53ca81d2c15b3 Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Wed, 13 May 2026 22:00:38 +0200 Subject: [PATCH 01/28] update data types --- petab/v2/core.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/petab/v2/core.py b/petab/v2/core.py index fb206502..2bf6a49e 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -19,6 +19,7 @@ Annotated, Any, Generic, + Literal, Self, TypeVar, get_args, @@ -318,9 +319,9 @@ class Observable(BaseModel): #: Observable name. name: str | None = Field(alias=C.OBSERVABLE_NAME, default=None) #: Observable formula. - formula: sp.Basic | None = Field(alias=C.OBSERVABLE_FORMULA, default=None) + formula: sp.Basic = Field(alias=C.OBSERVABLE_FORMULA) #: Noise formula. - noise_formula: sp.Basic | None = Field(alias=C.NOISE_FORMULA, default=None) + noise_formula: sp.Basic = Field(alias=C.NOISE_FORMULA) #: Noise distribution. noise_distribution: NoiseDistribution = Field( alias=C.NOISE_DISTRIBUTION, default=NoiseDistribution.NORMAL @@ -926,7 +927,7 @@ class Parameter(BaseModel): ) #: Nominal value. nominal_value: Annotated[ - float | None, BeforeValidator(_convert_nan_to_none) + float | Literal["array"] | None, BeforeValidator(_convert_nan_to_none) ] = Field(alias=C.NOMINAL_VALUE, default=None) #: Is the parameter to be estimated? estimate: bool = Field(alias=C.ESTIMATE, default=True) From d0038395da399d3a197dbda854f756aad40de97b Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Wed, 13 May 2026 22:05:58 +0200 Subject: [PATCH 02/28] add checks for mapping table --- petab/v2/lint.py | 146 +++++++++++++++++++++++++++++++++++------- tests/v2/test_lint.py | 52 ++++++++++++++- 2 files changed, 173 insertions(+), 25 deletions(-) diff --git a/petab/v2/lint.py b/petab/v2/lint.py index 687d58f2..fea3f3c8 100644 --- a/petab/v2/lint.py +++ b/petab/v2/lint.py @@ -44,6 +44,7 @@ "CheckPriorDistribution", "CheckUndefinedExperiments", "CheckInitialChangeSymbols", + "CheckMappingTable", "lint_problem", "default_validation_tasks", ] @@ -551,7 +552,8 @@ def run(self, problem: Problem) -> ValidationIssue | None: class CheckAllParametersPresentInParameterTable(ValidationTask): """Ensure all required parameters are contained in the parameter table - with no additional ones.""" + with no additional ones. This also ensures that the mapping table petab ids + are used in the PEtab problem.""" def run(self, problem: Problem) -> ValidationIssue | None: if problem.model is None: @@ -825,8 +827,8 @@ def run(self, problem: Problem) -> ValidationIssue | None: if parameter.prior_distribution not in PRIOR_DISTRIBUTIONS: messages.append( - f"Prior distribution `{parameter.prior_distribution}' " - f"for parameter `{parameter.id}' is not valid." + f"Prior distribution `{parameter.prior_distribution}` " + f"for parameter `{parameter.id}` is not valid." ) continue @@ -834,8 +836,8 @@ def run(self, problem: Problem) -> ValidationIssue | None: exp_num_par := self._num_pars[parameter.prior_distribution] ) != len(parameter.prior_parameters): messages.append( - f"Prior distribution `{parameter.prior_distribution}' " - f"for parameter `{parameter.id}' requires " + f"Prior distribution `{parameter.prior_distribution}` " + f"for parameter `{parameter.id}` requires " f"{exp_num_par} parameters, but got " f"{len(parameter.prior_parameters)} " f"({parameter.prior_parameters})." @@ -848,8 +850,8 @@ def run(self, problem: Problem) -> ValidationIssue | None: _ = parameter.prior_dist.sample(1) except Exception as e: messages.append( - f"Prior parameters `{parameter.prior_parameters}' " - f"for parameter `{parameter.id}' are invalid " + f"Prior parameters `{parameter.prior_parameters}` " + f"for parameter `{parameter.id}` are invalid " f"(hint: {e})." ) @@ -874,7 +876,7 @@ def run(self, problem: Problem) -> ValidationIssue | None: continue messages.append( - f"Measurement `{measurement}' does not have a model ID, " + f"Measurement `{measurement}` does not have a model ID, " "but there are multiple models available. " "Please specify the model ID in the measurement table." ) @@ -882,8 +884,8 @@ def run(self, problem: Problem) -> ValidationIssue | None: if measurement.model_id not in available_models: messages.append( - f"Measurement `{measurement}' has model ID " - f"`{measurement.model_id}' which does not match " + f"Measurement `{measurement}` has model ID " + f"`{measurement.model_id}` which does not match " "any of the available models: " f"{available_models}." ) @@ -894,6 +896,102 @@ def run(self, problem: Problem) -> ValidationIssue | None: return None +class CheckMappingTable(ValidationTask): + """Validate the mapping table.""" + + def run(self, problem: Problem) -> ValidationIssue | None: + messages = [] + + # Mapping table is optional + if problem.mappings: + # Check that each id only occurs once + counter = Counter( + [ + getattr(mapping, attr) + for mapping in problem.mappings + for attr in ["petab_id", "model_id"] + if getattr(mapping, attr) + ] + ) + non_unique = {id_ for id_, count in counter.items() if count > 1} + if non_unique: + return ValidationError( + f"Mapping table contains non-unique IDs: {non_unique}." + ) + + # petabEntityId is not defined elsewhere in the PEtab problem + petab_ids_mapping = {m.petab_id for m in problem.mappings} + defined_petab_ids = ( + {c.id for c in problem.conditions} + | {e.id for e in problem.experiments} + | {o.id for o in problem.observables} + ) + if petab_ids_mapping & defined_petab_ids: + messages.append( + f"PEtab IDs `{petab_ids_mapping & defined_petab_ids}` are " + "defined in the mapping table but also defined through " + "other PEtab tables." + ) + # Grab all symbols from condition table for later + condition_target_ids_values = { + sym + for cond in problem.conditions + for change in cond.changes + for sym in ( + change.target_value.free_symbols + | change.target_id.free_symbols + ) + } + + for mapping in problem.mappings: + # petabEntityId is not referenced in any model + for model in problem.models: + if model.has_entity_with_id(mapping.petab_id): + messages.append( + f"`{mapping.petab_id}` is used in the mapping " + "table and referenced directly in the model " + f"`{model.model_id}`." + ) + + # modelEntityId can be empty + if mapping.model_id: + # model_id is not in petab problem + if mapping.model_id in defined_petab_ids: + messages.append( + f"PEtab ID `{mapping.model_id}` mirrors the " + "model entity ID referenced in the mapping table." + ) + if mapping.model_id in condition_target_ids_values: + messages.append( + f"Identifier `{mapping.model_id}` is mapped to a " + "PEtab ID in the mapping table, but also directly " + "used in the conditions table." + ) + for observable_formula in [ + o.formula for o in problem.observables + ]: + if mapping.model_id in observable_formula.free_symbols: + messages.append( + f"Identifier `{mapping.model_id}` is mapped " + "to a PEtab ID in the mapping table, but also " + "directly used in an observable formula." + ) + for obs_noise_formula in [ + o.noise_formula for o in problem.observables + ]: + if mapping.model_id in obs_noise_formula.free_symbols: + messages.append( + f"Identifier `{mapping.model_id}` is mapped " + "to a PEtab ID in the mapping table, but also " + "directly used in a noise formula." + ) + + if messages: + return ValidationError("\n".join(messages)) + + return None + + def get_valid_parameters_for_parameter_table( problem: Problem, ) -> set[str]: @@ -933,9 +1031,13 @@ def get_valid_parameters_for_parameter_table( if p not in invalid ) + # Add petab ids from mapping table if they are used for aliasing for mapping in problem.mappings: - if mapping.model_id and mapping.model_id in parameter_ids.keys(): + if mapping.model_id: parameter_ids[mapping.petab_id] = None + # An aliased model id is not a valid parameter id + if mapping.model_id in parameter_ids: + del parameter_ids[mapping.model_id] # add output parameters from observable table output_parameters = problem.get_output_parameters() @@ -977,20 +1079,13 @@ def get_required_parameters_for_parameter_table( measurement table as well as all parametric condition table overrides that are not defined in the model. """ - parameter_ids = set() - condition_targets = { - change.target_id - for cond in problem.conditions - for change in cond.changes - } + # Start with mapping table petab ids + parameter_ids = {m.petab_id for m in problem.mappings} # Add parameters from measurement table, unless they are fixed parameters def append_overrides(overrides): parameter_ids.update( - str_p - for p in overrides - if isinstance(p, sp.Symbol) - and (str_p := str(p)) not in condition_targets + str(p) for p in overrides if isinstance(p, sp.Symbol) ) for m in problem.measurements: @@ -1033,7 +1128,12 @@ def append_overrides(overrides): if not problem.model.has_entity_with_id(str(p)) ) - # parameters that are overridden via the condition table are not allowed + # Parameters that are overridden via the condition table are not allowed + condition_targets = { + change.target_id + for cond in problem.conditions + for change in cond.changes + } parameter_ids -= condition_targets return parameter_ids @@ -1090,5 +1190,5 @@ def get_placeholders( CheckUnusedConditions(), CheckPriorDistribution(), CheckInitialChangeSymbols(), - # TODO validate mapping table + CheckMappingTable(), ] diff --git a/tests/v2/test_lint.py b/tests/v2/test_lint.py index 7eb6dc91..95fd8b8a 100644 --- a/tests/v2/test_lint.py +++ b/tests/v2/test_lint.py @@ -2,8 +2,11 @@ from copy import deepcopy +from petabtests import DEFAULT_PYSB_FILE + from petab.v2 import Problem from petab.v2.lint import * +from petab.v2.models.pysb_model import PySBModel from petab.v2.models.sbml_model import SbmlModel @@ -43,7 +46,7 @@ def test_invalid_model_id_in_measurements(): """Test that measurements with an invalid model ID are caught.""" problem = Problem() problem.models.append(SbmlModel.from_antimony("p1 = 1", model_id="model1")) - problem.add_observable("obs1", "A") + problem.add_observable("obs1", "A", 1) problem.add_measurement("obs1", experiment_id="e1", time=0, measurement=1) check = CheckMeasurementModelId() @@ -70,7 +73,7 @@ def test_undefined_experiment_id_in_measurements(): """Test that measurements with an undefined experiment ID are caught.""" problem = Problem() problem.add_experiment("e1", 0, "c1") - problem.add_observable("obs1", "A") + problem.add_observable("obs1", "A", 1) problem.add_measurement("obs1", experiment_id="e1", time=0, measurement=1) check = CheckUndefinedExperiments() @@ -107,3 +110,48 @@ def test_validate_initial_change_symbols(): problem.parameter_tables[0].parameters.remove(problem["p2"]) assert (error := check.run(problem)) is not None assert "contains additional symbols: {'p2'}" in error.message + + +def test_check_mapping_table(): + """Test checks related to the mapping table.""" + problem = Problem() + # PySB model from PEtab test suite + problem.model = PySBModel.from_file(DEFAULT_PYSB_FILE) + problem.add_mapping( + petab_id="A_comp", + model_id="A_() ** compartment", + name=None, + ) + problem.add_parameter( + "A_comp", + estimate=True, + nominal_value=2, + lb=0, + ub=10, + ) + + check = CheckMappingTable() + assert check.run(problem) is None + + check = CheckAllParametersPresentInParameterTable() + assert check.run(problem) is None + + # add a petab id without model id but with name for annotation + problem.add_mapping(petab_id="p2", model_id=None, name="Parameter 2") + problem.add_parameter("p2", estimate=True, nominal_value=1, lb=0, ub=10) + + check = CheckMappingTable() + assert check.run(problem) is None + + # Invalid: petabEntityId is referenced in the model + problem.mapping_tables = [] + problem.add_mapping( + petab_id="a0", + model_id="A_() ** compartment", + name=None, + ) + assert (error := check.run(problem)) is not None + assert ( + "`a0` is used in the mapping table and referenced directly" + in error.message + ) From c3e8819391fae0684402aca74f11e716dc465121 Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Wed, 13 May 2026 22:24:44 +0200 Subject: [PATCH 03/28] Use SBML in test --- tests/v2/test_lint.py | 20 ++++++-------------- 1 file changed, 6 insertions(+), 14 deletions(-) diff --git a/tests/v2/test_lint.py b/tests/v2/test_lint.py index 95fd8b8a..2b26fd57 100644 --- a/tests/v2/test_lint.py +++ b/tests/v2/test_lint.py @@ -2,11 +2,8 @@ from copy import deepcopy -from petabtests import DEFAULT_PYSB_FILE - from petab.v2 import Problem from petab.v2.lint import * -from petab.v2.models.pysb_model import PySBModel from petab.v2.models.sbml_model import SbmlModel @@ -116,14 +113,14 @@ def test_check_mapping_table(): """Test checks related to the mapping table.""" problem = Problem() # PySB model from PEtab test suite - problem.model = PySBModel.from_file(DEFAULT_PYSB_FILE) + problem.model = SbmlModel.from_antimony("a.mean = 1") problem.add_mapping( - petab_id="A_comp", - model_id="A_() ** compartment", + petab_id="a_m", + model_id="a.mean", name=None, ) problem.add_parameter( - "A_comp", + "a_m", estimate=True, nominal_value=2, lb=0, @@ -144,14 +141,9 @@ def test_check_mapping_table(): assert check.run(problem) is None # Invalid: petabEntityId is referenced in the model - problem.mapping_tables = [] - problem.add_mapping( - petab_id="a0", - model_id="A_() ** compartment", - name=None, - ) + problem.model = SbmlModel.from_antimony("a.mean = 1; a_m = 2") assert (error := check.run(problem)) is not None assert ( - "`a0` is used in the mapping table and referenced directly" + "`a_m` is used in the mapping table and referenced directly" in error.message ) From f4278c9409af4e8ce27a0c63b618c2c5db2e0bf0 Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Wed, 13 May 2026 22:50:17 +0200 Subject: [PATCH 04/28] ensure that all observables have a noise_formula --- tests/v2/test_core.py | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/tests/v2/test_core.py b/tests/v2/test_core.py index 22dbf0e1..7b5ad420 100644 --- a/tests/v2/test_core.py +++ b/tests/v2/test_core.py @@ -181,7 +181,7 @@ def test_measurments(): def test_observable(): - Observable(id="obs1", formula=x + y) + Observable(id="obs1", formula=x + y, noiseFormula=1) Observable(id="obs1", formula="x + y", noise_formula="x + y") Observable(id="obs1", formula=1, noise_formula=2) Observable( @@ -198,9 +198,17 @@ def test_observable(): observable_parameters=[sp.Symbol("p1")], noise_parameters=[sp.Symbol("n1")], ) - assert Observable(id="obs1", formula="x + y", non_petab=1).non_petab == 1 + assert ( + Observable( + id="obs1", + formula="x + y", + noise_formula="x + y", + non_petab=1, + ).non_petab + == 1 + ) - o = Observable(id="obs1", formula=x + y) + o = Observable(id="obs1", formula=x + y, noise_formula=1) assert o.observable_placeholders == [] assert o.noise_placeholders == [] @@ -492,14 +500,14 @@ def test_modify_problem(): problem.condition_df, exp_condition_df, check_dtype=False ) - problem.add_observable("observable1", "1") + problem.add_observable("observable1", "1", noise_formula=1) problem.add_observable("observable2", "2", noise_formula=2.2) exp_observable_df = pd.DataFrame( data={ OBSERVABLE_ID: ["observable1", "observable2"], OBSERVABLE_FORMULA: [1, 2], - NOISE_FORMULA: [np.nan, 2.2], + NOISE_FORMULA: [1, 2.2], } ).set_index([OBSERVABLE_ID]) assert_frame_equal( From 0a545587af9f434acf12e6d7b9421aafd3118052 Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Fri, 15 May 2026 11:47:06 +0200 Subject: [PATCH 05/28] rollback --- petab/v2/lint.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/petab/v2/lint.py b/petab/v2/lint.py index fea3f3c8..517a7fbd 100644 --- a/petab/v2/lint.py +++ b/petab/v2/lint.py @@ -1033,7 +1033,7 @@ def get_valid_parameters_for_parameter_table( # Add petab ids from mapping table if they are used for aliasing for mapping in problem.mappings: - if mapping.model_id: + if mapping.model_id and mapping.model_id in parameter_ids.keys(): parameter_ids[mapping.petab_id] = None # An aliased model id is not a valid parameter id if mapping.model_id in parameter_ids: From db6fbd69ca51257f2a1bb21b39ee2b5b6966872b Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Fri, 15 May 2026 11:51:06 +0200 Subject: [PATCH 06/28] add hybridization class --- petab/v2/core.py | 71 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) diff --git a/petab/v2/core.py b/petab/v2/core.py index 2bf6a49e..be459bdd 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -1108,6 +1108,77 @@ def n_estimated(self) -> int: return sum(p.estimate for p in self.parameters) +class Hybridization(BaseModel): + """Assigns NN inputs and outputs.""" + + #: The target ID. + target_id: str = Field(alias=C.TARGET_ID) + #: The target value. + target_val: sp.Basic = Field(alias=C.TARGET_VALUE) + + #: :meta private: + model_config = ConfigDict( + arbitrary_types_allowed=True, + populate_by_name=True, + extra="allow", + validate_assignment=True, + ) + + @field_validator("target_val", mode="before") + @classmethod + def _sympify(cls, v): + if v is None or isinstance(v, sp.Basic): + return v + if isinstance(v, float) and np.isnan(v): + return None + + return sympify_petab(v) + + +class HybridizationTable(BaseTable[Hybridization]): + """PEtab hybridization table.""" + + @property + def hybridizations(self) -> list[Hybridization]: + """List of hybridizations.""" + return self.elements + + @classmethod + def from_df(cls, df: pd.DataFrame, **kwargs) -> HybridizationTable: + """Create a HybridizationTable from a DataFrame.""" + if df is None: + return cls(**kwargs) + + hybridizations = [ + Hybridization( + **row.to_dict(), + ) + for _, row in df.reset_index().iterrows() + ] + + return cls(hybridizations, **kwargs) + + def to_df(self) -> pd.DataFrame: + """Convert the HybridizationTable to a DataFrame.""" + records = self.model_dump(by_alias=True)["elements"] + + return pd.DataFrame(records) + + def __getitem__(self, target_id: str) -> Hybridization: + """Get a hybridization by target ID.""" + for hybridization in self.hybridizations: + if hybridization.target_id == target_id: + return hybridization + raise KeyError(f"Target ID {target_id} not found") + + def get(self, target_id, default=None): + """Get a hybridization by target ID or return a default value.""" + try: + return self[target_id] + except KeyError: + return default + + class Problem: """ PEtab parameter estimation problem From 5f89cabe2eb41dbfd3ff3616b740c4fc24ad9b87 Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Fri, 15 May 2026 12:15:12 +0200 Subject: [PATCH 07/28] add sciml problem config --- petab/v2/C.py | 2 ++ petab/v2/core.py | 77 ++++++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 73 insertions(+), 6 deletions(-) diff --git a/petab/v2/C.py b/petab/v2/C.py index e640ae5c..7b141b77 100644 --- a/petab/v2/C.py +++ b/petab/v2/C.py @@ -258,6 +258,8 @@ MAPPING_FILES = "mapping_files" #: Extensions key in the YAML file EXTENSIONS = "extensions" +#: PEtab SciML extension +SCIML = "sciml" # MAPPING diff --git a/petab/v2/core.py b/petab/v2/core.py index be459bdd..d3be5638 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -2012,14 +2012,21 @@ def validate( validation_results = ValidationResultList() - if self.config and self.config.extensions: - extensions = ",".join(self.config.extensions.keys()) + supported_extensions = {C.SCIML} + if ( + self.config + and self.config.extensions + and (self.config.extensions.keys() - supported_extensions) + ): + extensions_without_support = ",".join( + self.config.extensions.keys() - supported_extensions + ) validation_results.append( ValidationIssue( ValidationIssueSeverity.WARNING, - "Validation of PEtab extensions is not yet implemented, " - "but the given problem uses the following extensions: " - f"{extensions}", + "The given problem uses the following extensions for " + "which validation is not yet implemented: " + f"{extensions_without_support}", ) ) @@ -2521,6 +2528,18 @@ class ModelFile(BaseModel): ) +class NeuralNetConfig(BaseModel): + """A neural net in the PEtab SciML problem configuration.""" + + location: AnyUrl | Path + pre_initialization: bool + format: str + + model_config = ConfigDict( + validate_assignment=True, + ) + + class ExtensionConfig(BaseModel): """The configuration of a PEtab extension.""" @@ -2528,6 +2547,25 @@ class ExtensionConfig(BaseModel): config: dict +class SciMLConfig(BaseModel): + """The extended configuration of a PEtab SciML problem.""" + + #: The PEtab SciML format version. + version: str = "0.1.0" + #: The paths to the array data files. + # Absolute or relative to `base_path`. + array_files: list[AnyUrl | Path] = [] + #: The paths to the hybridization tables. + # Absolute or relative to `base_path`. + hybridization_files: list[AnyUrl | Path] = [] + #: The neural network IDs and info. + neural_nets: dict[str, NeuralNetConfig] | None = {} + + model_config = ConfigDict( + validate_assignment=True, + ) + + class ProblemConfig(BaseModel): """The PEtab problem configuration.""" @@ -2577,6 +2615,23 @@ class ProblemConfig(BaseModel): validate_assignment=True, ) + @field_validator("extensions", mode="before") + @classmethod + def _parse_extensions(cls, v): + """Parse extensions dict and convert known extensions to their specific + config classes.""" + if isinstance(v, dict): + parsed_extensions = {} + for ext_name, ext_config in v.items(): + if ext_name == C.SCIML: + # Convert sciml extension to SciMLConfig + parsed_extensions[ext_name] = SciMLConfig(**ext_config) + else: + # Keep other extensions as ExtensionConfig + parsed_extensions[ext_name] = ExtensionConfig(**ext_config) + return parsed_extensions + return v + # convert parameter_file to list @field_validator( "parameter_files", @@ -2614,12 +2669,22 @@ def to_yaml(self, filename: str | Path): for model_id in data.get("model_files", {}): data["model_files"][model_id][C.MODEL_LOCATION] = str( - data["model_files"][model_id]["location"] + data["model_files"][model_id][C.MODEL_LOCATION] ) if data["id"] is None: # The schema requires a valid id or no id field at all. del data["id"] + for ext_id, d_ext in data[C.EXTENSIONS].items(): + if ext_id == C.SCIML: + # convert Paths to strings + for key in ("array_files", "hybridization_files"): + d_ext[key] = list(map(str, data[key])) + for nn in d_ext["neural_nets"]: + d_ext["neural_nets"][nn][C.MODEL_LOCATION] = str( + d_ext["neural_nets"][nn][C.MODEL_LOCATION] + ) + write_yaml(data, filename) @property From 2fbc20e96ee7c377c06a1535d9118b15dad5f97c Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Mon, 25 May 2026 17:22:39 +0200 Subject: [PATCH 08/28] create Problem for sciml extension --- petab/v2/core.py | 79 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 76 insertions(+), 3 deletions(-) diff --git a/petab/v2/core.py b/petab/v2/core.py index d3be5638..1067440e 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -1109,7 +1109,7 @@ def n_estimated(self) -> int: class Hybridization(BaseModel): - """Assigns NN inputs and outputs.""" + """Assigns PEtab SciML NN inputs and outputs.""" #: The target ID. target_id: str = Field(alias=C.TARGET_ID) @@ -1136,7 +1136,7 @@ def _sympify(cls, v): class HybridizationTable(BaseTable[Hybridization]): - """PEtab hybridization table.""" + """PEtab SciML hybridization table.""" @property def hybridizations(self) -> list[Hybridization]: @@ -1153,7 +1153,7 @@ def from_df(cls, df: pd.DataFrame, **kwargs) -> HybridizationTable: Hybridization( **row.to_dict(), ) - for _, row in df.reset_index().iterrows() + for _, row in df.iterrows() ] return cls(hybridizations, **kwargs) @@ -1205,6 +1205,9 @@ def __init__( measurement_tables: list[MeasurementTable] = None, parameter_tables: list[ParameterTable] = None, mapping_tables: list[MappingTable] = None, + neural_networks: list[NNModel] | None = None, + hybridization_tables: list[HybridizationTable] | None = None, + array_data_files: list[ArrayData] | None = None, config: ProblemConfig = None, ): from ..v2.lint import default_validation_tasks @@ -1221,6 +1224,11 @@ def __init__( self.measurement_tables = measurement_tables or [MeasurementTable()] self.mapping_tables = mapping_tables or [MappingTable()] self.parameter_tables = parameter_tables or [ParameterTable()] + self.neural_networks = neural_networks or [] + self.hybridization_tables = hybridization_tables or [ + HybridizationTable() + ] + self.array_data_files = array_data_files or [] def __repr__(self): return f"<{self.__class__.__name__} id={self.id!r}>" @@ -1393,6 +1401,59 @@ def from_yaml( else None ) + # sciml extension + if config.extensions and config.extensions[C.SCIML]: + try: + from petab_sciml import ( + ArrayDataStandard, + NNModel, + NNModelStandard, + ) + except ImportError as e: + raise ImportError( + "To generate a PEtab SciML problem, (petab_sciml) must be" + "installed." + ) from e + + # Neural network classes are constructed via pytorch for now to get the + # proper inputs + neural_networks = ( + [ + NNModel.from_pytorch_module( + NNModelStandard.load_data( + _generate_path( + file_path=nn_config.location, + base_path=base_path, + ) + ).to_pytorch_module(), + nn_model_id=nn_id, + ) + for nn_id, nn_config in ( + config.extensions[C.SCIML].neural_nets or {} + ).items() + ] + if config.extensions and config.extensions[C.SCIML] + else None + ) + + hybridization_tables = ( + [ + HybridizationTable.from_tsv(f, base_path) + for f in config.extensions[C.SCIML].hybridization_files + ] + if config.extensions and config.extensions[C.SCIML] + else None + ) + + array_data_files = ( + [ + ArrayDataStandard.load_data(_generate_path(f, base_path)) + for f in config.extensions[C.SCIML].array_files + ] + if config.extensions and config.extensions[C.SCIML] + else None + ) + return Problem( config=config, models=models, @@ -1402,6 +1463,9 @@ def from_yaml( measurement_tables=measurement_tables, parameter_tables=parameter_tables, mapping_tables=mapping_tables, + neural_networks=neural_networks, + hybridization_tables=hybridization_tables, + array_data_files=array_data_files, ) @staticmethod @@ -1708,6 +1772,15 @@ def id(self, value: str): self.config = ProblemConfig(format_version="2.0.0") self.config.id = value + @property + def hybridizations(self) -> list[Hybridization]: + """List of hybridizations in the hybridization table(s).""" + return list( + chain.from_iterable( + ht.hybridizations for ht in self.hybridization_tables + ) + ) + def get_optimization_parameters(self) -> list[str]: """ Get the list of optimization parameter IDs from parameter table. From 1c4330cd9613a68ca85f0329e76ecc8a965b029e Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Tue, 26 May 2026 13:09:11 +0200 Subject: [PATCH 09/28] Assign SciML-specific lint checks --- petab/v2/core.py | 13 +++++++++---- petab/v2/lint.py | 44 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 53 insertions(+), 4 deletions(-) diff --git a/petab/v2/core.py b/petab/v2/core.py index 1067440e..fac583ac 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -1210,13 +1210,18 @@ def __init__( array_data_files: list[ArrayData] | None = None, config: ProblemConfig = None, ): - from ..v2.lint import default_validation_tasks + from ..v2.lint import default_validation_tasks, sciml_validation_tasks self.config = config self.models: list[Model] = models or [] - self.validation_tasks: list[ValidationTask] = ( - default_validation_tasks.copy() - ) + if config.extensions and config.extensions[C.SCIML]: + self.validation_tasks: list[ValidationTask] = ( + sciml_validation_tasks.copy() + ) + else: + self.validation_tasks: list[ValidationTask] = ( + default_validation_tasks.copy() + ) self.observable_tables = observable_tables or [ObservableTable()] self.condition_tables = condition_tables or [ConditionTable()] diff --git a/petab/v2/lint.py b/petab/v2/lint.py index 517a7fbd..8e574721 100644 --- a/petab/v2/lint.py +++ b/petab/v2/lint.py @@ -992,6 +992,40 @@ def run(self, problem: Problem) -> ValidationIssue | None: return None +class CheckHybridizationTable(ValidationTask): + """Validate the SciML hybridization table.""" + + def run(self, problem: Problem) -> ValidationIssue | None: + messages = [] + + condition_targets = { + c.target_id for ct in problem.conditions for c in ct.changes + } + nn_input_ids = { + inp.input_id for nn in problem.neural_networks for inp in nn.inputs + } + hyb_target_ids = {hyb.target_id for hyb in problem.hybridizations} + hyb_target_vals = {hyb.target_value for hyb in problem.hybridizations} + + # Hybridization targets are not also targets in the condition table + if culprits := (hyb_target_ids & condition_targets): + messages.append( + f"Hybridization target ids `{culprits}` are also " + "target ids in the condition table." + ) + # NN inputs are not used as target values + if culprits := (hyb_target_vals & nn_input_ids): + messages.append( + "The following neural net inputs were used as target values " + f"in the Hybridization tbale: `{culprits}`. Please simplify." + ) + + if messages: + return ValidationError("\n".join(messages)) + + return None + + def get_valid_parameters_for_parameter_table( problem: Problem, ) -> set[str]: @@ -1192,3 +1226,13 @@ def get_placeholders( CheckInitialChangeSymbols(), CheckMappingTable(), ] + +#: Validation tasks that should be run PEtab SciML problems +sciml_validation_tasks = [ + CheckHybridizationTable(), +] + list( + set(default_validation_tasks) + - { + CheckAllParametersPresentInParameterTable(), + } +) From 648a21aa77e7680c9c148ef027cc136c8ce397ff Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Tue, 26 May 2026 13:12:15 +0200 Subject: [PATCH 10/28] remove lint checks that are covered by pydantic --- petab/v2/lint.py | 43 ------------------------------------------- 1 file changed, 43 deletions(-) diff --git a/petab/v2/lint.py b/petab/v2/lint.py index 8e574721..7408975a 100644 --- a/petab/v2/lint.py +++ b/petab/v2/lint.py @@ -932,16 +932,6 @@ def run(self, problem: Problem) -> ValidationIssue | None: "defined in the mapping table but also defined through " "other PEtab tables." ) - # Grab all symbols from condition table for later - condition_target_ids_values = { - sym - for cond in problem.conditions - for change in cond.changes - for sym in ( - change.target_value.free_symbols - | change.target_id.free_symbols - ) - } for mapping in problem.mappings: # petabEntityId is not referenced in any model @@ -953,39 +943,6 @@ def run(self, problem: Problem) -> ValidationIssue | None: f"`{model.model_id}`." ) - # modelEntityId can be empty - if mapping.model_id: - # model_id is not in petab problem - if mapping.model_id in defined_petab_ids: - messages.append( - f"PEtab ID `{mapping.model_id}` mirrors the " - "model entity ID referenced in the mapping table." - ) - if mapping.model_id in condition_target_ids_values: - messages.append( - f"Identifier `{mapping.model_id}` is mapped to a " - "PEtab ID in the mapping table, but also directly " - "used in the conditions table." - ) - for observable_formula in [ - o.formula for o in problem.observables - ]: - if mapping.model_id in observable_formula.free_symbols: - messages.append( - f"Identifier `{mapping.model_id}` is mapped " - "to a PEtab ID in the mapping table, but also " - "directly used in an observable formula." - ) - for obs_noise_formula in [ - o.noise_formula for o in problem.observables - ]: - if mapping.model_id in obs_noise_formula.free_symbols: - messages.append( - f"Identifier `{mapping.model_id}` is mapped " - "to a PEtab ID in the mapping table, but also " - "directly used in a noise formula." - ) - if messages: return ValidationError("\n".join(messages)) From be625d6143bfdac574e0b03577116a52834d9512 Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Tue, 26 May 2026 14:14:40 +0200 Subject: [PATCH 11/28] Proble.add_hybridization method --- petab/v2/core.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/petab/v2/core.py b/petab/v2/core.py index fac583ac..1de26993 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -2402,6 +2402,23 @@ def add_experiment(self, id_: str, *args): Experiment(id=id_, periods=periods) ) + def add_hybridization(self, target_id: str, target_value: str): + """Add a SciML hybridization table entry to the problem. + + If there are more than one hybridization tables, the hybridization + is added to the last one. + + Arguments: + target_id: The ID of the target entity in the PEtab problem + or neural network model + target_value: The value that is assigned to the target id. + """ + if not self.hybridization_tables: + self.hybridization_tables.append(HybridizationTable()) + self.hybridization_tables[-1].hybridizations.append( + Hybridization(target_id=target_id, target_value=target_value) + ) + def __iadd__(self, other): """Add Observable, Parameter, Measurement, Condition, or Experiment""" from .core import ( From 32c4b4bc8ce77d9c69eb058a35d45b77b88b4163 Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Tue, 26 May 2026 15:09:25 +0200 Subject: [PATCH 12/28] add hybridization df property, setter --- petab/v2/core.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/petab/v2/core.py b/petab/v2/core.py index 1de26993..be55d1eb 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -1786,6 +1786,19 @@ def hybridizations(self) -> list[Hybridization]: ) ) + @property + def hybridization_df(self) -> pd.DataFrame | None: + """Combined SciML hybridization tables as DataFrame.""" + return ( + HybridizationTable(hybridizations).to_df() + if (hybridizations := self.hybridizations) + else None + ) + + @hybridization_df.setter + def hybridization_df(self, value: pd.DataFrame): + self.hybridization_tables = [HybridizationTable.from_df(value)] + def get_optimization_parameters(self) -> list[str]: """ Get the list of optimization parameter IDs from parameter table. From 0de7a5f5e6cf78a56bc4f0c6cd460d6a45316f0f Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Tue, 26 May 2026 23:59:40 +0200 Subject: [PATCH 13/28] fix --- petab/v2/core.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/petab/v2/core.py b/petab/v2/core.py index be55d1eb..c055d023 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -61,6 +61,7 @@ __all__ = [ "Problem", "ProblemConfig", + "SciMLConfig", "Observable", "ObservableTable", "NoiseDistribution", @@ -1114,7 +1115,7 @@ class Hybridization(BaseModel): #: The target ID. target_id: str = Field(alias=C.TARGET_ID) #: The target value. - target_val: sp.Basic = Field(alias=C.TARGET_VALUE) + target_value: sp.Basic = Field(alias=C.TARGET_VALUE) #: :meta private: model_config = ConfigDict( @@ -1124,7 +1125,7 @@ class Hybridization(BaseModel): validate_assignment=True, ) - @field_validator("target_val", mode="before") + @field_validator("target_value", mode="before") @classmethod def _sympify(cls, v): if v is None or isinstance(v, sp.Basic): @@ -1214,7 +1215,7 @@ def __init__( self.config = config self.models: list[Model] = models or [] - if config.extensions and config.extensions[C.SCIML]: + if config and config.extensions and config.extensions[C.SCIML]: self.validation_tasks: list[ValidationTask] = ( sciml_validation_tasks.copy() ) @@ -2787,7 +2788,7 @@ def to_yaml(self, filename: str | Path): if ext_id == C.SCIML: # convert Paths to strings for key in ("array_files", "hybridization_files"): - d_ext[key] = list(map(str, data[key])) + d_ext[key] = list(map(str, d_ext[key])) for nn in d_ext["neural_nets"]: d_ext["neural_nets"][nn][C.MODEL_LOCATION] = str( d_ext["neural_nets"][nn][C.MODEL_LOCATION] From 5499ee16ef17c3f301a8bba00409dd3a82d2fdb2 Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Wed, 27 May 2026 00:25:14 +0200 Subject: [PATCH 14/28] add a basic test for sciml --- petab/v2/lint.py | 27 ++++++-- tests/v2/test_sciml.py | 138 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 159 insertions(+), 6 deletions(-) create mode 100644 tests/v2/test_sciml.py diff --git a/petab/v2/lint.py b/petab/v2/lint.py index 7408975a..a48912b2 100644 --- a/petab/v2/lint.py +++ b/petab/v2/lint.py @@ -45,6 +45,7 @@ "CheckUndefinedExperiments", "CheckInitialChangeSymbols", "CheckMappingTable", + "CheckHybridizationTable", "lint_problem", "default_validation_tasks", ] @@ -1186,10 +1187,24 @@ def get_placeholders( #: Validation tasks that should be run PEtab SciML problems sciml_validation_tasks = [ + CheckProblemConfig(), + CheckModel(), + CheckUniquePrimaryKeys(), + CheckMeasurementModelId(), + CheckMeasuredObservablesDefined(), + CheckPosLogMeasurements(), + CheckOverridesMatchPlaceholders(), + CheckValidConditionTargets(), + CheckExperimentTable(), + CheckExperimentConditionsExist(), + CheckUndefinedExperiments(), + CheckObservablesDoNotShadowModelEntities(), + # CheckAllParametersPresentInParameterTable(), + CheckValidParameterInConditionOrParameterTable(), + CheckUnusedExperiments(), + CheckUnusedConditions(), + CheckPriorDistribution(), + CheckInitialChangeSymbols(), + CheckMappingTable(), CheckHybridizationTable(), -] + list( - set(default_validation_tasks) - - { - CheckAllParametersPresentInParameterTable(), - } -) +] diff --git a/tests/v2/test_sciml.py b/tests/v2/test_sciml.py new file mode 100644 index 00000000..9e39fc80 --- /dev/null +++ b/tests/v2/test_sciml.py @@ -0,0 +1,138 @@ +import numpy as np +from pydantic import ConfigDict + +from petab.v2.core import * +from petab.v2.core import ModelFile, NeuralNetConfig +from petab.v2.lint import sciml_validation_tasks +from petab.v2.models.sbml_model import SbmlModel + + +def _get_test_problem(): + problem = Problem() + problem.validation_tasks = sciml_validation_tasks + problem.config = ProblemConfig( + format_version="2.0.0", + model_files=ConfigDict( + {"lv": ModelFile(location="lv.xml", language="sbml")} + ), + parameter_files=["parameters.tsv"], + measurement_files=["measurements.tsv"], + observable_files=["observables.tsv"], + experiment_files=["experiments.tsv"], + mapping_files=["mappings.tsv"], + extensions={ + "sciml": { + "version": "0.1.0", + "array_files": ["net1_ps.hdf5"], + "hybridization_files": ["hybridizations.tsv"], + "neural_nets": { + "net1": NeuralNetConfig( + location="net1.yaml", + pre_initialization=False, + format="YAML", + ) + }, + } + }, + ) + problem.model = SbmlModel.from_antimony(""" + model lv + species A, B; + A = 0.442; + B = 4.63; + alpha = 1.3; + gamma_ = 0.8; + -> A; alpha * A; + B -> ; 1.8 * B; + A -> ; 0.9 * A * B; + -> B; gamma_; + end + """) + problem.add_experiment("e1", 0, "") + problem.add_mapping("net1_input1", "net1.inputs[0][0]") + problem.add_mapping("net1_input2", "net1.inputs[0][1]") + problem.add_mapping("net1_output1", "net1.outputs[0][0]") + problem.add_mapping("net1_ps", "net1.parameters") + problem.add_measurement("B_obs", time=1, measurement=1, experiment_id="e1") + problem.add_observable("B_obs", "B", noise_formula="0.05") + problem.add_parameter( + "alpha", estimate=True, lb=0, ub=15, nominal_value=1.3 + ) + problem.add_parameter( + "net1_ps", estimate=True, lb=-np.inf, ub=np.inf, nominal_value="array" + ) + problem.add_hybridization("net1_input1", "A") + problem.add_hybridization("net1_input2", "B") + problem.add_hybridization("gamma_", "net1_output_1") + problem.add_neural_network_from_dict( + "net1", + nn_dict={ + "nn_model_id": "net1", + "inputs": [{"input_id": "input0"}], + "layers": [ + { + "layer_id": "layer1", + "layer_type": "Linear", + "args": { + "in_features": 2, + "out_features": 1, + "bias": True, + }, + } + ], + "forward": [ + { + "name": "net_input", + "op": "placeholder", + "target": "net_input", + }, + { + "name": "layer1", + "op": "call_module", + "target": "layer1", + "args": ["net_input"], + }, + { + "name": "tanh", + "op": "call_method", + "target": "tanh", + "args": ["layer1"], + }, + ], + }, + ) + + # array data + problem.add_array_data_from_dict( + { + "metadata": {"pytorch_format": True}, + "inputs": {}, + "parameters": { + "net1": { + "layer1": { + "bias": np.random.randn(2), + "weight": np.random.randn(2), + } + } + }, + } + ) + + # set the filenames + problem.config.filepath = "problem.yaml" + problem.model.rel_path = "lv.xml" + problem.experiment_tables[0].rel_path = "experiments.tsv" + problem.mapping_tables[0].rel_path = "mappings.tsv" + problem.measurement_tables[0].rel_path = "measurements.tsv" + problem.observable_tables[0].rel_path = "observables.tsv" + problem.parameter_tables[0].rel_path = "parameters.tsv" + problem.hybridization_tables[0].rel_path = "hybridizations.tsv" + # problem.neural_networks[0].rel_path = "net1.yaml" + # problem.array_data_files[0].rel_path = "net1_ps.hdf5" + + return problem + + +def test_lint(): + problem = _get_test_problem() + assert problem.validate() == [] From 64b8c2532be41533ec2e7acf1d4171ca44f3542e Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Wed, 27 May 2026 00:32:11 +0200 Subject: [PATCH 15/28] methods for adding nn, array data to problem --- petab/v2/core.py | 45 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) diff --git a/petab/v2/core.py b/petab/v2/core.py index c055d023..77fa873b 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -2433,6 +2433,51 @@ def add_hybridization(self, target_id: str, target_value: str): Hybridization(target_id=target_id, target_value=target_value) ) + def add_neural_network_from_dict(self, model_id: str, nn_dict: dict): + """Add a SciML neural net from a dictionary.""" + from petab_sciml import NNModel + + nn_model = NNModel.model_validate(nn_dict) + nn_model.nn_model_id = model_id + self.neural_networks.append(nn_model) + + def add_neural_network_from_yaml( + self, + model_id: str, + file_path: str | Path, + base_path: str | Path | None = None, + ): + """Add a SciML neural net from a yaml file.""" + from petab_sciml import NNModelStandard + + self.neural_networks.append( + NNModelStandard.load_data( + _generate_path( + file_path=file_path, + base_path=base_path, + ), + nn_model_id=model_id, + ) + ) + + def add_array_data_from_dict(self, array_data: dict): + """Add SciML array data from a dictionary.""" + from petab_sciml import ArrayData + + self.array_data_files.append(ArrayData.model_validate(array_data)) + + def add_array_data_from_hdf5( + self, + file_path: str | Path, + base_path: str | Path | None = None, + ): + """Add SciML array data from an hdf5 file.""" + from petab_sciml import ArrayDataStandard + + self.array_data_files.append( + ArrayDataStandard.load_data(_generate_path(file_path, base_path)) + ) + def __iadd__(self, other): """Add Observable, Parameter, Measurement, Condition, or Experiment""" from .core import ( From e426cb76bc1bc5ca2442b1848981c1940189f22b Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Wed, 27 May 2026 08:27:15 +0200 Subject: [PATCH 16/28] Non-local petab_sciml import --- petab/v2/core.py | 46 ++++++++++++++++++++++++++-------------------- 1 file changed, 26 insertions(+), 20 deletions(-) diff --git a/petab/v2/core.py b/petab/v2/core.py index 77fa873b..64c362d1 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -54,6 +54,16 @@ from ..versions import parse_version from . import C, get_observable_df +try: + from petab_sciml import ( + ArrayData, + ArrayDataStandard, + NNModel, + NNModelStandard, + ) +except ModuleNotFoundError: + pass + if TYPE_CHECKING: from ..v2.lint import ValidationResultList, ValidationTask @@ -1408,18 +1418,18 @@ def from_yaml( ) # sciml extension - if config.extensions and config.extensions[C.SCIML]: - try: - from petab_sciml import ( - ArrayDataStandard, - NNModel, - NNModelStandard, - ) - except ImportError as e: - raise ImportError( - "To generate a PEtab SciML problem, (petab_sciml) must be" - "installed." - ) from e + # if config.extensions and config.extensions[C.SCIML]: + # try: + # from petab_sciml import ( + # ArrayDataStandard, + # NNModel, + # NNModelStandard, + # ) + # except ImportError as e: + # raise ImportError( + # "To generate a PEtab SciML problem, (petab_sciml) must" + # "be installed." + # ) from e # Neural network classes are constructed via pytorch for now to get the # proper inputs @@ -2435,8 +2445,7 @@ def add_hybridization(self, target_id: str, target_value: str): def add_neural_network_from_dict(self, model_id: str, nn_dict: dict): """Add a SciML neural net from a dictionary.""" - from petab_sciml import NNModel - + # from petab_sciml import NNModel nn_model = NNModel.model_validate(nn_dict) nn_model.nn_model_id = model_id self.neural_networks.append(nn_model) @@ -2448,8 +2457,7 @@ def add_neural_network_from_yaml( base_path: str | Path | None = None, ): """Add a SciML neural net from a yaml file.""" - from petab_sciml import NNModelStandard - + # from petab_sciml import NNModelStandard self.neural_networks.append( NNModelStandard.load_data( _generate_path( @@ -2462,8 +2470,7 @@ def add_neural_network_from_yaml( def add_array_data_from_dict(self, array_data: dict): """Add SciML array data from a dictionary.""" - from petab_sciml import ArrayData - + # from petab_sciml import ArrayData self.array_data_files.append(ArrayData.model_validate(array_data)) def add_array_data_from_hdf5( @@ -2472,8 +2479,7 @@ def add_array_data_from_hdf5( base_path: str | Path | None = None, ): """Add SciML array data from an hdf5 file.""" - from petab_sciml import ArrayDataStandard - + # from petab_sciml import ArrayDataStandard self.array_data_files.append( ArrayDataStandard.load_data(_generate_path(file_path, base_path)) ) From 8227ce0a6cae64f6e5d4e613d3a5fc9841972c68 Mon Sep 17 00:00:00 2001 From: Maren Philipps Date: Wed, 27 May 2026 12:09:24 +0200 Subject: [PATCH 17/28] add dependency --- pyproject.toml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index e0e665e3..ab1a272c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -35,6 +35,7 @@ maintainers = [ tests = [ "antimony>=3.1.0", "copasi-basico>=0.85", + "petab_sciml", "pysb", "pytest", "pytest-cov", @@ -71,6 +72,9 @@ vis = [ "seaborn", "scipy" ] +sciml = [ + "petab_sciml", +] [project.scripts] petablint = "petab.petablint:main" From 01232813119d19f2f4c8d6c2f6f0dc5970da7200 Mon Sep 17 00:00:00 2001 From: Dilan Pathirana <59329744+dilpath@users.noreply.github.com> Date: Wed, 27 May 2026 12:16:42 +0200 Subject: [PATCH 18/28] Update petab_sciml dependency to use Git URL --- pyproject.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index ab1a272c..9d28e405 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -35,7 +35,7 @@ maintainers = [ tests = [ "antimony>=3.1.0", "copasi-basico>=0.85", - "petab_sciml", + "petab_sciml @ git+https://github.com/PEtab-dev/petab_sciml.git", "pysb", "pytest", "pytest-cov", @@ -73,7 +73,7 @@ vis = [ "scipy" ] sciml = [ - "petab_sciml", + "petab_sciml @ git+https://github.com/PEtab-dev/petab_sciml.git", ] [project.scripts] From 317b8100a84431b2887e594e2aa8b36c3e0e1cbe Mon Sep 17 00:00:00 2001 From: Branwen Snelling Date: Thu, 11 Jun 2026 15:28:42 +0100 Subject: [PATCH 19/28] update allowed params logic for mappings --- petab/v2/lint.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/petab/v2/lint.py b/petab/v2/lint.py index a48912b2..57678fda 100644 --- a/petab/v2/lint.py +++ b/petab/v2/lint.py @@ -1025,11 +1025,11 @@ def get_valid_parameters_for_parameter_table( # Add petab ids from mapping table if they are used for aliasing for mapping in problem.mappings: - if mapping.model_id and mapping.model_id in parameter_ids.keys(): + if mapping.petab_id not in invalid: parameter_ids[mapping.petab_id] = None - # An aliased model id is not a valid parameter id - if mapping.model_id in parameter_ids: - del parameter_ids[mapping.model_id] + # An aliased model id is not a valid parameter id + if mapping.model_id and mapping.model_id in parameter_ids: + del parameter_ids[mapping.model_id] # add output parameters from observable table output_parameters = problem.get_output_parameters() From cb5cef1e845d81e5735ca35758047ec6af4fe0ce Mon Sep 17 00:00:00 2001 From: Branwen Snelling Date: Thu, 11 Jun 2026 15:29:05 +0100 Subject: [PATCH 20/28] neural_nets to neural_networks --- petab/v2/core.py | 10 +++++----- tests/v2/test_sciml.py | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/petab/v2/core.py b/petab/v2/core.py index 64c362d1..dd860436 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -1445,7 +1445,7 @@ def from_yaml( nn_model_id=nn_id, ) for nn_id, nn_config in ( - config.extensions[C.SCIML].neural_nets or {} + config.extensions[C.SCIML].neural_networks or {} ).items() ] if config.extensions and config.extensions[C.SCIML] @@ -2719,7 +2719,7 @@ class SciMLConfig(BaseModel): # Absolute or relative to `base_path`. hybridization_files: list[AnyUrl | Path] = [] #: The neural network IDs and info. - neural_nets: dict[str, NeuralNetConfig] | None = {} + neural_networks: dict[str, NeuralNetConfig] | None = {} model_config = ConfigDict( validate_assignment=True, @@ -2840,9 +2840,9 @@ def to_yaml(self, filename: str | Path): # convert Paths to strings for key in ("array_files", "hybridization_files"): d_ext[key] = list(map(str, d_ext[key])) - for nn in d_ext["neural_nets"]: - d_ext["neural_nets"][nn][C.MODEL_LOCATION] = str( - d_ext["neural_nets"][nn][C.MODEL_LOCATION] + for nn in d_ext["neural_networks"]: + d_ext["neural_networks"][nn][C.MODEL_LOCATION] = str( + d_ext["neural_networks"][nn][C.MODEL_LOCATION] ) write_yaml(data, filename) diff --git a/tests/v2/test_sciml.py b/tests/v2/test_sciml.py index 9e39fc80..49dc0d13 100644 --- a/tests/v2/test_sciml.py +++ b/tests/v2/test_sciml.py @@ -25,7 +25,7 @@ def _get_test_problem(): "version": "0.1.0", "array_files": ["net1_ps.hdf5"], "hybridization_files": ["hybridizations.tsv"], - "neural_nets": { + "neural_networks": { "net1": NeuralNetConfig( location="net1.yaml", pre_initialization=False, From 4a208f93d85aa808f8df20bd51b0640eb4f82f6a Mon Sep 17 00:00:00 2001 From: Branwen Snelling Date: Mon, 15 Jun 2026 10:38:11 +0100 Subject: [PATCH 21/28] add required params check to sciml validations --- petab/v2/core.py | 14 -------------- petab/v2/lint.py | 7 ++++++- tests/v2/test_sciml.py | 2 +- 3 files changed, 7 insertions(+), 16 deletions(-) diff --git a/petab/v2/core.py b/petab/v2/core.py index dd860436..c4b073e7 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -1417,20 +1417,6 @@ def from_yaml( else None ) - # sciml extension - # if config.extensions and config.extensions[C.SCIML]: - # try: - # from petab_sciml import ( - # ArrayDataStandard, - # NNModel, - # NNModelStandard, - # ) - # except ImportError as e: - # raise ImportError( - # "To generate a PEtab SciML problem, (petab_sciml) must" - # "be installed." - # ) from e - # Neural network classes are constructed via pytorch for now to get the # proper inputs neural_networks = ( diff --git a/petab/v2/lint.py b/petab/v2/lint.py index 57678fda..6e6945ba 100644 --- a/petab/v2/lint.py +++ b/petab/v2/lint.py @@ -1128,6 +1128,11 @@ def append_overrides(overrides): } parameter_ids -= condition_targets + hybridization_targets = {hyb.target_id for hyb in problem.hybridizations} + parameter_ids -= hybridization_targets + hybridization_target_values = {str(hyb.target_value) for hyb in problem.hybridizations} + parameter_ids -= hybridization_target_values + return parameter_ids @@ -1199,7 +1204,7 @@ def get_placeholders( CheckExperimentConditionsExist(), CheckUndefinedExperiments(), CheckObservablesDoNotShadowModelEntities(), - # CheckAllParametersPresentInParameterTable(), + CheckAllParametersPresentInParameterTable(), CheckValidParameterInConditionOrParameterTable(), CheckUnusedExperiments(), CheckUnusedConditions(), diff --git a/tests/v2/test_sciml.py b/tests/v2/test_sciml.py index 49dc0d13..1f0c35e4 100644 --- a/tests/v2/test_sciml.py +++ b/tests/v2/test_sciml.py @@ -63,7 +63,7 @@ def _get_test_problem(): ) problem.add_hybridization("net1_input1", "A") problem.add_hybridization("net1_input2", "B") - problem.add_hybridization("gamma_", "net1_output_1") + problem.add_hybridization("gamma_", "net1_output1") problem.add_neural_network_from_dict( "net1", nn_dict={ From 111658e4842a311fd3f0412eb63a315ac39affdf Mon Sep 17 00:00:00 2001 From: Branwen Snelling Date: Mon, 15 Jun 2026 10:43:29 +0100 Subject: [PATCH 22/28] ruff format --- petab/v2/lint.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/petab/v2/lint.py b/petab/v2/lint.py index 6e6945ba..1d00ad71 100644 --- a/petab/v2/lint.py +++ b/petab/v2/lint.py @@ -1130,7 +1130,9 @@ def append_overrides(overrides): hybridization_targets = {hyb.target_id for hyb in problem.hybridizations} parameter_ids -= hybridization_targets - hybridization_target_values = {str(hyb.target_value) for hyb in problem.hybridizations} + hybridization_target_values = { + str(hyb.target_value) for hyb in problem.hybridizations + } parameter_ids -= hybridization_target_values return parameter_ids From 7050ff9f47523d81b801d772b2db3e4cc8344a41 Mon Sep 17 00:00:00 2001 From: Branwen Snelling Date: Wed, 17 Jun 2026 11:43:18 +0100 Subject: [PATCH 23/28] implement feedback from code review --- petab/v2/core.py | 5 +++-- petab/v2/lint.py | 13 ++++++++++--- 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/petab/v2/core.py b/petab/v2/core.py index c4b073e7..5852c02b 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -938,6 +938,7 @@ class Parameter(BaseModel): ) #: Nominal value. nominal_value: Annotated[ + # PEtab SciML supports arrays via "array" nominal values float | Literal["array"] | None, BeforeValidator(_convert_nan_to_none) ] = Field(alias=C.NOMINAL_VALUE, default=None) #: Is the parameter to be estimated? @@ -2415,8 +2416,8 @@ def add_experiment(self, id_: str, *args): def add_hybridization(self, target_id: str, target_value: str): """Add a SciML hybridization table entry to the problem. - If there are more than one hybridization tables, the hybridization - is added to the last one. + If there is more than one hybridization table, the hybridization + is added to the last table. Arguments: target_id: The ID of the target entity in the PEtab problem diff --git a/petab/v2/lint.py b/petab/v2/lint.py index 1d00ad71..dbf9f0a5 100644 --- a/petab/v2/lint.py +++ b/petab/v2/lint.py @@ -937,7 +937,10 @@ def run(self, problem: Problem) -> ValidationIssue | None: for mapping in problem.mappings: # petabEntityId is not referenced in any model for model in problem.models: - if model.has_entity_with_id(mapping.petab_id): + if ( + model.has_entity_with_id(mapping.petab_id) + and mapping.petab_id != mapping.model_id + ): messages.append( f"`{mapping.petab_id}` is used in the mapping " "table and referenced directly in the model " @@ -975,7 +978,7 @@ def run(self, problem: Problem) -> ValidationIssue | None: if culprits := (hyb_target_vals & nn_input_ids): messages.append( "The following neural net inputs were used as target values " - f"in the Hybridization tbale: `{culprits}`. Please simplify." + f"in the Hybridization table: `{culprits}`." ) if messages: @@ -1028,7 +1031,11 @@ def get_valid_parameters_for_parameter_table( if mapping.petab_id not in invalid: parameter_ids[mapping.petab_id] = None # An aliased model id is not a valid parameter id - if mapping.model_id and mapping.model_id in parameter_ids: + if ( + mapping.model_id + and mapping.model_id != mapping.petab_id + and mapping.model_id in parameter_ids + ): del parameter_ids[mapping.model_id] # add output parameters from observable table From 153289ffd789f9e0a7baebaac86214a40a9d7b90 Mon Sep 17 00:00:00 2001 From: Branwen Snelling Date: Wed, 17 Jun 2026 14:36:23 +0100 Subject: [PATCH 24/28] move sciml code to separate files and resolve circular imports --- lint.py | 0 petab/v2/base.py | 225 ++++++++++++++++++++++++++++++++++++ petab/v2/core.py | 227 +++---------------------------------- petab/v2/lint.py | 206 ++------------------------------- petab/v2/sciml/__init__.py | 0 petab/v2/sciml/core.py | 127 +++++++++++++++++++++ petab/v2/sciml/lint.py | 36 ++++++ tests/v2/test_sciml.py | 3 +- 8 files changed, 417 insertions(+), 407 deletions(-) create mode 100644 lint.py create mode 100644 petab/v2/base.py create mode 100644 petab/v2/sciml/__init__.py create mode 100644 petab/v2/sciml/core.py create mode 100644 petab/v2/sciml/lint.py diff --git a/lint.py b/lint.py new file mode 100644 index 00000000..e69de29b diff --git a/petab/v2/base.py b/petab/v2/base.py new file mode 100644 index 00000000..3decff94 --- /dev/null +++ b/petab/v2/base.py @@ -0,0 +1,225 @@ +"""Base classes shared across petab.v2 to avoid circular imports.""" + +from __future__ import annotations + +import logging +from abc import ABC, abstractmethod +from dataclasses import dataclass, field +from enum import IntEnum +from pathlib import Path +from typing import TYPE_CHECKING, Generic, TypeVar, get_args + +import pandas as pd +from pydantic import AnyUrl, BaseModel, Field + +from .._utils import _generate_path + +if TYPE_CHECKING: + from .core import Problem + +logger = logging.getLogger(__name__) + + +class ValidationIssueSeverity(IntEnum): + """The severity of a validation issue.""" + + INFO = 10 + WARNING = 20 + ERROR = 30 + CRITICAL = 40 + + +@dataclass +class ValidationIssue: + """The result of a validation task.""" + + level: ValidationIssueSeverity + message: str + task: str | None = None + + def __post_init__(self): + if not isinstance(self.level, ValidationIssueSeverity): + raise TypeError( + "`level` must be an instance of ValidationIssueSeverity." + ) + + def __str__(self): + return f"{self.level.name}: {self.message}" + + @staticmethod + def _get_task_name() -> str | None: + """Get the name of the ValidationTask that raised this error.""" + import inspect + + for frame_info in inspect.stack(): + frame = frame_info.frame + if "self" in frame.f_locals: + task = frame.f_locals["self"] + if isinstance(task, ValidationTask): + return task.__class__.__name__ + return None + + +@dataclass +class ValidationError(ValidationIssue): + """A validation result with level ERROR.""" + + level: ValidationIssueSeverity = field( + default=ValidationIssueSeverity.ERROR, init=False + ) + + def __post_init__(self): + if self.task is None: + self.task = self._get_task_name() + + +@dataclass +class ValidationWarning(ValidationIssue): + """A validation result with level WARNING.""" + + level: ValidationIssueSeverity = field( + default=ValidationIssueSeverity.WARNING, init=False + ) + + def __post_init__(self): + if self.task is None: + self.task = self._get_task_name() + + +class ValidationResultList(list): + """A list of validation results.""" + + def log( + self, + *, + logger: logging.Logger = logger, + min_level: ValidationIssueSeverity = ValidationIssueSeverity.INFO, + max_level: ValidationIssueSeverity = ValidationIssueSeverity.CRITICAL, + ): + """Log the validation results.""" + for result in self: + if result.level < min_level or result.level > max_level: + continue + msg = f"{result.level.name}: {result.message} [{result.task}]" + if result.level == ValidationIssueSeverity.INFO: + logger.info(msg) + elif result.level == ValidationIssueSeverity.WARNING: + logger.warning(msg) + elif result.level >= ValidationIssueSeverity.ERROR: + logger.error(msg) + + if not self: + logger.info("PEtab format check completed successfully.") + + def has_errors(self) -> bool: + """Check if there are any errors in the validation results.""" + return any( + result.level >= ValidationIssueSeverity.ERROR for result in self + ) + + +class ValidationTask(ABC): + """A task to validate a PEtab problem.""" + + @abstractmethod + def run(self, problem: Problem) -> ValidationIssue | None: + """Run the validation task.""" + ... + + def __call__(self, *args, **kwargs): + return self.run(*args, **kwargs) + + +T = TypeVar("T", bound=BaseModel) + + +class BaseTable(BaseModel, Generic[T]): + """Base class for PEtab tables.""" + + #: The table elements + elements: list[T] + #: The path to the table file, if applicable. + #: Relative to the base path, if the base path is set and rel_path is not + #: an absolute path. + rel_path: AnyUrl | Path | None = Field(exclude=True, default=None) + #: The base path for the table file, if applicable. + #: This is usually the directory of the PEtab YAML file. + base_path: AnyUrl | Path | None = Field(exclude=True, default=None) + + def __init__(self, elements: list[T] = None, **kwargs) -> None: + """Initialize the BaseTable with a list of elements.""" + if elements is None: + elements = [] + super().__init__(elements=elements, **kwargs) + + def __getitem__(self, id_: str) -> T: + """Get an element by ID. + + :param id_: The ID of the element to retrieve. + :return: The element with the given ID. + :raises KeyError: If no element with the given ID exists. + :raises NotImplementedError: + If the element type does not have an ID attribute. + """ + if "id" not in self._element_class().model_fields: + raise NotImplementedError( + f"__getitem__ is not implemented for {self.__class__.__name__}" + ) + + for element in self.elements: + if element.id == id_: + return element + + raise KeyError(f"{T.__name__} ID {id_} not found") + + @classmethod + @abstractmethod + def from_df(cls, df: pd.DataFrame, **kwargs) -> BaseTable[T]: + """Create a table from a DataFrame.""" + pass + + @abstractmethod + def to_df(self) -> pd.DataFrame: + """Convert the table to a DataFrame.""" + pass + + @classmethod + def from_tsv( + cls, file_path: str | Path, base_path: str | Path | None = None + ) -> BaseTable[T]: + """Create table from a TSV file.""" + df = pd.read_csv(_generate_path(file_path, base_path), sep="\t") + return cls.from_df(df, rel_path=file_path, base_path=base_path) + + def to_tsv(self, file_path: str | Path = None) -> None: + """Write the table to a TSV file.""" + df = self.to_df() + df.to_csv( + file_path or _generate_path(self.rel_path, self.base_path), + sep="\t", + index=not isinstance(df.index, pd.RangeIndex), + ) + + @classmethod + def _element_class(cls) -> type[T]: + """Get the class of the elements in the table.""" + return get_args(cls.model_fields["elements"].annotation)[0] + + def __add__(self, other: T) -> BaseTable[T]: + """Add an item to the table.""" + if not isinstance(other, self._element_class()): + raise TypeError( + f"Can only add {self._element_class().__name__} " + f"to {self.__class__.__name__}" + ) + return self.__class__(elements=self.elements + [other]) + + def __iadd__(self, other: T) -> BaseTable[T]: + """Add an item to the table in place.""" + if not isinstance(other, self._element_class()): + raise TypeError( + f"Can only add {self._element_class().__name__} " + f"to {self.__class__.__name__}" + ) + self.elements.append(other) + return self diff --git a/petab/v2/core.py b/petab/v2/core.py index 5852c02b..6f348f22 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -7,7 +7,6 @@ import os import tempfile import traceback -from abc import abstractmethod from collections.abc import Sequence from enum import Enum from itertools import chain @@ -18,11 +17,8 @@ TYPE_CHECKING, Annotated, Any, - Generic, Literal, Self, - TypeVar, - get_args, ) import numpy as np @@ -41,7 +37,18 @@ model_validator, ) +try: + from petab_sciml import ( + ArrayData, + ArrayDataStandard, + NNModel, + NNModelStandard, + ) +except ModuleNotFoundError: + pass + from .._utils import _generate_path +from .base import BaseTable from ..v1 import ( validate_yaml_syntax, yaml, @@ -53,16 +60,11 @@ from ..v1.yaml import get_path_prefix from ..versions import parse_version from . import C, get_observable_df - -try: - from petab_sciml import ( - ArrayData, - ArrayDataStandard, - NNModel, - NNModelStandard, - ) -except ModuleNotFoundError: - pass +from .sciml.core import ( + Hybridization, + HybridizationTable, + SciMLConfig, +) if TYPE_CHECKING: from ..v2.lint import ValidationResultList, ValidationTask @@ -225,101 +227,6 @@ class PriorDistribution(str, Enum): ) -T = TypeVar("T", bound=BaseModel) - - -class BaseTable(BaseModel, Generic[T]): - """Base class for PEtab tables.""" - - #: The table elements - elements: list[T] - #: The path to the table file, if applicable. - #: Relative to the base path, if the base path is set and rel_path is not - #: an absolute path. - rel_path: AnyUrl | Path | None = Field(exclude=True, default=None) - #: The base path for the table file, if applicable. - #: This is usually the directory of the PEtab YAML file. - base_path: AnyUrl | Path | None = Field(exclude=True, default=None) - - def __init__(self, elements: list[T] = None, **kwargs) -> None: - """Initialize the BaseTable with a list of elements.""" - if elements is None: - elements = [] - super().__init__(elements=elements, **kwargs) - - def __getitem__(self, id_: str) -> T: - """Get an element by ID. - - :param id_: The ID of the element to retrieve. - :return: The element with the given ID. - :raises KeyError: If no element with the given ID exists. - :raises NotImplementedError: - If the element type does not have an ID attribute. - """ - if "id" not in self._element_class().model_fields: - raise NotImplementedError( - f"__getitem__ is not implemented for {self.__class__.__name__}" - ) - - for element in self.elements: - if element.id == id_: - return element - - raise KeyError(f"{T.__name__} ID {id_} not found") - - @classmethod - @abstractmethod - def from_df(cls, df: pd.DataFrame, **kwargs) -> BaseTable[T]: - """Create a table from a DataFrame.""" - pass - - @abstractmethod - def to_df(self) -> pd.DataFrame: - """Convert the table to a DataFrame.""" - pass - - @classmethod - def from_tsv( - cls, file_path: str | Path, base_path: str | Path | None = None - ) -> BaseTable[T]: - """Create table from a TSV file.""" - df = pd.read_csv(_generate_path(file_path, base_path), sep="\t") - return cls.from_df(df, rel_path=file_path, base_path=base_path) - - def to_tsv(self, file_path: str | Path = None) -> None: - """Write the table to a TSV file.""" - df = self.to_df() - df.to_csv( - file_path or _generate_path(self.rel_path, self.base_path), - sep="\t", - index=not isinstance(df.index, pd.RangeIndex), - ) - - @classmethod - def _element_class(cls) -> type[T]: - """Get the class of the elements in the table.""" - return get_args(cls.model_fields["elements"].annotation)[0] - - def __add__(self, other: T) -> BaseTable[T]: - """Add an item to the table.""" - if not isinstance(other, self._element_class()): - raise TypeError( - f"Can only add {self._element_class().__name__} " - f"to {self.__class__.__name__}" - ) - return self.__class__(elements=self.elements + [other]) - - def __iadd__(self, other: T) -> BaseTable[T]: - """Add an item to the table in place.""" - if not isinstance(other, self._element_class()): - raise TypeError( - f"Can only add {self._element_class().__name__} " - f"to {self.__class__.__name__}" - ) - self.elements.append(other) - return self - - class Observable(BaseModel): """Observable definition.""" @@ -1120,77 +1027,6 @@ def n_estimated(self) -> int: return sum(p.estimate for p in self.parameters) -class Hybridization(BaseModel): - """Assigns PEtab SciML NN inputs and outputs.""" - - #: The target ID. - target_id: str = Field(alias=C.TARGET_ID) - #: The target value. - target_value: sp.Basic = Field(alias=C.TARGET_VALUE) - - #: :meta private: - model_config = ConfigDict( - arbitrary_types_allowed=True, - populate_by_name=True, - extra="allow", - validate_assignment=True, - ) - - @field_validator("target_value", mode="before") - @classmethod - def _sympify(cls, v): - if v is None or isinstance(v, sp.Basic): - return v - if isinstance(v, float) and np.isnan(v): - return None - - return sympify_petab(v) - - -class HybridizationTable(BaseTable[Hybridization]): - """PEtab SciML hybridization table.""" - - @property - def hybridizations(self) -> list[Hybridization]: - """List of hybridizations.""" - return self.elements - - @classmethod - def from_df(cls, df: pd.DataFrame, **kwargs) -> HybridizationTable: - """Create a HybridizationTable from a DataFrame.""" - if df is None: - return cls(**kwargs) - - hybridizations = [ - Hybridization( - **row.to_dict(), - ) - for _, row in df.iterrows() - ] - - return cls(hybridizations, **kwargs) - - def to_df(self) -> pd.DataFrame: - """Convert the HybridizationTable to a DataFrame.""" - records = self.model_dump(by_alias=True)["elements"] - - return pd.DataFrame(records) - - def __getitem__(self, target_id: str) -> Hybridization: - """Get a hybridization by target ID.""" - for hybridization in self.hybridizations: - if hybridization.target_id == target_id: - return hybridization - raise KeyError(f"Target ID {target_id} not found") - - def get(self, target_id, default=None): - """Get a hybridization by target ID or return a default value.""" - try: - return self[target_id] - except KeyError: - return default - - class Problem: """ PEtab parameter estimation problem @@ -2675,18 +2511,6 @@ class ModelFile(BaseModel): ) -class NeuralNetConfig(BaseModel): - """A neural net in the PEtab SciML problem configuration.""" - - location: AnyUrl | Path - pre_initialization: bool - format: str - - model_config = ConfigDict( - validate_assignment=True, - ) - - class ExtensionConfig(BaseModel): """The configuration of a PEtab extension.""" @@ -2694,25 +2518,6 @@ class ExtensionConfig(BaseModel): config: dict -class SciMLConfig(BaseModel): - """The extended configuration of a PEtab SciML problem.""" - - #: The PEtab SciML format version. - version: str = "0.1.0" - #: The paths to the array data files. - # Absolute or relative to `base_path`. - array_files: list[AnyUrl | Path] = [] - #: The paths to the hybridization tables. - # Absolute or relative to `base_path`. - hybridization_files: list[AnyUrl | Path] = [] - #: The neural network IDs and info. - neural_networks: dict[str, NeuralNetConfig] | None = {} - - model_config = ConfigDict( - validate_assignment=True, - ) - - class ProblemConfig(BaseModel): """The PEtab problem configuration.""" diff --git a/petab/v2/lint.py b/petab/v2/lint.py index dbf9f0a5..e6a7d9bc 100644 --- a/petab/v2/lint.py +++ b/petab/v2/lint.py @@ -3,17 +3,24 @@ from __future__ import annotations import logging -from abc import ABC, abstractmethod from collections import Counter, OrderedDict from collections.abc import Set -from dataclasses import dataclass, field -from enum import IntEnum from itertools import chain from pathlib import Path import pandas as pd import sympy as sp +from .base import ( + ValidationError, + ValidationIssue, + ValidationIssueSeverity, + ValidationResultList, + ValidationTask, + ValidationWarning, +) +from petab.v2.sciml.lint import CheckHybridizationTable + from ..v2.C import * from .core import PriorDistribution, Problem @@ -51,126 +58,6 @@ ] -class ValidationIssueSeverity(IntEnum): - """The severity of a validation issue.""" - - # INFO: Informational message, no action required - INFO = 10 - # WARNING: Warning message, potential issues - WARNING = 20 - # ERROR: Error message, action required - ERROR = 30 - # CRITICAL: Critical error message, stops further validation - CRITICAL = 40 - - -@dataclass -class ValidationIssue: - """The result of a validation task. - - Attributes: - level: The level of the validation event. - message: The message of the validation event. - """ - - level: ValidationIssueSeverity - message: str - task: str | None = None - - def __post_init__(self): - if not isinstance(self.level, ValidationIssueSeverity): - raise TypeError( - "`level` must be an instance of ValidationIssueSeverity." - ) - - def __str__(self): - return f"{self.level.name}: {self.message}" - - @staticmethod - def _get_task_name() -> str | None: - """Get the name of the ValidationTask that raised this error. - - Expected to be called from below a `ValidationTask.run`. - """ - import inspect - - # walk up the stack until we find the ValidationTask.run method - for frame_info in inspect.stack(): - frame = frame_info.frame - if "self" in frame.f_locals: - task = frame.f_locals["self"] - if isinstance(task, ValidationTask): - return task.__class__.__name__ - return None - - -@dataclass -class ValidationError(ValidationIssue): - """A validation result with level ERROR.""" - - level: ValidationIssueSeverity = field( - default=ValidationIssueSeverity.ERROR, init=False - ) - - def __post_init__(self): - if self.task is None: - self.task = self._get_task_name() - - -@dataclass -class ValidationWarning(ValidationIssue): - """A validation result with level WARNING.""" - - level: ValidationIssueSeverity = field( - default=ValidationIssueSeverity.WARNING, init=False - ) - - def __post_init__(self): - if self.task is None: - self.task = self._get_task_name() - - -class ValidationResultList(list[ValidationIssue]): - """A list of validation results. - - Contains all issues found during the validation of a PEtab problem. - """ - - def log( - self, - *, - logger: logging.Logger = logger, - min_level: ValidationIssueSeverity = ValidationIssueSeverity.INFO, - max_level: ValidationIssueSeverity = ValidationIssueSeverity.CRITICAL, - ): - """Log the validation results. - - :param logger: The logger to use for logging. - Defaults to the module logger. - :param min_level: The minimum severity level to log. - :param max_level: The maximum severity level to log. - """ - for result in self: - if result.level < min_level or result.level > max_level: - continue - msg = f"{result.level.name}: {result.message} [{result.task}]" - if result.level == ValidationIssueSeverity.INFO: - logger.info(msg) - elif result.level == ValidationIssueSeverity.WARNING: - logger.warning(msg) - elif result.level >= ValidationIssueSeverity.ERROR: - logger.error(msg) - - if not self: - logger.info("PEtab format check completed successfully.") - - def has_errors(self) -> bool: - """Check if there are any errors in the validation results.""" - return any( - result.level >= ValidationIssueSeverity.ERROR for result in self - ) - - def lint_problem(problem: Problem | str | Path) -> ValidationResultList: """Validate a PEtab problem. @@ -187,24 +74,6 @@ def lint_problem(problem: Problem | str | Path) -> ValidationResultList: return problem.validate() -class ValidationTask(ABC): - """A task to validate a PEtab problem.""" - - @abstractmethod - def run(self, problem: Problem) -> ValidationIssue | None: - """Run the validation task. - - Arguments: - problem: PEtab problem to check. - Returns: - Validation results or ``None`` - """ - ... - - def __call__(self, *args, **kwargs): - return self.run(*args, **kwargs) - - class CheckProblemConfig(ValidationTask): """A task to validate the configuration of a PEtab problem. @@ -953,40 +822,6 @@ def run(self, problem: Problem) -> ValidationIssue | None: return None -class CheckHybridizationTable(ValidationTask): - """Validate the SciML hybridization table.""" - - def run(self, problem: Problem) -> ValidationIssue | None: - messages = [] - - condition_targets = { - c.target_id for ct in problem.conditions for c in ct.changes - } - nn_input_ids = { - inp.input_id for nn in problem.neural_networks for inp in nn.inputs - } - hyb_target_ids = {hyb.target_id for hyb in problem.hybridizations} - hyb_target_vals = {hyb.target_value for hyb in problem.hybridizations} - - # Hybridization targets are not also targets in the condition table - if culprits := (hyb_target_ids & condition_targets): - messages.append( - f"Hybridization target ids `{culprits}` are also " - "target ids in the condition table." - ) - # NN inputs are not used as target values - if culprits := (hyb_target_vals & nn_input_ids): - messages.append( - "The following neural net inputs were used as target values " - f"in the Hybridization table: `{culprits}`." - ) - - if messages: - return ValidationError("\n".join(messages)) - - return None - - def get_valid_parameters_for_parameter_table( problem: Problem, ) -> set[str]: @@ -1200,25 +1035,6 @@ def get_placeholders( ] #: Validation tasks that should be run PEtab SciML problems -sciml_validation_tasks = [ - CheckProblemConfig(), - CheckModel(), - CheckUniquePrimaryKeys(), - CheckMeasurementModelId(), - CheckMeasuredObservablesDefined(), - CheckPosLogMeasurements(), - CheckOverridesMatchPlaceholders(), - CheckValidConditionTargets(), - CheckExperimentTable(), - CheckExperimentConditionsExist(), - CheckUndefinedExperiments(), - CheckObservablesDoNotShadowModelEntities(), - CheckAllParametersPresentInParameterTable(), - CheckValidParameterInConditionOrParameterTable(), - CheckUnusedExperiments(), - CheckUnusedConditions(), - CheckPriorDistribution(), - CheckInitialChangeSymbols(), - CheckMappingTable(), +sciml_validation_tasks = default_validation_tasks + [ CheckHybridizationTable(), ] diff --git a/petab/v2/sciml/__init__.py b/petab/v2/sciml/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/petab/v2/sciml/core.py b/petab/v2/sciml/core.py new file mode 100644 index 00000000..e4c29a46 --- /dev/null +++ b/petab/v2/sciml/core.py @@ -0,0 +1,127 @@ +from pathlib import Path +from typing import Self + +import numpy as np +import pandas as pd +import sympy as sp +from pydantic import ( + AnyUrl, + BaseModel, + ConfigDict, + Field, + field_validator, +) + +import petab.v2.C as C + +from ...v1.math.sympify import sympify_petab +from ..base import BaseTable + +__all__ = [ + "Hybridization", + "HybridizationTable", + "NeuralNetConfig", + "SciMLConfig", +] + + +class Hybridization(BaseModel): + """Assigns PEtab SciML NN inputs and outputs.""" + + #: The target ID. + target_id: str = Field(alias=C.TARGET_ID) + #: The target value. + target_value: sp.Basic = Field(alias=C.TARGET_VALUE) + + #: :meta private: + model_config = ConfigDict( + arbitrary_types_allowed=True, + populate_by_name=True, + extra="allow", + validate_assignment=True, + ) + + @field_validator("target_value", mode="before") + @classmethod + def _sympify(cls, v): + if v is None or isinstance(v, sp.Basic): + return v + if isinstance(v, float) and np.isnan(v): + return None + + return sympify_petab(v) + + +class HybridizationTable(BaseTable[Hybridization]): + """PEtab SciML hybridization table.""" + + @property + def hybridizations(self) -> list[Hybridization]: + """List of hybridizations.""" + return self.elements + + @classmethod + def from_df(cls, df: pd.DataFrame, **kwargs) -> Self: + """Create a HybridizationTable from a DataFrame.""" + if df is None: + return cls(**kwargs) + + hybridizations = [ + Hybridization( + **row.to_dict(), + ) + for _, row in df.iterrows() + ] + + return cls(hybridizations, **kwargs) + + def to_df(self) -> pd.DataFrame: + """Convert the HybridizationTable to a DataFrame.""" + records = self.model_dump(by_alias=True)["elements"] + + return pd.DataFrame(records) + + def __getitem__(self, target_id: str) -> Hybridization: + """Get a hybridization by target ID.""" + for hybridization in self.hybridizations: + if hybridization.target_id == target_id: + return hybridization + raise KeyError(f"Target ID {target_id} not found") + + def get(self, target_id, default=None): + """Get a hybridization by target ID or return a default value.""" + try: + return self[target_id] + except KeyError: + return default + + +class NeuralNetConfig(BaseModel): + """A neural net in the PEtab SciML problem configuration.""" + + location: AnyUrl | Path + pre_initialization: bool + format: str + + model_config = ConfigDict( + validate_assignment=True, + ) + + +class SciMLConfig(BaseModel): + """The extended configuration of a PEtab SciML problem.""" + + #: The PEtab SciML format version. + version: str = "0.1.0" + #: The paths to the array data files. + # Absolute or relative to `base_path`. + array_files: list[AnyUrl | Path] = [] + #: The paths to the hybridization tables. + # Absolute or relative to `base_path`. + hybridization_files: list[AnyUrl | Path] = [] + #: The neural network IDs and info. + neural_networks: dict[str, NeuralNetConfig] | None = {} + + model_config = ConfigDict( + validate_assignment=True, + ) diff --git a/petab/v2/sciml/lint.py b/petab/v2/sciml/lint.py new file mode 100644 index 00000000..dc087a36 --- /dev/null +++ b/petab/v2/sciml/lint.py @@ -0,0 +1,36 @@ +from petab.v1.problem import Problem +from petab.v2.base import ValidationError, ValidationIssue, ValidationTask + + +class CheckHybridizationTable(ValidationTask): + """Validate the SciML hybridization table.""" + + def run(self, problem: Problem) -> ValidationIssue | None: + messages = [] + + condition_targets = { + c.target_id for ct in problem.conditions for c in ct.changes + } + nn_input_ids = { + inp.input_id for nn in problem.neural_networks for inp in nn.inputs + } + hyb_target_ids = {hyb.target_id for hyb in problem.hybridizations} + hyb_target_vals = {hyb.target_value for hyb in problem.hybridizations} + + # Hybridization targets are not also targets in the condition table + if culprits := (hyb_target_ids & condition_targets): + messages.append( + f"Hybridization target ids `{culprits}` are also " + "target ids in the condition table." + ) + # NN inputs are not used as target values + if culprits := (hyb_target_vals & nn_input_ids): + messages.append( + "The following neural net inputs were used as target values " + f"in the Hybridization table: `{culprits}`." + ) + + if messages: + return ValidationError("\n".join(messages)) + + return None diff --git a/tests/v2/test_sciml.py b/tests/v2/test_sciml.py index 1f0c35e4..23737a0e 100644 --- a/tests/v2/test_sciml.py +++ b/tests/v2/test_sciml.py @@ -2,9 +2,10 @@ from pydantic import ConfigDict from petab.v2.core import * -from petab.v2.core import ModelFile, NeuralNetConfig +from petab.v2.core import ModelFile from petab.v2.lint import sciml_validation_tasks from petab.v2.models.sbml_model import SbmlModel +from petab.v2.sciml.core import NeuralNetConfig def _get_test_problem(): From 7bb786e429b4ed203c2f5f34d8beaa63921fcdf5 Mon Sep 17 00:00:00 2001 From: Branwen Snelling Date: Wed, 17 Jun 2026 14:48:39 +0100 Subject: [PATCH 25/28] fixup ruff --- petab/v2/core.py | 2 +- petab/v2/lint.py | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/petab/v2/core.py b/petab/v2/core.py index 6f348f22..c0477f29 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -48,7 +48,6 @@ pass from .._utils import _generate_path -from .base import BaseTable from ..v1 import ( validate_yaml_syntax, yaml, @@ -60,6 +59,7 @@ from ..v1.yaml import get_path_prefix from ..versions import parse_version from . import C, get_observable_df +from .base import BaseTable from .sciml.core import ( Hybridization, HybridizationTable, diff --git a/petab/v2/lint.py b/petab/v2/lint.py index e6a7d9bc..d0c11900 100644 --- a/petab/v2/lint.py +++ b/petab/v2/lint.py @@ -11,6 +11,9 @@ import pandas as pd import sympy as sp +from petab.v2.sciml.lint import CheckHybridizationTable + +from ..v2.C import * from .base import ( ValidationError, ValidationIssue, @@ -19,9 +22,6 @@ ValidationTask, ValidationWarning, ) -from petab.v2.sciml.lint import CheckHybridizationTable - -from ..v2.C import * from .core import PriorDistribution, Problem logger = logging.getLogger(__name__) From 2972df03aa8ed1873efa8535e0e328d56f28f692 Mon Sep 17 00:00:00 2001 From: Branwen Snelling Date: Wed, 17 Jun 2026 15:23:31 +0100 Subject: [PATCH 26/28] fix docs build issue --- doc/conf.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/doc/conf.py b/doc/conf.py index 975cad03..41c41496 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -9,6 +9,8 @@ import sys import warnings +from pydantic import BaseModel + # -- Path setup -------------------------------------------------------------- # If extensions (or modules to document with autodoc) are in another directory, @@ -126,6 +128,9 @@ def skip_some_objects(app, what, name, obj, skip, options): """Exclude some objects from the documentation""" if getattr(obj, "__module__", None) == "collections": return True + # Napoleon + Pydantic v2 bug: BaseModel itself triggers __getattr__ error + if obj is BaseModel: + return True def setup(app): From 8a138ea43cec843d671743c6fc3b9c6060415691 Mon Sep 17 00:00:00 2001 From: BSnelling Date: Wed, 17 Jun 2026 16:26:12 +0100 Subject: [PATCH 27/28] Update petab/v2/core.py Co-authored-by: Dilan Pathirana <59329744+dilpath@users.noreply.github.com> --- petab/v2/core.py | 30 +++++++++++------------------- 1 file changed, 11 insertions(+), 19 deletions(-) diff --git a/petab/v2/core.py b/petab/v2/core.py index c0477f29..37fa350c 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -1254,10 +1254,13 @@ def from_yaml( else None ) - # Neural network classes are constructed via pytorch for now to get the - # proper inputs - neural_networks = ( - [ + neural_networks = None + hybridization_tables = None + array_data_files = None + if config.extensions and config.extensions[C.SCIML]: + # Neural network classes are constructed via pytorch for now to get the + # proper inputs + neural_networks = [ NNModel.from_pytorch_module( NNModelStandard.load_data( _generate_path( @@ -1271,27 +1274,16 @@ def from_yaml( config.extensions[C.SCIML].neural_networks or {} ).items() ] - if config.extensions and config.extensions[C.SCIML] - else None - ) - - hybridization_tables = ( - [ + + hybridization_tables = [ HybridizationTable.from_tsv(f, base_path) for f in config.extensions[C.SCIML].hybridization_files ] - if config.extensions and config.extensions[C.SCIML] - else None - ) - - array_data_files = ( - [ + + array_data_files = [ ArrayDataStandard.load_data(_generate_path(f, base_path)) for f in config.extensions[C.SCIML].array_files ] - if config.extensions and config.extensions[C.SCIML] - else None - ) return Problem( config=config, From 87d273cd4bbe60bcb5d9b67b61876314e38b261e Mon Sep 17 00:00:00 2001 From: Branwen Snelling Date: Wed, 17 Jun 2026 16:36:58 +0100 Subject: [PATCH 28/28] add to docstrings --- petab/v2/core.py | 37 ++++++++++++++++++++++++++----------- 1 file changed, 26 insertions(+), 11 deletions(-) diff --git a/petab/v2/core.py b/petab/v2/core.py index 37fa350c..0d3211e4 100644 --- a/petab/v2/core.py +++ b/petab/v2/core.py @@ -1258,8 +1258,8 @@ def from_yaml( hybridization_tables = None array_data_files = None if config.extensions and config.extensions[C.SCIML]: - # Neural network classes are constructed via pytorch for now to get the - # proper inputs + # Neural network classes are constructed via pytorch for now to get + # the proper inputs neural_networks = [ NNModel.from_pytorch_module( NNModelStandard.load_data( @@ -1274,12 +1274,12 @@ def from_yaml( config.extensions[C.SCIML].neural_networks or {} ).items() ] - + hybridization_tables = [ HybridizationTable.from_tsv(f, base_path) for f in config.extensions[C.SCIML].hybridization_files ] - + array_data_files = [ ArrayDataStandard.load_data(_generate_path(f, base_path)) for f in config.extensions[C.SCIML].array_files @@ -1605,7 +1605,10 @@ def id(self, value: str): @property def hybridizations(self) -> list[Hybridization]: - """List of hybridizations in the hybridization table(s).""" + """ + List of hybridizations in the hybridization table(s). + Note that hybridizations are specific to PEtab SciML problems. + """ return list( chain.from_iterable( ht.hybridizations for ht in self.hybridization_tables @@ -1614,7 +1617,10 @@ def hybridizations(self) -> list[Hybridization]: @property def hybridization_df(self) -> pd.DataFrame | None: - """Combined SciML hybridization tables as DataFrame.""" + """ + Combined SciML hybridization tables as DataFrame. + Note that hybridizations are specific to PEtab SciML problems. + """ return ( HybridizationTable(hybridizations).to_df() if (hybridizations := self.hybridizations) @@ -2245,7 +2251,8 @@ def add_hybridization(self, target_id: str, target_value: str): """Add a SciML hybridization table entry to the problem. If there is more than one hybridization table, the hybridization - is added to the last table. + is added to the last table. Note that hybridizations are specific + to PEtab SciML problems. Arguments: target_id: The ID of the target entity in the PEtab problem @@ -2259,7 +2266,9 @@ def add_hybridization(self, target_id: str, target_value: str): ) def add_neural_network_from_dict(self, model_id: str, nn_dict: dict): - """Add a SciML neural net from a dictionary.""" + """ + Add a SciML neural net from a dictionary (or PEtab SciML problems). + """ # from petab_sciml import NNModel nn_model = NNModel.model_validate(nn_dict) nn_model.nn_model_id = model_id @@ -2271,7 +2280,9 @@ def add_neural_network_from_yaml( file_path: str | Path, base_path: str | Path | None = None, ): - """Add a SciML neural net from a yaml file.""" + """ + Add a SciML neural net from a yaml file (for PEtab SciML problems). + """ # from petab_sciml import NNModelStandard self.neural_networks.append( NNModelStandard.load_data( @@ -2284,7 +2295,9 @@ def add_neural_network_from_yaml( ) def add_array_data_from_dict(self, array_data: dict): - """Add SciML array data from a dictionary.""" + """ + Add SciML array data from a dictionary (for PEtab SciML problems). + """ # from petab_sciml import ArrayData self.array_data_files.append(ArrayData.model_validate(array_data)) @@ -2293,7 +2306,9 @@ def add_array_data_from_hdf5( file_path: str | Path, base_path: str | Path | None = None, ): - """Add SciML array data from an hdf5 file.""" + """ + Add SciML array data from an hdf5 file (for PEtab SciML problems). + """ # from petab_sciml import ArrayDataStandard self.array_data_files.append( ArrayDataStandard.load_data(_generate_path(file_path, base_path))