diff --git a/AUTHORS.md b/AUTHORS.md index 3409243a3a..d506412956 100644 --- a/AUTHORS.md +++ b/AUTHORS.md @@ -29,6 +29,7 @@ * Raphael Portmann * Nicolas Colombi * Leonie Villiger +* Timo Schmid * Kam Lam Yeung * Sarah Hülsen * Timo Schmid diff --git a/CHANGELOG.md b/CHANGELOG.md index 90d02c85cb..9e4265df04 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,7 @@ Code freeze date: YYYY-MM-DD ### Added - GitHub actions workflow for CLIMADA Petals compatibility tests [#855](https://github.com/CLIMADA-project/climada_python/pull/855) +- `climada.util.calibrate` module for calibrating impact functions [#692](https://github.com/CLIMADA-project/climada_python/pull/692) ### Changed diff --git a/climada/test/test_util_calibrate.py b/climada/test/test_util_calibrate.py new file mode 100644 index 0000000000..5432f62cd7 --- /dev/null +++ b/climada/test/test_util_calibrate.py @@ -0,0 +1,261 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- +Integration tests for calibration module +""" + +import unittest + +import pandas as pd +import numpy as np +import numpy.testing as npt +from scipy.optimize import NonlinearConstraint +from sklearn.metrics import mean_squared_error +from matplotlib.axes import Axes + +from climada.entity import ImpactFuncSet, ImpactFunc + +from climada.util.calibrate import ( + Input, + ScipyMinimizeOptimizer, + BayesianOptimizer, + OutputEvaluator, + BayesianOptimizerOutputEvaluator, + BayesianOptimizerController, +) + +from climada.util.calibrate.test.test_base import hazard, exposure + + +class TestScipyMinimizeOptimizer(unittest.TestCase): + """Test the TestScipyMinimizeOptimizer""" + + def setUp(self) -> None: + """Prepare input for optimization""" + self.hazard = hazard() + self.hazard.frequency = np.ones_like(self.hazard.event_id) + self.hazard.date = self.hazard.frequency + self.hazard.event_name = ["event"] * len(self.hazard.event_id) + self.exposure = exposure() + self.events = [10, 1] + self.hazard = self.hazard.select(event_id=self.events) + self.data = pd.DataFrame( + data={"a": [3, 1], "b": [0.2, 0.01]}, index=self.events + ) + self.impact_to_dataframe = lambda impact: impact.impact_at_reg(["a", "b"]) + self.impact_func_creator = lambda slope: ImpactFuncSet( + [ + ImpactFunc( + intensity=np.array([0, 10]), + mdd=np.array([0, 10 * slope]), + paa=np.ones(2), + id=1, + haz_type="TEST", + ) + ] + ) + self.input = Input( + self.hazard, + self.exposure, + self.data, + self.impact_func_creator, + self.impact_to_dataframe, + mean_squared_error, + ) + + def test_single(self): + """Test with single parameter""" + optimizer = ScipyMinimizeOptimizer(self.input) + output = optimizer.run(params_init={"slope": 0.1}) + + # Result should be nearly exact + self.assertTrue(output.result.success) + self.assertAlmostEqual(output.params["slope"], 1.0) + self.assertAlmostEqual(output.target, 0.0) + + def test_bound(self): + """Test with single bound""" + self.input.bounds = {"slope": (-1.0, 0.91)} + optimizer = ScipyMinimizeOptimizer(self.input) + output = optimizer.run(params_init={"slope": 0.1}) + + # Result should be very close to the bound + self.assertTrue(output.result.success) + self.assertGreater(output.params["slope"], 0.89) + self.assertAlmostEqual(output.params["slope"], 0.91, places=2) + + def test_multiple_constrained(self): + """Test with multiple constrained parameters""" + # Set new generator + self.input.impact_func_creator = lambda intensity_1, intensity_2: ImpactFuncSet( + [ + ImpactFunc( + intensity=np.array([0, intensity_1, intensity_2]), + mdd=np.array([0, 1, 3]), + paa=np.ones(3), + id=1, + haz_type="TEST", + ) + ] + ) + + # Constraint: param[0] < param[1] (intensity_1 < intensity_2) + self.input.constraints = NonlinearConstraint( + lambda params: params[0] - params[1], -np.inf, 0.0 + ) + self.input.bounds = {"intensity_1": (0, 3.1), "intensity_2": (0, 3.1)} + + # Run optimizer + optimizer = ScipyMinimizeOptimizer(self.input) + output = optimizer.run( + params_init={"intensity_1": 2, "intensity_2": 2}, + options=dict(gtol=1e-5, xtol=1e-5), + ) + + # Check results (low accuracy) + self.assertTrue(output.result.success) + print(output.result.message) + print(output.result.status) + self.assertAlmostEqual(output.params["intensity_1"], 1.0, places=2) + self.assertGreater(output.params["intensity_2"], 2.8) # Should be 3.0 + self.assertAlmostEqual(output.target, 0.0, places=3) + + +class TestBayesianOptimizer(unittest.TestCase): + """Integration tests for the BayesianOptimizer""" + + def setUp(self) -> None: + """Prepare input for optimization""" + self.hazard = hazard() + self.hazard.frequency = np.ones_like(self.hazard.event_id) + self.hazard.date = self.hazard.frequency + self.hazard.event_name = ["event"] * len(self.hazard.event_id) + self.exposure = exposure() + self.events = [10, 1] + self.hazard = self.hazard.select(event_id=self.events) + self.data = pd.DataFrame( + data={"a": [3, 1], "b": [0.2, 0.01]}, index=self.events + ) + self.impact_to_dataframe = lambda impact: impact.impact_at_reg(["a", "b"]) + self.impact_func_creator = lambda slope: ImpactFuncSet( + [ + ImpactFunc( + intensity=np.array([0, 10]), + mdd=np.array([0, 10 * slope]), + paa=np.ones(2), + id=1, + haz_type="TEST", + ) + ] + ) + self.input = Input( + self.hazard, + self.exposure, + self.data, + self.impact_func_creator, + self.impact_to_dataframe, + mean_squared_error, + ) + + 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(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""" + # Set new generator + self.input.impact_func_creator = lambda intensity_1, intensity_2: ImpactFuncSet( + [ + ImpactFunc( + intensity=np.array([0, intensity_1, intensity_2]), + mdd=np.array([0, 1, 3]), + paa=np.ones(3), + id=1, + haz_type="TEST", + ) + ] + ) + + # Constraint: param[0] < param[1] (intensity_1 < intensity_2) + self.input.constraints = NonlinearConstraint( + 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 + optimizer = BayesianOptimizer(self.input, random_state=1) + 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() + self.assertSetEqual( + set(p_space.columns.to_list()), + { + ("Parameters", "intensity_1"), + ("Parameters", "intensity_2"), + ("Calibration", "Cost Function"), + ("Calibration", "Constraints Function"), + ("Calibration", "Allowed"), + }, + ) + 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(), + np.full_like(p_allowed["intensity_1"].to_numpy(), True), + ) + + def test_plots(self): + """Check if executing the default plots works""" + self.input.bounds = {"slope": (-1, 3)} + optimizer = BayesianOptimizer(self.input, random_state=1) + controller = BayesianOptimizerController.from_input( + self.input, max_iterations=1 + ) + output = optimizer.run(controller) + + output_eval = OutputEvaluator(self.input, output) + output_eval.impf_set.plot() + output_eval.plot_at_event() + output_eval.plot_at_region() + output_eval.plot_event_region_heatmap() + + output_eval = BayesianOptimizerOutputEvaluator(self.input, output) + ax = output_eval.plot_impf_variability() + self.assertIsInstance(ax, Axes) diff --git a/climada/util/calibrate/__init__.py b/climada/util/calibrate/__init__.py new file mode 100644 index 0000000000..2e947ee049 --- /dev/null +++ b/climada/util/calibrate/__init__.py @@ -0,0 +1,29 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- +Impact function calibration module +""" + +from .base import Input, OutputEvaluator +from .bayesian_optimizer import ( + BayesianOptimizer, + BayesianOptimizerController, + BayesianOptimizerOutput, + BayesianOptimizerOutputEvaluator, + select_best +) +from .scipy_optimizer import ScipyMinimizeOptimizer diff --git a/climada/util/calibrate/base.py b/climada/util/calibrate/base.py new file mode 100644 index 0000000000..d61644dc75 --- /dev/null +++ b/climada/util/calibrate/base.py @@ -0,0 +1,494 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- +Calibration Base Classes and Interfaces +""" + +from abc import ABC, abstractmethod +from dataclasses import dataclass, field, InitVar +from typing import Callable, Mapping, Optional, Tuple, Union, Any, Dict +from numbers import Number +from pathlib import Path + +import pandas as pd +import numpy as np +from scipy.optimize import Bounds, LinearConstraint, NonlinearConstraint +import seaborn as sns +import h5py + +from climada.hazard import Hazard +from climada.entity import Exposures, ImpactFuncSet +from climada.engine import Impact, ImpactCalc + +ConstraintType = Union[LinearConstraint, NonlinearConstraint, Mapping] + + +@dataclass +class Input: + """Define the static input for a calibration task + + Attributes + ---------- + hazard : climada.Hazard + Hazard object to compute impacts from + exposure : climada.Exposures + Exposures object to compute impacts from + data : pandas.Dataframe + The data to compare computed impacts to. Index: Event IDs matching the IDs of + ``hazard``. Columns: Arbitrary columns. NaN values in the data frame have + special meaning: Corresponding impact values computed by the model are ignored + in the calibration. + 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. The first argument is the true/correct values (:py:attr:`data`), and the + second argument is the estimated/predicted values. + 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. + Unbounded parameters need not be specified here. See the documentation for + the selected optimization algorithm on which data types are supported. + constraints : Constraint or list of Constraint, optional + One or multiple instances of ``scipy.minimize.LinearConstraint``, + ``scipy.minimize.NonlinearConstraint``, or a mapping. See the documentation for + the selected optimization algorithm on which data types are supported. + impact_calc_kwds : Mapping (str, Any), optional + Keyword arguments to :py:meth:`climada.engine.impact_calc.ImpactCalc.impact`. + Defaults to ``{"assign_centroids": False}`` (by default, centroids are assigned + here via the ``assign_centroids`` parameter, to avoid assigning them each time + the impact is calculated). + missing_data_value : float, optional + If the impact model returns impact data for which no values exist in + :py:attr:`data`, insert this value. Defaults to NaN, in which case the impact + from the model is ignored. Set this to zero to explicitly calibrate to zero + impacts in these cases. + assign_centroids : bool, optional + If ``True`` (default), assign the hazard centroids to the exposure when this + object is created. + """ + + hazard: Hazard + exposure: Exposures + data: pd.DataFrame + 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( + default_factory=lambda: {"assign_centroids": False} + ) + missing_data_value: float = np.nan + assign_centroids: InitVar[bool] = True + + def __post_init__(self, assign_centroids): + """Prepare input data""" + if not isinstance(self.data, pd.DataFrame): + if isinstance(self.data, pd.Series): + raise TypeError( + "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 TypeError("'data' must be a pandas.DataFrame") + + if assign_centroids: + self.exposure.assign_centroids(self.hazard) + + def impact_to_aligned_df( + self, impact: Impact, fillna: float = np.nan + ) -> Tuple[pd.DataFrame, pd.DataFrame]: + """Create a dataframe from an impact and align it with the data. + + When aligning, two general cases might occur, which are not mutually exclusive: + + 1. There are data points for which no impact was computed. This will always be + treated as an impact of zero. + 2. There are impacts for which no data points exist. For these points, the input + data will be filled with the value of :py:attr:`Input.missing_data_value`. + + This method performs the following steps: + + * Transform the impact into a dataframe using :py:attr:`impact_to_dataframe`. + * Align the :py:attr:`data` with the impact dataframe, using + :py:attr:`missing_data_value` as fill value. + * Align the impact dataframe with the data, using zeros as fill value. + * In the aligned impact, set all values to zero where the data is NaN. + * Fill remaining NaNs in data with ``fillna``. + + Parameters + ---------- + impact_df : pandas.DataFrame + The impact computed by the model, transformed into a dataframe by + :py:attr:`Input.impact_to_dataframe`. + + Returns + ------- + data_aligned : pd.DataFrame + The data aligned to the impact dataframe + impact_df_aligned : pd.DataFrame + The impact transformed to a dataframe and aligned with the data + """ + # Transform impact to to dataframe + impact_df = self.impact_to_dataframe(impact) + if impact_df.isna().any(axis=None): + raise ValueError("NaN values computed in impact!") + + # Align with different fill values + data_aligned, _ = self.data.align( + impact_df, axis=None, fill_value=self.missing_data_value, copy=True + ) + impact_df_aligned, _ = impact_df.align( + data_aligned, join="right", axis=None, fill_value=0.0, copy=False + ) + + # Set all impacts to zero for which data is NaN + impact_df_aligned.where(data_aligned.notna(), 0.0, inplace=True) + + # NOTE: impact_df_aligned should not contain any NaNs at this point + return data_aligned.fillna(fillna), impact_df_aligned.fillna(fillna) + + +@dataclass +class Output: + """Generic output of a calibration task + + Attributes + ---------- + params : Mapping (str, Number) + The optimal parameters + target : Number + The target function value for the optimal parameters + """ + + params: Mapping[str, Number] + target: Number + + def to_hdf5(self, filepath: Union[Path, str], mode:str = "x"): + """Write the output into an H5 file + + This stores the data as attributes because we only store single numbers, not + arrays + + Parameters + ---------- + filepath : Path or str + The filepath to store the data. + mode : str (optional) + The mode for opening the file. Defaults to ``x`` (Create file, fail if + exists). + """ + with h5py.File(filepath, mode=mode) as file: + # Store target + grp = file.create_group("base") + grp.attrs["target"] = self.target + + # Store params + grp_params = grp.create_group("params") + for p_name, p_val in self.params.items(): + grp_params.attrs[p_name] = p_val + + @classmethod + def from_hdf5(cls, filepath: Union[Path, str]): + """Create an output object from an H5 file""" + with h5py.File(filepath) as file: + target = file["base"].attrs["target"] + params = dict(file["base"]["params"].attrs.items()) + return cls(params=params, target=target) + +@dataclass +class OutputEvaluator: + """Evaluate the output of a calibration task + + Parameters + ---------- + input : Input + The input object for the optimization task. + output : Output + The output object returned by the optimization task. + + Attributes + ---------- + impf_set : climada.entity.ImpactFuncSet + The impact function set built from the optimized parameters + impact : climada.engine.Impact + An impact object calculated using the optimal :py:attr:`impf_set` + """ + + input: Input + output: Output + + def __post_init__(self): + """Compute the impact for the optimal parameters""" + self.impf_set = self.input.impact_func_creator(**self.output.params) + self.impact = ImpactCalc( + exposures=self.input.exposure, + impfset=self.impf_set, + hazard=self.input.hazard, + ).impact(assign_centroids=True, save_mat=True) + self._impact_label = f"Impact [{self.input.exposure.value_unit}]" + + def plot_at_event( + self, + data_transf: Callable[[pd.DataFrame], pd.DataFrame] = lambda x: x, + **plot_kwargs, + ): + """Create a bar plot comparing estimated model output and data per event. + + Every row of the :py:attr:`Input.data` is considered an event. + The data to be plotted can be transformed with a generic function + ``data_transf``. + + Parameters + ---------- + data_transf : Callable (pd.DataFrame -> pd.DataFrame), optional + A function that transforms the data to plot before plotting. + It receives a dataframe whose rows represent events and whose columns + represent the modelled impact and the calibration data, respectively. + By default, the data is not transformed. + plot_kwargs + Keyword arguments passed to the ``DataFrame.plot.bar`` method. + + Returns + ------- + ax : matplotlib.axes.Axes + The plot axis returned by ``DataFrame.plot.bar`` + + Note + ---- + This plot does *not* include the ignored impact, see :py:attr:`Input.data`. + """ + data, impact = self.input.impact_to_aligned_df(self.impact) + values = pd.concat( + [impact.sum(axis="columns"), data.sum(axis="columns")], + axis=1, + ).rename(columns={0: "Model", 1: "Data"}) + + # Transform data before plotting + values = data_transf(values) + + # Now plot + ylabel = plot_kwargs.pop("ylabel", self._impact_label) + return values.plot.bar(ylabel=ylabel, **plot_kwargs) + + def plot_at_region( + self, + data_transf: Callable[[pd.DataFrame], pd.DataFrame] = lambda x: x, + **plot_kwargs, + ): + """Create a bar plot comparing estimated model output and data per event + + Every column of the :py:attr:`Input.data` is considered a region. + The data to be plotted can be transformed with a generic function + ``data_transf``. + + Parameters + ---------- + data_transf : Callable (pd.DataFrame -> pd.DataFrame), optional + A function that transforms the data to plot before plotting. + It receives a dataframe whose rows represent regions and whose columns + represent the modelled impact and the calibration data, respectively. + By default, the data is not transformed. + plot_kwargs + Keyword arguments passed to the ``DataFrame.plot.bar`` method. + + Returns + ------- + ax : matplotlib.axes.Axes + The plot axis returned by ``DataFrame.plot.bar``. + + Note + ---- + This plot does *not* include the ignored impact, see :py:attr:`Input.data`. + """ + data, impact = self.input.impact_to_aligned_df(self.impact) + values = pd.concat( + [impact.sum(axis="index"), data.sum(axis="index")], + axis=1, + ).rename(columns={0: "Model", 1: "Data"}) + + # Transform data before plotting + values = data_transf(values) + + # Now plot + ylabel = plot_kwargs.pop("ylabel", self._impact_label) + return values.plot.bar(ylabel=ylabel, **plot_kwargs) + + def plot_event_region_heatmap( + self, + data_transf: Callable[[pd.DataFrame], pd.DataFrame] = lambda x: x, + **plot_kwargs, + ): + """Plot a heatmap comparing all events per all regions + + Every column of the :py:attr:`Input.data` is considered a region, and every + row is considered an event. + The data to be plotted can be transformed with a generic function + ``data_transf``. + + Parameters + ---------- + data_transf : Callable (pd.DataFrame -> pd.DataFrame), optional + A function that transforms the data to plot before plotting. + It receives a dataframe whose rows represent events and whose columns + represent the regions, respectively. + By default, the data is not transformed. + plot_kwargs + Keyword arguments passed to the ``DataFrame.plot.bar`` method. + + Returns + ------- + ax : matplotlib.axes.Axes + The plot axis returned by ``DataFrame.plot.bar``. + + """ + # Data preparation + data, impact = self.input.impact_to_aligned_df(self.impact) + values = (impact + 1) / (data + 1) # Avoid division by zero + values = values.transform(np.log10) + + # Transform data + values = data_transf(values) + + # Default plot settings + annot = plot_kwargs.pop("annot", True) + vmax = plot_kwargs.pop("vmax", 3) + vmin = plot_kwargs.pop("vmin", -vmax) + center = plot_kwargs.pop("center", 0) + fmt = plot_kwargs.pop("fmt", ".1f") + cmap = plot_kwargs.pop("cmap", "RdBu_r") + cbar_kws = plot_kwargs.pop( + "cbar_kws", {"label": r"Model Error $\log_{10}(\mathrm{Impact})$"} + ) + + return sns.heatmap( + values, + annot=annot, + vmin=vmin, + vmax=vmax, + center=center, + fmt=fmt, + cmap=cmap, + cbar_kws=cbar_kws, + **plot_kwargs, + ) + + +@dataclass +class Optimizer(ABC): + """Abstract base class (interface) for an optimization + + This defines the interface for optimizers in CLIMADA. New optimizers can be created + by deriving from this class and overriding at least the :py:meth:`run` method. + + Attributes + ---------- + input : Input + The input object for the optimization task. See :py:class:`Input`. + """ + + input: Input + + def _target_func(self, data: pd.DataFrame, predicted: pd.DataFrame) -> Number: + """Target function for the optimizer + + The default version of this function simply returns the value of the cost + function evaluated on the arguments. + + Parameters + ---------- + data : pandas.DataFrame + The reference data used for calibration. By default, this is + :py:attr:`Input.data`. + predicted : pandas.DataFrame + The impact predicted by the data calibration after it has been transformed + into a dataframe by :py:attr:`Input.impact_to_dataframe`. + + Returns + ------- + The value of the target function for the optimizer. + """ + return self.input.cost_func(data, predicted) + + 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_creator`. + + In this default version, the method simply returns its keyword arguments as + mapping. Override this method if the optimizer used *does not* represent + parameters as key-value pairs. + + Parameters + ---------- + kwargs + The parameters as key-value pairs. + + Returns + ------- + The parameters as key-value pairs. + """ + return kwargs + + def _opt_func(self, *args, **kwargs) -> Number: + """The optimization function iterated by the optimizer + + This function takes arbitrary arguments from the optimizer, generates a new set + of impact functions from it, computes the impact, and finally calculates the + target function value and returns it. + + Parameters + ---------- + args, kwargs + Arbitrary arguments from the optimizer, including parameters + + Returns + ------- + Target function value for the given arguments + """ + # Create the impact function set from a new parameter estimate + params = self._kwargs_to_impact_func_creator(*args, **kwargs) + impf_set = self.input.impact_func_creator(**params) + + # Compute the impact + impact = ImpactCalc( + exposures=self.input.exposure, + impfset=impf_set, + hazard=self.input.hazard, + ).impact(**self.input.impact_calc_kwds) + + # Transform to DataFrame, align, and compute target function + data_aligned, impact_df_aligned = self.input.impact_to_aligned_df( + impact, fillna=0 + ) + return self._target_func(data_aligned, impact_df_aligned) + + @abstractmethod + def run(self, **opt_kwargs) -> Output: + """Execute the optimization""" diff --git a/climada/util/calibrate/bayesian_optimizer.py b/climada/util/calibrate/bayesian_optimizer.py new file mode 100644 index 0000000000..98fe302c03 --- /dev/null +++ b/climada/util/calibrate/bayesian_optimizer.py @@ -0,0 +1,851 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- +Calibration with Bayesian Optimization +""" + +from dataclasses import dataclass, InitVar, field +from typing import Mapping, Optional, Any, Union, List, Tuple +from numbers import Number +from itertools import combinations, repeat +from collections import deque, namedtuple +import logging +from pathlib import Path + +import pandas as pd +import numpy as np +import matplotlib as mpl +import matplotlib.pyplot as plt +import matplotlib.axes as maxes +import matplotlib.patches as mpatches +import matplotlib.ticker as mticker +from bayes_opt import BayesianOptimization, Events, UtilityFunction, ScreenLogger +from bayes_opt.target_space import TargetSpace + +from .base import Input, Output, Optimizer, OutputEvaluator + + +LOGGER = logging.getLogger(__name__) + + +@dataclass +class _FakeConstraint: + """Fake the behavior of the constrait for cycling the BayesianOutputOptimizer""" + + results: np.ndarray + + @property + def lb(self): + """Return the lower bound""" + return np.array([0]) + + def allowed(self, values): + """Return if the values are allowed. This only mocks the true behavior""" + if self.results.shape != values.shape: + raise ValueError("Inserting wrong constraint values") + return self.results + + +def select_best( + p_space_df: pd.DataFrame, + cost_limit: float, + absolute: bool = True, + cost_col=("Calibration", "Cost Function"), +) -> pd.DataFrame: + """Select the best parameter space samples defined by a cost function limit + + The limit is a factor of the minimum value relative to itself (``absolute=True``) or + to the range of cost function values (``absolute=False``). A ``cost_limit`` of 0.1 + will select all rows where the cost function is within + + - 110% of the minimum value if ``absolute=True``. + - 10% of the range between minimum and maximum cost function value if + ``absolute=False``. + + Parameters + ---------- + p_space_df : pd.DataFrame + The parameter space to select from. + cost_limit : float + The limit factor used for selection. + absolute : bool, optional + Whether the limit factor is applied to the minimum value (``True``) or the range + of values (``False``). Defaults to ``True``. + cost_col : Column specifier, optional + The column indicating cost function values. Defaults to + ``("Calibration", "Cost Function")``. + + Returns + ------- + pd.DataFrame + A subselection of the input data frame. + """ + min_val = p_space_df[cost_col].min() + cost_range = min_val if absolute else p_space_df[cost_col].max() - min_val + max_val = min_val + cost_range * cost_limit + return p_space_df.loc[p_space_df[cost_col] <= max_val] + + +@dataclass +class BayesianOptimizerOutput(Output): + """Output of a calibration with :py:class:`BayesianOptimizer` + + Attributes + ---------- + p_space : bayes_opt.target_space.TargetSpace + The parameter space sampled by the optimizer. + """ + + p_space: TargetSpace + + def p_space_to_dataframe(self): + """Return the sampled parameter space as pandas.DataFrame + + Returns + ------- + pandas.DataFrame + Data frame whose columns are the parameter values and the associated cost + function value (``Cost Function``) and whose rows are the optimizer + iterations. + """ + # 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 + + def to_hdf5(self, filepath: Union[Path, str], mode: str = "x"): + """Write this output to an H5 file""" + # Write base class information + super().to_hdf5(filepath=filepath, mode=mode) + + # Write parameter space + p_space_df = self.p_space_to_dataframe() + p_space_df.to_hdf(filepath, mode="a", key="p_space") + + @classmethod + def from_hdf5(cls, filepath: Union[Path, str]): + """Read BayesianOptimizerOutput from an H5 file + + Warning + ------- + This results in an object with broken :py:attr:`p_space` object. Do not further + modify this parameter space. This function is only intended to load the + parameter space again for analysis/plotting. + """ + output = Output.from_hdf5(filepath) + p_space_df = pd.read_hdf(filepath, mode="r", key="p_space") + p_space_df["Calibration", "Target"] = -p_space_df[ + "Calibration", "Cost Function" + ] + + # Reorganize data + bounds = {param: (np.nan, np.nan) for param in p_space_df["Parameters"].columns} + constraint = None + if "Constraints Function" in p_space_df["Calibration"].columns: + constraint = _FakeConstraint( + p_space_df["Calibration", "Allowed"].to_numpy() + ) + + p_space = TargetSpace( + target_func=lambda x: x, + pbounds=bounds, + constraint=constraint, + allow_duplicate_points=True, + ) + for _, row in p_space_df.iterrows(): + constraint_value = ( + None + if constraint is None + else row["Calibration", "Constraints Function"] + ) + p_space.register( + params=row["Parameters"].to_numpy(), + target=row["Calibration", "Target"], + constraint_value=constraint_value, + ) + + return cls(params=output.params, target=output.target, p_space=p_space) + + def plot_p_space( + self, + p_space_df: Optional[pd.DataFrame] = None, + x: Optional[str] = None, + y: Optional[str] = None, + min_def: Optional[Union[str, Tuple[str, str]]] = "Cost Function", + min_fmt: str = "x", + min_color: str = "r", + **plot_kwargs, + ) -> Union[maxes.Axes, List[maxes.Axes]]: + """Plot the parameter space as scatter plot(s) + + Produce a scatter plot where each point represents a parameter combination + sampled by the optimizer. The coloring represents the cost function value. + If there are more than two parameters in the input data frame, this method will + produce one plot for each combination of two parameters. + Explicit parameter names to plot can be given via the ``x`` and ``y`` arguments. + If no data frame is provided as argument, the output of + :py:meth:`p_space_to_dataframe` is used. + + Parameters + ---------- + p_space_df : pd.DataFrame, optional + The parameter space to plot. Defaults to the one returned by + :py:meth:`p_space_to_dataframe` + x : str, optional + The parameter to plot on the x-axis. If ``y`` is *not* given, this will plot + ``x`` against all other parameters. + y : str, optional + The parameter to plot on the y-axis. If ``x`` is *not* given, this will plot + ``y`` against all other parameters. + min_def : str, optional + The name of the column in ``p_space_df`` defining which parameter set + represents the minimum, which is plotted separately. Defaults to + ``"Cost Function"``. Set to ``None`` to avoid plotting the minimum. + min_fmt : str, optional + Plot format string for plotting the minimum. Defaults to ``"x"``. + min_color : str, optional + Color for plotting the minimum. Defaults to ``"r"`` (red). + """ + # pylint: disable=invalid-name + + 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 = ("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", + x=x, + y=y, + c=c, + s=s, + cmap=cmap, + **plot_kwargs, + ) + + # Plot the minimum + if min_def is not None: + best = p_space_df.loc[p_space_df.idxmin()[min_def]] + ax.plot(best[x], best[y], min_fmt, color=min_color) + + return ax + + # Option 0: Only one parameter + params = p_space_df["Parameters"].columns.to_list() + if len(params) < 2: + # 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: + return plot_single(x, y) + + # Option 2: Combination of all + iterable = combinations(params, 2) + # Option 3: Fix one and iterate over all others + if x is not None: + params.remove(x) + iterable = zip(repeat(x), params) + elif y is not None: + params.remove(y) + iterable = zip(params, repeat(y)) + + # Iterate over parameter combinations + return [plot_single(p_first, p_second) for p_first, p_second in iterable] + + +Improvement = namedtuple( + "Improvement", ["iteration", "sample", "random", "target", "improvement"] +) + + +class StopEarly(Exception): + """An exception for stopping an optimization iteration early""" + + pass + + +@dataclass(eq=False) +class BayesianOptimizerController(object): + """A class for controlling the iterations of a :py:class:`BayesianOptimizer`. + + Each iteration in the optimizer consists of a random sampling of the parameter space + with :py:attr:`init_points` steps, followed by a Gaussian process sampling with + :py:attr:`n_iter` steps. During the latter, the :py:attr:`kappa` parameter is + reduced to reach :py:attr:`kappa_min` at the end of the iteration. The iteration is + stopped prematurely if improvements of the buest guess are below + :py:attr:`min_improvement` for :py:attr:`min_improvement_count` consecutive times. + At the beginning of the next iteration, :py:attr:`kappa` is reset to its original + value. + + Optimization stops if :py:attr:`max_iterations` is reached or if an entire iteration + saw now improvement. + + Attributes + ---------- + init_points : int + Number of randomly sampled points during each iteration. + n_iter : int + Maximum number of points using Gaussian process sampling during each iteration. + min_improvement : float + Minimal relative improvement. If improvements are below this value + :py:attr:`min_improvement_count` times, the iteration is stopped. + min_improvement_count : int + Number of times the :py:attr:`min_improvement` must be undercut to stop the + iteration. + kappa : float + Parameter controlling exploration of the upper-confidence-bound acquisition + function of the sampling algorithm. Lower values mean less exploration of the + parameter space and more exploitation of local information. This value is + reduced throughout one iteration, reaching :py:attr:`kappa_min` at the + last iteration step. + kappa_min : float + Minimal value of :py:attr:`kappa` after :py:attr:`n_iter` steps. + max_iterations : int + Maximum number of iterations before optimization is stopped, irrespective of + convergence. + utility_func_kwargs + Further keyword arguments to the ``bayes_opt.UtilityFunction``. + """ + + # Init attributes + init_points: int + n_iter: int + min_improvement: float = 1e-3 + min_improvement_count: int = 2 + kappa: float = 2.576 + kappa_min: float = 0.1 + max_iterations: int = 10 + utility_func_kwargs: dict[str, Union[int, float, str]] = field(default_factory=dict) + + # Other attributes + kappa_decay: float = field(init=False, default=0.96) + steps: int = field(init=False, default=0) + iterations: int = field(init=False, default=0) + _improvements: deque[Improvement] = field(init=False, default_factory=deque) + _last_it_improved: int = 0 + _last_it_end: int = 0 + + def __post_init__(self): + """Set the decay factor for :py:attr:`kappa`.""" + 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): + """Create a controller from a calibration input + + This uses the number of parameters to determine the appropriate values for + :py:attr:`init_points` and :py:attr:`n_iter`. Both values are set to + :math:`b^N`, where :math:`b` is the ``sampling_base`` parameter and :math:`N` + is the number of estimated parameters. + + Parameters + ---------- + inp : Input + Input to the calibration + sampling_base : float, optional + Base for determining the sample size. Increase this for denser sampling. + Defaults to 4. + kwargs + Keyword argument for the default constructor. + """ + num_params = len(inp.bounds) + init_points = round(sampling_base**num_params) + n_iter = round(sampling_base**num_params) + return cls(init_points=init_points, n_iter=n_iter, **kwargs) + + @property + def _previous_max(self): + """Return the maximum target value observed""" + if not self._improvements: + return -np.inf + return self._improvements[-1].target + + def optimizer_params(self) -> dict[str, Union[int, float, str, UtilityFunction]]: + """Return parameters for the optimizer + + In the current implementation, these do not change. + """ + return { + "init_points": self.init_points, + "n_iter": self.n_iter, + "acquisition_function": UtilityFunction( + kappa=self.kappa, + kappa_decay=self.kappa_decay, + **self.utility_func_kwargs, + ), + } + + def _is_random_step(self) -> bool: + """Return true if we sample randomly instead of Bayesian""" + return (self._last_it_end + self.steps) < self.init_points + + def _append_improvement(self, target): + """Append a new improvement to the deque""" + impr = np.inf + if self._improvements: + impr = (self._improvements[-1].target / target) - 1 + + self._improvements.append( + Improvement( + sample=self.steps, + iteration=self.iterations, + target=target, + improvement=impr, + random=self._is_random_step(), + ) + ) + + def _is_new_max(self, instance): + """Determine if a guessed value is the new maximum""" + instance_max = instance.max + if not instance_max or instance_max.get("target") is None: + # During constrained optimization, there might not be a maximum + # value since the optimizer might've not encountered any points + # that fulfill the constraints. + return False + + if instance_max["target"] > self._previous_max: + return True + + return False + + def _maybe_stop_early(self, instance): + """Throw if we want to stop this iteration early""" + # Create sequence of last improvements + last_improvements = [ + self._improvements[-idx] + for idx in np.arange( + min(self.min_improvement_count, len(self._improvements)) + ) + + 1 + ] + if ( + # Same iteration + np.unique([impr.iteration for impr in last_improvements]).size == 1 + # Not random + and not any(impr.random for impr in last_improvements) + # Less than min improvement + and all( + impr.improvement < self.min_improvement for impr in last_improvements + ) + ): + LOGGER.info("Minimal improvement. Stop iteration.") + instance.dispatch(Events.OPTIMIZATION_END) + raise StopEarly() + + 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 + iteration will be stopped early. + + For end events, check if any improvement occured. If not, stop the optimization. + + Parameters + ---------- + event : bayes_opt.Events + The event descriptor + instance : bayes_opt.BayesianOptimization + Optimization instance triggering the event + + Raises + ------ + StopEarly + If the optimization only achieves minimal improvement, stop the iteration + early with this exception. + StopIteration + If an entire iteration did not achieve improvement, stop the optimization. + """ + if event == Events.OPTIMIZATION_STEP: + new_max = self._is_new_max(instance) + if new_max: + self._append_improvement(instance.max["target"]) + + self.steps += 1 + + # NOTE: Must call this after incrementing the step + if new_max: + self._maybe_stop_early(instance) + + if event == Events.OPTIMIZATION_END: + self.iterations += 1 + # Stop if we do not improve anymore + if ( + self._last_it_end > 0 + and self._last_it_improved == self._improvements[-1].iteration + ): + LOGGER.info("No improvement. Stop optimization.") + raise StopIteration() + + self._last_it_improved = self._improvements[-1].iteration + self._last_it_end = self.steps + + def improvements(self) -> pd.DataFrame: + """Return improvements as nicely formatted data + + Returns + ------- + improvements : pd.DataFrame + """ + return pd.DataFrame.from_records( + data=[impr._asdict() for impr in self._improvements] + ).set_index("sample") + + +@dataclass +class BayesianOptimizer(Optimizer): + """An optimization using ``bayes_opt.BayesianOptimization`` + + This optimizer reports the target function value for each parameter set and + *maximizes* that value. Therefore, a higher target function value is better. + The cost function, however, is still minimized: The target function is defined as + the inverse of the cost function. + + For details on the underlying optimizer, see + https://github.com/bayesian-optimization/BayesianOptimization. + + Parameters + ---------- + 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 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 + Allow the optimizer to sample the same points in parameter space multiple times. + This may happen if the parameter space is tightly bound or constrained. Defaults + to ``True``. + bayes_opt_kwds : dict + Additional keyword arguments passed to the ``BayesianOptimization`` constructor. + + Notes + ----- + The following requirements apply to the parameters of + :py:class:`~climada.util.calibrate.base.Input` when using this class: + + bounds + Setting :py:attr:`~climada.util.calibrate.base.Input.bounds` is required + because the optimizer first "explores" the bound parameter space and then + narrows its search to regions where the cost function is low. + constraints + Must be an instance of ``scipy.minimize.LinearConstraint`` or + ``scipy.minimize.NonlinearConstraint``. See + https://github.com/bayesian-optimization/BayesianOptimization/blob/master/examples/constraints.ipynb + for further information. Supplying contraints is optional. + + Attributes + ---------- + optimizer : bayes_opt.BayesianOptimization + The optimizer instance of this class. + """ + + 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, random_state, allow_duplicate_points, bayes_opt_kwds): + """Create optimizer""" + if bayes_opt_kwds is None: + bayes_opt_kwds = {} + + if self.input.bounds is None: + raise ValueError("Input.bounds is required for this optimizer") + + self.optimizer = BayesianOptimization( + f=self._opt_func, + pbounds=self.input.bounds, + constraint=self.input.constraints, + random_state=random_state, + allow_duplicate_points=allow_duplicate_points, + **bayes_opt_kwds, + ) + + 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: + """Execute the optimization + + ``BayesianOptimization`` *maximizes* a target function. Therefore, this class + inverts the cost function and used that as target function. The cost function is + still minimized. + + Parameters + ---------- + controller : BayesianOptimizerController + The controller instance used to set the optimization iteration parameters. + opt_kwargs + Further keyword arguments passed to ``BayesianOptimization.maximize``. + + Returns + ------- + output : BayesianOptimizerOutput + 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 + break + + # Return output + opt = self.optimizer.max + return BayesianOptimizerOutput( + params=opt["params"], + target=opt["target"], + p_space=self.optimizer.space, + ) + + +@dataclass +class BayesianOptimizerOutputEvaluator(OutputEvaluator): + """Evaluate the output of :py:class:`BayesianOptimizer`. + + Parameters + ---------- + input : Input + The input object for the optimization task. + output : BayesianOptimizerOutput + The output object returned by the Bayesian optimization task. + + Raises + ------ + TypeError + If :py:attr:`output` is not of type :py:class:`BayesianOptimizerOutput` + """ + + output: BayesianOptimizerOutput + + def __post_init__(self): + """Check output type and call base class post_init""" + if not isinstance(self.output, BayesianOptimizerOutput): + raise TypeError("'output' must be type BayesianOptimizerOutput") + + super().__post_init__() + + def plot_impf_variability( + self, + p_space_df: Optional[pd.DataFrame] = None, + plot_haz: bool = True, + plot_opt_kws: Optional[dict] = None, + plot_impf_kws: Optional[dict] = None, + plot_hist_kws: Optional[dict] = None, + plot_axv_kws: Optional[dict] = None, + ): + """Plot impact function variability with parameter combinations of + almost equal cost function values + + Args: + p_space_df (pd.DataFrame, optional): Parameter space to plot functions from. + If ``None``, this uses the space returned by + :py:meth:`~BayesianOptimizerOutput.p_space_to_dataframe`. Use + :py:func:`select_best` for a convenient subselection of parameters close + to the optimum. + plot_haz (bool, optional): Whether or not to plot hazard intensity + distibution. Defaults to False. + plot_opt_kws (dict, optional): Keyword arguments for optimal impact + function plot. Defaults to None. + plot_impf_kws (dict, optional): Keyword arguments for all impact + function plots. Defaults to None. + plot_hist_kws (dict, optional): Keyword arguments for hazard + intensity histogram plot. Defaults to None. + plot_axv_kws (dict, optional): Keyword arguments for hazard intensity range + plot (axvspan). + """ + + # Initialize plot keyword arguments + if plot_opt_kws is None: + plot_opt_kws = {} + if plot_impf_kws is None: + plot_impf_kws = {} + if plot_hist_kws is None: + plot_hist_kws = {} + if plot_axv_kws is None: + plot_axv_kws = {} + + # Retrieve hazard type and parameter space + haz_type = self.input.hazard.haz_type + if p_space_df is None: + p_space_df = self.output.p_space_to_dataframe() + + # Set plot defaults + colors = mpl.colormaps["tab20"].colors + lw = plot_opt_kws.pop("lw", 2) + label_opt = plot_opt_kws.pop("label", "Optimal Function") + color_opt = plot_opt_kws.pop("color", colors[0]) + zorder_opt = plot_opt_kws.pop("zorder", 4) + + label_impf = plot_impf_kws.pop("label", "All Functions") + color_impf = plot_impf_kws.pop("color", colors[1]) + alpha_impf = plot_impf_kws.pop("alpha", 0.5) + zorder_impf = plot_impf_kws.pop("zorder", 3) + + # get number of impact functions and create a plot for each + n_impf = len(self.impf_set.get_func(haz_type=haz_type)) + axes = [] + + for impf_idx in range(n_impf): + _, ax = plt.subplots() + + # Plot best-fit impact function + best_impf = self.impf_set.get_func(haz_type=haz_type)[impf_idx] + ax.plot( + best_impf.intensity, + best_impf.mdd * best_impf.paa * 100, + color=color_opt, + lw=lw, + zorder=zorder_opt, + label=label_opt, + **plot_opt_kws, + ) + + # Plot all impact functions within 'cost_func_diff' % of best estimate + for idx, (_, row) in enumerate(p_space_df.iterrows()): + label_temp = label_impf if idx == 0 else None + + temp_impf_set = self.input.impact_func_creator(**row["Parameters"]) + temp_impf = temp_impf_set.get_func(haz_type=haz_type)[impf_idx] + + ax.plot( + temp_impf.intensity, + temp_impf.mdd * temp_impf.paa * 100, + color=color_impf, + alpha=alpha_impf, + zorder=zorder_impf, + label=label_temp, + ) + + handles, _ = ax.get_legend_handles_labels() + ax.set( + xlabel=f"Intensity ({self.input.hazard.units})", + ylabel="Mean Damage Ratio (MDR)", + xlim=(min(best_impf.intensity), max(best_impf.intensity)), + ) + ax.yaxis.set_major_formatter(mticker.PercentFormatter(xmax=100)) + + # Plot hazard intensity value distributions + if plot_haz: + haz_vals = self.input.hazard.intensity[ + :, self.input.exposure.gdf[f"centr_{haz_type}"] + ].data + + # Plot defaults + bins = plot_hist_kws.pop("bins", 40) + label_hist = plot_hist_kws.pop("label", "Hazard Intensity") + color_hist = plot_hist_kws.pop("color", colors[2]) + color_axv = plot_axv_kws.pop("color", colors[3]) + alpha_axv = plot_axv_kws.pop("alpha", 0.5) + + # Histogram plot + ax2 = ax.twinx() + ax.set_facecolor("none") + ax.set_zorder(2) + ax2.set_zorder(1) + ax2.axvspan( + haz_vals.min(), haz_vals.max(), color=color_axv, alpha=alpha_axv + ) + ax2.hist( + haz_vals, + bins=bins, + color=color_hist, + label=label_hist, + **plot_hist_kws, + ) + ax2.set_ylabel("Exposure Points", color=color_hist) + + handles = handles + [ + mpatches.Patch(color=color_hist, label=label_hist), + mpatches.Patch(color=color_axv, label=f"{label_hist} Range"), + ] + ax.yaxis.label.set_color(color_opt) + ax.tick_params(axis="y", colors=color_opt) + ax2.tick_params(axis="y", colors=color_hist) + + ax.legend(handles=handles) + axes.append(ax) + + if n_impf > 1: + return axes + + return ax diff --git a/climada/util/calibrate/scipy_optimizer.py b/climada/util/calibrate/scipy_optimizer.py new file mode 100644 index 0000000000..12d46b661d --- /dev/null +++ b/climada/util/calibrate/scipy_optimizer.py @@ -0,0 +1,127 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- +Calibration with scipy.minimize +""" + +from dataclasses import dataclass +from typing import Mapping, Any, Dict, List + +import numpy as np +from scipy.optimize import minimize, OptimizeResult + +from .base import Output, Optimizer + + +@dataclass +class ScipyMinimizeOptimizerOutput(Output): + """Output of a calibration with :py:class:`ScipyMinimizeOptimizer` + + Attributes + ---------- + result : scipy.minimize.OptimizeResult + The OptimizeResult instance returned by ``scipy.optimize.minimize``. + """ + + result: OptimizeResult + + +@dataclass +class ScipyMinimizeOptimizer(Optimizer): + """An optimization using scipy.optimize.minimize + + By default, this optimizer uses the ``"trust-constr"`` method. This + is advertised as the most general minimization method of the ``scipy`` package and + supports bounds and constraints on the parameters. Users are free to choose + any method of the catalogue, but must be aware that they might require different + input parameters. These can be supplied via additional keyword arguments to + :py:meth:`run`. + + See https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html + for details. + + Parameters + ---------- + input : Input + The input data for this optimizer. Supported data types for + :py:attr:`constraint` might vary depending on the minimization method used. + """ + + def __post_init__(self): + """Create a private attribute for storing the parameter names""" + self._param_names: List[str] = list() + + 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)) + + def _select_by_param_names(self, mapping: Mapping[str, Any]) -> List[Any]: + """Return a list of entries from a map with matching keys or ``None``""" + return [mapping.get(key) for key in self._param_names] + + def run(self, **opt_kwargs) -> ScipyMinimizeOptimizerOutput: + """Execute the optimization + + Parameters + ---------- + params_init : Mapping (str, Number) + The initial guess for all parameters as key-value pairs. + method : str, optional + The minimization method applied. Defaults to ``"trust-constr"``. + See https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html + for details. + kwargs + Additional keyword arguments passed to ``scipy.optimize.minimize``. + + Returns + ------- + output : ScipyMinimizeOptimizerOutput + The output of the optimization. The + :py:attr:`ScipyMinimizeOptimizerOutput.result` attribute stores the + associated ``scipy.optimize.OptimizeResult`` instance. + """ + # Parse kwargs + try: + params_init = opt_kwargs.pop("params_init") + except KeyError as err: + raise RuntimeError( + "ScipyMinimizeOptimizer.run requires 'params_init' mapping as argument" + ) from err + method = opt_kwargs.pop("method", "trust-constr") + + # Store names to rebuild dict when the minimize iterator returns an array + self._param_names = list(params_init.keys()) + + # Transform bounds to match minimize input + bounds = ( + self._select_by_param_names(self.input.bounds) + if self.input.bounds is not None + else None + ) + + x0 = np.array(list(params_init.values())) # pylint: disable=invalid-name + res = minimize( + fun=self._opt_func, + x0=x0, + bounds=bounds, + constraints=self.input.constraints, + method=method, + **opt_kwargs, + ) + + params = dict(zip(self._param_names, res.x.flat)) + return ScipyMinimizeOptimizerOutput(params=params, target=res.fun, result=res) diff --git a/climada/util/calibrate/test/__init__.py b/climada/util/calibrate/test/__init__.py new file mode 100644 index 0000000000..d527ff4958 --- /dev/null +++ b/climada/util/calibrate/test/__init__.py @@ -0,0 +1,17 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +""" diff --git a/climada/util/calibrate/test/test_base.py b/climada/util/calibrate/test/test_base.py new file mode 100644 index 0000000000..f7b5fb69f4 --- /dev/null +++ b/climada/util/calibrate/test/test_base.py @@ -0,0 +1,265 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- +Tests for calibration module +""" + +import unittest +from unittest.mock import patch, create_autospec, MagicMock +from tempfile import TemporaryDirectory +from pathlib import Path + +import numpy as np +import numpy.testing as npt +import pandas as pd +from scipy.sparse import csr_matrix + +from climada.entity import Exposures, ImpactFunc, ImpactFuncSet +from climada.hazard import Hazard, Centroids +from climada.engine import ImpactCalc + +from climada.util.calibrate import Input, OutputEvaluator +from climada.util.calibrate.base import Optimizer, Output + + +class ConcreteOptimizer(Optimizer): + """An instance for testing. Implements 'run' without doing anything""" + + def run(self, **_): + pass + + +def hazard(): + """Create a dummy hazard instance""" + lat = [1, 2] + lon = [0, 1] + centroids = Centroids.from_lat_lon(lat=lat, lon=lon) + event_id = np.array([1, 3, 10]) + intensity = csr_matrix([[1, 0.1], [2, 0.2], [3, 2]]) + return Hazard( + event_id=event_id, centroids=centroids, intensity=intensity, haz_type="TEST" + ) + + +def exposure(): + """Create a dummy exposure instance""" + return Exposures( + data=dict( + longitude=[0, 1, 100], + latitude=[1, 2, 50], + value=[1, 0.1, 1e6], + impf_TEST=[1, 1, 1], + ) + ) + + +class TestInputPostInit(unittest.TestCase): + """Test the post_init dunder method of Input""" + + def setUp(self): + """Create default input instance""" + # Create the hazard instance + self.hazard = hazard() + + # Create the exposure instance + self.exposure = exposure() + + # Create some data + self.data_events = [10, 3] + 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() + + def test_post_init_calls(self): + """Test if post_init calls stuff correctly using mocks""" + # Create mocks + exposure_mock = create_autospec(Exposures()) + + # Default + Input( + hazard=self.hazard, + exposure=exposure_mock, + data=self.data, + cost_func=self.cost_func, + 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() + + # Default + Input( + hazard=self.hazard, + exposure=exposure_mock, + data=self.data, + cost_func=self.cost_func, + impact_func_creator=self.impact_func_gen, + impact_to_dataframe=self.impact_to_dataframe, + assign_centroids=False, + ) + exposure_mock.assign_centroids.assert_not_called() + + def test_post_init(self): + """Test if post_init results in a sensible hazard and exposure""" + # Create input + input = Input( + hazard=self.hazard, + exposure=self.exposure, + data=self.data, + cost_func=self.cost_func, + impact_func_creator=self.impact_func_gen, + impact_to_dataframe=self.impact_to_dataframe, + ) + + # Check centroids assignment + npt.assert_array_equal(input.exposure.gdf["centr_TEST"], [0, 1, -1]) + + def test_align_impact(self): + """Check alignment of impact and data""" + input = Input( + hazard=hazard(), + exposure=exposure(), + data=pd.DataFrame( + data={"col1": [1, 2], "col2": [2, 3]}, index=[0, 1], dtype="float" + ), + cost_func=lambda x, y: (x + y).sum(axis=None), + impact_func_creator=lambda _: ImpactFuncSet([ImpactFunc()]), + # Mock the dataframe creation by ignoring the argument + impact_to_dataframe=lambda _: pd.DataFrame( + data={"col2": [1, 2], "col3": [2, 3]}, index=[1, 2], dtype="float" + ), + ) + + # missing_data_value = np.nan + data_aligned, impact_df_aligned = input.impact_to_aligned_df(None) + data_aligned_test = pd.DataFrame( + data={ + "col1": [1, 2, np.nan], + "col2": [2, 3, np.nan], + "col3": [np.nan, np.nan, np.nan], + }, + index=[0, 1, 2], + dtype="float", + ) + pd.testing.assert_frame_equal(data_aligned, data_aligned_test) + impact_df_aligned_test = pd.DataFrame( + data={"col1": [0, 0, 0], "col2": [0, 1, 0], "col3": [0, 0, 0]}, + index=[0, 1, 2], + dtype="float", + ) + pd.testing.assert_frame_equal(impact_df_aligned, impact_df_aligned_test) + + # Check fillna + data_aligned, impact_df_aligned = input.impact_to_aligned_df(None, fillna=0) + pd.testing.assert_frame_equal(data_aligned, data_aligned_test.fillna(0)) + pd.testing.assert_frame_equal(impact_df_aligned, impact_df_aligned_test) + + # Different missing data value + input.missing_data_value = 0.0 + data_aligned, impact_df_aligned = input.impact_to_aligned_df(None) + pd.testing.assert_frame_equal(data_aligned, data_aligned_test.fillna(0)) + pd.testing.assert_frame_equal( + impact_df_aligned, + pd.DataFrame( + data={"col1": [0, 0, 0], "col2": [0, 1, 2], "col3": [0, 2, 3]}, + index=[0, 1, 2], + dtype="float", + ), + ) + + # Check error + with self.assertRaisesRegex(ValueError, "NaN values computed in impact!"): + input.impact_to_dataframe = lambda _: pd.DataFrame( + data={"col1": [np.nan], "col2": [2, 3]}, index=[1, 2] + ) + data_aligned, impact_df_aligned = input.impact_to_aligned_df(None) + + +class TestOptimizer(unittest.TestCase): + """Base class for testing optimizers. Creates an input mock""" + + def setUp(self): + """Mock the input""" + self.input = Input( + hazard=hazard(), + exposure=exposure(), + data=pd.DataFrame(data={"col1": [1, 2], "col2": [2, 3]}, index=[0, 1]), + cost_func=lambda x, y: (x + y).sum(axis=None), + impact_func_creator=lambda _: ImpactFuncSet([ImpactFunc()]), + impact_to_dataframe=lambda x: x.impact_at_reg(), + ) + self.optimizer = ConcreteOptimizer(self.input) + + +class TestOuput(unittest.TestCase): + """Test the optimizer output""" + + def test_cycle(self): + """Test if cycling an output object works""" + output = Output(params={"p1": 1.0, "p_2": 10}, target=2.0) + with TemporaryDirectory() as tmpdir: + outfile = Path(tmpdir, "out.h5") + output.to_hdf5(outfile) + self.assertTrue(outfile.is_file()) + output_2 = Output.from_hdf5(outfile) + self.assertEqual(output.target, output_2.target) + self.assertDictEqual(output.params, output_2.params) + +class TestOutputEvaluator(unittest.TestCase): + """Test the output evaluator""" + + def setUp(self): + """Create Input and Output""" + self.input = Input( + hazard=hazard(), + exposure=exposure(), + data=pd.DataFrame(), + impact_func_creator=MagicMock(), + # Should not be called + impact_to_dataframe=lambda _: None, + cost_func=lambda _: None, + ) + self.output = Output(params={"p1": 1, "p2": 2.0}, target=0.0) + + @patch("climada.util.calibrate.base.ImpactCalc", autospec=True) + def test_init(self, mock): + """Test initialization""" + self.input.exposure.value_unit = "my_unit" + self.input.impact_func_creator.return_value = "impact_func" + impact_calc_mock = MagicMock(ImpactCalc) + mock.return_value = impact_calc_mock + impact_calc_mock.impact = MagicMock() + impact_calc_mock.impact.return_value = "impact" + + out_eval = OutputEvaluator(self.input, self.output) + self.assertEqual(out_eval.impf_set, "impact_func") + self.assertEqual(out_eval.impact, "impact") + self.assertEqual(out_eval._impact_label, "Impact [my_unit]") + + self.input.impact_func_creator.assert_called_with(p1=1, p2=2.0) + mock.assert_called_with(self.input.exposure, "impact_func", self.input.hazard) + + +# Execute Tests +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestInputPostInit) + TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestOptimizer)) + TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestOutputEvaluator)) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada/util/calibrate/test/test_bayesian_optimizer.py b/climada/util/calibrate/test/test_bayesian_optimizer.py new file mode 100644 index 0000000000..71af9b3545 --- /dev/null +++ b/climada/util/calibrate/test/test_bayesian_optimizer.py @@ -0,0 +1,363 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- +Tests for calibration module +""" + +import unittest +from unittest.mock import patch, MagicMock +from tempfile import TemporaryDirectory +from pathlib import Path + +import numpy as np +import numpy.testing as npt +import pandas as pd +from bayes_opt import BayesianOptimization, Events +from scipy.optimize import NonlinearConstraint +from matplotlib.axes import Axes + +from climada.util.calibrate import Input, BayesianOptimizer, BayesianOptimizerController +from climada.util.calibrate.bayesian_optimizer import ( + Improvement, + StopEarly, + BayesianOptimizerOutput, +) + +from .test_base import hazard, exposure + + +def input(): + """Return a mocked input""" + return Input( + hazard=hazard(), + exposure=exposure(), + data=pd.DataFrame(data={"col1": [1, 2], "col2": [2, 3]}, index=[0, 1]), + cost_func=MagicMock(), + impact_func_creator=MagicMock(), + impact_to_dataframe=MagicMock(), + ) + + +class TestBayesianOptimizerController(unittest.TestCase): + """Tests for the controller of the BayesianOptimizer""" + + def setUp(self): + """Create a optimization instance""" + self.bayes_opt = BayesianOptimization( + f=lambda x: -(x**2), + pbounds={"x": (-10, 10)}, + constraint=NonlinearConstraint(fun=lambda x: x, lb=-0.5, ub=np.inf), + verbose=0, + allow_duplicate_points=True, + ) + + def _make_step(self, x, controller): + self.bayes_opt.probe({"x": x}, lazy=False) + controller.update(Events.OPTIMIZATION_STEP, self.bayes_opt) + + def test_kappa_decay(self): + """Check correct values for kappa_decay""" + contr = BayesianOptimizerController(0, kappa=3, kappa_min=3, n_iter=10) + self.assertAlmostEqual(contr.kappa_decay, 1.0) + + contr = BayesianOptimizerController(0, kappa=3, kappa_min=1, n_iter=10) + self.assertAlmostEqual(contr.kappa * (contr.kappa_decay**10), 1.0) + + def test_from_input(self): + """Check if input data is used correctly to set up controller""" + inp = input() + inp.bounds = {"a": (0, 1), "b": (1, 2)} + + contr = BayesianOptimizerController.from_input(inp, sampling_base=3, kappa=3) + self.assertEqual(contr.kappa, 3) + self.assertEqual(contr.init_points, 3**2) + self.assertEqual(contr.n_iter, 3**2) + + def test_optimizer_params(self): + """Test BayesianOptimizerController.optimizer_params""" + contr = BayesianOptimizerController( + 1, 2, kappa=3, utility_func_kwargs={"xi": 1.11, "kind": "ei"} + ) + result = contr.optimizer_params() + + self.assertDictContainsSubset( + { + "init_points": 1, + "n_iter": 2, + }, + result, + ) + util_func = result["acquisition_function"] + self.assertEqual(util_func.kappa, 3) + self.assertEqual(util_func._kappa_decay, contr._calc_kappa_decay()) + self.assertEqual(util_func.xi, 1.11) + self.assertEqual(util_func.kind, "ei") + + def test_update_step(self): + """Test the update for STEP events""" + contr = BayesianOptimizerController(3, 2) + + # Regular step + self._make_step(3.0, contr) + self.assertEqual(contr.steps, 1) + best = Improvement( + iteration=0, sample=0, random=True, target=-9.0, improvement=np.inf + ) + self.assertEqual(len(contr._improvements), 1) + self.assertTupleEqual(contr._improvements[-1], best) + + # Step that has no effect due to constraints + self._make_step(-2.0, contr) + self.assertEqual(contr.steps, 2) + self.assertEqual(len(contr._improvements), 1) + self.assertTupleEqual(contr._improvements[-1], best) + + # Step that is not new max + self._make_step(4.0, contr) + self.assertEqual(contr.steps, 3) + self.assertEqual(len(contr._improvements), 1) + self.assertTupleEqual(contr._improvements[-1], best) + + # Two minimal increments, therefore we should see a StopEarly + self._make_step(2.999, contr) + self.assertEqual(contr.steps, 4) + self.assertEqual(len(contr._improvements), 2) + + with self.assertRaises(StopEarly): + self._make_step(2.998, contr) + self.assertEqual(contr.steps, 5) + self.assertEqual(len(contr._improvements), 3) + + def test_update_end(self): + """Test the update for END events""" + contr = BayesianOptimizerController(1, 1) + + # One step with improvement, then stop + self._make_step(3.0, contr) + contr.update(Events.OPTIMIZATION_END, self.bayes_opt) + self.assertEqual(contr._last_it_improved, 0) + self.assertEqual(contr._last_it_end, 1) + + # One step with no more improvement + self._make_step(4.0, contr) + with self.assertRaises(StopIteration): + contr.update(Events.OPTIMIZATION_END, self.bayes_opt) + + def test_improvements(self): + """Test ouput of BayesianOptimizerController.improvements""" + contr = BayesianOptimizerController(1, 1) + self._make_step(3.0, contr) + self._make_step(2.0, contr) + contr.update(Events.OPTIMIZATION_END, self.bayes_opt) + self._make_step(2.5, contr) # Not better + self._make_step(1.0, contr) + contr.update(Events.OPTIMIZATION_END, self.bayes_opt) + self._make_step(-0.9, contr) # Constrained + + df = contr.improvements() + pd.testing.assert_frame_equal( + df, + pd.DataFrame.from_dict( + data={ + "iteration": [0, 0, 1], + "sample": [0, 1, 3], + "random": [True, False, False], + "target": [-9.0, -4.0, -1.0], + "improvement": [np.inf, 9.0 / 4.0 - 1, 3.0], + } + ).set_index("sample"), + ) + + +class TestBayesianOptimizerOutput(unittest.TestCase): + """Tests for the output class of BayesianOptimizer""" + + def setUp(self): + """Create a default output""" + bayes_opt = BayesianOptimization( + f=lambda x: -(x**2), + pbounds={"x": (-10, 10)}, + constraint=NonlinearConstraint(fun=lambda x: x, lb=-0.5, ub=np.inf), + verbose=0, + allow_duplicate_points=True, + ) + bayes_opt.probe({"x": 2.0}, lazy=False) + bayes_opt.probe({"x": 1.0}, lazy=False) + bayes_opt.probe({"x": -0.9}, lazy=False) + + self.output = BayesianOptimizerOutput( + params=bayes_opt.max["params"], + target=bayes_opt.max["target"], + p_space=bayes_opt.space, + ) + + def test_p_space_to_dataframe(self): + """""" + self.assertDictEqual(self.output.params, {"x": 1.0}) + self.assertEqual(self.output.target, -1.0) + + idx = pd.MultiIndex.from_tuples( + [ + ("Parameters", "x"), + ("Calibration", "Cost Function"), + ("Calibration", "Constraints Function"), + ("Calibration", "Allowed"), + ] + ) + df = pd.DataFrame(data=None, columns=idx) + df["Parameters", "x"] = [2.0, 1.0, -0.9] + df["Calibration", "Cost Function"] = [4.0, 1.0, 0.9**2] + df["Calibration", "Constraints Function"] = df["Parameters", "x"] + df["Calibration", "Allowed"] = [True, True, False] + df.index.rename("Iteration", inplace=True) + pd.testing.assert_frame_equal(self.output.p_space_to_dataframe(), df) + + def test_cycle(self): + """Check if the output can be cycled to produce the same p_space_df""" + with TemporaryDirectory() as tmpdir: + outpath = Path(tmpdir, "file.h5") + self.output.to_hdf5(outpath) + self.assertTrue(outpath.is_file()) + + output = BayesianOptimizerOutput.from_hdf5(outpath) + pd.testing.assert_frame_equal( + self.output.p_space_to_dataframe(), output.p_space_to_dataframe() + ) + + def test_plot_p_space(self): + """Test plotting of different parameter combinations""" + # Mock data + mock_df = pd.DataFrame( + { + ("Parameters", "param1"): [1, 2, 3], + ("Parameters", "param2"): [4, 5, 6], + ("Parameters", "param3"): [7, 8, 9], + ("Calibration", "Cost Function"): [10, 15, 20], + } + ) + + # Create instance of BayesianOptimizerOutput + output = BayesianOptimizerOutput(params=None, target=None, p_space=None) + + # Mock the p_space_to_dataframe method + with patch.object( + BayesianOptimizerOutput, "p_space_to_dataframe", return_value=mock_df + ): + # Plot all + axes = output.plot_p_space() + self.assertEqual(len(axes), 3) + for ax in axes: + self.assertIsInstance(ax, Axes) + self.assertTrue(ax.has_data()) + + # # Keep x fixed + axes = output.plot_p_space(x="param2") + self.assertEqual(len(axes), 2) + for ax in axes: + self.assertEqual(ax.get_xlabel(), "(Parameters, param2)") + + # # Keep y fixed + axes = output.plot_p_space(y="param1") + self.assertEqual(len(axes), 2) + for ax in axes: + self.assertEqual(ax.get_ylabel(), "(Parameters, param1)") + + # # Plot single combination + ax = output.plot_p_space(x="param2", y="param1") + self.assertIsInstance(ax, Axes) + self.assertEqual(ax.get_xlabel(), "(Parameters, param2)") + self.assertEqual(ax.get_ylabel(), "(Parameters, param1)") + + # Plot single parameter + ax = output.plot_p_space( + pd.DataFrame( + { + ("Parameters", "param1"): [1, 2, 3], + ("Calibration", "Cost Function"): [10, 15, 20], + } + ) + ) + self.assertIsInstance(ax, Axes) + self.assertEqual(ax.get_xlabel(), "(Parameters, param1)") + self.assertEqual(ax.get_ylabel(), "(Parameters, none)") + + +class TestBayesianOptimizer(unittest.TestCase): + """Tests for the optimizer based on bayes_opt.BayesianOptimization""" + + def setUp(self): + """Mock the input""" + self.input = input() + + @patch("climada.util.calibrate.base.ImpactCalc", autospec=True) + 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_creator' through 'run' because it is + private. + """ + # Create stubs + self.input.bounds = {"x_2": (0, 1), "x 1": (1, 2)} + self.input.cost_func.return_value = 1.0 + self.optimizer = BayesianOptimizer(self.input) + self.controller = BayesianOptimizerController( + init_points=2, n_iter=1, max_iterations=1 + ) + + # Call 'run' + with patch.object(self.input, "impact_to_aligned_df") as align: + align.return_value = (None, None) + self.optimizer.run(self.controller) + + # Check call to '_kwargs_to_impact_func_gen' + 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()) + + @patch("climada.util.calibrate.base.ImpactCalc", autospec=True) + def test_target_func(self, _): + """Test if cost function is transformed correctly + + We test the method '_target_func' through 'run' because it is private + """ + self.input.bounds = {"x_2": (0, 1), "x 1": (1, 2)} + self.input.cost_func.side_effect = [1.0, -1.0] + self.optimizer = BayesianOptimizer(self.input) + self.controller = BayesianOptimizerController( + init_points=1, n_iter=1, max_iterations=1 + ) + + # Call 'run' + with patch.object(self.input, "impact_to_aligned_df") as align: + align.return_value = (None, None) + output = self.optimizer.run(self.controller) + + # Check target space + npt.assert_array_equal(output.p_space.target, [-1.0, 1.0]) + + +# Execute Tests +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestBayesianOptimizer) + TESTS.addTests( + unittest.TestLoader().loadTestsFromTestCase(TestBayesianOptimizerOutput) + ) + TESTS.addTests( + unittest.TestLoader().loadTestsFromTestCase(TestBayesianOptimizerController) + ) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada/util/calibrate/test/test_scipy_optimizer.py b/climada/util/calibrate/test/test_scipy_optimizer.py new file mode 100644 index 0000000000..01b04ea5f7 --- /dev/null +++ b/climada/util/calibrate/test/test_scipy_optimizer.py @@ -0,0 +1,147 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- +Tests for calibration module +""" + +import unittest +from unittest.mock import patch, MagicMock, call +from typing import Optional, List + +import numpy as np +import numpy.testing as npt +import pandas as pd +from scipy.optimize import OptimizeResult + +from climada.util.calibrate import Input, ScipyMinimizeOptimizer + +from .test_base import hazard, exposure + + +class TestScipyMinimizeOptimizer(unittest.TestCase): + """Tests for the optimizer based on scipy.optimize.minimize""" + + def setUp(self): + """Mock the input""" + self.input = Input( + hazard=hazard(), + exposure=exposure(), + data=pd.DataFrame(data={"col1": [1, 2], "col2": [2, 3]}, index=[0, 1]), + cost_func=MagicMock(), + impact_func_creator=MagicMock(), + impact_to_dataframe=MagicMock(), + ) + + self.optimizer = ScipyMinimizeOptimizer(self.input) + + @patch("climada.util.calibrate.base.ImpactCalc", autospec=True) + 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_creator' through 'run' because it is + private. + """ + # Create stubs + self.input.constraints = None + self.input.bounds = None + self.input.cost_func.return_value = 1.0 + + # Call 'run', make sure that 'minimize' is only with these parameters + params_init = {"x_2": 1, "x 1": 2, "x_3": 3} # NOTE: Also works with whitespace + with patch.object(self.input, "impact_to_aligned_df") as align: + align.return_value = (None, None) + self.optimizer.run(params_init=params_init, options={"maxiter": 1}) + + # Check call to '_kwargs_to_impact_func_creator' + first_call = self.input.impact_func_creator.call_args_list[0] + self.assertEqual(first_call, call(**params_init)) + + # Check error on missing kwargs + with self.assertRaisesRegex( + RuntimeError, "ScipyMinimizeOptimizer.run requires 'params_init'" + ): + self.optimizer.run(options={"maxiter": 1}) + + def test_output(self): + """Check output reporting""" + params_init = {"x_2": 1, "x 1": 2, "x_3": 3} + target_func_value = 1.12 + self.input.constraints = None + self.input.bounds = None + + # Mock the optimization function and call 'run' + with patch.object(self.optimizer, "_opt_func") as opt_func_mock: + opt_func_mock.return_value = target_func_value + output = self.optimizer.run(params_init=params_init, options={"maxiter": 1}) + + # Assert output + self.assertListEqual(list(output.params.keys()), list(params_init.keys())) + npt.assert_allclose(list(output.params.values()), list(params_init.values())) + self.assertEqual(output.target, target_func_value) + self.assertIsInstance(output.result, OptimizeResult) + + # NOTE: For scipy.optimize, this means no error + self.assertTrue(output.result.success) + + @patch("climada.util.calibrate.scipy_optimizer.minimize", autospec=True) + def test_bounds_select(self, minimize_mock): + """Test the _select_by_param_names method + + We test the method '_select_by_param_names' through 'run' because it is private. + """ + + def assert_bounds_in_call(bounds: Optional[List]): + """Check if scipy.optimize.minimize was called with the expected kwargs""" + call_kwargs = minimize_mock.call_args.kwargs + print(minimize_mock.call_args) + + if bounds is None: + self.assertIsNone(call_kwargs["bounds"]) + else: + self.assertListEqual(call_kwargs["bounds"], bounds) + + # Initialize params and mock return value + params_init = {"x_2": 1, "x_1": 2, "x_3": 3} + minimize_mock.return_value = OptimizeResult( + x=np.array(list(params_init.values())), fun=0, success=True + ) + + # Set constraints and bounds to None (default) + self.input.bounds = None + + # Call the optimizer (constraints and bounds are None) + self.optimizer.run(params_init=params_init) + self.assertListEqual(self.optimizer._param_names, list(params_init.keys())) + minimize_mock.assert_called_once() + assert_bounds_in_call(None) + minimize_mock.reset_mock() + + # Set new bounds and constraints + self.input.bounds = {"x_1": "a", "x_4": "b", "x_3": (1, 2)} + self.input.constraints = {"x_5": [1], "x_2": 2} + + # Call the optimizer + self.optimizer.run(params_init=params_init) + self.assertListEqual(self.optimizer._param_names, list(params_init.keys())) + minimize_mock.assert_called_once() + assert_bounds_in_call(bounds=[None, "a", (1, 2)]) + + +# Execute Tests +if __name__ == "__main__": + TESTS = unittest.TestLoader().loadTestsFromTestCase(TestScipyMinimizeOptimizer) + unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/doc/climada/climada.util.calibrate.rst b/doc/climada/climada.util.calibrate.rst new file mode 100644 index 0000000000..e56cdb6b8b --- /dev/null +++ b/doc/climada/climada.util.calibrate.rst @@ -0,0 +1,32 @@ +================================== +Impact Function Calibration Module +================================== + +Base Classes +------------ + +Generic classes for defining the data structures of this module. + +.. automodule:: climada.util.calibrate.base + :members: + :private-members: + +Bayesian Optimizer +------------------ + +Calibration based on Bayesian optimization. + +.. automodule:: climada.util.calibrate.bayesian_optimizer + :members: + :show-inheritance: + :inherited-members: abc.ABC + +Scipy Optimizer +--------------- + +Calibration based on the ``scipy.optimize`` module. + +.. automodule:: climada.util.calibrate.scipy_optimizer + :members: + :show-inheritance: + :inherited-members: abc.ABC diff --git a/doc/climada/climada.util.rst b/doc/climada/climada.util.rst index 298ab3b87c..820fd43f7f 100644 --- a/doc/climada/climada.util.rst +++ b/doc/climada/climada.util.rst @@ -9,6 +9,14 @@ climada\.util\.api\_client module :undoc-members: :show-inheritance: +climada\.util\.calibrate module +------------------------------- + +.. toctree:: + :maxdepth: 1 + + climada.util.calibrate + climada\.util\.checker module ----------------------------- diff --git a/doc/index.rst b/doc/index.rst index 6afee00eaf..732290eeee 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -85,6 +85,7 @@ Jump right in: Impact Uncertainty Quantification tutorial/climada_engine_Forecast + tutorial/climada_util_calibrate Google Earth Engine tutorial/climada_util_api_client diff --git a/doc/joss/calibration-module/impfs.png b/doc/joss/calibration-module/impfs.png new file mode 100644 index 0000000000..317a5bbea4 Binary files /dev/null and b/doc/joss/calibration-module/impfs.png differ diff --git a/doc/joss/calibration-module/paper.bib b/doc/joss/calibration-module/paper.bib new file mode 100644 index 0000000000..bbb47f1e70 --- /dev/null +++ b/doc/joss/calibration-module/paper.bib @@ -0,0 +1,315 @@ + +@article{aznar-siguan_climada_2019, + title = {{CLIMADA} v1: a global weather and climate risk assessment platform}, + volume = {12}, + issn = {1991-959X}, + shorttitle = {{CLIMADA} v1}, + url = {https://www.geosci-model-dev.net/12/3085/2019/}, + doi = {10.5194/gmd-12-3085-2019}, + abstract = {{\textless}p{\textgreater}{\textless}strong{\textgreater}Abstract.{\textless}/strong{\textgreater} The need for assessing the risk of extreme weather events is ever increasing. In addition to quantification of risk today, the role of aggravating factors such as high population growth and changing climate conditions matters, too. We present the open-source software CLIMADA (CLIMate ADAptation), which integrates hazard, exposure, and vulnerability to compute the necessary metrics to assess risk and to quantify socio-economic impact. The software design is modular and object oriented, offering a simple collaborative framework and a parallelization strategy which allows for scalable computations on clusters. CLIMADA supports multi-hazard calculations and provides an event-based probabilistic approach that is globally consistent for a wide range of resolutions, suitable for whole-country to detailed local studies. This paper uses the platform to estimate and contextualize the damage of hurricane Irma in the Caribbean in 2017. Most of the affected islands are non-sovereign countries and also rely on overseas support in case disaster strikes. The risk assessment performed for this region, based on remotely available data available shortly before or hours after landfall of Irma, proves to be close to reported damage and hence demonstrates a method to provide readily available impact estimates and associated uncertainties in real time.{\textless}/p{\textgreater}}, + language = {English}, + number = {7}, + urldate = {2020-05-11}, + journal = {Geoscientific Model Development}, + author = {Aznar-Siguan, Gabriela and Bresch, David N.}, + month = jul, + year = {2019}, + keywords = {Python, TC}, + pages = {3085--3097}, + file = {Aznar-Siguan and Bresch - 2019 - CLIMADA v1 a global weather and climate risk asse.pdf:/Users/ldr.riedel/Zotero/storage/DP4G5785/Aznar-Siguan and Bresch - 2019 - CLIMADA v1 a global weather and climate risk asse.pdf:application/pdf;Full Text PDF:/Users/ldr.riedel/Zotero/storage/CKM943SM/Aznar-Siguan and Bresch - 2019 - CLIMADA v1 a global weather and climate risk asse.pdf:application/pdf;Full Text PDF:/Users/ldr.riedel/Zotero/storage/F78V926K/Aznar-Siguan and Bresch - 2019 - CLIMADA v1 a global weather and climate risk asse.pdf:application/pdf;Snapshot:/Users/ldr.riedel/Zotero/storage/P2QX8GI5/2019.html:text/html;Snapshot:/Users/ldr.riedel/Zotero/storage/IXJQUUZX/2019.html:text/html}, +} + +@article{bresch_climada_2021, + title = {{CLIMADA} v1.4.1: towards a globally consistent adaptation options appraisal tool}, + volume = {14}, + issn = {1991-959X}, + shorttitle = {{CLIMADA} v1.4.1}, + url = {https://gmd.copernicus.org/articles/14/351/2021/}, + doi = {10.5194/gmd-14-351-2021}, + abstract = {{\textless}p{\textgreater}{\textless}strong class="journal-contentHeaderColor"{\textgreater}Abstract.{\textless}/strong{\textgreater} Climate change is a fact; therefore, adaptation to a changing environment is a necessity. Adaptation is ultimately local, yet similar challenges pose themselves to decision-makers all across the globe and on all levels. The Economics of Climate Adaptation (ECA) methodology has established an economic framework to fully integrate risk and reward perspectives of different stakeholders, underpinned by the CLIMADA (CLIMateADAptation) impact modeling platform. We present an extension of the latter to appraise adaption options in a consistent fashion in order to provide decision-makers from the local to the global level with the necessary facts to identify the most effective instruments to meet the adaptation challenge. We apply the open-source Python implementation to a tropical cyclone impact case study in the Caribbean, using openly available data. This allows us to prioritize a small basket of adaptation options, namely green and gray infrastructure options as well as behavioral measures and risk transfer, and permits inter-island comparisons. In Anguilla, for example, mangroves avert simulated damages more than 4 times the cost estimated for mangrove restoration, whereas the enforcement of building codes is shown to be effective in the Turks and Caicos Islands in a moderate-climate-change scenario. For all islands, cost-effective measures reduce the cost of risk transfer, which covers the damage of high-impact events that cannot be cost-effectively prevented by other measures. This extended version of the CLIMADA platform has been designed to enable risk assessment and options appraisal in a modular form and occasionally bespoke fashion yet with the high reusability of common functionalities to foster the usage of the platform in interdisciplinary studies and international collaboration.{\textless}/p{\textgreater}}, + language = {English}, + number = {1}, + urldate = {2021-12-24}, + journal = {Geoscientific Model Development}, + author = {Bresch, David N. and Aznar-Siguan, Gabriela}, + month = jan, + year = {2021}, + note = {Publisher: Copernicus GmbH}, + pages = {351--363}, + file = {Full Text PDF:/Users/ldr.riedel/Zotero/storage/4HDPKWKF/Bresch and Aznar-Siguan - 2021 - CLIMADA v1.4.1 towards a globally consistent adap.pdf:application/pdf;Snapshot:/Users/ldr.riedel/Zotero/storage/RUUA7987/gmd-14-351-2021.html:text/html}, +} + +@article{virtanen_scipy_2020, + title = {{SciPy} 1.0: {Fundamental} {Algorithms} for {Scientific} {Computing} in {Python}}, + volume = {17}, + doi = {10.1038/s41592-019-0686-2}, + journal = {Nature Methods}, + author = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and Haberland, Matt and Reddy, Tyler and Cournapeau, David and Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and Bright, Jonathan and van der Walt, St{\'e}fan J. and Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and Kern, Robert and Larson, Eric and Carey, C J and Polat, {\.I}lhan and Feng, Yu and Moore, Eric W. and VanderPlas, Jake and Laxalde, Denis and Perktold, Josef and Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and Harris, Charles R. and Archibald, Anne M. and Ribeiro, Ant{\^o}nio H. and Pedregosa, Fabian and van Mulbregt, Paul and {SciPy 1.0 Contributors}}, + year = {2020}, + pages = {261--272}, +} + +@misc{nogueira_bayesian_2014, + title = {Bayesian {Optimization}: {Open} source constrained global optimization tool for {Python}}, + url = {https://github.com/fmfn/BayesianOptimization}, + author = {Nogueira, Fernando}, + year = {2014}, +} + +@techreport{cred_2022_2023, + address = {Brussels}, + type = {Emergency Events Database (EM-DAT) Annual Report}, + title = {2022 {Disasters} in {Numbers}}, + url = {https://cred.be/sites/default/files/2022_EMDAT_report.pdf}, + institution = {Centre for Research on the Epidemiology of Disasters (CRED)}, + author = {{CRED}}, + year = {2023}, + file = {CRED - 2023 - 2022. Disasters in Numbers.pdf:/Users/ldr.riedel/Zotero/storage/JQRMMVC2/CRED - 2023 - 2022. Disasters in Numbers.pdf:application/pdf}, +} + +@article{eberenz_regional_2021, + title = {Regional tropical cyclone impact functions for globally consistent risk assessments}, + volume = {21}, + issn = {1561-8633}, + url = {https://nhess.copernicus.org/articles/21/393/2021/}, + doi = {10.5194/nhess-21-393-2021}, + abstract = {Assessing the adverse impacts caused by tropical cyclones has become increasingly important as both climate change and human coastal development increase the damage potential. In order to assess tropical cyclone risk, direct economic damage is frequently modeled based on hazard intensity, asset exposure, and vulnerability, the latter represented by impact functions. In this study, we show that assessing tropical cyclone risk on a global level with one single impact function calibrated for the USA {\textendash} which is a typical approach in many recent studies {\textendash} is problematic, biasing the simulated damage by as much as a factor of 36 in the north West Pacific. Thus, tropical cyclone risk assessments should always consider regional differences in vulnerability, too. This study proposes a calibrated model to adequately assess tropical cyclone risk in different regions by fitting regional impact functions based on reported damage data. Applying regional calibrated impact functions within the risk modeling framework CLIMADA (CLIMate ADAptation) at a resolution of 10 km worldwide, we find global annual average direct damage caused by tropical cyclones to range from USD 51 up to USD 121 billion (value in 2014, 1980{\textendash}2017) with the largest uncertainties in the West Pacific basin where the calibration results are the least robust. To better understand the challenges in the West Pacific and to complement the global perspective of this study, we explore uncertainties and limitations entailed in the modeling setup for the case of the Philippines. While using wind as a proxy for tropical cyclone hazard proves to be a valid approach in general, the case of the Philippines reveals limitations of the model and calibration due to the lack of an explicit representation of sub-perils such as storm surges, torrential rainfall, and landslides. The globally consistent methodology and calibrated regional impact functions are available online as a Python package ready for application in practical contexts like physical risk disclosure and providing more credible information for climate adaptation studies.}, + language = {English}, + number = {1}, + urldate = {2021-01-29}, + journal = {Natural Hazards and Earth System Sciences}, + author = {Eberenz, Samuel and L{\"u}thi, Samuel and Bresch, David N.}, + month = jan, + year = {2021}, + note = {Publisher: Copernicus GmbH}, + keywords = {global, Hurricane, Impact Functions, TC, tropical cyclones, Typhoon, Vulnerability}, + pages = {393--415}, + file = {eberenz_2021_natural_hazards_and_earth_system_sciences_regional_tropical_cyclone_impact_functions_for_globally_consistent_risk.pdf:/Users/ldr.riedel/Zotero/storage/P3CD2TJT/eberenz_2021_natural_hazards_and_earth_system_sciences_regional_tropical_cyclone_impact_functions_for_globally_consistent_risk.pdf:application/pdf;Full Text PDF:/Users/ldr.riedel/Zotero/storage/URDD6URX/Eberenz et al. - 2020 - Regional tropical cyclone impact functions for glo.pdf:application/pdf;Snapshot:/Users/ldr.riedel/Zotero/storage/KWHT8L7M/2021.html:text/html;Snapshot:/Users/ldr.riedel/Zotero/storage/GR53CKH8/nhess-2020-229.html:text/html}, +} + +@article{fischer_combining_2015, + title = {Combining engineering and data-driven approaches: {Calibration} of a generic fire risk model with data}, + volume = {74}, + issn = {0379-7112}, + shorttitle = {Combining engineering and data-driven approaches}, + url = {https://www.sciencedirect.com/science/article/pii/S0379711215000600}, + doi = {10.1016/j.firesaf.2015.04.008}, + abstract = {Two general approaches may be followed for the development of a fire risk model: statistical models based on observed fire losses can support simple cost-benefit studies but are usually not detailed enough for engineering decision-making. Engineering models, on the other hand, require many assumptions that may result in a biased risk assessment. In two related papers we show how engineering and data-driven modelling can be combined by developing generic risk models that are calibrated to statistical data on observed fire events. The focus of the present paper is on the calibration procedure. A framework is developed that is able to deal with data collection in non-homogeneous portfolios of buildings. Also incomplete data sets containing only little information on each fire event can be used for model calibration. To illustrate the capabilities of the proposed framework, it is applied to the calibration of a generic fire risk model for single family houses to Swiss insurance data. The example demonstrates that the bias in the risk estimation can be strongly reduced by model calibration.}, + urldate = {2023-11-27}, + journal = {Fire Safety Journal}, + author = {Fischer, Katharina and De Sanctis, Gianluca and Kohler, Jochen and Faber, Michael H. and Fontana, Mario}, + month = may, + year = {2015}, + keywords = {Calibration, Fire risk model, Generic risk assessment, Model validation, Probabilistic approach}, + pages = {32--42}, + file = {Full Text:/Users/ldr.riedel/Zotero/storage/J8DRJBIX/Fischer et al. - 2015 - Combining engineering and data-driven approaches .pdf:application/pdf}, +} + +@article{luthi_globally_2021, + title = {Globally consistent assessment of economic impacts of wildfires in {CLIMADA} v2.2}, + url = {https://gmd.copernicus.org/preprints/gmd-2021-192/}, + doi = {10.5194/gmd-2021-192}, + abstract = {In light of the dramatic increase in economic impacts due to wildfires over recent years, the need for globally consistent impact modelling of wildfire damages is ever increasing. Insurance companies, individual households, humanitarian organisations and governmental authorities, as well as investors and portfolio owners, are increasingly required to account for climate-related physical risks. In response to these societal challenges, we present an extension to the open-source and open5 access risk modelling platform CLIMADA (CLImate ADAptation) for modelling economic impacts of wildfires in a globally consistent and spatially explicit approach. All input data is free, public and globally available, ensuring applicability in datascarce regions of the Global South. The model was calibrated at resolutions of 1, 4 and 10 kilometers using information on past wildfire damage reported by the disaster database EM-DAT. Despite the large remaining uncertainties, the model yields sound damage estimates with a model performance well in line with the results of other natural catastrophe impact models, such as for 10 tropical cyclones. To complement the global perspective of this study, we conducted two case studies on the recent mega fires in Chile (2017) and Australia (2020). The model is made available online as part of a Python package, ready for application in practical contexts such as disaster risk assessment, near real time impact estimates or physical climate risk disclosure.}, + language = {en}, + urldate = {2021-10-01}, + author = {L{\"u}thi, Samuel and Aznar-Siguan, Gabriela and Fairless, Christopher and Bresch, David N.}, + month = jul, + year = {2021}, + file = {L{\"u}thi et al. - 2021 - Globally consistent assessment of economic impacts.pdf:/Users/ldr.riedel/Zotero/storage/LFF4PIQF/L{\"u}thi et al. - 2021 - Globally consistent assessment of economic impacts.pdf:application/pdf}, +} + +@misc{gabriela_aznar_siguan_2023_8383171, + title = {{CLIMADA}-project/climada\_python: v4.0.1}, + publisher = {Zenodo}, + author = {Aznar-Siguan, Gabriela and Schmid, Emanuel and Vogt, Thomas and Eberenz, Samuel and Steinmann, Carmen B. and R{\"o}{\"o}sli, Thomas and Yu, Yue and M{\"u}hlhofer, Evelyn and L{\"u}thi, Samuel and Sauer, Inga J. and Hartman, Jan and Kropf, Chahan M. and Guillod, Benoit P. and Stalhandske, Z{\'e}lie and Ciullo, Alessio and Bresch, David N. and Riedel, Lukas and Fairless, Chris and Schmid, Timo and Kam, Pui Man (Mannie) and Colombi, Nicolas and {wjan262} and Meiler, Simona and Villger, Leonie and Portmann, Raphael and Bozzini, Veronica and Stocker, Dario}, + month = sep, + year = {2023}, + doi = {10.5281/zenodo.8383171}, +} + +@article{riedel_fluvial_2024, + title = {Fluvial flood inundation and socio-economic impact model based on open data}, + volume = {17}, + issn = {1991-959X}, + doi = {10.5194/gmd-17-5291-2024}, + abstract = {Fluvial floods are destructive hazards that affect millions of people worldwide each year. Forecasting flood events and their potential impacts therefore is crucial for disaster preparation and mitigation. Modeling flood inundation based on extreme value analysis of river discharges is an alternative to physical models of flood dynamics, which are computationally expensive. We present the implementation of a globally applicable, open-source fluvial flood model within a state-of-the-art risk modeling framework. It uses openly available data to rapidly compute flood inundation footprints of historic and forecasted events for the estimation of associated impacts. For the example of Pakistan, we use this flood model to compute flood depths and extents and employ it to estimate population displacement due to floods. Comparing flood extents to satellite data reveals that incorporating estimated flood protection standards does not necessarily improve the flood footprint computed by the model. We further show that, after calibrating the vulnerability of the impact model to a single event, the estimated displacement caused by past floods is in good agreement with disaster reports. Finally, we demonstrate that this calibrated model is suited for probabilistic impact-based forecasting.}, + language = {English}, + number = {13}, + urldate = {2024-07-10}, + journal = {Geoscientific Model Development}, + author = {Riedel, Lukas and R{\"o}{\"o}sli, Thomas and Vogt, Thomas and Bresch, David N.}, + month = jul, + year = {2024}, + pages = {5291--5308}, +} + +@misc{kam_impact-based_2023, + title = {Impact-{Based} {Forecasting} of {Tropical} {Cyclone}-{Related} {Human} {Displacement} to {Support} {Anticipatory} {Action}}, + url = {https://www.researchsquare.com/article/rs-3682198/v1}, + doi = {10.21203/rs.3.rs-3682198/v1}, + urldate = {2024-04-29}, + author = {Kam, Pui Man and Ciccone, Fabio and Kropf, Chahan and Riedel, Lukas and Fairless, Christopher and Bresch, David}, + month = dec, + year = {2023}, + file = {Full Text PDF:/Users/ldr.riedel/Zotero/storage/HB9QP4MF/Kam et al. - 2023 - Impact-Based Forecasting of Tropical Cyclone-Relat.pdf:application/pdf}, +} + +@article{roosli_towards_2021, + title = {Towards operational impact forecasting of building damage from winter windstorms in {Switzerland}}, + volume = {28}, + issn = {1469-8080}, + url = {https://onlinelibrary.wiley.com/doi/abs/10.1002/met.2035}, + doi = {10.1002/met.2035}, + abstract = {National meteorological and hydrological services issue warnings for severe weather events, typically based on stakeholder-agreed fixed thresholds of meteorological parameters such as wind speeds or precipitation amounts. Yet societal decisions on preventive actions depend on the expected impacts of the weather event. In order to better inform such preventive actions, meteorological services are currently working towards including expected impacts into their warnings. We develop an open-source impact forecasting system for building damage due to winter windstorms in Switzerland. It combines a numerical ensemble weather prediction model with exposure and vulnerability data. This system forecasts expected building damage in Swiss Francs with a 2-day lead time on a 500-m grid or aggregated to administrative regions. We compare the forecasted building damage with insurance claims in the canton of Zurich. The uncertainty of the impact forecasts is large. For the majority of days with severe winter windstorm damage, the mean forecasted damage was in the right order of magnitude, with one missed event and one false alarm. For thunderstorms and foehn storms, the rate of missed events and false alarms is much higher, most likely related to the limited meteorological forecast skill. Such impact forecasts can inform decision makers on preventive actions, such as allocating emergency response and other assets. Additionally, impact forecasts could also help communicating the severity of the upcoming event to the general public as well as indirectly help meteorological forecasters with taking warning decisions.}, + language = {en}, + number = {6}, + urldate = {2022-01-12}, + journal = {Meteorological Applications}, + author = {R{\"o}{\"o}sli, Thomas and Appenzeller, Christof and Bresch, David N.}, + year = {2021}, + note = {\_eprint: https://onlinelibrary.wiley.com/doi/pdf/10.1002/met.2035}, + keywords = {building damage, impact forecast, impact modelling, impact-based warning, numerical weather prediction}, + pages = {e2035}, + file = {Full Text PDF:/Users/ldr.riedel/Zotero/storage/I8WT8G7K/R{\"o}{\"o}sli et al. - 2021 - Towards operational impact forecasting of building.pdf:application/pdf}, +} + +@article{welker_comparing_2021, + title = {Comparing an insurer's perspective on building damages with modelled damages from pan-{European} winter windstorm event sets: a case study from {Zurich}, {Switzerland}}, + volume = {21}, + issn = {1561-8633}, + url = {https://nhess.copernicus.org/articles/21/279/2021/}, + doi = {10.5194/nhess-21-279-2021}, + language = {English}, + number = {1}, + urldate = {2024-04-29}, + journal = {Natural Hazards and Earth System Sciences}, + author = {Welker, Christoph and R{\"o}{\"o}sli, Thomas and Bresch, David N.}, + month = jan, + year = {2021}, + note = {Publisher: Copernicus GmbH}, + pages = {279--299}, + file = {Full Text PDF:/Users/ldr.riedel/Zotero/storage/4V3IQZIA/Welker et al. - 2021 - Comparing an insurer's perspective on building dam.pdf:application/pdf}, +} + +@article{Schmid2023a, + title = {An open-source radar-based hail damage model for buildings and cars}, + url = {https://nhess.copernicus.org/preprints/nhess-2023-158/}, + doi = {10.5194/nhess-2023-158}, + abstract = {{\textless}p{\textgreater}{\textless}strong class="journal-contentHeaderColor"{\textgreater}Abstract.{\textless}/strong{\textgreater} Severe hailstorms cause substantial damages to buildings and vehicles, necessitating the quantification of associated risks. Here, we present a novel open-source hail damage model for buildings and cars based on single-polarization radar data and 250\’000 geolocated hail damage reports in Switzerland from 2002 to 2021. To this end, we conduct a detailed evaluation of different radar-based hail intensity measures at 1 km resolution and find that the maximum expected severe hail size (MESHS) outperforms the other measures, despite a considerable false alarm ratio. Asset-specific hail damage impact functions for buildings and cars are calibrated based on MESHS and incorporated into the open-source risk modelling platform CLIMADA. The model successfully estimates the correct order of magnitude for the number of building damages in 91 \%, their total cost in 77 \%, the number of vehicle damages in 74 \%, and their total cost in 60 \% of over 100 considered large hail events. We found considerable uncertainties in hail damage estimates, which are largely attributable to limitations of radar-based hail detection. Therefore, we explore the usage of crowdsourced hail reports and find substantially improved spatial representation of severe hail for individual events. By highlighting the potential and limitations of radar-based hail size estimates, particularly MESHS, and the utilization of an open-source risk modelling platform, this study represents a significant step towards addressing the gap in risk quantification associated with severe hail events in Switzerland.{\textless}/p{\textgreater}}, + language = {English}, + urldate = {2023-09-27}, + journal = {Natural Hazards and Earth System Sciences Discussions}, + author = {Schmid, Timo and Portmann, Raphael and Villiger, Leonie and Schr{\"o}er, Katharina and Bresch, David N.}, + month = sep, + year = {2023}, + note = {Publisher: Copernicus GmbH}, + pages = {1--38}, + file = {Full Text PDF:/Users/ldr.riedel/Zotero/storage/AT4U3Z3I/Schmid et al. - 2023 - An open-source radar-based hail damage model for b.pdf:application/pdf}, +} + +@book{rougier_risk_2013, + title = {Risk and {Uncertainty} {Assessment} for {Natural} {Hazards}}, + isbn = {978-1-107-00619-5}, + abstract = {Assessment of risk and uncertainty is crucial for natural hazard risk management, facilitating risk communication and informing strategies to successfully mitigate our society's vulnerability to natural disasters. Written by some of the world's leading experts, this book provides a state-of-the-art overview of risk and uncertainty assessment in natural hazards. It presents the core statistical concepts using clearly defined terminology applicable across all types of natural hazards and addresses the full range of sources of uncertainty, the role of expert judgement and the practice of uncertainty elicitation. The core of the book provides detailed coverage of all the main hazard types and concluding chapters address the wider societal context of risk management. This is an invaluable compendium for academic researchers and professionals working in the fields of natural hazards science, risk assessment and management and environmental science and will be of interest to anyone involved in natural hazards policy.}, + language = {en}, + publisher = {Cambridge University Press}, + author = {Rougier, Jonathan and Hill, Lisa J. and Sparks, Robert Stephen John}, + month = feb, + year = {2013}, + keywords = {Science / Environmental Science}, + url = {https://cambridge.org/9781107006195}, +} + +@incollection{smith_human_2014, + address = {Cambridge, United Kingdom and New York, NY, USA}, + title = {Human {Health}: {Impacts}, {Adaptation}, and {Co}-{Benefits}}, + url = {https://www.ipcc.ch/report/ar5/wg2/}, + doi = {10.1017/CBO9781107415379.016}, + booktitle = {Climate {Change} 2014: {Impacts}, {Adaptation}, and {Vulnerability}. {Part} {A}: {Global} and {Sectoral} {Aspects}. {Contribution} of {Working} {Group} {II} to the {Fifth} {Assessment} {Report} of the {Intergovernmental} {Panel} on {Climate} {Change}}, + publisher = {Cambridge University Press}, + author = {Smith, Kirk R. and Woodward, Alistair and Campbell-Lendrum, Diarmid and Chadee, Dave D. and Honda, Yasushi and Liu, Qiyong and Olwoch, Jane M. and Revich, Boris and Sauerborn, Rainer}, + year = {2014}, + pages = {709--754}, +} + +@misc{oasis, + author = {{Oasis LMF Ltd.}}, + title = {Oasis Loss Modelling Framework}, + year = {2024}, + url = {https://oasislmf.github.io/}, +} + +@misc{delforge_em-dat_2023, + title = {{EM}-{DAT}: the {Emergency} {Events} {Database}}, + shorttitle = {{EM}-{DAT}}, + url = {https://www.researchsquare.com/article/rs-3807553/v1}, + doi = {10.21203/rs.3.rs-3807553/v1}, + abstract = {The Emergency Events Database (EM-DAT) compiles global disaster data resulting from both technological and natural hazards. It details the human and economic impacts from 1900 to present, with systematic recording since 1988. Serving the humanitarian, disaster risk reduction, and academic sectors, EM-DAT\&\#039;s transition to open access and increasing climate change concerns have expanded its reach and visibility. The dataset, freely available for non-commercial use, is downloadable as an Excel file. It is categorized by hazard type and standardized by individual disaster events for each country. With over 26,000 unique entries, the database is populated through the monitoring of textual documents and their manual processing. The data collection and validation processes involve systematic daily checks from predefined sources, searches for additional sources, and periodic thematic updates. The evolution of EM-DAT\&\#039;s data content mirrors societal and technological advancements in disaster reporting. Besides these progresses, known inconsistencies and biases in the data quality have been reported. The article acknowledges these issues, highlighting their potential implications for research and decision-making.}, + urldate = {2024-04-29}, + author = {Delforge, Damien and Wathelet, Valentin and Below, Regina and Sofia, Cinzia Lanfredi and Tonnelier, Margo and Loenhout, Joris van and Speybroeck, Niko}, + month = dec, + year = {2023}, + note = {ISSN: 2693-5015}, + file = {Full Text PDF:/Users/ldr.riedel/Zotero/storage/IU9SY5AV/Delforge et al. - 2023 - EM-DAT the Emergency Events Database.pdf:application/pdf}, +} + + +@article{knapp_international_2010, + title = {The {International} {Best} {Track} {Archive} for {Climate} {Stewardship} ({IBTrACS}): {Unifying} {Tropical} {Cyclone} {Data}}, + volume = {91}, + issn = {0003-0007, 1520-0477}, + shorttitle = {The {International} {Best} {Track} {Archive} for {Climate} {Stewardship} ({IBTrACS})}, + url = {https://journals.ametsoc.org/view/journals/bams/91/3/2009bams2755_1.xml}, + doi = {10.1175/2009BAMS2755.1}, + abstract = {The goal of the International Best Track Archive for Climate Stewardship (IBTrACS) project is to collect the historical tropical cyclone best-track data from all available Regional Specialized Meteorological Centers (RSMCs) and other agencies, combine the disparate datasets into one product, and disseminate in formats used by the tropical cyclone community. Each RSMC forecasts and monitors storms for a specific region and annually archives best-track data, which consist of information on a storm's position, intensity, and other related parameters. IBTrACS is a new dataset based on the best-track data from numerous sources. Moreover, rather than preferentially selecting one track and intensity for each storm, the mean position, the original intensities from the agencies, and summary statistics are provided. This article discusses the dataset construction, explores the tropical cyclone climatology from IBTrACS, and concludes with an analysis of uncertainty in the tropical cyclone intensity record.}, + language = {en}, + number = {3}, + urldate = {2022-07-11}, + journal = {Bulletin of the American Meteorological Society}, + author = {Knapp, Kenneth R. and Kruk, Michael C. and Levinson, David H. and Diamond, Howard J. and Neumann, Charles J.}, + month = mar, + year = {2010}, + note = {tex.ids= Knapp2010 +publisher: American Meteorological Society +section: Bulletin of the American Meteorological Society}, + pages = {363--376}, + file = {Full Text PDF:/Users/ldr.riedel/Zotero/storage/VTI5QP8D/Knapp et al. - 2010 - The International Best Track Archive for Climate S.pdf:application/pdf;Full Text PDF:/Users/ldr.riedel/Zotero/storage/STJ7VDN8/Knapp et al. - 2010 - The International Best Track Archive for Climate S.pdf:application/pdf;Snapshot:/Users/ldr.riedel/Zotero/storage/H3CEIX4U/2009bams2755_1.html:text/html}, +} + +@article{holland_revised_2008, + title = {A {Revised} {Hurricane} {Pressure}{\textendash}{Wind} {Model}}, + volume = {136}, + issn = {0027-0644}, + url = {https://journals.ametsoc.org/doi/abs/10.1175/2008MWR2395.1}, + doi = {10.1175/2008MWR2395.1}, + abstract = {A new technique for relating central pressure and maximum winds in tropical cyclones is presented, together with a method of objectively determining a derivative of the Holland b parameter, bs, which relates directly to surface winds and varies with the pressure drop into the cyclone center, intensification rate, latitude, and translation speed. By allowing this bs parameter to vary, a realistic scatter in maximum winds for a given central pressure is obtained. This provides an improvement over traditional approaches that provide a unique wind for each central pressure. It is further recommended that application of the Dvorak satellite-interpretation technique be changed to enable a direct derivation of central pressure. The pressure{\textendash}wind model derived here can then provide the maximum wind estimates. The recent North Atlantic data archive is shown to be largely derived from the use of the Dvorak technique, even when hurricane reconnaissance data are available and Dvorak overestimates maximum winds in this region for the more intense hurricanes. Application to the full North Atlantic hurricane archive confirms the findings by Landsea (1993) of a substantial overestimation of maximum winds between 1950 and 1980; the Landsea corrections do not completely remove this bias.}, + number = {9}, + urldate = {2018-05-16}, + journal = {Monthly Weather Review}, + author = {Holland, Greg}, + month = sep, + year = {2008}, + note = {00158}, + keywords = {TC}, + pages = {3432--3445}, + file = {holland_2008_monthly_weather_review_a_revised_hurricane_pressure{\textendash}wind_model.pdf:/Users/ldr.riedel/Zotero/storage/I9VLDHTK/holland_2008_monthly_weather_review_a_revised_hurricane_pressure{\textendash}wind_model.pdf:application/pdf;Snapshot:/Users/ldr.riedel/Zotero/storage/62ZZVVY9/2008MWR2395.html:text/html}, +} + +@article{eberenz_asset_2020, + title = {Asset exposure data for global physical risk assessment}, + volume = {12}, + issn = {1866-3508}, + url = {https://www.earth-syst-sci-data.net/12/817/2020/}, + doi = {10.5194/essd-12-817-2020}, + abstract = {{\textless}p{\textgreater}{\textless}strong{\textgreater}Abstract.{\textless}/strong{\textgreater} One of the challenges in globally consistent assessments of physical climate risks is the fact that asset exposure data are either unavailable or restricted to single countries or regions. We introduce a global high-resolution asset exposure dataset responding to this challenge. The data are produced using {\textquotedblleft}lit population{\textquotedblright} (LitPop), a globally consistent methodology to disaggregate asset value data proportional to a combination of nightlight intensity and geographical population data. By combining nightlight and population data, unwanted artefacts such as blooming, saturation, and lack of detail are mitigated. Thus, the combination of both data types improves the spatial distribution of macroeconomic indicators. Due to the lack of reported subnational asset data, the disaggregation methodology cannot be validated for asset values. Therefore, we compare disaggregated gross domestic product (GDP) per subnational administrative region to reported gross regional product (GRP) values for evaluation. The comparison for 14 industrialized and newly industrialized countries shows that the disaggregation skill for GDP using nightlights or population data alone is not as high as using a combination of both data types. The advantages of LitPop are global consistency, scalability, openness, replicability, and low entry threshold. The open-source LitPop methodology and the publicly available asset exposure data offer value for manifold use cases, including globally consistent economic disaster risk assessments and climate change adaptation studies, especially for larger regions, yet at considerably high resolution. The code is published on GitHub as part of the open-source software CLIMADA (CLIMate ADAptation) and archived in the ETH Data Archive with the link {\textless}a href="https://doi.org/10.5905/ethz-1007-226"{\textgreater}https://doi.org/10.5905/ethz-1007-226{\textless}/a{\textgreater} (Bresch et al., 2019b). The resulting asset exposure dataset for 224 countries is archived in the ETH Research Repository with the link {\textless}a href="https://doi.org/10.3929/ethz-b-000331316"{\textgreater}https://doi.org/10.3929/ethz-b-000331316{\textless}/a{\textgreater} (Eberenz et al., 2019).{\textless}/p{\textgreater}}, + language = {English}, + number = {2}, + urldate = {2020-05-14}, + journal = {Earth System Science Data}, + author = {Eberenz, Samuel and Stocker, Dario and R{\"o}{\"o}sli, Thomas and Bresch, David N.}, + month = apr, + year = {2020}, + keywords = {Exposure}, + pages = {817--833}, + file = {Full Text PDF:/Users/ldr.riedel/Zotero/storage/IHS57ZPE/Eberenz et al. - 2020 - Asset exposure data for global physical risk asses.pdf:application/pdf;Snapshot:/Users/ldr.riedel/Zotero/storage/PUTYCUM6/2020.html:text/html}, +} diff --git a/doc/joss/calibration-module/paper.md b/doc/joss/calibration-module/paper.md new file mode 100644 index 0000000000..ef8960cd6d --- /dev/null +++ b/doc/joss/calibration-module/paper.md @@ -0,0 +1,144 @@ +--- +title: 'A Module for Calibrating Impact Functions in the Climate Risk Modeling Platform CLIMADA' +tags: + - Python + - climate risk + - impact function + - vulnerability + - optimization +authors: + - name: Lukas Riedel + orcid: 0000-0002-4667-3652 + affiliation: "1, 2" + corresponding: true + - name: Chahan M. Kropf + orcid: 0000-0002-3761-2292 + affiliation: "1, 2" + - name: Timo Schmid + orcid: 0000-0002-6788-2154 + affiliation: "1, 2" +affiliations: + - name: Institute for Environmental Decisions, ETH Zürich, Zürich, Switzerland + index: 1 + - name: Federal Office of Meteorology and Climatology MeteoSwiss, Zürich-Airport, Switzerland + index: 2 +date: 01 May 2024 +bibliography: paper.bib + +--- + +# Summary + +Impact functions model the vulnerability of people and assets exposed to weather and climate hazards. +Given probabilistic hazard event sets or weather forecasts, they enable the computation of associated risks or impacts, respectively. +Because impact functions are difficult to determine on larger spatial and temporal scales of interest, they are often calibrated using hazard, exposure, and impact data from past events. +We present a module for calibrating impact functions based on such data using established calibration techniques like Bayesian optimization. +It is implemented as Python submodule `climada.util.calibrate` of the climate risk modeling platform CLIMADA [@gabriela_aznar_siguan_2023_8383171], and fully integrates into its workflow. + +# Statement of Need + +Natural hazards like storms, floods, droughts, and extreme temperatures will be exacerbated by climate change. +In 2022 alone, weather- and climate-related disasters affected 185 million people and caused economic losses of more than US$ 200 billion [@cred_2022_2023]. +Forecasting the impacts of imminent events as well as determining climate risk according to future socio-economic pathways is crucial for decision-making in societal, humanitarian, political, socio-economic, and ecological issues [@smith_human_2014]. +One major source of uncertainty in such computations is the vulnerability [@rougier_risk_2013]. +Typically modeled as impact function[^1] that yields the percentage of affected exposure depending on hazard intensity, vulnerability is difficult to determine *a priori*. +Using hazard footprints, exposure, and recorded impacts from past events, researchers therefore employ calibration techniques to estimate unknown impact functions and use these functions for future risk projections or impact forecasts [@eberenz_regional_2021; @luthi_globally_2021; @welker_comparing_2021; @roosli_towards_2021; @kam_impact-based_2023; @Schmid2023a; @riedel_fluvial_2024]. + +CLIMADA is a widely used, open-source framework for calculating weather- and climate-related impacts and risks [@aznar-siguan_climada_2019], and for appraising the benefits of adaptation options [@bresch_climada_2021]. +The aforementioned studies calibrate impact functions with different optimization algorithms within the CLIMADA ecosystem, but lack a consistent implementation of these algorithms. +OASIS LMF, another well-adopted, open-source loss modeling framework, also does not feature tools for impact function calibration, and regards vulnerability solely as model input [@oasis]. +With the proposed calibration module, we aim at unifying the approaches to impact function calibration, while providing an extensible structure that can be easily adjusted to particular applications. + +# Module Structure + +Calibrating the parameters of impact functions can be a complex task involving highly non-linear objective functions, constrained and ambiguous parameters, and parameter spaces with multiple local optima. +To support different iterative optimization algorithms, we implemented an `Optimizer` base class from which concrete optimizers employing different algorithms are derived. +All optimizers receive data through a common `Input` object, which provides all necessary information for the calibration task. +This enables users to quickly switch between optimizers without disrupting their workflow. +Pre-defined optimizers are based on the `scipy.optimize` module [@virtanen_scipy_2020] and the `BayesianOptimization` package [@nogueira_bayesian_2014]. +The latter is especially useful for calibration tasks because it supports constraints and only requires bounds of the parameter space as prior information. +We provide a `BayesianOptimizerController` that iteratively explores and "exploits" the parameter space to find the global optimum and stop the optimization process then. +This only requires minimal user input for indicating the sampling density. + +# Example Code + +Given a hazard event set, and exposure, and associated impact data in the appropriate CLIMADA data structures, the calibration input can quickly be defined. +Users have to supply a cost function, the parameter space bounds, a function that creates an impact function from the estimated parameter set, and a function that transforms a CLIMADA `Impact` object into the same structure as the input impact data. + +```python +import pandas as pd +from sklearn.metrics import mean_squared_log_error + +from climada.hazard import Hazard +from climada.entity import Exposure, ImpactFuncSet, ImpfTropCyclone +from climada.engine import Impact + +from climada.util.calibrate import ( + Input, + BayesianOptimizer, + BayesianOptimizerController, + BayesianOptimizerOutputEvaluator, + select_best, +) + +def calibrate(hazard: Hazard, exposure: Exposure, impact_data: pd.DataFrame): + """Calibrate an impact function with BayesianOptimizer""" + + def impact_function_tropical_cyclone(v_half: float, scale: float) -> ImpactFuncSet: + """Return an impact function set for tropical cyclones given two parameters + + This assumes that the input data relates to tropical cyclone asset damages. + """ + return ImpactFuncSet( + [ImpfTropCyclone.from_emanuel_usa(v_half=v_half, scale=scale)] + ) + + def aggregate_impact(impact: Impact) -> pd.DataFrame: + """Aggregate modeled impacts per region ID and return as DataFrame""" + return impact.impact_at_reg() + + # Prepare the calibration input + calibration_input = Input( + hazard=hazard + exposure=exposure, + data=impact_data, + bounds={"v_half": (25.8, 150), "scale": (0.01, 1)}, + cost_func=mean_squared_log_error, + impact_func_creator=impact_function_tropical_cyclone, + impact_to_dataframe=aggregate_impact, + ) + + # Execute the calibration + controller = BayesianOptimizerController.from_input(calibration_input) + optimizer = BayesianOptimizer(calibration_input) + calibration_output = optimizer.run(controller) + + # Store calibration results + calibration_output.to_hdf5("calibration.h5") + + # Plot the parameter space + calibration_output.plot_p_space(x="v_half", y="scale") + + # Plot best 3% of calibrated impact functions in terms of cost function value + output_evaluator = BayesianOptimizerOutputEvaluator( + calibration_input, calibration_output + ) + output_evaluator.plot_impf_variability(select_best(p_space_df, 0.03)) +``` + +Within the CLIMADA documentation, we provide a tutorial Jupyter script[^2] demonstrating the setup of all calibration data for executing code like the one above. +In this tutorial, we use data on tropical cyclone (TC) damages in the North Atlantic basin between 2010 and 2017 from the Emergency Events Database EM-DAT [@delforge_em-dat_2023], which lists total damages per cyclone and country. +As hazard event set we use the associated TC tracks from IBTrACS [@knapp_international_2010] and the windfield model by @holland_revised_2008. +As exposure, we use asset values estimated from gross domestic product, population distribution, and nightlight intensity [@eberenz_asset_2020]. +For an easier setup and visualization, we chose to only calibrate two parameters of the impact function. +However, parameter spaces of any dimension may be sampled the same way. +Executing the calibration with these data and the above code yields plots for the sampled parameter space (see \autoref{fig:pspace}) and impact functions (see \autoref{fig:impfs}). + +![Parameter space sampling with Bayesian optimization. The 'x' marks the optimal parameter set found by the algorithm. Colors indicate the respective values of the cost function (here: mean squared log error between recorded and modeled impacts).\label{fig:pspace}](pspace.png){ width=80% } + +![Impact functions for tropical cyclone asset damages in the North Atlantic basin found with Bayesian optimization. The dark blue line shows the optimal function given by the parameter set noted with 'x' in \autoref{fig:pspace}. Light blue lines give the functions whose cost function value is not greater than 103% of the estimated optimum. The orange histogram denotes the hazard intensities observed.\label{fig:impfs}](impfs.png){ width=80% } + +# References + +[^1]: Other common names are "vulnerability function" or "damage function". +[^2]: See \url{https://climada-python--692.org.readthedocs.build/en/692/tutorial/climada_util_calibrate.html}. diff --git a/doc/joss/calibration-module/pspace.png b/doc/joss/calibration-module/pspace.png new file mode 100644 index 0000000000..271a12ed67 Binary files /dev/null and b/doc/joss/calibration-module/pspace.png differ diff --git a/doc/misc/citation.rst b/doc/misc/citation.rst index cfc7d66509..e41d85cac6 100644 --- a/doc/misc/citation.rst +++ b/doc/misc/citation.rst @@ -29,6 +29,8 @@ If you use specific tools and modules of CLIMADA, please cite the appropriate pu - Mühlhofer, E., et al. (2023): OpenStreetMap for Multi-Faceted Climate Risk Assessments https://eartharxiv.org/repository/view/5615/ * - :doc:`LitPop exposures ` - Eberenz, S., et al. (2020): Asset exposure data for global physical risk assessment. Earth System Science Data 12, 817–833, https://doi.org/10.3929/ethz-b-000409595 + * - :doc:`Impact function calibration ` + - Riedel, L., et al. (2024): A Module for Calibrating Impact Functions in the Climate Risk Modeling Platform CLIMADA, Journal of Open Source Software [`under review `_] Please find the code to reprocduce selected CLIMADA-related scientific publications in our `repository of scientific publications `_. diff --git a/doc/tutorial/climada_util_calibrate.ipynb b/doc/tutorial/climada_util_calibrate.ipynb new file mode 100644 index 0000000000..202296c734 --- /dev/null +++ b/doc/tutorial/climada_util_calibrate.ipynb @@ -0,0 +1,4072 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Impact Function Calibration\n", + "\n", + "CLIMADA provides the [`climada.util.calibrate`](../climada/climada.util.calibrate) module for calibrating impact functions based on impact data.\n", + "This tutorial will guide through the usage of this module by calibrating an impact function for tropical cyclones (TCs).\n", + "\n", + "For further information on the classes available from the module, see its [documentation](../climada/climada.util.calibrate).\n", + "\n", + "## Overview\n", + "\n", + "The basic idea of the calibration is to find a set of parameters for an impact function that minimizes the deviation between the calculated impact and some impact data.\n", + "For setting up a calibration task, users have to supply the following information:\n", + "\n", + "* Hazard and Exposure (as usual, see [the tutorial](../tutorial/1_main_climada.ipynb#tutorial-an-example-risk-assessment))\n", + "* The impact data to calibrate the model to\n", + "* An impact function definition depending on the calibrated parameters\n", + "* Bounds and constraints of the calibrated parameters (depending on the calibration algorithm)\n", + "* A \"cost function\" defining the single-valued deviation between impact data and calculated impact\n", + "* A function for transforming the calculated impact into the same data structure as the impact data\n", + "\n", + "This information defines the calibration task and is inserted into the {py:class}`~climada.util.calibrate.base.Input` object.\n", + "Afterwards, the user may insert this object into one of the optimizer classes.\n", + "Currently, the following classes are available:\n", + "\n", + "* {py:class}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizer`: Uses Bayesian optimization to sample the parameter space.\n", + "* {py:class}`~climada.util.calibrate.scipy_optimizer.ScipyMinimizeOptimizer`: Uses the [`scipy.optimize.minimize`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html) function for determining the best parameter set.\n", + "\n", + "The following tutorial walks through the input data preparation and the setup of a {py:class}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizer` instance for calibration.\n", + "For a brief example, refer to [Quickstart](#quickstart).\n", + "If you want to go through a somewhat realistic calibration task step-by-step, continue with [Calibration Data](#calibration-data)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/site-packages/dask/dataframe/_pyarrow_compat.py:17: FutureWarning: Minimal version of pyarrow will soon be increased to 14.0.1. You are using 12.0.1. Please consider upgrading.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "import logging\n", + "import climada\n", + "\n", + "logging.getLogger(\"climada\").setLevel(\"WARNING\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Quickstart\n", + "\n", + "This section gives a very quick overview of assembling a calibration task.\n", + "Here, we calibrate a single impact function for damage reports in Mexico (`MEX`) from a TC with IbtracsID `2010176N16278`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-07-08 16:36:14,126 - climada.entity.exposures.base - INFO - Reading /Users/ldr.riedel/climada/data/exposures/litpop/LitPop_150arcsec_MEX/v3/LitPop_150arcsec_MEX.hdf5\n", + "2024-07-08 16:36:20,330 - climada.hazard.base - INFO - Reading /Users/ldr.riedel/climada/data/hazard/tropical_cyclone/tropical_cyclone_0synth_tracks_150arcsec_global_1980_2020/v2/tropical_cyclone_0synth_tracks_150arcsec_global_1980_2020.hdf5\n", + "2024-07-08 16:36:28,741 - climada.entity.exposures.base - INFO - Matching 100369 exposures with 6125253 centroids.\n", + "2024-07-08 16:36:30,939 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2024-07-08 16:36:34,188 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 0\n", + "2024-07-08 16:36:34,646 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 1\n", + "2024-07-08 16:36:34,996 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 2\n", + "2024-07-08 16:36:35,313 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 3\n", + "2024-07-08 16:36:35,690 - climada.util.calibrate.bayesian_optimizer - INFO - No improvement. Stop optimization.\n", + "2024-07-08 16:36:35,733 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", + "2024-07-08 16:36:35,736 - climada.entity.exposures.base - INFO - Existing centroids will be overwritten for TC\n", + "2024-07-08 16:36:35,736 - climada.entity.exposures.base - INFO - Matching 100369 exposures with 6125253 centroids.\n", + "2024-07-08 16:36:37,907 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n", + "2024-07-08 16:36:41,611 - climada.engine.impact_calc - INFO - Calculating impact for 292230 assets (>0) and 1 events.\n" + ] + }, + { + "data": { + "text/plain": [ + "{'v_half': 48.30330549244917}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAHFCAYAAADmGm0KAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABeX0lEQVR4nO3deZxO5f/H8dc9+z6WGbMwtii7hBLJTiH1kyhkaSPEVLKVtZgoUiqlZEmWFiJFpiyFsitb1rEbY50xxqz3+f0xub/uZjDDzJx7Zt7Px+N+NOec6z73+1w098d1zrmOxTAMAxERERGx42R2ABERERFHpCJJREREJBMqkkREREQyoSJJREREJBMqkkREREQyoSJJREREJBMqkkREREQyoSJJREREJBMqkkREREQyoSJJxAFZLJYsvVavXg3A6dOnGTJkCNWrV8fHxwcPDw8qVqzIgAED2L9//00/74033qBt27aULFkSi8VCjx49bvsYevToccPshc3MmTOxWCwcPnz4hu1WrlzJM888Q6VKlfD29qZkyZI8+uijbNmyJdP2W7dupXnz5vj4+FCkSBHat2/PoUOHMrSbPHky7du3p1y5clgsFho3bpzp/o4fP054eDiNGjWiSJEiWCwWZs6cmc2jFSkYXMwOICIZ/fHHH3bLb775JqtWrWLlypV266tUqcLGjRtp27YthmHQr18/7r//ftzc3Ni7dy9z5szh3nvv5cKFCzf8vPfee48aNWrQrl07vvjiixw7Dk9PzwyZ5camTp3KuXPnGDBgAFWqVOHMmTNMnDiRevXq8fPPP9O0aVNb23/++YfGjRtz99138/XXX5OYmMiIESNo2LAh27dvJzAw0Nb2k08+wdvbm6ZNm/LDDz9c9/MPHDjAV199xd13303r1q2ZN29erh6viCNTkSTigOrVq2e3HBgYiJOTU4b1cXFxPProo3h4eLB+/XpKlSpl29a4cWN69erFt99+e9PPu3TpEk5O6QPLX375ZQ4cQbrMMsuNffTRR5QoUcJu3UMPPUSFChUYN26cXZE0YsQI3N3dWbp0KX5+fgDUrl2bihUr8u677zJ+/Hhb2927d9v+jKtVq3bdz3/wwQc5c+YMAJs3b1aRJIWaTreJ5GOfffYZ0dHRTJgwwa5AulaHDh1uup+rX55mWL16NRaLhblz5zJ48GBCQkLw8fHhkUce4fTp01y6dIkXXniBgIAAAgIC6NmzJ/Hx8Xb7+Oijj3jwwQcpUaIE3t7eVK9enQkTJpCSkmLXrnHjxlSrVo1NmzbRsGFDvLy8KF++PG+//TZWq9XW7nqnxq5mvXqa86pffvmFZs2a4efnh5eXFw0aNODXX3+9pf74b4EE4OPjQ5UqVTh27JhtXWpqKkuXLuXxxx+3FUgAZcqUoUmTJixatMhuH1n9Mzbz74KIo9H/DSL52IoVK3B2duaRRx7Jk8+7WiSMGjUqy+9JTU3N8Lq2ILlq2LBhxMTEMHPmTCZOnMjq1at56qmnePzxx/H392fevHkMGjSIL7/8kmHDhtm99+DBg3Tu3Jkvv/ySpUuX8uyzz/LOO+/Qq1evDJ8THR1Nly5d6Nq1K0uWLOHhhx9m6NChzJkzJ9v9ATBnzhxatmyJn58fs2bN4uuvv6ZYsWK0atXqlgul/4qNjWXr1q1UrVrVtu7gwYNcuXKFGjVqZGhfo0YNDhw4QGJiYo58vkhhpdNtIvnY0aNHCQwMxNvbO08+z2Kx4OzsnOXRhsuXL+Pq6pphfbNmzfjll1/s1tWoUYMZM2bYlv/55x8mT55M//79eeeddwBo0aIFf/zxB1999RUffPCBre2kSZNsP1utVho2bEjx4sXp2bMnEydOpGjRorbt586d46effuLee+8FoHnz5qxevZq5c+fSrVu3LB3XVQkJCQwYMIC2bdvajdy0bt2ae+65h2HDhrFhw4Zs7TMzffv25fLly7z++ut2xwFQrFixDO2LFSuGYRhcuHCBkJCQ2/58kcJKRZKIZFmjRo1ITU3NcntPT09+++23DOuvPT10Vdu2be2WK1euDECbNm0yrP/++++Jj4/Hx8cHgG3btjFy5EjWrVvH+fPn7drv27eP++67z7YcHBxsK5CuqlGjBtu3b8/ycV21fv16zp8/T/fu3TP0y0MPPcSECRO4fPnybRWxw4cP56uvvmLKlCnUrl07w/Yb3SlYGO8iFMlJKpJE8rHSpUuzf//+2/4izi1OTk7UqVMnS23/OyLi5uZ2w/WJiYn4+Phw9OhRGjZsyF133cX7779P2bJl8fDwYOPGjfTt25crV67Yvb948eIZPtvd3T1Du6w4ffo0cOPrvs6fP3/LfzajR4/mrbfeYuzYsfTr189u29XjuDqi9N/PtFgsFClS5JY+V0TSqUgSycdatWrFihUr+OGHH3jyySfNjmOK77//nsuXL7Nw4ULKlCljW38rI0NXeXh4AJCUlGS3/uzZs3bLAQEBAEyZMuW6d/EFBQXdUobRo0czatQoRo0aleEaLIA77rgDT09PduzYkWHbjh07qFChgu04ROTW6MJtkXzs2WefJTg4mEGDBnHixIlM2yxcuDCPU+Wtq6eU3N3dbesMw+Czzz675X2WLVsWgL///ttu/ZIlS+yWGzRoQJEiRdi9ezd16tTJ9HV15Cs73nzzTUaNGsUbb7zByJEjM23j4uLCI488wsKFC7l06ZJt/dGjR1m1ahXt27fP9ueKiD2NJInkY/7+/ixevJi2bdtSq1Ytu8kk9+/fz5w5c/jrr79u+oW5Zs0a29w4aWlpHDlyxDa/UqNGjWyTEq5Zs4ZmzZoxYsQIRowYcdN8VquVP//8M9NttWrVsitsblWLFi1wc3PjqaeeYtCgQSQmJjJ16tSbTqB5I3Xr1uWuu+5i4MCBpKamUrRoURYtWsTatWvt2vn4+DBlyhS6d+/O+fPn6dChAyVKlODMmTP89ddfnDlzhqlTp2brsydOnMiIESN46KGHaNOmTYb+u3bEavTo0dStW5e2bdsyZMgQ22SSAQEBvPrqq3bv27x5s21Kg7i4OAzDsP0Z161b124U7ur6qzN3b9682Xb9V1amlBApMAwRcXjdu3c3vL29r7s9OjraGDx4sFG1alXDy8vLcHd3NypUqGD06tXL2LFjx03336hRIwPI9LVq1Spbu1WrVhmAMXLkyCxlvt4+AWP//v12+/zmm2/s3j9jxgwDMDZt2mS3fuTIkQZgnDlzxrbuhx9+MGrWrGl4eHgYJUuWNF577TVj2bJlGfI3atTIqFq1aqZZy5QpY7du3759RsuWLQ0/Pz8jMDDQeOmll4wff/wxwz4NwzDWrFljtGnTxihWrJjh6upqlCxZ0mjTpo3dMV09nqioqBv2243+LDL7lb1582ajWbNmhpeXl+Hn52c89thjxoEDBzI9xuvtc8aMGXZts/P5IgWZxTAMI/dKMBEREZH8SdckiYiIiGRCRZKIiIhIJlQkiYiIiGRCRZKIiIhIJlQkiYiIiGRCRZKIiIhIJjSZJOkT3p08eRJfX189EFJERCSfMAyDS5cuERoaipNTzo/7qEgCTp48SVhYmNkxRERE5BYcO3aMUqVK5fh+VSQBvr6+QHon+/n5mZxGREREsiIuLo6wsDDb93hOU5HE/x6Q6efnpyJJREQkn8mtS2V04baIiIhIJlQkiYiIiGRCRZKIiIhIJlQkiYiIiGRCRZKIiIhIJlQkiYiIiGRCRZKIiIhIJlQkiYiIiGRCRZKIiIhIJlQkiYiIiGTC1CLpt99+45FHHiE0NBSLxcL3339vt90wDEaNGkVoaCienp40btyYXbt22bVJSkripZdeIiAgAG9vb9q1a8fx48fz8ChERESkIDK1SLp8+TI1a9bkww8/zHT7hAkTmDRpEh9++CGbNm0iODiYFi1acOnSJVub8PBwFi1axPz581m7di3x8fG0bduWtLS0vDoMERERKYAshmEYZoeA9IfTLVq0iMceewxIH0UKDQ0lPDycwYMHA+mjRkFBQYwfP55evXoRGxtLYGAgX375JZ06dQLg5MmThIWF8dNPP9GqVassfXZcXBz+/v7EnjypB9yKiIjkE3FxcfiHhhIbG5sr398uOb7HHBIVFUV0dDQtW7a0rXN3d6dRo0asX7+eXr16sWXLFlJSUuzahIaGUq1aNdavX3/dIikpKYmkpCTbclxc3NU3587BiIiISL7jsBduR0dHAxAUFGS3PigoyLYtOjoaNzc3ihYtet02mYmIiMDf39/2CgsLy+H0IiIikt857EjSVRaLxW7ZMIwM6/7rZm2GDh3KK6+8YluOi4tLL5ROngSdbhMREckf4uJy9SyQwxZJwcHBQPpoUUhIiG19TEyMbXQpODiY5ORkLly4YDeaFBMTQ/369a+7b3d3d9zd3TNu8PZOf4mIiIjjy+WbtBy2SCpXrhzBwcFERkZSq1YtAJKTk1mzZg3jx48HoHbt2ri6uhIZGUnHjh0BOHXqFDt37mTChAmmZRcREZGsS021cuFCIufPJ3D+fAIJCVaKFi1LQgIkJMD69ZGcO3eWS5cSiI9P4PLlBBISEkhJyd1cphZJ8fHxHDhwwLYcFRXF9u3bKVasGKVLlyY8PJxx48ZRsWJFKlasyLhx4/Dy8qJz584A+Pv78+yzz/Lqq69SvHhxihUrxsCBA6levTrNmzc367BEREQKpNRUK9HR8cTExHPmTDwJCRaKFatIfDxcugSRkV9y/vw5Ll2K59KlSyQkxJOQEE9iYjwuLmGULDmZK1fSC5/Dh+uRknIAw0gArvznk6oA186LGA7sziRRiVw60nSmFkmbN2+mSZMmtuWr1wl1796dmTNnMmjQIK5cuUKfPn24cOEC9913HytWrMDX19f2nvfeew8XFxc6duzIlStXaNasGTNnzsTZ2TnPj0dERMQRGQZcuQKxsXDxIqxb9yfR0Rc5cyaWs2cvcuFCLBcvXuTSpVhcXcsRGjqQ2Nj0wmfPnrtJSTmFYcQDCf/Zc31g3TXLQ4CT10lRjaNHr12+CJzLpJ0Hzs6uBAeDl1f66+TJ+0hNDcHNzQs3Ny/c3T3x8PDCw8OHzZtz78yRw8yTZCbbPEm5NM+CiIhIToiLS+LAgXMcOnSWS5dc8fauzLlzcOaMweLFr3LpUiyXL1/kypWLJCXFkpx8kbS0WKABhvH9NXvyJmPBc1UDYO01y6HAqf+0cQJ8cXevS7lykfj4gI8PREW9CMTi6emDl5cPPj6++Pj44OfnQ1BQCI0aPYa3N3h6wunTe/DwgKJFvShWzIvixb0oWtQTV9es33if29/fDntNkoiISEEWH5/MgQPnOHjwLEeOnOXEiXNYrcUpXrwJZ89CTEwqkZGPkJBwluTks6SmngXir9lDW+CHf3+2AJ+Q8bTVVWcBcHICf39ISKiBk1Mi7u5F8PDwx9u7CD4+/vj7F6FkyQo0b57eztcXjh//AX9/VwICfChRwpfgYB/8/T1wcsrsLvKp2eiBytloaw4VSSIiIjnEMAxOnrzE33+fYs+ekxw8eIrk5AD8/Fpy8iQcP57Ihg01SEmJBi5lsoe2wNXLUFyANWQsfJyxWIrj6+vL3XdD8eLpr3/+GYqXlwtFi/pTvHgRAgP9CQoqQnCwP2XKBFCxYvpoT/oMOX9k46hqZ7MXCg4VSSIiIllw8uQl/vrrJHv2nCQ+3gsvr/s4dQqOHUtmxYoWJCScJCXlFHD5P+9sA1x9MoQH6aeuro4IOWGxFMfVNQAPjwCCgqrSqBEEBKS/DhyYQWCgN6VLB1C2bHHuuCOAsDB/XFwyOyU1PHcOvBBTkSQiIgKcPp3EiRPuHDoE+/cnM2fOAE6fPkRc3GFSUk5gX/y0Bn7892c3YBv2I0N+uLmF4OUVSsmSd/Pww+lzHoaEQGzsr5QtW4Q77wy8QcFzVaecPUjJFhVJIiJSKCQlGfz++0E2bTrEjh2HOHgwihMnDnH+/CESEw9hGA2BJf+2dgXmAnH/2Ut68RMQUIrGjdMLn9BQOHVqLmFhflSuHEr16iEEBd1oYuJ7c+HoJDeoSBIRkQJj796zrFmzn+3bD7FvXxTx8X54ePQnKop/bz+/h8yvBQI4SFAQlCsH5ctbOHduLKGh3lSrVpbq1UtRvXoIwcE+13lv21w5HjGXiiQREcl3rlyB3bthxw74+OOhHDy4hYsX/8ZqPf2fltWA/v/+bMHJqTqurrEUKVKekJDylCtXjqpVy3PPPeVo0KAcJezmJuyXJ8cijktFkoiIOKyUFCtr1hwiMnIHGzfuYP/+HcTGGiQkfIvVerXVj8AO23ucnUvh43MHJUqUp1y5KnTrBuXLp48QBQWt4ybPSBexUZEkIiIOISYmfWRoxw6YNWsE+/f/zOXLO8k46aEHkEbx4s5Urw4uLgMJDU3mwQer06ZN1RucEhPJHhVJIiKS5zZvPsHs2b+zbt1GDh/eQWzsMdLS9pA+KSLATmDjvz974OlZhdDQ6lSuXJ369avTtatBqVJX5/zpZsYhSCGgIklERHKVYcCBA/Dhhz/y44/fcuTIb6SmHsqk5XHuuCOM6tXBx6cfgYFP0aJFDZo2rYC7u57HKXlPRZKIiOSo1FQr33+/k6+//p3U1G788Ycv0dEAq4GZ/7ZywtPzbipUqE+tWjVp3LgGjz0WRNGiV/fSNO+Di/yHiiQREbktCQkpzJu3lYULf2Pz5t84c2YthnHx360VgZa4ucFddz2Gj48rrVs/SI8e9SlVSg8UF8emIklERLIlIQE2bIDffoOFC7/n77+7kPHiam+KFavPo4+60r073HsveHo2IP0J8yL5g4okERG5IavV4IsvNjB9+mJ27lzDlSvPk5bW89+tdwAJWCzFCApqSJ06DenQ4UGeeOJuvLxczYwtcttUJImISAZWq8GsWZv46KOv2b79G9LSjl6z9Q5CQ3vy4IPQoEFVSpbcwSOPVLnJM8hE8h8VSSIiAqTfhbZlC8yZc5mPPqpOamrUNVu9KV36EVq0aEW3bo1p2PDq7fdOpM9qLVLwqEgSESnErFaDefO2MWfONvbufZaoKABvIBiIoXTpR+jU6QmGDHmYYsU8zQ0rksdUJImIFDJWq8GCBdv54IOv2bz5G1JTD5L+dfB/eHkVo21baNhwNk8+GUpAgJfZcUVMoyJJRKQQMAxYsmQvEybMZtOmr0lJOXDNVk9KlWrLkCGx9OhRDG9vgAomJRVxHCqSREQKKKvV4K+/rCxc6MzXX8O+fb8C4/7d6kHJkm144omODBnShqAgbzOjijgkFUkiIgXM/v3n6N37Y9aunUty8gCgNwDu7u0pVuwXOnToyLBhbfUgWJGbUJEkIlJAbNlykl69JrJly6fAZQAsloU8+mhvOnaEtm2D8fVdaG5IkXxERZKISD63atUh+vQZzz//zASSAfD0rEW3bi/zxhuPUqqUqfFE8i0VSSIi+dTOnRARAXPnvgD8CoCfX0Nee20Yw4a1wsnJYm5AkXxORZKISD7zxRcb+OabO1i+PODfNYMJDHRjxIih9OvX0NRsIgWJ5pAXEckHrFaDiRNXUqxYc559th7Ll0/GYoEOHWDr1hbExPykAkkkh2kkSUTEgaWmWhk5cinvvz+Oy5c3/LvWhcqV41m4ECpVMjWeSIGmIklExAGlpsKrr37Dp5+OISlp579rPahe/Tk++eQ16tcvbWo+kcJARZKIiANJSoLZs2H8eDh48BdgJ+BLvXp9+eyzcKpVCzI7okihoSJJRMQBxMRc5oUXprF+fVPOnKkJQJEig6ldO4zPP+9H2bJFzA0oUgipSBIRMVFqqpVOnT5k0aIxGMY54AlCQ79m4EB44YXyeHu/YXZEkUJLRZKIiEn++OMobdr05MKFlQC4uJSnc+dWTJsG7u4mhxMRTQEgIpLXrFaD3r2/pH796v8WSF506vQRly7tZdasZ1UgiTgIjSSJiOShs2ehdeuv2LSpGwA+PvVYuHA2LVpUNDmZiPyXRpJERPLIsmVQvTps2vQEUJtmzd7izJnfVSCJOCiNJImI5LLo6HgeffRDNm4cSPpEkO7MmPEn992nX8EijkwjSSIiuWjatD8IC7ubjRuHAuMID4ctW1CBJJIP6P9SEZFcEB+fzEMPjWHdugjAirNzKd5+uwEDB5qdTESySkWSiEgOW7JkN08+2ZUrV7YBUK5cV1atmkKZMkXMDSYi2aLTbSIiOcRqhe7dF/Doo/dw5co2LJZivPLKNxw69KUKJJF8SCNJIiI54OhR6NkTVq6sCVgIDHyYFSumc/fdIWZHE5FbpJEkEZHbYLUavPXWdqpXh5UrwcurEsOHbyY6+kcVSCL5nEaSRERu0d69Z2nWrDcnTiwCfqNevQbMng0VK1Y1O5qI5ACNJImI3IIxY5ZRpUp1Tpz4DnCiXbud/P47VNS8kCIFhkaSRESy4ezZBB588BX27PkUAHf3Kkyf/iVdutxjcjIRyWkqkkREsuj8+Svceecj/z6UFu6552UiI8dSrJinyclEJDfodJuISBYkJkLDhl/9WyD5EBGxgi1bJqlAEinANJIkInITSUnQvj3s3v0sLi5Hee+9FvTr19DsWCKSy1QkiYjcQHx8Mp06WVm2zANPTws//TSGxo3NTiUieUFFkojIdSQkpHDXXU9x8mQC7u4L+eEHTxVIIoWIiiQRkUwkJqZy111dOHlyIeBGRMR2mjW73+xYIpKHdOG2iMh/JCenUalSd44f/wZwZeTIhbz8sgokkcJGRZKIyDWSk9OoXLknR47MBVwYNuxbRo1qY3YsETGBiiQRkX+lplqpVu15Dh36EnBm4MD5jB3bzuxYImISFUkiIoDVCl26HGT//vTHjISHz+Wddx43O5aImMihi6TU1FTeeOMNypUrh6enJ+XLl2fMmDFYrVZbG8MwGDVqFKGhoXh6etK4cWN27dplYmoRyW8MA/r1g6+/rojFEkm/fnN5772OZscSEZM5dJE0fvx4PvnkEz788EP27NnDhAkTeOedd5gyZYqtzYQJE5g0aRIffvghmzZtIjg4mBYtWnDp0iUTk4tIfmG1Gjz77FGmTgWLBWbOvJcpUzqZHUtEHIBDF0l//PEHjz76KG3atKFs2bJ06NCBli1bsnnzZiB9FGny5Mm8/vrrtG/fnmrVqjFr1iwSEhKYO3euyelFxNFZrQb33vsaM2bUBDbz+efQrZvZqUTEUTh0kfTAAw/w66+/sm/fPgD++usv1q5dS+vWrQGIiooiOjqali1b2t7j7u5Oo0aNWL9+/XX3m5SURFxcnN1LRAoXq9WgQYNhbNkyEbhIt25/88wzZqcSEUfi0JNJDh48mNjYWCpVqoSzszNpaWmMHTuWp556CoDo6GgAgoKC7N4XFBTEkSNHrrvfiIgIRo8enXvBRcThNWo0kj//fBuAjh0/YtYsVUgiYs+hR5IWLFjAnDlzmDt3Llu3bmXWrFm8++67zJo1y66dxWKxWzYMI8O6aw0dOpTY2Fjb69ixY7mSX0QcU9OmY1i79k0A/u//3mfBgj4mJxIRR+TQI0mvvfYaQ4YM4cknnwSgevXqHDlyhIiICLp3705wcDCQPqIUEhJie19MTEyG0aVrubu74+7unrvhRcQhtWoVwapVIwFo2/ZdFi7sb3IiEXFUDj2SlJCQgJOTfURnZ2fbFADlypUjODiYyMhI2/bk5GTWrFlD/fr18zSriDi+t99OZcWKX4D0YumHH141OZGIODKHHkl65JFHGDt2LKVLl6Zq1aps27aNSZMm8cy/V1daLBbCw8MZN24cFStWpGLFiowbNw4vLy86d+5scnoRcSTvvQdDh7oAP9Chw/d8841+R4jIjTl0kTRlyhSGDx9Onz59iImJITQ0lF69ejFixAhbm0GDBnHlyhX69OnDhQsXuO+++1ixYgW+vr4mJhcRRzJw4EYmTqwLWBgxwovRo1UgicjNWQzDMMwOYba4uDj8/f2JjY3Fz8/P7DgikoO6dPmUuXN7A0MZMmQs48ZZuMF9HSKSj+T297dDX5MkInI7Pvzwd+bOfRGAOnVSGDsWFUgikmUqkkSkQIqJuczLL/cEDMqX78aGDRNwclKFJCJZpyJJRAqkli2HkZp6EGfnUqxa9YEKJBHJNhVJIlLgTJnyG3/99QEAo0d/TunS/iYnEpH8SEWSiBQoFy4k88or6dOE3Hnns7z+eiuTE4lIfqUiSUQKlJEj3UhNnYSr671ERk40O46I5GMqkkSkwFizBqZMAWjHkiV/6jSbiNwWFUkiUiDExFymW7dTADz3HDz0kC7UFpHboyJJRAqEFi2GcvRoVYoXX8REnWUTkRzg0I8lERHJivffX8Pff08B4NVXvdHE+SKSEzSSJCL5WkzMZQYOTL+brVKl5xk6tKXJiUSkoFCRJCL5WvPmQ0hNPYSzcxiRke+aHUdEChAVSSKSb02evIYdOz4E4M03P6dUKZ1nE5GcoyJJRPKl06cv89prOs0mIrlHRZKI5EsjR1pITW2Ds3MZnWYTkVyhIklE8p3Vq+HTT72AD/juux06zSYiuUJFkojkK+fOJdGzpxWAF16ARx/1NTmRiBRUKpJEJF9p0uRVDh9uSmjoId55x+w0IlKQaTJJEck3Jk1axY4dHwEwYMAh/PzKm5xIRAoyjSSJSL4QHR3P4MHpd7NVrtyLQYOam5xIRAo6FUkiki+0aDGY1NTDODuX4ZdfdJ5NRHKfiiQRcXgTJ65k586PAYiImE5oqC7WFpHcpyJJRBxadHQ8Q4Y8C0CVKr147bVmJicSkcJCRZKIOLSBA0+Tmur776SROs0mInlHd7eJiMNauRK++uoOYDPTpx/WaTYRyVMaSRIRhxQfD8+mn2Wjd283une/09xAIlLoqEgSEYfUoMHLHD78JqVLpzBhgtlpRKQw0uk2EXE4Eyeu5O+/JwPw6qtN8fVtYG4gESmUNJIkIg7l1Kl4Bg9OP89WteqL9O+vAklEzKEiSUQcSosWg0hLO4yLS1l++UXn2UTEPCqSRMRhTJy4kl27pgIwfvwXBAf7mJxIRAozFUki4hBSU60MG9YXgGrV+vDKK01MTiQihZ2KJBFxCO+9t5Xk5P1YLEVYtizC7DgiIrq7TUTMZxjw7bd1gIN07LiTUqX8zI4kIqIiSUTMt3o1bNwInp5lmDKljNlxREQAnW4TEQcwcuQRIH2G7cBAk8OIiPxLRZKImOqrr7by++/lgA68/LLV7DgiIjYqkkTEVEOHjgcMypb1oHx5/UoSEceh30giYprIyP0cO/YtAO++O8jkNCIi9lQkiYhp+vd/F7ASGNiaxx+vYXYcERE7KpJExBTbt5/in39mAjBy5BBzw4iIZEJFkoiYolevyUAyvr716dPnAbPjiIhkoCJJRPLcuXNpbNq0EIDw8CFYLBaTE4mIZKTJJEUkz02b5oxh/EXJkt8wYkQbs+OIiGRKRZKI5KkrV2DyZAAv3n67Oy76LSQiDkqn20QkT7333lFiYqyUKQOdOpmdRkTk+lQkiUieSUxMZeTIJkA1unbdg6ur2YlERK5PA90ikmcGDfqW1NRDWCwBhIfrQbYi4tg0kiQiecJqNfjss7cBaNKkPwEBXiYnEhG5MRVJIpInxo37mcTEvwBvPvusr9lxRERuSkWSiOSJd99NH0WqXbsX5csXMzmNiMjNqUgSkVw3bdofxMauAVyZOvVls+OIiGSJiiQRyXUTJnwLwJ13Pk3duqVMTiMikjW6u01EctXu3XDw4LvAQ3z4YXmz44iIZJmKJBHJVRMmAFho374FLVqYnUZEJOt0uk1Ecs3ff59nzpw4AAYPNjmMiEg2OXyRdOLECbp27Urx4sXx8vLi7rvvZsuWLbbthmEwatQoQkND8fT0pHHjxuzatcvExCJyVffuY0hLK03lyjO5916z04iIZM8tnW47duwYhw8fJiEhgcDAQKpWrYq7u3tOZ+PChQs0aNCAJk2asGzZMkqUKMHBgwcpUqSIrc2ECROYNGkSM2fO5M477+Stt96iRYsW7N27F19f3xzPJCJZs3fvWbZv/wxIoFu3kmbHERHJNothGEZWGh45coRPPvmEefPmcezYMa59m5ubGw0bNuSFF17g8ccfx8kpZwaohgwZwrp16/j9998z3W4YBqGhoYSHhzP437H8pKQkgoKCGD9+PL169crS58TFxeHv709sbCx+fn45kl2ksGvceBRr1ozG0/Me4uM34+RkMTuSiBQwuf39naVqZsCAAVSvXp39+/czZswYdu3aRWxsLMnJyURHR/PTTz/xwAMPMHz4cGrUqMGmTZtyJNySJUuoU6cOTzzxBCVKlKBWrVp89tlntu1RUVFER0fTsmVL2zp3d3caNWrE+vXrr7vfpKQk4uLi7F4iknOio+P57bcpAPTuPUQFkojkS1k63ebm5sbBgwcJDAzMsK1EiRI0bdqUpk2bMnLkSH766SeOHDlC3bp1bzvcoUOHmDp1Kq+88grDhg1j48aN9O/fH3d3d7p160Z0dDQAQUFBdu8LCgriyJEj191vREQEo0ePvu18IpK5F1/8HMM4j6trBd5+u73ZcUREbkmWT7eZwc3NjTp16tiNCvXv359Nmzbxxx9/sH79eho0aMDJkycJCQmxtXn++ec5duwYy5cvz3S/SUlJJCUl2Zbj4uIICwvT6TaRHBAfn0yRIneQlnacp5+exuzZz5sdSUQKqNw+3XZb8ySdPXuWDRs2kJaWRt26de0KlZwQEhJClSpV7NZVrlyZ7777DoDg4GAAoqOj7T47JiYmw+jStdzd3XPlQnMRgbfeWk9a2kmcnEL48MNuZscREbllt3yF9XfffUeFChUYPXo0I0eO5I477mDGjBk5mY0GDRqwd+9eu3X79u2jTJkyAJQrV47g4GAiIyNt25OTk1mzZg3169fP0SwicnNWKyxe3BjYxzPPzMTPT/8YEZH8K8sjSfHx8fj4+NiWR48ezcaNG7nzzjsB+PHHH3n++efp2bNnjoV7+eWXqV+/PuPGjaNjx45s3LiRadOmMW3aNAAsFgvh4eGMGzeOihUrUrFiRcaNG4eXlxedO3fOsRwikjVLlsA//4C//x1MnHiH2XFERG5LlkeSateuzeLFi23LLi4uxMTE2JZPnz6Nm5tbjoarW7cuixYtYt68eVSrVo0333yTyZMn06VLF1ubQYMGER4eTp8+fahTpw4nTpxgxYoVmiNJJI9ZrQajRx8GoG9f0OV9IpLfZfnC7cOHD9OnTx/c3d356KOPOHjwIE8++SRpaWmkpqbi5OTEzJkzad26dW5nznGaJ0nk9k2evJqXX26Kk1MXTpyYTXCwbvsXkdzlMBduly1blp9++om5c+fSqFEjBgwYwIEDBzhw4ABpaWlUqlQJDw+PHA8oIvnD2LHjAYPKlX1VIIlIgZDtC7c7d+7Mxo0b2bZtG40bN8ZqtXL33XerQBIpxBYs2M7Zs8sBJz76aKDZcUREckS2pgBYtmwZu3fvpmbNmkyfPp3Vq1fTuXNnWrduzZgxY/D09MytnCLiwAYNGg9AmTKdaNSovMlpRERyRpZHkgYNGkSPHj3YtGkTvXr14s0336Rx48Zs27YNd3d37r77bpYtW5abWUXEAa1ceZCjR78G4J13BpucRkQk52T5wu2AgAB+/vlnateuzfnz56lXrx779u2zbd+1axe9evVi7dq1uRY2t+jCbZFbV7Xqi+ze/QmBgQ8TE/OT2XFEpBBxiAfcAnh5eREVFQXAsWPHMlyDVLVq1XxZIInIrTtyJIndu5cAMHz4EJPTiIjkrCxfkxQREUG3bt3o378/CQkJzJo1KzdziUg+8Mkn7sBeKlRYTN++Dc2OIyKSo7L1gNtz585x6NAhKlasSJEiRXIxVt7S6TaR7IuNhdKlIS4OFi+Gdu3MTiQihY3DzJMEULx4cYoXL57jIUQk/5ky5TxxcUWpUsVC27ZmpxERyXlZuiapd+/eHDt2LEs7XLBgAV999dVthRIRxzd2bDOgOo89th2nW35UtoiI48rSSFJgYCDVqlWjfv36tGvXjjp16hAaGoqHhwcXLlxg9+7drF27lvnz51OyZEnbA2hFpGBauHAniYnbAVeeeaa02XFERHJFlq9JiomJYfr06cyfP5+dO3fabfP19aV58+a88MILtGzZMleC5iZdkySSPfXqDWHDhvGEhDzGyZOLzI4jIoVUbn9/Z+vC7asuXrzIkSNHuHLlCgEBAdxxxx1YLPn3WU0qkkSyLjXViodHGdLSjvPaa98xYUJ7syOJSCHlUBduX1WkSJECdXebiGTdBx+sIS3tOBZLEYYNa212HBGRXKPLLUUkWz75ZA4Ad931BEWK6MHWIlJwqUgSkSw7f/4K+/d/C0Dfvk+bnEZEJHfd0uk2ESmcfv7ZFZiPr++P9O7dwOw4IiK5SkWSiGTZ3LkuwMP07/8wLvrtISIFXLZPtzVt2pSLFy9mWB8XF0fTpk1zIpOIOKAzZ2D58vSfu3QxN4uISF7IdpG0evVqkpOTM6xPTEzk999/z5FQIuJ4Bg78itTUwVStupfKlc1OIyKS+7I8YP7333/bft69ezfR0dG25bS0NJYvX07JkiVzNp2IOIzvvpsCbODOO0OBu8yOIyKS67JcJN19991YLBYsFkump9U8PT2ZMmVKjoYTEccQGbmfy5c3AM6MGfOk2XFERPJEloukqKgoDMOgfPnybNy4kcDAQNs2Nzc3SpQogbOzc66EFBFzvfVW+txIgYEtqVYtyOQ0IiJ5I8tFUpkyZQCwWq25FkZEHI/VarB+fXqR9MQTXU1OIyKSd7J94XZERARffPFFhvVffPEF48ePz5FQIuI4Pv/8T1JTDwE+jBr1mNlxRETyTLaLpE8//ZRKlSplWF+1alU++eSTHAklIo7jgw++BKB8+fYEBnqZnEZEJO9ku0iKjo4mJCQkw/rAwEBOnTqVI6FExDEkJ8PBg8WA4jz/vE61iUjhku0iKSwsjHXr1mVYv27dOkJDQ3MklIg4hmXLIDHxLYKDT/LKK5osVkQKl2w/WOC5554jPDyclJQU21QAv/76K4MGDeLVV1/N8YAiYp456ddr06WLG25u5mYREclr2S6SBg0axPnz5+nTp49t5m0PDw8GDx7M0KFDczygiJjjyJFYFi/+G2hA167ZHnQWEcn3LIZhGLfyxvj4ePbs2YOnpycVK1bE3d09p7Plmbi4OPz9/YmNjcXPz8/sOCIOoXv3z5k9+3l8fB4mLu4nLBazE4mI2Mvt7+9bfo63j48PdevWzcksIuJAFi9OP9f2wAONVCCJSKF0S0XSpk2b+Oabbzh69GiGh90uXLgwR4KJiHnWrTtCbOwaAEaN6mxyGhERc2T7QoP58+fToEEDdu/ezaJFi0hJSWH37t2sXLkSf3//3MgoInlszJi5ABQp0pj77gszOY2IiDmyXSSNGzeO9957j6VLl+Lm5sb777/Pnj176NixI6VLl86NjCKSh6xWg9Wr0yeQfOyxp01OIyJinmwXSQcPHqRNmzYAuLu7c/nyZSwWCy+//DLTpk3L8YAikrfmzdtGcvIewIPRox83O46IiGmyXSQVK1aMS5cuAVCyZEl27twJwMWLF0lISMjZdCKS56ZMWQxAWFg7SpfWKXQRKbyyfeF2w4YNiYyMpHr16nTs2JEBAwawcuVKIiMjadasWW5kFJE8kpoKUVEjgRYMHOhjdhwREVNle56k8+fPk5iYSGhoKFarlXfffZe1a9dSoUIFhg8fTtGiRXMra67RPEki6X7+GR56CIoXh1OnwNXV7EQiItfncPMkFStWzPazk5MTgwYNYtCgQTkaSkTMMXu2AVh48kkVSCIitzRPUlpaGosWLWLPnj1YLBYqV67Mo48+iovLLc9NKSImi46OZ968qkBbnnjiHcDL7EgiIqbKdlWzc+dOHn30UaKjo7nrrrsA2LdvH4GBgSxZsoTq1avneEgRyX2jRi3CMI7i6rqChg0/NDuOiIjpsn1323PPPUfVqlU5fvw4W7duZevWrRw7dowaNWrwwgsv5EZGEckD336b/hiSBg264uSk55CIiGR7JOmvv/5i8+bNdhdoFy1alLFjx+pZbiL51Pbtpzh37hcAhg/vanIaERHHkO2RpLvuuovTp09nWB8TE0OFChVyJJSI5K2RI+cBVnx87qdp0zvMjiMi4hBu6bEk/fv359tvv+X48eMcP36cb7/9lvDwcMaPH09cXJztJSL5Q2Rk+qm2tm31GBIRkauyPU+Sk9P/6iqLJf26hau7uHbZYrGQlpaWUzlzleZJksJs8eJdPPZYNcCFffuiqVixuNmRRESyxOHmSVq1alWOhxAR86xY4Q8MpkyZWBVIIiLXyHaR1KhRo9zIISImsFrhhx9KAW/z7rtmpxERcSy3NPtjYmIif//9NzExMVitVrtt7dq1y5FgIpL7fvsNjh0Df39o29bsNCIijiXbRdLy5cvp1q0bZ8+ezbAtP12HJCIwfPjnQCiPP94SDw/NmC8icq1s393Wr18/nnjiCU6dOoXVarV7qUASyT8uXEhk7dpXgTbUrLne7DgiIg4n20VSTEwMr7zyCkFBQbmRR0TyyJtv/gDE4excmj59HjA7joiIw8l2kdShQwdWr16dC1FEJC/NnZs+N9K993bBxSXbvwpERAq8bM+TlJCQwBNPPEFgYCDVq1fH1dXVbnv//v1zNGBe0DxJUtjs3XuWSpVCgFQWL95Fu3ZVzI4kIpJtDjdP0ty5c/n555/x9PRk9erVtgkkIf3C7fxYJIkUNiNHfg2k4ul5jwokEZHryPYY+xtvvMGYMWOIjY3l8OHDREVF2V6HDh3KjYw2ERERWCwWwsPDbesMw2DUqFGEhobi6elJ48aN2bVrV67mEMnvfvwx/VRby5Z6DImIyPVku0hKTk6mU6dOdo8nyQubNm1i2rRp1KhRw279hAkTmDRpEh9++CGbNm0iODiYFi1acOnSpTzNJ5Jf/P33ZeLjLwFOjB79pNlxREQcVrYrne7du7NgwYLcyHJd8fHxdOnShc8++4yiRYva1huGweTJk3n99ddp37491apVY9asWSQkJDB37tw8zSiSXyxc6A38TcOG+6hZM9jsOCIiDivb1ySlpaUxYcIEfv75Z2rUqJHhwu1JkyblWLir+vbtS5s2bWjevDlvvfWWbX1UVBTR0dG0bNnSts7d3Z1GjRqxfv16evXqleNZRPIzw4A5cwAsvPDCHWbHERFxaNkuknbs2EGtWrUA2Llzp922ay/izinz589n69atbNq0KcO26OhogAxzNgUFBXHkyJHr7jMpKYmkpCTbclxcXA6lFXFsy5ef4eBBL7y9vfm//zM7jYiIY8t2kbRq1arcyJGpY8eOMWDAAFasWIGHh8d12/23ODMM44YFW0REBKNHj86xnCL5xaBBo4BZVK06EW9vjbSKiNyIQ88gt2XLFmJiYqhduzYuLi64uLiwZs0aPvjgA1xcXGwjSFdHlK6KiYm54YzgQ4cOJTY21vY6duxYrh6HiCOIj09m164FwGXatStrdhwREYeX5ZGk9u3bZ6ndwoULbznMfzVr1owdO3bYrevZsyeVKlVi8ODBlC9fnuDgYCIjI22nAJOTk1mzZg3jx4+/7n7d3d1xd3fPsZwi+UFExHIM4xxOTsG8+mozs+OIiDi8LBdJ/v7+uZkjU76+vlSrVs1unbe3N8WLF7etDw8PZ9y4cVSsWJGKFSsybtw4vLy86Ny5c57nFXFks2enz410991P4eGR7TPtIiKFTpZ/U86YMSM3c9yyQYMGceXKFfr06cOFCxe47777WLFiBb6+vmZHE3EYR4/Gcvz4EgAGDtQEkiIiWZHtZ7cVRHp2mxR0L7wwm88+646bWyWuXNmNk1PO34kqIpLXcvv726Ev3BaRnPH99+kTwNav/6QKJBGRLNKFCSIF3PnzcP78B8ADDBrUwew4IiL5hookkQLu++8hLe0OqlcfysMPm51GRCT/0Ok2kQLu6qMWO3UyN4eISH6jIkmkAPvnn7OsWNEemMcTTxT6ezRERLJFRZJIAfbWWwuBRXh6vsudd+qCbRGR7FCRJFKA/fRT+rm2Ro06mpxERCT/UZEkUkDt3HmaCxdWAzB0qIokEZHsUpEkUkC9+eZ3gBVv73t58MFyZscREcl3VCSJFFA//5x+qq1pU93WJiJyK1QkiRRAW7eeJDb2dwCGDXvC5DQiIvmTJpMUKYDmzTsN3Iuvrwv16oWZHUdEJF9SkSRSAK1fXwv4kxEjEs2OIiKSb+l0m0gBc+wYrF8PFgt07uxhdhwRkXxLRZJIAfPBB7uACzRsCKGhZqcREcm/VCSJFDBTpz4DBFG58g9mRxERydd0TZJIAfL774e5fHkj4ES/fveaHUdEJF/TSJJIARIR8TUARYs2plq1IHPDiIjkcyqSRAqQ1avTJ5B8+GE9hkRE5HapSBIpIH799QBXrmwFnBkx4nGz44iI5HsqkkQKiLffTj/VVrx4M+66K8DkNCIi+Z+KJJECYu3abwFo21an2kREcoLubhMpAP75BxITf8LJ6TuGD/8/s+OIiBQIKpJECoAFCwCCeeihvtxxh9lpREQKBp1uE8nnDONqkQQddaZNRCTHqEgSyee+/34ne/Y0xdl5Bo89ZnYaEZGCQ0WSSD43adICYBWBgd/j7292GhGRgkNFkkg+ZrUabNiQfut/+/adTE4jIlKwqEgSyce++eYvUlL2AR68/vojZscRESlQVCSJ5GOTJ6dfsR0a2prQUF+T04iIFCwqkkTyKavVYPPm9CKpY0edahMRyWkqkkTyqTlztpCaGgV4MXRoG7PjiIgUOJpMUiSfWrHCCrSkdOkASpTwNjuOiEiBoyJJJB8yDPj993uBn5k40Wp2HBGRAkmn20TyoQ0b4OhR8PGBNm30v7GISG7Qb1eRfGjixDXACdq1A09Ps9OIiBRMKpJE8pnUVCsLF3YBwqhW7Tez44iIFFgqkkTymU8/XYfVegLwo2/f+8yOIyJSYKlIEslnPv00/TEkd9zxGH5+7ianEREpuFQkieQjyclp7Nr1LQBPP93R5DQiIgWbiiSRfOTDD3/Dao3GYinKq682NzuOiEiBpiJJJB+ZPj39VFvFiu3x8XEzOY2ISMGmIkkkn0hJMfjnn6UA9OihU20iIrlNM26L5BOrV1uwWnfi4/MDL7/c1Ow4IiIFnookkXzi668B/OncuSseHmanEREp+HS6TSQfSEmBhQvTf+7UydwsIiKFhYokkXzg7beXc/58HXx9P6NRI7PTiIgUDiqSRPKB2bMXAFsoU2Y7zs5mpxERKRxUJIk4uLi4JA4cWATACy/oXJuISF5RkSTi4N59NxKIxckphBdffMDsOCIihYaKJBEHN2fOAgBq1HgCFxf9Lysiklf0G1fEgV28mEhU1GIAevfWqTYRkbykIknEgb399nLgEs7OYTz7bD2z44iIFCqaTFLEgW3eHAx0oG7dSjrVJiKSx1QkiTiohAT44496wDe8/77ZaURECh/901TEQf34Y3qhVK4c1K1rdhoRkcLHoYukiIgI6tati6+vLyVKlOCxxx5j7969dm0Mw2DUqFGEhobi6elJ48aN2bVrl0mJRXLOxIlfA//QsSNYLGanEREpfBy6SFqzZg19+/blzz//JDIyktTUVFq2bMnly5dtbSZMmMCkSZP48MMP2bRpE8HBwbRo0YJLly6ZmFzk9kRHx7NhQ3egMnXqqOgXETGDxTAMw+wQWXXmzBlKlCjBmjVrePDBBzEMg9DQUMLDwxk8eDAASUlJBAUFMX78eHr16pWl/cbFxeHv709sbCx+fn65eQgiWfLSS/P48MPOuLpWIDFxH05OGkoSEfmv3P7+duiRpP+KjY0FoFixYgBERUURHR1Ny5YtbW3c3d1p1KgR69evNyWjSE749tv5ANx7bycVSCIiJsk3d7cZhsErr7zCAw88QLVq1QCIjo4GICgoyK5tUFAQR44cue6+kpKSSEpKsi3HxcXlQmKRW/Pbb1FERy8FYNCgzianEREpvPLNSFK/fv34+++/mTdvXoZtlv9c1WoYRoZ114qIiMDf39/2CgsLy/G8Ireqf//JgJXixVvRrl0Vs+OIiBRa+aJIeumll1iyZAmrVq2iVKlStvXBwcHA/0aUroqJickwunStoUOHEhsba3sdO3Ysd4KLZFNU1AX++ms6AK+++qrJaURECjeHLpIMw6Bfv34sXLiQlStXUq5cObvt5cqVIzg4mMjISNu65ORk1qxZQ/369a+7X3d3d/z8/OxeIo5gwoRdgCceHjUYPLi52XFERAo1h74mqW/fvsydO5fFixfj6+trGzHy9/fH09MTi8VCeHg448aNo2LFilSsWJFx48bh5eVF5866lkPyl+RkWLLkAeAoo0Yd0wXbIiImc+gpAK53XdGMGTPo0aMHkD7aNHr0aD799FMuXLjAfffdx0cffWS7uDsrNAWAOIIvv4Ru3SAkBA4fBjc3sxOJiDi23P7+dugiKa+oSBKzWa0GFSuu5NChJowb58TQoWYnEhFxfJonSaQQePfdXzl0qDlOTvfx/PNWs+OIiAgqkkQcwjvvTASgatV6BATof0sREUeg38YiJluyZBdnzy4HLEyeHG52HBER+ZdD390mUhi89tokAEJD/4+mTe8wOY2I5KS0tDRSUlLMjpFvubq64uzsbNrnq0gSMdGOHdHs2zcHgBEjNHmkSEFhGAbR0dFcvHjR7Cj5XpEiRQgODr7hkzRyi4okERP16fMRkIyPTz169br+BKgikr9cLZBKlCiBl5eXKV/w+Z1hGCQkJBATEwNASEhInmdQkSRikoQE2LDhDwBeeEGjSCIFRVpamq1AKl68uNlx8jVPT08g/XFjJUqUyPNTbyqSREwyezakpEQSHLyGiIiGZscRkRxy9RokLy8vk5MUDFf7MSUlRUWSSGFgtcJ77wFYGDq0sWbXFimAdIotZ5jZj5oCQMQEn312kH37LlGkCDzzjNlpREQkMyqSREwwePAzQBjNmy/Dx8fsNCIikhkVSSJ5bPbszcTG/gZcZvDgGmbHERGx6dGjBxaLhd69e2fY1qdPHywWi+0B81fbWiwWXF1dCQoKokWLFnzxxRdYrfaPVypbtqytraenJ2XLlqVjx46sXLkyLw7rlqlIEsljw4enP4KkfPmnqFOnpMlpRETshYWFMX/+fK5cuWJbl5iYyLx58yhdurRd24ceeohTp05x+PBhli1bRpMmTRgwYABt27YlNTXVru2YMWM4deoUe/fuZfbs2RQpUoTmzZszduzYPDmuW6ELt0Xy0B9/HOXo0W8AiIjQbf8ihYVhpE/7YQYvL8jOtc/33HMPhw4dYuHChXTp0gWAhQsXEhYWRvny5e3auru7ExwcDEDJkiW55557qFevHs2aNWPmzJk899xztra+vr62tqVLl+bBBx8kJCSEESNG0KFDB+66667bPNKcp5EkkTz00kvvA2kULdqMjh1rmh1HRPJIQgL4+JjzupXirGfPnsyYMcO2/MUXX/BMFu8yadq0KTVr1mThwoU3bTtgwAAMw2Dx4sXZD5kHVCSJ5JGjR2PZsuUzAMLDNYokIo7r6aefZu3atRw+fJgjR46wbt06unbtmuX3V6pUicOHD9+0XbFixShRokSW2ppBp9tE8sjIkauBy7i5Veb111uZHUdE8pCXF8THm/fZ2RUQEECbNm2YNWsWhmHQpk0bAgICsvx+wzCyPL9RdtrmNRVJInkgJQV+/fVRYD+vvBKNs7MGcUUKE4sFvL3NTpE9zzzzDP369QPgo48+ytZ79+zZQ7ly5W7a7ty5c5w5cyZLbc2g39QieeDbb+HYMShRojwjR+pBtiLi+B566CGSk5NJTk6mVausj36vXLmSHTt28Pjjj9+07fvvv4+TkxOPPfbYbSTNPRpJEsllVqvBuHFHgTL06wceHmYnEhG5OWdnZ/bs2WP7OTNJSUlER0eTlpbG6dOnWb58OREREbRt25Zu3brZtb106RLR0dGkpKQQFRXFnDlz+Pzzz4mIiKBChQq5fjy3QkWSSC6bMuU3du5sgrNzZ3r3/hJwzHPvIiL/5efnd8Pty5cvJyQkBBcXF4oWLUrNmjX54IMP6N69O05O9ierRowYwYgRI3BzcyM4OJh69erx66+/0qRJk9w8hNtiMQzDMDuE2eLi4vD39yc2NvamfyFEsis4uB2nT/9AlSq92bVrqtlxRCSXJSYmEhUVRbly5fDQ0PFtu1F/5vb3t65JEslFy5bt5fTpHwALkya9bHYcERHJBhVJIrno1VffAyA4+BFatbrT5DQiIpIdKpJEcsmePWfYs2cWAEOHvmJyGhERyS4VSSK5pG/fqUAiXl616dfvQbPjiIhINqlIEskFV64Y/PbbXACeeeZVnJx0R5uISH6jKQBEcsFXX1lIS9tMsWJzmTChg9lxRETkFqhIEslhVitMmgTgw+uvv4Cnp9mJRETkVuh0m0gO++ab8+zZY+DnB889Z3YaERG5VSqSRHLYiy8+AdSkbduNaG5SEZH8S0WSSA5asGA7Fy6sBHbTr1+w2XFERLKlR48eWCwWLBYLrq6ulC9fnoEDB3L58mVbmxdeeAFnZ2fmz59/w321bNkSZ2dn/vzzz9yOnWtUJInkoKFDJwJQpkxH7r+/tMlpRESy76GHHuLUqVMcOnSIt956i48//piBAwcCkJCQwIIFC3jttdeYPn36dfdx9OhR/vjjD/r163fDdo5ORZJIDtm06ThRUen/snrrrVdNTiMicmvc3d0JDg4mLCyMzp0706VLF77//nsAvvnmG6pUqcLQoUNZt24dhw8fznQfM2bMoG3btrz44ossWLDAbiQqP1GRJJJD+vWbAqTi79+Irl1rmx1HRByJYcDly+a8bvM59p6enqSkpAAwffp0unbtir+/P61bt2bGjBmZHKrBjBkz6Nq1K5UqVeLOO+/k66+/vq0MZlGRJJIDTp68xMaNnwLw0ksaRRKR/0hIAB8fc14JCbcce+PGjcydO5dmzZqxf/9+/vzzTzp16gRA165dmTFjBlar1e49v/zyCwkJCbRq1crWLr+eclORJJIDXn31GyAWN7e7GDmyjdlxRERu2dKlS/Hx8cHDw4P777+fBx98kClTpjB9+nRatWpFQEAAAK1bt+by5cv88ssvdu+fPn06nTp1wsUlfSrGp556ig0bNrB37948P5bbpckkRW5Tair88UcPIITnn7fi4qJ/e4jIf3h5QXy8eZ+dDU2aNGHq1Km4uroSGhqKq6sraWlpzJ49m+joaFvxA5CWlsb06dNp2bIlAOfPn+f7778nJSWFqVOn2rX74osvGD9+fM4cUx5RkSRymz7+GI4ccSIg4GHeecfsNCLikCwW8PY2O0WWeHt7U6FCBbt1P/30E5cuXWLbtm04Ozvb1v/zzz906dKFc+fOUbx4cb766itKlSplu9D7ql9//ZWIiAjGjh1rV2Q5Ov2TV+Q2dOjwEQMGbAZg4ED0CBIRKZCmT59OmzZtqFmzJtWqVbO9Hn/8cQIDA5kzZ46tXYcOHezaVKtWjWeeeYaLFy/y448/mnwk2aMiSeQWWK0GzZq9yXff9QNa0avXKQYNMjuViEjOO336ND/++COPP/54hm0Wi4X27dszffp0tmzZwl9//ZVpO19fX1q2bJnvLuC2GMZt3htYAMTFxeHv709sbCx+eo6E3ITValCv3mA2bUo/t9a06RgiI9/AyclicjIRcQSJiYlERUVRrlw5PDw8zI6T792oP3P7+zv/nBgUcQCpqVZq1uzL7t2fAPDYY++xaFG4uaFERCRXqEgSyaLExFSqVOlJVNQcwEK3btOYNes5s2OJiEgu0TVJIlmQlAS1a7/7b4HkwksvzVWBJCJSwKlIErmJy5fhkUdg9+7+WCwteeONhXzwwZNmxxIRkVym020iN3DqVAJPPOHJunUWvLy8WLx4Oc2b6wJtEZHCQCNJItexd+9ZKlR4kHXrhuPvD5GRqEASESlEVCSJZGLbtpPUrNmIhIQtWCzT+O67GOrXNzuViIjkJRVJIv+xdu1h7r23IUlJu3FyKsnSpb/RrFkJs2OJiEgeU5Ekco1ly/6hceMHSE09hItLeVat+p3WrSuZHUtEREygIknkX19//Rdt2jxIWtoJ3Nyq8Oefv/Pgg+XMjiUiIiZRkSQC/Pkn9Oz5N4ZxBk/Pe/jrrzXUrh1qdiwRkTzVo0cPLBYLvXv3zrCtT58+WCwWevToYdfWYrHg6upKUFAQLVq04IsvvsBqtdq9t2zZsra2np6eVKpUiXfeeQdHfzKaiiQp9FauhObNISHhae688xv27FlJpUoBZscSETFFWFgY8+fP58qVK7Z1iYmJzJs3j9KlS9u1feihhzh16hSHDx9m2bJlNGnShAEDBtC2bVtSU1Pt2o4ZM4ZTp06xZ88eBg4cyLBhw5g2bVqeHNOtUpEkhdqbb67g4YdPc/lyeqG0dWsHypTxNzuWiIhp7rnnHkqXLs3ChQtt6xYuXEhYWBi1atWya+vu7k5wcDAlS5bknnvuYdiwYSxevJhly5Yxc+ZMu7a+vr4EBwdTtmxZnnvuOWrUqMGKFSvy4pBumYokKbTCwxcwYkQbkpNb0Lr1RX74Aby9zU4lIgXZ5cuXr/tKTEzMcttrR3lu1PZW9ezZkxkzZtiWv/jiC5555pksvbdp06bUrFnTrsi6lmEYrF69mj179uDq6nrLGfOCiiQplHr2nM777z8FpFK2bA2++cYbDw+zU4lIQefj43Pd1+OPP27XtkSJEtdt+/DDD9u1LVu2bKbtbtXTTz/N2rVrOXz4MEeOHGHdunV07do1y++vVKkShw8ftls3ePBgfHx8cHd3p0mTJhiGQf/+/W85Y14oMEXSxx9/TLly5fDw8KB27dr8/vvvZkcSBxIfD8uW7efttyNp2HA4M2c+BxhUqvQC+/bNxsvLsf81IyKSlwICAmjTpg2zZs1ixowZtGnThoCArF+raRgGFov9Ewpee+01tm/fzpo1a2jSpAmvv/469R18lt4C8ey2BQsWEB4ezscff0yDBg349NNPefjhh9m9e3eGi8yk4ImOjmfLluPs2HGMffuOc/jwMU6dOk58vJUiRT7n2DGIjQV4Cthie1/t2q+yceM7ODnpUSMikjfi4+Ovu83Z2dluOSYm5rptnZzsxzj+O2qTE5555hn69esHwEcffZSt9+7Zs4dy5eynUAkICKBChQpUqFCB7777jgoVKlCvXj2aN2+eY5lzWoEokiZNmsSzzz7Lc889B8DkyZP5+eefmTp1KhEREVnez59/HsXb2zfDem9vH4oWLQ6A1Wrl5Mlj192Hp6cXxYsHAumV9IkTR6/b1sPDk4CA/83kfPz4keu2dXf3IDAwyLZ88uSxDLdYXuXm5kaJEiG25VOnjpOWlpZp2/TbNv93q3t09IkMdyRc5eLiQnBwSdtyTMwpkpOTM23r7OxMSEipa9pGk5yclGlbi8VCyZL/K2bPnDlNUtL/zs1fuJDAzp3H2bfvONHR8ZQs+RLHj8Px47BnT2PS0tZkul/w4vjxzwDLv8daGSenRHx9w2jR4lHmzOmlAklE8pR3Ni58zK22WfXQQw/Zfse3atUqy+9buXIlO3bs4OWXX75um6JFi/LSSy8xcOBAtm3blmHUyVHk+yIpOTmZLVu2MGTIELv1LVu2ZP369Zm+JykpiaSk/31hx8XFAdCqVfXrfMqzwOf//hwPlL1BoieBef/+nHaTto8AS65ZvhPIvOiAZsAv1yzXBC5cp2094I//LJ+4TtvqwN/XLDcF9l2n7R3AgWuW2wDbrtM2GDh1zXIHYN112voCcdcsdwOud8eDJ9CPq4UPFPn3v364u4fh41OKgIAwQkJKUbZsGB07Wilb1plSpcDX98vr7FNERP7L2dmZPXv22H7OTFJSEtHR0aSlpXH69GmWL19OREQEbdu2pVu3bjfcf9++fRk/fjzfffcdHTp0yPH8OSHfF0lnz54lLS2NoKAgu/VBQUFER0dn+p6IiAhGjx6dyRZ3/vfl+z/Ozq5cvQDfMCAp6fpX+Do5ueLmltW2bra2AImJHlzvMrHM22a+b4vFDXf3/y0nJXlgGNdr6/6ftu451NbDrm1yshtW6/X6wsPuoumMbd1xdy9lK4CeeCKZcuXcKVUKPD0/pXz52ZQs6XedfYuIyK3y87vx79bly5cTEhKCi4sLRYsWpWbNmnzwwQd07949wynB/woMDOTpp59m1KhRtG/f/qbtzWAxHH26y5s4efIkJUuWZP369dx///229WPHjuXLL7/kn3/+yfCezEaSwsLCiI2NvelfCBERkRtJTEwkKirKdjOR3J4b9WdcXBz+/v659v2d70eSAgICcHZ2zjBqFBMTk2F06Sp3d3fcrx3mEBEREfkPxxvbyiY3Nzdq165NZGSk3frIyEiHv7VQREREHFe+H0kCeOWVV3j66aepU6cO999/P9OmTePo0aOZPqBPREREJCsKRJHUqVMnzp07Z3t4XrVq1fjpp58oU6aM2dFEREQknyoQRRJAnz596NOnj9kxREREpIDI99ckiYiIOKJ8fvO4wzCzH1UkiYiI5KCrT7ZPSEgwOUnBcLUfr/ZrXiowp9tEREQcgbOzM0WKFLE9e83Ly8thH7vhyAzDICEhgZiYGIoUKXLdWb9zk4okERGRHBYcHAzc+CG1kjVFihSx9WdeU5EkIiKSwywWCyEhIZQoUYKUlBSz4+Rbrq6upowgXaUiSUREJJc4Ozub+iUvt0cXbouIiIhkQkWSiIiISCZUJImIiIhkQtck8b+JquLi4kxOIiIiIll19Xs7tyacVJEEnDt3DoCwsDCTk4iIiEh2nTt3Dn9//xzfr4okoFixYgAcPXo0Vzq5MImLiyMsLIxjx47h5+dndpx8S/2Yc9SXOUd9mTPUjzknNjaW0qVL277Hc5qKJMDJKf3SLH9/f/2FzSF+fn7qyxygfsw56suco77MGerHnHP1ezzH95srexURERHJ51QkiYiIiGRCRRLg7u7OyJEjcXd3NztKvqe+zBnqx5yjvsw56sucoX7MObndlxYjt+6bExEREcnHNJIkIiIikgkVSSIiIiKZUJEkIiIikgkVSSIiIiKZKPRF0scff0y5cuXw8PCgdu3a/P7772ZHcngRERHUrVsXX19fSpQowWOPPcbevXvt2hiGwahRowgNDcXT05PGjRuza9cukxLnDxEREVgsFsLDw23r1I9Zd+LECbp27Urx4sXx8vLi7rvvZsuWLbbt6susSU1N5Y033qBcuXJ4enpSvnx5xowZg9VqtbVRX2b022+/8cgjjxAaGorFYuH777+3256VPktKSuKll14iICAAb29v2rVrx/Hjx/PwKBzDjfoyJSWFwYMHU716dby9vQkNDaVbt26cPHnSbh851pdGITZ//nzD1dXV+Oyzz4zdu3cbAwYMMLy9vY0jR46YHc2htWrVypgxY4axc+dOY/v27UabNm2M0qVLG/Hx8bY2b7/9tuHr62t89913xo4dO4xOnToZISEhRlxcnInJHdfGjRuNsmXLGjVq1DAGDBhgW69+zJrz588bZcqUMXr06GFs2LDBiIqKMn755RfjwIEDtjbqy6x56623jOLFixtLly41oqKijG+++cbw8fExJk+ebGujvszop59+Ml5//XXju+++MwBj0aJFdtuz0me9e/c2SpYsaURGRhpbt241mjRpYtSsWdNITU3N46Mx14368uLFi0bz5s2NBQsWGP/884/xxx9/GPfdd59Ru3Ztu33kVF8W6iLp3nvvNXr37m23rlKlSsaQIUNMSpQ/xcTEGICxZs0awzAMw2q1GsHBwcbbb79ta5OYmGj4+/sbn3zyiVkxHdalS5eMihUrGpGRkUajRo1sRZL6MesGDx5sPPDAA9fdrr7MujZt2hjPPPOM3br27dsbXbt2NQxDfZkV//1iz0qfXbx40XB1dTXmz59va3PixAnDycnJWL58eZ5ldzSZFZz/tXHjRgOwDXDkZF8W2tNtycnJbNmyhZYtW9qtb9myJevXrzcpVf4UGxsL/O9BwVFRUURHR9v1rbu7O40aNVLfZqJv3760adOG5s2b261XP2bdkiVLqFOnDk888QQlSpSgVq1afPbZZ7bt6suse+CBB/j111/Zt28fAH/99Rdr166ldevWgPryVmSlz7Zs2UJKSopdm9DQUKpVq6Z+vYnY2FgsFgtFihQBcrYvC+0Dbs+ePUtaWhpBQUF264OCgoiOjjYpVf5jGAavvPIKDzzwANWqVQOw9V9mfXvkyJE8z+jI5s+fz9atW9m0aVOGberHrDt06BBTp07llVdeYdiwYWzcuJH+/fvj7u5Ot27d1JfZMHjwYGJjY6lUqRLOzs6kpaUxduxYnnrqKUB/L29FVvosOjoaNzc3ihYtmqGNvpOuLzExkSFDhtC5c2fbw4Jzsi8LbZF0lcVisVs2DCPDOrm+fv368ffff7N27doM29S3N3bs2DEGDBjAihUr8PDwuG479ePNWa1W6tSpw7hx4wCoVasWu3btYurUqXTr1s3WTn15cwsWLGDOnDnMnTuXqlWrsn37dsLDwwkNDaV79+62durL7LuVPlO/Xl9KSgpPPvkkVquVjz/++Kbtb6UvC+3ptoCAAJydnTNUlTExMRmqfcncSy+9xJIlS1i1ahWlSpWyrQ8ODgZQ397Eli1biImJoXbt2ri4uODi4sKaNWv44IMPcHFxsfWV+vHmQkJCqFKlit26ypUrc/ToUUB/J7PjtddeY8iQITz55JNUr16dp59+mpdffpmIiAhAfXkrstJnwcHBJCcnc+HCheu2kf9JSUmhY8eOREVFERkZaRtFgpzty0JbJLm5uVG7dm0iIyPt1kdGRlK/fn2TUuUPhmHQr18/Fi5cyMqVKylXrpzd9nLlyhEcHGzXt8nJyaxZs0Z9e41mzZqxY8cOtm/fbnvVqVOHLl26sH37dsqXL69+zKIGDRpkmIZi3759lClTBtDfyexISEjAycn+q8HZ2dk2BYD6Mvuy0me1a9fG1dXVrs2pU6fYuXOn+vU/rhZI+/fv55dffqF48eJ223O0L7N1mXcBc3UKgOnTpxu7d+82wsPDDW9vb+Pw4cNmR3NoL774ouHv72+sXr3aOHXqlO2VkJBga/P2228b/v7+xsKFC40dO3YYTz31VKG/RTgrrr27zTDUj1m1ceNGw8XFxRg7dqyxf/9+46uvvjK8vLyMOXPm2NqoL7Ome/fuRsmSJW1TACxcuNAICAgwBg0aZGujvszo0qVLxrZt24xt27YZgDFp0iRj27ZttjuustJnvXv3NkqVKmX88ssvxtatW42mTZsWyikAbtSXKSkpRrt27YxSpUoZ27dvt/sOSkpKsu0jp/qyUBdJhmEYH330kVGmTBnDzc3NuOeee2y3scv1AZm+ZsyYYWtjtVqNkSNHGsHBwYa7u7vx4IMPGjt27DAvdD7x3yJJ/Zh1P/zwg1GtWjXD3d3dqFSpkjFt2jS77erLrImLizMGDBhglC5d2vDw8DDKly9vvP7663ZfQOrLjFatWpXp78Xu3bsbhpG1Prty5YrRr18/o1ixYoanp6fRtm1b4+jRoyYcjblu1JdRUVHX/Q5atWqVbR851ZcWwzCM7I09iYiIiBR8hfaaJBEREZEbUZEkIiIikgkVSSIiIiKZUJEkIiIikgkVSSIiIiKZUJEkIiIikgkVSSIiIiKZUJEkIgXC4cOHsVgsbN++PVf2P336dFq2bJkr+76epUuXUqtWLdsjQUQkb6lIEpEb6tGjB4899li23mOxWPj+++9zJc/1hIWFcerUKapVqwbA6tWrsVgsXLx48bb3nZSUxIgRIxg+fPht7wvgypUreHl58c8//9ywXdu2bbFYLMydOzdHPldEskdFkogUCM7OzgQHB+Pi4pLj+/7uu+/w8fGhYcOGObK/yMhIwsLCqFSp0k3b9uzZkylTpuTI54pI9qhIEpFsady4Mf3792fQoEEUK1aM4OBgRo0aZdtetmxZAP7v//4Pi8ViWwb44YcfqF27Nh4eHpQvX57Ro0eTmppq226xWPj888/5v//7P7y8vKhYsSJLliyxbb9w4QJdunQhMDAQT09PKlasyIwZMwD7022HDx+mSZMmABQtWhSLxUKPHj2YPXs2xYsXJykpye6YHn/8cbp163bdY54/fz7t2rWzW3d1hG3cuHEEBQVRpEgR2/G89tprFCtWjFKlSvHFF19k2N/ixYtt+/vrr79o0qQJvr6++Pn5Ubt2bTZv3mxr265dOzZu3MihQ4eum09EcoeKJBHJtlmzZuHt7c2GDRuYMGECY8aMITIyEoBNmzYBMGPGDE6dOmVb/vnnn+natSv9+/dn9+7dfPrpp8ycOZOxY8fa7Xv06NF07NiRv//+m9atW9OlSxfOnz8PwPDhw9m9ezfLli1jz549TJ06lYCAgAz5wsLC+O677wDYu3cvp06d4v333+eJJ54gLS3NrvA6e/YsS5cupWfPntc93t9//506depkWL9y5UpOnjzJb7/9xqRJkxg1ahRt27alaNGibNiwgd69e9O7d2+OHTtme4/VamXp0qU8+uijAHTp0oVSpUqxadMmtmzZwpAhQ3B1dbW1L1OmDCVKlOD333+/wZ+IiOSKHHtsr4gUSN27dzceffRR23KjRo2MBx54wK5N3bp1jcGDB9uWAWPRokV2bRo2bGiMGzfObt2XX35phISE2L3vjTfesC3Hx8cbFovFWLZsmWEYhvHII48YPXv2zDTn1aeDb9u2zTCM/z1J/MKFC3btXnzxRePhhx+2LU+ePNkoX768YbVaM93vhQsXDMD47bff7NZ3797dKFOmjJGWlmZbd9dddxkNGza0Laemphre3t7GvHnzbOvWrVtnBAQE2N7n6+trzJw5M9PPvqpWrVrGqFGjbthGRHKeRpJEJNtq1KhhtxwSEkJMTMwN37NlyxbGjBmDj4+P7fX8889z6tQpEhISMt23t7c3vr6+tn2/+OKLzJ8/n7vvvptBgwaxfv36bGd//vnnWbFiBSdOnADSR7x69OiBxWLJtP2VK1cA8PDwyLCtatWqODn979doUFAQ1atXty07OztTvHhxu75ZvHgxbdu2tb3vlVde4bnnnqN58+a8/fbbHDx4MMPneHp62vWRiOQNFUkikm3Xng6C9GuJbnabutVqZfTo0Wzfvt322rFjB/v377crQG6074cffpgjR44QHh7OyZMnadasGQMHDsxW9lq1alGzZk1mz57N1q1b2bFjBz169Lhu++LFi2OxWLhw4UKGbZllvVnfLFmyxHaqDWDUqFHs2rWLNm3asHLlSqpUqcKiRYvs9nH+/HkCAwOzc5gikgNUJIlIjnN1dSUtLc1u3T333MPevXupUKFChte1ozE3ExgYSI8ePZgzZw6TJ09m2rRpmbZzc3MDyJAD4LnnnmPGjBl88cUXNG/enLCwsOt+npubG1WqVGH37t1Zzng9+/fv5/DhwxnmW7rzzjt5+eWXWbFiBe3bt7ddjA6QmJjIwYMHqVWr1m1/vohkj4okEclxZcuW5ddffyU6Oto2AjNixAhmz55tGznZs2cPCxYs4I033sjyfkeMGMHixYs5cOAAu3btYunSpVSuXDnTtmXKlMFisbB06VLOnDlDfHy8bVuXLl04ceIEn332Gc8888xNP7dVq1asXbs2yzmvZ/HixTRv3hwvLy8g/VRev379WL16NUeOHGHdunVs2rTJ7pj+/PNP3N3duf/++2/780Uke1QkiUiOmzhxom0uoKsjIK1atWLp0qVERkZSt25d6tWrx6RJkyhTpkyW9+vm5sbQoUOpUaMGDz74IM7OzsyfPz/TtiVLlmT06NEMGTKEoKAg+vXrZ9vm5+fH448/jo+PT5Ymynz++ef56aefiI2NzXLWzCxevNjuVJuzszPnzp2jW7du3HnnnXTs2JGHH36Y0aNH29rMmzePLl262AorEck7FsMwDLNDiIjktRYtWlC5cmU++OCDLLXv2LEjtWrVYujQobf0eWfPniUkJIRjx44RHBycpfecOXOGSpUqsXnzZsqVK3dLnysit04jSSJSqJw/f5758+ezcuVK+vbtm+X3vfPOO/j4+NzW506aNCnLBRJAVFQUH3/8sQokEZNoJElECpWyZcty4cIFhg8fnu0740SkcFGRJCIiIpIJnW4TERERyYSKJBEREZFMqEgSERERyYSKJBEREZFMqEgSERERyYSKJBEREZFMqEgSERERyYSKJBEREZFMqEgSERERycT/A8d2busCGuqCAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "from sklearn.metrics import mean_squared_log_error\n", + "\n", + "from climada.util import log_level\n", + "from climada.util.api_client import Client\n", + "from climada.entity import ImpactFuncSet, ImpfTropCyclone\n", + "from climada.util.calibrate import (\n", + " Input,\n", + " BayesianOptimizer,\n", + " BayesianOptimizerController,\n", + " OutputEvaluator,\n", + ")\n", + "\n", + "# Load hazard and exposure from Data API\n", + "client = Client()\n", + "exposure = client.get_litpop(\"MEX\")\n", + "exposure.gdf[\"impf_TC\"] = 1\n", + "all_tcs = client.get_hazard(\n", + " \"tropical_cyclone\",\n", + " properties={\"event_type\": \"observed\", \"spatial_coverage\": \"global\"},\n", + ")\n", + "hazard = all_tcs.select(event_names=[\"2010176N16278\"])\n", + "\n", + "# Impact data (columns: region ID, index: hazard event ID)\n", + "data = pd.DataFrame(data=[[2.485465e09]], columns=[484], index=list(hazard.event_id))\n", + "\n", + "# Create input\n", + "inp = Input(\n", + " hazard=hazard,\n", + " exposure=exposure,\n", + " data=data,\n", + " # Generate impact function from estimated parameters\n", + " impact_func_creator=lambda v_half: ImpactFuncSet(\n", + " [ImpfTropCyclone.from_emanuel_usa(v_half=v_half, impf_id=1)]\n", + " ),\n", + " # Estimated parameter bounds\n", + " bounds={\"v_half\": (26, 100)},\n", + " # Cost function\n", + " cost_func=mean_squared_log_error,\n", + " # Transform impact to pandas Dataframe with same structure as data\n", + " impact_to_dataframe=lambda impact: impact.impact_at_reg(exposure.gdf[\"region_id\"]),\n", + ")\n", + "\n", + "# Set up optimizer (with controller)\n", + "controller = BayesianOptimizerController.from_input(inp)\n", + "opt = BayesianOptimizer(inp)\n", + "\n", + "# Run optimization\n", + "with log_level(\"WARNING\", \"climada.engine.impact_calc\"):\n", + " output = opt.run(controller)\n", + "\n", + "# Analyse results\n", + "output.plot_p_space()\n", + "out_eval = OutputEvaluator(inp, output)\n", + "out_eval.impf_set.plot()\n", + "\n", + "# Optimal value\n", + "output.params" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Follow the next sections of the tutorial for a more in-depth explanation." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Calibration Data\n", + "\n", + "CLIMADA ships data from the International Disaster Database EM-DAT, which we will use to calibrate impact functions on.\n", + "In the first step, we will select TC events that caused damages in the `NA1` basin since 2010.\n", + "\n", + "We use EMDAT data from TCs occurring in the `NA1` basin since 2010.\n", + "We calculate the centroids for which we want to compute the windfields by extracting the countries hit by the cyclones and retrieving a `LitPop` exposure instance from them.\n", + "We then use the exposure coordinates as centroids coordinates." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countryregion_idcal_region2yearEM_IDibtracsIDemdat_impactreference_yearemdat_impact_scaledclimada_impact...scalelog_ratiounique_IDAssociated_disasterSurgeRainFloodSlideOtherOtherThanSurge
326MEX484NA120102010-02602010176N162782.000000e+0920142.485465e+092.478270e+09...1.0-0.0028992010-0260MEXTrueFalseFalseTrueFalseFalseTrue
331ATG28NA120102010-04682010236N123411.260000e+0720141.394594e+071.402875e+07...1.00.0059202010-0468ATGTrueFalseFalseTrueFalseFalseTrue
334MEX484NA120102010-04942010257N162823.900000e+0920144.846656e+094.857140e+09...1.00.0021612010-0494MEXTrueFalseFalseTrueFalseFalseTrue
339LCA662NA120102010-05712010302N093065.000000e+0520145.486675e+055.492871e+05...1.00.0011292010-0571LCATrueFalseFalseTrueTrueFalseTrue
340VCT670NA120102010-05712010302N093062.500000e+0720142.670606e+072.676927e+07...1.00.0023642010-0571VCTFalseFalseFalseFalseFalseFalseFalse
344BHS44NA120112011-03282011233N153014.000000e+0720144.352258e+074.339898e+07...1.0-0.0028442011-0328BHSFalseFalseFalseFalseFalseFalseFalse
345DOM214NA120112011-03282011233N153013.000000e+0720143.428317e+073.404744e+07...1.0-0.0069002011-0328DOMTrueFalseFalseTrueFalseFalseTrue
346PRI630NA120112011-03282011233N153015.000000e+0820145.104338e+085.139659e+08...1.00.0068962011-0328PRITrueFalseFalseTrueFalseFalseTrue
352MEX484NA120112011-03852011279N102572.770000e+0720143.084603e+073.077374e+07...1.0-0.0023462011-0385MEXTrueFalseFalseTrueTrueFalseTrue
359MEX484NA120122012-02762012215N123133.000000e+0820143.283428e+083.284805e+08...1.00.0004192012-0276MEXFalseFalseFalseFalseFalseFalseFalse
365MEX484NA120122012-04012012166N092695.550000e+0820146.074341e+086.103254e+08...1.00.0047492012-0401MEXFalseFalseFalseFalseFalseFalseFalse
369JAM388NA120122012-04102012296N142831.654200e+0720141.548398e+071.548091e+07...1.0-0.0001982012-0410JAMFalseFalseFalseFalseFalseFalseFalse
406MEX484NA120142014-03332014253N132602.500000e+0920142.500000e+092.501602e+09...1.00.0006402014-0333MEXTrueFalseFalseTrueFalseFalseTrue
427MEX484NA120152015-04702015293N132668.230000e+0820149.242430e+089.239007e+08...1.0-0.0003702015-0470MEXTrueFalseFalseTrueFalseFalseTrue
428CPV132NA120152015-04732015242N123431.100000e+0620141.281242e+061.282842e+06...1.00.0012482015-0473CPVFalseFalseFalseFalseFalseFalseFalse
429BHS44NA120152015-04792015270N272919.000000e+0720148.362720e+071.129343e+06...1.0-4.3047332015-0479BHSTrueTrueFalseTrueFalseFalseTrue
437MEX484NA120162016-03192016248N152555.000000e+0720146.098482e+076.088808e+07...1.0-0.0015882016-0319MEXTrueFalseFalseTrueFalseFalseTrue
451MEX484NA120172017-03342017219N162792.000000e+0620142.284435e+062.285643e+06...1.00.0005292017-0334MEXTrueFalseFalseTrueTrueFalseTrue
456ATG28NA120172017-03812017242N163332.500000e+0820142.111764e+082.110753e+08...1.0-0.0004792017-0381ATGFalseFalseFalseFalseFalseFalseFalse
457BHS44NA120172017-03812017242N163332.000000e+0620141.801876e+066.118379e+05...1.0-1.0801162017-0381BHSFalseFalseFalseFalseFalseFalseFalse
458CUB192NA120172017-03812017242N163331.320000e+1020141.099275e+101.090424e+10...1.0-0.0080852017-0381CUBTrueFalseFalseTrueFalseFalseTrue
459KNA659NA120172017-03812017242N163332.000000e+0720141.848489e+071.848665e+07...1.00.0000952017-0381KNAFalseFalseFalseFalseFalseFalseFalse
460TCA796NA120172017-03812017242N163335.000000e+0820145.000000e+085.003790e+08...1.00.0007582017-0381TCATrueFalseFalseTrueFalseFalseTrue
462VGB92NA120172017-03812017242N163333.000000e+0920143.000000e+096.236200e+08...1.0-1.5708262017-0381VGBFalseFalseFalseFalseFalseFalseFalse
463DMA212NA120172017-03832017260N123101.456000e+0920141.534596e+098.951186e+08...1.0-0.5390662017-0383DMATrueFalseFalseTrueTrueFalseTrue
464DOM214NA120172017-03832017260N123106.300000e+0720145.481371e+075.493466e+07...1.00.0022042017-0383DOMTrueFalseFalseTrueTrueFalseTrue
465PRI630NA120172017-03832017260N123106.800000e+1020146.700905e+106.702718e+10...1.00.0002712017-0383PRITrueFalseFalseTrueFalseTrueTrue
\n", + "

27 rows × 22 columns

\n", + "
" + ], + "text/plain": [ + " country region_id cal_region2 year EM_ID ibtracsID \\\n", + "326 MEX 484 NA1 2010 2010-0260 2010176N16278 \n", + "331 ATG 28 NA1 2010 2010-0468 2010236N12341 \n", + "334 MEX 484 NA1 2010 2010-0494 2010257N16282 \n", + "339 LCA 662 NA1 2010 2010-0571 2010302N09306 \n", + "340 VCT 670 NA1 2010 2010-0571 2010302N09306 \n", + "344 BHS 44 NA1 2011 2011-0328 2011233N15301 \n", + "345 DOM 214 NA1 2011 2011-0328 2011233N15301 \n", + "346 PRI 630 NA1 2011 2011-0328 2011233N15301 \n", + "352 MEX 484 NA1 2011 2011-0385 2011279N10257 \n", + "359 MEX 484 NA1 2012 2012-0276 2012215N12313 \n", + "365 MEX 484 NA1 2012 2012-0401 2012166N09269 \n", + "369 JAM 388 NA1 2012 2012-0410 2012296N14283 \n", + "406 MEX 484 NA1 2014 2014-0333 2014253N13260 \n", + "427 MEX 484 NA1 2015 2015-0470 2015293N13266 \n", + "428 CPV 132 NA1 2015 2015-0473 2015242N12343 \n", + "429 BHS 44 NA1 2015 2015-0479 2015270N27291 \n", + "437 MEX 484 NA1 2016 2016-0319 2016248N15255 \n", + "451 MEX 484 NA1 2017 2017-0334 2017219N16279 \n", + "456 ATG 28 NA1 2017 2017-0381 2017242N16333 \n", + "457 BHS 44 NA1 2017 2017-0381 2017242N16333 \n", + "458 CUB 192 NA1 2017 2017-0381 2017242N16333 \n", + "459 KNA 659 NA1 2017 2017-0381 2017242N16333 \n", + "460 TCA 796 NA1 2017 2017-0381 2017242N16333 \n", + "462 VGB 92 NA1 2017 2017-0381 2017242N16333 \n", + "463 DMA 212 NA1 2017 2017-0383 2017260N12310 \n", + "464 DOM 214 NA1 2017 2017-0383 2017260N12310 \n", + "465 PRI 630 NA1 2017 2017-0383 2017260N12310 \n", + "\n", + " emdat_impact reference_year emdat_impact_scaled climada_impact ... \\\n", + "326 2.000000e+09 2014 2.485465e+09 2.478270e+09 ... \n", + "331 1.260000e+07 2014 1.394594e+07 1.402875e+07 ... \n", + "334 3.900000e+09 2014 4.846656e+09 4.857140e+09 ... \n", + "339 5.000000e+05 2014 5.486675e+05 5.492871e+05 ... \n", + "340 2.500000e+07 2014 2.670606e+07 2.676927e+07 ... \n", + "344 4.000000e+07 2014 4.352258e+07 4.339898e+07 ... \n", + "345 3.000000e+07 2014 3.428317e+07 3.404744e+07 ... \n", + "346 5.000000e+08 2014 5.104338e+08 5.139659e+08 ... \n", + "352 2.770000e+07 2014 3.084603e+07 3.077374e+07 ... \n", + "359 3.000000e+08 2014 3.283428e+08 3.284805e+08 ... \n", + "365 5.550000e+08 2014 6.074341e+08 6.103254e+08 ... \n", + "369 1.654200e+07 2014 1.548398e+07 1.548091e+07 ... \n", + "406 2.500000e+09 2014 2.500000e+09 2.501602e+09 ... \n", + "427 8.230000e+08 2014 9.242430e+08 9.239007e+08 ... \n", + "428 1.100000e+06 2014 1.281242e+06 1.282842e+06 ... \n", + "429 9.000000e+07 2014 8.362720e+07 1.129343e+06 ... \n", + "437 5.000000e+07 2014 6.098482e+07 6.088808e+07 ... \n", + "451 2.000000e+06 2014 2.284435e+06 2.285643e+06 ... \n", + "456 2.500000e+08 2014 2.111764e+08 2.110753e+08 ... \n", + "457 2.000000e+06 2014 1.801876e+06 6.118379e+05 ... \n", + "458 1.320000e+10 2014 1.099275e+10 1.090424e+10 ... \n", + "459 2.000000e+07 2014 1.848489e+07 1.848665e+07 ... \n", + "460 5.000000e+08 2014 5.000000e+08 5.003790e+08 ... \n", + "462 3.000000e+09 2014 3.000000e+09 6.236200e+08 ... \n", + "463 1.456000e+09 2014 1.534596e+09 8.951186e+08 ... \n", + "464 6.300000e+07 2014 5.481371e+07 5.493466e+07 ... \n", + "465 6.800000e+10 2014 6.700905e+10 6.702718e+10 ... \n", + "\n", + " scale log_ratio unique_ID Associated_disaster Surge Rain Flood \\\n", + "326 1.0 -0.002899 2010-0260MEX True False False True \n", + "331 1.0 0.005920 2010-0468ATG True False False True \n", + "334 1.0 0.002161 2010-0494MEX True False False True \n", + "339 1.0 0.001129 2010-0571LCA True False False True \n", + "340 1.0 0.002364 2010-0571VCT False False False False \n", + "344 1.0 -0.002844 2011-0328BHS False False False False \n", + "345 1.0 -0.006900 2011-0328DOM True False False True \n", + "346 1.0 0.006896 2011-0328PRI True False False True \n", + "352 1.0 -0.002346 2011-0385MEX True False False True \n", + "359 1.0 0.000419 2012-0276MEX False False False False \n", + "365 1.0 0.004749 2012-0401MEX False False False False \n", + "369 1.0 -0.000198 2012-0410JAM False False False False \n", + "406 1.0 0.000640 2014-0333MEX True False False True \n", + "427 1.0 -0.000370 2015-0470MEX True False False True \n", + "428 1.0 0.001248 2015-0473CPV False False False False \n", + "429 1.0 -4.304733 2015-0479BHS True True False True \n", + "437 1.0 -0.001588 2016-0319MEX True False False True \n", + "451 1.0 0.000529 2017-0334MEX True False False True \n", + "456 1.0 -0.000479 2017-0381ATG False False False False \n", + "457 1.0 -1.080116 2017-0381BHS False False False False \n", + "458 1.0 -0.008085 2017-0381CUB True False False True \n", + "459 1.0 0.000095 2017-0381KNA False False False False \n", + "460 1.0 0.000758 2017-0381TCA True False False True \n", + "462 1.0 -1.570826 2017-0381VGB False False False False \n", + "463 1.0 -0.539066 2017-0383DMA True False False True \n", + "464 1.0 0.002204 2017-0383DOM True False False True \n", + "465 1.0 0.000271 2017-0383PRI True False False True \n", + "\n", + " Slide Other OtherThanSurge \n", + "326 False False True \n", + "331 False False True \n", + "334 False False True \n", + "339 True False True \n", + "340 False False False \n", + "344 False False False \n", + "345 False False True \n", + "346 False False True \n", + "352 True False True \n", + "359 False False False \n", + "365 False False False \n", + "369 False False False \n", + "406 False False True \n", + "427 False False True \n", + "428 False False False \n", + "429 False False True \n", + "437 False False True \n", + "451 True False True \n", + "456 False False False \n", + "457 False False False \n", + "458 False False True \n", + "459 False False False \n", + "460 False False True \n", + "462 False False False \n", + "463 True False True \n", + "464 True False True \n", + "465 False True True \n", + "\n", + "[27 rows x 22 columns]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "from climada.util.constants import SYSTEM_DIR\n", + "\n", + "emdat = pd.read_csv(SYSTEM_DIR / \"tc_impf_cal_v01_EDR.csv\")\n", + "emdat_subset = emdat[(emdat.cal_region2 == \"NA1\") & (emdat.year >= 2010)]\n", + "emdat_subset" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each entry in the database refers to an economic impact for a specific country and TC event.\n", + "The TC events are identified by the ID assigned from the International Best Track Archive for Climate Stewardship (IBTrACS).\n", + "We now want to reshape this data so that impacts are grouped by event and country.\n", + "\n", + "To achieve this, we iterate over the unique track IDs, select all reported damages associated with this ID, and concatenate the results.\n", + "For missing entries, `pandas` will set the value to NaN.\n", + "We assume that missing entries means that no damages are reported (this is a strong assumption), and set all NaN values to zero.\n", + "Then, we transpose the dataframe so that each row represents an event and each column states the damage for a specific country.\n", + "Finally, we set the track ID to be the index of the data frame." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
region_id284492132192212214388484630659662670796
ibtracsID
2010176N16278NaNNaNNaNNaNNaNNaNNaNNaN2.485465e+09NaNNaNNaNNaNNaN
2010236N123411.394594e+07NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
2010257N16282NaNNaNNaNNaNNaNNaNNaNNaN4.846656e+09NaNNaNNaNNaNNaN
2010302N09306NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN548667.501926706058.15NaN
2011233N15301NaN4.352258e+07NaNNaNNaNNaN34283168.75NaNNaN5.104338e+08NaNNaNNaNNaN
2011279N10257NaNNaNNaNNaNNaNNaNNaNNaN3.084603e+07NaNNaNNaNNaNNaN
2012166N09269NaNNaNNaNNaNNaNNaNNaNNaN6.074341e+08NaNNaNNaNNaNNaN
2012215N12313NaNNaNNaNNaNNaNNaNNaNNaN3.283428e+08NaNNaNNaNNaNNaN
2012296N14283NaNNaNNaNNaNNaNNaNNaN15483975.86NaNNaNNaNNaNNaNNaN
2014253N13260NaNNaNNaNNaNNaNNaNNaNNaN2.500000e+09NaNNaNNaNNaNNaN
2015242N12343NaNNaNNaN1281242.483NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
2015270N27291NaN8.362720e+07NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
2015293N13266NaNNaNNaNNaNNaNNaNNaNNaN9.242430e+08NaNNaNNaNNaNNaN
2016248N15255NaNNaNNaNNaNNaNNaNNaNNaN6.098482e+07NaNNaNNaNNaNNaN
2017219N16279NaNNaNNaNNaNNaNNaNNaNNaN2.284435e+06NaNNaNNaNNaNNaN
2017242N163332.111764e+081.801876e+063.000000e+09NaN1.099275e+10NaNNaNNaNNaNNaN18484889.46NaNNaN500000000.0
2017260N12310NaNNaNNaNNaNNaN1.534596e+0954813712.03NaNNaN6.700905e+10NaNNaNNaNNaN
\n", + "
" + ], + "text/plain": [ + "region_id 28 44 92 132 \\\n", + "ibtracsID \n", + "2010176N16278 NaN NaN NaN NaN \n", + "2010236N12341 1.394594e+07 NaN NaN NaN \n", + "2010257N16282 NaN NaN NaN NaN \n", + "2010302N09306 NaN NaN NaN NaN \n", + "2011233N15301 NaN 4.352258e+07 NaN NaN \n", + "2011279N10257 NaN NaN NaN NaN \n", + "2012166N09269 NaN NaN NaN NaN \n", + "2012215N12313 NaN NaN NaN NaN \n", + "2012296N14283 NaN NaN NaN NaN \n", + "2014253N13260 NaN NaN NaN NaN \n", + "2015242N12343 NaN NaN NaN 1281242.483 \n", + "2015270N27291 NaN 8.362720e+07 NaN NaN \n", + "2015293N13266 NaN NaN NaN NaN \n", + "2016248N15255 NaN NaN NaN NaN \n", + "2017219N16279 NaN NaN NaN NaN \n", + "2017242N16333 2.111764e+08 1.801876e+06 3.000000e+09 NaN \n", + "2017260N12310 NaN NaN NaN NaN \n", + "\n", + "region_id 192 212 214 388 \\\n", + "ibtracsID \n", + "2010176N16278 NaN NaN NaN NaN \n", + "2010236N12341 NaN NaN NaN NaN \n", + "2010257N16282 NaN NaN NaN NaN \n", + "2010302N09306 NaN NaN NaN NaN \n", + "2011233N15301 NaN NaN 34283168.75 NaN \n", + "2011279N10257 NaN NaN NaN NaN \n", + "2012166N09269 NaN NaN NaN NaN \n", + "2012215N12313 NaN NaN NaN NaN \n", + "2012296N14283 NaN NaN NaN 15483975.86 \n", + "2014253N13260 NaN NaN NaN NaN \n", + "2015242N12343 NaN NaN NaN NaN \n", + "2015270N27291 NaN NaN NaN NaN \n", + "2015293N13266 NaN NaN NaN NaN \n", + "2016248N15255 NaN NaN NaN NaN \n", + "2017219N16279 NaN NaN NaN NaN \n", + "2017242N16333 1.099275e+10 NaN NaN NaN \n", + "2017260N12310 NaN 1.534596e+09 54813712.03 NaN \n", + "\n", + "region_id 484 630 659 662 \\\n", + "ibtracsID \n", + "2010176N16278 2.485465e+09 NaN NaN NaN \n", + "2010236N12341 NaN NaN NaN NaN \n", + "2010257N16282 4.846656e+09 NaN NaN NaN \n", + "2010302N09306 NaN NaN NaN 548667.5019 \n", + "2011233N15301 NaN 5.104338e+08 NaN NaN \n", + "2011279N10257 3.084603e+07 NaN NaN NaN \n", + "2012166N09269 6.074341e+08 NaN NaN NaN \n", + "2012215N12313 3.283428e+08 NaN NaN NaN \n", + "2012296N14283 NaN NaN NaN NaN \n", + "2014253N13260 2.500000e+09 NaN NaN NaN \n", + "2015242N12343 NaN NaN NaN NaN \n", + "2015270N27291 NaN NaN NaN NaN \n", + "2015293N13266 9.242430e+08 NaN NaN NaN \n", + "2016248N15255 6.098482e+07 NaN NaN NaN \n", + "2017219N16279 2.284435e+06 NaN NaN NaN \n", + "2017242N16333 NaN NaN 18484889.46 NaN \n", + "2017260N12310 NaN 6.700905e+10 NaN NaN \n", + "\n", + "region_id 670 796 \n", + "ibtracsID \n", + "2010176N16278 NaN NaN \n", + "2010236N12341 NaN NaN \n", + "2010257N16282 NaN NaN \n", + "2010302N09306 26706058.15 NaN \n", + "2011233N15301 NaN NaN \n", + "2011279N10257 NaN NaN \n", + "2012166N09269 NaN NaN \n", + "2012215N12313 NaN NaN \n", + "2012296N14283 NaN NaN \n", + "2014253N13260 NaN NaN \n", + "2015242N12343 NaN NaN \n", + "2015270N27291 NaN NaN \n", + "2015293N13266 NaN NaN \n", + "2016248N15255 NaN NaN \n", + "2017219N16279 NaN NaN \n", + "2017242N16333 NaN 500000000.0 \n", + "2017260N12310 NaN NaN " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "track_ids = emdat_subset[\"ibtracsID\"].unique()\n", + "\n", + "data = pd.pivot_table(\n", + " emdat_subset,\n", + " values=\"emdat_impact_scaled\",\n", + " index=\"ibtracsID\",\n", + " columns=\"region_id\",\n", + " # fill_value=0,\n", + ")\n", + "data" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is the data against which we want to compare our model output.\n", + "Let's continue setting up the calibration!" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model Setup\n", + "\n", + "In the first step, we create the exposure layer for the model.\n", + "We use the {py:class}`~climada.entity.exposures.litpop.litpop.LitPop` module and simply pass the names of all countries listed in our calibration data to the {py:meth}`~climada.entity.exposures.litpop.litpop.LitPop.from_countries` classmethod.\n", + "The countries are the columns in the `data` object.\n", + "\n", + "Alternatively, we could have inserted `emdat_subset[\"region_id\"].unique().tolist()`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# from climada.entity.exposures.litpop import LitPop\n", + "# from climada.util import log_level\n", + "\n", + "# # Calculate the exposure\n", + "# with log_level(\"ERROR\"):\n", + "# exposure = LitPop.from_countries(data.columns.tolist())" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", + " setstate(state)\n", + "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", + " setstate(state)\n", + "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", + " setstate(state)\n", + "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", + " setstate(state)\n", + "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", + " setstate(state)\n", + "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", + " setstate(state)\n", + "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", + " setstate(state)\n", + "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", + " setstate(state)\n", + "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", + " setstate(state)\n", + "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", + " setstate(state)\n", + "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", + " setstate(state)\n", + "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", + " setstate(state)\n", + "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", + " setstate(state)\n", + "/Users/ldr.riedel/miniforge3/envs/climada_env_3.9/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", + " setstate(state)\n" + ] + } + ], + "source": [ + "from climada.util.api_client import Client\n", + "from climada.entity.exposures.litpop import LitPop\n", + "from climada.util.coordinates import country_to_iso\n", + "\n", + "client = Client()\n", + "exposure = LitPop.concat(\n", + " [\n", + " client.get_litpop(country_to_iso(country_id, representation=\"alpha3\"))\n", + " for country_id in data.columns\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'res_arcsec': ['150'],\n", + " 'event_type': ['observed'],\n", + " 'spatial_coverage': ['global'],\n", + " 'climate_scenario': ['None']}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from climada.util.api_client import Client\n", + "\n", + "client = Client()\n", + "tc_dataset_infos = client.list_dataset_infos(data_type=\"tropical_cyclone\")\n", + "client.get_property_values(\n", + " client.list_dataset_infos(data_type=\"tropical_cyclone\"),\n", + " known_property_values={\"event_type\": \"observed\", \"spatial_coverage\": \"global\"},\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will use the CLIMADA Data API to download readily computed wind fields from TC tracks.\n", + "The API provides a large dataset containing all historical TC tracks.\n", + "We will download them and then select the subset of TCs for which we have impact data by using {py:meth}`~climada.hazard.base.Hazard.select`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from climada.util.api_client import Client\n", + "\n", + "client = Client()\n", + "all_tcs = client.get_hazard(\n", + " \"tropical_cyclone\",\n", + " properties={\"event_type\": \"observed\", \"spatial_coverage\": \"global\"},\n", + ")\n", + "hazard = all_tcs.select(event_names=track_ids.tolist())" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**NOTE:** Discouraged! This will usually take a longer time than using the Data API\n", + "\n", + "Alternatively, CLIMADA provides the {py:class}`~climada.hazard.tc_tracks.TCTracks` class, which lets us download the tracks of TCs using their IBTrACS IDs.\n", + "We then have to equalize the time steps of the different TC tracks.\n", + "\n", + "The track and intensity of a cyclone are insufficient to compute impacts in CLIMADA.\n", + "We first have to re-compute a windfield from each track at the locations of interest.\n", + "For consistency, we simply choose the coordinates of the exposure." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# NOTE: Uncomment this to compute wind fields yourself\n", + "\n", + "# from climada.hazard import Centroids, TCTracks, TropCyclone\n", + "\n", + "# # Get the tracks for associated TCs\n", + "# tracks = TCTracks.from_ibtracs_netcdf(storm_id=track_ids.tolist())\n", + "# tracks.equal_timestep(time_step_h=1.0, land_params=False)\n", + "# tracks.plot()\n", + "\n", + "# # Calculate windfield for the tracks\n", + "# centroids = Centroids.from_lat_lon(exposure.gdf.latitude, exposure.gdf.longitude)\n", + "# hazard = TropCyclone.from_tracks(tracks, centroids)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Calibration Setup\n", + "\n", + "We are now set up to define the specifics of the calibration task.\n", + "First, let us define the impact function we actually want to calibrate.\n", + "We select the formula by Emanuel (2011), for which a shortcut exists in the CLIMADA code base: {py:meth}`~climada.entity.impact_funcs.trop_cyclone.ImpfTropCyclone.from_emanuel_usa`.\n", + "The sigmoid-like impact function takes three parameters, the wind threshold for any impact `v_thresh`, the wind speed where half of the impact occurs `v_half`, and the maximum impact factor `scale`.\n", + "According to the model by Emanuel (2011), `v_thresh` is considered a constant, so we choose to only calibrate the latter two.\n", + "\n", + "Any CLIMADA {py:class}`~climada.util.calibrate.base.Optimizer` will roughly perform the following algorithm:\n", + "1. Create a set of parameters and built an impact function (set) from it.\n", + "2. Compute an impact with that impact function set.\n", + "3. Compare the impact and the calibration data via the cost/target function.\n", + "4. Repeat N times or until the target function goal is reached.\n", + "\n", + "The selection of parameters is based on the target function varies strongly between different optimization algorithms.\n", + "\n", + "For the first step, we have to supply a function that takes the parameters we try to estimate and returns the impact function set that can later be used in an impact calculation.\n", + "We only calibrate a single function for the entire basin, so this is straightforward.\n", + "\n", + "To ensure the impact function is applied correctly, we also have to set the `impf_` column of the exposure `GeoDataFrame`.\n", + "Note that the default impact function ID is 1, and that the hazard type is `\"TC\"`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from climada.entity import ImpactFuncSet, ImpfTropCyclone\n", + "\n", + "# Match impact function and exposure\n", + "exposure.gdf[\"impf_TC\"] = 1\n", + "\n", + "\n", + "def impact_func_tc(v_half, scale):\n", + " return ImpactFuncSet([ImpfTropCyclone.from_emanuel_usa(v_half=v_half, scale=scale)])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will be using the {py:class}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizer`, which requires very little information on the parameter space beforehand.\n", + "One crucial information are the bounds of the parameters, though.\n", + "Initial values are not needed because the optimizer first samples the bound parameter space uniformly and then iteratively \"narrows down\" the search.\n", + "We choose a `v_half` between `v_thresh` and 150, and a scale between 0.01 (it must never be zero) and 1.0.\n", + "Specifying the bounds as dictionary (a must in case of `BayesianOptimizer`) also serves the purpose of naming the parameters we want to calibrate.\n", + "Notice that these names have to match the arguments of the impact function generator." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "bounds = {\"v_half\": (25.8, 150), \"scale\": (0.01, 1)}" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Defining the cost function is crucial for the result of the calibration.\n", + "You can choose what is best suited for your application.\n", + "Often, it is not clear which function works best, and it's a good idea to try out a few.\n", + "Because the impacts of different events may vary over several orders of magnitude, we select the mean squared logartihmic error (MSLE).\n", + "This one and other error measures are readily supplied by the `sklearn` package.\n", + "\n", + "The cost function must be defined as a function that takes the impact object calculated by the optimization algorithm and the input calibration data as arguments, and that returns a single number.\n", + "This number represents a \"cost\" of the parameter set used for calculating the impact.\n", + "A higher cost therefore is worse, a lower cost is better.\n", + "Any optimizer will try to minimize the cost.\n", + "\n", + "Note that the impact object is an instance of `Impact`, whereas the input calibration data is a `pd.DataFrame`.\n", + "To compute the MSLE, we first have to transform the impact into the same data structure, meaning that we have to aggregate the point-wise impacts by event and country.\n", + "The function performing this transformation task is provided to the {py:class}`~climada.util.calibrate.base.Input` via its {py:attr}`~climada.util.calibrate.base.Input.impact_to_dataframe` attribute.\n", + "Here we choose {py:meth}`climada.engine.impact.Impact.impact_at_reg`, which aggregates over countries by default.\n", + "To improve performance, we can supply this function with our known region IDs instead of re-computing them in every step.\n", + "\n", + "Computations on data frames align columns and indexes.\n", + "The indexes of the calibration data are the IBTrACS IDs, but the indexes of the result of `impact_at_reg` are the hazard event IDs, which at this point are only integer numbers.\n", + "To resolve that, we adjust our calibration dataframe to carry the respective `Hazard.event_id` as index." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
region_id284492132192212214388484630659662670796
event_id
1333NaNNaNNaNNaNNaNNaNNaNNaN2.485465e+09NaNNaNNaNNaNNaN
13391.394594e+07NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
1344NaNNaNNaNNaNNaNNaNNaNNaN4.846656e+09NaNNaNNaNNaNNaN
1351NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN548667.501926706058.15NaN
1361NaN4.352258e+07NaNNaNNaNNaN34283168.75NaNNaN5.104338e+08NaNNaNNaNNaN
3686NaNNaNNaNNaNNaNNaNNaNNaN3.084603e+07NaNNaNNaNNaNNaN
3691NaNNaNNaNNaNNaNNaNNaNNaN6.074341e+08NaNNaNNaNNaNNaN
1377NaNNaNNaNNaNNaNNaNNaNNaN3.283428e+08NaNNaNNaNNaNNaN
1390NaNNaNNaNNaNNaNNaNNaN15483975.86NaNNaNNaNNaNNaNNaN
3743NaNNaNNaNNaNNaNNaNNaNNaN2.500000e+09NaNNaNNaNNaNNaN
1421NaNNaNNaN1281242.483NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
1426NaN8.362720e+07NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
3777NaNNaNNaNNaNNaNNaNNaNNaN9.242430e+08NaNNaNNaNNaNNaN
3795NaNNaNNaNNaNNaNNaNNaNNaN6.098482e+07NaNNaNNaNNaNNaN
1450NaNNaNNaNNaNNaNNaNNaNNaN2.284435e+06NaNNaNNaNNaNNaN
14542.111764e+081.801876e+063.000000e+09NaN1.099275e+10NaNNaNNaNNaNNaN18484889.46NaNNaN500000000.0
1458NaNNaNNaNNaNNaN1.534596e+0954813712.03NaNNaN6.700905e+10NaNNaNNaNNaN
\n", + "
" + ], + "text/plain": [ + "region_id 28 44 92 132 \\\n", + "event_id \n", + "1333 NaN NaN NaN NaN \n", + "1339 1.394594e+07 NaN NaN NaN \n", + "1344 NaN NaN NaN NaN \n", + "1351 NaN NaN NaN NaN \n", + "1361 NaN 4.352258e+07 NaN NaN \n", + "3686 NaN NaN NaN NaN \n", + "3691 NaN NaN NaN NaN \n", + "1377 NaN NaN NaN NaN \n", + "1390 NaN NaN NaN NaN \n", + "3743 NaN NaN NaN NaN \n", + "1421 NaN NaN NaN 1281242.483 \n", + "1426 NaN 8.362720e+07 NaN NaN \n", + "3777 NaN NaN NaN NaN \n", + "3795 NaN NaN NaN NaN \n", + "1450 NaN NaN NaN NaN \n", + "1454 2.111764e+08 1.801876e+06 3.000000e+09 NaN \n", + "1458 NaN NaN NaN NaN \n", + "\n", + "region_id 192 212 214 388 484 \\\n", + "event_id \n", + "1333 NaN NaN NaN NaN 2.485465e+09 \n", + "1339 NaN NaN NaN NaN NaN \n", + "1344 NaN NaN NaN NaN 4.846656e+09 \n", + "1351 NaN NaN NaN NaN NaN \n", + "1361 NaN NaN 34283168.75 NaN NaN \n", + "3686 NaN NaN NaN NaN 3.084603e+07 \n", + "3691 NaN NaN NaN NaN 6.074341e+08 \n", + "1377 NaN NaN NaN NaN 3.283428e+08 \n", + "1390 NaN NaN NaN 15483975.86 NaN \n", + "3743 NaN NaN NaN NaN 2.500000e+09 \n", + "1421 NaN NaN NaN NaN NaN \n", + "1426 NaN NaN NaN NaN NaN \n", + "3777 NaN NaN NaN NaN 9.242430e+08 \n", + "3795 NaN NaN NaN NaN 6.098482e+07 \n", + "1450 NaN NaN NaN NaN 2.284435e+06 \n", + "1454 1.099275e+10 NaN NaN NaN NaN \n", + "1458 NaN 1.534596e+09 54813712.03 NaN NaN \n", + "\n", + "region_id 630 659 662 670 796 \n", + "event_id \n", + "1333 NaN NaN NaN NaN NaN \n", + "1339 NaN NaN NaN NaN NaN \n", + "1344 NaN NaN NaN NaN NaN \n", + "1351 NaN NaN 548667.5019 26706058.15 NaN \n", + "1361 5.104338e+08 NaN NaN NaN NaN \n", + "3686 NaN NaN NaN NaN NaN \n", + "3691 NaN NaN NaN NaN NaN \n", + "1377 NaN NaN NaN NaN NaN \n", + "1390 NaN NaN NaN NaN NaN \n", + "3743 NaN NaN NaN NaN NaN \n", + "1421 NaN NaN NaN NaN NaN \n", + "1426 NaN NaN NaN NaN NaN \n", + "3777 NaN NaN NaN NaN NaN \n", + "3795 NaN NaN NaN NaN NaN \n", + "1450 NaN NaN NaN NaN NaN \n", + "1454 NaN 18484889.46 NaN NaN 500000000.0 \n", + "1458 6.700905e+10 NaN NaN NaN NaN " + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = data.rename(\n", + " index={\n", + " hazard.event_name[idx]: hazard.event_id[idx]\n", + " for idx in range(len(hazard.event_id))\n", + " }\n", + ")\n", + "data.index.rename(\"event_id\", inplace=True)\n", + "data" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Execute the Calibration\n", + "\n", + "We created a class {py:class}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizerController` to control and guide the calibration process.\n", + "It is intended to walk through several optimization iterations and stop the process if the best guess cannot be improved.\n", + "The optimization works as follows:\n", + "\n", + "1. The optimizer randomly samples the parameter space {py:attr}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizerController.init_points` times.\n", + "2. The optimizer uses a Gaussian regression process to \"smartly\" sample the parameter space at most {py:attr}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizerController.n_iter` times.\n", + " * The process uses an \"Upper Confidence Bound\" sampling method whose parameter {py:attr}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizerController.kappa` indicates how close the sampled points are to the buest guess.\n", + " Higher `kappa` means more exploration of the parameter space, lower `kappa` means more exploitation.\n", + " * After each sample, the parameter `kappa` is reduced by the factor `kappa_decay`.\n", + " By default, this parameter is set such that `kappa` equals {py:attr}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizerController.kappa_min` at the last step.\n", + " This way, the sampling becomes more exploitative the more steps are taken.\n", + "3. The controller tracks the improvements of the buest guess for parameters.\n", + " If {py:attr}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizerController.min_improvement_count` consecutive improvements are lower than {py:attr}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizerController.min_improvement`, the smart sampling is stopped.\n", + " In this case, the `iterations` count is increased and the process repeated from step 1.\n", + "4. If an entire iteration did not show any improvement, the optimization is stopped.\n", + " It is also stopped when the {py:attr}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizerController.max_iterations` count is reached.\n", + "\n", + "Users can control the \"density\", and thus the accuracy of the sampling by adjusting the controller parameters.\n", + "Increasing `init_points`, `n_iter`, `min_improvement_count`, and `max_iterations`, and decreasing `min_improvement` generally increases density and accuracy, but leads to longer runtimes.\n", + "\n", + "We suggest using the `from_input` classmethod for a convenient choice of sampling density based on the parameter space.\n", + "The two parameters `init_points` and `n_iter` are set to $b^N$, where $N$ is the number of estimated parameters and $b$ is the `sampling_base` parameter, which defaults to 4.\n", + "\n", + "Now we can finally execute our calibration task!\n", + "We will plug all input parameters in an instance of `Input`, and then create the optimizer instance with it.\n", + "The `Optimizer.run` method returns an {py:class}`~climada.util.calibrate.base.Output` object, whose {py:attr}`~climada.util.calibrate.base.Output.params` attribute holds the optimal parameters determined by the calibration.\n", + "\n", + "Notice that the `BayesianOptimization` *maximizes* a target function.\n", + "Therefore, higher target values are *better* than lower ones in this case." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-04-29 14:09:45,569 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 0\n", + "2024-04-29 14:09:46,990 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 1\n", + "2024-04-29 14:09:49,255 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 2\n", + "2024-04-29 14:09:50,873 - climada.util.calibrate.bayesian_optimizer - INFO - Minimal improvement. Stop iteration.\n", + "2024-04-29 14:09:50,874 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 3\n", + "2024-04-29 14:09:52,698 - climada.util.calibrate.bayesian_optimizer - INFO - Minimal improvement. Stop iteration.\n", + "2024-04-29 14:09:52,699 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 4\n", + "2024-04-29 14:09:55,673 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 5\n", + "2024-04-29 14:09:58,819 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 6\n", + "2024-04-29 14:10:02,072 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 7\n", + "2024-04-29 14:10:06,238 - climada.util.calibrate.bayesian_optimizer - INFO - No improvement. Stop optimization.\n" + ] + } + ], + "source": [ + "from climada.util.calibrate import Input, BayesianOptimizer, BayesianOptimizerController\n", + "from sklearn.metrics import mean_squared_log_error\n", + "\n", + "from climada.util import log_level\n", + "\n", + "# Define calibration input\n", + "with log_level(\"INFO\", name_prefix=\"climada.util.calibrate\"):\n", + " input = Input(\n", + " hazard=hazard,\n", + " exposure=exposure,\n", + " data=data,\n", + " impact_func_creator=impact_func_tc,\n", + " cost_func=mean_squared_log_error,\n", + " impact_to_dataframe=lambda imp: imp.impact_at_reg(exposure.gdf[\"region_id\"]),\n", + " bounds=bounds,\n", + " )\n", + "\n", + " # Create and run the optimizer\n", + " opt = BayesianOptimizer(input)\n", + " controller = BayesianOptimizerController.from_input(input)\n", + " bayes_output = opt.run(controller)\n", + " bayes_output.params # The optimal parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate Output" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Bayesian Optimizer returns the entire paramter space it sampled via {py:class}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizerOutput`\n", + "We can find out a lot about the relation of the fitted parameters by investigating how the cost function value depends on them.\n", + "We can retrieve the parameter space as `pandas.DataFrame` via {py:meth}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizerOutput.p_space_to_dataframe`.\n", + "This dataframe has MultiIndex columns.\n", + "One group are the `Parameters`, the other holds information on the `Calibration` for each parameter set.\n", + "Notice that the optimal parameter set is not necessarily the last entry in the parameter space!" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ParametersCalibration
scalev_halfCost Function
Iteration
00.422852115.2643022.726950
10.01011363.3497064.133135
20.15528837.2684530.800611
30.19439868.7186421.683610
40.40280092.7210382.046407
............
2460.79059050.1645550.765166
2470.78842548.0436360.768636
2480.82670449.9323480.764991
2490.88073649.2905320.767437
2500.74452351.5966420.770761
\n", + "

251 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " Parameters Calibration\n", + " scale v_half Cost Function\n", + "Iteration \n", + "0 0.422852 115.264302 2.726950\n", + "1 0.010113 63.349706 4.133135\n", + "2 0.155288 37.268453 0.800611\n", + "3 0.194398 68.718642 1.683610\n", + "4 0.402800 92.721038 2.046407\n", + "... ... ... ...\n", + "246 0.790590 50.164555 0.765166\n", + "247 0.788425 48.043636 0.768636\n", + "248 0.826704 49.932348 0.764991\n", + "249 0.880736 49.290532 0.767437\n", + "250 0.744523 51.596642 0.770761\n", + "\n", + "[251 rows x 3 columns]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_space_df = bayes_output.p_space_to_dataframe()\n", + "p_space_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In contrast, the controller only tracks the consecutive improvements of the best guess." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
iterationrandomtargetimprovement
sample
00True-2.726950inf
20True-0.8006112.406088
230False-0.7994840.001409
250False-0.7941190.006756
290False-0.7917230.003026
401False-0.7811150.013581
441False-0.7779100.004119
551False-0.7725570.006929
882False-0.7686260.005115
922False-0.7684940.000172
932False-0.7681440.000456
1133False-0.7678890.000333
1153False-0.7671050.001021
1163False-0.7665610.000709
1223False-0.7664000.000211
1424False-0.7652100.001556
1464False-0.7649470.000343
1735False-0.7640000.001240
2166False-0.7639360.000084
\n", + "
" + ], + "text/plain": [ + " iteration random target improvement\n", + "sample \n", + "0 0 True -2.726950 inf\n", + "2 0 True -0.800611 2.406088\n", + "23 0 False -0.799484 0.001409\n", + "25 0 False -0.794119 0.006756\n", + "29 0 False -0.791723 0.003026\n", + "40 1 False -0.781115 0.013581\n", + "44 1 False -0.777910 0.004119\n", + "55 1 False -0.772557 0.006929\n", + "88 2 False -0.768626 0.005115\n", + "92 2 False -0.768494 0.000172\n", + "93 2 False -0.768144 0.000456\n", + "113 3 False -0.767889 0.000333\n", + "115 3 False -0.767105 0.001021\n", + "116 3 False -0.766561 0.000709\n", + "122 3 False -0.766400 0.000211\n", + "142 4 False -0.765210 0.001556\n", + "146 4 False -0.764947 0.000343\n", + "173 5 False -0.764000 0.001240\n", + "216 6 False -0.763936 0.000084" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "controller.improvements()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get one group of the columns, simply access the item." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
scalev_half
Iteration
00.422852115.264302
10.01011363.349706
20.15528837.268453
30.19439868.718642
40.40280092.721038
.........
2460.79059050.164555
2470.78842548.043636
2480.82670449.932348
2490.88073649.290532
2500.74452351.596642
\n", + "

251 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " scale v_half\n", + "Iteration \n", + "0 0.422852 115.264302\n", + "1 0.010113 63.349706\n", + "2 0.155288 37.268453\n", + "3 0.194398 68.718642\n", + "4 0.402800 92.721038\n", + "... ... ...\n", + "246 0.790590 50.164555\n", + "247 0.788425 48.043636\n", + "248 0.826704 49.932348\n", + "249 0.880736 49.290532\n", + "250 0.744523 51.596642\n", + "\n", + "[251 rows x 2 columns]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_space_df[\"Parameters\"]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that the optimal parameter set is not necessarily the last entry in the parameter space!\n", + "Therefore, let's order the parameter space by the ascending cost function values." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ParametersCalibration
scalev_halfCost Function
Iteration
2160.99374452.2556060.763936
1730.98572152.0265160.764000
1770.88114351.5586650.764718
1460.96728451.0347020.764947
2480.82670449.9323480.764991
............
350.028105118.9679246.298332
950.012842102.4493986.635728
1990.031310143.5379007.262185
990.025663141.2361047.504095
2320.010398147.1134869.453765
\n", + "

251 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " Parameters Calibration\n", + " scale v_half Cost Function\n", + "Iteration \n", + "216 0.993744 52.255606 0.763936\n", + "173 0.985721 52.026516 0.764000\n", + "177 0.881143 51.558665 0.764718\n", + "146 0.967284 51.034702 0.764947\n", + "248 0.826704 49.932348 0.764991\n", + "... ... ... ...\n", + "35 0.028105 118.967924 6.298332\n", + "95 0.012842 102.449398 6.635728\n", + "199 0.031310 143.537900 7.262185\n", + "99 0.025663 141.236104 7.504095\n", + "232 0.010398 147.113486 9.453765\n", + "\n", + "[251 rows x 3 columns]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_space_df = p_space_df.sort_values((\"Calibration\", \"Cost Function\"), ascending=True)\n", + "p_space_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The {py:class}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizerOutput` supplies the {py:meth}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizerOutput.plot_p_space` method for convenience.\n", + "If there were more than two parameters we calibrated, it would produce a plot for each parameter combination." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bayes_output.plot_p_space(x=\"v_half\", y=\"scale\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'scale': 0.9937435057717706, 'v_half': 52.25560598796059}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_space_df[\"Parameters\"].iloc[0, :].to_dict()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analyze the Calibration\n", + "\n", + "Now that we obtained a calibration result, we should investigate it further.\n", + "The tasks of evaluating results and plotting them is simplified by the {py:class}`~climada.util.calibrate.base.OutputEvaluator`.\n", + "It takes the input and output of a calibration task as parameters.\n", + "Let's start by plotting the optimized impact function:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from climada.util.calibrate import OutputEvaluator\n", + "\n", + "output_eval = OutputEvaluator(input, bayes_output)\n", + "output_eval.impf_set.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we show how the variability in parameter combinations with similar cost function values (as seen in the plot of the parameter space) translate to varying impact functions. In addition, the hazard value distribution is shown. Together this provides an intuitive overview regarding the robustness of the optimization, given the chosen cost function. It does NOT provide a view of the sampling uncertainty (as e.g. bootstrapping or cross-validation) NOR of the suitability of the cost function which is chosen by the user.\n", + "\n", + "This functionality is only available from the {py:class}`~climada.util.calibrate.bayesian_optimizer.BayesianOptimizerOutputEvaluator` tailored to Bayesian optimizer outputs.\n", + "It includes all function from {py:class}`~climada.util.calibrate.base.OutputEvaluator`." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from climada.util.calibrate import BayesianOptimizerOutputEvaluator, select_best\n", + "\n", + "output_eval = BayesianOptimizerOutputEvaluator(input, bayes_output)\n", + "\n", + "# Plot the impact function variability\n", + "output_eval.plot_impf_variability(select_best(p_space_df, 0.03), plot_haz=False)\n", + "output_eval.plot_impf_variability(select_best(p_space_df, 0.03))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The target function has limited meaning outside the calibration task.\n", + "To investigate the quality of the calibration, it is helpful to compute the impact with the impact function defined by the optimal parameters.\n", + "The {py:class}`~climada.util.calibrate.base.OutputEvaluator` readily computed this impact when it was created.\n", + "You can access the impact via the {py:attr}`~climada.util.calibrate.base.OutputEvaluator.impact` attribute." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
284492132192212214388484630659662670796
2010176N162780.000000e+000.000000e+000.000000e+000.0000000.000000e+000.000000e+000.000000e+000.000000e+001.641194e+090.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
2010236N123412.382896e+070.000000e+006.319901e+070.0000000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+007.558366e+071.253981e+070.000000e+000.000000e+000.000000e+00
2010257N162820.000000e+000.000000e+000.000000e+000.0000000.000000e+000.000000e+000.000000e+000.000000e+009.292543e+070.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
2010302N093060.000000e+000.000000e+000.000000e+000.0000000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+006.727897e+064.578844e+066.995127e+05
2011233N153010.000000e+001.230474e+092.364701e+070.0000000.000000e+000.000000e+007.109156e+040.000000e+000.000000e+007.094676e+080.000000e+000.000000e+000.000000e+001.383507e+08
2011279N102570.000000e+000.000000e+000.000000e+000.0000000.000000e+000.000000e+000.000000e+000.000000e+003.718903e+060.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
2012215N123130.000000e+000.000000e+000.000000e+000.0000000.000000e+000.000000e+000.000000e+000.000000e+001.577538e+080.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
2012166N092690.000000e+000.000000e+000.000000e+000.0000000.000000e+000.000000e+000.000000e+000.000000e+001.901566e+080.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
2012296N142830.000000e+001.323275e+080.000000e+000.0000002.751122e+090.000000e+000.000000e+003.101404e+090.000000e+000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
2014253N132600.000000e+000.000000e+000.000000e+000.0000000.000000e+000.000000e+000.000000e+000.000000e+001.352591e+100.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
2015293N132660.000000e+000.000000e+000.000000e+000.0000000.000000e+000.000000e+000.000000e+000.000000e+009.440247e+080.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
2015242N123430.000000e+000.000000e+000.000000e+00227605.6098030.000000e+000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
2015270N272910.000000e+008.433712e+050.000000e+000.0000000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
2016248N152550.000000e+000.000000e+000.000000e+000.0000000.000000e+000.000000e+000.000000e+000.000000e+003.127676e+090.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
2017219N162790.000000e+000.000000e+000.000000e+000.0000000.000000e+000.000000e+000.000000e+000.000000e+009.101261e+070.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
2017242N163333.750206e+081.354638e+064.684316e+080.0000003.369390e+090.000000e+002.693964e+070.000000e+000.000000e+001.172531e+104.040075e+080.000000e+000.000000e+008.060133e+08
2017260N123100.000000e+000.000000e+003.413228e+070.0000000.000000e+006.646546e+081.189164e+080.000000e+000.000000e+008.918857e+100.000000e+000.000000e+000.000000e+009.235309e+07
\n", + "
" + ], + "text/plain": [ + " 28 44 92 132 \\\n", + "2010176N16278 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", + "2010236N12341 2.382896e+07 0.000000e+00 6.319901e+07 0.000000 \n", + "2010257N16282 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", + "2010302N09306 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", + "2011233N15301 0.000000e+00 1.230474e+09 2.364701e+07 0.000000 \n", + "2011279N10257 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", + "2012215N12313 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", + "2012166N09269 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", + "2012296N14283 0.000000e+00 1.323275e+08 0.000000e+00 0.000000 \n", + "2014253N13260 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", + "2015293N13266 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", + "2015242N12343 0.000000e+00 0.000000e+00 0.000000e+00 227605.609803 \n", + "2015270N27291 0.000000e+00 8.433712e+05 0.000000e+00 0.000000 \n", + "2016248N15255 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", + "2017219N16279 0.000000e+00 0.000000e+00 0.000000e+00 0.000000 \n", + "2017242N16333 3.750206e+08 1.354638e+06 4.684316e+08 0.000000 \n", + "2017260N12310 0.000000e+00 0.000000e+00 3.413228e+07 0.000000 \n", + "\n", + " 192 212 214 388 \\\n", + "2010176N16278 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2010236N12341 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2010257N16282 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2010302N09306 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2011233N15301 0.000000e+00 0.000000e+00 7.109156e+04 0.000000e+00 \n", + "2011279N10257 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2012215N12313 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2012166N09269 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2012296N14283 2.751122e+09 0.000000e+00 0.000000e+00 3.101404e+09 \n", + "2014253N13260 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2015293N13266 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2015242N12343 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2015270N27291 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2016248N15255 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2017219N16279 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2017242N16333 3.369390e+09 0.000000e+00 2.693964e+07 0.000000e+00 \n", + "2017260N12310 0.000000e+00 6.646546e+08 1.189164e+08 0.000000e+00 \n", + "\n", + " 484 630 659 662 \\\n", + "2010176N16278 1.641194e+09 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2010236N12341 0.000000e+00 7.558366e+07 1.253981e+07 0.000000e+00 \n", + "2010257N16282 9.292543e+07 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2010302N09306 0.000000e+00 0.000000e+00 0.000000e+00 6.727897e+06 \n", + "2011233N15301 0.000000e+00 7.094676e+08 0.000000e+00 0.000000e+00 \n", + "2011279N10257 3.718903e+06 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2012215N12313 1.577538e+08 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2012166N09269 1.901566e+08 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2012296N14283 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2014253N13260 1.352591e+10 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2015293N13266 9.440247e+08 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2015242N12343 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2015270N27291 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2016248N15255 3.127676e+09 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2017219N16279 9.101261e+07 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "2017242N16333 0.000000e+00 1.172531e+10 4.040075e+08 0.000000e+00 \n", + "2017260N12310 0.000000e+00 8.918857e+10 0.000000e+00 0.000000e+00 \n", + "\n", + " 670 796 \n", + "2010176N16278 0.000000e+00 0.000000e+00 \n", + "2010236N12341 0.000000e+00 0.000000e+00 \n", + "2010257N16282 0.000000e+00 0.000000e+00 \n", + "2010302N09306 4.578844e+06 6.995127e+05 \n", + "2011233N15301 0.000000e+00 1.383507e+08 \n", + "2011279N10257 0.000000e+00 0.000000e+00 \n", + "2012215N12313 0.000000e+00 0.000000e+00 \n", + "2012166N09269 0.000000e+00 0.000000e+00 \n", + "2012296N14283 0.000000e+00 0.000000e+00 \n", + "2014253N13260 0.000000e+00 0.000000e+00 \n", + "2015293N13266 0.000000e+00 0.000000e+00 \n", + "2015242N12343 0.000000e+00 0.000000e+00 \n", + "2015270N27291 0.000000e+00 0.000000e+00 \n", + "2016248N15255 0.000000e+00 0.000000e+00 \n", + "2017219N16279 0.000000e+00 0.000000e+00 \n", + "2017242N16333 0.000000e+00 8.060133e+08 \n", + "2017260N12310 0.000000e+00 9.235309e+07 " + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "impact_data = output_eval.impact.impact_at_reg(exposure.gdf[\"region_id\"])\n", + "impact_data.set_index(np.asarray(hazard.event_name), inplace=True)\n", + "impact_data" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now compare the modelled and reported impact data on a country- or event-basis.\n", + "The `OutputEvaluator` also has methods for that.\n", + "In both of these, you can supply a transformation function with the `data_transf` argument.\n", + "This transforms the data to be plotted right before plotting.\n", + "Recall that we set the event IDs as index for the data frames.\n", + "To better interpret the results, it is useful to transform them into event names again, which are the IBTrACS IDs.\n", + "Likewise, we use the region IDs for region identification.\n", + "It might be nicer to transform these into country names before plotting." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "import climada.util.coordinates as u_coord\n", + "\n", + "\n", + "def country_code_to_name(code):\n", + " return u_coord.country_to_iso(code, representation=\"name\")\n", + "\n", + "\n", + "event_id_to_name = {\n", + " hazard.event_id[idx]: hazard.event_name[idx] for idx in range(len(hazard.event_id))\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "output_eval.plot_at_event(\n", + " data_transf=lambda x: x.rename(index=event_id_to_name), logy=True\n", + ")\n", + "output_eval.plot_at_region(\n", + " data_transf=lambda x: x.rename(index=country_code_to_name), logy=True\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we can do an event- *and* country-based comparison using a heatmap using {py:meth}`~climada.util.calibrate.base.OutputEvaluator.plot_event_region_heatmap`\n", + "Since the magnitude of the impact values may differ strongly, this method compare them on a logarithmic scale.\n", + "It divides each modelled impact by the observed impact and takes the the decadic logarithm.\n", + "The result will tell us how many orders of magnitude our model was off.\n", + "Again, the considerations for \"nicer\" index and columns apply." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "output_eval.plot_event_region_heatmap(\n", + " data_transf=lambda x: x.rename(index=event_id_to_name, columns=country_code_to_name)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Handling Missing Data\n", + "\n", + "NaN-valued input data has a special meaning in calibration: It implies that the impact calculated by the model for that data point should be ignored.\n", + "Opposed to that, a value of zero indicates that the model should be calibrated towards an impact of exactly zero for this data point.\n", + "\n", + "There might be instances where data is provided for a certain region or event, and the model produces no impact for them.\n", + "This is always treated as an impact of zero during the calibration.\n", + "Likewise, there might be instances where the model computes an impact for a region for which no impact data is available.\n", + "In these cases, {py:attr}`~climada.util.calibrate.base.Input.missing_data_value` of {py:class}`~climada.util.calibrate.base.Input` is used as fill value for the data.\n", + "According to the data value logic mentioned above, `missing_data_value=np.nan` (the default setting) will cause the modeled impact to be ignored in the calibration.\n", + "Setting `missing_data_value=0`, on the other hand, will calibrate the model towards zero impact for all regions or events where no data is supplied.\n", + "\n", + "Let's exemplify this with a subset of the data used for the last calibration.\n", + "Irma is the cyclone with ID `2017242N16333`, and it hit most locations we were looking at before.\n", + "It has the event ID `1454` in our setup.\n", + "Let's just use this hazard and the related data for now.\n", + "\n", + "NOTE: We must pass a dataframe to the input, but selecting a single row or column will return a Series.\n", + "We expand it into a dataframe again and make sure the new frame is oriented the correct way." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
region_id284492132192212214388484630659662670796
1454211176356.81801876.3213.000000e+09NaN1.099275e+10NaNNaNNaNNaNNaN18484889.46NaNNaN500000000.0
\n", + "
" + ], + "text/plain": [ + "region_id 28 44 92 132 192 212 \\\n", + "1454 211176356.8 1801876.321 3.000000e+09 NaN 1.099275e+10 NaN \n", + "\n", + "region_id 214 388 484 630 659 662 670 796 \n", + "1454 NaN NaN NaN NaN 18484889.46 NaN NaN 500000000.0 " + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hazard_irma = all_tcs.select(event_names=[\"2017242N16333\"])\n", + "data_irma = data.loc[1454, :].to_frame().T\n", + "data_irma" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's first calibrate the impact function only on this event, including all data we have." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "from climada.util.calibrate import (\n", + " Input,\n", + " BayesianOptimizer,\n", + " OutputEvaluator,\n", + " BayesianOptimizerOutputEvaluator,\n", + ")\n", + "from sklearn.metrics import mean_squared_log_error\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "def calibrate(hazard, data, **input_kwargs):\n", + " \"\"\"Calibrate using custom hazard and data\"\"\"\n", + " # Define calibration input\n", + " input = Input(\n", + " hazard=hazard,\n", + " exposure=exposure,\n", + " data=data,\n", + " impact_func_creator=impact_func_tc,\n", + " cost_func=mean_squared_log_error,\n", + " impact_to_dataframe=lambda imp: imp.impact_at_reg(exposure.gdf[\"region_id\"]),\n", + " bounds=bounds,\n", + " **input_kwargs,\n", + " )\n", + "\n", + " # Create and run the optimizer\n", + " with log_level(\"INFO\", name_prefix=\"climada.util.calibrate\"):\n", + " opt = BayesianOptimizer(input)\n", + " controller = BayesianOptimizerController.from_input(input)\n", + " bayes_output = opt.run(controller)\n", + "\n", + " # Evaluate output\n", + " output_eval = OutputEvaluator(input, bayes_output)\n", + " output_eval.impf_set.plot()\n", + "\n", + " plt.figure() # New figure because seaborn.heatmap draws into active axes\n", + " output_eval.plot_event_region_heatmap(\n", + " data_transf=lambda x: x.rename(\n", + " index=event_id_to_name, columns=country_code_to_name\n", + " )\n", + " )\n", + "\n", + " return bayes_output.params # The optimal parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-02-20 13:27:01,235 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 0\n", + "2024-02-20 13:27:02,398 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 1\n", + "2024-02-20 13:27:03,922 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 2\n", + "2024-02-20 13:27:05,573 - climada.util.calibrate.bayesian_optimizer - INFO - No improvement. Stop optimization.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "param_irma = calibrate(hazard_irma, data_irma)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we now remove some of the damage reports and repeat the calibration, the respective impact computed by the model will be ignored.\n", + "For Saint Kitts and Nevis, and for Turks and the Caicos Islands, the impact is overestimated by the model.\n", + "Removing these regions from the estimation should shift the estimated parameters accordingly, because by default, impacts for missing data points are ignored with `missing_data_value=np.nan`." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-02-20 13:27:12,398 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 0\n", + "2024-02-20 13:27:13,605 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 1\n", + "2024-02-20 13:27:14,991 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 2\n", + "2024-02-20 13:27:16,771 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 3\n", + "2024-02-20 13:27:18,916 - climada.util.calibrate.bayesian_optimizer - INFO - No improvement. Stop optimization.\n" + ] + }, + { + "data": { + "text/plain": [ + "{'scale': 0.9893201575415296, 'v_half': 46.03113797418196}" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "calibrate(hazard_irma, data_irma.drop(columns=[659, 796]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "However, the calibration should change into the other direction once we require the modeled impact at missing data points to be zero:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-02-20 13:27:25,785 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 0\n", + "2024-02-20 13:27:26,845 - climada.util.calibrate.bayesian_optimizer - INFO - Minimal improvement. Stop iteration.\n", + "2024-02-20 13:27:26,845 - climada.util.calibrate.bayesian_optimizer - INFO - Optimization iteration: 1\n", + "2024-02-20 13:27:28,241 - climada.util.calibrate.bayesian_optimizer - INFO - No improvement. Stop optimization.\n" + ] + }, + { + "data": { + "text/plain": [ + "{'scale': 0.07120177027571553, 'v_half': 134.9655530108171}" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "calibrate(hazard_irma, data_irma.drop(columns=[659, 796]), missing_data_value=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Actively requiring that the model calibrates towards zero impact in the two dropped regions means that it will typically strongly overestimate the impact there (because impact actually took place).\n", + "This will \"flatten\" the vulnerability curve, causing strong underestimation in the other regions." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## How to Continue\n", + "\n", + "While the found impact function looks reasonable, we find that the model overestimates the impact severely for several events.\n", + "This might be due to missing data, but it is also strongly related to the choice of impact function (shape) and the particular goal of the calibration task.\n", + "\n", + "The most crucial information in the calibration task is the cost function.\n", + "The RMSE measure is sensitive to the largest errors (and hence the largest impact).\n", + "Therefore, using it in the calibration minimizes the overall error, but will incorrectly capture events with impact of lower orders of magnitude.\n", + "Using a cost function based on the ratio between modelled and observed impact might increase the overall error but decrease the log-error for many events.\n", + "\n", + "So we present some ideas on how to continue and/or improve the calibration:\n", + "\n", + "1. Run the calibration again, but change the number of initial steps and/or iteration steps.\n", + "2. Use a different cost function, e.g., an error measure based on a ratio rather than a difference.\n", + "3. Also calibrate the `v_thresh` parameter. This requires adding constraints, because `v_thresh` < `v_half`.\n", + "4. Calibrate different impact functions for houses in Mexico and Puerto Rico within the same optimization task.\n", + "5. Employ the {py:class}`~climada.util.calibrate.scipy_optimizer.ScipyMinimizeOptimizer` instead of the `BayesianOptimizer`." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "climada_env_3.9", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/requirements/env_climada.yml b/requirements/env_climada.yml index 646e7cd77c..3f1cc9741a 100644 --- a/requirements/env_climada.yml +++ b/requirements/env_climada.yml @@ -31,6 +31,7 @@ dependencies: - rasterio>=1.3 - requests>=2.31 - salib>=1.4 + - seaborn>=0.13 - scikit-learn>=1.4 - scipy>=1.12 - sparse>=0.15 diff --git a/setup.py b/setup.py index bb9efe2fb3..0961cf1b59 100644 --- a/setup.py +++ b/setup.py @@ -60,6 +60,7 @@ python_requires=">=3.9,<3.12", install_requires=[ + 'bayesian-optimization', 'bottleneck', 'cartopy', 'cfgrib', @@ -85,6 +86,7 @@ 'rasterio', 'salib', 'scikit-learn', + 'seaborn', 'statsmodels', 'sparse', 'tables',