mxlpy 0.19.0__py3-none-any.whl → 0.21.0__py3-none-any.whl

mxlpy/__init__.py

@@ -42,6 +42,7 @@ from typing import TYPE_CHECKING
 import pandas as pd
 
 from . import (
+    compare,
     distributions,
     experimental,
     fit,
@@ -57,11 +58,7 @@ 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 .scan import steady_state, time_course, time_course_over_protocol
 from .simulator import Simulator
 from .symbolic import SymbolicModel, to_symbolic_model
 from .types import Derived, IntegratorProtocol, unwrap
@@ -72,11 +69,7 @@ with contextlib.suppress(ImportError):
 if TYPE_CHECKING:
     from mxlpy.types import ArrayLike
 
-    from . import (
-        nn,
-        npe,
-        surrogates,
-    )
+    from . import nn, npe, surrogates
 else:
     from lazy_import import lazy_module
 
@@ -98,6 +91,7 @@ __all__ = [
     "Simulator",
     "SymbolicModel",
     "cartesian_product",
+    "compare",
     "distributions",
     "experimental",
     "fit",

mxlpy/carousel.py

@@ -0,0 +1,166 @@
+"""Reaction carousel."""
+
+from __future__ import annotations
+
+import itertools as it
+from copy import deepcopy
+from dataclasses import dataclass, field
+from functools import partial
+from typing import TYPE_CHECKING
+
+import pandas as pd
+
+from mxlpy import parallel, scan
+
+__all__ = ["Carousel", "CarouselSteadyState", "CarouselTimeCourse", "ReactionTemplate"]
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping
+
+    from mxlpy import Model
+    from mxlpy.types import Array, IntegratorType, RateFn
+
+
+@dataclass
+class ReactionTemplate:
+    """Template for a reaction in a model."""
+
+    fn: RateFn
+    args: list[str]
+    additional_parameters: dict[str, float] = field(default_factory=dict)
+
+
+@dataclass
+class CarouselSteadyState:
+    """Time course of a carousel simulation."""
+
+    carousel: list[Model]
+    results: list[scan.TimePoint]
+
+    def get_variables_by_model(self) -> pd.DataFrame:
+        """Get the variables of the time course results, indexed by model."""
+        return pd.DataFrame({i: r.variables for i, r in enumerate(self.results)}).T
+
+
+@dataclass
+class CarouselTimeCourse:
+    """Time course of a carousel simulation."""
+
+    carousel: list[Model]
+    results: list[scan.TimeCourse]
+
+    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)})
+
+
+def _dict_product[T1, T2](d: Mapping[T1, Iterable[T2]]) -> Iterable[dict[T1, T2]]:
+    yield from (dict(zip(d.keys(), x, strict=True)) for x in it.product(*d.values()))
+
+
+def _make_reaction_carousel(
+    model: Model, rxns: dict[str, list[ReactionTemplate]]
+) -> Iterable[Model]:
+    for d in _dict_product(rxns):
+        new = deepcopy(model)
+        for rxn, template in d.items():
+            new.add_parameters(template.additional_parameters)
+            new.update_reaction(name=rxn, fn=template.fn, args=template.args)
+        yield new
+
+
+class Carousel:
+    """A carousel of models with different reaction templates."""
+
+    variants: list[Model]
+
+    def __init__(
+        self,
+        model: Model,
+        variants: dict[str, list[ReactionTemplate]],
+    ) -> None:
+        """Initialize the carousel with a model and reaction templates."""
+        self.variants = list(
+            _make_reaction_carousel(
+                model=model,
+                rxns=variants,
+            )
+        )
+
+    def time_course(
+        self,
+        time_points: Array,
+        *,
+        y0: dict[str, float] | None = None,
+        integrator: IntegratorType | None = None,
+    ) -> CarouselTimeCourse:
+        """Simulate the carousel of models over a time course."""
+        results = [
+            i[1]
+            for i in parallel.parallelise(
+                partial(
+                    scan._time_course_worker,  # noqa: SLF001
+                    time_points=time_points,
+                    integrator=integrator,
+                    y0=y0,
+                ),
+                list(enumerate(self.variants)),
+            )
+        ]
+
+        return CarouselTimeCourse(
+            carousel=self.variants,
+            results=results,
+        )
+
+    def protocol_time_course(
+        self,
+        protocol: pd.DataFrame,
+        *,
+        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_worker,  # noqa: SLF001
+                    protocol=protocol,
+                    integrator=integrator,
+                    y0=y0,
+                ),
+                list(enumerate(self.variants)),
+            )
+        ]
+
+        return CarouselTimeCourse(
+            carousel=self.variants,
+            results=results,
+        )
+
+    def steady_state(
+        self,
+        *,
+        y0: dict[str, float] | None = None,
+        integrator: IntegratorType | None = None,
+        rel_norm: bool = False,
+    ) -> CarouselSteadyState:
+        """Simulate the carousel of models over a time course."""
+        results = [
+            i[1]
+            for i in parallel.parallelise(
+                partial(
+                    scan._steady_state_worker,  # noqa: SLF001
+                    integrator=integrator,
+                    rel_norm=rel_norm,
+                    y0=y0,
+                ),
+                list(enumerate(self.variants)),
+            )
+        ]
+
+        return CarouselSteadyState(
+            carousel=self.variants,
+            results=results,
+        )

mxlpy/compare.py

@@ -0,0 +1,240 @@
+"""Docstring."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, cast
+
+import pandas as pd
+
+from mxlpy import plot
+from mxlpy.simulator import Result, Simulator
+from mxlpy.types import unwrap
+
+if TYPE_CHECKING:
+    from mxlpy.model import Model
+    from mxlpy.types import ArrayLike
+
+__all__ = [
+    "ProtocolComparison",
+    "SteadyStateComparison",
+    "TimeCourseComparison",
+    "protocol_time_courses",
+    "steady_states",
+    "time_courses",
+]
+
+
+@dataclass
+class SteadyStateComparison:
+    """Compare two steady states."""
+
+    res1: Result
+    res2: Result
+
+    @property
+    def variables(self) -> pd.DataFrame:
+        """Compare the steady state variables."""
+        ss1 = self.res1.get_variables().iloc[-1]
+        ss2 = self.res2.get_variables().iloc[-1]
+        diff = ss2 - ss1
+        return pd.DataFrame(
+            {"m1": ss1, "m2": ss2, "diff": diff, "rel_diff": diff / ss1}
+        )
+
+    @property
+    def fluxes(self) -> pd.DataFrame:
+        """Compare the steady state fluxes."""
+        ss1 = self.res1.get_fluxes().iloc[-1]
+        ss2 = self.res2.get_fluxes().iloc[-1]
+        diff = ss2 - ss1
+        return pd.DataFrame(
+            {"m1": ss1, "m2": ss2, "diff": diff, "rel_diff": diff / ss1}
+        )
+
+    @property
+    def all(self) -> pd.DataFrame:
+        """Compare both steady-state variables and fluxes."""
+        ss1 = self.res1.get_combined().iloc[-1]
+        ss2 = self.res2.get_combined().iloc[-1]
+        diff = ss2 - ss1
+        return pd.DataFrame(
+            {"m1": ss1, "m2": ss2, "diff": diff, "rel_diff": diff / ss1}
+        )
+
+    def plot_variables(self, title: str = "Variables") -> plot.FigAxs:
+        """Plot the relative difference of steady-state variables."""
+        fig, axs = plot.bars_autogrouped(self.variables["rel_diff"], ylabel="")
+        plot.grid_labels(axs, ylabel="Relative difference")
+        fig.suptitle(title)
+        return fig, axs
+
+    def plot_fluxes(self, title: str = "Fluxes") -> plot.FigAxs:
+        """Plot the relative difference of steady-state fluxes."""
+        fig, axs = plot.bars_autogrouped(self.fluxes["rel_diff"], ylabel="")
+        plot.grid_labels(axs, ylabel="Relative difference")
+        fig.suptitle(title)
+        return fig, axs
+
+    def plot_all(self, title: str = "Variables and Fluxes") -> plot.FigAxs:
+        """Plot the relative difference of steady-state variables and fluxes."""
+        combined = self.all
+
+        fig, axs = plot.bars_autogrouped(combined["rel_diff"], ylabel="")
+        plot.grid_labels(axs, ylabel="Relative difference")
+        fig.suptitle(title)
+        return fig, axs
+
+
+@dataclass
+class TimeCourseComparison:
+    """Compare two time courses."""
+
+    res1: Result
+    res2: Result
+
+    # @property
+    # def variables(self) -> pd.DataFrame:
+    #     """Compare the steady state variables."""
+    #     ss1 = self.res1.get_variables()
+    #     ss2 = self.res2.get_variables()
+    #     diff = ss2 - ss1
+    #     return pd.DataFrame(
+    #         {"m1": ss1, "m2": ss2, "diff": diff, "rel_diff": diff / ss1}
+    #     )
+
+    # @property
+    # def fluxes(self) -> pd.DataFrame:
+    #     """Compare the steady state fluxes."""
+    #     ss1 = self.res1.get_fluxes()
+    #     ss2 = self.res2.get_fluxes()
+    #     diff = ss2 - ss1
+    #     return pd.DataFrame(
+    #         {"m1": ss1, "m2": ss2, "diff": diff, "rel_diff": diff / ss1}
+    #     )
+
+    def plot_variables_relative_difference(self) -> plot.FigAxs:
+        """Plot the relative difference of time course variables."""
+        c1 = self.res1.variables
+        c2 = self.res2.variables
+
+        rel_diff = ((c2.loc[:, cast(list[str], c1.columns)] - c1) / c1).fillna(0)
+        fig, axs = plot.line_autogrouped(rel_diff, ylabel="")
+        plot.grid_labels(axs, ylabel="Relative difference")
+        fig.suptitle("Variables")
+        return fig, axs
+
+    def plot_fluxes_relative_difference(self) -> plot.FigAxs:
+        """Plot the relative difference of time course fluxes."""
+        v1 = self.res1.fluxes
+        v2 = self.res2.fluxes
+
+        rel_diff = ((v2.loc[:, cast(list[str], v1.columns)] - v1) / v1).fillna(0)
+        fig, axs = plot.line_autogrouped(rel_diff, ylabel="")
+        plot.grid_labels(axs, ylabel="Relative difference")
+        fig.suptitle("Fluxes")
+        return fig, axs
+
+
+@dataclass
+class ProtocolComparison:
+    """Compare two protocol time courses."""
+
+    res1: Result
+    res2: Result
+    protocol: pd.DataFrame
+
+    # @property
+    # def variables(self) -> pd.DataFrame:
+    #     """Compare the steady state variables."""
+    #     ss1 = self.res1.get_variables()
+    #     ss2 = self.res2.get_variables()
+    #     diff = ss2 - ss1
+    #     return pd.DataFrame(
+    #         {"m1": ss1, "m2": ss2, "diff": diff, "rel_diff": diff / ss1}
+    #     )
+
+    # @property
+    # def fluxes(self) -> pd.DataFrame:
+    #     """Compare the steady state fluxes."""
+    #     ss1 = self.res1.get_fluxes()
+    #     ss2 = self.res2.get_fluxes()
+    #     diff = ss2 - ss1
+    #     return pd.DataFrame(
+    #         {"m1": ss1, "m2": ss2, "diff": diff, "rel_diff": diff / ss1}
+    #     )
+
+    def plot_variables_relative_difference(
+        self,
+        shade_protocol_variable: str | None = None,
+    ) -> plot.FigAxs:
+        """Plot the relative difference of time course variables."""
+        c1 = self.res1.variables
+        c2 = self.res2.variables
+
+        rel_diff = ((c2.loc[:, cast(list[str], c1.columns)] - c1) / c1).fillna(0)
+        fig, axs = plot.line_autogrouped(rel_diff, ylabel="")
+        plot.grid_labels(axs, ylabel="Relative difference")
+        fig.suptitle("Variables")
+
+        if shade_protocol_variable is not None:
+            protocol = self.protocol[shade_protocol_variable]
+            for ax in axs:
+                plot.shade_protocol(protocol=protocol, ax=ax)
+        return fig, axs
+
+    def plot_fluxes_relative_difference(
+        self,
+        shade_protocol_variable: str | None = None,
+    ) -> plot.FigAxs:
+        """Plot the relative difference of time course fluxes."""
+        v1 = self.res1.fluxes
+        v2 = self.res2.fluxes
+
+        rel_diff = ((v2.loc[:, cast(list[str], v1.columns)] - v1) / v1).fillna(0)
+        fig, axs = plot.line_autogrouped(rel_diff, ylabel="")
+        plot.grid_labels(axs, ylabel="Relative difference")
+        fig.suptitle("Fluxes")
+
+        if shade_protocol_variable is not None:
+            protocol = self.protocol[shade_protocol_variable]
+            for ax in axs:
+                plot.shade_protocol(protocol=protocol, ax=ax)
+        return fig, axs
+
+
+def steady_states(m1: Model, m2: Model) -> SteadyStateComparison:
+    """Compare the steady states of two models."""
+    return SteadyStateComparison(
+        res1=unwrap(Simulator(m1).simulate_to_steady_state().get_result()),
+        res2=unwrap(Simulator(m2).simulate_to_steady_state().get_result()),
+    )
+
+
+def time_courses(m1: Model, m2: Model, time_points: ArrayLike) -> TimeCourseComparison:
+    """Compare the time courses of two models."""
+    return TimeCourseComparison(
+        res1=unwrap(
+            Simulator(m1).simulate_time_course(time_points=time_points).get_result()
+        ),
+        res2=unwrap(
+            Simulator(m2).simulate_time_course(time_points=time_points).get_result()
+        ),
+    )
+
+
+def protocol_time_courses(
+    m1: Model,
+    m2: Model,
+    protocol: pd.DataFrame,
+) -> ProtocolComparison:
+    """Compare the time courses of two models."""
+    return ProtocolComparison(
+        res1=unwrap(
+            Simulator(m1).simulate_over_protocol(protocol=protocol).get_result()
+        ),
+        res2=unwrap(
+            Simulator(m2).simulate_over_protocol(protocol=protocol).get_result()
+        ),
+        protocol=protocol,
+    )

mxlpy/experimental/diff.py

@@ -1,12 +1,24 @@
 """Diffing utilities for comparing models."""
 
-from collections.abc import Mapping
+from __future__ import annotations
+
 from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
 
-from mxlpy.model import Model
 from mxlpy.types import Derived
 
-__all__ = ["DerivedDiff", "ModelDiff", "ReactionDiff", "model_diff", "soft_eq"]
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from mxlpy.model import Model
+
+__all__ = [
+    "DerivedDiff",
+    "ModelDiff",
+    "ReactionDiff",
+    "model_diff",
+    "soft_eq",
+]
 
 
 @dataclass