mxlpy 0.24.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

mxlpy/surrogates/_equinox.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Self
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+import optax
+import pandas as pd
+
+from mxlpy.nn._equinox import MLP, LossFn, mean_abs_error
+from mxlpy.nn._equinox import train as _train
+from mxlpy.types import AbstractSurrogate, Derived
+
+if TYPE_CHECKING:
+    import equinox as eqx
+
+__all__ = ["Surrogate", "Trainer", "train"]
+
+
+@dataclass(kw_only=True)
+class Surrogate(AbstractSurrogate):
+    """Surrogate model using PyTorch.
+
+    Attributes:
+        model: PyTorch neural network model.
+
+    Methods:
+        predict: Predict outputs based on input data using the PyTorch model.
+
+    """
+
+    model: eqx.Module
+
+    def predict_raw(self, y: np.ndarray) -> np.ndarray:
+        """Predict outputs based on input data using the PyTorch model.
+
+        Args:
+            y: Input data as a numpy array.
+
+        Returns:
+            dict[str, float]: Dictionary mapping output variable names to predicted values.
+
+        """
+        # One has to implement __call__ on eqx.Module, so this should
+        # always exist. Should really be abstract on eqx.Module
+        return self.model(y).numpy()  # type: ignore
+
+    def predict(
+        self,
+        args: dict[str, float | pd.Series | pd.DataFrame],
+    ) -> dict[str, float]:
+        """Predict outputs based on input data."""
+        return dict(
+            zip(
+                self.outputs,
+                self.predict_raw(np.array([args[arg] for arg in self.args])),
+                strict=True,
+            )
+        )
+
+
+@dataclass(init=False)
+class Trainer:
+    features: pd.DataFrame
+    targets: pd.DataFrame
+    model: eqx.Module
+    optimizer: optax.GradientTransformation
+    losses: list[pd.Series]
+    loss_fn: LossFn
+    seed: int
+
+    def __init__(
+        self,
+        features: pd.DataFrame,
+        targets: pd.DataFrame,
+        model: eqx.Module | None = None,
+        optimizer: optax.GradientTransformation | None = None,
+        loss_fn: LossFn = mean_abs_error,
+        seed: int = 0,
+    ) -> None:
+        self.features = features
+        self.targets = targets
+
+        if model is None:
+            model = MLP(
+                n_inputs=len(features.columns),
+                neurons_per_layer=[50, 50, len(targets.columns)],
+                key=jax.random.PRNGKey(seed),
+            )
+        self.model = model
+
+        self.optimizer = (
+            optax.adamw(learning_rate=0.001) if optimizer is None else optimizer
+        )
+        self.loss_fn = loss_fn
+        self.losses = []
+        self.seed = seed
+
+    def train(
+        self,
+        epochs: int,
+        batch_size: int | None = None,
+    ) -> Self:
+        losses = _train(
+            model=self.model,
+            features=jnp.array(self.features),
+            targets=jnp.array(self.targets),
+            epochs=epochs,
+            optimizer=self.optimizer,
+            batch_size=batch_size,
+            loss_fn=self.loss_fn,
+        )
+        if len(self.losses) > 0:
+            losses.index += self.losses[-1].index[-1]
+        self.losses.append(losses)
+        return self
+
+    def get_loss(self) -> pd.Series:
+        return pd.concat(self.losses)
+
+    def get_surrogate(
+        self,
+        surrogate_args: list[str] | None = None,
+        surrogate_outputs: list[str] | None = None,
+        surrogate_stoichiometries: dict[str, dict[str, float | Derived]] | None = None,
+    ) -> Surrogate:
+        return Surrogate(
+            model=self.model,
+            args=surrogate_args if surrogate_args is not None else [],
+            outputs=surrogate_outputs if surrogate_outputs is not None else [],
+            stoichiometries=surrogate_stoichiometries
+            if surrogate_stoichiometries is not None
+            else {},
+        )
+
+
+def train(
+    features: pd.DataFrame,
+    targets: pd.DataFrame,
+    epochs: int,
+    surrogate_args: list[str] | None = None,
+    surrogate_outputs: list[str] | None = None,
+    surrogate_stoichiometries: dict[str, dict[str, float | Derived]] | None = None,
+    batch_size: int | None = None,
+    model: eqx.Module | None = None,
+    optimizer: optax.GradientTransformation | None = None,
+    loss_fn: LossFn = mean_abs_error,
+) -> tuple[Surrogate, pd.Series]:
+    """Train a PyTorch surrogate model.
+
+    Examples:
+        >>> train_torch_surrogate(
+        ...     features,
+        ...     targets,
+        ...     epochs=100,
+        ...     surrogate_inputs=["x1", "x2"],
+        ...     surrogate_stoichiometries={
+        ...         "v1": {"x1": -1, "x2": 1, "ATP": -1},
+        ...     },
+        ...)surrogate_stoichiometries
+
+    Args:
+        features: DataFrame containing the input features for training.
+        targets: DataFrame containing the target values for training.
+        epochs: Number of training epochs.
+        surrogate_args: Names of inputs arguments for the surrogate model.
+        surrogate_outputs: Names of output arguments from the surrogate.
+        surrogate_stoichiometries: Mapping of variables to their stoichiometries
+        batch_size: Size of mini-batches for training (None for full-batch).
+        model: Predefined neural network model (None to use default MLP features-50-50-output).
+        optimizer: Optimizer class to use for training (default: optax.GradientTransformation).
+        device: Device to run the training on (default: DefaultDevice).
+        loss_fn: Custom loss function or instance of torch loss object
+
+    Returns:
+        tuple[TorchSurrogate, pd.Series]: Trained surrogate model and loss history.
+
+    """
+    trainer = Trainer(
+        features=features,
+        targets=targets,
+        model=model,
+        optimizer=optimizer,
+        loss_fn=loss_fn,
+    ).train(
+        epochs=epochs,
+        batch_size=batch_size,
+    )
+    return trainer.get_surrogate(
+        surrogate_args=surrogate_args,
+        surrogate_outputs=surrogate_outputs,
+        surrogate_stoichiometries=surrogate_stoichiometries,
+    ), trainer.get_loss()

mxlpy/surrogates/_torch.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from collections.abc import Callable
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Self
 
@@ -10,37 +9,23 @@ import torch
 from torch import nn
 from torch.optim.adam import Adam
 
-from mxlpy.nn._torch import MLP, DefaultDevice
+from mxlpy.nn._torch import MLP, DefaultDevice, LossFn, mean_abs_error
 from mxlpy.nn._torch import train as _train
 from mxlpy.types import AbstractSurrogate, Derived
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from torch.optim.optimizer import ParamsT
 
-type LossFn = Callable[[torch.Tensor, torch.Tensor], torch.Tensor]
 
 __all__ = [
-    "LossFn",
     "Surrogate",
     "Trainer",
     "train",
 ]
 
 
-def _mean_abs(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
-    """Standard loss for surrogates.
-
-    Args:
-        x: Predictions of a model.
-        y: Targets.
-
-    Returns:
-        torch.Tensor: loss.
-
-    """
-    return torch.mean(torch.abs(x - y))
-
-
 @dataclass(kw_only=True)
 class Surrogate(AbstractSurrogate):
     """Surrogate model using PyTorch.
@@ -101,7 +86,7 @@ class Trainer:
         model: nn.Module | None = None,
         optimizer_cls: Callable[[ParamsT], Adam] = Adam,
         device: torch.device = DefaultDevice,
-        loss_fn: LossFn = _mean_abs,
+        loss_fn: LossFn = mean_abs_error,
     ) -> None:
         self.features = features
         self.targets = targets
@@ -168,7 +153,7 @@ def train(
     model: nn.Module | None = None,
     optimizer_cls: Callable[[ParamsT], Adam] = Adam,
     device: torch.device = DefaultDevice,
-    loss_fn: LossFn = _mean_abs,
+    loss_fn: LossFn = mean_abs_error,
 ) -> tuple[Surrogate, pd.Series]:
     """Train a PyTorch surrogate model.
 

mxlpy/symbolic/symbolic_model.py

@@ -1,5 +1,4 @@
-# ruff: noqa: D100, D101, D102, D103, D104, D105, D106, D107, D200, D203, D400, D401
-
+"""Conversions into symbolic representation."""
 
 from __future__ import annotations
 
@@ -7,6 +6,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, cast
 
 import sympy
+from wadler_lindig import pformat
 
 from mxlpy.meta.sympy_tools import fn_to_sympy, list_of_symbols
 
@@ -21,13 +21,20 @@ __all__ = [
 
 @dataclass
 class SymbolicModel:
+    """Symbolic model."""
+
     variables: dict[str, sympy.Symbol]
     parameters: dict[str, sympy.Symbol]
+    external: dict[str, sympy.Symbol]
     eqs: list[sympy.Expr]
     initial_conditions: dict[str, float]
     parameter_values: dict[str, float]
 
+    def __repr__(self) -> str:
+        return pformat(self)
+
     def jacobian(self) -> sympy.Matrix:
+        """Get jacobian of symbolic model."""
         # FIXME: don't rely on ordering of variables
         return sympy.Matrix(self.eqs).jacobian(
             sympy.Matrix(list(self.variables.values()))
@@ -35,6 +42,7 @@ class SymbolicModel:
 
 
 def to_symbolic_model(model: Model) -> SymbolicModel:
+    """Convert model into symbolic representation."""
     cache = model._create_cache()  # noqa: SLF001
     initial_conditions = model.get_initial_conditions()
 
@@ -52,7 +60,25 @@ def to_symbolic_model(model: Model) -> SymbolicModel:
             strict=True,
         )
     )
-    symbols: dict[str, sympy.Symbol | sympy.Expr] = variables | parameters  # type: ignore
+    # data
+    data = dict(
+        zip(
+            model._data,  # noqa: SLF001
+            cast(list[sympy.Symbol], list_of_symbols(model._data)),  # noqa: SLF001
+            strict=True,
+        )
+    )
+    # Insert surrogates?
+    _surr = model.get_surrogate_output_names(include_fluxes=True)
+    surrogates: dict[str, sympy.Symbol] = dict(
+        zip(
+            _surr,
+            cast(list[sympy.Symbol], list_of_symbols(_surr)),
+            strict=True,
+        )
+    )
+
+    symbols: dict[str, sympy.Symbol | sympy.Expr] = variables | parameters | data  # type: ignore
 
     # Insert derived into symbols
     for k, v in model.get_raw_derived().items():
@@ -93,4 +119,5 @@ def to_symbolic_model(model: Model) -> SymbolicModel:
         eqs=[eqs[i] for i in cache.var_names],
         initial_conditions=model.get_initial_conditions(),
         parameter_values=model.get_parameter_values(),
+        external=data | surrogates,
     )

mxlpy/types.py

@@ -798,6 +798,177 @@ class Result:
         """
         return pd.concat((self.variables, self.fluxes), axis=1)
 
+    @overload
+    def get_right_hand_side(  # type: ignore
+        self,
+        *,
+        normalise: float | ArrayLike | None = None,
+        concatenated: Literal[False],
+    ) -> list[pd.DataFrame]: ...
+
+    @overload
+    def get_right_hand_side(
+        self,
+        *,
+        normalise: float | ArrayLike | None = None,
+        concatenated: Literal[True],
+    ) -> pd.DataFrame: ...
+
+    @overload
+    def get_right_hand_side(
+        self,
+        *,
+        normalise: float | ArrayLike | None = None,
+        concatenated: bool = True,
+    ) -> pd.DataFrame: ...
+
+    def get_right_hand_side(
+        self,
+        *,
+        normalise: float | ArrayLike | None = None,
+        concatenated: bool = True,
+    ) -> pd.DataFrame | list[pd.DataFrame]:
+        """Get right hand side over time."""
+        args_by_simulation = self._compute_args()
+        return self._adjust_data(
+            [
+                self.model.update_parameters(p).get_right_hand_side_time_course(
+                    args=args
+                )
+                for args, p in zip(args_by_simulation, self.raw_parameters, strict=True)
+            ],
+            normalise=normalise,
+            concatenated=concatenated,
+        )
+
+    @overload
+    def get_producers(  # type: ignore
+        self,
+        variable: str,
+        *,
+        scaled: bool = False,
+        normalise: float | ArrayLike | None = None,
+        concatenated: Literal[False],
+    ) -> list[pd.DataFrame]: ...
+
+    @overload
+    def get_producers(
+        self,
+        variable: str,
+        *,
+        scaled: bool = False,
+        normalise: float | ArrayLike | None = None,
+        concatenated: Literal[True],
+    ) -> pd.DataFrame: ...
+
+    @overload
+    def get_producers(
+        self,
+        variable: str,
+        *,
+        scaled: bool = False,
+        normalise: float | ArrayLike | None = None,
+        concatenated: bool = True,
+    ) -> pd.DataFrame: ...
+
+    def get_producers(
+        self,
+        variable: str,
+        *,
+        scaled: bool = False,
+        normalise: float | ArrayLike | None = None,
+        concatenated: bool = True,
+    ) -> pd.DataFrame | list[pd.DataFrame]:
+        """Get fluxes of variable with positive stoichiometry."""
+        self.model.update_parameters(self.raw_parameters[0])
+        names = [
+            k
+            for k, v in self.model.get_stoichiometries_of_variable(variable).items()
+            if v > 0
+        ]
+
+        fluxes: list[pd.DataFrame] = [
+            i.loc[:, names]
+            for i in self.get_fluxes(normalise=normalise, concatenated=False)
+        ]
+
+        if scaled:
+            fluxes = [i.copy() for i in fluxes]
+            for v, p in zip(fluxes, self.raw_parameters, strict=True):
+                self.model.update_parameters(p)
+                stoichs = self.model.get_stoichiometries_of_variable(variable)
+                for k in names:
+                    v.loc[:, k] *= stoichs[k]
+
+        self.model.update_parameters(self.raw_parameters[-1])
+        if concatenated:
+            return pd.concat(fluxes, axis=0)
+        return fluxes
+
+    @overload
+    def get_consumers(  # type: ignore
+        self,
+        variable: str,
+        *,
+        scaled: bool = False,
+        normalise: float | ArrayLike | None = None,
+        concatenated: Literal[False],
+    ) -> list[pd.DataFrame]: ...
+
+    @overload
+    def get_consumers(
+        self,
+        variable: str,
+        *,
+        scaled: bool = False,
+        normalise: float | ArrayLike | None = None,
+        concatenated: Literal[True],
+    ) -> pd.DataFrame: ...
+
+    @overload
+    def get_consumers(
+        self,
+        variable: str,
+        *,
+        scaled: bool = False,
+        normalise: float | ArrayLike | None = None,
+        concatenated: bool = True,
+    ) -> pd.DataFrame: ...
+
+    def get_consumers(
+        self,
+        variable: str,
+        *,
+        scaled: bool = False,
+        normalise: float | ArrayLike | None = None,
+        concatenated: bool = True,
+    ) -> pd.DataFrame | list[pd.DataFrame]:
+        """Get fluxes of variable with negative stoichiometry."""
+        self.model.update_parameters(self.raw_parameters[0])
+        names = [
+            k
+            for k, v in self.model.get_stoichiometries_of_variable(variable).items()
+            if v < 0
+        ]
+
+        fluxes: list[pd.DataFrame] = [
+            i.loc[:, names]
+            for i in self.get_fluxes(normalise=normalise, concatenated=False)
+        ]
+
+        if scaled:
+            fluxes = [i.copy() for i in fluxes]
+            for v, p in zip(fluxes, self.raw_parameters, strict=True):
+                self.model.update_parameters(p)
+                stoichs = self.model.get_stoichiometries_of_variable(variable)
+                for k in names:
+                    v.loc[:, k] *= -stoichs[k]
+
+        self.model.update_parameters(self.raw_parameters[-1])
+        if concatenated:
+            return pd.concat(fluxes, axis=0)
+        return fluxes
+
     def get_new_y0(self) -> dict[str, float]:
         """Get the new initial conditions after the simulation.
 
@@ -810,6 +981,7 @@ class Result:
             self.get_variables(
                 include_derived_variables=False,
                 include_readouts=False,
+                include_surrogate_variables=False,
             ).iloc[-1]
         )
 

{mxlpy-0.24.0.dist-info → mxlpy-0.26.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mxlpy
-Version: 0.24.0
+Version: 0.26.0
 Summary: A package to build metabolic models
 Author-email: Marvin van Aalst <marvin.vanaalst@gmail.com>
 Maintainer-email: Marvin van Aalst <marvin.vanaalst@gmail.com>
@@ -45,6 +45,9 @@ Requires-Dist: toml>=0.10.2
 Requires-Dist: tqdm>=4.66.6
 Requires-Dist: typing-extensions>=4.12.2
 Requires-Dist: wadler-lindig>=0.1.7
+Provides-Extra: equinox
+Requires-Dist: equinox>=0.13; extra == 'equinox'
+Requires-Dist: optax>=0.2.5; extra == 'equinox'
 Provides-Extra: keras
 Requires-Dist: keras>=3.9.2; extra == 'keras'
 Provides-Extra: tensorflow
@@ -124,3 +127,10 @@ You have two choices here, using `uv` (pypi-only) or using `pixi` (conda-forge,
 ## LLMs
 
 We support the [llms.txt](https://llmstxt.org/) convention for making documentation available to large language models and the applications that make use of them. It is located at [docs/llms.txt](https://github.com/Computational-Biology-Aachen/MxlPy/tree/main/docs/llms.txt)
+
+## Tool family 🏠
+
+`MxlPy` is part of a larger family of tools that are designed with a similar set of abstractions. Check them out!
+
+- [MxlBricks](https://github.com/Computational-Biology-Aachen/mxl-bricks) is built on top of `MxlPy` to build mechanistic models composed of pre-defined reactions (bricks)
+- [MxlWeb](https://github.com/Computational-Biology-Aachen/mxl-web) brings simulation of mechanistic models to the browser!

{mxlpy-0.24.0.dist-info → mxlpy-0.26.0.dist-info}/RECORD

@@ -1,16 +1,17 @@
-mxlpy/__init__.py,sha256=MzR_lZLel95RyWISsF16mDLscGoaw79oD976MFo5_TI,4453
+mxlpy/__init__.py,sha256=BbX_NokTtsiJgVqCcEeBlt3KJJbjl-8dFCQu9xkPZao,4477
 mxlpy/carousel.py,sha256=3M2rqi2bx87y8D-oqEKTKZ6Q_clDQHbdLNdVjLJeO7c,6013
 mxlpy/compare.py,sha256=rJPOXc-aX6I1EC3ERAAW5Jn04kMwrlqUqdBgbZa6LA4,8098
 mxlpy/distributions.py,sha256=ce6RTqn19YzMMec-u09fSIUA8A92M6rehCuHuXWcX7A,8734
-mxlpy/fit.py,sha256=UTNvbUcL9mg7NuH5qq3syqpXXqynT_lXmKQudxwWcsE,22880
+mxlpy/fit.py,sha256=Kxf5NTHS47YGa9jD_35T_ddEZLsI_lfSJcpqYDW5vWA,40746
 mxlpy/fns.py,sha256=NLxYwa3ylS7SkISBjw_TgQSKEm7WnkZF9wPigX_ZCAM,13915
-mxlpy/identify.py,sha256=G-Zyr_l-K2mDtIV1xGrQ52QJxoBYqRoNA5RW6GpbNjs,2213
+mxlpy/fuzzy.py,sha256=T72nr_IHCF4KH5daLxWEgui9SyBw8TPlvPzmGHhaTWQ,4161
+mxlpy/identify.py,sha256=gB66R9u8-SJGHxEoTfl9QC2seDoreaIo3e6zMQOMGho,2258
 mxlpy/label_map.py,sha256=PwYanfg07hC0ayyOOP72RFlCQNvhCTbpOhW6kZZ2GUU,17826
 mxlpy/linear_label_map.py,sha256=6Ye6IziWGKkYD_5z3FmTVwnJ2T9SvVGN3U4CfXjXseo,10320
 mxlpy/mc.py,sha256=uMHknTNHmK5b4REM3PtCpCjEr9LoSIBsGsCNU4_yHpg,18639
 mxlpy/mca.py,sha256=IoOHJbjPnAEDqKk64OjFjgRPX5K_aE9D4RrCJ1xFIkw,9457
-mxlpy/model.py,sha256=kjZTQo8yM62JX2GedwTCfxtTQpdprg8vJzgJvp_5XCI,79643
-mxlpy/parallel.py,sha256=yLQLw5O4vnPVp_Zmtw1UhPWtB3483foimxQB-TwFKPg,5016
+mxlpy/model.py,sha256=1LzmtolJgQi1NefFIBZWajDaScNTANXBqJkfcejia8Q,80928
+mxlpy/parallel.py,sha256=UIswqVcdycZt-SNGZqTl0g0ErONUkrEpVDQn7TI19Z0,7373
 mxlpy/parameterise.py,sha256=IgbvfEnkmaqVq_5GgFjHqApGUN9CJrsVD3Fr7pg9iFA,758
 mxlpy/paths.py,sha256=TK2wO4N9lG-UV1JGfeB64q48JVDbwqIUj63rl55MKuQ,1022
 mxlpy/plot.py,sha256=Dng9tyga8xagINQO_OZvjLRoaYGFR8crMljDHrzwEF8,33603
@@ -18,40 +19,43 @@ mxlpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mxlpy/report.py,sha256=v597yzKecgtoNmlNZ_nVhBCa3czNw0tksOK5mLtAQvE,10631
 mxlpy/scan.py,sha256=KXFdeWwgUBqJBCiOGDdMAGU5nS3PRVn7Cg0ISpzzK1U,17160
 mxlpy/simulator.py,sha256=-jsSP1fEnJnHj1hcj37cAPUyyP57mP_ow2cL-xd9iw8,16699
-mxlpy/types.py,sha256=Vg3ekCkhbH8HjqdDTA7vaAdFp9Diney3ARZZfbq0MoA,33475
+mxlpy/types.py,sha256=JaJFE_7aiQPWU8j70Sg0tzNX64uratFEEu6MBqMOgTI,38507
 mxlpy/units.py,sha256=4bKXkCYsONUVWRdzV7aVcWFQSA6sxilebgXXFUEKw_c,2091
 mxlpy/experimental/__init__.py,sha256=kZTE-92OErpHzNRqmgSQYH4CGXrogGJ5EL35XGZQ81M,206
 mxlpy/experimental/diff.py,sha256=fmsM53lH86TD2iglQILK-XeZnIAtwHAcGC3Afs8V-tc,9457
 mxlpy/integrators/__init__.py,sha256=TKo2dkJqdW3_n7YrmF6k3kEjr8_kr3-7MDaLu-zFWRg,533
 mxlpy/integrators/int_assimulo.py,sha256=1cvR8cOBdrl_DQs9v0o7wItSG5iyYqwZVh7EO0fg3ro,5021
 mxlpy/integrators/int_diffrax.py,sha256=q_8NZgIZ6T-SRRcI8kSjEb6l-DbXqPv6rjj9KApkQac,3326
-mxlpy/integrators/int_scipy.py,sha256=xKyisVN1jW5hxmVD2K_RpoQ2MwNrMxSGODsAEgEt6_I,4922
+mxlpy/integrators/int_scipy.py,sha256=ncfrdYCTU4sDVe6oX_1Kpv9aMjHmKtgUMS8KAmCW4-c,5020
 mxlpy/meta/__init__.py,sha256=8-UPZan2pT6RSuN65KC4vV9WPJiAzm2ZsXz3Zu_rmww,475
-mxlpy/meta/codegen_latex.py,sha256=Owj5GKDFkiqks2mIDQIXV3M_5TysGwAZgKSq8C3KBIg,23461
+mxlpy/meta/codegen_latex.py,sha256=Br6xAP7LigvFUEtvnyzbk3bG8Q_GGxZSPS4pYggi5WY,23502
 mxlpy/meta/codegen_model.py,sha256=FkVrAS7HOyTQPNTItgyo8jjDEylkbETGnxJgRTBDAP4,6722
 mxlpy/meta/codegen_mxlpy.py,sha256=FjBw37IqziB4dv5VBAvKenFODfxjJXdW6rQqx9CqYUk,8433
-mxlpy/meta/source_tools.py,sha256=e6ufIsBjgde3QuQ9OsAYES0Lib4WALw4E-0wH_2cF6Y,22442
+mxlpy/meta/source_tools.py,sha256=CBrDqKzeqyClP5rokBw8KsaXkY1tZS0qHvTkes8y870,22440
 mxlpy/meta/sympy_tools.py,sha256=mWVn63OMeiTmVlV586pXxDa3l-_Pc1VcP1G39vYRGS4,3203
-mxlpy/nn/__init__.py,sha256=Qjr-ERsY2lbD75sFBOhCUwEasQDSJKcpBn_kReLZ6oA,633
+mxlpy/nn/__init__.py,sha256=MHzt_lpQlOstEXh_qIP0NR-WYd8xzzuFWXWcI2u3URA,816
+mxlpy/nn/_equinox.py,sha256=YF3MGzAgW6pFDL8uQcPe86bfGsYfmr9ojK2neC_cF20,8727
 mxlpy/nn/_keras.py,sha256=-5zjHRu8OjSiZeuBSIZFyB63uBsNNH5o9y4kBcPnhx8,2263
-mxlpy/nn/_torch.py,sha256=GUJmLU282VU4O-fs3Sz90SEaAnfuXN2MPlBr_tHmvn4,5775
-mxlpy/npe/__init__.py,sha256=hBHCUD2JYDBBGS2kTY8mTCfWB3u1R7m5l--wUupZt6o,1270
+mxlpy/nn/_torch.py,sha256=gv3fIC_byDF-KQtUlkYk0k7Kn6tyzBDEe_U_Wy8v69s,7788
+mxlpy/npe/__init__.py,sha256=G550CnHCI1glqjAB3cxdObaRjfe8qTGho1wAF2C_8r8,1454
+mxlpy/npe/_equinox.py,sha256=zHaaYmdwhIByKSYhz53h3SeT3HpsoFwBeiNRNorfO9I,11086
 mxlpy/npe/_keras.py,sha256=ytvXMPK9KUCGOzTQm08_SgafiMb-MOIUdZQV7JjAO40,9721
-mxlpy/npe/_torch.py,sha256=v3joh6lFJJxvYJj--wzmKXL9UMTaIN3h6hPNq0uX9NU,11250
+mxlpy/npe/_torch.py,sha256=4g9RBSHjmgdBYb0xotrjHKM1j0mmPhNAVhNt8fMaKtg,10980
 mxlpy/sbml/__init__.py,sha256=Mt97CddpLi3wIrA1b_5cagLmDdNxAVF_S7QV57Pzw8s,226
 mxlpy/sbml/_data.py,sha256=98w5vyhdOHilD5zjy21XFzam0FlvcW_cb1XRTsIgD_M,2019
 mxlpy/sbml/_export.py,sha256=leKf7dFqpoYxO3xFu4j_mM5eAgo-lq__ywADXsmamRU,21008
 mxlpy/sbml/_import.py,sha256=_4MR54YyVkIh9eVAiSMd7yijhHC_ds-3v7M_C4Zn8BY,3565
 mxlpy/sbml/_name_conversion.py,sha256=93muW47M7qJoE227HKHmThWpPeWsXDN9eM8cRH2pqPs,1340
-mxlpy/surrogates/__init__.py,sha256=cz9qr0ToYSutIK45IvKrMe1mPP7Lj0I_V0HYGixfpZU,916
+mxlpy/surrogates/__init__.py,sha256=nrjfvS9ZnaQkKT2ybFxP33LhkwUs9D2EKmrMkgczaFw,1107
+mxlpy/surrogates/_equinox.py,sha256=hF-c67RYzcV_Z-wfDyWsFSrKvvWgryDIrAsDQiStSrA,6032
 mxlpy/surrogates/_keras.py,sha256=r2pR3iTJOaMqtATbsCm5CF94TYG9b-9cKljc8kMOplQ,3852
 mxlpy/surrogates/_poly.py,sha256=z2g3JTdVyQJ8dIiXP4BOun_yMZOrlYpPNvQ0wmFYDTk,3672
 mxlpy/surrogates/_qss.py,sha256=9w-hPPhdcwybkyaSX0sIfYfvcKu1U5j4HHj4SlgZcYQ,723
-mxlpy/surrogates/_torch.py,sha256=gU0secuRBYgewhNqZmSo6_Xf804dSzwWwIYmdKA7y60,6389
+mxlpy/surrogates/_torch.py,sha256=sgSc9z6s4ry2ZYhl7C6DuQaj7rXcd-TNckmvB342aGk,6086
 mxlpy/symbolic/__init__.py,sha256=_vM5YM5I6OH0QDbFt9uGYKO8Z5Vly0wbGuvUScVrPRU,258
 mxlpy/symbolic/strikepy.py,sha256=tzo3uvPpXLDex09hWTuitVzuTNwbgl7jWGjD8g6a8iI,20033
-mxlpy/symbolic/symbolic_model.py,sha256=cKfWoktvFmXjuo8egE7gXKrKBq2iBUiy_BcIKIvvz8A,3026
-mxlpy-0.24.0.dist-info/METADATA,sha256=Hqld-ntG-lfZey_b-aHgJo-T8KYylrC-iSf9CxMs-XA,4980
-mxlpy-0.24.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mxlpy-0.24.0.dist-info/licenses/LICENSE,sha256=lHX9Eu70g3Iv1aOxXTWNHa3vq9vaVYSPQx4jOLYmDpw,1096
-mxlpy-0.24.0.dist-info/RECORD,,
+mxlpy/symbolic/symbolic_model.py,sha256=tJriUs6C_A3y2i89FBNGBYDL3dLKS_MHBm2nQuBRmvs,3773
+mxlpy-0.26.0.dist-info/METADATA,sha256=dOHcVtFJHYDSoWxdIrDTsyjzoTm79rj4qyPaE3jSdCM,5534
+mxlpy-0.26.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mxlpy-0.26.0.dist-info/licenses/LICENSE,sha256=lHX9Eu70g3Iv1aOxXTWNHa3vq9vaVYSPQx4jOLYmDpw,1096
+mxlpy-0.26.0.dist-info/RECORD,,