Separate computing cost from transforming impact objects

Author: peanutfun

climada/test/test_util_calibrate.py

@@ -9,8 +9,7 @@
 
 from climada.entity import ImpactFuncSet, ImpactFunc
 
-from climada.util.calibrate import Input, ScipyMinimizeOptimizer
-from climada.util.calibrate.impact_func import cost_func_rmse
+from climada.util.calibrate import Input, ScipyMinimizeOptimizer, rmse, impact_at_reg
 
 from climada.util.calibrate.test.test_calibrate import hazard, exposure
 
@@ -30,10 +29,8 @@ def setUp(self) -> None:
         self.data = pd.DataFrame(
             data={"a": [3, 1], "b": [0.2, 0.01]}, index=self.events
         )
-        self.cost_func = partial(
-            cost_func_rmse, impact_proc=lambda impact: impact.impact_at_reg(["a", "b"])
-        )
-        self.impact_func_gen = lambda slope: ImpactFuncSet(
+        self.impact_to_dataframe = partial(impact_at_reg, region_ids=["a", "b"])
+        self.impact_func_creator = lambda slope: ImpactFuncSet(
             [
                 ImpactFunc(
                     intensity=np.array([0, 10]),
@@ -44,7 +41,12 @@ def setUp(self) -> None:
             ]
         )
         self.input = Input(
-            self.hazard, self.exposure, self.data, self.cost_func, self.impact_func_gen
+            self.hazard,
+            self.exposure,
+            self.data,
+            self.impact_func_creator,
+            self.impact_to_dataframe,
+            rmse,
         )
 
     def test_single(self):
@@ -71,7 +73,7 @@ def test_bound(self):
     def test_multiple_constrained(self):
         """Test with multiple constrained parameters"""
         # Set new generator
-        self.input.impact_func_gen = lambda intensity_1, intensity_2: ImpactFuncSet(
+        self.input.impact_func_creator = lambda intensity_1, intensity_2: ImpactFuncSet(
             [
                 ImpactFunc(
                     intensity=np.array([0, intensity_1, intensity_2]),

climada/util/calibrate/__init__.py

@@ -3,3 +3,4 @@
 from .base import Input
 from .bayesian_optimizer import BayesianOptimizer
 from .scipy_optimizer import ScipyMinimizeOptimizer
+from .func import rmse, rmsf, impact_at_reg

climada/util/calibrate/base.py

@@ -5,7 +5,6 @@
 from typing import Callable, Mapping, Optional, Tuple, Union, Any, Dict
 from numbers import Number
 
-import numpy as np
 import pandas as pd
 from scipy.optimize import Bounds, LinearConstraint, NonlinearConstraint
 
@@ -29,14 +28,19 @@ class Input:
     data : pandas.Dataframe
         The data to compare computed impacts to. Index: Event IDs matching the IDs of
         ``hazard``. Columns: Arbitrary columns.
-    cost_func : Callable
-        Function that takes an ``Impact`` object and a ``pandas.Dataframe`` as argument
-        and returns a single number. The optimization algorithm will try to minimize this
-        number. See this module for a suggestion of cost functions.
-    impact_func_gen : Callable
+    impact_func_creator : Callable
         Function that takes the parameters as keyword arguments and returns an impact
         function set. This will be called each time the optimization algorithm updates
         the parameters.
+    impact_to_dataframe : Callable
+        Function that takes an impact object as input and transforms its data into a
+        pandas.DataFrame that is compatible with the format of :py:attr:`data`.
+        The return value of this function will be passed to the :py:attr`cost_func`
+        as first argument.
+    cost_func : Callable
+        Function that takes two ``pandas.Dataframe`` objects and returns the scalar
+        "cost" between them. The optimization algorithm will try to minimize this
+        number.
     bounds : Mapping (str, {Bounds, tuple(float, float)}), optional
         The bounds for the parameters. Keys: parameter names. Values:
         ``scipy.minimize.Bounds`` instance or tuple of minimum and maximum value.
@@ -58,8 +62,9 @@ class Input:
     hazard: Hazard
     exposure: Exposures
     data: pd.DataFrame
-    cost_func: Callable[[Impact, pd.DataFrame], Number]
-    impact_func_gen: Callable[..., ImpactFuncSet]
+    impact_func_creator: Callable[..., ImpactFuncSet]
+    impact_to_dataframe: Callable[[Impact], pd.DataFrame]
+    cost_func: Callable[[pd.DataFrame, pd.DataFrame], Number]
     bounds: Optional[Mapping[str, Union[Bounds, Tuple[Number, Number]]]] = None
     constraints: Optional[Union[ConstraintType, list[ConstraintType]]] = None
     impact_calc_kwds: Mapping[str, Any] = field(
@@ -104,7 +109,7 @@ class Optimizer(ABC):
 
     input: Input
 
-    def _target_func(self, impact: Impact, data: pd.DataFrame) -> Number:
+    def _target_func(self, impact: pd.DataFrame, data: pd.DataFrame) -> Number:
         """Target function for the optimizer
 
         The default version of this function simply returns the value of the cost
@@ -123,13 +128,13 @@ def _target_func(self, impact: Impact, data: pd.DataFrame) -> Number:
         """
         return self.input.cost_func(impact, data)
 
-    def _kwargs_to_impact_func_gen(self, *_, **kwargs) -> Dict[str, Any]:
+    def _kwargs_to_impact_func_creator(self, *_, **kwargs) -> Dict[str, Any]:
         """Define how the parameters to :py:meth:`_opt_func` must be transformed
 
         Optimizers may implement different ways of representing the parameters (e.g.,
         key-value pairs, arrays, etc.). Depending on this representation, the parameters
         must be transformed to match the syntax of the impact function generator used,
-        see :py:attr:`Input.impact_func_gen`.
+        see :py:attr:`Input.impact_func_creator`.
 
         In this default version, the method simply returns its keyword arguments as
         mapping. Override this method if the optimizer used *does not* represent
@@ -162,14 +167,15 @@ def _opt_func(self, *args, **kwargs) -> Number:
         -------
         Target function value for the given arguments
         """
-        params = self._kwargs_to_impact_func_gen(*args, **kwargs)
-        impf_set = self.input.impact_func_gen(**params)
+        params = self._kwargs_to_impact_func_creator(*args, **kwargs)
+        impf_set = self.input.impact_func_creator(**params)
         impact = ImpactCalc(
             exposures=self.input.exposure,
             impfset=impf_set,
             hazard=self.input.hazard,
         ).impact(**self.input.impact_calc_kwds)
-        return self._target_func(impact, self.input.data)
+        impact_df = self.input.impact_to_dataframe(impact)
+        return self._target_func(impact_df, self.input.data)
 
     @abstractmethod
     def run(self, **opt_kwargs) -> Output:

climada/util/calibrate/bayesian_optimizer.py

@@ -84,9 +84,9 @@ def __post_init__(
             **bayes_opt_kwds,
         )
 
-    def _target_func(self, impact: Impact, data: pd.DataFrame) -> Number:
+    def _target_func(self, impact: pd.DataFrame, data: pd.DataFrame) -> Number:
         """Invert the cost function because BayesianOptimization maximizes the target"""
-        return 1 / self.input.cost_func(impact, data)
+        return -self.input.cost_func(impact, data)
 
     def run(self, **opt_kwargs):
         """Execute the optimization

climada/util/calibrate/impact_func.py

@@ -34,7 +34,7 @@ def __post_init__(self):
         """Create a private attribute for storing the parameter names"""
         self._param_names: List[str] = list()
 
-    def _kwargs_to_impact_func_gen(self, *args, **_) -> Dict[str, Any]:
+    def _kwargs_to_impact_func_creator(self, *args, **_) -> Dict[str, Any]:
         """Transform the array of parameters into key-value pairs"""
         return dict(zip(self._param_names, args[0].flat))
 

climada/util/calibrate/scipy_optimizer.py

@@ -54,6 +54,7 @@ def setUp(self):
         self.data = pd.DataFrame(data={"a": [1, 2]}, index=self.data_events)
 
         # Create dummy funcs
+        self.impact_to_dataframe = lambda _: pd.DataFrame()
         self.cost_func = lambda impact, data: 1.0
         self.impact_func_gen = lambda **kwargs: ImpactFuncSet()
 
@@ -68,7 +69,8 @@ def test_post_init_calls(self):
             exposure=exposure_mock,
             data=self.data,
             cost_func=self.cost_func,
-            impact_func_gen=self.impact_func_gen,
+            impact_func_creator=self.impact_func_gen,
+            impact_to_dataframe=self.impact_to_dataframe
         )
         exposure_mock.assign_centroids.assert_called_once_with(self.hazard)
         exposure_mock.reset_mock()
@@ -79,7 +81,8 @@ def test_post_init_calls(self):
             exposure=exposure_mock,
             data=self.data,
             cost_func=self.cost_func,
-            impact_func_gen=self.impact_func_gen,
+            impact_func_creator=self.impact_func_gen,
+            impact_to_dataframe=self.impact_to_dataframe,
             assign_centroids=False
         )
         exposure_mock.assign_centroids.assert_not_called()
@@ -93,7 +96,8 @@ def test_post_init(self):
             exposure=self.exposure,
             data=self.data,
             cost_func=self.cost_func,
-            impact_func_gen=self.impact_func_gen,
+            impact_func_creator=self.impact_func_gen,
+            impact_to_dataframe=self.impact_to_dataframe
         )
 
         # Check hazard and exposure
@@ -112,7 +116,8 @@ def setUp(self):
                 exposure=create_autospec(Exposures, instance=True),
                 data=create_autospec(pd.DataFrame, instance=True),
                 cost_func=MagicMock(),
-                impact_func_gen=MagicMock(),
+                impact_func_creator=MagicMock(),
+                impact_to_dataframe=MagicMock(),
                 assign_centroids=False,
             )
         )
@@ -127,10 +132,10 @@ def setUp(self):
         self.optimizer = ScipyMinimizeOptimizer(self.input)
 
     @patch("climada.util.calibrate.base.ImpactCalc", autospec=True)
-    def test_kwargs_to_impact_func_gen(self, _):
+    def test_kwargs_to_impact_func_creator(self, _):
         """Test transform of minimize func arguments to impact_func_gen arguments
 
-        We test the method '_kwargs_to_impact_func_gen' through 'run' because it is
+        We test the method '_kwargs_to_impact_func_creator' through 'run' because it is
         private.
         """
         # Create stubs
@@ -142,8 +147,8 @@ def test_kwargs_to_impact_func_gen(self, _):
         params_init = {"x_2": 1, "x 1": 2, "x_3": 3}  # NOTE: Also works with whitespace
         self.optimizer.run(params_init=params_init, options={"maxiter": 1})
 
-        # Check call to '_kwargs_to_impact_func_gen'
-        self.input.impact_func_gen.assert_any_call(**params_init)
+        # Check call to '_kwargs_to_impact_func_creator'
+        self.input.impact_func_creator.assert_any_call(**params_init)
 
     def test_output(self):
         """Check output reporting"""
@@ -218,10 +223,10 @@ def setUp(self):
         super().setUp()
 
     @patch("climada.util.calibrate.base.ImpactCalc", autospec=True)
-    def test_kwargs_to_impact_func_gen(self, _):
+    def test_kwargs_to_impact_func_creator(self, _):
         """Test transform of minimize func arguments to impact_func_gen arguments
 
-        We test the method '_kwargs_to_impact_func_gen' through 'run' because it is
+        We test the method '_kwargs_to_impact_func_creator' through 'run' because it is
         private.
         """
         # Create stubs
@@ -233,7 +238,7 @@ def test_kwargs_to_impact_func_gen(self, _):
         self.optimizer.run(init_points=2, n_iter=1)
 
         # Check call to '_kwargs_to_impact_func_gen'
-        call_args = self.input.impact_func_gen.call_args_list
+        call_args = self.input.impact_func_creator.call_args_list
         self.assertEqual(len(call_args), 3)
         for args in call_args:
             self.assertSequenceEqual(args.kwargs.keys(), self.input.bounds.keys())