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

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/fit.py

@@ -10,29 +10,42 @@ Functions:
 
 from __future__ import annotations
 
+import logging
+from copy import deepcopy
+from dataclasses import dataclass
 from functools import partial
 from typing import TYPE_CHECKING, Protocol
 
 import numpy as np
 from scipy.optimize import minimize
 
-from mxlpy.integrators import DefaultIntegrator
+from mxlpy import parallel
 from mxlpy.simulator import Simulator
 from mxlpy.types import Array, ArrayLike, Callable, IntegratorType, cast
 
 if TYPE_CHECKING:
     import pandas as pd
 
+    from mxlpy.carousel import Carousel
     from mxlpy.model import Model
 
+LOGGER = logging.getLogger(__name__)
+
 __all__ = [
+    "CarouselFit",
+    "FitResult",
     "InitialGuess",
+    "LOGGER",
     "LossFn",
+    "MinResult",
     "MinimizeFn",
     "ProtocolResidualFn",
     "ResidualFn",
     "SteadyStateResidualFn",
     "TimeSeriesResidualFn",
+    "carousel_steady_state",
+    "carousel_time_course",
+    "carousel_time_course_over_protocol",
     "rmse",
     "steady_state",
     "time_course",
@@ -40,9 +53,37 @@ __all__ = [
 ]
 
 
+@dataclass
+class MinResult:
+    """Result of a minimization operation."""
+
+    parameters: dict[str, float]
+    residual: float
+
+
+@dataclass
+class FitResult:
+    """Result of a fit operation."""
+
+    model: Model
+    best_pars: dict[str, float]
+    loss: float
+
+
+@dataclass
+class CarouselFit:
+    """Result of a carousel fit operation."""
+
+    fits: list[FitResult]
+
+    def get_best_fit(self) -> FitResult:
+        """Get the best fit from the carousel."""
+        return min(self.fits, key=lambda x: x.loss)
+
+
 type InitialGuess = dict[str, float]
 type ResidualFn = Callable[[Array], float]
-type MinimizeFn = Callable[[ResidualFn, InitialGuess], dict[str, float]]
+type MinimizeFn = Callable[[ResidualFn, InitialGuess], MinResult | None]
 type LossFn = Callable[
     [
         pd.DataFrame | pd.Series,
@@ -70,7 +111,7 @@ class SteadyStateResidualFn(Protocol):
         par_names: list[str],
         data: pd.Series,
         model: Model,
-        y0: dict[str, float],
+        y0: dict[str, float] | None,
         integrator: IntegratorType,
         loss_fn: LossFn,
     ) -> float:
@@ -88,7 +129,7 @@ class TimeSeriesResidualFn(Protocol):
         par_names: list[str],
         data: pd.DataFrame,
         model: Model,
-        y0: dict[str, float],
+        y0: dict[str, float] | None,
         integrator: IntegratorType,
         loss_fn: LossFn,
     ) -> float:
@@ -106,7 +147,7 @@ class ProtocolResidualFn(Protocol):
         par_names: list[str],
         data: pd.DataFrame,
         model: Model,
-        y0: dict[str, float],
+        y0: dict[str, float] | None,
         integrator: IntegratorType,
         loss_fn: LossFn,
         protocol: pd.DataFrame,
@@ -119,22 +160,27 @@ class ProtocolResidualFn(Protocol):
 def _default_minimize_fn(
     residual_fn: ResidualFn,
     p0: dict[str, float],
-) -> dict[str, float]:
+) -> MinResult | None:
     res = minimize(
         residual_fn,
         x0=list(p0.values()),
-        bounds=[(1e-12, 1e6) for _ in range(len(p0))],
+        bounds=[(0, None) for _ in range(len(p0))],
         method="L-BFGS-B",
     )
     if res.success:
-        return dict(
-            zip(
-                p0,
-                res.x,
-                strict=True,
-            )
+        return MinResult(
+            parameters=dict(
+                zip(
+                    p0,
+                    res.x,
+                    strict=True,
+                ),
+            ),
+            residual=res.fun,
         )
-    return dict(zip(p0, np.full(len(p0), np.nan, dtype=float), strict=True))
+
+    LOGGER.warning("Minimisation failed.")
+    return None
 
 
 def _steady_state_residual(
@@ -285,14 +331,15 @@ def _protocol_residual(
 
 def steady_state(
     model: Model,
+    *,
     p0: dict[str, float],
     data: pd.Series,
     y0: dict[str, float] | None = None,
     minimize_fn: MinimizeFn = _default_minimize_fn,
     residual_fn: SteadyStateResidualFn = _steady_state_residual,
-    integrator: IntegratorType = DefaultIntegrator,
+    integrator: IntegratorType | None = None,
     loss_fn: LossFn = rmse,
-) -> dict[str, float]:
+) -> FitResult | None:
     """Fit model parameters to steady-state experimental data.
 
     Examples:
@@ -333,23 +380,30 @@ def steady_state(
             loss_fn=loss_fn,
         ),
     )
-    res = minimize_fn(fn, p0)
-
-    # Restore
+    min_result = minimize_fn(fn, p0)
+    # Restore original model
     model.update_parameters(p_orig)
-    return res
+    if min_result is None:
+        return min_result
+
+    return FitResult(
+        model=deepcopy(model).update_parameters(min_result.parameters),
+        best_pars=min_result.parameters,
+        loss=min_result.residual,
+    )
 
 
 def time_course(
     model: Model,
+    *,
     p0: dict[str, float],
     data: pd.DataFrame,
     y0: dict[str, float] | None = None,
     minimize_fn: MinimizeFn = _default_minimize_fn,
     residual_fn: TimeSeriesResidualFn = _time_course_residual,
-    integrator: IntegratorType = DefaultIntegrator,
+    integrator: IntegratorType | None = None,
     loss_fn: LossFn = rmse,
-) -> dict[str, float]:
+) -> FitResult | None:
     """Fit model parameters to time course of experimental data.
 
     Examples:
@@ -388,23 +442,33 @@ def time_course(
             loss_fn=loss_fn,
         ),
     )
-    res = minimize_fn(fn, p0)
+
+    min_result = minimize_fn(fn, p0)
+    # Restore original model
     model.update_parameters(p_orig)
-    return res
+    if min_result is None:
+        return min_result
+
+    return FitResult(
+        model=deepcopy(model).update_parameters(min_result.parameters),
+        best_pars=min_result.parameters,
+        loss=min_result.residual,
+    )
 
 
 def time_course_over_protocol(
     model: Model,
+    *,
     p0: dict[str, float],
     data: pd.DataFrame,
     protocol: pd.DataFrame,
     y0: dict[str, float] | None = None,
     minimize_fn: MinimizeFn = _default_minimize_fn,
     residual_fn: ProtocolResidualFn = _protocol_residual,
-    integrator: IntegratorType = DefaultIntegrator,
+    integrator: IntegratorType | None = None,
     loss_fn: LossFn = rmse,
     time_points_per_step: int = 10,
-) -> dict[str, float]:
+) -> FitResult | None:
     """Fit model parameters to time course of experimental data.
 
     Examples:
@@ -447,6 +511,188 @@ def time_course_over_protocol(
             time_points_per_step=time_points_per_step,
         ),
     )
-    res = minimize_fn(fn, p0)
+
+    min_result = minimize_fn(fn, p0)
+    # Restore original model
     model.update_parameters(p_orig)
-    return res
+    if min_result is None:
+        return min_result
+
+    return FitResult(
+        model=deepcopy(model).update_parameters(min_result.parameters),
+        best_pars=min_result.parameters,
+        loss=min_result.residual,
+    )
+
+
+def _carousel_steady_state_worker(
+    model: Model,
+    p0: dict[str, float],
+    data: pd.Series,
+    y0: dict[str, float] | None,
+    integrator: IntegratorType | None,
+    loss_fn: LossFn,
+    minimize_fn: MinimizeFn,
+    residual_fn: SteadyStateResidualFn,
+) -> FitResult | None:
+    model_pars = model.parameters
+
+    return steady_state(
+        model,
+        p0={k: v for k, v in p0.items() if k in model_pars},
+        y0=y0,
+        data=data,
+        minimize_fn=minimize_fn,
+        residual_fn=residual_fn,
+        integrator=integrator,
+        loss_fn=loss_fn,
+    )
+
+
+def _carousel_time_course_worker(
+    model: Model,
+    p0: dict[str, float],
+    data: pd.DataFrame,
+    y0: dict[str, float] | None,
+    integrator: IntegratorType | None,
+    loss_fn: LossFn,
+    minimize_fn: MinimizeFn,
+    residual_fn: TimeSeriesResidualFn,
+) -> FitResult | None:
+    model_pars = model.parameters
+    return time_course(
+        model,
+        p0={k: v for k, v in p0.items() if k in model_pars},
+        y0=y0,
+        data=data,
+        minimize_fn=minimize_fn,
+        residual_fn=residual_fn,
+        integrator=integrator,
+        loss_fn=loss_fn,
+    )
+
+
+def _carousel_protocol_worker(
+    model: Model,
+    p0: dict[str, float],
+    data: pd.DataFrame,
+    protocol: pd.DataFrame,
+    y0: dict[str, float] | None,
+    integrator: IntegratorType | None,
+    loss_fn: LossFn,
+    minimize_fn: MinimizeFn,
+    residual_fn: ProtocolResidualFn,
+) -> FitResult | None:
+    model_pars = model.parameters
+    return time_course_over_protocol(
+        model,
+        p0={k: v for k, v in p0.items() if k in model_pars},
+        y0=y0,
+        protocol=protocol,
+        data=data,
+        minimize_fn=minimize_fn,
+        residual_fn=residual_fn,
+        integrator=integrator,
+        loss_fn=loss_fn,
+    )
+
+
+def carousel_steady_state(
+    carousel: Carousel,
+    *,
+    p0: dict[str, float],
+    data: pd.Series,
+    y0: dict[str, float] | None = None,
+    minimize_fn: MinimizeFn = _default_minimize_fn,
+    residual_fn: SteadyStateResidualFn = _steady_state_residual,
+    integrator: IntegratorType | None = None,
+    loss_fn: LossFn = rmse,
+) -> CarouselFit:
+    """Fit model parameters to steady-state experimental data over a carousel."""
+    return CarouselFit(
+        [
+            fit
+            for i in parallel.parallelise(
+                partial(
+                    _carousel_steady_state_worker,
+                    p0=p0,
+                    data=data,
+                    y0=y0,
+                    integrator=integrator,
+                    loss_fn=loss_fn,
+                    minimize_fn=minimize_fn,
+                    residual_fn=residual_fn,
+                ),
+                inputs=list(enumerate(carousel.variants)),
+            )
+            if (fit := i[1]) is not None
+        ]
+    )
+
+
+def carousel_time_course(
+    carousel: Carousel,
+    *,
+    p0: dict[str, float],
+    data: pd.DataFrame,
+    y0: dict[str, float] | None = None,
+    minimize_fn: MinimizeFn = _default_minimize_fn,
+    residual_fn: TimeSeriesResidualFn = _time_course_residual,
+    integrator: IntegratorType | None = None,
+    loss_fn: LossFn = rmse,
+) -> CarouselFit:
+    """Fit model parameters to time course of experimental data over a carousel."""
+    return CarouselFit(
+        [
+            fit
+            for i in parallel.parallelise(
+                partial(
+                    _carousel_time_course_worker,
+                    p0=p0,
+                    data=data,
+                    y0=y0,
+                    integrator=integrator,
+                    loss_fn=loss_fn,
+                    minimize_fn=minimize_fn,
+                    residual_fn=residual_fn,
+                ),
+                inputs=list(enumerate(carousel.variants)),
+            )
+            if (fit := i[1]) is not None
+        ]
+    )
+
+
+def carousel_time_course_over_protocol(
+    carousel: Carousel,
+    *,
+    p0: dict[str, float],
+    data: pd.DataFrame,
+    protocol: pd.DataFrame,
+    y0: dict[str, float] | None = None,
+    minimize_fn: MinimizeFn = _default_minimize_fn,
+    residual_fn: ProtocolResidualFn = _protocol_residual,
+    integrator: IntegratorType | None = None,
+    loss_fn: LossFn = rmse,
+) -> CarouselFit:
+    """Fit model parameters to time course of experimental data over a protocol."""
+    return CarouselFit(
+        [
+            fit
+            for i in parallel.parallelise(
+                partial(
+                    _carousel_protocol_worker,
+                    p0=p0,
+                    data=data,
+                    protocol=protocol,
+                    y0=y0,
+                    integrator=integrator,
+                    loss_fn=loss_fn,
+                    minimize_fn=minimize_fn,
+                    residual_fn=residual_fn,
+                ),
+                inputs=list(enumerate(carousel.variants)),
+            )
+            if (fit := i[1]) is not None
+        ]
+    )

mxlpy/identify.py

@@ -28,16 +28,15 @@ def _mc_fit_time_course_worker(
     data: pd.DataFrame,
     loss_fn: fit.LossFn,
 ) -> float:
-    p_fit = fit.time_course(model=model, p0=p0.to_dict(), data=data)
-    return fit._time_course_residual(  # noqa: SLF001
-        par_values=list(p_fit.values()),
-        par_names=list(p_fit.keys()),
-        data=data,
+    fit_result = fit.time_course(
         model=model,
-        y0=None,
-        integrator=fit.DefaultIntegrator,
+        p0=p0.to_dict(),
+        data=data,
         loss_fn=loss_fn,
     )
+    if fit_result is None:
+        return np.inf
+    return fit_result.loss
 
 
 def profile_likelihood(

mxlpy/mc.py

@@ -22,7 +22,6 @@ from typing import TYPE_CHECKING, Protocol, cast
 import pandas as pd
 
 from mxlpy import mca, scan
-from mxlpy.integrators import DefaultIntegrator
 from mxlpy.parallel import Cache, parallelise
 from mxlpy.scan import (
     ProtocolWorker,
@@ -122,7 +121,7 @@ def steady_state(
     cache: Cache | None = None,
     rel_norm: bool = False,
     worker: SteadyStateWorker = _steady_state_worker,
-    integrator: IntegratorType = DefaultIntegrator,
+    integrator: IntegratorType | None = None,
 ) -> SteadyStates:
     """Monte-carlo scan of steady states.
 
@@ -153,6 +152,7 @@ def steady_state(
                 worker,
                 rel_norm=rel_norm,
                 integrator=integrator,
+                y0=None,
             ),
             model=model,
         ),
@@ -161,8 +161,8 @@ def steady_state(
         cache=cache,
     )
     return SteadyStates(
-        variables=pd.concat({k: v.variables for k, v in res.items()}, axis=1).T,
-        fluxes=pd.concat({k: v.fluxes for k, v in res.items()}, axis=1).T,
+        variables=pd.concat({k: v.variables for k, v in res}, axis=1).T,
+        fluxes=pd.concat({k: v.fluxes for k, v in res}, axis=1).T,
         parameters=mc_to_scan,
     )
 
@@ -176,7 +176,7 @@ def time_course(
     max_workers: int | None = None,
     cache: Cache | None = None,
     worker: TimeCourseWorker = _time_course_worker,
-    integrator: IntegratorType = DefaultIntegrator,
+    integrator: IntegratorType | None = None,
 ) -> TimeCourseByPars:
     """MC time course.
 
@@ -207,6 +207,7 @@ def time_course(
                 worker,
                 time_points=time_points,
                 integrator=integrator,
+                y0=None,
             ),
             model=model,
         ),
@@ -217,8 +218,8 @@ def time_course(
 
     return TimeCourseByPars(
         parameters=mc_to_scan,
-        variables=pd.concat({k: v.variables.T for k, v in res.items()}, axis=1).T,
-        fluxes=pd.concat({k: v.fluxes.T for k, v in res.items()}, axis=1).T,
+        variables=pd.concat({k: v.variables.T for k, v in res}, axis=1).T,
+        fluxes=pd.concat({k: v.fluxes.T for k, v in res}, axis=1).T,
     )
 
 
@@ -232,7 +233,7 @@ def time_course_over_protocol(
     max_workers: int | None = None,
     cache: Cache | None = None,
     worker: ProtocolWorker = _protocol_worker,
-    integrator: IntegratorType = DefaultIntegrator,
+    integrator: IntegratorType | None = None,
 ) -> ProtocolByPars:
     """MC time course.
 
@@ -264,6 +265,7 @@ def time_course_over_protocol(
                 worker,
                 protocol=protocol,
                 integrator=integrator,
+                y0=None,
                 time_points_per_step=time_points_per_step,
             ),
             model=model,
@@ -272,8 +274,8 @@ def time_course_over_protocol(
         max_workers=max_workers,
         cache=cache,
     )
-    concs = {k: v.variables.T for k, v in res.items()}
-    fluxes = {k: v.fluxes.T for k, v in res.items()}
+    concs = {k: v.variables.T for k, v in res}
+    fluxes = {k: v.fluxes.T for k, v in res}
     return ProtocolByPars(
         variables=pd.concat(concs, axis=1).T,
         fluxes=pd.concat(fluxes, axis=1).T,
@@ -292,7 +294,7 @@ def scan_steady_state(
     cache: Cache | None = None,
     rel_norm: bool = False,
     worker: ParameterScanWorker = _parameter_scan_worker,
-    integrator: IntegratorType = DefaultIntegrator,
+    integrator: IntegratorType | None = None,
 ) -> McSteadyStates:
     """Parameter scan of mc distributed steady states.
 
@@ -339,6 +341,7 @@ def scan_steady_state(
                 parameters=to_scan,
                 rel_norm=rel_norm,
                 integrator=integrator,
+                y0=None,
             ),
             model=model,
         ),
@@ -346,8 +349,8 @@ def scan_steady_state(
         cache=cache,
         max_workers=max_workers,
     )
-    concs = {k: v.variables.T for k, v in res.items()}
-    fluxes = {k: v.fluxes.T for k, v in res.items()}
+    concs = {k: v.variables.T for k, v in res}
+    fluxes = {k: v.fluxes.T for k, v in res}
     return McSteadyStates(
         variables=pd.concat(concs, axis=1).T,
         fluxes=pd.concat(fluxes, axis=1).T,
@@ -422,7 +425,7 @@ def variable_elasticities(
         cache=cache,
         max_workers=max_workers,
     )
-    return cast(pd.DataFrame, pd.concat(res))
+    return cast(pd.DataFrame, pd.concat(dict(res)))
 
 
 def parameter_elasticities(
@@ -486,7 +489,7 @@ def parameter_elasticities(
         cache=cache,
         max_workers=max_workers,
     )
-    return cast(pd.DataFrame, pd.concat(res))
+    return cast(pd.DataFrame, pd.concat(dict(res)))
 
 
 def response_coefficients(
@@ -501,7 +504,7 @@ def response_coefficients(
     disable_tqdm: bool = False,
     max_workers: int | None = None,
     rel_norm: bool = False,
-    integrator: IntegratorType = DefaultIntegrator,
+    integrator: IntegratorType | None = None,
 ) -> ResponseCoefficientsByPars:
     """Calculate response coefficients using Monte Carlo analysis.
 
@@ -558,9 +561,7 @@ def response_coefficients(
     )
 
     return ResponseCoefficientsByPars(
-        variables=cast(
-            pd.DataFrame, pd.concat({k: v.variables for k, v in res.items()})
-        ),
-        fluxes=cast(pd.DataFrame, pd.concat({k: v.fluxes for k, v in res.items()})),
+        variables=cast(pd.DataFrame, pd.concat({k: v.variables for k, v in res})),
+        fluxes=cast(pd.DataFrame, pd.concat({k: v.fluxes for k, v in res})),
         parameters=mc_to_scan,
     )

mxlpy/mca.py

@@ -22,7 +22,6 @@ from typing import TYPE_CHECKING
 
 import pandas as pd
 
-from mxlpy.integrators import DefaultIntegrator
 from mxlpy.parallel import parallelise
 from mxlpy.scan import _steady_state_worker
 from mxlpy.types import ResponseCoefficients
@@ -46,7 +45,7 @@ def _response_coefficient_worker(
     normalized: bool,
     rel_norm: bool,
     displacement: float = 1e-4,
-    integrator: IntegratorType,
+    integrator: IntegratorType | None,
 ) -> tuple[pd.Series, pd.Series]:
     """Calculate response coefficients for a single parameter.
 
@@ -81,6 +80,7 @@ def _response_coefficient_worker(
         model,
         rel_norm=rel_norm,
         integrator=integrator,
+        y0=None,
     )
 
     model.update_parameters({parameter: old * (1 - displacement)})
@@ -88,6 +88,7 @@ def _response_coefficient_worker(
         model,
         rel_norm=rel_norm,
         integrator=integrator,
+        y0=None,
     )
 
     conc_resp = (upper.variables - lower.variables) / (2 * displacement * old)
@@ -99,6 +100,7 @@ def _response_coefficient_worker(
             model,
             rel_norm=rel_norm,
             integrator=integrator,
+            y0=None,
         )
         conc_resp *= old / norm.variables
         flux_resp *= old / norm.fluxes
@@ -237,7 +239,7 @@ def response_coefficients(
     parallel: bool = True,
     max_workers: int | None = None,
     rel_norm: bool = False,
-    integrator: IntegratorType = DefaultIntegrator,
+    integrator: IntegratorType | None = None,
 ) -> ResponseCoefficients:
     """Calculate response coefficients.
 
@@ -284,6 +286,6 @@ def response_coefficients(
         max_workers=max_workers,
     )
     return ResponseCoefficients(
-        variables=pd.DataFrame({k: v[0] for k, v in res.items()}),
-        fluxes=pd.DataFrame({k: v[1] for k, v in res.items()}),
+        variables=pd.DataFrame({k: v[0] for k, v in res}),
+        fluxes=pd.DataFrame({k: v[1] for k, v in res}),
     )

mxlpy/parallel.py

@@ -103,7 +103,7 @@ def parallelise[K: Hashable, Tin, Tout](
     timeout: float | None = None,
     disable_tqdm: bool = False,
     tqdm_desc: str | None = None,
-) -> dict[Tin, Tout]:
+) -> list[tuple[K, Tout]]:
     """Execute a function in parallel over a collection of inputs.
 
     Examples:
@@ -136,9 +136,9 @@ def parallelise[K: Hashable, Tin, Tout](
         cache=cache,
     )  # type: ignore
 
-    results: dict[Tin, Tout]
+    results: list[tuple[K, Tout]]
     if parallel:
-        results = {}
+        results = []
         max_workers = (
             multiprocessing.cpu_count() if max_workers is None else max_workers
         )
@@ -157,18 +157,19 @@ def parallelise[K: Hashable, Tin, Tout](
                 try:
                     key, value = next(it)
                     pbar.update(1)
-                    results[key] = value
+                    results.append((key, value))
                 except StopIteration:
                     break
                 except TimeoutError:
                     pbar.update(1)
     else:
-        results = dict(
+        results = list(
             tqdm(
                 map(worker, inputs),  # type: ignore
                 total=len(inputs),
                 disable=disable_tqdm,
                 desc=tqdm_desc,
-            )  # type: ignore
+            )
         )  # type: ignore
+
     return results

mxlpy/scan.py

@@ -22,7 +22,6 @@ from typing import TYPE_CHECKING, Protocol, Self, cast
 import numpy as np
 import pandas as pd
 
-from mxlpy.integrators import DefaultIntegrator
 from mxlpy.parallel import Cache, parallelise
 from mxlpy.simulator import Result, Simulator
 from mxlpy.types import IntegratorType, ProtocolByPars, SteadyStates, TimeCourseByPars
@@ -281,7 +280,8 @@ class SteadyStateWorker(Protocol):
         model: Model,
         *,
         rel_norm: bool,
-        integrator: IntegratorType,
+        integrator: IntegratorType | None,
+        y0: dict[str, float] | None,
     ) -> TimePoint:
         """Call the worker function."""
         ...
@@ -295,7 +295,8 @@ class TimeCourseWorker(Protocol):
         model: Model,
         time_points: Array,
         *,
-        integrator: IntegratorType,
+        integrator: IntegratorType | None,
+        y0: dict[str, float] | None,
     ) -> TimeCourse:
         """Call the worker function."""
         ...
@@ -309,7 +310,8 @@ class ProtocolWorker(Protocol):
         model: Model,
         protocol: pd.DataFrame,
         *,
-        integrator: IntegratorType,
+        integrator: IntegratorType | None,
+        y0: dict[str, float] | None,
         time_points_per_step: int = 10,
     ) -> TimeCourse:
         """Call the worker function."""
@@ -320,7 +322,8 @@ def _steady_state_worker(
     model: Model,
     *,
     rel_norm: bool,
-    integrator: IntegratorType,
+    integrator: IntegratorType | None,
+    y0: dict[str, float] | None,
 ) -> TimePoint:
     """Simulate the model to steady state and return concentrations and fluxes.
 
@@ -336,7 +339,7 @@ def _steady_state_worker(
     """
     try:
         res = (
-            Simulator(model, integrator=integrator)
+            Simulator(model, integrator=integrator, y0=y0)
             .simulate_to_steady_state(rel_norm=rel_norm)
             .get_result()
         )
@@ -348,7 +351,8 @@ def _steady_state_worker(
 def _time_course_worker(
     model: Model,
     time_points: Array,
-    integrator: IntegratorType,
+    y0: dict[str, float] | None,
+    integrator: IntegratorType | None,
 ) -> TimeCourse:
     """Simulate the model to steady state and return concentrations and fluxes.
 
@@ -364,7 +368,7 @@ def _time_course_worker(
     """
     try:
         res = (
-            Simulator(model, integrator=integrator)
+            Simulator(model, integrator=integrator, y0=y0)
             .simulate_time_course(time_points=time_points)
             .get_result()
         )
@@ -381,7 +385,8 @@ def _protocol_worker(
     model: Model,
     protocol: pd.DataFrame,
     *,
-    integrator: IntegratorType = DefaultIntegrator,
+    integrator: IntegratorType | None,
+    y0: dict[str, float] | None,
     time_points_per_step: int = 10,
 ) -> TimeCourse:
     """Simulate the model over a protocol and return concentrations and fluxes.
@@ -399,7 +404,7 @@ def _protocol_worker(
     """
     try:
         res = (
-            Simulator(model, integrator=integrator)
+            Simulator(model, integrator=integrator, y0=y0)
             .simulate_over_protocol(
                 protocol=protocol,
                 time_points_per_step=time_points_per_step,
@@ -430,7 +435,7 @@ def steady_state(
     rel_norm: bool = False,
     cache: Cache | None = None,
     worker: SteadyStateWorker = _steady_state_worker,
-    integrator: IntegratorType = DefaultIntegrator,
+    integrator: IntegratorType | None = None,
 ) -> SteadyStates:
     """Get steady-state results over supplied values.
 
@@ -479,6 +484,7 @@ def steady_state(
                 worker,
                 rel_norm=rel_norm,
                 integrator=integrator,
+                y0=None,
             ),
             model=model,
         ),
@@ -486,8 +492,8 @@ def steady_state(
         cache=cache,
         parallel=parallel,
     )
-    concs = pd.DataFrame({k: v.variables.T for k, v in res.items()}).T
-    fluxes = pd.DataFrame({k: v.fluxes.T for k, v in res.items()}).T
+    concs = pd.DataFrame({k: v.variables.T for k, v in res}).T
+    fluxes = pd.DataFrame({k: v.fluxes.T for k, v in res}).T
     idx = (
         pd.Index(to_scan.iloc[:, 0])
         if to_scan.shape[1] == 1
@@ -506,8 +512,8 @@ def time_course(
     y0: dict[str, float] | None = None,
     parallel: bool = True,
     cache: Cache | None = None,
+    integrator: IntegratorType | None = None,
     worker: TimeCourseWorker = _time_course_worker,
-    integrator: IntegratorType = DefaultIntegrator,
 ) -> TimeCourseByPars:
     """Get time course for each supplied parameter.
 
@@ -559,6 +565,8 @@ def time_course(
 
 
     """
+    # We update the initial conditions separately here, because `to_scan` might also
+    # contain initial conditions.
     if y0 is not None:
         model.update_variables(y0)
 
@@ -569,6 +577,7 @@ def time_course(
                 worker,
                 time_points=time_points,
                 integrator=integrator,
+                y0=None,  # See comment above
             ),
             model=model,
         ),
@@ -576,8 +585,8 @@ def time_course(
         cache=cache,
         parallel=parallel,
     )
-    concs = cast(dict, {k: v.variables for k, v in res.items()})
-    fluxes = cast(dict, {k: v.fluxes for k, v in res.items()})
+    concs = cast(dict, {k: v.variables for k, v in res})
+    fluxes = cast(dict, {k: v.fluxes for k, v in res})
     return TimeCourseByPars(
         parameters=to_scan,
         variables=pd.concat(concs, names=["n", "time"]),
@@ -595,7 +604,7 @@ def time_course_over_protocol(
     parallel: bool = True,
     cache: Cache | None = None,
     worker: ProtocolWorker = _protocol_worker,
-    integrator: IntegratorType = DefaultIntegrator,
+    integrator: IntegratorType | None = None,
 ) -> ProtocolByPars:
     """Get protocol series for each supplied parameter.
 
@@ -626,6 +635,8 @@ def time_course_over_protocol(
         TimeCourseByPars: Protocol series results for each parameter set.
 
     """
+    # We update the initial conditions separately here, because `to_scan` might also
+    # contain initial conditions.
     if y0 is not None:
         model.update_variables(y0)
 
@@ -637,6 +648,7 @@ def time_course_over_protocol(
                 protocol=protocol,
                 time_points_per_step=time_points_per_step,
                 integrator=integrator,
+                y0=None,
             ),
             model=model,
         ),
@@ -644,8 +656,8 @@ def time_course_over_protocol(
         cache=cache,
         parallel=parallel,
     )
-    concs = cast(dict, {k: v.variables for k, v in res.items()})
-    fluxes = cast(dict, {k: v.fluxes for k, v in res.items()})
+    concs = cast(dict, {k: v.variables for k, v in res})
+    fluxes = cast(dict, {k: v.fluxes for k, v in res})
     return ProtocolByPars(
         parameters=to_scan,
         protocol=protocol,

mxlpy/simulator.py

@@ -335,7 +335,7 @@ class Simulator:
         self,
         model: Model,
         y0: dict[str, float] | None = None,
-        integrator: IntegratorType = DefaultIntegrator,
+        integrator: IntegratorType | None = None,
         *,
         use_jacobian: bool = False,
         test_run: bool = True,
@@ -354,7 +354,7 @@ class Simulator:
         self.model = model
         self.y0 = model.get_initial_conditions() if y0 is None else y0
 
-        self._integrator_type = integrator
+        self._integrator_type = DefaultIntegrator if integrator is None else integrator
         self._time_shift = None
         self.variables = None
         self.dependent = None

{mxlpy-0.20.0.dist-info → mxlpy-0.21.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mxlpy
-Version: 0.20.0
+Version: 0.21.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>
@@ -69,6 +69,8 @@ Description-Content-Type: text/markdown
 [docs-badge]: https://img.shields.io/badge/docs-main-green.svg?style=flat-square
 [docs]: https://computational-biology-aachen.github.io/mxlpy/
 
+MxlPy (pronounced "em axe el pie") is a Python package for mechanistic learning (Mxl) - the combination of mechanistic modeling and machine learning to deliver explainable, data-informed solutions.
+
 ## Installation
 
 You can install mxlpy using pip: `pip install mxlpy`.

{mxlpy-0.20.0.dist-info → mxlpy-0.21.0.dist-info}/RECORD

@@ -1,22 +1,23 @@
 mxlpy/__init__.py,sha256=4pbDeyLhQjfL76h2oXdodARzKkrkX5wESV7kEjwC3K8,4399
+mxlpy/carousel.py,sha256=o72YKzfPCDhT5oHhow4oNvIShG-i3-Z0UMEQLt2iE5A,4699
 mxlpy/compare.py,sha256=6iIl6yKXP9guSVLgqqnaqILP_BF_oqyx7DTGbdpwAjM,7800
 mxlpy/distributions.py,sha256=ce6RTqn19YzMMec-u09fSIUA8A92M6rehCuHuXWcX7A,8734
-mxlpy/fit.py,sha256=i1R_2WErNJdHNf6JWPFPBDfbI7-MkY9fTaO6jgL4Pqk,12433
+mxlpy/fit.py,sha256=vJGd_kl-MqyI7db96uM9STeBnvPVu1VGLCiGuH8mEKc,19009
 mxlpy/fns.py,sha256=NLxYwa3ylS7SkISBjw_TgQSKEm7WnkZF9wPigX_ZCAM,13915
-mxlpy/identify.py,sha256=I136kpczw_WriN-CtTMP3cBN-K4ZKaHW6lWZCWsIQUE,2233
+mxlpy/identify.py,sha256=yU6ccd0yDJhtyo5gkemMuecZALzjR1KzT0vKPmlL4kg,2107
 mxlpy/label_map.py,sha256=Zla9tey-7_POTE57XNEuCSeTqdAbMWZdj_j_OwokngY,17823
 mxlpy/linear_label_map.py,sha256=5FyD0MMdSGsC3eKeBnpd1LBHyVBqIDWCDjgR8_q6XZo,10289
-mxlpy/mc.py,sha256=6uN2fw4W627FoK_yVNIWbphoPa-pBA7-51nIX81CilU,17200
-mxlpy/mca.py,sha256=PloMdBtyoPsiyJT-vnB0RUc1aTFkoMYwvYa7WmKA7tY,9359
+mxlpy/mc.py,sha256=bt2DrMaovWO_LM3PfkVr0cvK6k_ZSjLRnudasgC5SRM,17132
+mxlpy/mca.py,sha256=B1bRb_EHim3uJ90KJkTZ5HXrVOBjrctcRCsQG4PXU-U,9351
 mxlpy/model.py,sha256=14gncyYft39rwoiJPb5AynL3whXnZrJY3N7SLExH0Qk,62056
-mxlpy/parallel.py,sha256=a69Ci7NrCplo4pq7qFQUMtOPD56SfaZ6Vz3JNplJpZ0,5013
+mxlpy/parallel.py,sha256=yLQLw5O4vnPVp_Zmtw1UhPWtB3483foimxQB-TwFKPg,5016
 mxlpy/parameterise.py,sha256=IgbvfEnkmaqVq_5GgFjHqApGUN9CJrsVD3Fr7pg9iFA,758
 mxlpy/paths.py,sha256=TK2wO4N9lG-UV1JGfeB64q48JVDbwqIUj63rl55MKuQ,1022
 mxlpy/plot.py,sha256=PA7tAmy2XXACxBLtdnfpxKUFRzi-lnCQjr7gw_nzxKU,32544
 mxlpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mxlpy/report.py,sha256=6V_kH5usFtar2lUGLjG5k7WIJjUi1TD5qIO7V_6V3Gc,8773
-mxlpy/scan.py,sha256=AnDSR-ttOjFGBrvOdhMdM04URZSHVoiS049tK0oUwV8,18948
-mxlpy/simulator.py,sha256=fXFRJHXvDzhZHIccxH6l5QJEZUcpYrNCeA9DUkvnN-8,21052
+mxlpy/scan.py,sha256=_MwwTiL-IQPlUU9e2L1Wc-V95sElcaPw-DkxoXYanzc,19421
+mxlpy/simulator.py,sha256=tdxTUbsWo3SdYi7a1lsMah9D_Dz_FqnMjTfK-3oT2Gk,21091
 mxlpy/types.py,sha256=FXBkwHgQ3v_k4ER49hDqyFMIA6i1BQf8isPma97LJdg,12605
 mxlpy/experimental/__init__.py,sha256=kZTE-92OErpHzNRqmgSQYH4CGXrogGJ5EL35XGZQ81M,206
 mxlpy/experimental/diff.py,sha256=MoM15rbMAHa7p9Zva8NxIc7K585kHJYKFaD1LnN5e10,9088
@@ -49,7 +50,7 @@ mxlpy/surrogates/_torch.py,sha256=gU0secuRBYgewhNqZmSo6_Xf804dSzwWwIYmdKA7y60,63
 mxlpy/symbolic/__init__.py,sha256=_vM5YM5I6OH0QDbFt9uGYKO8Z5Vly0wbGuvUScVrPRU,258
 mxlpy/symbolic/strikepy.py,sha256=tzo3uvPpXLDex09hWTuitVzuTNwbgl7jWGjD8g6a8iI,20033
 mxlpy/symbolic/symbolic_model.py,sha256=JFzcIdyfJihvKjef748DMXU6WI8nHjgjIk5BwUuB4HQ,2543
-mxlpy-0.20.0.dist-info/METADATA,sha256=oZ5kyCjoeUm28YKPxNSf0kTZx977NA3-3BfEd6riQSI,4402
-mxlpy-0.20.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mxlpy-0.20.0.dist-info/licenses/LICENSE,sha256=lHX9Eu70g3Iv1aOxXTWNHa3vq9vaVYSPQx4jOLYmDpw,1096
-mxlpy-0.20.0.dist-info/RECORD,,
+mxlpy-0.21.0.dist-info/METADATA,sha256=ZKxvZTNcrNCaadkRmKSU_6bQlSsJdTtuz_idNVEVbVs,4601
+mxlpy-0.21.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mxlpy-0.21.0.dist-info/licenses/LICENSE,sha256=lHX9Eu70g3Iv1aOxXTWNHa3vq9vaVYSPQx4jOLYmDpw,1096
+mxlpy-0.21.0.dist-info/RECORD,,