{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "aa9d9193-b135-4658-b03d-1ff38f779549",
   "metadata": {},
   "source": [
    "# Custom Calibrators\n",
    "\n",
    "The following tutorial demonstrates how one may create a custom calibrator to perform your own calibration workflows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cfd1dd54-8cd4-4ccc-bd85-2fc107f2c89f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.optimize import differential_evolution\n",
    "\n",
    "from calisim.base import CalibrationWorkflowBase\n",
    "from calisim.data_model import (\n",
    "\tDistributionModel,\n",
    "\tParameterDataType,\n",
    "\tParameterSpecification,\n",
    ")\n",
    "from calisim.data_model import ParameterDataType, ParameterEstimateModel\n",
    "\n",
    "from calisim.example_models import LotkaVolterraModel\n",
    "from calisim.optimisation import OptimisationMethod, OptimisationMethodModel\n",
    "from calisim.statistics import MeanSquaredError\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8117e8e2-0e98-45dd-862a-9557996eccc1",
   "metadata": {},
   "source": [
    "## Creating a Calibrator\n",
    "\n",
    "Let's create a custom calibrator called `SciPyDEOptimisation` that uses [SciPy's](https://scipy.org/) differential evolution algorithm for calibrating models via black-box optimisation. All custom calibrators must inherit from the `CalibrationWorkflowBase` abstract class.\n",
    "\n",
    "```python\n",
    "class SciPyDEOptimisation(CalibrationWorkflowBase):\n",
    "    \"\"\"The SciPy differential evolution optimisation method class.\"\"\"\n",
    "```\n",
    "\n",
    "The `CalibrationWorkflowBase` class defines three abstract methods which must be implemented by your calibrator:\n",
    "\n",
    "- `specify()`: Specify the parameters of the model calibration procedure.\n",
    "- `execute()`: Execute the simulation calibration procedure.\n",
    "- `analyze()`: Analyze the results of the simulation calibration procedure.\n",
    "\n",
    "### Specify\n",
    "\n",
    "Let's first define `specify()`:\n",
    "\n",
    "```python\n",
    "def specify(self) -> None:\n",
    "    \"\"\"Specify the parameters of the model calibration procedure.\"\"\"\n",
    "    self.names = []\n",
    "    self.data_types = []\n",
    "    self.bounds = []\n",
    "    \n",
    "    parameter_spec = self.specification.parameter_spec.parameters\n",
    "    for spec in parameter_spec:\n",
    "        parameter_name = spec.name\n",
    "        data_type = spec.data_type\n",
    "    \n",
    "        if data_type == ParameterDataType.CONSTANT:\n",
    "            parameter_value = spec.parameter_value\n",
    "            self.constants[parameter_name] = parameter_value\n",
    "            continue\n",
    "        elif data_type == ParameterDataType.CATEGORICAL:\n",
    "            bounds = self.set_categorical_parameter(spec)\n",
    "        else:\n",
    "            bounds = self.get_parameter_bounds(spec)  \n",
    "    \n",
    "        self.names.append(parameter_name)\n",
    "        self.data_types.append(data_type)\n",
    "        self.bounds.append(bounds)\n",
    "```\n",
    "\n",
    "We can see that our calibrator loops through each parameter specification within a `ParameterSpecification` collection object. \n",
    "\n",
    "`CalibrationWorkflowBase` has a `constants` dictionary for storing **CONSTANT** parameter data types. `CalibrationWorkflowBase` defines a method called `set_categorical_parameter()` for dealing with **CATEGORICAL** data, which returns lower and upper parameter bounds. For **CONTINUOUS** and **DISCRETE** data, `CalibrationWorkflowBase` defines a method called `get_parameter_bounds()` which returns the lower and upper parameter bounds. \n",
    "\n",
    "Finally, we store the parameter names, data types, and bounds within three lists.\n",
    "\n",
    "### Execute\n",
    "\n",
    "Let's next define `execute()`:\n",
    "\n",
    "```python\n",
    "def execute(self) -> None:\n",
    "    \"\"\"Execute the simulation calibration procedure.\"\"\"\n",
    "    optimisation_kwargs = self.get_calibration_func_kwargs()\n",
    "\n",
    "    self.history = []\n",
    "    self.eval_count = 0\n",
    "    output_labels = self.specification.output_labels\n",
    "    if output_labels is None:\n",
    "        output_labels = [\"target\"]\n",
    "        \n",
    "    def target_function(X: np.ndarray) -> np.ndarray:\n",
    "        X_dict = {\n",
    "            name: X[i]\n",
    "            for i, name in enumerate(self.names)\n",
    "        }\n",
    "        X = [X]\n",
    "        \n",
    "        Y = self.calibration_func_wrapper(\n",
    "            X,\n",
    "            self,\n",
    "            self.specification.observed_data,\n",
    "            self.names,\n",
    "            self.data_types,\n",
    "            optimisation_kwargs,\n",
    "        )\n",
    "\n",
    "        X_dict[\"eval_count\"] = self.eval_count\n",
    "        self.eval_count += 1\n",
    "        X_dict[output_labels[0]] = Y\n",
    "        self.history.append(X_dict)\n",
    "    \n",
    "        return Y\n",
    "    \n",
    "    n_iterations = self.specification.n_iterations\n",
    "    verbose = self.specification.verbose\n",
    "    n_jobs = self.specification.n_jobs\n",
    "    random_seed = self.specification.random_seed\n",
    "\n",
    "    method_kwargs = self.specification.method_kwargs\n",
    "    if method_kwargs is None:\n",
    "        method_kwargs = {}\n",
    "            \n",
    "    self.study = differential_evolution(\n",
    "        target_function,\n",
    "        self.bounds,\n",
    "        maxiter=n_iterations,\n",
    "        disp=verbose,\n",
    "        workers=n_jobs,\n",
    "        seed=random_seed,\n",
    "        **method_kwargs\n",
    "    )\n",
    "```\n",
    "\n",
    "The `CalibrationWorkflowBase` class defines a getter method called `get_calibration_func_kwargs()` that retrieves the `calibration_func_kwargs` values supplied to the `OptimisationMethodModel` object's constructor. This allows us to include custom arguments within our objective function. \n",
    "\n",
    "Our `SciPyDEOptimisation` class will store the trial history and number of objective function evaluations using two properties (`self.history` and `self.eval_count`). We specify the names of our objectives using the `output_labels` field within our `OptimisationMethodModel` specification.\n",
    "\n",
    "We define a function called `target_function()` which will be executed by the differential evolution algorithm. This function calls the `calibration_func_wrapper()` method, which is defined by our `CalibrationWorkflowBase` base class. `calibration_func_wrapper()` will perform some data preprocessing and call our objective function under the hood.\n",
    "\n",
    "We retrieve several `OptimisationMethodModel` specification values:\n",
    "\n",
    "- `n_iterations`: The number of trial iterations for optimisation.\n",
    "- `verbose`: The verbosity of the calibration procedure. How much detail is provided in the outputs.\n",
    "- `n_jobs`: The number of jobs to run for parallel processing.\n",
    "- `random_seed`: The random seed for replicability due to stochasticity.\n",
    "- `method_kwargs`: Named arguments to pass to the calibration procedure when the default values are insufficient.\n",
    "\n",
    "Finally, we execute the `differential_evolution()` algorithm to perform calibration.\n",
    "\n",
    "### Analyze\n",
    "\n",
    "We must next define `analyze()`:\n",
    "\n",
    "```python\n",
    "def analyze(self) -> None:\n",
    "    \"\"\"Analyze the results of the simulation calibration procedure.\"\"\"\n",
    "    task, time_now, experiment_name, outdir = self.prepare_analyze()\n",
    "\n",
    "    output_labels = self.specification.output_labels\n",
    "    if output_labels is None:\n",
    "        output_labels = [\"target\"]\n",
    "        \n",
    "    trials_df = pd.DataFrame(self.history)\n",
    "    trials_df_best = trials_df.sort_values(output_labels).head(1)\n",
    "    for col in trials_df_best.columns:\n",
    "        if col in output_labels or col == \"eval_count\":\n",
    "            continue\n",
    "        estimate = trials_df_best[col].item()\n",
    "        parameter_estimate = ParameterEstimateModel(name=col, estimate=estimate)\n",
    "        self.add_parameter_estimate(parameter_estimate)\n",
    "\n",
    "    for output_label in output_labels:\n",
    "        ax  = trials_df.plot.scatter(\"eval_count\", output_label, figsize=self.specification.figsize)\n",
    "        fig = ax.get_figure()\n",
    "        ax.set_title(f\"Optimisation history: {output_label}\")\n",
    "        \n",
    "        self.present_fig(\n",
    "            fig, outdir, time_now, task, experiment_name, f\"plot-optimization-history-{output_label}\"\n",
    "        )\n",
    "\n",
    "    fig, axes = plt.subplots(nrows = len(self.names), figsize=self.specification.figsize)\n",
    "    for i, name in enumerate(self.names):\n",
    "        trials_df.plot.scatter(name, \"eval_count\", ax=axes[i])\n",
    "        axes[i].invert_yaxis()\n",
    "        axes[i].set_title(f\"Parameter: {name}\")\n",
    "    self.present_fig(\n",
    "        fig, outdir, time_now, task, experiment_name, \"plot-slice\"\n",
    "    )\n",
    "        \n",
    "    if outdir is None:\n",
    "        return\n",
    "    \n",
    "    self.to_csv(trials_df, \"trials\")\n",
    "\n",
    "```\n",
    "\n",
    "The `prepare_analyze()` method retrieves several values which are needed to store data to file.\n",
    "\n",
    "From our `self.history` property, we can construct a trial history [Pandas dataframe](https://pandas.pydata.org/). We retrieve the best trial from the dataframe, and thereafter save the optimised parameter estimates within `ParameterEstimateModel` objects, which are then added to a list of parameter estimates via the `add_parameter_estimate()` method.\n",
    "\n",
    "We loop through each named objective (`output_labels`) and construct a scatter plot visualising the relationship between the objective values and the trial evaluation number. The `CalibrationWorkflowBase` class defines the `present_fig()` method which will either save the scatter plot to file or directly render and open the plot to the user's screen. We also loop through each named parameter (`self.names`) and similarly create scatter plots to visualise the relationship between parameter values and the trial evaluation number. \n",
    "\n",
    "Finally, if the `outdir` directory is provided, we save the trial history dataframe as a `csv` file.\n",
    "\n",
    "Let's put all of this code together into one `SciPyDEOptimisation` class: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "12eb9d59-0524-4443-8a05-605325fdfb6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SciPyDEOptimisation(CalibrationWorkflowBase):\n",
    "    \"\"\"The SciPy differential evolution optimisation method class.\"\"\"\n",
    "\n",
    "    def specify(self) -> None:\n",
    "        \"\"\"Specify the parameters of the model calibration procedure.\"\"\"\n",
    "        self.names = []\n",
    "        self.data_types = []\n",
    "        self.bounds = []\n",
    "        \n",
    "        parameter_spec = self.specification.parameter_spec.parameters\n",
    "        for spec in parameter_spec:\n",
    "            parameter_name = spec.name\n",
    "            data_type = spec.data_type\n",
    "        \n",
    "            if data_type == ParameterDataType.CONSTANT:\n",
    "                parameter_value = spec.parameter_value\n",
    "                self.constants[parameter_name] = parameter_value\n",
    "                continue\n",
    "            elif data_type == ParameterDataType.CATEGORICAL:\n",
    "                bounds = self.set_categorical_parameter(spec)\n",
    "            else:\n",
    "                bounds = self.get_parameter_bounds(spec)  \n",
    "        \n",
    "            self.names.append(parameter_name)\n",
    "            self.data_types.append(data_type)\n",
    "            self.bounds.append(bounds)\n",
    "\n",
    "    def execute(self) -> None:\n",
    "        \"\"\"Execute the simulation calibration procedure.\"\"\"\n",
    "        optimisation_kwargs = self.get_calibration_func_kwargs()\n",
    "\n",
    "        self.history = []\n",
    "        self.eval_count = 0\n",
    "        output_labels = self.specification.output_labels\n",
    "        if output_labels is None:\n",
    "            output_labels = [\"target\"]\n",
    "            \n",
    "        def target_function(X: np.ndarray) -> np.ndarray:\n",
    "            X_dict = {\n",
    "                name: X[i]\n",
    "                for i, name in enumerate(self.names)\n",
    "            }\n",
    "            X = [X]\n",
    "            \n",
    "            Y = self.calibration_func_wrapper(\n",
    "                X,\n",
    "                self,\n",
    "                self.specification.observed_data,\n",
    "                self.names,\n",
    "                self.data_types,\n",
    "                optimisation_kwargs,\n",
    "            )\n",
    "\n",
    "            X_dict[\"eval_count\"] = self.eval_count\n",
    "            self.eval_count += 1\n",
    "            X_dict[output_labels[0]] = Y\n",
    "            self.history.append(X_dict)\n",
    "        \n",
    "            return Y\n",
    "        \n",
    "        n_iterations = self.specification.n_iterations\n",
    "        verbose = self.specification.verbose\n",
    "        n_jobs = self.specification.n_jobs\n",
    "        random_seed = self.specification.random_seed\n",
    "\n",
    "        method_kwargs = self.specification.method_kwargs\n",
    "        if method_kwargs is None:\n",
    "            method_kwargs = {}\n",
    "                \n",
    "        self.study = differential_evolution(\n",
    "            target_function,\n",
    "            self.bounds,\n",
    "            maxiter=n_iterations,\n",
    "            disp=verbose,\n",
    "            workers=n_jobs,\n",
    "            seed=random_seed,\n",
    "            **method_kwargs\n",
    "        )\n",
    "\n",
    "    def analyze(self) -> None:\n",
    "        \"\"\"Analyze the results of the simulation calibration procedure.\"\"\"\n",
    "        task, time_now, experiment_name, outdir = self.prepare_analyze()\n",
    "\n",
    "        output_labels = self.specification.output_labels\n",
    "        if output_labels is None:\n",
    "            output_labels = [\"target\"]\n",
    "            \n",
    "        trials_df = pd.DataFrame(self.history)\n",
    "        trials_df_best = trials_df.sort_values(output_labels).head(1)\n",
    "        for col in trials_df_best.columns:\n",
    "            if col in output_labels or col == \"eval_count\":\n",
    "                continue\n",
    "            estimate = trials_df_best[col].item()\n",
    "            parameter_estimate = ParameterEstimateModel(name=col, estimate=estimate)\n",
    "            self.add_parameter_estimate(parameter_estimate)\n",
    "\n",
    "        for output_label in output_labels:\n",
    "            ax  = trials_df.plot.scatter(\"eval_count\", output_label, figsize=self.specification.figsize)\n",
    "            fig = ax.get_figure()\n",
    "            ax.set_title(f\"Optimisation history: {output_label}\")\n",
    "            \n",
    "            self.present_fig(\n",
    "                fig, outdir, time_now, task, experiment_name, f\"plot-optimization-history-{output_label}\"\n",
    "            )\n",
    "\n",
    "        fig, axes = plt.subplots(nrows = len(self.names), figsize=self.specification.figsize)\n",
    "        for i, name in enumerate(self.names):\n",
    "            trials_df.plot.scatter(name, \"eval_count\", ax=axes[i])\n",
    "            axes[i].invert_yaxis()\n",
    "            axes[i].set_title(f\"Parameter: {name}\")\n",
    "        self.present_fig(\n",
    "            fig, outdir, time_now, task, experiment_name, \"plot-slice\"\n",
    "        )\n",
    "            \n",
    "        if outdir is None:\n",
    "            return\n",
    "        \n",
    "        self.to_csv(trials_df, \"trials\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66d1536d-48cc-42dc-8f28-0bc67aac1dad",
   "metadata": {},
   "source": [
    "## Performing Calibration\n",
    "\n",
    "That covers the end-to-end process of creating a custom calibrator. Let's try calibrating an example model: `LotkaVolterraModel`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "311b2b8d-6ed1-435f-9142-4db763a4901f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>year</th>\n",
       "      <th>lynx</th>\n",
       "      <th>hare</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1900.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>30.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1901.0</td>\n",
       "      <td>6.1</td>\n",
       "      <td>47.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1902.0</td>\n",
       "      <td>9.8</td>\n",
       "      <td>70.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1903.0</td>\n",
       "      <td>35.2</td>\n",
       "      <td>77.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1904.0</td>\n",
       "      <td>59.4</td>\n",
       "      <td>36.3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     year  lynx  hare\n",
       "0  1900.0   4.0  30.0\n",
       "1  1901.0   6.1  47.2\n",
       "2  1902.0   9.8  70.2\n",
       "3  1903.0  35.2  77.4\n",
       "4  1904.0  59.4  36.3"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = LotkaVolterraModel()\n",
    "observed_data = model.get_observed_data()\n",
    "observed_data.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7500f441-8605-4571-b09e-02291d1f79c5",
   "metadata": {},
   "source": [
    "We'll define our parameter specification containing parameter names, data types, distribution types, and bounds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "55bed38a-3819-49ca-983d-cfc98a8c8e58",
   "metadata": {},
   "outputs": [],
   "source": [
    "parameter_spec = ParameterSpecification(\n",
    "\tparameters=[\n",
    "\t\tDistributionModel(\n",
    "\t\t\tname=\"alpha\",\n",
    "\t\t\tdistribution_name=\"uniform\",\n",
    "\t\t\tdistribution_args=[0.45, 0.55],\n",
    "\t\t\tdata_type=ParameterDataType.CONTINUOUS,\n",
    "\t\t),\n",
    "\t\tDistributionModel(\n",
    "\t\t\tname=\"beta\",\n",
    "\t\t\tdistribution_name=\"uniform\",\n",
    "\t\t\tdistribution_args=[0.02, 0.03],\n",
    "\t\t\tdata_type=ParameterDataType.CONTINUOUS,\n",
    "\t\t),\n",
    "\t]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b724352-0b89-4224-b2fb-db68a74eb053",
   "metadata": {},
   "source": [
    "We'll define our objective function. We aim to minimise the discrepancy between simulated and observed data using the `MeanSquaredError` metric as our loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "93f3c7fe-f043-4f49-8fa2-4ca8e6f6ea36",
   "metadata": {},
   "outputs": [],
   "source": [
    "def objective(\n",
    "\tparameters: dict, simulation_id: str, observed_data: np.ndarray | None, t: pd.Series\n",
    ") -> float | list[float]:\n",
    "\tsimulation_parameters = dict(h0=34.0, l0=5.9, t=t, gamma=0.84, delta=0.026)\n",
    "\n",
    "\tfor k in [\"alpha\", \"beta\"]:\n",
    "\t\tsimulation_parameters[k] = parameters[k]\n",
    "\n",
    "\tsimulated_data = model.simulate(simulation_parameters).lynx.values\n",
    "\tmetric = MeanSquaredError()\n",
    "\tdiscrepancy = metric.calculate(observed_data, simulated_data)\n",
    "\treturn discrepancy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d62ba85-2849-457f-8454-1293436ea79f",
   "metadata": {},
   "source": [
    "We'll define the specification for the differential evolution optimisation procedure. This will include the number of opimisation iterations (`n_iterations`), the name of the optimisation objectives (`output_labels`), and the named arguments to pass to SciPy's differential evolution function (`method_kwargs`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "94a06096-fec2-4482-bbfe-232790afb5ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "specification = OptimisationMethodModel(\n",
    "\texperiment_name=\"scipy_optimisation\",\n",
    "\tparameter_spec=parameter_spec,\n",
    "\tobserved_data=observed_data.lynx.values,\n",
    "\tn_iterations=100,\n",
    "\toutput_labels=[\"Lynx\"],\n",
    "\tmethod_kwargs=dict(\n",
    "\t\tinit='latinhypercube',\n",
    "        popsize=15\n",
    "\t),\n",
    "\tcalibration_func_kwargs=dict(t=observed_data.year),\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bf51928-5267-4460-ad49-e160ffb78902",
   "metadata": {},
   "source": [
    "Finally, let's run the calibration workflow by instantiating an `OptimisationMethod` calibrator, and subsequently calling the `specify()`, `execute()`, and `analyze()` methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "134dbf48-c8eb-478e-ace8-3b9e09bad186",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<calisim.optimisation.implementation.OptimisationMethod at 0x7fbde9e427a0>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x1200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x1200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "calibrator = OptimisationMethod(\n",
    "\tcalibration_func=objective, \n",
    "    specification=specification, \n",
    "    implementation=SciPyDEOptimisation\n",
    ")\n",
    "\n",
    "calibrator.specify().execute().analyze()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0b94d71-a064-470f-bc41-ac1eece26ef8",
   "metadata": {},
   "source": [
    "The differential evolution algorithm was able to recover the ground truth parameters for the simulation study."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d1751120-5b91-4b48-a5e5-c8da53870e79",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>parameter</th>\n",
       "      <th>estimate</th>\n",
       "      <th>ground truth</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>alpha</td>\n",
       "      <td>0.512032</td>\n",
       "      <td>0.520</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>beta</td>\n",
       "      <td>0.024060</td>\n",
       "      <td>0.024</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  parameter  estimate  ground truth\n",
       "0     alpha  0.512032         0.520\n",
       "1      beta  0.024060         0.024"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame([\n",
    "    { \"parameter\": estimate.name, \"estimate\": estimate.estimate, \"ground truth\": model.GROUND_TRUTH[estimate.name] }\n",
    "    for estimate in calibrator.get_parameter_estimates().estimates\n",
    "])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}