Merge branch 'calibrate-impact-functions' into cross-calibrate-impact-functions

Author: peanutfun

CHANGELOG.md

@@ -16,13 +16,19 @@ Code freeze date: YYYY-MM-DD
 
 ### Fixed
 
-- Fix `util.coordinates.latlon_bounds` for cases where the specified buffer is very large so that the bounds cover more than the full longitudinal range `[-180, 180]` [#839](https://github.com/CLIMADA-project/climada_python/pull/839)
-- Fix `climada.hazard.trop_cyclone` for TC tracks crossing the antimeridian [#839](https://github.com/CLIMADA-project/climada_python/pull/839)
-
 ### Deprecated
 
 ### Removed
 
+## 4.1.1
+
+Release date: 2024-02-21
+
+### Fixed
+
+- Fix `util.coordinates.latlon_bounds` for cases where the specified buffer is very large so that the bounds cover more than the full longitudinal range `[-180, 180]` [#839](https://github.com/CLIMADA-project/climada_python/pull/839)
+- Fix `climada.hazard.trop_cyclone` for TC tracks crossing the antimeridian [#839](https://github.com/CLIMADA-project/climada_python/pull/839)
+
 ## 4.1.0
 
 Release date: 2024-02-14

climada/_version.py

@@ -1 +1 @@
-__version__ = '4.1.1-dev'
+__version__ = '4.1.2-dev'

climada/hazard/base.py

@@ -840,7 +840,7 @@ def year_month_day_accessor(
                 return array.dt.strftime("%Y-%m-%d").values
 
             # Handle access errors
-            except (ValueError, TypeError) as err:
+            except (ValueError, TypeError, AttributeError) as err:
                 if strict:
                     raise err
 

climada/test/test_util_calibrate.py

@@ -35,6 +35,7 @@
     BayesianOptimizer,
     OutputEvaluator,
     BayesianOptimizerOutputEvaluator,
+    BayesianOptimizerController,
 )
 
 from climada.util.calibrate.test.test_base import hazard, exposure
@@ -173,14 +174,18 @@ def setUp(self) -> None:
     def test_single(self):
         """Test with single parameter"""
         self.input.bounds = {"slope": (-1, 3)}
+        controller = BayesianOptimizerController(
+            init_points=10, n_iter=20, max_iterations=1
+        )
         optimizer = BayesianOptimizer(self.input, random_state=1)
-        output = optimizer.run(init_points=10, n_iter=20)
+        output = optimizer.run(controller)
 
         # Check result (low accuracy)
         self.assertAlmostEqual(output.params["slope"], 1.0, places=2)
         self.assertAlmostEqual(output.target, 0.0, places=3)
         self.assertEqual(output.p_space.dim, 1)
         self.assertTupleEqual(output.p_space_to_dataframe().shape, (30, 2))
+        self.assertEqual(controller.iterations, 1)
 
     def test_multiple_constrained(self):
         """Test with multiple constrained parameters"""
@@ -204,13 +209,17 @@ def test_multiple_constrained(self):
         self.input.bounds = {"intensity_1": (-1, 4), "intensity_2": (-1, 4)}
         # Run optimizer
         optimizer = BayesianOptimizer(self.input, random_state=1)
-        output = optimizer.run(n_iter=200)
+        controller = BayesianOptimizerController.from_input(
+            self.input, sampling_base=5, max_iterations=3
+        )
+        output = optimizer.run(controller)
 
         # Check results (low accuracy)
         self.assertEqual(output.p_space.dim, 2)
         self.assertAlmostEqual(output.params["intensity_1"], 1.0, places=2)
         self.assertAlmostEqual(output.params["intensity_2"], 3.0, places=1)
         self.assertAlmostEqual(output.target, 0.0, places=3)
+        self.assertGreater(controller.iterations, 1)
 
         # Check constraints in parameter space
         p_space = output.p_space_to_dataframe()
@@ -224,7 +233,8 @@ def test_multiple_constrained(self):
                 ("Calibration", "Allowed"),
             },
         )
-        self.assertTupleEqual(p_space.shape, (300, 5))
+        self.assertGreater(p_space.shape[0], 50)  # Two times random iterations
+        self.assertEqual(p_space.shape[1], 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(),
@@ -235,7 +245,10 @@ def test_plots(self):
         """Check if executing the default plots works"""
         self.input.bounds = {"slope": (-1, 3)}
         optimizer = BayesianOptimizer(self.input, random_state=1)
-        output = optimizer.run(init_points=10, n_iter=20)
+        controller = BayesianOptimizerController.from_input(
+            self.input, max_iterations=1
+        )
+        output = optimizer.run(controller)
 
         output_eval = OutputEvaluator(self.input, output)
         output_eval.impf_set.plot()

climada/util/calibrate/bayesian_optimizer.py

@@ -29,7 +29,7 @@
 import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.axes as maxes
-from bayes_opt import BayesianOptimization, Events, UtilityFunction
+from bayes_opt import BayesianOptimization, Events, UtilityFunction, ScreenLogger
 from bayes_opt.target_space import TargetSpace
 
 from .base import Input, Output, Optimizer, OutputEvaluator
@@ -162,7 +162,11 @@ def plot_single(x, y):
         # Option 0: Only one parameter
         params = p_space_df["Parameters"].columns.to_list()
         if len(params) < 2:
-            return plot_single(x=params[0], y=repeat(0))
+            # Add zeros for scatter plot
+            p_space_df["Parameters", "none"] = np.zeros_like(
+                p_space_df["Parameters", params[0]]
+            )
+            return plot_single(x=params[0], y="none")
 
         # Option 1: Only a single plot
         if x is not None and y is not None:
@@ -237,8 +241,8 @@ class BayesianOptimizerController(object):
     """
 
     # Init attributes
-    init_points: int = 0
-    n_iter: int = 0
+    init_points: int
+    n_iter: int
     min_improvement: float = 1e-3
     min_improvement_count: int = 2
     kappa: float = 2.576
@@ -256,9 +260,13 @@ class BayesianOptimizerController(object):
 
     def __post_init__(self):
         """Set the decay factor for :py:attr:`kappa`."""
-        self.kappa_decay = np.exp(
-            (np.log(self.kappa_min) - np.log(self.kappa)) / self.n_iter
-        )
+        if self.init_points < 0 or self.n_iter < 0:
+            raise ValueError("'init_points' and 'n_iter' must be 0 or positive")
+        self.kappa_decay = self._calc_kappa_decay()
+
+    def _calc_kappa_decay(self):
+        """Compute the decay factor for :py:attr:`kappa`."""
+        return np.exp((np.log(self.kappa_min) - np.log(self.kappa)) / self.n_iter)
 
     @classmethod
     def from_input(cls, inp: Input, sampling_base: float = 4, **kwargs):
@@ -291,10 +299,6 @@ def _previous_max(self):
             return -np.inf
         return self._improvements[-1].target
 
-    def is_converged(self) -> bool:
-        """Check if convergence criteria are met"""
-        return True
-
     def optimizer_params(self) -> dict[str, Union[int, float, str, UtilityFunction]]:
         """Return parameters for the optimizer"""
         return {
@@ -365,7 +369,7 @@ def _maybe_stop_early(self, instance):
             instance.dispatch(Events.OPTIMIZATION_END)
             raise StopEarly()
 
-    def update(self, event, instance):
+    def update(self, event: str, instance: BayesianOptimization):
         """Update the step tracker of this instance.
 
         For step events, check if the latest guess is the new maximum. Also check if the
@@ -441,7 +445,8 @@ class BayesianOptimizer(Optimizer):
     input : Input
         The input data for this optimizer. See the Notes below for input requirements.
     verbose : int, optional
-        Verbosity of the optimizer output. Defaults to 1.
+        Verbosity of the optimizer output. Defaults to 0. The output is *not* affected
+        by the CLIMADA logging settings.
     random_state : int, optional
         Seed for initializing the random number generator. Defaults to 1.
     allow_duplicate_points : bool, optional
@@ -472,14 +477,12 @@ class BayesianOptimizer(Optimizer):
         The optimizer instance of this class.
     """
 
-    verbose: InitVar[int] = 1
+    verbose: int = 0
     random_state: InitVar[int] = 1
     allow_duplicate_points: InitVar[bool] = True
     bayes_opt_kwds: InitVar[Optional[Mapping[str, Any]]] = None
 
-    def __post_init__(
-        self, verbose, random_state, allow_duplicate_points, bayes_opt_kwds
-    ):
+    def __post_init__(self, random_state, allow_duplicate_points, bayes_opt_kwds):
         """Create optimizer"""
         if bayes_opt_kwds is None:
             bayes_opt_kwds = {}
@@ -491,7 +494,6 @@ def __post_init__(
             f=self._opt_func,
             pbounds=self.input.bounds,
             constraint=self.input.constraints,
-            verbose=verbose,
             random_state=random_state,
             allow_duplicate_points=allow_duplicate_points,
             **bayes_opt_kwds,
@@ -502,10 +504,7 @@ def _target_func(self, data: pd.DataFrame, predicted: pd.DataFrame) -> Number:
         """Invert the cost function because BayesianOptimization maximizes the target"""
         return -self.input.cost_func(data, predicted)
 
-    def run(
-        self,
-        controller: BayesianOptimizerController,
-    ) -> BayesianOptimizerOutput:
+    def run(self, controller: BayesianOptimizerController) -> BayesianOptimizerOutput:
         """Execute the optimization
 
         ``BayesianOptimization`` *maximizes* a target function. Therefore, this class
@@ -525,14 +524,29 @@ def run(
             Optimization output. :py:attr:`BayesianOptimizerOutput.p_space` stores data
             on the sampled parameter space.
         """
+        # Register the controller
         for event in (Events.OPTIMIZATION_STEP, Events.OPTIMIZATION_END):
             self.optimizer.subscribe(event, controller)
 
+        # Register the logger
+        if self.verbose > 0:
+            log = ScreenLogger(
+                verbose=self.verbose, is_constrained=self.optimizer.is_constrained
+            )
+            for event in (
+                Events.OPTIMIZATION_START,
+                Events.OPTIMIZATION_STEP,
+                Events.OPTIMIZATION_END,
+            ):
+                self.optimizer.subscribe(event, log)
+
+        # Run the optimization
         while controller.iterations < controller.max_iterations:
             try:
                 LOGGER.info(f"Optimization iteration: {controller.iterations}")
                 self.optimizer.maximize(**controller.optimizer_params())
             except StopEarly:
+                # Start a new iteration
                 continue
             except StopIteration:
                 # Exit the loop