mxlpy 0.23.0__py3-none-any.whl → 0.25.0__py3-none-any.whl

mxlpy/__init__.py

@@ -45,21 +45,22 @@ from . import (
     compare,
     distributions,
     experimental,
-    fit,
     fns,
     mc,
     mca,
     plot,
     report,
     sbml,
+    scan,
     units,
 )
+from .fit import global_ as fit_global
+from .fit import local_ as fit_local
 from .integrators import DefaultIntegrator, Diffrax, Scipy
 from .label_map import LabelMapper
 from .linear_label_map import LinearLabelMapper
 from .mc import Cache
 from .model import Model
-from .scan import steady_state, time_course, time_course_over_protocol
 from .simulator import Simulator
 from .symbolic import SymbolicModel, to_symbolic_model
 from .types import (
@@ -106,7 +107,8 @@ __all__ = [
     "compare",
     "distributions",
     "experimental",
-    "fit",
+    "fit_global",
+    "fit_local",
     "fns",
     "make_protocol",
     "mc",
@@ -116,11 +118,9 @@ __all__ = [
     "plot",
     "report",
     "sbml",
-    "steady_state",
+    "scan",
     "surrogates",
     "symbolic",
-    "time_course",
-    "time_course_over_protocol",
     "to_symbolic_model",
     "units",
     "unwrap",

mxlpy/carousel.py

@@ -9,6 +9,7 @@ from functools import partial
 from typing import TYPE_CHECKING
 
 import pandas as pd
+from wadler_lindig import pformat
 
 from mxlpy import parallel, scan
 
@@ -25,6 +26,10 @@ if TYPE_CHECKING:
 class ReactionTemplate:
     """Template for a reaction in a model."""
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     fn: RateFn
     args: list[str]
     additional_parameters: dict[str, float] = field(default_factory=dict)
@@ -37,6 +42,10 @@ class CarouselSteadyState:
     carousel: list[Model]
     results: list[Result]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     def get_variables_by_model(self) -> pd.DataFrame:
         """Get the variables of the time course results, indexed by model."""
         return pd.DataFrame(
@@ -51,6 +60,10 @@ class CarouselTimeCourse:
     carousel: list[Model]
     results: list[Result]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     def get_variables_by_model(self) -> pd.DataFrame:
         """Get the variables of the time course results, indexed by model."""
         return pd.concat({i: r.variables for i, r in enumerate(self.results)})
@@ -76,6 +89,10 @@ class Carousel:
 
     variants: list[Model]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     def __init__(
         self,
         model: Model,
@@ -115,7 +132,7 @@ class Carousel:
             results=results,
         )
 
-    def protocol_time_course(
+    def protocol(
         self,
         protocol: pd.DataFrame,
         *,
@@ -141,6 +158,34 @@ class Carousel:
             results=results,
         )
 
+    def protocol_time_course(
+        self,
+        protocol: pd.DataFrame,
+        time_points: Array,
+        *,
+        y0: dict[str, float] | None = None,
+        integrator: IntegratorType | None = None,
+    ) -> CarouselTimeCourse:
+        """Simulate the carousel of models over a protocol time course."""
+        results = [
+            i[1]
+            for i in parallel.parallelise(
+                partial(
+                    scan._protocol_time_course_worker,  # noqa: SLF001
+                    protocol=protocol,
+                    integrator=integrator,
+                    time_points=time_points,
+                    y0=y0,
+                ),
+                list(enumerate(self.variants)),
+            )
+        ]
+
+        return CarouselTimeCourse(
+            carousel=self.variants,
+            results=results,
+        )
+
     def steady_state(
         self,
         *,

mxlpy/compare.py

@@ -6,6 +6,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, cast
 
 import pandas as pd
+from wadler_lindig import pformat
 
 from mxlpy import plot
 from mxlpy.simulator import Simulator
@@ -32,6 +33,10 @@ class SteadyStateComparison:
     res1: Result
     res2: Result
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     @property
     def variables(self) -> pd.DataFrame:
         """Compare the steady state variables."""
@@ -93,6 +98,10 @@ class TimeCourseComparison:
     res1: Result
     res2: Result
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     # @property
     # def variables(self) -> pd.DataFrame:
     #     """Compare the steady state variables."""
@@ -144,6 +153,10 @@ class ProtocolComparison:
     res2: Result
     protocol: pd.DataFrame
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     # @property
     # def variables(self) -> pd.DataFrame:
     #     """Compare the steady state variables."""

mxlpy/experimental/diff.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
+from wadler_lindig import pformat
+
 from mxlpy.types import Derived
 
 if TYPE_CHECKING:
@@ -28,6 +30,10 @@ class DerivedDiff:
     args1: list[str] = field(default_factory=list)
     args2: list[str] = field(default_factory=list)
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class ReactionDiff:
@@ -38,6 +44,10 @@ class ReactionDiff:
     stoichiometry1: dict[str, float | Derived] = field(default_factory=dict)
     stoichiometry2: dict[str, float | Derived] = field(default_factory=dict)
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class ModelDiff:
@@ -56,6 +66,10 @@ class ModelDiff:
     different_readouts: dict[str, DerivedDiff] = field(default_factory=dict)
     different_derived: dict[str, DerivedDiff] = field(default_factory=dict)
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     def __str__(self) -> str:
         """Return a human-readable string representation of the diff."""
         content = ["Model Diff", "----------"]

mxlpy/fit/__init__.py

@@ -0,0 +1,9 @@
+"""Fitting routines."""
+
+from . import common, global_, local_
+
+__all__ = [
+    "common",
+    "global_",
+    "local_",
+]

mxlpy/fit/common.py

@@ -0,0 +1,298 @@
+"""Common types and utilities between local and global fitting."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Protocol
+
+import numpy as np
+import pandas as pd
+from wadler_lindig import pformat
+
+from mxlpy.model import Model
+from mxlpy.simulator import Simulator
+from mxlpy.types import Array, ArrayLike, Callable, IntegratorType, cast
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+    from mxlpy.model import Model
+
+LOGGER = logging.getLogger(__name__)
+
+type InitialGuess = dict[str, float]
+
+type Bounds = dict[str, tuple[float | None, float | None]]
+type ResidualFn = Callable[[Array], float]
+type LossFn = Callable[
+    [
+        pd.DataFrame | pd.Series,
+        pd.DataFrame | pd.Series,
+    ],
+    float,
+]
+
+
+__all__ = [
+    "Bounds",
+    "CarouselFit",
+    "FitResult",
+    "InitialGuess",
+    "LOGGER",
+    "LossFn",
+    "MinResult",
+    "ProtocolResidualFn",
+    "ResidualFn",
+    "SteadyStateResidualFn",
+    "TimeSeriesResidualFn",
+    "rmse",
+]
+
+
+@dataclass
+class MinResult:
+    """Result of a minimization operation."""
+
+    parameters: dict[str, float]
+    residual: float
+
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
+
+@dataclass
+class FitResult:
+    """Result of a fit operation."""
+
+    model: Model
+    best_pars: dict[str, float]
+    loss: float
+
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
+
+@dataclass
+class CarouselFit:
+    """Result of a carousel fit operation."""
+
+    fits: list[FitResult]
+
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
+    def get_best_fit(self) -> FitResult:
+        """Get the best fit from the carousel."""
+        return min(self.fits, key=lambda x: x.loss)
+
+
+def rmse(
+    y_pred: pd.DataFrame | pd.Series,
+    y_true: pd.DataFrame | pd.Series,
+) -> float:
+    """Calculate root mean square error between model and data."""
+    return cast(float, np.sqrt(np.mean(np.square(y_pred - y_true))))
+
+
+class SteadyStateResidualFn(Protocol):
+    """Protocol for steady state residual functions."""
+
+    def __call__(
+        self,
+        par_values: Array,
+        # This will be filled out by partial
+        par_names: list[str],
+        data: pd.Series,
+        model: Model,
+        y0: dict[str, float] | None,
+        integrator: IntegratorType | None,
+        loss_fn: LossFn,
+    ) -> float:
+        """Calculate residual error between model steady state and experimental data."""
+        ...
+
+
+class TimeSeriesResidualFn(Protocol):
+    """Protocol for time series residual functions."""
+
+    def __call__(
+        self,
+        par_values: Array,
+        # This will be filled out by partial
+        par_names: list[str],
+        data: pd.DataFrame,
+        model: Model,
+        y0: dict[str, float] | None,
+        integrator: IntegratorType | None,
+        loss_fn: LossFn,
+    ) -> float:
+        """Calculate residual error between model time course and experimental data."""
+        ...
+
+
+class ProtocolResidualFn(Protocol):
+    """Protocol for time series residual functions."""
+
+    def __call__(
+        self,
+        par_values: Array,
+        # This will be filled out by partial
+        par_names: list[str],
+        data: pd.DataFrame,
+        model: Model,
+        y0: dict[str, float] | None,
+        integrator: IntegratorType | None,
+        loss_fn: LossFn,
+        protocol: pd.DataFrame,
+    ) -> float:
+        """Calculate residual error between model time course and experimental data."""
+        ...
+
+
+def _steady_state_residual(
+    par_values: Array,
+    # This will be filled out by partial
+    par_names: list[str],
+    data: pd.Series,
+    model: Model,
+    y0: dict[str, float] | None,
+    integrator: IntegratorType | None,
+    loss_fn: LossFn,
+) -> float:
+    """Calculate residual error between model steady state and experimental data.
+
+    Args:
+        par_values: Parameter values to test
+        data: Experimental steady state data
+        model: Model instance to simulate
+        y0: Initial conditions
+        par_names: Names of parameters being fit
+        integrator: ODE integrator class to use
+        loss_fn: Loss function to use for residual calculation
+
+    Returns:
+        float: Root mean square error between model and data
+
+    """
+    res = (
+        Simulator(
+            model.update_parameters(
+                dict(
+                    zip(
+                        par_names,
+                        par_values,
+                        strict=True,
+                    )
+                )
+            ),
+            y0=y0,
+            integrator=integrator,
+        )
+        .simulate_to_steady_state()
+        .get_result()
+    )
+    if res is None:
+        return cast(float, np.inf)
+
+    return loss_fn(
+        res.get_combined().loc[:, cast(list, data.index)],
+        data,
+    )
+
+
+def _time_course_residual(
+    par_values: ArrayLike,
+    # This will be filled out by partial
+    par_names: list[str],
+    data: pd.DataFrame,
+    model: Model,
+    y0: dict[str, float] | None,
+    integrator: IntegratorType | None,
+    loss_fn: LossFn,
+) -> float:
+    """Calculate residual error between model time course and experimental data.
+
+    Args:
+        par_values: Parameter values to test
+        data: Experimental time course data
+        model: Model instance to simulate
+        y0: Initial conditions
+        par_names: Names of parameters being fit
+        integrator: ODE integrator class to use
+        loss_fn: Loss function to use for residual calculation
+
+    Returns:
+        float: Root mean square error between model and data
+
+    """
+    res = (
+        Simulator(
+            model.update_parameters(dict(zip(par_names, par_values, strict=True))),
+            y0=y0,
+            integrator=integrator,
+        )
+        .simulate_time_course(cast(list, data.index))
+        .get_result()
+    )
+    if res is None:
+        return cast(float, np.inf)
+    results_ss = res.get_combined()
+
+    return loss_fn(
+        results_ss.loc[:, cast(list, data.columns)],
+        data,
+    )
+
+
+def _protocol_time_course_residual(
+    par_values: ArrayLike,
+    # This will be filled out by partial
+    par_names: list[str],
+    data: pd.DataFrame,
+    model: Model,
+    y0: dict[str, float] | None,
+    integrator: IntegratorType | None,
+    loss_fn: LossFn,
+    protocol: pd.DataFrame,
+) -> float:
+    """Calculate residual error between model time course and experimental data.
+
+    Args:
+        par_values: Parameter values to test
+        data: Experimental time course data
+        model: Model instance to simulate
+        y0: Initial conditions
+        par_names: Names of parameters being fit
+        integrator: ODE integrator class to use
+        loss_fn: Loss function to use for residual calculation
+        protocol: Experimental protocol
+        time_points_per_step: Number of time points per step in the protocol
+
+    Returns:
+        float: Root mean square error between model and data
+
+    """
+    res = (
+        Simulator(
+            model.update_parameters(dict(zip(par_names, par_values, strict=True))),
+            y0=y0,
+            integrator=integrator,
+        )
+        .simulate_protocol_time_course(
+            protocol=protocol,
+            time_points=data.index,
+        )
+        .get_result()
+    )
+    if res is None:
+        return cast(float, np.inf)
+    results_ss = res.get_combined()
+
+    return loss_fn(
+        results_ss.loc[:, cast(list, data.columns)],
+        data,
+    )