working on parallel plots

src/sbmlsim/examples/experiments/midazolam/experiments/__init__.py

@@ -4,7 +4,7 @@
 from sbmlsim.experiment import SimulationExperiment, ExperimentDict
 from sbmlsim.model import AbstractModel
 from sbmlsim.simulation import TimecourseSim
-from sbmlsim.simulation.sensititvity import ModelSensitivity
+from sbmlsim.simulation.sensitivity import ModelSensitivity
 from sbmlsim.task import Task
 
 from ...midazolam import MODEL_PATH

src/sbmlsim/examples/experiments/midazolam/fitting_example.py

@@ -0,0 +1,57 @@
+from typing import Callable
+
+from sbmlsim.examples.experiments.midazolam import MIDAZOLAM_PATH
+from sbmlsim.examples.experiments.midazolam.fitting_problems import (
+    op_kupferschmidt1995,
+    op_mandema1992,
+    op_mid1oh_iv,
+)
+from sbmlsim.fit.optimization import OptimizationProblem
+from sbmlsim.fit.options import (
+    FittingStrategyType,
+    OptimizationAlgorithmType,
+    ResidualType,
+    WeightingPointsType,
+)
+from sbmlsim.fit.result import OptimizationResult
+
+from sbmlsim.fit.runner import run_optimization
+from sbmlsim.fit.analysis import OptimizationAnalysis
+
+
+def fitting_example(op_factory: Callable, size: int = 10, n_cores: int = 10) -> None:
+    """Demonstrate fitting functionality."""
+
+    fit_kwargs = {
+        "seed": 1234,
+        "fitting_strategy": FittingStrategyType.ABSOLUTE_VALUES,
+        "residual_type": ResidualType.ABSOLUTE_NORMED_RESIDUALS,
+        "weighting_points": WeightingPointsType.ABSOLUTE_ONE_OVER_WEIGHTING,
+        "absolute_tolerance": 1e-6,
+        "relative_tolerance": 1e-6,
+    }
+
+    for alg_key, algorithm in [
+        ("lsq", OptimizationAlgorithmType.LEAST_SQUARE),
+        ("de", OptimizationAlgorithmType.DIFFERENTIAL_EVOLUTION),
+    ]:
+
+        op: OptimizationProblem = op_factory()
+        fit_path = MIDAZOLAM_PATH / "results_fit" / op.opid / alg_key
+        if not fit_path.exists():
+            fit_path.mkdir(parents=True)
+
+        opt_result: OptimizationResult = run_optimization(
+            problem=op,
+            algorithm=algorithm,
+            size=size,
+            n_cores=n_cores,
+            **fit_kwargs
+        )
+
+        # OptimizationAnalysis(opt_result=opt_result, op=op)
+
+
+if __name__ == "__main__":
+    for op_factory in [op_mandema1992, op_kupferschmidt1995, op_mid1oh_iv]:
+        fitting_example(op_factory=op_factory)

src/sbmlsim/fit/__init__.py

@@ -3,4 +3,6 @@
 For additional resources see for instance
 https://pyabc.readthedocs.io/en/latest/index.html
 """
+
 from .objects import FitMapping, FitData, FitExperiment, FitParameter
+

src/sbmlsim/fit/objects.py

@@ -8,7 +8,7 @@
 import numpy as np
 
 from sbmlsim.data import Data
-from sbmlsim.serialization import ObjectJSONEncoder
+from sbmlsim.serialization import ObjectJSONEncoder, to_json
 
 
 logger = logging.getLogger(__name__)

src/sbmlsim/fit/optimization.py

@@ -8,11 +8,11 @@
 import pandas as pd
 
 from pathlib import Path
-from typing import Collection, Dict, Iterable, List, Set, Sized, Tuple, Callable, Union, \
-    Optional
+from typing import Collection, List, Set, Tuple, Callable, Union, Optional
 
 import numpy as np
 import scipy
+from scipy import interpolate
 
 from sbmlsim.data import Data
 from sbmlsim.experiment import ExperimentRunner
@@ -87,6 +87,11 @@ def __init__(
         self.base_path = base_path
         self.data_path = data_path
 
+        # set in initialization
+        self.fitting_strategy: Optional[FittingStrategyType] = None
+        self.weighting_points: Optional[WeightingPointsType] = None
+        self.residual_type: Optional[ResidualType] = None
+
     def __repr__(self) -> str:
         """Get representation."""
         return f"<OptimizationProblem: {self.opid}>"
@@ -495,26 +500,16 @@ def optimize(
         self,
         size: Optional[int] = 5,
         algorithm: OptimizationAlgorithmType = OptimizationAlgorithmType.LEAST_SQUARE,
-        fitting_strategy: FittingStrategyType = FittingStrategyType.ABSOLUTE_VALUES,
-        weighting_points: WeightingPointsType = WeightingPointsType.NO_WEIGHTING,
-        residual_type: ResidualType = ResidualType.ABSOLUTE_RESIDUALS,
         sampling: SamplingType = SamplingType.UNIFORM,
         seed: Optional[int] = None,
-        variable_step_size=True,
-        relative_tolerance=1e-6,
-        absolute_tolerance=1e-8,
         **kwargs,
     ) -> Tuple[List[scipy.optimize.OptimizeResult], List]:
-        """Run parameter optimization."""
-
-        # additional settings for optimization
-        self.fitting_strategy = fitting_strategy
-        self.weighting_points = weighting_points
-        self.residual_type = residual_type
-        self.variable_step_size = variable_step_size
-        self.relative_tolerance = relative_tolerance
-        self.absolute_tolerance = absolute_tolerance
+        """Run parameter optimization.
 
+        To change the weighting or handling of residuals reinitialize the optimization
+        algorithm.
+        """
+        # create samples
         x_samples: pd.DataFrame
         if algorithm == OptimizationAlgorithmType.LEAST_SQUARE:
             # initial value samples for local optimizer
@@ -670,7 +665,7 @@ def residuals(self, xlog: np.ndarray, complete_data=False):
                 df = simulator._timecourses([simulation])[0]
 
                 # interpolation of simulation results
-                f = scipy.interpolate.interp1d(
+                f = interpolate.interp1d(
                     x=df[self.xid_observable[k]],
                     y=df[self.yid_observable[k]],
                     copy=False,
@@ -731,6 +726,3 @@ def residuals(self, xlog: np.ndarray, complete_data=False):
             # FIXME
             self._trajectory.append((deepcopy(x), 0.5 * np.sum(np.power(res_all, 2))))
             return res_all
-
-
-