Use MultiIndex in parameter space dataframe

Author: peanutfun

climada/test/test_util_calibrate.py

@@ -170,7 +170,7 @@ def test_multiple_constrained(self):
 
         # Constraint: param[0] < param[1] (intensity_1 < intensity_2)
         self.input.constraints = NonlinearConstraint(
-            lambda params: params[0] - params[1], -np.inf, 0.0
+            lambda intensity_1, intensity_2: intensity_1 - intensity_2, -np.inf, 0.0
         )
         self.input.bounds = {"intensity_1": (-1, 4), "intensity_2": (-1, 4)}
         # Run optimizer
@@ -187,6 +187,17 @@ def test_multiple_constrained(self):
         p_space = output.p_space_to_dataframe()
         self.assertSetEqual(
             set(p_space.columns.to_list()),
-            {"intensity_1", "intensity_2", "Cost Function"},
+            {
+                ("Parameters", "intensity_1"),
+                ("Parameters", "intensity_2"),
+                ("Calibration", "Cost Function"),
+                ("Calibration", "Constraints Function"),
+                ("Calibration", "Allowed"),
+            },
+        )
+        self.assertTupleEqual(p_space.shape, (300, 5))
+        p_allowed = p_space.loc[p_space["Calibration", "Allowed"], "Parameters"]
+        npt.assert_array_equal(
+            (p_allowed["intensity_1"] < p_allowed["intensity_2"]).to_numpy(),
+            np.full_like(p_allowed["intensity_1"].to_numpy(), True),
         )
-        self.assertTupleEqual(p_space.shape, (300, 3))

climada/util/calibrate/base.py

@@ -87,6 +87,15 @@ class Input:
 
     def __post_init__(self, assign_centroids):
         """Prepare input data"""
+        if not isinstance(self.data, pd.DataFrame):
+            if isinstance(self.data, pd.Series):
+                raise ValueError(
+                    "You passed a pandas Series as 'data'. Please transform it into a "
+                    "dataframe with Series.to_frame() and make sure that columns "
+                    "correctly indicate locations and indexes events."
+                )
+            raise ValueError("'data' must be a pandas.DataFrame")
+
         if assign_centroids:
             self.exposure.assign_centroids(self.hazard)
 
@@ -251,22 +260,16 @@ def plot_impf_variability(
                 )
             p_space_df = self.output.p_space_to_dataframe()
 
-        # Retrieve list of parameters required for creating impact functions
-        # and remove the dimension 'Cost Function'.
-        params = p_space_df.columns.tolist()
-        try:
-            params.remove("Cost Function")
-        except ValueError:
-            pass
-
         # Retrieve parameters of impact functions with cost function values
         # within 'cost_func_diff' % of the best estimate
-        params_within_range = p_space_df[params]
+        params_within_range = p_space_df["Parameters"]
         plot_space_label = "Parameter space"
         if cost_func_diff is not None:
-            max_cost_func_val = p_space_df["Cost Function"].min() * (1 + cost_func_diff)
-            params_within_range = p_space_df.loc[
-                p_space_df["Cost Function"] <= max_cost_func_val, params
+            max_cost_func_val = p_space_df["Calibration", "Cost Function"].min() * (
+                1 + cost_func_diff
+            )
+            params_within_range = params_within_range.loc[
+                p_space_df["Calibration", "Cost Function"] <= max_cost_func_val
             ]
             plot_space_label = (
                 f"within {int(cost_func_diff*100)} percent " f"of best fit"

climada/util/calibrate/bayesian_optimizer.py

@@ -1,7 +1,7 @@
 """Calibration with Bayesian Optimization"""
 
 from dataclasses import dataclass, InitVar
-from typing import Mapping, Optional, Any, Union, List
+from typing import Mapping, Optional, Any, Union, List, Tuple
 from numbers import Number
 from itertools import combinations, repeat
 
@@ -80,6 +80,7 @@ def __post_init__(
         self.optimizer = BayesianOptimization(
             f=self._opt_func,
             pbounds=self.input.bounds,
+            constraint=self.input.constraints,
             verbose=verbose,
             random_state=random_state,
             allow_duplicate_points=allow_duplicate_points,
@@ -153,13 +154,26 @@ def p_space_to_dataframe(self):
             function value (``Cost Function``) and whose rows are the optimizer
             iterations.
         """
-        # TODO: Handle constraints!!!
-        data = {
-            self.p_space.keys[i]: self.p_space.params[..., i]
-            for i in range(self.p_space.dim)
-        }
-        data["Cost Function"] = -self.p_space.target
-        data = pd.DataFrame.from_dict(data)
+        # Build MultiIndex for columns
+        index = pd.MultiIndex.from_tuples(
+            [("Parameters", p) for p in self.p_space.keys]
+            + [("Calibration", "Cost Function")]
+        )
+
+        # Create DataFrame and fill
+        data = pd.DataFrame(data=None, columns=index)
+        for i in range(self.p_space.dim):
+            data["Parameters", self.p_space.keys[i]] = self.p_space.params[..., i]
+        data["Calibration", "Cost Function"] = -self.p_space.target
+
+        # Constraints
+        if self.p_space.constraint is not None:
+            data["Calibration", "Constraints Function"] = self.p_space.constraint_values
+            data["Calibration", "Allowed"] = self.p_space.constraint.allowed(
+                self.p_space.constraint_values
+            )
+
+        # Rename index and return
         data.index.rename("Iteration", inplace=True)
         return data
 
@@ -168,7 +182,7 @@ def plot_p_space(
         p_space_df: Optional[pd.DataFrame] = None,
         x: Optional[str] = None,
         y: Optional[str] = None,
-        min_def: Optional[str] = "Cost Function",
+        min_def: Optional[Union[str, Tuple[str, str]]] = "Cost Function",
         min_fmt: str = "x",
         min_color: str = "r",
         **plot_kwargs
@@ -206,13 +220,19 @@ def plot_p_space(
         if p_space_df is None:
             p_space_df = self.p_space_to_dataframe()
 
+        if min_def is not None and not isinstance(min_def, tuple):
+            min_def = ("Calibration", min_def)
+
         # Plot defaults
         cmap = plot_kwargs.pop("cmap", "viridis_r")
         s = plot_kwargs.pop("s", 40)
-        c = plot_kwargs.pop("c", "Cost Function")
+        c = ("Calibration", plot_kwargs.pop("c", "Cost Function"))
 
         def plot_single(x, y):
             """Plot a single combination of parameters"""
+            x = ("Parameters", x)
+            y = ("Parameters", y)
+
             # Plot scatter
             ax = p_space_df.plot(
                 kind="scatter",
@@ -231,14 +251,8 @@ def plot_single(x, y):
 
             return ax
 
-        # Ignore cost dimension
-        params = p_space_df.columns.tolist()
-        try:
-            params.remove(c)
-        except ValueError:
-            pass
-
         # Option 0: Only one parameter
+        params = p_space_df.columns.to_list()
         if len(params) < 2:
             return plot_single(x=params[0], y=repeat(0))