{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "2b4a762c",
      "metadata": {},
      "source": [
        "# Bayesian Optimization with AFL Pipelines\n",
        "\n",
        "This tutorial shows an end-to-end Bayesian optimization campaign that stays native to the AFL pipeline API while using the BoTorch-backed `BoTorchRegressor` and `BoTorchAcquisition` ops.\n",
        "\n",
        "Each optimization round runs the same AFL `Pipeline` on the current `xarray.Dataset`, reads the recommended next sample from the pipeline outputs, evaluates a BoTorch standard test function, and appends the new observation back into the dataset.\n",
        "\n",
        "The notebook is written for low-dimensional synthetic objectives from `botorch.test_functions.synthetic`, such as `Branin`, `Ackley`, and `Hartmann`."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f5a63e73",
      "metadata": {},
      "source": [
        "## 1. Set Up the Environment\n",
        "\n",
        "Import the libraries used for the optimization campaign, configure plotting, and set a reproducible random seed."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "aa915915",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Uncomment this cell if you need to install AFL-agent with BoTorch support.\n",
        "# !pip install -e .[botorch]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "6fb7bd87",
      "metadata": {},
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import xarray as xr\n",
        "from AFL.double_agent import (\n",
        "    Pipeline,\n",
        "    CartesianGrid,\n",
        "    Standardize,\n",
        "    BoTorchRegressor,\n",
        "    BoTorchAcquisition,\n",
        ")\n",
        "\n",
        "\n",
        "plt.style.use(\"seaborn-v0_8-whitegrid\")\n",
        "\n",
        "rng = np.random.default_rng(7)\n",
        "np.set_printoptions(precision=4, suppress=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "06a715b5",
      "metadata": {},
      "outputs": [],
      "source": [
        "# set campaign parameters\n",
        "N_ITERATIONS = 10\n",
        "N_INITIAL = 5\n",
        "N_BATCH = 1"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3d99c096",
      "metadata": {},
      "source": [
        "## 2. Define the Objective Function\n",
        "\n",
        "BoTorch ships a collection of standard synthetic test functions. The helper below loads one by name, exposes its bounds, and evaluates it on NumPy arrays while preserving the original objective convention."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "8b926bd0",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Objective function: Branin has bounds [[-5. 10.]\n",
            " [ 0. 15.]] \n",
            "and global minimum value 0.3979 at \n",
            "[[-3.1416 12.275 ]\n",
            " [ 3.1416  2.275 ]\n",
            " [ 9.4248  2.475 ]]\n"
          ]
        }
      ],
      "source": [
        "def load_test_function(name: str):\n",
        "    from botorch.test_functions import synthetic\n",
        "    if not hasattr(synthetic, name):\n",
        "        available = sorted(\n",
        "            candidate\n",
        "            for candidate in dir(synthetic)\n",
        "            if candidate and candidate[0].isupper()\n",
        "        )\n",
        "\n",
        "        raise ValueError(f\"Unknown BoTorch synthetic function '{name}'. Try one of: {available[:20]}\")\n",
        "\n",
        "    function_cls = getattr(synthetic, name)\n",
        "    test_function = function_cls(negate=False)\n",
        "    bounds = test_function.bounds.detach().cpu().numpy().T\n",
        "    dimension = bounds.shape[0]\n",
        "    def evaluate(points: np.ndarray) -> np.ndarray:\n",
        "        points = np.asarray(points, dtype=float)\n",
        "        if points.ndim == 1:\n",
        "            points = points[None, :]\n",
        "        values = test_function(\n",
        "            __import__(\"torch\").as_tensor(points, dtype=__import__(\"torch\").double)\n",
        "        )\n",
        "        return values.detach().cpu().numpy().reshape(-1)\n",
        "    return test_function, bounds, dimension, evaluate\n",
        "\n",
        "function_name = \"Branin\"\n",
        "test_function, bounds, dimension, evaluate_objective = load_test_function(function_name)\n",
        "\n",
        "if dimension == 1:\n",
        "    grid_axis = np.linspace(bounds[0, 0], bounds[0, 1], 401)\n",
        "    candidate_grid = grid_axis[:, None]\n",
        "elif dimension == 2:\n",
        "    axis_0 = np.linspace(bounds[0, 0], bounds[0, 1], 81)\n",
        "    axis_1 = np.linspace(bounds[1, 0], bounds[1, 1], 81)\n",
        "    mesh_0, mesh_1 = np.meshgrid(axis_0, axis_1, indexing=\"ij\")\n",
        "    candidate_grid = np.column_stack([mesh_0.ravel(), mesh_1.ravel()])\n",
        "else:\n",
        "    raise ValueError(\n",
        "        f\"This tutorial currently supports only 1D or 2D functions, but {function_name} has dimension {dimension}.\"\n",
        "    )\n",
        "\n",
        "initial_x = rng.uniform(bounds[:, 0], bounds[:, 1], size=(N_INITIAL, dimension))\n",
        "initial_y = evaluate_objective(initial_x)\n",
        "candidate_grid.shape, initial_x.shape\n",
        "print(f\"Objective function: {function_name} has bounds {bounds} \\n\"\n",
        "      f\"and global minimum value {test_function.optimal_value:.4f} at \\n\"\n",
        "      f\"{test_function.optimizers.cpu().numpy()}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "220b4f0f",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 600x500 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "z_true = evaluate_objective(candidate_grid).reshape(mesh_0.shape)\n",
        "global_minima = test_function.optimizers.cpu().numpy()\n",
        "\n",
        "fig, ax = plt.subplots(figsize=(6, 5))\n",
        "\n",
        "contour = ax.contourf(\n",
        "    mesh_0,\n",
        "    mesh_1,\n",
        "    z_true,\n",
        "    levels=20,\n",
        "    cmap=\"coolwarm\",\n",
        ")\n",
        "\n",
        "ax.scatter(\n",
        "    global_minima[:, 0],\n",
        "    global_minima[:, 1],\n",
        "    c=\"white\",\n",
        "    edgecolors=\"black\",\n",
        "    marker=\"X\",\n",
        "    s=120,\n",
        "    label=\"Global minima\",\n",
        ")\n",
        "\n",
        "ax.set_xlabel(\"x0\")\n",
        "ax.set_ylabel(\"x1\")\n",
        "ax.legend(loc=\"upper center\", ncol=2, bbox_to_anchor=(0.5, 1.10))\n",
        "\n",
        "fig.colorbar(contour, ax=ax, label=\"Objective\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a6c32126",
      "metadata": {},
      "source": [
        "## 3. Specify the Search Space\n",
        "\n",
        "Choose an initial design and build a dense candidate grid. This tutorial supports one- and two-dimensional BoTorch synthetic functions because the current AFL acquisition flow is grid-first."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "0287e851",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Initial samples:\n",
            "         x0         x1   objective\n",
            "0  2.126608   8.887860   37.289563\n",
            "1  2.417188   4.707776    6.049219\n",
            "2  9.341378   1.249534    1.767633\n",
            "3 -3.518548   5.211992   64.868666\n",
            "4  7.703730  11.422624  111.771974\n"
          ]
        }
      ],
      "source": [
        "from botorch.utils.sampling import draw_sobol_samples\n",
        "\n",
        "if dimension > 2:\n",
        "    raise ValueError(\n",
        "        f\"This tutorial currently supports only 1D or 2D functions, but {function_name} has dimension {dimension}.\"\n",
        "    )\n",
        "\n",
        "component_names = [f\"x{i}\" for i in range(dimension)]\n",
        "\n",
        "sobol_bounds = __import__(\"torch\").as_tensor(bounds.T, dtype=__import__(\"torch\").double)\n",
        "initial_x = (\n",
        "    draw_sobol_samples(bounds=sobol_bounds, n=1, q=N_INITIAL, seed=0)\n",
        "    .squeeze(0)\n",
        "    .detach()\n",
        "    .cpu()\n",
        "    .numpy()\n",
        ")\n",
        "initial_y = evaluate_objective(initial_x)\n",
        "\n",
        "print(f\"Initial samples:\\n{pd.DataFrame(initial_x, columns=component_names).assign(objective=initial_y)}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "1e540962",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/html": [
              "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n",
              "<defs>\n",
              "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n",
              "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n",
              "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n",
              "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n",
              "</symbol>\n",
              "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n",
              "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n",
              "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
              "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
              "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
              "</symbol>\n",
              "</defs>\n",
              "</svg>\n",
              "<style>/* CSS stylesheet for displaying xarray objects in notebooks */\n",
              "\n",
              ":root {\n",
              "  --xr-font-color0: var(\n",
              "    --jp-content-font-color0,\n",
              "    var(--pst-color-text-base rgba(0, 0, 0, 1))\n",
              "  );\n",
              "  --xr-font-color2: var(\n",
              "    --jp-content-font-color2,\n",
              "    var(--pst-color-text-base, rgba(0, 0, 0, 0.54))\n",
              "  );\n",
              "  --xr-font-color3: var(\n",
              "    --jp-content-font-color3,\n",
              "    var(--pst-color-text-base, rgba(0, 0, 0, 0.38))\n",
              "  );\n",
              "  --xr-border-color: var(\n",
              "    --jp-border-color2,\n",
              "    hsl(from var(--pst-color-on-background, white) h s calc(l - 10))\n",
              "  );\n",
              "  --xr-disabled-color: var(\n",
              "    --jp-layout-color3,\n",
              "    hsl(from var(--pst-color-on-background, white) h s calc(l - 40))\n",
              "  );\n",
              "  --xr-background-color: var(\n",
              "    --jp-layout-color0,\n",
              "    var(--pst-color-on-background, white)\n",
              "  );\n",
              "  --xr-background-color-row-even: var(\n",
              "    --jp-layout-color1,\n",
              "    hsl(from var(--pst-color-on-background, white) h s calc(l - 5))\n",
              "  );\n",
              "  --xr-background-color-row-odd: var(\n",
              "    --jp-layout-color2,\n",
              "    hsl(from var(--pst-color-on-background, white) h s calc(l - 15))\n",
              "  );\n",
              "}\n",
              "\n",
              "html[theme=\"dark\"],\n",
              "html[data-theme=\"dark\"],\n",
              "body[data-theme=\"dark\"],\n",
              "body.vscode-dark {\n",
              "  --xr-font-color0: var(\n",
              "    --jp-content-font-color0,\n",
              "    var(--pst-color-text-base, rgba(255, 255, 255, 1))\n",
              "  );\n",
              "  --xr-font-color2: var(\n",
              "    --jp-content-font-color2,\n",
              "    var(--pst-color-text-base, rgba(255, 255, 255, 0.54))\n",
              "  );\n",
              "  --xr-font-color3: var(\n",
              "    --jp-content-font-color3,\n",
              "    var(--pst-color-text-base, rgba(255, 255, 255, 0.38))\n",
              "  );\n",
              "  --xr-border-color: var(\n",
              "    --jp-border-color2,\n",
              "    hsl(from var(--pst-color-on-background, #111111) h s calc(l + 10))\n",
              "  );\n",
              "  --xr-disabled-color: var(\n",
              "    --jp-layout-color3,\n",
              "    hsl(from var(--pst-color-on-background, #111111) h s calc(l + 40))\n",
              "  );\n",
              "  --xr-background-color: var(\n",
              "    --jp-layout-color0,\n",
              "    var(--pst-color-on-background, #111111)\n",
              "  );\n",
              "  --xr-background-color-row-even: var(\n",
              "    --jp-layout-color1,\n",
              "    hsl(from var(--pst-color-on-background, #111111) h s calc(l + 5))\n",
              "  );\n",
              "  --xr-background-color-row-odd: var(\n",
              "    --jp-layout-color2,\n",
              "    hsl(from var(--pst-color-on-background, #111111) h s calc(l + 15))\n",
              "  );\n",
              "}\n",
              "\n",
              ".xr-wrap {\n",
              "  display: block !important;\n",
              "  min-width: 300px;\n",
              "  max-width: 700px;\n",
              "  line-height: 1.6;\n",
              "  padding-bottom: 4px;\n",
              "}\n",
              "\n",
              ".xr-text-repr-fallback {\n",
              "  /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n",
              "  display: none;\n",
              "}\n",
              "\n",
              ".xr-header {\n",
              "  padding-top: 6px;\n",
              "  padding-bottom: 6px;\n",
              "}\n",
              "\n",
              ".xr-header {\n",
              "  border-bottom: solid 1px var(--xr-border-color);\n",
              "  margin-bottom: 4px;\n",
              "}\n",
              "\n",
              ".xr-header > div,\n",
              ".xr-header > ul {\n",
              "  display: inline;\n",
              "  margin-top: 0;\n",
              "  margin-bottom: 0;\n",
              "}\n",
              "\n",
              ".xr-obj-type,\n",
              ".xr-obj-name {\n",
              "  margin-left: 2px;\n",
              "  margin-right: 10px;\n",
              "}\n",
              "\n",
              ".xr-obj-type,\n",
              ".xr-group-box-contents > label {\n",
              "  color: var(--xr-font-color2);\n",
              "  display: block;\n",
              "}\n",
              "\n",
              ".xr-sections {\n",
              "  padding-left: 0 !important;\n",
              "  display: grid;\n",
              "  grid-template-columns: 150px auto auto 1fr 0 20px 0 20px;\n",
              "  margin-block-start: 0;\n",
              "  margin-block-end: 0;\n",
              "}\n",
              "\n",
              ".xr-section-item {\n",
              "  display: contents;\n",
              "}\n",
              "\n",
              ".xr-section-item > input,\n",
              ".xr-group-box-contents > input,\n",
              ".xr-array-wrap > input {\n",
              "  display: block;\n",
              "  opacity: 0;\n",
              "  height: 0;\n",
              "  margin: 0;\n",
              "}\n",
              "\n",
              ".xr-section-item > input + label,\n",
              ".xr-var-item > input + label {\n",
              "  color: var(--xr-disabled-color);\n",
              "}\n",
              "\n",
              ".xr-section-item > input:enabled + label,\n",
              ".xr-var-item > input:enabled + label,\n",
              ".xr-array-wrap > input:enabled + label,\n",
              ".xr-group-box-contents > input:enabled + label {\n",
              "  cursor: pointer;\n",
              "  color: var(--xr-font-color2);\n",
              "}\n",
              "\n",
              ".xr-section-item > input:focus-visible + label,\n",
              ".xr-var-item > input:focus-visible + label,\n",
              ".xr-array-wrap > input:focus-visible + label,\n",
              ".xr-group-box-contents > input:focus-visible + label {\n",
              "  outline: auto;\n",
              "}\n",
              "\n",
              ".xr-section-item > input:enabled + label:hover,\n",
              ".xr-var-item > input:enabled + label:hover,\n",
              ".xr-array-wrap > input:enabled + label:hover,\n",
              ".xr-group-box-contents > input:enabled + label:hover {\n",
              "  color: var(--xr-font-color0);\n",
              "}\n",
              "\n",
              ".xr-section-summary {\n",
              "  grid-column: 1;\n",
              "  color: var(--xr-font-color2);\n",
              "  font-weight: 500;\n",
              "  white-space: nowrap;\n",
              "}\n",
              "\n",
              ".xr-section-summary > em {\n",
              "  font-weight: normal;\n",
              "}\n",
              "\n",
              ".xr-span-grid {\n",
              "  grid-column-end: -1;\n",
              "}\n",
              "\n",
              ".xr-section-summary > span {\n",
              "  display: inline-block;\n",
              "  padding-left: 0.3em;\n",
              "}\n",
              "\n",
              ".xr-group-box-contents > input:checked + label > span {\n",
              "  display: inline-block;\n",
              "  padding-left: 0.6em;\n",
              "}\n",
              "\n",
              ".xr-section-summary-in:disabled + label {\n",
              "  color: var(--xr-font-color2);\n",
              "}\n",
              "\n",
              ".xr-section-summary-in + label:before {\n",
              "  display: inline-block;\n",
              "  content: \"►\";\n",
              "  font-size: 11px;\n",
              "  width: 15px;\n",
              "  text-align: center;\n",
              "}\n",
              "\n",
              ".xr-section-summary-in:disabled + label:before {\n",
              "  color: var(--xr-disabled-color);\n",
              "}\n",
              "\n",
              ".xr-section-summary-in:checked + label:before {\n",
              "  content: \"▼\";\n",
              "}\n",
              "\n",
              ".xr-section-summary-in:checked + label > span {\n",
              "  display: none;\n",
              "}\n",
              "\n",
              ".xr-section-summary,\n",
              ".xr-section-inline-details,\n",
              ".xr-group-box-contents > label {\n",
              "  padding-top: 4px;\n",
              "}\n",
              "\n",
              ".xr-section-inline-details {\n",
              "  grid-column: 2 / -1;\n",
              "}\n",
              "\n",
              ".xr-section-details {\n",
              "  grid-column: 1 / -1;\n",
              "  margin-top: 4px;\n",
              "  margin-bottom: 5px;\n",
              "}\n",
              "\n",
              ".xr-section-summary-in ~ .xr-section-details {\n",
              "  display: none;\n",
              "}\n",
              "\n",
              ".xr-section-summary-in:checked ~ .xr-section-details {\n",
              "  display: contents;\n",
              "}\n",
              "\n",
              ".xr-children {\n",
              "  display: inline-grid;\n",
              "  grid-template-columns: 100%;\n",
              "  grid-column: 1 / -1;\n",
              "  padding-top: 4px;\n",
              "}\n",
              "\n",
              ".xr-group-box {\n",
              "  display: inline-grid;\n",
              "  grid-template-columns: 0px 30px auto;\n",
              "}\n",
              "\n",
              ".xr-group-box-vline {\n",
              "  grid-column-start: 1;\n",
              "  border-right: 0.2em solid;\n",
              "  border-color: var(--xr-border-color);\n",
              "  width: 0px;\n",
              "}\n",
              "\n",
              ".xr-group-box-hline {\n",
              "  grid-column-start: 2;\n",
              "  grid-row-start: 1;\n",
              "  height: 1em;\n",
              "  width: 26px;\n",
              "  border-bottom: 0.2em solid;\n",
              "  border-color: var(--xr-border-color);\n",
              "}\n",
              "\n",
              ".xr-group-box-contents {\n",
              "  grid-column-start: 3;\n",
              "  padding-bottom: 4px;\n",
              "}\n",
              "\n",
              ".xr-group-box-contents > label::before {\n",
              "  content: \"📂\";\n",
              "  padding-right: 0.3em;\n",
              "}\n",
              "\n",
              ".xr-group-box-contents > input:checked + label::before {\n",
              "  content: \"📁\";\n",
              "}\n",
              "\n",
              ".xr-group-box-contents > input:checked + label {\n",
              "  padding-bottom: 0px;\n",
              "}\n",
              "\n",
              ".xr-group-box-contents > input:checked ~ .xr-sections {\n",
              "  display: none;\n",
              "}\n",
              "\n",
              ".xr-group-box-contents > input + label > span {\n",
              "  display: none;\n",
              "}\n",
              "\n",
              ".xr-group-box-ellipsis {\n",
              "  font-size: 1.4em;\n",
              "  font-weight: 900;\n",
              "  color: var(--xr-font-color2);\n",
              "  letter-spacing: 0.15em;\n",
              "  cursor: default;\n",
              "}\n",
              "\n",
              ".xr-array-wrap {\n",
              "  grid-column: 1 / -1;\n",
              "  display: grid;\n",
              "  grid-template-columns: 20px auto;\n",
              "}\n",
              "\n",
              ".xr-array-wrap > label {\n",
              "  grid-column: 1;\n",
              "  vertical-align: top;\n",
              "}\n",
              "\n",
              ".xr-preview {\n",
              "  color: var(--xr-font-color3);\n",
              "}\n",
              "\n",
              ".xr-array-preview,\n",
              ".xr-array-data {\n",
              "  padding: 0 5px !important;\n",
              "  grid-column: 2;\n",
              "}\n",
              "\n",
              ".xr-array-data,\n",
              ".xr-array-in:checked ~ .xr-array-preview {\n",
              "  display: none;\n",
              "}\n",
              "\n",
              ".xr-array-in:checked ~ .xr-array-data,\n",
              ".xr-array-preview {\n",
              "  display: inline-block;\n",
              "}\n",
              "\n",
              ".xr-dim-list {\n",
              "  display: inline-block !important;\n",
              "  list-style: none;\n",
              "  padding: 0 !important;\n",
              "  margin: 0;\n",
              "}\n",
              "\n",
              ".xr-dim-list li {\n",
              "  display: inline-block;\n",
              "  padding: 0;\n",
              "  margin: 0;\n",
              "}\n",
              "\n",
              ".xr-dim-list:before {\n",
              "  content: \"(\";\n",
              "}\n",
              "\n",
              ".xr-dim-list:after {\n",
              "  content: \")\";\n",
              "}\n",
              "\n",
              ".xr-dim-list li:not(:last-child):after {\n",
              "  content: \",\";\n",
              "  padding-right: 5px;\n",
              "}\n",
              "\n",
              ".xr-has-index {\n",
              "  font-weight: bold;\n",
              "}\n",
              "\n",
              ".xr-var-list,\n",
              ".xr-var-item {\n",
              "  display: contents;\n",
              "}\n",
              "\n",
              ".xr-var-item > div,\n",
              ".xr-var-item label,\n",
              ".xr-var-item > .xr-var-name span {\n",
              "  background-color: var(--xr-background-color-row-even);\n",
              "  border-color: var(--xr-background-color-row-odd);\n",
              "  margin-bottom: 0;\n",
              "  padding-top: 2px;\n",
              "}\n",
              "\n",
              ".xr-var-item > .xr-var-name:hover span {\n",
              "  padding-right: 5px;\n",
              "}\n",
              "\n",
              ".xr-var-list > li:nth-child(odd) > div,\n",
              ".xr-var-list > li:nth-child(odd) > label,\n",
              ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n",
              "  background-color: var(--xr-background-color-row-odd);\n",
              "  border-color: var(--xr-background-color-row-even);\n",
              "}\n",
              "\n",
              ".xr-var-name {\n",
              "  grid-column: 1;\n",
              "}\n",
              "\n",
              ".xr-var-dims {\n",
              "  grid-column: 2;\n",
              "}\n",
              "\n",
              ".xr-var-dtype {\n",
              "  grid-column: 3;\n",
              "  text-align: right;\n",
              "  color: var(--xr-font-color2);\n",
              "}\n",
              "\n",
              ".xr-var-preview {\n",
              "  grid-column: 4;\n",
              "}\n",
              "\n",
              ".xr-index-preview {\n",
              "  grid-column: 2 / 5;\n",
              "  color: var(--xr-font-color2);\n",
              "}\n",
              "\n",
              ".xr-var-name,\n",
              ".xr-var-dims,\n",
              ".xr-var-dtype,\n",
              ".xr-preview,\n",
              ".xr-attrs dt {\n",
              "  white-space: nowrap;\n",
              "  overflow: hidden;\n",
              "  text-overflow: ellipsis;\n",
              "  padding-right: 10px;\n",
              "}\n",
              "\n",
              ".xr-var-name:hover,\n",
              ".xr-var-dims:hover,\n",
              ".xr-var-dtype:hover,\n",
              ".xr-attrs dt:hover {\n",
              "  overflow: visible;\n",
              "  width: auto;\n",
              "  z-index: 1;\n",
              "}\n",
              "\n",
              ".xr-var-attrs,\n",
              ".xr-var-data,\n",
              ".xr-index-data {\n",
              "  display: none;\n",
              "  border-top: 2px dotted var(--xr-background-color);\n",
              "  padding-bottom: 20px !important;\n",
              "  padding-top: 10px !important;\n",
              "}\n",
              "\n",
              ".xr-var-attrs-in + label,\n",
              ".xr-var-data-in + label,\n",
              ".xr-index-data-in + label {\n",
              "  padding: 0 1px;\n",
              "}\n",
              "\n",
              ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n",
              ".xr-var-data-in:checked ~ .xr-var-data,\n",
              ".xr-index-data-in:checked ~ .xr-index-data {\n",
              "  display: block;\n",
              "}\n",
              "\n",
              ".xr-var-data > table {\n",
              "  float: right;\n",
              "}\n",
              "\n",
              ".xr-var-data > pre,\n",
              ".xr-index-data > pre,\n",
              ".xr-var-data > table > tbody > tr {\n",
              "  background-color: transparent !important;\n",
              "}\n",
              "\n",
              ".xr-var-name span,\n",
              ".xr-var-data,\n",
              ".xr-index-name div,\n",
              ".xr-index-data,\n",
              ".xr-attrs {\n",
              "  padding-left: 25px !important;\n",
              "}\n",
              "\n",
              ".xr-attrs,\n",
              ".xr-var-attrs,\n",
              ".xr-var-data,\n",
              ".xr-index-data {\n",
              "  grid-column: 1 / -1;\n",
              "}\n",
              "\n",
              "dl.xr-attrs {\n",
              "  padding: 0;\n",
              "  margin: 0;\n",
              "  display: grid;\n",
              "  grid-template-columns: 125px auto;\n",
              "}\n",
              "\n",
              ".xr-attrs dt,\n",
              ".xr-attrs dd {\n",
              "  padding: 0;\n",
              "  margin: 0;\n",
              "  float: left;\n",
              "  padding-right: 10px;\n",
              "  width: auto;\n",
              "}\n",
              "\n",
              ".xr-attrs dt {\n",
              "  font-weight: normal;\n",
              "  grid-column: 1;\n",
              "}\n",
              "\n",
              ".xr-attrs dt:hover span {\n",
              "  display: inline-block;\n",
              "  background: var(--xr-background-color);\n",
              "  padding-right: 10px;\n",
              "}\n",
              "\n",
              ".xr-attrs dd {\n",
              "  grid-column: 2;\n",
              "  white-space: pre-wrap;\n",
              "  word-break: break-all;\n",
              "}\n",
              "\n",
              ".xr-icon-database,\n",
              ".xr-icon-file-text2,\n",
              ".xr-no-icon {\n",
              "  display: inline-block;\n",
              "  vertical-align: middle;\n",
              "  width: 1em;\n",
              "  height: 1.5em !important;\n",
              "  stroke-width: 0;\n",
              "  stroke: currentColor;\n",
              "  fill: currentColor;\n",
              "}\n",
              "\n",
              ".xr-var-attrs-in:checked + label > .xr-icon-file-text2,\n",
              ".xr-var-data-in:checked + label > .xr-icon-database,\n",
              ".xr-index-data-in:checked + label > .xr-icon-database {\n",
              "  color: var(--xr-font-color0);\n",
              "  filter: drop-shadow(1px 1px 5px var(--xr-font-color2));\n",
              "  stroke-width: 0.8px;\n",
              "}\n",
              "</style><pre class='xr-text-repr-fallback'>&lt;xarray.Dataset&gt; Size: 136B\n",
              "Dimensions:      (sample: 5, component: 2)\n",
              "Coordinates:\n",
              "  * component    (component) &lt;U2 16B &#x27;x0&#x27; &#x27;x1&#x27;\n",
              "Dimensions without coordinates: sample\n",
              "Data variables:\n",
              "    composition  (sample, component) float64 80B 2.127 8.888 ... 7.704 11.42\n",
              "    objective    (sample) float64 40B 37.29 6.049 1.768 64.87 111.8</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.Dataset</div></div><ul class='xr-sections'><li class='xr-section-item'><input id='section-6af6dc64-0554-4356-98b5-1a7e54b20b31' class='xr-section-summary-in' type='checkbox' disabled /><label for='section-6af6dc64-0554-4356-98b5-1a7e54b20b31' class='xr-section-summary'>Dimensions:</label><div class='xr-section-inline-details'><ul class='xr-dim-list'><li><span>sample</span>: 5</li><li><span class='xr-has-index'>component</span>: 2</li></ul></div></li><li class='xr-section-item'><input id='section-84182a6d-4883-47fb-8eab-2c63a325bcfc' class='xr-section-summary-in' type='checkbox' checked /><label for='section-84182a6d-4883-47fb-8eab-2c63a325bcfc' class='xr-section-summary' title='Expand/collapse section'>Coordinates: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>component</span></div><div class='xr-var-dims'>(component)</div><div class='xr-var-dtype'>&lt;U2</div><div class='xr-var-preview xr-preview'>&#x27;x0&#x27; &#x27;x1&#x27;</div><input id='attrs-5678a6c9-c33c-4a5d-a8db-5d0e3b8c4bd9' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-5678a6c9-c33c-4a5d-a8db-5d0e3b8c4bd9' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-84b6b1ce-0758-4c09-ab7b-d01be536e5e5' class='xr-var-data-in' type='checkbox'><label for='data-84b6b1ce-0758-4c09-ab7b-d01be536e5e5' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([&#x27;x0&#x27;, &#x27;x1&#x27;], dtype=&#x27;&lt;U2&#x27;)</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-1f598797-645f-4783-b864-752e4010fab8' class='xr-section-summary-in' type='checkbox' checked /><label for='section-1f598797-645f-4783-b864-752e4010fab8' class='xr-section-summary' title='Expand/collapse section'>Data variables: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span>composition</span></div><div class='xr-var-dims'>(sample, component)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>2.127 8.888 2.417 ... 7.704 11.42</div><input id='attrs-cfe3dc57-10dd-471a-8eae-df13711f2395' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-cfe3dc57-10dd-471a-8eae-df13711f2395' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-c4f0fcf9-92ac-4b97-b108-c6311e3a0532' class='xr-var-data-in' type='checkbox'><label for='data-c4f0fcf9-92ac-4b97-b108-c6311e3a0532' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([[ 2.1266,  8.8879],\n",
              "       [ 2.4172,  4.7078],\n",
              "       [ 9.3414,  1.2495],\n",
              "       [-3.5185,  5.212 ],\n",
              "       [ 7.7037, 11.4226]])</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>objective</span></div><div class='xr-var-dims'>(sample)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>37.29 6.049 1.768 64.87 111.8</div><input id='attrs-c2d2882a-d062-4289-a7b0-e13f213c02c8' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-c2d2882a-d062-4289-a7b0-e13f213c02c8' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-6957b80b-6f83-4528-aa34-6859d7c497fe' class='xr-var-data-in' type='checkbox'><label for='data-6957b80b-6f83-4528-aa34-6859d7c497fe' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([ 37.2896,   6.0492,   1.7676,  64.8687, 111.772 ])</pre></div></li></ul></div></li></ul></div></div>"
            ],
            "text/plain": [
              "<xarray.Dataset> Size: 136B\n",
              "Dimensions:      (sample: 5, component: 2)\n",
              "Coordinates:\n",
              "  * component    (component) <U2 16B 'x0' 'x1'\n",
              "Dimensions without coordinates: sample\n",
              "Data variables:\n",
              "    composition  (sample, component) float64 80B 2.127 8.888 ... 7.704 11.42\n",
              "    objective    (sample) float64 40B 37.29 6.049 1.768 64.87 111.8"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "component_names = [f\"x{i}\" for i in range(dimension)]\n",
        "\n",
        "initial_dataset = xr.Dataset(\n",
        "    data_vars={\n",
        "        \"composition\": ((\"sample\", \"component\"), initial_x),\n",
        "        \"objective\": (\"sample\", initial_y),\n",
        "    },\n",
        "    coords={\"component\": component_names},\n",
        ")\n",
        "initial_dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "94f2fcc5",
      "metadata": {},
      "source": [
        "## 4. Run Bayesian Optimization\n",
        "\n",
        "Define a reusable AFL pipeline and execute it repeatedly. The pipeline itself stays fixed; only the dataset grows as new observations are appended."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "id": "1ccc8541",
      "metadata": {},
      "outputs": [],
      "source": [
        "grid_spec = {\n",
        "    name: {\"min\": float(lo), \"max\": float(hi), \"steps\": 20}\n",
        "    for name, (lo, hi) in zip(component_names, bounds.tolist())\n",
        "}\n",
        "\n",
        "with Pipeline() as bayesopt_pipeline:\n",
        "    CartesianGrid(\n",
        "        output_variable=\"composition_grid_raw\",\n",
        "        grid_spec=grid_spec,\n",
        "        sample_dim=\"grid\",\n",
        "        component_dim=\"component\",\n",
        "    )\n",
        "\n",
        "    Standardize(\n",
        "        input_variable=\"composition\",\n",
        "        output_variable=\"composition_std\",\n",
        "        dim=\"grid\",\n",
        "        component_dim=\"component\",\n",
        "        scale_variable=\"composition_grid_raw\",\n",
        "    )\n",
        "\n",
        "    Standardize(\n",
        "        input_variable=\"composition_grid_raw\",\n",
        "        output_variable=\"composition_grid\",\n",
        "        dim=\"grid\",\n",
        "        component_dim=\"component\",\n",
        "    )\n",
        "\n",
        "    BoTorchRegressor(\n",
        "        feature_input_variable=\"composition_std\",\n",
        "        predictor_input_variable=\"objective\",\n",
        "        grid_variable=\"composition_grid\",\n",
        "        grid_dim=\"grid\",\n",
        "        sample_dim=\"sample\",\n",
        "        output_prefix=\"botorch\",\n",
        "        objective_direction=\"minimize\",\n",
        "        posterior_optimize=True,\n",
        "    )\n",
        "\n",
        "    BoTorchAcquisition(\n",
        "        feature_input_variable=\"composition_std\",\n",
        "        predictor_input_variable=\"objective\",\n",
        "        grid_variable=\"composition_grid\",\n",
        "        grid_dim=\"grid\",\n",
        "        sample_dim=\"sample\",\n",
        "        objective_direction=\"minimize\",\n",
        "        acquisition_kind=\"qlogei\",\n",
        "        best_f_variable=\"botorch_best_f\",\n",
        "        output_prefix=\"botorch\",\n",
        "        decision_rtol=1.0,\n",
        "        count=N_BATCH,\n",
        "    )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "id": "db7dd968",
      "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>suggested_x</th>\n",
              "      <th>objective</th>\n",
              "      <th>best_observed</th>\n",
              "      <th>best_posterior</th>\n",
              "      <th>best_posterior_location</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>iteration</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>[2.1266077551990747, 8.887859727256]</td>\n",
              "      <td>37.289563</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>NaN</td>\n",
              "      <td>None</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>[2.4171879841014743, 4.707775977440178]</td>\n",
              "      <td>6.049219</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>NaN</td>\n",
              "      <td>None</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>[9.341377750970423, 1.2495335564017296]</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>NaN</td>\n",
              "      <td>None</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>[-3.518547718413174, 5.211991709657013]</td>\n",
              "      <td>64.868666</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>NaN</td>\n",
              "      <td>None</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>[7.703730380162597, 11.422624387778342]</td>\n",
              "      <td>111.771974</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>NaN</td>\n",
              "      <td>None</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>[0.7063676786115726, 0.10601830611992093]</td>\n",
              "      <td>40.674245</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>0.087429</td>\n",
              "      <td>[0.8414478607087343, 0.09716918714135396]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>[0.7271571753512608, 0.14487502597293678]</td>\n",
              "      <td>39.889377</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>-0.243806</td>\n",
              "      <td>[0.8312134353054518, 0.10864019208141946]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>[0.7291749835590083, 0.1478321624171413]</td>\n",
              "      <td>39.821335</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>0.879403</td>\n",
              "      <td>[0.8903637855593641, 0.08878086226650754]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>[0.7322323886309159, 0.14824675488150138]</td>\n",
              "      <td>39.756984</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>1.308807</td>\n",
              "      <td>[0.9147119353555778, 0.08310338090085889]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>[0.7363519016965578, 0.14582017836395147]</td>\n",
              "      <td>39.698644</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>1.475435</td>\n",
              "      <td>[0.9261023157384878, 0.08067795232984298]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>[0.7398639549511439, 0.1409011272475093]</td>\n",
              "      <td>39.675945</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>1.537192</td>\n",
              "      <td>[0.9316094383804001, 0.0789470107827323]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>7</th>\n",
              "      <td>[0.7423517633064638, 0.1340353297601402]</td>\n",
              "      <td>39.691980</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>1.558492</td>\n",
              "      <td>[0.9345910027868953, 0.07704957324729528]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>[0.7431016408413346, 0.12543960332955773]</td>\n",
              "      <td>39.758941</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>1.577390</td>\n",
              "      <td>[0.9376714155728872, 0.07445753751706405]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>[0.7715587580831954, 0.10121408976202616]</td>\n",
              "      <td>39.423838</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>1.634049</td>\n",
              "      <td>[0.9447969239734312, 0.07072835101371597]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>10</th>\n",
              "      <td>[0.8732253817458685, 0.007312406532392863]</td>\n",
              "      <td>38.271271</td>\n",
              "      <td>1.767633</td>\n",
              "      <td>1.627841</td>\n",
              "      <td>[0.9559805373306564, 0.06437199186153479]</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                          suggested_x   objective  \\\n",
              "iteration                                                           \n",
              "0                [2.1266077551990747, 8.887859727256]   37.289563   \n",
              "0             [2.4171879841014743, 4.707775977440178]    6.049219   \n",
              "0             [9.341377750970423, 1.2495335564017296]    1.767633   \n",
              "0             [-3.518547718413174, 5.211991709657013]   64.868666   \n",
              "0             [7.703730380162597, 11.422624387778342]  111.771974   \n",
              "1           [0.7063676786115726, 0.10601830611992093]   40.674245   \n",
              "2           [0.7271571753512608, 0.14487502597293678]   39.889377   \n",
              "3            [0.7291749835590083, 0.1478321624171413]   39.821335   \n",
              "4           [0.7322323886309159, 0.14824675488150138]   39.756984   \n",
              "5           [0.7363519016965578, 0.14582017836395147]   39.698644   \n",
              "6            [0.7398639549511439, 0.1409011272475093]   39.675945   \n",
              "7            [0.7423517633064638, 0.1340353297601402]   39.691980   \n",
              "8           [0.7431016408413346, 0.12543960332955773]   39.758941   \n",
              "9           [0.7715587580831954, 0.10121408976202616]   39.423838   \n",
              "10         [0.8732253817458685, 0.007312406532392863]   38.271271   \n",
              "\n",
              "           best_observed  best_posterior  \\\n",
              "iteration                                  \n",
              "0               1.767633             NaN   \n",
              "0               1.767633             NaN   \n",
              "0               1.767633             NaN   \n",
              "0               1.767633             NaN   \n",
              "0               1.767633             NaN   \n",
              "1               1.767633        0.087429   \n",
              "2               1.767633       -0.243806   \n",
              "3               1.767633        0.879403   \n",
              "4               1.767633        1.308807   \n",
              "5               1.767633        1.475435   \n",
              "6               1.767633        1.537192   \n",
              "7               1.767633        1.558492   \n",
              "8               1.767633        1.577390   \n",
              "9               1.767633        1.634049   \n",
              "10              1.767633        1.627841   \n",
              "\n",
              "                             best_posterior_location  \n",
              "iteration                                             \n",
              "0                                               None  \n",
              "0                                               None  \n",
              "0                                               None  \n",
              "0                                               None  \n",
              "0                                               None  \n",
              "1          [0.8414478607087343, 0.09716918714135396]  \n",
              "2          [0.8312134353054518, 0.10864019208141946]  \n",
              "3          [0.8903637855593641, 0.08878086226650754]  \n",
              "4          [0.9147119353555778, 0.08310338090085889]  \n",
              "5          [0.9261023157384878, 0.08067795232984298]  \n",
              "6           [0.9316094383804001, 0.0789470107827323]  \n",
              "7          [0.9345910027868953, 0.07704957324729528]  \n",
              "8          [0.9376714155728872, 0.07445753751706405]  \n",
              "9          [0.9447969239734312, 0.07072835101371597]  \n",
              "10         [0.9559805373306564, 0.06437199186153479]  "
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "history = []\n",
        "\n",
        "for x_row, y_val in zip(initial_x, initial_y):\n",
        "    history.append(\n",
        "        {\n",
        "            \"iteration\": 0,\n",
        "            \"suggested_x\": x_row.tolist(),\n",
        "            \"objective\": float(y_val),\n",
        "            \"best_observed\": float(np.min(initial_y)),\n",
        "            \"best_posterior\": np.nan,\n",
        "            \"best_posterior_location\": None,\n",
        "        }\n",
        "    )\n",
        "\n",
        "campaign_dataset = initial_dataset.copy()\n",
        "\n",
        "for iteration in range(N_ITERATIONS):\n",
        "    result = bayesopt_pipeline.calculate(campaign_dataset, disable_progress_bar=True)\n",
        "\n",
        "    suggested_x = np.asarray(result[\"next_samples\"].values, dtype=float).reshape(N_BATCH, dimension)\n",
        "    suggested_y = evaluate_objective(suggested_x)\n",
        "\n",
        "    best_observed = float(np.min(campaign_dataset[\"objective\"].values))\n",
        "    best_posterior = float(np.asarray(result[\"botorch_best_f\"].values).reshape(-1)[0])\n",
        "    best_posterior_location = np.asarray(\n",
        "        result[\"botorch_best_x\"].values, dtype=float\n",
        "    ).reshape(-1).tolist()\n",
        "\n",
        "    for batch_member, (x_row, y_val) in enumerate(zip(suggested_x, suggested_y)):\n",
        "        history.append(\n",
        "            {\n",
        "                \"iteration\": iteration+1,\n",
        "                \"suggested_x\": x_row.tolist(),\n",
        "                \"objective\": float(y_val),\n",
        "                \"best_observed\": best_observed,\n",
        "                \"best_posterior\": best_posterior,\n",
        "                \"best_posterior_location\": best_posterior_location,\n",
        "            }\n",
        "        )\n",
        "\n",
        "    updated_x = np.vstack([campaign_dataset[\"composition\"].values, suggested_x])\n",
        "    updated_y = np.concatenate([campaign_dataset[\"objective\"].values, suggested_y])\n",
        "\n",
        "    campaign_dataset = xr.Dataset(\n",
        "        data_vars={\n",
        "            \"composition\": ((\"sample\", \"component\"), updated_x),\n",
        "            \"objective\": (\"sample\", updated_y),\n",
        "        },\n",
        "        coords={\n",
        "            \"sample\": np.arange(updated_x.shape[0]),\n",
        "            \"component\": component_names,\n",
        "        },\n",
        "    )\n",
        "\n",
        "history_df = pd.DataFrame(history).set_index(\"iteration\")\n",
        "history_df"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "37303da5",
      "metadata": {},
      "source": [
        "## 5. Inspect Best Parameters and Best Score\n",
        "\n",
        "The objective values below are reported in the original BoTorch test-function convention, so lower is better for the standard minimization problems used here."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "id": "4487c990",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Function: Branin\n",
            "Best objective: 1.627841\n",
            "Best parameters: [0.956  0.0644]\n"
          ]
        }
      ],
      "source": [
        "best_x = result[\"botorch_best_x\"].values\n",
        "best_y = float(result[\"botorch_best_f\"].values)\n",
        "print(f\"Function: {function_name}\")\n",
        "print(f\"Best objective: {best_y:.6f}\")\n",
        "print(\"Best parameters:\", best_x)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3e8bbfd4",
      "metadata": {},
      "source": [
        "## 6. Visualize Optimization Progress\n",
        "\n",
        "Plot the best-so-far trace across iterations. For one-dimensional objectives, also compare the sampled points against the true objective and the final acquisition surface."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "id": "bff2642a",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm4AAAGCCAYAAABZxk93AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAY+5JREFUeJzt3Qd0FNXDBfCbBEgCofcmTXpvgkpTQCmigICAUgUUBRULxQZWBNunoiiCBUFAFAtFQMAC/imK0qQX6b1DCKnfuW8z66aStruz2fs7Z0+2zs7MS7J3Xw2Ii4uLg4iIiIjYXqC3d0BERERE0kbBTURERMRHKLiJiIiI+AgFNxEREREfoeAmIiIi4iMU3ERERER8hIKbiIiIiI9QcBMRERHxEQpuImL42lzc3t5fb7+/iPgnBTcRH7R+/XoMHz4cN998M2rXro3WrVvj2WefxZ49ezK8vSFDhjhvHzp0CFWrVsW8efMytZ98PbfD7WWluXPnYsKECW5/n+QcO3bMnKvDhw/Dzrif9957r/n9uPHGG3HlypUs3f7o0aPNOXe9NGjQAD169MDSpUvhSe+99555fxF/kMPbOyAi6TNlyhS89dZbaNasGZ5++mkULVoU+/fvx6xZs9ClSxeMHz8eHTt2THcQcg19xYoVw5w5c3DddddlqnhatWpltsPtZaXJkyfjhhtucPv7JOd///sffv31V9jd559/jg0bNuD1119H8eLFERoamuXvwd+9SZMmmeuxsbE4f/48FixYgEceeQTTpk0zXyw8oXv37mjevLlH3kvE2xTcRHzIzz//jDfffNPUtg0bNsx5P0NM586d8cQTT5iakCpVqqBy5coZfp9cuXKhXr16md7fQoUKmYu7eep9fMm5c+dMkO3QoYPb3iO53xOG6L///tsEaU8FtxIlSpiLiD9QU6mID2HtRsWKFfHwww8neSxnzpx48cUXERQUhI8//th5P5uQZsyYgVGjRqF+/fq46aab8Morr+Dq1avmcQa9b7/91jT9Wc2jiZtK+ZNNbn/++Sfuvvtuc/3222/HihUrsHfvXvTr1w9169ZF27ZtsXDhwhSbMBM3rbleLNu3bzehtGnTpqhZs6apSXn55ZcRERFhHr/11lvNvnKfrW0n11T6+++/o3fv3mjYsCGaNGliQu3Ro0cT7FuNGjWwceNG3HPPPeaYbrnlFlNTlBK+ZsyYMeY6m6d57qx9evXVV815qFOnDp555pk0HQtFRkbi//7v/8z2+No77rjDHJurZcuWoWvXrmYfGYa4jfDw8BT3k/vDfT1y5Ig5L2xKpBMnTpj9b9mypXmvbt26Yfny5Qley+fz94zvx+dYNWppFRAQgLx585qfFp4nnpuxY8ea5lSGyZiYGJw5cwYvvPCCOe+1atUyX0D4u+1ajn369DHnkzXNDIU8Bz179sSmTZtSbCpNy2tEfJVq3ER8BD/ktmzZgvvvvz/Bh6KrAgUKmGCW+MP4nXfeMcGKAYFNovx58uRJ8/Ohhx4y2966dav5kGbzaHKhIDo62oQfBpGSJUvijTfewJNPPokiRYqgV69eePDBB83rGRAZlpKrAWEtjKvdu3fjueeeMyHBChbsl8VanNdee83U6Pz222/49NNPTe0R+5bxPfiToYv7nlzz6HfffWf2gyHogQcewNmzZ/Huu++agMZQVLhwYWfz3mOPPYb+/fubn19//TUmTpxoaiyTa3pjCBg6dKhpquV+uIaFmTNnYsCAARg8eDDy5MmTpmMhnkM2vXK7LCNeZ9BhEOf+z58/3zynU6dOZh8ZWt9++21z7rit5H4XuG8sW6tMWRanTp0yQS04OBgjRoxAwYIFTbhjUOIx33nnnc7Xf/jhh6asK1SogNKlSyf7u+b6e2EN1rh06ZLZ3127djkDroWhn+/9/vvvm9+vwMBAUzZsXrV+j3bs2GH2mwHPNUAvWbIElSpVMv04+T7s38haZ35x4BeV5GTkNSK+QMFNxEdYneGv9UFarlw5E9z4gZg/f35zH5sR+WGcI0cOU9vCD032heMHGT/c+Lhrs1dywY0hh+GM/YnowoULJgCwJoWBhVjTwho5Bszkgptrsxqb8p566ilTq8MPatq5cyeqV69ugmZYWJi5j0GUtWdr1651BjbuK/c5ueZc7idDJfsAslnZYtX0MBCMHDnS3McPdIY/65gYOH/66Sf88ssvyQY3vqfV74/7WaZMGedjpUqVMgHEsmrVqmseC4+XAYN9FXkeiQMJWNZ8Dvsq8li4L/xpKV++vAmbDHkMk4nxHCUuU/Z1Y0Dn+1m/Q/xd4HYY3BgS+XtBjRo1cpZparifrElMjEHetQ+iFfBYI2z9Xhw/ftz0u2PA5vsRa0YPHDiQJODztSw36zxevnzZvG7btm2mpi45GXmNiC9QcBPxEdb0E6yJSY1Vm+A6XQVraxjaLGzmZHD7448/THBLKza1WqxaK9YSudb4WaEuNfxQZQd2jnRkTRgDBjFs8RIVFWVqlDjoguGGgcPa9rXs27fP1CayxsgVAxf3f926dSkekxUIU2uGTAlDmqu0HAtH89Jtt92W4LVW0yZrRzk6lDVTVs0WNW7c2AQShsDkgltyeNw81sTBnzVtrB1jk/f111+f7LGkNjiBtY8W1rixZo1NlLzuGjZ5zK5hngMmpk+fbn5P2TTK88N9+Ouvv0zzsSvulxXArNdSaiNlM/IaEV+g4CbiI6wP3GtNQ3Hw4EHTVOcadKwPrcShi7Vy6eH6QWjJyGjFl156yXxA84Pbdd9YW8YRs2x2ZHhikyxr5NjEllasySM2vSXG+9h86CokJCTBbdY6ZWSOtty5cye4nZZjsfbVKo+UjoX9wHhJjM2xacWyLlu2bJL7rfPkGrYTH0tKGHTZf8wVawz5JYFNnqy1s2rk+DuZ2A8//GDOEfse8veVgTFxeST3O2bVDPIcpyQjrxHxBQpuIj6CH+5s9mJT16OPPur8IHLFWg7WwrBzuiv28XLF/k7kjZGYHCgxe/Zs02zG5ktXrKn57LPPTEhhLRSbXol9s9LKCqzWMbpiTRz7dnlCWo4lX7585idr4Vxro1jTxtBmPc6m3cRNj2Q1hacFn8vjT8y6LyvPi9UUyVq05JpSiTVzbLrkQAL227QCPJttrZpIEUlKo0pFfAgHBrApkLUUiXGUHvuKccTioEGDEjzGDtmuGP7YqZ2jHSm5EOiuOdDYRMtBArwkxg9sNnGxn5wVdNgXik2MrjUlqe0vO9SzCY/ziSWuieS8ZonDYnql9Vyl5VjYpy658mETI0f+cgQxAzubElmzZV0Ycth/L3HtYWrYvMppOhLX2LLWi+eLfSOzijV6M7Vtcl94HtjP0gpt/B3m7wipZkwkeapxE/Eh7KTOEYeslWAna4YCjlDkBzsn4OV9/MCvVq1agtcxsLDj/F133WWmqGAfKs5wbzWdsWaHNVTs7J7W/k3pxU7nHBXJD3O+N6fhcG2SZMhhU+IHH3xgaqtYu8gam48++sj0eXLtm8T9ZWhhvy2+JnGwevzxx02/LfZzYx8u1jhydCVrndLS6T41Vi0YBzG0aNEixT6CaTkWllO7du3MwAEGbp57jjzlfH3cX/ZX5ACQ559/3lzntBls0uR2GQJTqs1KDo+bIY2DEfgFgDWTHH27Zs0aM5VJRsI7j4W/Wxb2w2OZsN8b+/eltn9WubHmlb/HbMplszJ/P4nNy8k1zYv4OwU3ER/DD2B2MufM+JzigM1srDHh/F4MbVYHc1ccscgPen5gs0mMo0PZ4d3C6TgY2jg1BAcNuGPSVjaN8cOZF35QJ8b+btbUHbzOaSPYL4xhk7WDDD0MLQxOAwcONGGDTWycEiMxHg/7VPE1PCYGAIZeBjqeq8zgyEeODmWN1+rVq00wS05aj4WhjSGN5cnnMwhywEabNm3MdjjilccydepUM9qS/c9Ya8haueT6rKWEx81wz/3mPHAcNMHgyBDIOeQygs2srjWnHDjDvph9+/ZNdq7BxOeRgZTlt3jxYtPXjvfxXPC1rLHkqFcRSSggTisli2RrnGuMgY1NUiIi4tvUx01ERETERyi4iYiIiPgINZWKiIiI+AjVuImIiIj4CAU3ERERER+h4CYiIiLiIzSPWzI4iSTnmuKagp6aUV5ERET8U2xsLK5evWomCedav6lRcEsGQ9u///7rrvIRERERSaJ8+fJmmbvUKLglgzVt1gkMDQ1FVuN6fFyvsEqVKmYZG/EelYU9qBzsQ2VhHyoL/ymHK1eumAojK3+kRsEtGVbzKEMbl5dxxy8BcdsKbt6lsrAHlYN9qCzsQ2Xhf+UQmIbuWerAJSIiIuIjFNxEREREfISCm4iIiIiPUHATERER8REKbiIiIiI+QsFNRERExEdoOhAPi4mNw5q9p/HHgSuIyHcaTSsVRVBgAHzxONbtO4MTFyNQLG8IbqhQyOeOIzuUhcrBPlQW9pAdyoH0/8keYmz4OREQFxcX59U9sKHw8HBs27YN1atXz9J53BZvOYoX5m/F0fMRzvtK5g/B2E410K5WSfiK7HAcOgZ7yA7lkF2OQ8dgHyoL/yuH8HTkDp8IbpGRkejatSuee+45NGnSJMnjffr0wbp165Lcz9eMHz/eLGF1ww03JHisQIECWLt2rceCG38Bhs74C4lPtpXbJ9/XwCf+wWeH49Ax2EN2KIfschw6BvtQWfhnOYSnI3fYvqmUi64+8cQT2LVrV4rPee+99xAVFeW8vXHjRjz22GPo3bu3ub17924T1BYsWOB8jicXj2dVK1N7cgk5Lv4XYdwPW3Hz9UW8XgV7reMY+8M/Pn0cOgZ7yA7lkF2OQ8dgHyoL3ymHF+ZvRdsaJbzyd23rGjcGLoY27uKOHTswffr0ZGvcEi9Nceedd6Jt27YmvNHcuXPxzTffYPbs2Wl636yucVu95zR6fbwm09sRERERe5g1uClurJT6gvBplZ7cYetRpWz+ZFCbM2dOml8zb9480zQ6ePDgBAGQC8Z7CzvJioiISPZxwkuf7bZuKrWaOtOKNXNTp05F3759kSdPHuf9e/bsQXR0NLp164bjx4+jUaNGGDNmDIoVK3bN2jtrcdnMKJInZ5qe90m/BmhcvhDs6o9/z2Dg53/59HHoGOwhO5RDdjkOHYN9qCx8qxyK5MmZJRmB0rMdWwe39OJgg2PHjqFHjx4J7t+7dy8KFSpkwhrD3dtvv40HH3zQNKEGBQWluL2dO3dmyX7ljItD4dBAnL4Sm+Jz+HjY5cPYufUI7CosGxyHjsEeskM5ZJfj0DHYh8rCt8oh5/kD2LDhIDwtWwW3JUuWoEWLFmYggquFCxciICAAISEh5va7776LZs2amUEMDRo0SHF7VapUybJRpS/lOoaHv9xgrrt2KrS6Nb7UpQ4a1iwBu8sOx6FjsIfsUA7Z5Th0DPahsvDPcggPD09zZVG2Cm4rV67EsGHDktwfGhqa4HbhwoVNuGOzaWpYG5dajVx6dKhTGpMDA5PMCVPCx+Z6yg7HoWOwh+xQDtnlOHQM9qGy8M9yCEpH1rD1qFJXVatWTXVU6ZkzZ3DjjTdi2bJlKFu2rPP+S5cu4ZZbbjFThjRt2tTcx8DWsmVLfP/992a7npqA1zkL856T+GPLTjSuVcUWszD76+zk2aEsVA72obKwh+xQDqT/T/5VDuHZaR63lJw8eRJ58+Z1Nn9ynrfg4GCUKVMmwfPCwsLQsGFDMxHvSy+9ZFLtK6+8gubNmycb2tyNBd60YmGEXAhFvYqFffIfCnG/s2oYtLdkh7JQOdiHysIeskM5kP4/2UOQDT8nbD0dSGrYR23RokXO26dPn0a+fPlMX7bEJkyYgBo1amDIkCFmlYXSpUvjjTfe8PAei4iIiGSOz9S4cQLe1G536NDBXJKTP39+U+MmIiIi4st8tsZNRERExN8ouImIiIj4CAU3ERERER+h4CYiIiLiI3xmcIKIiIj4gHMHgfDTKT+euzBQ4L/5ViV9FNxEREQk60LbpIZA9NVUkkcwMGy9vcPbOZfwGRuL0HM7gaMBQGCg18OngpuIiIhkDYad1EIb8XE+z67B7VzC8MnFqGrwykp7hE/1cRMRERHJSPj0AtW4iYiISObFRDtqq9Li+4eBkPxAYBAQmBMIzAEE5Ux0O4fjZ1bdDgyKfw/rPtfb8RfevnLW1r8NCm4iIiKSdpHhwOldwMmdwKkdwMkdwKmdwOk9QGxU2rZxfIvOeAYpuImIiEhS4WfiQ9mO+JAWH9RMrVpc8mcsKBiIuUYzI7V9ydE/jLV0sbxEOX5m6nYMEBOVxtsxLtuISnibFxtTcBMREfFXcXHAhcP/1Zq5/gw/lfLrQgsBRasCRar895MXhr2PW137fSu0AErVgy0d+RuYkoZj8BIFNxERkew+DQVrps7uS1SDxuu7gMhLKb8uXxmgKENZVZefVYE8RZJ/vs37h6VNAOxMwU1ERCS7TEMRedkRxpy1Z/HhLLX+ZwFBQKGKydegBYel7xgYLLmP15rHjc+TDFFwExER8bVpKHLlSVp7xp/nD6T82py5gSKVk9aeFawA5MiVNcfAQMlg6csrJ+S2d/hUcBMREd/nT8ssTb8LiDiXjv5n8UGNzZ5Wk6s78Tz78rkukDB8xsTGYseOHahatSqCtHKCiIhINltmiSMUr1509B3jz8QX5/0XgKsuz7l4LG3bt0Jb/rJJmzZT638mGQufMTG4cjwOKFkXCGIDtnepxk1ERHxbViyzxNGV7B/mDFYX4gOVS7CKdA1gLuErQUC7BERdhlt1nQJU7Zj+/meSLSi4iYj4OxsvqH1NsbGOwJUWv7zmmBk/Sc1X/CWluckyirPzB+eNv+RzBC3rdq6wpPezDJaNu/Z22fSp0Oa3FNxERPyZtxfUjooAIs47aq4ieDkXf/2847br9QTP4/X4+9MauHb+eO3nBATGBysrcOVNFLgS358vURBzufC8pceRDQDSENzErym4iYj4s8w0M3JusKvJBarE18+lHMJiIuExjYc4Oum7hqtcLuGLQYwjLwPsPY+X+DcFNxERubZFIx3zkrrWhKU2cWu6BDjCU0i++J/5Hdf507rfeT3+seD8/10/+y/wye3Xfpv699p3tn4fmIZC7EHBTUTE33BZohNbgeNbgX9/S9trDq1N+bEcoSmEK9cQViCZEBZ/nc2PmZmmIq2jMe3O5tNQiD34RHCLjIxE165d8dxzz6FJkybJPmfo0KFYsWJFgvs+/PBD3HLLLeb6Z599hmnTpuHSpUto37692VZoaKhH9l9ExCsiwx0TszKgMahZYe1SBoJOi1FAiVqJAll8AMuqyVvF1tNQiD3YPrhdvXoVTzzxBHbt2pXq8/bs2YPXX38dN954o/O+/Pnzm59LlizBpEmTzOOFCxfGmDFjzPXnn3/e7fsvIuJ27Gt2Zq9LOPsHOLHNcV9KHfcLXAcUqwnkLgRsmHnt96jWwb7NjGpiFD9i6+C2e/duE9riOL/ONWrkDh06hNq1a6No0aJJHp8+fTr69evnrH174YUXcP/99+Opp55SrZuI+A7+L7xwJGHtGX9y6aOYqymHmmI1HJfi/FnTMUkra86skYxpCW52lh2WWRLJDsFt3bp1pml0xIgRqFcv5W96e/fuRUBAAMqWTfpHGRMTg82bN2PYsGHO+7itqKgobN++HfXr13fb/ouIH3DXUktXzjpqzazaMyuscXBAcjgasmi1+HDmcgkr5h+jJH19mSWR7BDcevfunabnMbiFhYVh5MiRJuyVKFECw4cPR8uWLXHhwgXT3FqsWDHn83PkyIECBQrg2LHU+3kw9PGS1axtumPborLwRT77N3H+EALfb4yAlGq7WEkWFIzYh/8A8pdJ/gnREWZx8ABTc7YVAfEhLeDi0eS3FxAEFK6EuPhgFle0uiOgFSznmIMsuQlqUxNSEIFBwdc+hpCCps+VeI7P/l1kMzEeKIf0bNvWwS2tGNwiIiLQrFkzDBkyBD/99JMZrDBnzhwUKeJYsy1XroSdZ3mbTayp2blzp1v3mzWBYg8qC3vwtXLgCgM1Ugk8xEC04+//4Ur+Sgi+fAShF/ch9MI+58/gy4cRgOTD1dXQYojIWwFX8lXAFf7MWxERYWURF+Ty/ywCwIHzwIFNGT6OnK0+Q47IFGrymC1z5UfUvlMAeBFP87W/i+xqs03KIVsEt4ceegh9+vRxDkaoVq0a/vnnH3z11VemmZUShzTevtao0ipVqiB37txZvr9W8y375AVppJBXqSzswWfLgctCua4wkILqW98Ezh9EAGvXkhHHqTJYe2bVohWrBhStgRwh+cDVKD25IqXPlkU2pLLwn3IIDw9Pc2VRtghugYGBztBmqVixohncwCbR4OBgnDp1CpUqVTKPRUdH49y5c8kOZHDFAnLnPy53b1/STmVhDz5XDmmceyzgdPyo+Bwhjn5ozoECjktA3hKmH5qdeqL5XFlkYyqL7F8OQenYbrYIbqNHjzaDE8aPH++8jwMPWGPGUMeUvH79eucccBs2bDD93FgzJyKSYbFp7JfS9iWgWkegYHkgUGFIRDIuE1NVe9fJkydNvza69dZbMX/+fHz33XfYv3+/mbONQe2+++5zDnLg5LvLli3Dpk2bMG7cOPTo0UNTgYhIxhdG/2MaMOfetD2/QgszoEChTUQyy2dr3DgQgTVsXFHhtttuw9ixYzF58mQcOXIElStXxtSpU1GmjGMUV8eOHXH48GEz4S77tvH5nMNNRCRdOBXHn58Aqz8ALp/QyRMRj/OZ4Mb12lK73b17d3NJCUeb8iIikm6XTgBrJgN/THUsrk75ywI1uwD/e1cnVEQ8xmeCm4iIx539F/j9XeDvGf+tTFCkKtBsBFC7m2Nx83UfAdGpTAmSI9gxCa+ISBZQcBMRSYyrFax6G9gyD4iLH4BQuhHQ/HGgSvv/RpNqqSUR8TAFNxERy/7VjsC2a8l/56RSa0cNW/lmyS8dpaWWRMSDFNxExL9x4fZdS4GVbwEH18TfGQDU7Azc/BhQKuV1kkVEPE3BTUT8U0w08M+3jhq2E/847uNSUnV7ATc/6pi+Q0TEZhTcRMS/RF0BNsx0DDo4t99xX64woNEAoOnDQL6S3t5DEZEUKbiJiP/MwcZJczmthzUHG0d7NhkK3DAICC3o7T0UEbkmBTcRyd4uHgfWfOCYONd1DrabHgHq3wfkyu3tPRQRSTMFNxHJns7sc0yO+/fM/+Zg4wLvHCFa624gKKe391BEJN0U3EQkezm2GVj1f8A/nIMt1nFfmcZAM87B1u6/OdhERHyQgpuIZA/7/xc/B9vS/+67vo2jhq3czcnPwSYi4mMU3ETEt+dg27nEEdisOdgCAoEanR2BrWQdb++hiEiWUnATER+dg21e/BxsW/+bg63evcBNwzUHm4hkWwpuIuJbc7BxwXcOOjh3wHFfrrxA44FA04eAvCW8vYciIm6l4CYi3nHuIBB+2nE9Nhah53YCRwP+GzzAOda4DihdOQf8MdUxB1v4qfjHiwBNhwKNOQdbAS8dhIiIZym4iYh3QtukhkC0Y5qOIAA1eGWly3NyBAMDlgBbvwX++ASIvOi4P/91wM3xc7DlDFXpiYhfUXATEc9jTVt8aEsRH5/WFoiNctwuWj1+DraumoNNRPyWgpuI2BdDW9kmjjnYKt+mOdhExO8puImIfXV6D2jQR3OwiYjE0xTiImJfnIdNE+eKiDgpuImIiIj4CAU3ERERER+h4CYiIiLiI3wiuEVGRuKOO+7A2rVrU3zOL7/8grvuugv169dHp06dsHz58gSPN2rUCFWrVk1wuXz5sgf2XkSSOLPv2ieF87hxEl4REfGdUaVXr17FE088gV27dqX4nO3bt2PYsGEYOXIkWrZsiVWrVuHRRx/F119/jWrVquH48eO4ePEili1bhpCQEOfrcufO7aGjEBGns/uBRU84rle8BWgzFjGxcdixY4f5QhWU3MoJIiJi/+C2e/duE9ri4uJSfd6CBQvQtGlT9O3b19wuV64cVqxYgR9//NEEtz179qBo0aIoW1YfAiJedfUiMKuXYwLekvWAnl8CuXIDMTG4cjwOKFkXCOI6CiIi4nPBbd26dWjSpAlGjBiBevXqpfi8Ll26ICoqfnZ1F6xlswJghQoV3LqvInINsbHAvAeAE/8AYcX/C20iIpI9glvv3r3T9LxKlSoluM1m1dWrV6Nnz57mNmvcrly5gj59+mDfvn2oXr06nn766WuGuZiYGHPJatY23bFtUVnYVcCKlxG4YyHigoIR2+MLIKyEqWkj/U3Yh8rCPlQW/lMOMenYtq2DW0acOXMGw4cPR4MGDdC6dWtz3969e3H+/Hk8/vjjCAsLw8cff4z+/ftj4cKF5nZKdu7c6dZ93bx5s1u3L2mnsnCvgoeXo+Jfb5nr/9Z5HGdO5gBOblA52Jj+JuxDZWEPm23ymZ2tgtupU6cwYMAA0yfu3XffRWB8J+dp06aZptQ8efKY22+88YYZxPDzzz+bEagpqVKlilsGMDBZ8xegdu3aCFJ/Hq9SWXjAkb8Q+OOb5mrsjY/gujZP4TqVg23pb8I+VBb+Uw7h4eFprizKNsGNI0etwQnTp09HoUKFnI/lypXLXCzBwcEoU6aMeU1qWEDuDFbu3r6kncrCTS4cBb7qA0RHAJVvR2DbcUBgyr/zKgf7UFnYh8oi+5dDUDq26xPzuKUlqQ4aNMjUsM2YMQPFixd3PsbatzZt2mDevHkJnr9//35UrFjRS3ss4geirgCzewMXjwJFqwF3T001tImISDaucTt58iTy5s1r5mX76KOPcODAAXzxxRfOx4iP8TmtWrXCe++9h9KlS5uauHfeeQclSpQwzaUi4gacwueH4aaZFKEFgV6zgZB8OtUiIv4a3Jo1a4bx48eja9euWLJkCSIiItC9e/ck04S89tpreOqpp5AjRw4zJ9ylS5fMnG9TpkxRM6WIu6x6G9g8FwjMAfSYDhTSdDwiIn4V3Direkq3Fy9enOpr2adt9OjR5iIibrZ9EbD8Rcf19hOACi10ykVEski26OMmIjZx/B9g3mC2lQKN7gcaD/L2HomIZCsKbiKSNS6fBmb1BCIvAeWbO2rbREQkSym4iUjmRUcCX/UFzh0AClZw9GsLyqkzKyKSxRTcRCTzI0h/HAnsXwXkyusYQZr7v3kURUQk6yi4iUjm/DEVWP8pVyMFuk0DilXTGRURcRMFNxHJuL2/AD+Oclxv+wJQ5XadTRERN1JwE5GMOb0H+KofEBcD1OkJ3PSIzqSIiJspuIlI+kWcd4wgjTgHlGkMdHoHCAjQmRQRcTMFNxFJn9gY4Ov7gVM7gbylgHtmADlDdBZFRDxAwU1E0mfZWGD3T0COUKDXl0DeEjqDIiIeouAmImm34Uvgf+85rnf+AChVX2dPRMSDFNxEJG0OrAXmP+q43mIkUKurzpyIiIcpuInItZ0/BMy5D4iJBKrdAbQao7MmIuIFCm4ikrrIy8CsXsDlE0DxWkCXj4BA/esQEfEG/fcVkZTFxgLfDQWObQJyFwF6zQKCw3TGRES8RMFNRFL220Rg6/dAYE6g50ygwHU6WyIiXqTgJiLJY2D7Zbzj+h1vA9c11ZkSEfEyBTcRSeroJuDbBx3Xmz4ENOijsyQiYgMKbiKS0KUTjsEIUeFApdZA25d0hkREbELBTUT+E30VmH0vcOEQULgy0O0TICiHzpCIiE0ouImIQ1wcsGAEcGgdEJIf6DUbCC2gsyMiYiMKbiLisPp9YMNMICAQ6PYpUOR6nRkREZtRcBMRYNdPwE/POc7E7eOB61vrrIiI2JBPBLfIyEjccccdWLt2bYrP2bp1K7p37466devi7rvvxpYtWxI8vmDBArRp08Y8/vDDD+PMmTMe2HMRH3ByB/D1QCAuFmjQF2jygLf3SEREfDW4Xb16FY8//jh27dqV4nPCw8MxZMgQNGrUCPPmzUP9+vXxwAMPmPtp06ZNeOaZZzBs2DDMmTMHFy5cwJgxWmtRBOFngFk9gasXgOtuAjq8CQQE6MSIiNiUrYPb7t270aNHDxw4cCDV5y1atAjBwcEYOXIkKlWqZEJanjx5sHjxYvP4jBkz0L59e3Tu3BnVqlXDxIkT8euvv+LgwYMeOhIRG4qJBr4eAJzZC+S/DrjnCyBHLm/vlYiIpMLW4/zXrVuHJk2aYMSIEahXr16Kz9u4cSMaNmyIgPiaAv5s0KABNmzYgK5du5rHBw8e7Hx+yZIlUapUKXN/2bJlU9xuTEyMuWQ1a5vu2LaoLNIqYPEYBO79BXE58yD2nplASEH+UnrlV0h/E/ahsrAPlYX/lENMOrZt6+DWu3fvND3v5MmTuP76hCPgChcu7GxePXHiBIoVK5bk8WPHjqW63Z07d8KdNm/e7NbtS9r5W1kU2b8A5TZNMdf31B2F80ejgKMbvL1bflcOdqaysA+VhT1stsn/J1sHt7S6cuUKcuVK2MTD2xzUQBEREak+npIqVaogd+7cbknW/AWoXbs2goKCsnz7orJI1f7fEbjwXXM1ttUzqNB8mNd/ZfQ3YR8qC/tQWfhPOYSHh6e5sihbBDf2b0scwng7JCQk1cdDQ0NT3S4LyJ3Byt3bl7Tzm7I4+y8wtx8QGw3UuhuBLZ+y1WAEvykHH6CysA+VRfYvh6B0bNfWgxPSqnjx4jh16lSC+3jbah5N6fGiRYt6dD9FvOrqRccapFfOACXrAXdOslVoExERPwlunJvt77//RhyX7DEr98Thr7/+Mvdbj69fv975/KNHj5qL9bhIthcbC8x7ADixFQgrAfSaBeTK+m4AIiLiXj4b3DgggX3XqF27dmZutldeecVMIcKf7PfGKUCoV69e+P777zF37lxs377dTBvSqlWrVEeUimQrP78M7FgIBAUDPb8E8pXy9h6JiIg/BbdmzZqZ+dsoLCwMH330kalVs6b/mDJlinNgASfkffHFF/H++++bEJc/f36MHz/ey0cg4iGb5gIr33Rcv2sSUKahTr2IiI/K1OAETrfx77//4uabb8bp06dRpkwZ51xqWW3Hjh2p3q5Tpw6+/fbbFF/PQMeLiF85vB74IX7U6M2PAXV6eHuPRETE08Ht/PnzePTRR80EubRkyRLTPMmVCFjTVbp0aRWKiLddOArM6g1ERwBV2gOtn/f2HomIiDeaSl9++WUzlcaaNWvMVBv06quvokSJEuYxEfGyqCvA7N7ApWNA0erA3R8DgZpmQ0TEL4PbypUrzcLv+fLlc95XqFAhs3D7H3/8kZX7JyLpxdHV3w8DjvwFhBZyjCANzqvzKCLiz4MTrl69muS+M2fOIEeObDGnr4jvWvUWsOVrIDAH0GM6UKiCt/dIRESySIZS1h133GH6tHGkJgcjcKkGNpuOHTsWHTp0yKp9E5GUnDsIhJ9Oev+/vwPLX3Rcbz8RqNBc51BExN+DG+dBe+utt8wozaioKHTu3Nks19CtWzfzmIi4ObRNaghEJ631dgoIAirfpmIQEclmMhTcuED76NGj8dhjj5mRpFyAlZPZ5smTJ+v3UEQSYk1baqGN4mIczyugSaZFRODvwe32229Hx44dTbNo5cqVs36vRERERCRrBicMHDjQrE7AJtJOnTrhgw8+wP79+zOyKRERERFxZ43bPffcYy6ciHf58uVYunSpmXi3YsWKpibu/vvvz8hmRURERMRda5VyzU8OUHjyySdNWOPyV5MmTcrMJkVEREQkBRmedG3r1q1mqauffvoJhw8fRvPmzc2qCbfccktGNykiIiIiWR3cbr31Vpw4cQJNmzbF4MGD0bZtW4SFhWVkUyIiIiLizuA2ZMgQM7K0YMGCGXm5iGRG7sJAjuDUpwTh43yeiIj4Z3DjGqT169c3S1pVqlQJu3fvTvG5jRs3zqr9E5HEODfbsPXA4lHA9oVAjc5AsxEJn8PQpjncRET8N7j16dMHv//+OwoXLmyup4RLYG3bti2r9k9EkpOvFHBgreN6w/5AqXo6TyIifiDNwW379u3JXhcRLzi4Dgg/BYTkB8o3UxGIiPiJDE0H0rp1a5w7dy7J/cePH8eNN96YFfslIqnZvsDxs0o7ICinzpWIiJ9Ic43b4sWL8euvv5rrnP7jxRdfRHBwcILn8H4uNi8ibhQXB2yb77he7Q6dahERP5LmGrcbbrghwe04fngkwnVLufyViLjR8S3Auf1AjhDg+tY61SIifiTNNW6FChXC+PHjzfXSpUublRJCQ0Odj0dGRiJXrlzu2UsR+Q9HklKlW4FceXRmRET8SIb6uN13330YPXp0guWtOAnviBEjcPHixazcPxFJbFt8/zY1k4qI+J0MBbdx48bh9OnTaN++vfO+Dz/8EKdOnTLLXomIm5z9Fzi+GQgIAqr+9/cnIiL+IUMrJ6xatQpz5swxE/Faqlevjueffx733ntvlu3c1atX8cILL2Dp0qUICQnBwIEDzSUxziu3bt26JPd37drVNO+eP38+SR+9AgUKYO3a+HmwRHyttq3cTUDuQt7eGxER8YXgxhB17NixBMGNzpw5Y1ZWyCoTJ07Eli1b8Pnnn+PIkSMYNWoUSpUqhXbt2iV43nvvvYeoqCjn7Y0bN+Kxxx5D7969zW2u8sCgtmDBgv+qGgMzVNkoYo/+bWomFRHxSxlKWazJevrpp02ftpo1azon5X3nnXdw1113ZcmOhYeHY+7cufj444/Ne/Cya9cuzJw5M0lwYyizxMTE4O2338agQYNQu3Ztc9/evXtRoUIFFC1aNEv2TcQrLp0EDqx2XK/WUYUgIuKHMhTcHn30UTMdyGuvveaciJcLzrPJkgvQZwUGwejoaLM+qqVhw4amL11sbGyKNWbz5s0zTaODBw923scat/Lly6d7HxgCeclq1jbdsW3JvmURsH0BAhGHuJL1EJu3FHca2YUvlUN2p7KwD5WF/5RDTDq2naHgxkl2n3jiCXNh82jOnDmRN29eZKWTJ0+aMOg6xUiRIkVMvzeGRU5PkhjD5NSpU9G3b1/kyfPfNAl79uwxIbBbt25mdYdGjRphzJgxKFasWKr7sHPnTrjT5s2b3bp9yV5lcf26WcgP4Ei+Bji2YQOyI18oB3+hsrAPlYU9bLbJ/6cMd0g7ePAgvvzyS+zfv9+MMl2yZIlpjmStWFa4cuVKknnhrNucMy45HGzAvnc9evRIcD+bShn0GNYY7tiU+uCDD5qm2NRWeqhSpQpy584NdyRr/gKwKVcrTXiXz5TF1YsIXPS3uVqi1f0oUaw6shOfKQc/oLKwD5WF/5RDeHh4miuLMhTc/vjjD9Mk2rx5c6xcudLUgjEcMcC99dZbuO2225BZXE4rcUCzbnNwRHIYHlu0aJGgzxstXLgQAQEBzte9++67aNasmRnE0KBBgxT3gQXkzg8Rd29fslFZ7F0BxEQChSohqERNICAA2ZHty8GPqCzsQ2WR/cshKB3bzdDQytdff900kzIAWaNIR44ciSeffNLclxWKFy+Os2fPmiZO1+ZThq98+fIl+xqGyNatky4BxBUeXMNe4cKFTbhjs6mITy0qX/2ObBvaRETETcGN1XktW7ZMcj9D04EDB5AVOC8cQ+EGl74869evN1WVyQ1MYF87Nt8mbqq9dOkSGjdujDVr1jjvY2BjKKxYsWKW7KuIW0VfBXYudVyv1kknW0TEj2UouHGt0uQ66f3yyy/msazAWrLOnTub5tdNmzZh2bJl+OSTT8zAA6v2LSIiwvl8ThXC5tUyZcok2E5YWJgJc5yIl9v5559/zDQmbOatWrVqluyriFvtWwlEXgTCSgCls6YPqYiI+KYM9XHj5LZcq5ThjZ32vvvuOxw6dMj0JeOkuVmFgwkY3Pr162cC2PDhw53959hHjWGMc8oRl+BiEyr7siU2YcIEM3UJ++WxnxxrBp999tks208Rt9o+3/GzWgfOHK2TLSLixzIU3LigfNmyZU0NWOXKlbF8+XIzopST49atWzfLdo61bgxdvCS2Y8eOBLc7dOhgLsnJnz+/CXkiPic2Bti+yHFdqyWIiPi9DE8HUq1atSytXRORZBz6A7h8AgjOD5RvrlMkIuLncqSn2fKZZ54xTZa8nhpOyMvJbe+++26ULFkyK/ZTxL9Hk1a5DciRcF5DERHxP27pMMPJczmn2kMPPeSOzYv4h7g4YFt8cFMzqYiIpKfGzbWPWFr6i23ZssU5AlREMuDEVuDsPiAoGLi+jU6hiIhkvI8bV0+YPXu2WQeUTaOcE61///5m/jWqVasWVqxYoVMsklFWbVulW4DgMJ1HERHJWFPpjBkzMHDgQLN2KBdu79Spk5kWhGuEckoQS+Klp0QkA/3b1EwqIiKZqXH7+OOP8dJLL5kJcl01atTIrFXasWPHjGxWRCxn9wPHNgEBgUDV9jovIiKS8Ro3LiPFpacSY3Dj0lMikknb42uur7sJyFNEp1NERDIe3O677z6z0PyFCxec9129ehWTJk0yzaUiklXNpKq9FhGRDDSV3nrrrc7lpOLi4nDkyBG0aNHCrKDARd+5uDzDmzU4QUQy6PIp4MBqx3UFNxERyUhw4zqhrrjm5/nz580ABI4qFZEssuNHIC4WKFEHKFhOp1VERNIf3Lp06WJ+fvnll/jqq68SrBVatWpV00Tau3fvtG5ORK7VTFq9k86RiIhkLLhxug+uhMD527p27YohQ4aYxdtPnDhhJtvlQvC//vorJk+ebJpORSQDrl4E9vzsuK5mUhERyWhw+/zzz7Fr1y4zT1vi9UdZGzdo0CD069cP06dPNxPxikgG7F4OxFwFClYAitXQKRQRkQTSXDX27bff4qmnnkpx0Xjez8e/+eabtG5SRFJsJr0DiB8MJCIiku7gxlGjderUSfU5XObq4MGDad2kiLiKjgR2LnVcr6b+bSIikongljdvXhw/fjzV53CKkEKFCqV1kyLi6t/fgKvngTzFgDKNdW5ERCTjwe2WW27B+++/b+ZwSw7v/+CDD8x8byKSidUSqnUANMBHREQyE9weeeQR7NmzB3379sXKlStx9uxZxMbGmlq4FStWoHv37qY5lSNPRSSdYmOB7Ysc19VMKiIimR1VWrRoUcyePRsvvviimQrEFaf/aNOmjalxU1OpSAYc/hO4dAwIzgdUaKFTKCIimQtuVKJECRPOTp8+jX/++cesnMC53DgoQYFNJBO2zXf8rNwWyJFLp1JERDIf3CyFCxc265SKSBZgv1HnovJ36JSKiEiKbL3EARetf/rpp9GoUSM0a9YMn3zySYrPHTp0qFl6y/Xy88/xM9AD+Oyzz9C8eXPUr1/fbPPKlSseOgqRazi5HTizFwgKdtS4iYiIZGWNm6dMnDjRLKfFVRs41cioUaNQqlQptGvXLslzOXDi9ddfx4033ui8j824tGTJEkyaNMk8ztrCMWPGmOvPP/+8R49HJFnb4mvbKrYCgvPqJImIiO/VuIWHh2Pu3Ll45plnULNmTbRt29YsqzVz5swkz42MjMShQ4dQu3ZtM4jCuuTK5egrxGW4uBwXpzThJMIvvPCCWeFBtW5iC85m0o7e3hMREbE52wa37du3Izo62jRtWho2bIiNGzeaaUhc7d27FwEBAShbtmyS7cTExGDz5s2mudVSr149REVFmfcQ8apzB4GjG4CAQKBqBxWGiIj4ZlPpyZMnUbBgQWetGRUpUsT0ezt37lyCUawMbmFhYRg5ciTWrVtnRr8OHz4cLVu2xIULF8xrihUr5nx+jhw5UKBAARw7dizVfWDo4yWrWdt0x7bFt8oiYNt88+0prmwTxIYW4o7AH3m7HERlYUf6u/CfcohJx7ZtG9zYjOka2si6zaZRVwxuERERZgAD55j76aefzGCFOXPmmLDn+lrXbSXeTmI7d+6EO7EmUOzBW2VR5c85YK+2Q2H1cGLDBvg7/U3Yh8rCPlQW9rDZJp/Ztg1uwcHBSYKVdTskJCTB/VytoU+fPs7BCNWqVTPzzH311VcYMWJEgte6bis0NDTVfahSpQpy586NrGY137JPXlBQUJZvX3ykLMLPIHDBJnO11K1DUKpgOfgr/U3Yh8rCPlQW/lMO4eHhaa4ssm1wK168uFlWi/3c2LRpNZ8ytOXLly/Jyg1WaLNUrFgRu3fvNk2iDIGnTp1CpUqVzGPcJptbOYAhNSwgd36Yu3v7YvOy2L0UiIsFitdGUJGKnn1vm9LfhH2oLOxDZZH9yyEoHdu17eCE6tWrm8C2waX5aP369SbxMqi5Gj16tJniwxUHHjC88bl8DV9r4Ta5bdbMiXh9NGl1TborIiI+HtzYjNm5c2eMGzcOmzZtwrJly8wEvFzk3qp9Y782uvXWWzF//nx899132L9/v5mzjUHtvvvuM4/37t0b06ZNM9vgtrjNHj16XLOpVMRtIi8De1Y4rmsaEBERSSPbNpUSa9EYsjgHG0eNcqTobbfdZh7jQITx48eja9eu5r6xY8di8uTJZqLeypUrY+rUqShTpox5bseOHXH48GEz4S77tvH5Tz31lJePTvza7uVAdARQoBxQvJa390ZERHyErYMba8QmTJhgLont2LEjwe3u3bubS0o42pQXEXs1k3YCAgK8vTciIuIjbNtUKpJtxUQBOxc7rmtReRERSQcFNxFP+3clEHEeyF0EKHuDzr+IiKSZgpuIp21f6PhZrQMQqOlgREQk7RTcRDyJ6+w6g1snnXsREUkXBTcRTzryF3DxKJArDKjYUudeRETSRcFNxJO2zXf8rNwWyBGscy8iIumi4CbiSc5mUq2WICIi6afgJuIpJ3cAp3cBQbmAyo6JpEVERNJDwU3E082kFVoCIfl03kVEJN0U3EQ8vVqC1iYVEZEMUnAT8YTzh4AjfwMIUHATEZEMU3AT8YTtixw/yzYBworpnIuISIYouIl4wvb4/m3VNZpUREQyTsFNxN3CzwD//u64rv5tIiKSCQpuIu62cwkQFwMUqwkUqqjzLSIiGabgJuKp0aRqJhURkUxScBNxp8hwYPdyx3WtliAiIpmk4CbiTnuWA9FXgPzXASVq61yLiEimKLiJeGJtUjaTBgToXIuISKYouIm4S0wUsONHx3U1k4qISBZQcBNxl/2/AxHngNyFgeua6jyLiEimKbiJuMu2+NGkVdsDgUE6zyIikmkKbiLuEBf3X/+2ap10jkVEJPsHt6tXr+Lpp59Go0aN0KxZM3zyyScpPveXX37BXXfdhfr166NTp05Yvjx+CoZ43EbVqlUTXC5fvuyBoxC/dOQv4OIRIFcYULGVt/dGRESyiRywsYkTJ2LLli34/PPPceTIEYwaNQqlSpVCu3btEjxv+/btGDZsGEaOHImWLVti1apVePTRR/H111+jWrVqOH78OC5evIhly5YhJCTE+brcuXN74ajEr5pJr28D5Pzvd05ERCRbBrfw8HDMnTsXH3/8MWrWrGkuu3btwsyZM5MEtwULFqBp06bo27evuV2uXDmsWLECP/74owlue/bsQdGiRVG2bFkvHY347WoJGk0qIiL+ENxYixYdHW2aPi0NGzbEhx9+iNjYWAQG/tfK26VLF0RFRSXZBmvZaPfu3ahQoYKH9lz83smdwKmdQGBOoMptfn86RETED4LbyZMnUbBgQeTKlct5X5EiRUy/t3PnzqFQoULO+ytVqpTgtayZW716NXr27Glus8btypUr6NOnD/bt24fq1aubvnPXCnMxMTHmktWsbbpj2+L9sgjYNt90Ho2r0ByxOcO4cRWLF8pBMkZlYR8qC/8ph5h0bNu2wY1ByzW0kXU7MjIyxdedOXMGw4cPR4MGDdC6dWtz3969e3H+/Hk8/vjjCAsLM82v/fv3x8KFC83tlOzcuRPutHnzZrduX7xTFtX++gp5ABzIXRenNmxQMXipHCRzVBb2obKwh802+f9k2+AWHBycJKBZt10HGLg6deoUBgwYgLi4OLz77rvO5tRp06aZptQ8efhxCrzxxhtmEMPPP/9sRqCmpEqVKm4ZwMBkzV+A2rVrIyhI83t5U5aXxYUjCJq/HXEIQJnWg1Emb4ms2M1sT38T9qGysA+Vhf+UQ3h4eJori2wb3IoXL46zZ8+afm45cuRwNp8ytOXLly/J8zly1BqcMH369ARNqaypc629YygsU6aMeU1qWEDuDFbu3r54oSx2LTY/Aso0RlCB0iqCdNLfhH2oLOxDZZH9yyEoHdu17Txu7IfGwLbBpalp/fr1JvG6DkywkuqgQYPM/TNmzDChz8LatzZt2mDevHkJnr9//35UrFjRQ0cjfjealIvKi4iIZDHb1riFhoaic+fOGDduHF599VWcOHHCTMA7fvx4Z+1b3rx5TQ3cRx99hAMHDuCLL75wPkZ8jM9p1aoV3nvvPZQuXdrUxL3zzjsoUaKEaS4VyTJXzgL/rnJc1zQgIiLiT8GNxowZY4Jbv379zCACDjq47TbH9ApcSYEhrmvXrliyZAkiIiLQvXv3BK/nNCGvvfYannrqKVN798QTT+DSpUtmzrcpU6aomVKy1s4lQGw0ULQ6UDjhSGcREZFsH9xY6zZhwgRzSWzHjh3O64sXO/oVpYR92kaPHm0uIm6jZlIREXEz2/ZxE/EpUVeA3fHr46qZVERE3ETBTSQr7FkBRIUD+csCJevqnIqIiFsouIlk5aLy1ToCAQE6pyIi4hYKbiKZFRMN7PzRcV3NpCIi4kYKbiKZdeB/jqlAQgsB192o8ykiIm6j4CaSVc2kVdsDQbYeqC0iIj5OwU0kM+LigO0LHdfVTCoiIm6m4CaSGUc3ABcOATnzAJVu0bkUERG3UnATyYpm0utbAzlDdS5FRMStFNxEsmK1BDWTioiIB6gntaTPuYNA+OmUH89dGChQ1j/O6qndwMntQGAOoIpjDV0RERF3UnCT9IW2SQ2B6Kup/EYFA8PW+0d4s2rbyjcHQgt6e29ERMQPqKlU0o41bamFNuLjqdXIZSdaVF5ERDxMwU0kIy4cBQ794bhetYPOoYiIeISCm0hG7Iifu610IyBfKZ1DERHxCAU3kYywJt2tfofOn4iIeIyCm0h6XTkH7PvNcb1aJ50/ERHxGAU3kfTatRSIjQaKVAWKXK/zJyIiHqPgJpJe2+Y7fqqZVEREPEzBTdKOk+tynrZr+ff37HtWo64Au5c7rmu1BBER8TBNwCtpx0l1OblucvO0xcYAv70O7PwRWPo0EJQDaPJA9ju7e38Boi4D+UoDpep7e29ERMTPKLhJ+sNbSqsi9PwSWPoMsOYD4MeRQMR5oMVTQEBA9ltUvlrH7HVcIiLiE9RUKln42xQI3P4q0Oppx+2fXwGWPAPExWWPsxwTDexY5LiuZlIREfECWwe3q1ev4umnn0ajRo3QrFkzfPLJJyk+d+vWrejevTvq1q2Lu+++G1u2bEnw+IIFC9CmTRvz+MMPP4wzZ8544Aj8EGuhWo0C2k1w3F7zPvD9MEfo8XUH1wBXzjjWJS13s7f3RkRE/JCtg9vEiRNNAPv8888xduxYTJo0CYsXL07yvPDwcAwZMsQEvHnz5qF+/fp44IEHzP20adMmPPPMMxg2bBjmzJmDCxcuYMyYMV44Ij/S9EGg84dAQBCwYQbwdf9rr3PqK82kVdo7+vCJiIh4mG2DG0PX3LlzTeCqWbMm2rZti0GDBmHmzJlJnrto0SIEBwdj5MiRqFSpknlNnjx5nCFvxowZaN++PTp37oxq1aqZQPjrr7/i4MGDXjgyP1KvF9BjOhCUyzGFxpf3AJGX4ZPY3LvdpX+biIiIF9g2uG3fvh3R0dGm9szSsGFDbNy4EbGxsQmey/v4WEB8Z3H+bNCgATZs2OB8nLVxlpIlS6JUqVLmfnEzznXW+ysgZx5g78/AF12AK2d977Qf2wScPwjkCAUq3ertvRERET9l2/aekydPomDBgsiVK5fzviJFiph+b+fOnUOhQoUSPPf66xPOYF+4cGHs2rXLXD9x4gSKFSuW5PFjx46lug8xMTHmktWsbbpj27ZUvgVw3zwEzroHAQfXIu7Tjoi99xsgLGGZeENayyJg6w/mW05cpdaIDQrmCzy0h/7B7/4mbExlYR8qC/8ph5h0bNu2we3KlSsJQhtZtyMjI9P0XOt5ERERqT6ekp07d8KdNm/eDP+REyFN3kCVNSOR88Q/iJrSGruavo7I3CVgB9cqixobvkEo5xYOrYUz8TW54vlyEM9RWdiHysIeNtvk/5Ntgxv7rCUOVtbtkJCQND3Xel5Kj4eG8qM4ZVWqVEHu3LnhjmTNX4DatWsjKCgI/qMeUKs+4mZ2Rci5/ai17gnE3jsPKFrVa3uUprI4sxdBF/chLiAI17UZjOs4qlQ8Xw5i67KIiY3DH/+ewYmLV1EsbzAaly+EoED3zXVYo0aNBLfZQtO6dWuMGjXK9HHOrDVr1qBo0aKm33R69evXD40bNzYD4nzp7+Lbb7/F+++/j2XLlrn9vXxJjAfKgf3601pZZNvgVrx4cZw9e9b0c8uRI4ezSZRhLF++fEmee+rUqQT38bbVPJrS4/yjTA0LyJ1/LO7evi0VvR4YuNj0dQs4uR1B0+8A7vvG66sQpFoWXA2CzaXlmyEorIhnd8zP+OXfRDYoi8VbjuKF+Vtx9HyE876S+UMwtlMNtKtV0m37+N5775l+0Oz3fPToUTz//PN488038cILL2R62wMHDsT06dMz9PvIftaBgYFZ9rvsqb8L7jP3XX+Dni+H9GzXtoMTqlevbgKbNcCA1q9fbxIvf7lccW62v//+G3HxE73y519//WXutx7nay38A+fFelw8LF8poP8iR1jj8lmfdbL3+qbWaNLqnby9JyK2w9A2dMZfCUIbHTsfYe7n4+6SP39+8wWcX87r1atnpoH68UfHFy2R7Mq2wY3NmJy+Y9y4cWYeNlbdcgLevn37Omvf2HeN2rVrZ+Zme+WVV7B7927zk/3eOAUI9erVC99//72ZXoSjVTltSKtWrVC2bApLN4n75SkM9P0BKN8ciLwIzOgK7FxqvzN/8ThwcJ3jetUO3t4bEY/hF+DwyOhULxcjojD2h3+Q3Noo1n3jfthqnnetbVlfvDMjcfcXdol5+eWX0aRJE3N58sknzeA2C2vUbrnlFlMh0LVrV/z555/m/ltvdYwc5+cNa/WS8/PPP6NLly6oU6cOOnTogKVLE/7/4uC3++67z2y7R48e5rPHdQqr22+/3TzG17o2TbJS4cEHHzQVC5w0/ptvvnF2XOc8pT179jSTyHMmhR9++ME8j593llWrVplZFfj5yHPKpk9OYM+ZFbjdI0eOOJ97/PhxM80WQy+P5cCBAxk+9+I5tm0qJU6Sy+DG/gJhYWEYPnw4brvtNvMYfxHHjx9v/tj42EcffWQm6f3qq69QtWpVTJkyxdk/jVXpL774It59912cP38eN998M1566SUvH50gJB9w71xg7gBHc+TsXkCXj4Da3exzcnYsdHwElWoA5C/t7b0R8Qh+4PeYshZ/HTiXue0wwFyIQO1x1/5S1qhcQcx98EbntE7pxdVwvvjiC9x5553O+9566y0zifvHH39s+jq//fbbePTRR82k7lxth3N6cmJ3zkrAEPfYY4/ht99+w9dff40bb7zRhDZ+XiS2evVq83nEINiyZUv88ssvGDFihJngvVatWs7+Ylz5h822H3zwgenvtmTJEhMcWXnAzySGSc43+vjjj5v3ZQ0in8f5Rvl6Bit+DvLzzOovx9YlBjC+hv36GFb5WgZBYoBk8GS3Ip6P+fPnm+ZjzsrAyg82AfO+nDlzmnPBz0lWanAWBs6Bym2Kvdk6uPEXcsKECeaS2I4dOxLc5rce/qKnhAGPF7GZnKHAPV8A3z0EbP4K+GYQcPUC0GggbGH7wv/moxPxIxnMTx41ePBg0zeIQZO1TgUKFDBf9om3Ofk6a6z4ZZ4Y1BiW+Plx+PBhExI5p2eZMmVMaGPtG/vLWdNNMUglN9CBE8EzKPXv39/crlChgmkZYjBiWCTWlrHGjRjemjdvjt9//90EqKioKJQoUQKlS5c2QYr7x2DJARGsEWOQYpegcuXKoXfv3pg6daozuHGfhw4d6hx8x8oMhjXuD2vmWHvHWkbi61ihwWMmhkVWeqxcudK0ODEEsuaQ56By5com5Ca3OpHYi62Dm/iJoJyOmjbWwP0xFVgwArhyDmj+uHf3K+I8sPdXx/Vq6t8m/oPhYM7gJohMONd5Euv2nUH/T/+45vY+G9AYN1T4b+7N5ITmDEp3bRsDCpsKGdw4mI1BjV1jWKN0+vRpE5DYtOiKwezff/9FixYtzMwBnTp1MiNUOSKV611bg+FSs2fPniTbZcsOQ6JrZYKFrUIMd3v37jUBjl11BgwYYO6z3pcVFdwua+TYDEo8LoYxNvny+Kw5SF1nVujYsSMeeugh8xwGMR4zw9nly5dNcy1rAl37hbMJlcfPOVEZdBnaLGy6VXCzPwU3sQf+Y+nwBhCSH1j5JrD8BUdwajPOe1/9d/0ExEYBhSsDRat4Zx9EvIQhKneu1Ee6Na9c1Iwe5UCE5Hqo8S+3RP4Q8zx3TA3CQQmslaLy5cub5RFZu8QBClb4+fLLL5NM68Tww6DEmq1169aZWif2H5s1a5b5ye2mhrVjiTEQuq7qk3iUIB9j8yTPK7v2sIZu+fLl+Omnn8w+8sJZFCpWrGiaVomhbdu2bWawXt68eZN9b047wuP73//+Z2rSWNPHeUqtPuDvvPOOCYiuWJPI5t7E/Qq5f2J/th2cIH6IAa3180Db+P6Hv/8fsPBxINZLs+lzfVVSM6lIshjGOOUHJY5l1m0+7s753FyxZsmqpWJTIMMTa7AY7nhhzRf7RrM2jrVTDFBNmzY1/chY08RaKNcZCFLCIJR4yURuzzUguc7JxcFzrOViKGOtGrv/sEaOtWELFy40yzAydPH1bCplU621zxyIx354KdVG8pg5QI/97BgEWQNHnDaLAZWvt7bF93n99dexb98+U9vIPt/79+93boshUexPwU3s5+ZHgE7vOv71//kJMG8wEBPl2X2IigB2x4/0UjOpSIo4T9vk+xqYmjVXvM373TmPG4MHgwkvDEbsw8XQxs75DGlsgmSft7Vr15oZBzgogEGFfdrY3MgRl6x1O3TokAlQnATV6g/HWix22L948WKS92XfNg404CAHvu9nn31mas7YTGthcy0Hy/F9OUiBwYkhkYGKNXusVTt48KAJXOxvx+ZaNnGy39tTTz1l+uFxlCv7qbF2MLV5vhjWOHMCgyffw3U//+///g8rVqww+/nss8+aqbIYIDmxMAdgcN844pV949jULPanplKxp4b9HH3evhkMbPkGuHoR6P45kCvrV7JI1r5fgchLQN5SXp8cWMTuGM7a1ihh+ryduBiBYnlDTJ82d9e0cWSnheGGIzo5gtSa6mn06NGmduuRRx4xfb/YrMgRmgxBbH7k1FEMUAx87OvF2ihrpYQ+ffqYwQycIoPhxhX71fExjjrla1hTxoDEIGTh6zk6lTMYsP+bVWvGeef4ujfeeAMffvihqRXjCFGGNpo8ebJ5DacQYXhkk2/i90+M03lwNCj7z7n20bv//vtNXzdOTHzp0iVzfqZNm2aaSomjbJ977jnTX4/Hz31mU7HYW0BcVkyek83wW5fVr8BdS15xYmH+sWmG6mvYtQyYcx8QfQW47iag92xHPzh3l8X3w4C/vwAaDwI6vpll7yfpLAfxOJWFfags/KccwtORO9RUKvZWuQ3Q51sgOB9w4H/A552AywmXL8ty7FO3I3729WqaBkREROxDwU3sr9yNQP8FQO4iwNGNwKftgfOH3fd+B9cC4aeAkAJAeUfzhYiIiB0ouIlvKFnXsTh9vjLAqZ3AJ+2A03vc817b4tcmrdLOMceciIiITSi4ie8oUtkR3gpfD5w/4AhvxzZn7Xuwy+f2+GlAqjmG1YuIiNiFgpv4lgJlgQGLgRK1gcsngM86AgfWZt32GQTPHQByhADXt8667YqIiGQBBTfxPWFFgX4LgLJNHasrfNEZ2LMia9cmrdQayJV0jUIRERFvUnAT3xRawDHa9Po2QFQ4MLMHsPX7zG93e3z/Nq2WICIiNqTgJr6Lk/H2nAXU6OxYU3Ruf+DvTMz8fWYfcHwLEBDkGJggIiJiMwpu4tty5AK6fQI06AvExQLfPwysfj9ztW3lbgJyF8rS3RQREckKCm7i+wKDHGub3vSI4/aSp4EVrzhGiGakf1v1Tlm/jyLZ1bmDwJENKV/4uBtwPVKuK2pdatasaRZb57qhWYGz2HNdz8zsn12Wj3I9Fq7baq3Hml2cPn0aP/4YP2k6YI6Px5nVIiMjzfqz3qa1SiV7CAgA2r7o6Pu2/EXgt4mOgQvtXgMC0/D95NIJ4MAax3VNAyKSNgxlkxoC0VdTfk6OYGDYeseI8CzGNTw7dOhgrkdHR2PNmjV45plnUKBAAXTu3DlT23744YcxbNgwNGjQIEOv5zql7lgyMbPHwnVTV61ahezkjTfeAFfvbN++vbnN47PWY81KixYtMuvLch1Zb1KNm2Sv8Nb8CaDDG47b6z4Cvn8IiIm+9kt38ttaHFCyHpC/jPv3VSQ7CD+demgjPs7nuUHevHnNou28lCxZEl26dDELvS9duhTeVqhQIYSEhMBucuXKZc5XdhKXqHWFx8fjdPf7eIuCm2Q/NwwGun7sGGSwcRYwtx8QFZHqSwJ2WM2kWptUxOCHVOTl1C/RV9J2svi8a20riz4Uc+TIgZw5HSuexMbGYurUqWjdujXq1KmDPn36YMeOHQlqUG6//XbUrl3b1NwtW7bM3M/nHT58GGPGjMHo0aPNfTt37jT3czt8zcyZM53bee+99/DQQw/h3nvvxQ033IB169YlaCq91n6wae+dd95BkyZN8OCDDyZ7XD///LMJpnw999U1nHJ7kyZNQq9evVC3bl307t0be/bsSfZYXJtKDx06ZK7/8ssvZn9ZG/fyyy+bY+3atatZVP2BBx7ApUuXzPP5eut8JNcsyW2wpvHuu+82+zlw4EDz3sOHDzf7ddddd2HXrl0plt1PP/1kjo3P7datmzmPlu3bt6Nnz57msebNm5vjtc79t99+ay58/8zu09y5c02Te61atUx5vPDCC2aR+a1bt5raXL6W2+e5Y5B7//330axZMzRq1MiU3ZEjR+BuCm6SPdXpAfScCQQFOwYdfNkduHox2acGRl0G9v3muFFN/dtEGKICP2sPvFoq9QtXL0kLPi8t28pEeIuKijJh5vfffzcBifih+sknn5gmVX6wly5dGoMGDUJ4eLjpFzVy5EgTTBYvXmw+2B9//HGcO3fOhIESJUqY1/HDOiIiAoMHD0bDhg3xww8/YNSoUfjggw/w3XffOd9/+fLluOOOO/D555+bgOAqtf1wDWazZs3Ck08+meTY2ATMoMGQ8f3336N79+4YMWIEtmzZ4nzORx99ZAIlw2Lx4sUxZMgQ0ycr8bEkZ8qUKeZ4XnrpJXzxxRemWfWJJ57AtGnTsGHDBhN80ur//u//zGu//PJLE3YYNm+66SazjdDQULz11lvJvo7BjOd16NCh5hzfeeed5pzv37/fPM6yql69OhYsWIBXXnnFBOFff/3VBDE2kfKS0n6mdZ8YFBlc+XvA3wmGNj5nxYoVqFKligm/PJdsimUN74wZMzB//ny8+eabmDNnDgoXLmz2h7+L7qTgJtlX1fbAfd8AucIcwWz6XUD4mSRPy39iHQJiIh1LaRXNXp12RTLV9cDmxo4da2qJeGFY4gd/v379zIc+a0P4wfroo4+aIFepUiUTTIKCgkwwOH78uPmA5QcxgxQ/cBlegoODTR85Po9Nsbzww5kfyo899hjKly9vanFYuzJ9+nTnvhQpUsTUeDFcuDaRXms/LPfccw8qVqyI66+/PslxMnAwlPXv3x8VKlTAgAEDcNttt5kwaGnRooV53Nr+mTNnTIhNfCzJYW1htWrVTPDkcXbs2BE333yzCapset67d2+ay4Q1dQxFrLFq2rQpKleubM4Lf7JcUtoWQyL7jnXq1AnlypVD3759zTExzBJrungspUuXNvd/+umnqFGjBvLkyWPONy9sns7MPrFPIkMhz22ZMmVMzRvfY/fu3aYmNywszJxLNsXyJ8MjAyVr5njeX3zxRZw/fx4rV66EO2lwgmRvFZoD/X4AZtwNHF4PfNrBMXFvvpLOpxQ4tuq/QQk+8GEl4nYBAYjttwhBsdfov3ZsU9pq3bjGcImEtVBJ5Myd7r+/Rx55xHzIEgOX9YFKrFFj7Rmbw5xvkTOn+fBmMyKDUqtWrUwIYhhiqGJNFmtgEuMHO2uEGBAtbD6z3osYKJJzrf241uut92czoSvuyzfffOO87TqIggGDx8Tt33LLLbiWsmX/GzjCAOS6L7zNmru0uta2UqqN4r5yZChrrix8LpshiTWjrBmbM2eOKTfWPqa1r15a94llwtvvvvuuCWtszmaNH0NfYpcvX8axY8dMzWegywA41s7++++/cCcFN8n+SjcEBvwIfNEFOLkNmNbGMYAhb0nT9y3/8dWO5xWp5pi+IHdht4yAE/EpDFHXWvYtR9KQk+Lz3LCEHGuHWDuTHAa55DBwsc9ZQECAaV7ctGmTaeZk/yrWbPHCWjNXHLHKmqfnn38+xX1J6f2utR/Xeh4l19Ger3V9PWuEEm/fNVCkxjWAUkqv4zlz7aDP85LRbSXG/WXTaOLRwFbtJZt+2Ry6bNky03TJmlXWLDJsX0ta94k1ZRyBy31gPzpeZ3NpSvtL7JvIkOzKHSNafaKplL8cHOLLak129pw4cWKCX9LE2A7PbyT8FsIqZXYwdMXqUNc5f3hhB0zxE8WqO771c8To+UPArJ7AlJYI+vR2BMXED1z4fqi5z0xv4Ka5p0TEM9gsyOZLfjZYWLPyzz//OGujJkyYYJpYWWuycOFC028puWYuPn/fvn2m+YxBkRdul/3BMrsfacHnbdy4McF9f//9d4LXs0bQcvHiRRw4cCDL52tjTSFrmiwHD2bd/0keCzv8W+eXF9au/fbbb7h69arpe8YAO2DAAHPe2ay6ZMkSZ6DMCswN7OvIJk8GQjZ/8jxaYdX1ffLly2e+OJw8edK5v/z9ef31183vil8GN7ZfsxMiR46w2pJ9DHhfcnjimNQZ8Njxk9XnTOIcKWMlY1Zdsp8BOxVaF/YnED9SsLxjot5rceP0BSLZCmunOU9bavg4n+cF7PPFzw/W0DCoPffccyYEcOQiP3jZf4r92hhA+HnBflTs02T1d2ITJZs5+cWfTWCsceN22CmefaH4wZ3Z/UgL9vdiSOHAB36WcZJh1hCyn5aFn5EcLMHtcxBCqVKlTN+rxMeSGRx9y35zq1evNhUfDDjWCN7M4jniKF/2G2RY4jHywj6FrI3kBML8XN+7dy82b96MP//801lWbN5m2bHfYmawDx0DMZtIOdKUI2iZL6ymVL4P+7CxDFjbyH3mwAeWK+979tlnzX66O1vYtqmUhccAxiG2xJE2rJK8//77kzyXVaf8RsORIMSC5lBg/iKzLZwpniee36xSq44WP+ClDxCRbIldCji5bmpfdLzY9YADDjiVBYMSf7JFhrU1Vid2jrhkyw4nVWUI42eI1aeKoYiP8QOZFQgff/wxXn31VdOMxg94Tv3BfldZsR/Xwv5xbHXi/rJGh7VTDAxsvrWwU//s2bPNgA1+bnJ/reZT12Ph9CAZxX5lDCYczMCaRA64sEZ9ZhanHrGOkT+vu+46M1qzcePG5vG3337bBMVu3bqZ4+LAAe6HtV9s1mTA5gjcjOJoWo4cZf9H9hNs2bKlOXdceYIDUhiEWbPGc80mdeYR1kAy0LNc2UeOgyzc3VQaEGeXGeVcMDVz1AgDmdWpkOGLnUdZjV2sWLEEz+djp06dMgVv4YnkdtiHgf0X+O2IqTgtOESbBcXhv+6Y+Zo1gPzGwG8vidvexc2ObkTQ1Gt31o0Z9DNQ8r/OxOJe+puwD5WF75UF+3sx4DB4iG/+TTB3sBaT/SuvlTtsWePGqklyDWisUSOO4kgc3NjvgBfXUTzsr8B5b4hVx6zO5bcjznvDbyscwpt4rp3E3N0Hjr8I4lmh53bCUbmeOlaVXzluu+802Z7+JuxDZeE7ZcHaHn42uvajk+z7N+G14Mb+Aim1R1uTErqOpLGuX2tYMrfLwMagx+pOYkdBtkuzsyGbX7lILL+hsD2dnQlTohq3bOhoAJCGKXZMp17VuHmMannsQ2Xhe2XBZj3OR+fa6iS+WeNm6+DGETLscJmcp556yhnSrD5pVmBLbo4dC9ua2ebNdny2P1vPZYdGBjr+ctO4ceNMOz1noE5peRFiAbmzKdPd25dkpHV4PJ+nsvE4/U3Yh8rCd8qCA+/Et/8m0rNdrwU3dvJzXavNFWvi2AGTTaZWE6jVfJrShHusKuYSIhyNwpE3HKBgsWY8tnBIL0d9ZHYEioiIiIgn2XI6EK6zxqHM69evd97H67wvcf824vxu7JTJQQocqcNlLFxZC/C6Pp+hUdOB+CGbT18gIiLic4MTXIcvs92eOCyYQ6otXIeNzahcp4yLwHL6j8mTJ5u5eazaOQ5I4LBtDuPlIr8crcGBCZxqhBMUcqFZ8e/pC2LiQzz7tJnmUdLKCSIiYlO2DW6cH4WjQ1mTxrZfzt3Cye4svM3gxYEInJiQtWiJ59ThhLysgePrrJmXOW0I58ThZL6uzafiZ+HNmlcqJsYxepQDEdSnTUREbM62wY1hjRPh8ZIc1znZOOFdatinjYMQUhuIICIiImJ3tuzjJiIiIiJJKbiJiIiI+AgFNxEREREfoeAmIiIi4iMU3ERERER8hG1HlXoTpxahK1euuG3dM2ttMi155V0qC3tQOdiHysI+VBb+Uw5X4vOGlT9SExAXFxfnlr3wYZw/juudioiIiHgKl+ssXDj1lXsU3JIRHR2N8+fPm5UZAtO4KLmIiIhIRrCmjQsF5M+f36yvnhoFNxEREREfoeokERERER+h4CYiIiLiIxTcPIxt2E8//TQaNWqEZs2a4ZNPPvH0LgiA48eP45FHHsENN9yA5s2bY/z48aZsxLuGDBmC0aNHqxi8JDIyEi+88AIaN26Mm266CW+99RY0fs3zjh49igceeAANGjTArbfeis8++8wLe+HfIiMjcccdd2Dt2rXO+w4ePIj+/fujXr166NChA1atWuWVfdN0IB42ceJEbNmyBZ9//jmOHDmCUaNGoVSpUmjXrp2nd8Vv8YOIoS1fvnyYOXOmGYjCMM2BKCwP8Y6FCxfi119/RZcuXVQEXvLyyy+bD6pp06bh8uXLGDFihPn/1LNnT5WJBz322GPmvM+bNw+7d+/Gk08+idKlS6Nt27YqBw/gl/gnnngCu3btSvC58fDDD6NKlSr45ptvsGzZMgwbNgyLFi0yZeVJqnHzIM4BM3fuXDzzzDOoWbOm+SMcNGiQCQ/iOXv37sWGDRtMLVvlypVN7SeD3IIFC1QMXnLu3DnzpaZ27doqAy+WAT+QXnrpJdSpUwc33ngjBg4ciI0bN6pMPIhfJPn/aejQoWZqiDZt2phWgdWrV6scPGD37t3o0aMHDhw4kOD+NWvWmBq3F198EZUqVTI1oqx549+Mpym4edD27dvNVCP169d33tewYUPzjzEtk+5J1ihatCimTp2KIkWKJLj/0qVLOsVeMmHCBNx11124/vrrVQZesn79eoSFhZnuA65N1/yCI54TEhKC0NBQU9sWFRVlvmj+9ddfqF69uorBA9atW4cmTZpgzpw5Ce7n53SNGjWQO3fuBJ/fDNmepuDmQSdPnkTBggWRK1cu530MD6yW5bdd8Qw2kfIbrIWhecaMGWjatKmKwAtYk/Dnn3/ioYce0vn3ItYmsDnuu+++M103Wrdujffff19fKj2M84c+//zzJjjUrVsX7du3R4sWLdC9e3dP74pf6t27t+k6w/Cc+PO7WLFiCe7jRLnHjh3z8B6qj5tHcUkL19BG1m12hBTveP3117F161Z8/fXXKgIP45eWsWPHmg8q1jSId7ty7N+/H7Nnzza1bPygYrnwA4xNpuI5e/bswS233IIBAwaYflZsvmbT9Z133qlisNnntzc+uzU4wcPfpBIXsnVbH1reC20cKPL222+bTqfiWZMmTUKtWrUS1ICKd3C2dnYXePPNN03NG3EA1axZsxTcPFwDzS+RHKjDzwX2++Qo+MmTJyu4efnz+1yiljF+fnvjs1vBzYOKFy+Os2fPmn5u1pIW/FbLgmfznXgWv8XyQ4nh7fbbb9fp99JI0lOnTjn7fVpfZJYsWYK///5bZeLhvp/8cLJCG1WoUMFMTSGew1kHypUrlyAQsG/Vhx9+qGLw8uf37t27E9zH/12Jm089QcHNg9i5lIGNnRk5ktHqEMxvVFoT1fM1PWwS4jxVmorFe7744gvzRcbyxhtvmJ+c/kA8i/2p2HS9b98+E9iIHeNdg5y4H4MAm6z5JcZqmmM5lClTRqffy38fU6ZMQUREhDNU8/ObAxQ8TYMTPIh9RTp37oxx48Zh06ZNZh4YTsDbt29fT+6G32P/kQ8++ACDBw82f3Ss9bQu4lkMBaxdsC558uQxF14Xz6pYsSJatWqFMWPGmBHwK1euNB9UvXr1UlF4ECfczZkzJ5599lkTolesWGFq2/r06aNy8KIbbrgBJUuWNH8f7HfIvw1+jnfr1s3j+6JF5r3QwZHBbenSpWbo/f33329mYhbP4R8c+/EkZ8eOHSoKL7JWTXjttddUDl5w8eJF04Xgp59+Ml80OcKOk44GBASoPDyITXKvvPKKCQaFChXCvffei379+qkcPKxq1aqYPn26mR6EWBPKeVg5NQi/XHL0KVcY8TQFNxEREREfoaZSERERER+h4CYiIiLiIxTcRERERHyEgpuIiIiIj1BwExEREfERCm4iIiIiPkLBTURERMRHKLiJiIiI+AgFNxHxK1w66L333jPXf/zxR5w+fdpt7+W6fb6nli0SkcxScBMRv3T48GE89thjZhk6T2x/4MCBzsAoIpJROTL8ShERHxYXF+fR7efJk8et7yci/kE1biLil1q3bu38OW/ePHOdi6t36NABdevWRbdu3bBu3Trn89nMyQXY+fxWrVrh0qVLWL9+PXr16mWeX69ePQwePBgnTpxIdvuJm0r//vtv81q+7tZbb8WsWbOcj40ePRrjx483NXbcdsuWLfHdd9957NyIiH0puImIX5o7d67zJ8Pa9u3bMWrUKAwdOhQ//PAD7rzzThPE9u/f73wNA9jrr7+OSZMmmRq1Bx54ADfffDMWLFiAadOm4cCBA5gyZUqy23e1Z88e9OvXD40bNzbbHD58OCZMmGCCo2XmzJmoWbOm2fZtt92GsWPH4uLFix46OyJiVwpuIuKXChUq5PwZEhJiglePHj3QqVMnlCtXDn379kWLFi0S1ISxpq1BgwaoVasWIiIi8NBDD+Hhhx9G2bJl0bBhQxOwdu3alez2XX311VeoUaMGHn/8cVSsWBFdunTBfffdh6lTpzqfU7VqVRMcue1HH33UvJ+1bRHxX+rjJiISXwvGUaBz5sxxno+oqCg0a9bMebt06dLO60WLFkXnzp3x2WefYdu2bdi9ezd27Nhhgl1a3qtOnToJ7qtfvz5mz57tvF2+fHnn9bCwMPMzOjpaZSXi5xTcREQAxMTEmBouhjFXrrVlwcHBzuvHjx/H3XffbZozb7rpJlNb98svv2Djxo3XPJ+u27HExsaafbDkzJnT4wMqRMT+FNxExC8FBAQkuF2hQgUcOnTINJNaJk6caO7v3r17ktezP1r+/Pnx0UcfOe/74osvnOEq8fYTv9cff/yR4D4OVuD9IiKpUR83EfFLoaGh5icHJVy+fBn9+/fHokWLMH36dDPIgE2gvLg2WboqUKAAjhw5gtWrV+PgwYNmUMLSpUsRGRmZ7PZd9e7d2zSvvvXWW9i3bx++/fZbfPnll7j33nvdftwi4tsU3ETEL3HQAEeOcsoNjvzktBysYWOA4ihQDiB48803zcjP5LRv3968/pFHHjFNpmvXrjWjUtl/jeEt8fZdlSpVytTUrVy50gyGmDx5spkChNsREUlNQJw6TYiIiIj4BNW4iYiIiPgIBTcRERERH6HgJiIiIuIjFNxEREREfISCm4iIiIiPUHATERER8REKbiIiIiI+QsFNRERExEcouImIiIj4CAU3ERERER+h4CYiIiIC3/D/FqvnaA0z310AAAAASUVORK5CYII=",
            "text/plain": [
              "<Figure size 700x400 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 600x500 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "history_by_iteration = history_df.groupby(level=0).first().copy()\n",
        "history_by_iteration[\"best_so_far\"] = history_by_iteration[\"best_observed\"].cummin()\n",
        "\n",
        "fig, ax = plt.subplots(figsize=(7, 4))\n",
        "ax.plot(\n",
        "    history_by_iteration.index,\n",
        "    history_by_iteration[\"best_so_far\"],\n",
        "    marker=\"o\",\n",
        "    label=\"Best observed\",\n",
        ")\n",
        "ax.plot(\n",
        "    history_by_iteration.index,\n",
        "    history_by_iteration[\"best_posterior\"],\n",
        "    marker=\"s\",\n",
        "    label=\"Posterior optimum estimate\",\n",
        ")\n",
        "ax.set_xlabel(\"Iteration\")\n",
        "ax.set_ylabel(\"Objective\")\n",
        "ax.set_title(f\"Optimization trace for {function_name}\")\n",
        "ax.legend()\n",
        "plt.show()\n",
        "\n",
        "final_result = bayesopt_pipeline.calculate(campaign_dataset, disable_progress_bar=True)\n",
        "\n",
        "if dimension == 1:\n",
        "    grid_x = np.asarray(final_result[\"composition_grid_raw\"].values, dtype=float)\n",
        "    surrogate_mean = np.asarray(final_result[\"botorch_mean\"].values, dtype=float)\n",
        "    surrogate_var = np.asarray(final_result[\"botorch_variance\"].values, dtype=float)\n",
        "    acquisition = np.asarray(final_result[\"botorch_decision_surface\"].values, dtype=float)\n",
        "\n",
        "    x_plot = grid_x[:, 0]\n",
        "    order = np.argsort(x_plot)\n",
        "\n",
        "    fig, axes = plt.subplots(3, 1, figsize=(8, 10), sharex=True)\n",
        "\n",
        "    axes[0].plot(\n",
        "        x_plot[order],\n",
        "        evaluate_objective(grid_x)[order],\n",
        "        label=\"True objective\",\n",
        "        color=\"black\",\n",
        "    )\n",
        "    axes[0].scatter(\n",
        "        campaign_dataset[\"composition\"].values[:, 0],\n",
        "        campaign_dataset[\"objective\"].values,\n",
        "        color=\"tab:red\",\n",
        "        label=\"Samples\",\n",
        "    )\n",
        "    axes[0].set_ylabel(\"Objective\")\n",
        "    axes[0].legend()\n",
        "\n",
        "    axes[1].plot(\n",
        "        x_plot[order],\n",
        "        surrogate_mean[order],\n",
        "        color=\"tab:blue\",\n",
        "        label=\"Surrogate mean\",\n",
        "    )\n",
        "    axes[1].fill_between(\n",
        "        x_plot[order],\n",
        "        surrogate_mean[order] - 2.0 * np.sqrt(surrogate_var[order]),\n",
        "        surrogate_mean[order] + 2.0 * np.sqrt(surrogate_var[order]),\n",
        "        color=\"tab:blue\",\n",
        "        alpha=0.2,\n",
        "        label=\"Mean +/- 2 sigma\",\n",
        "    )\n",
        "    axes[1].set_ylabel(\"Surrogate\")\n",
        "    axes[1].legend()\n",
        "\n",
        "    axes[2].plot(\n",
        "        x_plot[order],\n",
        "        acquisition[order],\n",
        "        color=\"tab:green\",\n",
        "        label=\"Acquisition\",\n",
        "    )\n",
        "    axes[2].set_xlabel(\"x\")\n",
        "    axes[2].set_ylabel(\"Decision surface\")\n",
        "    axes[2].legend()\n",
        "\n",
        "    plt.show()\n",
        "\n",
        "elif dimension == 2:\n",
        "    grid_x = np.asarray(final_result[\"composition_grid_raw\"].values, dtype=float)\n",
        "    surrogate_mean = np.asarray(final_result[\"botorch_mean\"].values, dtype=float)\n",
        "\n",
        "    fig, ax = plt.subplots(figsize=(6, 5))\n",
        "    sc = ax.tricontourf(\n",
        "        grid_x[:, 0],\n",
        "        grid_x[:, 1],\n",
        "        surrogate_mean,\n",
        "        cmap=\"coolwarm\",\n",
        "    )\n",
        "    ax.scatter(\n",
        "        final_result[\"botorch_best_x\"].values[0],\n",
        "        final_result[\"botorch_best_x\"].values[1],\n",
        "        color=\"white\",\n",
        "        edgecolor=\"black\",\n",
        "        marker=\"X\",\n",
        "        s=100,\n",
        "        label=\"Posterior optimum\",\n",
        "        zorder=5,\n",
        "    )\n",
        "    ax.scatter(\n",
        "        campaign_dataset[\"composition\"].values[:, 0],\n",
        "        campaign_dataset[\"composition\"].values[:, 1],\n",
        "        color=\"red\",\n",
        "        edgecolor=\"white\",\n",
        "        s=60,\n",
        "        label=\"Samples\",\n",
        "    )\n",
        "    ax.set_xlabel(\"x0\")\n",
        "    ax.set_ylabel(\"x1\")\n",
        "    ax.set_title(f\"Surrogate mean for {function_name}\")\n",
        "    ax.legend(loc=\"upper right\", ncol=2, bbox_to_anchor=(0.5, 1.25))\n",
        "    fig.colorbar(sc, ax=ax, label=\"Surrogate mean\")\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6994249c",
      "metadata": {},
      "source": [
        "## 7. Compare Suggested Configurations\n",
        "\n",
        "Create a compact table of all evaluated points, sorted by objective value."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "id": "b52703ab",
      "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>x0</th>\n",
              "      <th>x1</th>\n",
              "      <th>objective</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>9.341378</td>\n",
              "      <td>1.249534</td>\n",
              "      <td>1.767633</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>2.417188</td>\n",
              "      <td>4.707776</td>\n",
              "      <td>6.049219</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>2.126608</td>\n",
              "      <td>8.887860</td>\n",
              "      <td>37.289563</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>0.873225</td>\n",
              "      <td>0.007312</td>\n",
              "      <td>38.271271</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0.771559</td>\n",
              "      <td>0.101214</td>\n",
              "      <td>39.423838</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>0.739864</td>\n",
              "      <td>0.140901</td>\n",
              "      <td>39.675945</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>0.742352</td>\n",
              "      <td>0.134035</td>\n",
              "      <td>39.691980</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>7</th>\n",
              "      <td>0.736352</td>\n",
              "      <td>0.145820</td>\n",
              "      <td>39.698644</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>0.732232</td>\n",
              "      <td>0.148247</td>\n",
              "      <td>39.756984</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>0.743102</td>\n",
              "      <td>0.125440</td>\n",
              "      <td>39.758941</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>10</th>\n",
              "      <td>0.729175</td>\n",
              "      <td>0.147832</td>\n",
              "      <td>39.821335</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>11</th>\n",
              "      <td>0.727157</td>\n",
              "      <td>0.144875</td>\n",
              "      <td>39.889377</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>12</th>\n",
              "      <td>0.706368</td>\n",
              "      <td>0.106018</td>\n",
              "      <td>40.674245</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>13</th>\n",
              "      <td>-3.518548</td>\n",
              "      <td>5.211992</td>\n",
              "      <td>64.868666</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>14</th>\n",
              "      <td>7.703730</td>\n",
              "      <td>11.422624</td>\n",
              "      <td>111.771974</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "          x0         x1   objective\n",
              "0   9.341378   1.249534    1.767633\n",
              "1   2.417188   4.707776    6.049219\n",
              "2   2.126608   8.887860   37.289563\n",
              "3   0.873225   0.007312   38.271271\n",
              "4   0.771559   0.101214   39.423838\n",
              "5   0.739864   0.140901   39.675945\n",
              "6   0.742352   0.134035   39.691980\n",
              "7   0.736352   0.145820   39.698644\n",
              "8   0.732232   0.148247   39.756984\n",
              "9   0.743102   0.125440   39.758941\n",
              "10  0.729175   0.147832   39.821335\n",
              "11  0.727157   0.144875   39.889377\n",
              "12  0.706368   0.106018   40.674245\n",
              "13 -3.518548   5.211992   64.868666\n",
              "14  7.703730  11.422624  111.771974"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "results_df = pd.DataFrame(\n",
        "    campaign_dataset[\"composition\"].values,\n",
        "    columns=[str(feature) for feature in campaign_dataset.coords[\"component\"].values],\n",
        ")\n",
        "\n",
        "results_df[\"objective\"] = campaign_dataset[\"objective\"].values\n",
        "results_df = results_df.sort_values(\"objective\", ascending=True).reset_index(drop=True)\n",
        "results_df"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4930b3e1",
      "metadata": {},
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": ".venv (3.12.11)",
      "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.12.11"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}