Fix build break: 3

Author: joseph-hellerstein

scripts/calculate_linear_prediction_scores.py

@@ -105,8 +105,11 @@ def processModels(first_model_num: int, last_model_num: int,
     endtime_dct = getBiomodelsEndtimes(is_include_endtime_source=True)
 
     score = Score(serialization_path=serialization_path)
-    if os.path.exists(score.serialization_path):
-        existing_models = set(score.score_df["description"].unique())
+    if len(score.score_df) > 0:
+        if "description" in score.score_df.columns:
+            existing_models = set(score.score_df["description"].unique())
+        else:
+            existing_models = set(score.score_df[cn.COL_SYSTEM_ID].unique())
     else:
         existing_models = set()
     excluded_models = list(set(EXCLUDED_MODELS) | existing_models)

scripts/make_biomodels_endtime.py

@@ -30,6 +30,8 @@
 DIAMETER_MAX_CV = "max_cv"
 
 # Columns
+COL_AGGREGATION_TYPE = "aggregation_type"  # model or species name
+COL_AGGREGATION_TYPE_MODEL = "model"
 COL_MAXCV = "max_cv"
 COL_ENDTIME = "end_time"
 COL_MODEL_NAME = "model_name"
@@ -77,8 +79,3 @@
 # Endtime fraction
 ENDTIME_FRACTION_STEADYSTATE = 0.1  # Fraction of endtime to use for timecourse analysis
 ENDTIME_FRACTION_MAXMEDIAN = 0.1  # Fraction of endtime to use for timecourse analysis
-
-# Aggregations
-AGGREGATION_TYPE = "aggregation_type"  # model or species name
-AGGREGATION_TYPE_MODEL = "model"
-DESCRIPTION = "description"  # Description of the aggregation

src/constants.py

@@ -146,10 +146,10 @@ def score(self, column_name: str = 'p95') -> float:
         """Length-weighted aggregation of per-subsequence ScoreInfo. See
         docs/piecewise_system_discovery.md `score()` section."""
         weighted_score_df = self.getWeightedScores()
-        sel = weighted_score_df[cn.AGGREGATION_TYPE] == cn.AGGREGATION_TYPE_MODEL
+        sel = weighted_score_df[cn.COL_AGGREGATION_TYPE] == cn.COL_AGGREGATION_TYPE_MODEL
         result = weighted_score_df[sel][column_name].values
         if len(result) != 1:
-            raise RuntimeError(f"Expected 1 row for {cn.AGGREGATION_TYPE_MODEL} but got {len(result)}")
+            raise RuntimeError(f"Expected 1 row for {cn.COL_AGGREGATION_TYPE_MODEL} but got {len(result)}")
         return cast(float, result[0])
 
     def __str__(self) -> str:

src/piecewise_system_discovery.py

@@ -105,14 +105,15 @@ def add(self,
             The full score DataFrame after this addition.
         """
         mape_df: pd.DataFrame = self.calculateMAPE(true_timecourse_df, prediction_timecourse_df)
-        self.statistic_calculator.add(cn.AGGREGATION_TYPE_MODEL, mape_df.values.flatten())
+        self.statistic_calculator.add(cn.COL_AGGREGATION_TYPE_MODEL, mape_df.values.flatten())
         # Species level aggregations (one per species column, across all timepoints)
         species_names = list(mape_df.columns)
         for species_name in species_names:
             self.statistic_calculator.add(species_name, mape_df[species_name].to_numpy())
         # Add the system ID
         self.score_df = self.statistic_calculator.dataframe.copy()
         self.score_df[cn.COL_SYSTEM_ID] = system_id
+        self.score_df = self.score_df.rename(columns={cn.COL_LABEL: cn.COL_AGGREGATION_TYPE})
         # Serialize the accumulated statistics
         if self._is_persist:
             self.score_df.to_csv(self.serialization_path, index=False)
@@ -163,14 +164,14 @@ def doPlot(value_arr: np.ndarray, xlabel: str):
                 plt.close()
         ##
         if is_plot_model:
-            if cn.AGGREGATION_TYPE in df.columns:
-                model_df = df[df[cn.AGGREGATION_TYPE] == cn.AGGREGATION_TYPE_MODEL]
+            if cn.COL_AGGREGATION_TYPE in df.columns:
+                model_df = df[df[cn.COL_AGGREGATION_TYPE] == cn.COL_AGGREGATION_TYPE_MODEL]
                 if not model_df.empty and metric_name in model_df.columns:
                     value_arr = np.array(model_df[metric_name].values)
                     doPlot(value_arr, xlabel=metric_name)
         if is_plot_species:
-            if cn.AGGREGATION_TYPE in df.columns:
-                species_df = df[df[cn.AGGREGATION_TYPE] != cn.AGGREGATION_TYPE_MODEL]
+            if cn.COL_AGGREGATION_TYPE in df.columns:
+                species_df = df[df[cn.COL_AGGREGATION_TYPE] != cn.COL_AGGREGATION_TYPE_MODEL]
                 if not species_df.empty and metric_name in species_df.columns:
                     value_arr = np.array(species_df[metric_name].values)
                     doPlot(value_arr, xlabel=metric_name)

src/score.py

@@ -545,8 +545,8 @@ def calculateRsq(self, method: str = "derivative",
         self._require_fitted()
         score_type = "timecourse" if method == "simulation" else "derivative"
         detail_df = self.getScoreDetails(test_df=test_df, score_type=score_type)
-        species_rows = detail_df[detail_df[cn.AGGREGATION_TYPE]
-                != cn.AGGREGATION_TYPE_MODEL].copy()
+        species_rows = detail_df[detail_df[cn.COL_AGGREGATION_TYPE]
+                != cn.COL_AGGREGATION_TYPE_MODEL].copy()
         result: dict[str, float] = {}
         for i, sp_name in enumerate(self.species_names):
             if i < len(species_rows):
@@ -938,18 +938,21 @@ def getScoreDetails(self, test_df: pd.DataFrame = NULL_DF, score_type: str = "de
             A DataFrame containing the score information for the model and each species.
         """
         score = Score()
+        result_df = pd.DataFrame()
         if score_type == "derivative":
             if test_df is NULL_DF:
                 test_df = self.df
             pred_arr = self.predictAllDerivatives(test_df.to_numpy(dtype=float))
             pred_df = pd.DataFrame(pred_arr[:-1], index=test_df.index[1:],
                     columns=self.species_names)
-            return score.add(self.Xdot_df, pred_df)
+            result_df = score.add(self.Xdot_df, pred_df)
         elif score_type == "timecourse":
             pred_df = self.predict()
-            return score.add(self.df, pred_df)
+            result_df =score.add(self.df, pred_df)
         else:
             raise ValueError(f"Invalid score_type '{score_type}'. Must be 'derivative' or 'timecourse'.")
+        #
+        return result_df
 
     def score(self, score_type: str = "derivative") -> float:
         """
@@ -973,12 +976,12 @@ def score(self, score_type: str = "derivative") -> float:
             - ``"timecourse"``: R² for the species timecourses
         """
         score_detail_df = self.getScoreDetails(score_type=score_type)
-        model_sel = score_detail_df["aggregation_type"] == "model"
+        model_sel = score_detail_df[cn.COL_AGGREGATION_TYPE] == "model"
         if score_type == "derivative":
             result = float(score_detail_df[model_sel]["min"].iloc[0])
             return result
         elif score_type == "timecourse":
-            species_sel = score_detail_df["aggregation_type"] != "model"
+            species_sel = score_detail_df[cn.COL_AGGREGATION_TYPE] != "model"
             p95_vals = score_detail_df[species_sel]["p95"].to_numpy(dtype=float)
             result = float(np.max(p95_vals))
             return result