LinearModelPredictor

Author: joseph-hellerstein

docs/model_based_design.md

@@ -16,49 +16,58 @@ This class contains properties of the static model, those properties derived fro
 Included are the properties:
 
 * ``model_name``
-* ``sbml_str`` is an SBML string for the model
+* ``sbml_str`` is an SBML string for the model. Antimony models are converted to SBML using roadrunner.
 * Various static properties, such as ``species_names``, ``num_species``
 
+StaticModel uses roadrunner transiently to query the underlying model (e.g., names of floating species).
+
 ### ``DynamicModel``
 
 This class is a container for properties obtained running a simulation.
 
 The constructor has arguments for: static model, and the following:
 
-* ``start_time``, ``end_time`, ``num_point``
 * ``jacobian_collection_arr`` the Jacobians at each of the timepoints
 * ``timepoint_arr`` is the times at which simulation results are reported
-* ``forced_input_collection_arr`` an array of arrays of forced inputs calculated at each timepoint
+* ``forcing_input_collection_arr`` an array of arrays of forced inputs calculated at each timepoint
 * ``timecourse_df`` is the timecourse for the dynamics
 
 The following are properties calculated from the properties above:
 
 * ``jacobian_median_arr`` is the median of the values in ``jacobian_collection_arr``, a computed property.
 * ``jacobian_std_arr`` is the standard deviation of Jacobian values, a computed property.
+* ``start_time``, ``end_time``, ``num_point``
 
 The following are external methods:
 
-* ``makeSubmodel(start_time, end_time)`` uses a subset of the dynamical data (as specified by start and end) to construct a new dynamical model that copies of subset of the data in the current model into the new model.
-* ``makeModel(start_time, end_time, num_point, StaticModel)`` runs simulations to collect
+* ``makeSubmodel(start_time, end_time)`` uses a subset of the dynamical data (as specified by start and end) to construct a new dynamical model that copies of subset of the data in the current model into the new model. This method uses slicing to obtain values for constructing a new DynamicModel.
+* ``makeFromSimulation(start_time, end_time, num_point, StaticModel)`` is a class method that runs simulations to obtain the arguments for the DynamicModel constructor. This is the only method in DynamicModel that uses roadrunner. If the model_name begins with "BIOMD", then: (a) the model is in BIOMODELS_DIR and (b) ``end_time`` is obtained from the module ``biomodels_iterator``. ``end_time=None`` triggers autodetect of ``end_time``.
+* ``_makeEndtime`` is a method formerly in LRoadrunner.
 
 ### ``LinearModelPredictor``
 
-This class does linear prediction and evaluations of these predictions. It is constructed with a ``DynamicModel`` and ``num_step``, the number of steps ahead to do the prediction. It has the following methods
+This class does linear prediction and evaluations of these predictions. It is constructed with a ``DynamicModel``, ``jacobian_selection`` and ``num_step``, the number of steps ahead to do the prediction. It has the following methods
 
 * ``predict`` provides predictions for the timecourse of the ``DynamicModel``. 
 * ``score`` scores the prediction using the Score class.
 * ``plotPrediction`` plots the timecourse and the prediction from the ``start_time`` to the ``end_time``
 
 ### ``Score``
+* We will use ``makeScoreInfo`` to construct the various score metrics to evaluate the quality of a prediction.
 
 ### ``MultipleLinearPredictor``
 
-This class performs piece-wise linear prediction. It is constructed wtih a DynamicModel, ``num_step``, and a collection of timepoints a which a new dynamic model is constructed.
+This class performs piece-wise linear prediction. The times at which
+there is a partition of the linear model is a "split point". Using slicing, we can easily construct the DynamicModels for a collection of split points. (Of course, all will have the same StaticModel.) If there are n split points, then there are n + 1 linear models.
+Note that the old Trajectory.sequentialPartition / nonsequentialPartition aren't mentioned beause their implementation is deferred.
+* When splitting a ``DynamicModel``, slicing is used, not simulation.
 
 * ``predict``
 * ``score``
 * ``plotPrediction`` The plot shows predicted and actual (simulated) values with vertical dashed lines to indicate regions for submodels.
 
+
+
 ## To Do
 
 ### Prompts
@@ -67,5 +76,4 @@ This class performs piece-wise linear prediction. It is constructed wtih a Dynam
 1. Review the design and provide comments on where confusions exist as well as where improvements can be made. Do not implement yet.
 1. Implement StaticModel as described in @model_based_design.md and associated tests.
 2. Implement DynamicModel as described in @model_based_design.md and associated tests. 
-3.  
 4. Update the modules in scripts to use ...

notebooks/score_analysis.ipynb

@@ -40,6 +40,6 @@
 NULL_ARRAY = np.array([])
 
 # Jacobian selection
-JAC_FITTED = "fit_gershgorin" # Fit a Jacobian, selecting diagonal elements using Gershgorin circles
+JAC_FITTED = "fit_gershgorin" # Fit a Jacobian by using the timecourse for each row
 JAC_MEDIAN = "median"  # Use the median Jacobian
 JAC_FIRST = "first" # Use the first Jacobian

src/constants.py

@@ -15,18 +15,22 @@ class DataframeSerializer:
     an instance from an existing file.
     """
 
-    def __init__(self, path: str) -> None:
+    def __init__(self, path: str, is_initialize: bool = False) -> None:
         """
         Parameters
         ----------
         path : str
             Path to the CSV serialization file.
+        is_initialize : bool
+            Whether to initialize the CSV file by writing an empty DataFrame with the appropriate columns.
         """
         self._path = path
         if os.path.exists(path):
             self.dataframe: pd.DataFrame = pd.read_csv(path)
         else:
             self.dataframe = pd.DataFrame()
+        if is_initialize:
+            self.dataframe = pd.DataFrame()
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, DataframeSerializer):

src/dataframe_serializer.py

@@ -77,19 +77,24 @@ class Score:
     """
 
     def __init__(self, serialization_path: str = SERIALIZATION_PATH,
-            is_ignore_first_prediction: bool = True) -> None:
+            is_ignore_first_prediction: bool = True,
+            is_initialize: bool = False) -> None:
         """
         Parameters
         ----------
         serialization_path : str
             Path to a CSV file for persistence.
         is_ignore_first_prediction : bool
             Whether to ignore the first prediction when computing scores, since it may be an outlier.
+        is_initialize : bool
+            Whether to initialize the CSV file by writing an empty DataFrame with the appropriate columns.
         """
-        self._serializer = DataframeSerializer(serialization_path)
+        self._serializer = DataframeSerializer(serialization_path,
+                is_initialize=is_initialize)
         self._serialization_path = serialization_path
         self._is_ignore_first_prediction = is_ignore_first_prediction
-
+        if is_initialize:
+            self._serializer.serialize([])
     @property
     def score_df(self) -> pd.DataFrame:
         return self._serializer.dataframe

src/score.py

@@ -13,8 +13,6 @@
 import pandas as pd  # type: ignore
 
 import src.constants as cn  # type: ignore
-from src.l_roadrunner import LRoadrunner  # type: ignore
-from src.trajectory import Trajectory  # type: ignore
 from src.score import (Score, ScoreInfo,  # type: ignore
         AGGREGATION_TYPE, AGGREGATION_MEAN, AGGREGATION_COUNT)
 
@@ -71,6 +69,42 @@ def test_existing_file_loaded(self) -> None:
         restored = Score(serialization_path=score._serialization_path)
         self.assertFalse(restored.score_df.empty)
 
+    def test_is_initialize_true_clears_existing_data(self) -> None:
+        """is_initialize=True gives empty score_df even when CSV has existing data."""
+        if IGNORE_TESTS:
+            return
+        score = _make_score()
+        path = score._serialization_path
+        reset = Score(serialization_path=path, is_initialize=True)
+        self.assertTrue(reset.score_df.empty)
+
+    def test_is_initialize_true_writes_empty_csv(self) -> None:
+        """is_initialize=True creates the CSV file on disk."""
+        if IGNORE_TESTS:
+            return
+        path = _temp_csv_path()
+        Score(serialization_path=path, is_initialize=True)
+        self.assertTrue(os.path.exists(path))
+
+    def test_is_initialize_true_subsequent_add_starts_fresh(self) -> None:
+        """After is_initialize=True, addTestResult produces the correct row count."""
+        if IGNORE_TESTS:
+            return
+        score = _make_score()
+        path = score._serialization_path
+        reset = Score(serialization_path=path, is_initialize=True)
+        reset.addTestResult(TRUE_DF, PRED_DF)
+        self.assertEqual(len(reset.score_df), 1 + len(TRUE_DF.columns))
+
+    def test_is_initialize_false_is_default(self) -> None:
+        """Default is_initialize=False preserves existing CSV data."""
+        if IGNORE_TESTS:
+            return
+        score = _make_score()
+        path = score._serialization_path
+        reloaded = Score(serialization_path=path)
+        self.assertFalse(reloaded.score_df.empty)
+
 
 class TestAddTestResult(unittest.TestCase):
     """Tests for Score.addTestResult."""
@@ -419,6 +453,8 @@ def _checkBiomodel(self, model_num: int, end_time: float) -> None:
         """Run full pipeline for one BioModel and assert valid score statistics."""
         if IGNORE_TESTS:
             return
+        from src.l_roadrunner import LRoadrunner  # type: ignore
+        from src.trajectory import Trajectory  # type: ignore
         l_roadrunner = LRoadrunner.makeBiomodel(model_num=model_num, start_time=0.0, end_time=end_time, num_point=11)
         true_df = l_roadrunner.timecourse_df
         trajectory = Trajectory(l_roadrunner)