diff --git a/examples/hypoAL.ipynb b/examples/hypoAL.ipynb deleted file mode 100644 index cbd9920..0000000 --- a/examples/hypoAL.ipynb +++ /dev/null @@ -1,1521 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "hypoAL_paper_Algo1.ipynb", - "provenance": [], - "collapsed_sections": [], - "mount_file_id": "1-ixeuqsSo4uHHfnuQ7zq54N3i_k4H3wf", - "authorship_tag": "ABX9TyNqOwrUIy0s6MQz1n+a+fhU", - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "source": [ - "# Hypothesis learning: toy data example" - ], - "metadata": { - "id": "KswNo4REitip" - } - }, - { - "cell_type": "markdown", - "source": [ - "This notebook demonstrates how to apply the hypothesis learning to toy data. The [hypothesis learning](https://arxiv.org/abs/2112.06649) is based on the idea that in active learning, the correct model of the system’s behavior leads to a faster decrease in the overall Bayesian uncertainty about the system under study. In the hypothesis learning setup, probabilistic models of the possible system’s behaviors (hypotheses) are wrapped into structured GPs, and a basic reinforcement learning policy is used to select a correct model from several competing hypotheses.\n", - "\n", - "*Prepared by Maxim Ziatdinov (March 2022)*" - ], - "metadata": { - "id": "4M3tFS1hiebL" - } - }, - { - "cell_type": "markdown", - "source": [ - "Installations:" - ], - "metadata": { - "id": "H7NQ_pNfi2pe" - } - }, - { - "cell_type": "code", - "metadata": { - "id": "9cNHFhBbKjzz" - }, - "source": [ - "!pip install -q git+https://github.com/ziatdinovmax/gpax" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "3RmuZCkiH01r", - "cellView": "form" - }, - "source": [ - "#@title Imports\n", - "from typing import Union, Dict, Type\n", - "\n", - "import gpax\n", - "\n", - "import jax.numpy as jnp\n", - "import jax.random as jra\n", - "import numpy as onp\n", - "import numpyro\n", - "import matplotlib.pyplot as plt\n", - "\n", - "gpax.utils.enable_x64()" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "ukjdW3IYiHeu", - "cellView": "form" - }, - "source": [ - "#@title Plotting and data utilities { form-width: \"20%\" }\n", - "\n", - "def get_training_data(X, Y, num_seed_points=2, rng_seed=42, **kwargs):\n", - " onp.random.seed(rng_seed)\n", - " indices = jnp.arange(len(X))\n", - " idx = kwargs.get(\"list_of_indices\")\n", - " if idx is not None:\n", - " idx = onp.array(idx)\n", - " else:\n", - " idx = onp.random.randint(0, len(X), num_seed_points)\n", - " idx = onp.unique(idx)\n", - " X_train, y_train = X[idx], Y[idx]\n", - " indices_train = indices[idx]\n", - " X_test = jnp.delete(X, idx)\n", - " y_test = jnp.delete(Y, idx)\n", - " indices_test = jnp.delete(indices, idx)\n", - " return X_train, y_train, X_test, y_test, indices_train, indices_test\n", - " \n", - "\n", - "def plot_results(X_measured, y_measured, X_unmeasured, y_pred, y_sampled, obj, model_idx, rewards, **kwargs):\n", - " X = jnp.concatenate([X_measured, X_unmeasured], axis=0).sort()\n", - " fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))\n", - " ax1.scatter(X_measured, y_measured, marker='x', s=100, c='k', label=\"Measured points\", zorder=1)\n", - " ax1.plot(X, y_pred, c='red', label='Model reconstruction', zorder=0)\n", - " ax1.fill_between(X, y_pred - y_sampled.std(0), y_pred + y_sampled.std(0),\n", - " color='r', alpha=0.2, label=\"Model uncertainty\", zorder=0)\n", - " ax1.set_xlabel(\"$x$\", fontsize=18)\n", - " ax1.set_ylabel(\"$y$\", fontsize=18)\n", - " ax2.plot(X_unmeasured, obj, c='k')\n", - " ax2.vlines(X_unmeasured[obj.argmax()], obj.min(), obj.max(), linestyles='dashed', label= \"Next point\")\n", - " ax2.set_xlabel(\"$x$\", fontsize=18)\n", - " ax2.set_ylabel(\"Acquisition function\", fontsize=18)\n", - " ax1.legend(loc=\"upper left\")\n", - " ax2.legend(loc=\"upper left\")\n", - " step = kwargs.get(\"e\", 0)\n", - " plt.suptitle(\"Step: {}, Sampled Model: {}, Rewards: {}\".format(\n", - " step+1, model_idx, onp.around(rewards, 3).tolist()), fontsize=24)\n", - " fig.savefig(\"./{}.png\".format(step))\n", - " plt.show() \n", - " \n", - "\n", - "def plot_acq(x, obj, idx):\n", - " plt.plot(x.squeeze(), obj, c='k')\n", - " plt.vlines(x[idx], obj.min(), obj.max(), linestyles='dashed')\n", - " plt.xlabel(\"$x$\", fontsize=18)\n", - " plt.ylabel(\"Acquisition function\", fontsize=18)\n", - " plt.show()\n", - " \n", - "\n", - "def plot_final_result(X, y, X_test, y_pred, y_sampled, seed_points):\n", - " plt.figure(dpi=100)\n", - " plt.scatter(X[seed_points:], y[seed_points:], c=jnp.arange(1, len(X[seed_points:])+1),\n", - " cmap='viridis', label=\"Sampled points\", zorder=2)\n", - " cbar = plt.colorbar(label=\"Exploration step\")\n", - " cbar_ticks = jnp.arange(2, len(X[seed_points:]) + 1, 2)\n", - " cbar.set_ticks(cbar_ticks)\n", - " plt.scatter(X[:seed_points], y[:seed_points], marker='x', s=64,\n", - " c='k', label=\"Seed points\", zorder=1)\n", - " plt.plot(X_test, y_pred, '--', c='red', label='Model reconstruction', zorder=1)\n", - " plt.plot(X_test, truefunc, c='k', label=\"Ground truth\", zorder=0)\n", - " plt.fill_between(X_test, y_pred - y_sampled.std(0), y_pred + y_sampled.std(0),\n", - " color='r', alpha=0.2, label=\"Model uncertainty\", zorder=0)\n", - " plt.xlabel(\"$x$\", fontsize=12)\n", - " plt.ylabel(\"$y$\", fontsize=12)\n", - " plt.legend(fontsize=9, loc='upper left')\n", - " #plt.ylim(1.8, 6.6)\n", - " plt.show()" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "IdXQ-tJXhmUC" - }, - "source": [ - "First, let's generate some data. As a practical example chosen here, we are interested in the active learning of phase\n", - "diagram that has a transition between different phases. The phase transition manifests in discontinuity of a measurable system’s property, such as heat capacity. However, we usually do not know where a phase transition occurs precisely, nor are we aware of the exact behavior of the property of interest in different phases. We note that using a standard Gaussian process-based active learning is not an optimal choice in such a case as simple GP struggles around the discontinuity point." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 400 - }, - "id": "Onu_jtyMH3q2", - "outputId": "70b13847-8d70-427b-b1d8-debc43fb2d9d" - }, - "source": [ - "def function_(x: jnp.ndarray, params: Dict[str, float]) -> jnp.ndarray:\n", - " return jnp.piecewise(\n", - " x, [x < params[\"t\"], x >= params[\"t\"]],\n", - " [lambda x: x**params[\"beta1\"], lambda x: x**params[\"beta2\"]])\n", - "\n", - "\n", - "X = jnp.linspace(0.0, 2.5, 100)\n", - "params = {\"t\": 1.6, \"beta1\": 4, \"beta2\": 2.5}\n", - "\n", - "truefunc = function_(X, params)\n", - "Y = truefunc + 0.33 * jra.normal(jra.PRNGKey(0), shape=truefunc.shape)\n", - "\n", - "_, ax = plt.subplots(dpi=100) \n", - "ax.scatter(X, Y, alpha=0.5, c='k', label=\"Noisy observations\")\n", - "ax.plot(X, truefunc, lw=2, c='k', label=\"True function\")\n", - "ax.legend()\n", - "ax.set_xlabel(\"$x$\")\n", - "ax.set_ylabel(\"$y$\")" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "Text(0, 0.5, '$y$')" - ] - }, - "metadata": {}, - "execution_count": 4 - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "hJ31U3oPhe8u" - }, - "source": [ - "Define possible models of system's behavior as dereministic functions:" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "zdrtXqGPKzUe" - }, - "source": [ - "def piecewise1(x: jnp.ndarray, params: Dict[str, jnp.ndarray]) -> jnp.ndarray:\n", - " return jnp.piecewise(\n", - " x, [x < params[\"t\"], x >= params[\"t\"]],\n", - " [lambda x: x**params[\"beta\"], lambda x: params[\"c\"]*x])\n", - " \n", - "def piecewise2(x: jnp.ndarray, params: Dict[str, jnp.ndarray]) -> jnp.ndarray:\n", - " return jnp.piecewise(\n", - " x, [x < params[\"t\"], x >= params[\"t\"]],\n", - " [lambda x: params[\"b\"]*x, lambda x: params[\"c\"]*x])\n", - " \n", - "def piecewise3(x: jnp.ndarray, params: Dict[str, jnp.ndarray]) -> jnp.ndarray:\n", - " return jnp.piecewise(\n", - " x, [x < params[\"t\"], x >= params[\"t\"]],\n", - " [lambda x: x**params[\"beta1\"], lambda x: x**params[\"beta2\"]])" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "z6az3H14qKQg" - }, - "source": [ - "Put priors over parameters of each model to make them probabilistic:" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "lqXxUSGeqGhm" - }, - "source": [ - "def piecewise1_priors() -> Dict[str, jnp.ndarray]:\n", - " # Sample model parameters\n", - " t = numpyro.sample(\"t\", numpyro.distributions.Uniform(0.5, 2.0))\n", - " beta = numpyro.sample(\"beta\", numpyro.distributions.Normal(3, 1))\n", - " c = numpyro.sample(\"c\", numpyro.distributions.Normal(3, 1))\n", - " # Return sampled parameters as a dictionary\n", - " return {\"t\": t, \"beta\": beta, \"c\": c}\n", - "\n", - "def piecewise2_priors() -> Dict[str, jnp.ndarray]:\n", - " # Sample model parameters\n", - " t = numpyro.sample(\"t\", numpyro.distributions.Uniform(0.5, 2.0))\n", - " b = numpyro.sample(\"b\", numpyro.distributions.Normal(3, 1))\n", - " c = numpyro.sample(\"c\", numpyro.distributions.Normal(3, 1))\n", - " # Return sampled parameters as a dictionary\n", - " return {\"t\": t, \"b\": b, \"c\": c}\n", - "\n", - "def piecewise3_priors() -> Dict[str, jnp.ndarray]:\n", - " # Sample model parameters\n", - " t = numpyro.sample(\"t\", numpyro.distributions.Uniform(0.5, 2.0))\n", - " beta1 = numpyro.sample(\"beta1\", numpyro.distributions.Normal(3, 1))\n", - " beta2 = numpyro.sample(\"beta2\", numpyro.distributions.Normal(3, 1))\n", - " # Return sampled parameters as a dictionary\n", - " return {\"t\": t, \"beta1\": beta1, \"beta2\": beta2}" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "7KuF0Zd5tgHg" - }, - "source": [ - "Let's also specify custom priors over GP kernel:" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "RW7STCxetmVc" - }, - "source": [ - " def gp_kernel_prior() -> Dict[str, jnp.ndarray]:\n", - " length = numpyro.sample(\"k_length\", numpyro.distributions.Uniform(0, 1))\n", - " scale = numpyro.sample(\"k_scale\", numpyro.distributions.LogNormal(0, 1))\n", - " return {\"k_length\": length, \"k_scale\": scale}" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "k2HhVQcO-RtT" - }, - "source": [ - "Helper functions for running the hypothesis learning:" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "KGn9AeH33kN1" - }, - "source": [ - "def get_best_model(record):\n", - " return record[:,1].argmax()\n", - "\n", - "def update_record(record, action, r):\n", - " new_r = (record[action, 0] * record[action, 1] + r) / (record[action, 0] + 1)\n", - " record[action, 0] += 1\n", - " record[action, 1] = new_r\n", - " return record\n", - "\n", - "def get_reward(obj_history, obj):\n", - " \"\"\"A reward of +/-1 is given if the integral uncertainty at the current step\n", - " is smaller/larger than the median uncertainty at the previous step\"\"\"\n", - " if jnp.nanmedian(obj) < obj_history[-1]: # one can use integral uncertainty instead of median\n", - " r = 1\n", - " else:\n", - " r = -1\n", - " return r\n", - "\n", - "def step(model, model_prior, X_train, y_train, X_new=None, num_restarts=1, **kwargs):\n", - " \"\"\"Compute model posterior and use it to derive acqusition function\"\"\"\n", - " acq_fn = gpax.acquisition.UE\n", - " verbose = kwargs.get(\"print_summary\", True)\n", - " sgr = numpyro.diagnostics.split_gelman_rubin\n", - " for i in range(num_restarts):\n", - " rng_key, rng_key_predict = gpax.utils.get_keys(i)\n", - " # Get/update model posterior. In the paper, we used\n", - " # num_samples = num_warmup = 5000 but that takes some time\n", - " gp_model = gpax.ExactGP(\n", - " 1, 'Matern', kernel_prior=gp_kernel_prior,\n", - " mean_fn=model, mean_fn_prior=model_prior)\n", - " gp_model.fit(\n", - " rng_key, X_train, y_train, num_warmup=2000,\n", - " num_samples=2000, num_chains=1, print_summary=verbose)\n", - " rhats = [sgr(v).item() for v in gp_model.get_samples(1).values()]\n", - " if max(rhats) < 1.1:\n", - " break \n", - " # Compute acquisition function\n", - " obj = 0\n", - " if X_new is not None:\n", - " obj = acq_fn(rng_key_predict, gp_model, X_new)\n", - " return obj, gp_model\n", - "\n", - "def update_datapoints(next_point_idx, train, test):\n", - " \"\"\"Update \"measured\" dummy data points\"\"\"\n", - " X_train, y_train, indices_train = train\n", - " X_test, y_test, indices_test = test\n", - " X_train = jnp.append(X_train, X_test[next_point_idx][None], 0)\n", - " X_test = jnp.delete(X_test, next_point_idx, 0)\n", - " y_train = jnp.append(y_train, y_test[next_point_idx])\n", - " y_test = jnp.delete(y_test, next_point_idx)\n", - " indices_train = jnp.append(indices_train, next_point_idx)\n", - " indices_test = jnp.delete(indices_test, next_point_idx)\n", - " return (X_train, y_train, indices_train), (X_test, y_test, indices_test)" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ElREFYU5-PEm" - }, - "source": [ - "Generate seed points:" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "TIV4yxEUVKo7" - }, - "source": [ - "(X_train, y_train, X_test, y_test,\n", - " indices_train, indices_test) = get_training_data(X, Y, list_of_indices=[0, 33, 66, 99])\n", - "num_seed_points = len(X_train)" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ipQJp0Lj_22L" - }, - "source": [ - "The main part (Algorithm 1 in the paper):" - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "W7orp6mL5BEU", - "outputId": "cfb312b9-9d9f-49e3-a12d-103b448020f0" - }, - "source": [ - "exploration_steps = 15\n", - "eps = 0.4\n", - "warmup_steps = 3\n", - "models = [piecewise1, piecewise2, piecewise3]\n", - "model_priors = [piecewise1_priors, piecewise2_priors, piecewise3_priors]\n", - "save_reconstruction = True # available only for exploration phase\n", - "\n", - "\n", - "onp.random.seed(55) # rng seed for epsilon-greedy sampling\n", - "record = onp.zeros((len(models), 2))\n", - "model_choices = []\n", - "obj_history = []\n", - "# Warm-up phase\n", - "for w in range(warmup_steps):\n", - " print(\"Warmup step {}/{}\".format(w+1, warmup_steps))\n", - " obj_median_all, obj_all = [], []\n", - " # Iterate over probabilistic models in the list\n", - " for i, model in enumerate(models):\n", - " # for each model, run BI and store uncertainty values\n", - " obj, _ = step(model, model_priors[i], X_train, y_train, X_test)\n", - " record[i, 0] += 1\n", - " obj_all.append(obj)\n", - " obj_median_all.append(jnp.nanmedian(obj).item()) # (one can use integral uncertainty instead of median)\n", - " # 'Reward' a model that has the smallest integral/median uncertainty\n", - " idx = onp.argmin(obj_median_all)\n", - " model_choices.append(idx)\n", - " record[idx, 1] += 1\n", - " # Store the integral/median uncertainty\n", - " obj_history.append(obj_median_all[idx])\n", - " # Compute the next measurement point using the predictive uncertainty of rewarded model\n", - " obj = obj_all[idx]\n", - " next_point_idx = obj.argmax()\n", - " next_point = indices_test[next_point_idx]\n", - " # Evaluate the function in the suggested point\n", - " measured_point = y_test[next_point_idx]\n", - " # Update training/test data\n", - " ((X_train, y_train, indices_train),\n", - " (X_test, y_test, indices_test)) = update_datapoints(\n", - " next_point_idx, (X_train, y_train, indices_train), (X_test, y_test, indices_test))\n", - "# Average over the number of warmup steps\n", - "record[:, 1] = record[:, 1] / warmup_steps\n", - "\n", - "# Run exploration\n", - "for e in range(exploration_steps - warmup_steps):\n", - " print(\"Exploration step {}/{}\".format(e+warmup_steps+1, exploration_steps))\n", - " # Choose model according to epsilon-greedy policy\n", - " if onp.random.random() > eps: \n", - " idx = get_best_model(record)\n", - " else:\n", - " idx = onp.random.randint(len(models))\n", - " model_choices.append(idx)\n", - " print(\"Using model {}\".format(idx+1))\n", - " # Derive acqusition function with the selected model\n", - " obj, m_post = step(models[idx], model_priors[idx], X_train, y_train, X_test, num_restarts=2)\n", - " # Get reward\n", - " r = get_reward(obj_history, obj)\n", - " # Update records\n", - " record = update_record(record, idx, r)\n", - " obj_history.append(jnp.nanmedian(obj).item())\n", - " # Evaluate function in the suggested point\n", - " next_point_idx = obj.argmax()\n", - " next_point = indices_test[next_point_idx]\n", - " measured_point = y_test[next_point_idx]\n", - " if save_reconstruction: \n", - " # plot current reconstruction and acqusition function\n", - " y_pred, y_sampled = m_post.predict(gpax.utils.get_keys()[1], X)\n", - " plot_results(X_train, y_train, X_test, y_pred, y_sampled.squeeze(), obj, idx+1, record[:, 1], e=e)\n", - " # Update training/test data\n", - " ((X_train, y_train, indices_train),\n", - " (X_test, y_test, indices_test)) = update_datapoints(\n", - " next_point_idx, (X_train, y_train, indices_train), (X_test, y_test, indices_test))" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Warmup step 1/3\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:24<00:00, 162.74it/s, 1023 steps of size 3.26e-03. acc. prob=0.76]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " beta 2.62 0.87 2.51 1.40 4.19 513.33 1.00\n", - " c 3.37 0.52 3.40 2.51 4.18 518.68 1.00\n", - " k_length 0.46 0.29 0.45 0.00 0.88 713.82 1.00\n", - " k_scale 1.18 1.22 0.81 0.07 2.55 854.43 1.00\n", - " noise 1.24 1.29 0.87 0.06 2.63 658.38 1.00\n", - " t 1.52 0.42 1.70 0.83 2.00 361.99 1.00\n", - "\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:19<00:00, 206.09it/s, 1023 steps of size 2.18e-03. acc. prob=0.81]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " b 2.48 0.88 2.38 1.16 3.95 361.32 1.00\n", - " c 3.39 0.54 3.43 2.52 4.25 506.65 1.00\n", - " k_length 0.51 0.29 0.53 0.01 0.90 466.31 1.00\n", - " k_scale 1.36 1.33 0.94 0.06 2.85 604.46 1.00\n", - " noise 1.31 1.36 0.91 0.04 2.77 472.10 1.00\n", - " t 1.50 0.44 1.69 0.76 2.00 284.39 1.00\n", - "\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:06<00:00, 600.32it/s, 15 steps of size 4.39e-01. acc. prob=0.86] \n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " beta1 2.88 1.00 2.85 1.17 4.44 1387.64 1.00\n", - " beta2 2.42 0.16 2.43 2.19 2.67 1234.74 1.00\n", - " k_length 0.51 0.29 0.50 0.10 1.00 1653.89 1.00\n", - " k_scale 0.86 0.80 0.62 0.04 1.82 1488.36 1.00\n", - " noise 0.85 0.84 0.58 0.04 1.74 1697.79 1.00\n", - " t 1.16 0.39 1.16 0.50 1.67 1402.66 1.00\n", - "\n", - "Warmup step 2/3\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:12<00:00, 330.59it/s, 255 steps of size 1.65e-02. acc. prob=0.82]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " beta 2.93 0.93 2.91 1.40 4.46 978.65 1.00\n", - " c 3.27 0.49 3.28 2.38 4.00 1452.27 1.00\n", - " k_length 0.44 0.30 0.42 0.00 0.89 1221.52 1.00\n", - " k_scale 1.20 1.25 0.84 0.07 2.55 1299.67 1.00\n", - " noise 1.95 1.51 1.59 0.10 3.65 1330.92 1.00\n", - " t 1.23 0.39 1.23 0.54 1.82 1322.04 1.00\n", - "\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:09<00:00, 439.36it/s, 31 steps of size 1.11e-01. acc. prob=0.83] \n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " b 2.77 0.91 2.74 1.33 4.31 1068.48 1.00\n", - " c 3.29 0.56 3.30 2.49 4.29 698.60 1.00\n", - " k_length 0.47 0.30 0.46 0.00 0.90 1054.74 1.00\n", - " k_scale 1.33 1.47 0.90 0.03 2.75 469.21 1.00\n", - " noise 2.05 1.55 1.69 0.17 3.64 1134.67 1.00\n", - " t 1.27 0.44 1.27 0.65 1.99 1135.40 1.00\n", - "\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:28<00:00, 141.19it/s, 1023 steps of size 2.37e-04. acc. prob=0.88]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " beta1 3.70 0.46 3.78 2.90 4.37 7.57 1.37\n", - " beta2 2.47 0.12 2.47 2.26 2.65 4.65 1.44\n", - " k_length 0.46 0.30 0.42 0.06 0.94 9.73 1.03\n", - " k_scale 0.68 0.44 0.57 0.09 1.21 30.67 1.03\n", - " noise 1.18 1.00 1.02 0.04 2.55 4.31 1.74\n", - " t 1.56 0.13 1.60 1.28 1.67 17.52 1.18\n", - "\n", - "Warmup step 3/3\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:10<00:00, 383.73it/s, 127 steps of size 3.19e-02. acc. prob=0.80] \n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " beta 2.97 0.95 2.96 1.43 4.63 1127.77 1.00\n", - " c 3.20 0.51 3.19 2.35 4.05 866.11 1.00\n", - " k_length 0.45 0.30 0.41 0.00 0.88 1150.91 1.00\n", - " k_scale 1.25 1.18 0.89 0.07 2.63 1230.32 1.00\n", - " noise 1.77 1.25 1.50 0.20 3.31 966.88 1.00\n", - " t 1.25 0.40 1.24 0.68 1.98 861.01 1.00\n", - "\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:22<00:00, 175.90it/s, 1023 steps of size 3.29e-03. acc. prob=0.82]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " b 2.74 0.86 2.70 1.21 4.02 941.87 1.00\n", - " c 3.28 0.53 3.27 2.44 4.18 688.67 1.00\n", - " k_length 0.45 0.30 0.43 0.00 0.88 1024.45 1.00\n", - " k_scale 1.34 1.35 0.95 0.06 2.76 1024.58 1.00\n", - " noise 1.79 1.30 1.45 0.20 3.25 1382.90 1.00\n", - " t 1.32 0.45 1.34 0.69 2.00 848.68 1.00\n", - "\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:29<00:00, 135.07it/s, 1023 steps of size 1.10e-04. acc. prob=0.90]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " beta1 3.70 0.20 3.71 3.35 3.98 13.36 1.20\n", - " beta2 2.35 0.12 2.37 2.16 2.50 2.66 3.02\n", - " k_length 0.69 0.16 0.74 0.41 0.90 5.78 1.23\n", - " k_scale 0.65 0.36 0.58 0.14 1.06 6.18 1.30\n", - " noise 0.36 0.11 0.36 0.20 0.48 4.07 1.37\n", - " t 1.59 0.02 1.59 1.57 1.61 112.90 1.00\n", - "\n", - "Exploration step 4/15\n", - "Using model 1\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:14<00:00, 274.45it/s, 255 steps of size 1.23e-02. acc. prob=0.82]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " beta 2.96 0.94 2.97 1.56 4.63 885.79 1.00\n", - " c 3.27 0.47 3.25 2.51 4.08 988.09 1.00\n", - " k_length 0.43 0.31 0.38 0.00 0.88 883.19 1.00\n", - " k_scale 1.19 1.21 0.83 0.07 2.52 1000.59 1.00\n", - " noise 1.85 1.14 1.58 0.28 3.44 997.16 1.00\n", - " t 1.22 0.38 1.22 0.52 1.77 979.26 1.00\n", - "\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Exploration step 5/15\n", - "Using model 3\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:39<00:00, 100.29it/s, 1023 steps of size 7.85e-04. acc. prob=0.91]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " beta1 3.80 0.26 3.81 3.39 4.25 44.71 1.08\n", - " beta2 2.44 0.11 2.43 2.26 2.62 24.53 1.09\n", - " k_length 0.48 0.29 0.48 0.03 0.89 74.24 1.00\n", - " k_scale 0.67 0.69 0.49 0.03 1.29 39.01 1.01\n", - " noise 0.54 0.43 0.41 0.05 1.10 27.33 1.01\n", - " t 1.60 0.01 1.60 1.59 1.62 23.33 1.06\n", - "\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Exploration step 6/15\n", - "Using model 2\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:41<00:00, 95.48it/s, 1023 steps of size 1.29e-03. acc. prob=0.88] \n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " b 2.64 0.83 2.65 1.26 3.89 466.29 1.00\n", - " c 3.38 0.45 3.37 2.66 4.11 142.61 1.02\n", - " k_length 0.47 0.31 0.48 0.00 0.90 191.07 1.00\n", - " k_scale 1.23 1.14 0.90 0.09 2.59 394.35 1.00\n", - " noise 1.67 0.97 1.43 0.26 3.04 242.22 1.00\n", - " t 1.32 0.42 1.34 0.69 2.00 168.45 1.01\n", - "\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Exploration step 7/15\n", - "Using model 3\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:57<00:00, 69.44it/s, 1023 steps of size 1.34e-03. acc. prob=0.82]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " beta1 3.84 0.20 3.86 3.50 4.15 229.07 1.00\n", - " beta2 2.45 0.10 2.46 2.29 2.61 163.36 1.01\n", - " k_length 0.57 0.28 0.61 0.12 0.98 96.41 1.00\n", - " k_scale 0.58 0.57 0.40 0.03 1.21 198.00 1.00\n", - " noise 0.36 0.31 0.28 0.05 0.69 116.43 1.00\n", - " t 1.60 0.01 1.60 1.59 1.62 104.91 1.00\n", - "\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Exploration step 8/15\n", - "Using model 3\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [01:06<00:00, 60.27it/s, 1023 steps of size 1.50e-03. acc. prob=0.84]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " beta1 3.85 0.19 3.86 3.57 4.18 289.01 1.00\n", - " beta2 2.45 0.09 2.45 2.30 2.61 214.06 1.01\n", - " k_length 0.59 0.28 0.64 0.15 1.00 136.27 1.00\n", - " k_scale 0.50 0.50 0.36 0.05 1.09 245.19 1.00\n", - " noise 0.31 0.23 0.25 0.05 0.56 112.05 1.00\n", - " t 1.60 0.01 1.60 1.59 1.62 124.97 1.01\n", - "\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Exploration step 9/15\n", - "Using model 2\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:48<00:00, 81.65it/s, 1023 steps of size 7.68e-05. acc. prob=0.79]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " b 4.33 0.34 4.28 3.82 4.79 6.40 1.49\n", - " c 2.82 0.38 2.90 2.19 3.26 2.98 2.53\n", - " k_length 0.62 0.17 0.63 0.37 0.86 6.87 1.02\n", - " k_scale 2.43 0.46 2.41 1.69 3.15 14.65 1.00\n", - " noise 0.32 0.19 0.25 0.11 0.61 3.01 1.83\n", - " t 1.61 0.01 1.60 1.59 1.62 82.14 1.04\n", - "\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:51<00:00, 77.93it/s, 1023 steps of size 6.28e-05. acc. prob=0.84]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " b 4.61 0.30 4.64 4.09 5.12 7.04 1.33\n", - " c 3.33 0.15 3.28 3.15 3.59 3.79 1.32\n", - " k_length 0.58 0.13 0.60 0.35 0.76 6.16 1.40\n", - " k_scale 1.75 0.29 1.83 1.18 2.11 7.57 1.15\n", - " noise 0.60 0.13 0.60 0.41 0.83 3.00 1.99\n", - " t 1.61 0.01 1.61 1.59 1.63 66.28 1.05\n", - "\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Exploration step 10/15\n", - "Using model 1\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [01:05<00:00, 61.39it/s, 1023 steps of size 1.18e-03. acc. prob=0.77]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " beta 3.20 0.89 3.24 1.75 4.59 69.80 1.03\n", - " c 3.26 0.35 3.27 2.69 3.81 150.13 1.03\n", - " k_length 0.47 0.30 0.46 0.00 0.90 89.75 1.02\n", - " k_scale 0.93 0.92 0.66 0.07 1.90 174.27 1.00\n", - " noise 1.13 0.62 1.02 0.22 2.02 147.46 1.00\n", - " t 1.33 0.33 1.36 0.84 1.98 74.87 1.01\n", - "\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Exploration step 11/15\n", - "Using model 3\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [01:29<00:00, 44.79it/s, 1023 steps of size 5.31e-04. acc. prob=0.93]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " beta1 3.86 0.16 3.86 3.60 4.11 50.76 1.02\n", - " beta2 2.46 0.08 2.46 2.34 2.60 28.27 1.07\n", - " k_length 0.55 0.28 0.57 0.13 0.98 27.90 1.00\n", - " k_scale 0.35 0.34 0.25 0.03 0.70 40.06 1.01\n", - " noise 0.27 0.12 0.25 0.09 0.42 47.75 1.01\n", - " t 1.60 0.01 1.60 1.59 1.62 65.62 1.00\n", - "\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Exploration step 12/15\n", - "Using model 2\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [01:27<00:00, 45.66it/s, 1023 steps of size 8.04e-05. acc. prob=0.98]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " b 2.40 0.49 2.26 1.90 3.56 8.60 1.10\n", - " c 3.15 0.40 3.19 2.52 3.70 2.73 2.36\n", - " k_length 0.57 0.15 0.58 0.35 0.82 10.02 1.02\n", - " k_scale 1.66 0.87 1.51 0.69 2.70 4.47 1.46\n", - " noise 0.84 0.22 0.78 0.54 1.18 3.02 1.95\n", - " t 1.38 0.17 1.42 1.13 1.65 10.85 1.00\n", - "\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [01:22<00:00, 48.38it/s, 1023 steps of size 3.02e-05. acc. prob=0.99]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " b 2.31 0.26 2.32 1.81 2.67 4.85 1.37\n", - " c 3.71 0.16 3.68 3.47 3.95 3.66 1.49\n", - " k_length 0.44 0.08 0.44 0.32 0.56 9.74 1.08\n", - " k_scale 0.51 0.11 0.52 0.33 0.69 2.72 2.30\n", - " noise 1.22 0.15 1.18 1.05 1.53 4.00 1.49\n", - " t 1.47 0.06 1.48 1.40 1.57 8.27 1.16\n", - "\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Exploration step 13/15\n", - "Using model 3\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [01:32<00:00, 43.10it/s, 1023 steps of size 3.51e-03. acc. prob=0.73]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " beta1 3.87 0.17 3.88 3.58 4.12 619.54 1.00\n", - " beta2 2.48 0.07 2.49 2.35 2.58 721.12 1.00\n", - " k_length 0.63 0.25 0.66 0.27 1.00 795.21 1.00\n", - " k_scale 0.38 0.35 0.28 0.04 0.78 823.89 1.00\n", - " noise 0.25 0.13 0.22 0.09 0.41 535.62 1.00\n", - " t 1.60 0.01 1.60 1.59 1.62 543.06 1.00\n", - "\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Exploration step 14/15\n", - "Using model 2\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [01:34<00:00, 42.22it/s, 1023 steps of size 3.15e-05. acc. prob=0.93]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " b 3.57 0.15 3.53 3.36 3.86 10.29 1.00\n", - " c 2.65 0.11 2.69 2.47 2.80 3.33 1.84\n", - " k_length 0.41 0.04 0.42 0.33 0.47 6.83 1.00\n", - " k_scale 1.59 0.16 1.55 1.35 1.79 5.25 1.20\n", - " noise 0.51 0.04 0.51 0.45 0.57 3.94 1.27\n", - " t 1.61 0.02 1.61 1.59 1.64 10.73 1.07\n", - "\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [01:33<00:00, 42.94it/s, 1023 steps of size 1.33e-03. acc. prob=0.96]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " b 3.28 0.78 3.22 2.10 4.51 5.05 1.55\n", - " c 3.35 0.58 3.39 2.37 4.33 5.04 1.64\n", - " k_length 0.63 0.26 0.69 0.25 1.00 15.36 1.02\n", - " k_scale 1.49 1.15 1.09 0.20 3.27 6.65 1.41\n", - " noise 0.92 0.45 0.89 0.20 1.58 11.97 1.29\n", - " t 1.52 0.10 1.54 1.36 1.63 2.72 2.36\n", - "\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Exploration step 15/15\n", - "Using model 3\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [01:56<00:00, 34.43it/s, 1023 steps of size 3.47e-03. acc. prob=0.73]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " beta1 3.83 0.17 3.84 3.56 4.10 567.27 1.00\n", - " beta2 2.48 0.07 2.49 2.37 2.60 529.09 1.00\n", - " k_length 0.64 0.25 0.68 0.28 1.00 415.99 1.00\n", - " k_scale 0.36 0.36 0.25 0.03 0.74 665.74 1.00\n", - " noise 0.23 0.11 0.21 0.09 0.37 475.71 1.00\n", - " t 1.60 0.01 1.60 1.59 1.61 351.57 1.00\n", - "\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "VQbb8mOa-V62" - }, - "source": [ - "Plot integral/median uncerainty as a function of exploration steps:\n", - "\n", - "(note that for the warm-up steps, we plot only model that produced lowest uncertainty)" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "0rVeoqj5aiEl", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 397 - }, - "outputId": "f400ebc5-fdba-47e1-9740-a1919207590d" - }, - "source": [ - "plt.figure(dpi=100)\n", - "plt.plot(onp.arange(1, exploration_steps+1), obj_history, c='k')\n", - "plt.scatter(onp.arange(1, exploration_steps+1), obj_history,\n", - " c=[m+1 for m in model_choices],\n", - " s=128, cmap='rainbow', alpha=1)\n", - "plt.xlabel(\"Exploration step\", fontsize=14)\n", - "plt.ylabel(\"Median uncertainty\", fontsize=14)\n", - "plt.xticks(size=14)\n", - "plt.yticks(size=14)\n", - "cbar = plt.colorbar()\n", - "cbar.set_ticks([1, 2, 3])" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgIAAAF8CAYAAAC9hdPgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9eZxcZZX//z7Vne5OutOdfSUrWSAhLEHCDgkgi7ivo4MK4zYojI4zzug4Ki7z9ecsKowKiAsqIzqi6MiOQMIOCRCyQMjaSS9ZOun03uml6vz+uHUrlU5Vd9WtW1W3qs779Xpe1VX3uc89Wbru555znnNEVTEMwzAMozQJ5dsAwzAMwzDyhwkBwzAMwyhhTAgYhmEYRgljQsAwDMMwShgTAoZhGIZRwpgQMAzDMIwSxoSAYRiGYZQwJgQMwzAMo4QxIWAYhmEYJYwJAcMwDMMoYUwIGIZhGEaBIiLXi8gGEemIjudE5Kq01rBeA4ZhGIZRmIjI24AwsA0Q4KPAF4AzVHVzSmuYEDAMwzCM4kFEWoEvqOpPU5lfnmV7igYREWAG0JlvWwzDMIyMGQs0a5aehkWkCqjwcck+Ve0b4ZplwPuAauC5VBc2IZA6M4DGfBthGIZh+MYJQJPfi4pI1TTo3ed9iS6gZshnXwduSnK9ZTg3/qroue9S1ddSvZiFBlJERGqB9oaGBmpra/NtjmEYhuGRjo4OZs2aBVCnqh1+rx+7X4SEdO8WHcCsiIIjUuI90Ek9AiJSAcwG6oD3Ah8HLk5VDJhHIE1qa2tNCBiGYRgjUgvUiqR30tGH885URYqq9gPbo29fEpGzgM8Cn0rlfBMChmEYhpENygTSFgJAJGNPfQioTHWyCQEjMIT74UgblFVCZW36vz+GYRiBoizkQQgoDERSni4i3wYeBPbgJEB+CFgJXJHqGiYEjLwS7ofX/wAv/Dc0Pnv081HVcPp1cNb1MHlJ/uwzDMPwTLlHj0B6TAF+CUwH2oENwBWq+miqC1iyYIq4yR/t7e2WI+AT2x6Aez8CvYdAykDDxx4PlUNkEBa+Bd79P1A1Lj92GoZRXHR0dFBXVwdZThZsr6tMO0egQ5W69r6s2ZYIKzFs5IWNv4ZfvxV6W533Q0UAOCIAYPvD8NNzoedQ7uwzDMPImJA4eQLpjFDuY6ImBIycs+dp+ONHcVxgKTikNAyHtsHdb4dIAsFgGIYRSMpC3kaOMSFg5JwnvhK/QyY1NOzkEOx4ODs2GYZhlComBIyccnAL1K9OHAoYCSmDF3/gu0mGYRjZwTwChnE8L90B4nGvioZh+0PQvsdfmwzDMLJCuvkB7sgxJgSMnNKyGXQw8bEIEZ7mO+zh2cQTABQOvpEd2wzDMHylQDwCVkfAyCl9w2yG2c2T/IUvMpXTuJ71Sef1d2XBMMMwDL/xsgsgD4XUTAgYOWW4WgBt1ANwmJ3DrlFpZRwMwygEyiT9J/xw6lUF/cJCA0ZOmb7cSfpLRBd7AeinkyMkdh1IGUxZmi3rDMMwSg8TAkZOWf4J0CSCt4uj3bs7aDzueKgcTnoX1EzLlnWGYRg+YsmChnE84+bAoqsTewU6ox4BgA4ajjseGYQVN2TTOsMwDB8pkGRBEwJGzln1LSgbxXFJMV3HCIFjPQISgkVvgzkX5cBAwzAMPzAh4A0RqRKR74rIkyLSLCJHRGSfiDwjIteJyKg01gqJyI0islFEekWkRUTuFpH52fwzGMMz7TT4qz9BWYVzg3fpTCIEJAQnnAvv/Y21JjYMo4Cw0IBnaoDrcarQ3w98F7gXmAn8DLhPRFK1+3bgFpxnz1uAh4B3A2tFZKHPdhtpcOLlcN2TMHGR817K9BiPQDsNSMjJC1j+CfjIYzBqTJ6MNQzD8EKBeASCuH2wFaf9Yn/8hyJSDjwKXA5chSMSkiIiq4CPA08Cb3bXE5FfAw8APwCu8N16I2VmroBPv+Y0IVr9vU4G7u2JHesd3cglX4Uz/gaqp+TRSMMwDK+EPDzhq3kEUNXIUBEQ/XwQxzMAsCCFpT4Rff1K/Hqq+iCwGrhcRGZnaK6RISIw50I459t7j/k8NK+BC75oIsAwDCPbBE4IJCMaDrgy+nZTCqesBLqBZxIcc3vYXZy5ZYYf7N3rCIFRo5wUkMbG47cPGoZhFBQWGsgMEakA/gUnvj8RuBQ4Cfi5qj42wrnVwHRgk2rCPnfboq9J8wREpBKojPtobOrWG+niCoFTTz2Vl156iY6ODjo6OqittTKChmEUKF6S//IQGgisEAAqgK/FvVfgP4EvpXBuXfS1PcnxjiHzEvGlIdc3sogrBBYsWMCOHTtoa2ujsbGRJUuW5NkywzAMj3h5wtfsmDIcgQ0NqGqXqgpQBswCPoOT/LdaRHLxmPhtHKHgjhNycM2SxRUC06dP54QTnL9qCw8YhlHQ2PZBf4gmDzaq6q3AJ4HzgS+PcJrrCUj2xF87ZF6i6/apaoc7gM507DbSw4SAYRhFR4HkCAReCAzhkejryuEmqWo3sBeYJ5KwxY2bG7AtwTEjD+zb5/QZmD59OrNmzQKgoeH4MsOGYRiGvxSaEJgRfR1IYe4aoBrHgzAUt37Ak34YZWSOeQQMwyg6QpK+NyBkoQFEZImIHFdDLvrZd6NvH4j7fJKInCQik4ac8uPo6zejOxDc+VfheBQeUdXdvhpveMaEgGEYRUeB5AgEcdfA+4HPi8jTQD1Ohv9MnGqCE4GngO/Fzb8BJ7v/68BN7oeq+oSI/AQnwfBlEbkfZ0vhB3CqF96Y7T+IkRpHjhzh8OHDgIUGDMMoIrzE/CO53zYQRCFwH04I4DzgXJzeA+3ABuA3wM+iVQZT4VPARpwkw88CXTjVCb+sqjt8ttvwiJsfUFlZyfjx480jYBhGceDlCT9iHgFUdR2wLo35NxHnCRhyLILTbOgWP2wzsoMbFpg2bRoiEhMC7e3tdHZ2Mnas1XIyDKMAKRCPQOByBIzSIz4/AGDs2LHU1Tk7P80rYBhGwVIgOQImBIy8M1QIABYeMAzDyBEmBIy8k0gIWMKgYRgFT8hDMaGQNR0ySpD4HAEX8wgYhlHweHH12/ZBoxSx0IBhGEWJl2TBMts+aJQgFhowDKMoMY+AYaRGfJ8BF/MIGIZR8BSIR8CSBY28Eg6HOXDgAGBCwDAMIx+YR8DIKwcOHCASiRAKhZgyZUrsczc00NbWRldXFzU1Nfky0TAMwxtl4sEjEMmOLcNgHgEjr7j5AVOmTKGs7GjH6LFjx1JbWwuYV8AwjAIlJN5Grs3M+RUNI45EiYIuFh4wDKOgKZA6AiYEjLwynBCwnQOGYRQ0BVJi2HIEjLxSLB6BAcLspIUu+lBgNKOYzyRGU5Fv0wzDyBeedg1YZUGjxCh0IdBKN+vYzcs00M+x3bHLEE5hBmcxlxmMy5OFhmHkDasjYBgjU8ihgc00cy/rUUA5fu9vGGUjzbxKExezkItYiJD7X3LDMIzhMCFg5JVEfQZcguwR2EQzf+CVEedFogJhDdsIo1zC4mybZhhGUAh5SP6zZEGj1ChEj8Ahuvkj69M+72m2s5X9WbDIMIxAUiDJgiYEjLyhqgnLC7u4HgG3qFBQWEd9gkDAyAjwHDv9NscwjKBi2wcNY3gOHz5Mf38/kDg0UFtby9ixYwFoamrKqW3J6GeQV2hImBMwEgrsppUWOv03zDCM4GEeAcMYHjcsMH78eKqqqhLOCVp4YDst9BP2fL4gbKLZR4sMwwgsbo5AuiPXZub8ioYRZbj8AJegJQx20Tfs8fs+/SN+cdmXCQ8MJjwuQPcIaxiGUSQUiEfAdg0YeaMQhUAERSBhYGCwb4B1tz2IqtLy2h6mnTY/6RqGYRhBwTwCRt5IRQgELTQwhlFJb+Nt9ftRdY62NxxMukYVo7JgmWEYgcPtPpjWMI+AUUIUokdgPpOSegRad+yN/ZxMCERQFjE1O8YZhhEsvHQTLJTugyJS6bchRulRiEKghipOZnrCCoGt2+OEwJ4DCc+fwBjmMCFr9hmGESDS9gZ46E3gA16v2CwiN4vIMl+tMUqKQgwNAJzF3ITbB+M9Ah1JPAJnM8/KDBtGqSBy1CuQ6pAC8QgAncCNwHoReU5E/kZExvhol1ECpOMROHz4MN3d3TmxayTmMIFzOT4R8PCOfbGf2/e0HHNMgAVM5kxmZ9s8wzCCQpF7BOYBVwF/AM4A7gD2ishtIvImv4wzipvh+gy41NbWUlNTAwSnqBDAZZzECuYCxJ7vh8sRmM8k3styQpafaxhGwPD0raQOD6vq+4ATgH8CmoBPAi+IyCsicr2I1Ppoq1FEdHV1xcoGD+cREJFAhgcE4UqW8h7OYDp1RCIR2nYd7SPQ2XSISDjMeMZwBUv4IGdRYbm5hlFapBsW8JJc6IeZmS6gqgdV9b9UdQlwIfALYAHwA5xcgp+LyIpMr2MUF26PgTFjxsTKCCcjaAmD8SxlBh/nAt7aNJ/BvgHKyssJlZURHhjkiv3zuYGVnM088wQYRilS5KGBZHQCPcAgjse0DPgo8JyI3C8iU3y+nlGgxOcHyAjJMUH0CAyla4eTEzBv7lxmzpgBQKih2xIDDaOUKRWPgIjUiMgnReRF4BXg08BW4GPABGAFcA9OTsHtmV7PKA5SSRR0CbJHwGXHjh0AnHjiiTHhsmfPnnyaZBhGvikQj4DnoKWInAN8AngfUAN0AT8GblfV+Gbt64APiEg/8PYMbDWKiGIWAq2trTz77LOB9mAYhpEDCqSgkCchICIbgSU47v9XcJ70f62qwzWN3wz8tZfrGcVHOkKgEEID8UKguroaMI+AYZQ8IQ9P+AXUfXA+8HPgbFU9U1V/PIIIAPgfYNVIC4vITBH5nIg8IiJ7RKRfRPaJyO9F5OxUDRSRlSKiw4xrU13L8J9i9gjMnu3UCgiycDEMw3DxGhqYrqod6Zygqg1AKt+MNwL/DOwAHgFagIXAO4F3isiHVPW3aVx6DbA6wefrE3xm5AgvQqC1tZWenh7GjAle7ap4IeBiQsAwSpxiDg0AfxSRO1X1l8kmiMg1wN+o6iVprv0isFJV1wxZ70LgMeBWEfmjqqba1H21qt6Upg1GlklHCNTV1VFTU0NXVxeNjY0sWrQo2+alRWtrK21tbQDMnz+f/v5+wEIDhlHyhELpu/oLKDSwEqJl1ZIzB7g43YVV9Q9DRUD086eAJ4DxgPU4KHDSEQIiEujwgOsNmD59OmPGjImFBvbv309fX6p61TCMoqOMaCvidEbuzcym9KgGBnxe011vMI1zFkZzDr4kIh8WkZk+22SkSX9/P4cOHQKGLy8cTyEIATcsMHHiRKqqqoBg2msYRo5wPQLpjhyTcmhARIZ2SxmX4DNw9Mws4D1AvXfTEl7/MmAvsDGNUz8UHS6DIvLfwBdUNTzM9SqB+HbLw5e/M1LGrSpYXl7OxIkTUzonyDsHhgoBEWH27Nls3bqVhoaGY/IGDMMoIQokRyAd6VEP7IoOBT4b9z5+bMdx4S/EaUaUMSIyCvgVzo35n4e7gcfRAnwROAWnzsFUnITD7cDfA/8+wvlfAtrjhj3a+YQrBKZNm0YoRfVbSB4BCLZwMQzDiCedZMFf4ggAAT4CvErizPsw0Ao8rqoPZWqgiISAO4GLgDtU9VepnKeqm3FqF7h0A38SkReADcDfich3VPVAkiW+DXw37v1YTAz4Qjr5AS5BFgLbt28HEgsBSxg0jBLGjfune06OSVkIqOq17s8icjHwc1W9JRtGxV0nBPwMx7V/F/C3ma6pqvtE5E/Ax4GzgT8nmdcHxDK9RqqHb6SOFyEQ5CfsRB4BqyVgGEah7BrwtH1QVef5bchQoiLg5zjeh7uBa1U14tPybrP4ap/WM9KgmDwCvb29NDc3A+YRMAzjWCIiRNKM+Ufy8NAZyAbpQ0TAb4EPp5gXkCpuhcJ6H9c0UiQTj8ChQ4cCVVRo586dgFPrID7x0TwChmFEQiEiaT7hpzvfDzxfUUQuE5EHRKRFRAZEJJxgpLPNz13XDQd8BPgdcM0I2f2TROQkEZk05PMzk8z/LE6p423A2nTtMzLHixCoq6uL1fBvamrKil1eiA8LxIePghzKMAwjN0RC4mnkGq9Nh96D86QeAnYDW0hvb/9wfBX4KE43w63AvyaIz/8xrsPhDcDXgK8DN8XN+b2IDOB0P2zECQOcA5wBtDGCwDCyhxch4BYVeuONN2hsbGThwoXZMi8tEuUHwFEh0N7eTkdHB7W1tTm3zTCM/BIuCxFOs+lQuvP9wGto4KtAL/AOVX3cR3vgaMXCGuDLSebUM3KvgFuBK3B2G0wEIjii5fvAf6lqsILNJYQXIQDOzfWNN94I1FN2MiFQU1PD+PHjOXz4MA0NDSxdujQf5hmGYYyIVyGwGPhVFkSAuzvh2jTm38SxngD38+8A3/HJLMMnwuEw+/fvB9IXAkFMGEwmBMARLocPH2bPnj0mBAyjBPHi6s9HaMCrD+IQ0OOnIUZpcPDgQcLhMCLClClT0jq30ISAJQwaRmmjoZCnkWu8egTuAS4TkXJV9Ss3wCgB3LDApEmTGDVqVFrnBi0BLxwOU19fDyT3CEBw7DUMI7cUu0fgX3AS7n6bpN+AYSTEa34ABM8j0NDQwMDAABUVFcyceXwvK9cjYLUEDKM0KepdAzhNf0bhZOG/U0TacOrxD0VV1TquGDHcPgPFIATcsMC8efMoKzu+d6h5BAyjtHFu7OnWESgcIRDC2S4Y/6iTyHqry2scQyYeAffGevDgQXp7exk9erSvtqXLcPkBYNUFDcMoDLyWGJ7rsx1GiZCJEBg3bhxjxoyhp6eHpqYmFixY4Ld5aTGSEHBDA42Njaiq9aswjBJDPZQY1jx8T+Q+PdEoaTIRAm5RIQhGeGAkITBz5kxEhL6+PlpaWnJpmmEYASAsIU8j15gQMHJKJkIAghV3H0kIjBo1KvbntPCAYZQeRZUsKCJfBRT4oaq2Rt+ngqrqNz1bZxQdmQqBoHgEVJXt27cDyYUAOMKlubmZhoYG3vSmN+XKPMMwAkChbB9MNUfgJhwh8FuglQSV/JKggAkBA3Bunn55BPItBFpaWujq6kJEmDcveVfuWbNm8cILL5hHwDBKEC8FgoJcUGhV9HXPkPeGkTLt7e0cOXIEyNwjkO/QgBsWmDlzJlVVVUnnWXVBwyhdisojoKprhntvGKngegPq6uo8b/0LSmhgpPwAF9tCaBhG0PFaR8Aw0ibTsAAEJ1kwVSFgHgHDKF0ioZCHgkLBDQ0kRUTKgElAZaLjqmqPQgZwVAhMmzbN8xquR+DgwYMcOXJkWLd8NnGFwEi1DIIiXAzDyD0RESJp1gVId74feBYCInIm8P+Ai4CKJNM0k2sYxUUm5YVdxo8fz+jRo+nt7aWpqWnEJ/JskW5ooLm5mYGBgbQbLRmGUbgUSo6AJx+EiJwOPAWcCzyCU0p4Q/Tng9H3a4Bf+WOmUQz4ERoQkUA8ZacqBKZMmUJFRQWqSnNzcy5MMwwjIGg0NJDOyMeuAa9X/Er09WxVfUf053tV9SpgLnAbcArw9czMM4oJP4QA5D9hsKuri/379wMjC4FQKBSz1xIGDaO0CCOEJc2RhxY9XoXABcD/qerrcZ8JgKr2AjcAzTihA8MAikcI7Ny5E4AJEyYwbty4EedbwqBhlCZu98H0RuEIgTpgZ9z7AaDGfaOqEWA1cKlny4yiwy8hkO/QQKphAZd822sYhjEcXhP5DgDj497vAxYOmVMFjPG4vlGEFItHwKsQsNCAYZQWKpJ2N8FC6j74GrA47v0zwOUici6AiJwMvB/Ykpl5RrHQ29tLe3s7UHpCwEIDhlGaFErTIa9C4H7gIhFxv9G/g5Mj8LSItAAbgXFYjoARxfUGVFVVUVdXl9Fa+Xa1m0fAMIxUiEjI08g1Xq94GzATOASgqq/i5AM8hLN98C/A21T1Xj+MNAqf+LCAZOj6cj0CLS0tsd4FucQ8AoZhpEKheAQ85Qio6gCwf8hnzwJX+2GUUXz4lR8ATrZ+VVUVR44cobm5mfnz52e8ZqoMDAywe/duIH2PQGtrK93d3VRXV2fNPsMwgkOhVBb0WlDoqyJy0QhzLhSRr3ozyyg2/BQC+SwqtHv3bsLhMFVVVSn/Werq6qitrQXMK2AYRvDwGhq4CVg5wpyLgK95XN8oMvzoMxBPvhIG3bDA/PnzCaVRASzfeQ2GYeSeSChEOM2Rj6ZD2bxiBRDO4vpGAeFHn4F48nVjTTc/wMUSBg2j9HBDA+mOXJNJQyBNdkBEKoALceoNGIavoQHIv0cgXSFgCYOGUXoUSo5AykJARHYO+ejvReS6BFPdtsRVwB0Z2GYUEaUuBCw0YBilh3poIpSPpkPpeARCHPUCKE7dgETSZQDYDDwOfDMj64yiwW8hUGihAdcjYKEBwygdis4joKpz3Z9FJAJ8T1W/kQ2jjOJicHCQlpYWoLA9AqoaazhkHgHDMEai6ITAEK4DXvXTEKN42b9/P6pKWVkZkydP9mVNVwgcOHCAvr4+KisrfVl3OPbt20dPTw+hUIi5c+emdW58sqCqZlxUyTAMwy+8BiN+CnzST0OM4sUNC0ydOjWtLXfDMXHiRKqqqgBoamryZc2RcMMCs2fPpqKiIq1zXeHS29tLa2ur77YZhhE8InjYNZAw4p5dvH4rtwC5r+1qFCR+5weAU1Qo1+EBr/kB4PRYmDJlCmDhAcMoFYq918CjwErJgn9TRGaKyOdE5BER2SMi/SKyT0R+LyJnp7lWSERuFJGNItIrIi0icreI5K4mrZEVIQC5zxPIRAiAJQwaRqkRES+1BHJvp1ch8EVgIvBjEZngoz0ANwLfA+YDjwD/BTwNvAN4VkQ+kMZatwO34OxuuAWnKdK7gbUistBPo43kZEsI5DoBL1MhYAmDhlFaREJCOM1RME2HgLuANuBvgGtEZBdOE6KhRYZUVS9Nc+0XgZWquib+QxG5EHgMuFVE/qiqfcMtIiKrgI8DTwJvVtX+6Oe/Bh4AfgBckaZthgf8Li/sUmgeAasuaBilhRdXfz5CA16FwMq4nyuBk6JjKEmrDyZDVf+Q5POnROQJ4HJgGbBuhKU+EX39iisCous8KCKrgctFZLaq2rdylrHQgINVFzQMI4h4kh6qGkpxlPls70D0dTCFuSuBbuCZBMcejr5enOxkEakUkVp3AGPTMdQ4it99Blxy6Wrv6Ojg4MGDgHkEDMNIDRXxNHJN7n0QHhGR2cBlwF5g4whzq4HpwC5VTdT4aFv0dbg8gS8B7XEjt7Vsi4hi8Ai43oDJkyczdqw3TWgeAcMoLSKIp5FrMhYCIlIjIsujMfysICKjgF/hhCH+OcnNPZ666Gt7kuMdQ+Yl4tvR4+44ITVrjXhUNesegf3799PXN2zKSMZs374d8O4NgKP2NjU1EQ5bY07DKHYKpfugZyEgInNF5E/AYWAt8ETcsfNF5DURWZmpgSISAu4ELgLuUNVfZbpmKqhqn6p2uAPozMV1i41Dhw4xMOBEdPxOFpw4cWKsomBzc7Ovaw8l0/wAcP785eXlhMPhmJfEMIzipajrCETd9M8DbwH+BDzHsQ2IXsDpQPjBTIyLioCfAR/C2anwtyme6noCkj3x1w6ZZ2QJ94Y3ceLEtKvxjUQuiwr5IQTKysqYOXMmYOEBwygFit0j8HVgPHCxqr4Xp8BQDFUdBJ4CzvdqWFQE/Bz4KHA3cK2qRlI5V1W7cXIJ5olIooRFNzdgW4Jjho9kKz/AJVcJg34IAbCEQcMoJcIinkau8SoErgDuVdVnh5mzG5jpZfE4EfAR4LfAh1PICxjKGqCaxGLErR/wpBf7jNTJthAoJI8AWMKgYRjBw6sQmADUjzBHcJL70iIuHPAR4HfANcOJABGZJCInicikIYd+HH39pohUxM2/Cmdr4SOqujtd+4z0KAYh0NfXF7tx++URMCFgGMVPoYQGvBYU2s/wW+/AKfrjxf/5VZxwQBewFfjXBC0N/qiq66M/3wB8DSdccZM7QVWfEJGf4FQXfFlE7sfZUvgBoBWnlLGRZYohNFBfX4+qUl1dzdSpUzNay0IDhlE6RAgRSfN5O935fuBVCDwKfFhETlXVDUMPRrcSXgJ838Pac6OvNcCXk8ypB9YnORbPp3BqDnwS+CyOuLgX+LKq7vBgm5EmxeARcMMC8+fPJ9M+WxYaMIwSwkuBoALyCHwLeC/wpIj8B7AAYm7384DPAweB/0h3YVW9Frg2jfk3EecJGHIsgtNs6JZ07TD8IVt9BlxyKQQyDQuAeQQMo5Tw4uovmNCAqtaLyBXAb4Bv4vQUEOC+6Ose4L2qapulS5xsFRNyiS8q1N/f7/sWRTgqBBYsWJDxWq5HoKWlhSNHjlBVVZXxmoZhBBMvlQLzUVnQq0cAVX0h2sr3bcDZOAmEHTg1BP4U3+jHKF2yHRqYNGkSFRUV9Pf309zczNy5c32/hp8egfHjxzNmzBh6enpobGz0RVwYhmFkQkZZCao6qKr3quoXVfWTqvqPqvo7EwEGQGdnJ93d3UD2hEAuigr5KQREJOYVsPCAYRQ3Tmgg3cqCBVJHQETKol35Ep4fd9zv7oNGAeF6A2pqaqipqcnadbK5cyASibBz507AHyEAtoXQMEqFYm869DXgADAxyfEJOFsMk2X9GyVAtsMCLtn0CDQ3N9PX10d5eXnsST5TLGHQMEqDQqkj4FUIvBV4TFVbEh2Mfv4X4B1eDTMKn1wJgWw+YbthgTlz5lBe7jml5hhsC6FhlAZhxNPINV6FwHxgywhz3gDmeVzfKAKKwSPgZ36Ai4UGDKM0KBSPgNdHnFHASA2AFLC9USWMCYHEWLKgYZQGiqBpPuGnO98PvHoEtuNUDhyOS4BdHtc3ioBiCA1s374dyI5HYM+ePaiqb+sahmF4wasQ+ANwuoh8Y+jOgOiOgW8Cp+M0DTJKlFx7BNyiQn6SzdBAV1cX7e3tvq1rGEaw0LS3DobQxJvxsorX0MB/AX+Fsyvgr0TkCaAJp+3wKuBE4HXgP/0w0ihMciUE4osK7d27lzlz5vi2djaEwJgxY5g4cSKHDh2ioaGBcePG+UcHhRQAACAASURBVLZ2qXJ4J6y7DXY9AUdaoXw0TFgAZ3wMFr4FQraR2cgDRV1ZUFW7ROQi4FbgXUR7DUSJAPcAn1bVrsxNNFKitxcaGqCrC8aOhdmzoTLtLtC+ku0+Ay6hUIgTTjiBnTt30tDQ4JsQaG1tpa2tDXAaDvnJrFmzYkJg2bJlvq5dShx8Ax76LOx4BCQE8Q3LD26BN/4EY2fCRf8KZ34qL/1cjBKmUISAZx+Eqrao6nuBGThlhq/B2VY4Q1U/oKqHfLLRGI7Nm+GGG2DSJFi8GM48ExYtgilT4B/+AbZty4tZfX19HD58GMi+RwCykzDoegOmTZtGdXW1b+uCJQz6QcNz8JMVsPMvgB4rAuDo+84muP96ePBGsJQMI5cUe0GhGKq6X1XvV9Vfq+oDqnrAD8OMEejrg2uugVNOgdtvh56eY493dMDNNzui4NOfhsHBnJrnNhuqqKhgwoQJWb9eNoWAn2EBF9tCmBkH34D/uRL6u44XAMlY+0NY/bXs2mUY8YRFPI1ck/usBCNz+vvhqqvg7rud98lu8uHoN+Rtt8H73nf0fQ6IDwtIDv5jZ+PGmgshYB4Bbzz8eejvBh1pE/MQnvwWtO7Ijk2GUah4FgIiskREfiQia0Vkm4jsTDDsVy4b3HADrFkDkRS/BVXhT3+CL+eu4nOuEgVdCs0jYNUFvdNWD9sfTN0TEI+E4KXbfTfJMBKS7dCAiHwpeg/uFJEDIvJHEVmcrp1emw5dDLwE/C1wGk7hIEkwzOPgN42N8NOfpi4CXFTh+9+HaNw+25gQGB7zCHhn3e3ODd0LGoaXfgyDR/y1yTASESHkaaTBxcAPgXOAN+MU+3tERNJKavJ6o/7/cHYcfBwYraqzVHVeouFxfSMZd9zhPfW5vx9+8Qt/7UlCroVAoYUGXI9AY2MjkXRFXYmze83w3oAm1tJLcsHb1+7sKDCMbONWFkx3pLy+6pWqeqeqblbVV4FrgdnAmenY6VUInAb8RlV/purFQWd45vbbM4v133abf7YMQ748Avv27WNgYCDj9Xp7e2lqagJgwYIFI8xOnxkzZhAKhRgYGODAAcuvTYfeYZxa23mEO1jBn/nksGscafPZKMNIQIahgbEiUhs3UtkPXhd9bU3HTq9CoBunDbGRS44cgf37kx5+GcdFU59sgirsyk3V51wLgcmTJ1NRUYGq0tzcnPF6u6J/T7W1tUycmKzbtnfKy8tjfzcWHkiPUcN0MNnMbwHYxRMoyfcKlo/22yrDOB71IALiPAKNQHvc+NJw1xKREPB94BlV3ZSOnV6FwAPAhR7PNbwydItgHJuAy4CfAt8bbo3+/vTzCzyQayEQCoWYOXMm4E+eQHxYIFu7Hixh0BsTFoEkqBQYIcJW7gegl0N0kkQQCozzr/ikYSQlQ4/ACThP+O749giX+yFwCk7V37TwKgS+AIwTkVtEZIzHNYx0qa1N+PEu4HKIRUWfG26N6moIZT+HM9dCAPxNGMxmfoCLJQx6Y/nHEucI7OVlujnqMdvHq8fNkXJYcBXUZLfYpWH4QaeqdsSNvmQTReQHOAX9Vqlq2l+AXnsN/AboAj4DXCsiW4GOBPNUVS/1eA1jKOXlsHw5rF8fe6rfjyMC9gLzcETBK0AvcJz3s6wMzj0362aGw+FY3DuXQsDPhMFcCAHzCHhj/mUwbq6zjTCerdx3zPt9rGcRbznmMx2EFTdk1z7DcAkD4TQrBaaTASaOu/K/cUr9r1RVT7Ffr4+GK3G6CwpQAyyPfpZoGH5y440xEdAGXIHTE3ou8DQwFRjEyRc4jnDYOT/LtLS0EIlEEBEmT56c9eu5FKpHwIRAekgILk5QIdAVApNZAsD+IR6BUDlMOx0WXJF1Ew0DyP6uAZxwwDXAh4BOEZkWHWllwXgSAqoaSnFYzy+/+cAHoK6OHuDtwKs4N/9HcZo+nBOddlx4QASmT4err866iW5YYMqUKZSXe3U6pY+fQmD79u2AhQaCyunXwnlfOPq+k73s5SUAzuefgWNDA1LmhAM+9ID3GgSGkS456DVwPU7+wGocx7A7PpDOIvYrUWiMHs3A97/PB4CncP4HPMzR9o+u4//5ROfefrsTHsgy+cgPAP+esMPhMPX19YCFBoLMZd+BS7/t3Ni3yQMAzOAsTuRyAFrZxkDISbCdeip8/EUYm9v/kkaJE1bxNFJFVSXJuDMdO00IFBiRSIS/eewx7sMp5/hnnKIOLq4QeA6czVMizrjjDnjb23JiY76EgF8egYaGBgYGBhg1alRszWzgCpd9+/bR39+ftesUKyJwwRfhs/VwaJETFljEWxnLNKqZihKh8rxNXPMwfHKdiQAj9xRK90FPflsR+WqKU1VVv+nlGsbxqCqf//znueuuuygrK+Oef/onLvzf/4UdO5xEwsFBzgTKgGacTaizTjoJvvtduPLKnNmZbyGwd+/e2I3cC25+wLx58yjLogdl8uTJVFZW0tfXR1NTE/PmWSFOL1RN6WN946MA/Mtvr2bxTHjiH09jzfOPMPXD6znx8hV5ttAoVTzE/NOe7wdeA7g3jXBccRIJFTAh4BP/9m//xs033wzAnXfeydXXXAP/9m/w+ONw662wYQPVXV2c1trKy319PPf1rzPrK1/xXpLYI/kSAlOmTGHUqFEMDAywd+/emOs9XXKRKAggIsyaNYvt27fT0NBgQsAja9asobu7m+nTp3Ppe88gFIIVFzpC4NVXj99CaBjGsXgNDaxKMt4JfAOnCtI9wCU+2GgAt956K1/5ylcAuPnmm7nmmmucAyJw6aVwzz2wdSs0N3POxz4GwHOHD+dcBED+hIBfRYVyJQTAEgb94L77nLDA1VdfTShaI+O005yAmQkBI5/koOmQL3jyCKjqmmEO/5+I/A/ODrbfe7LKOIbf/OY3fOYznwHgq1/9Kn/3d3837Pxzzz2XH/3oRzz/fMKUwayTLyEATnigvr6+YISAJQxmhqoeIwRcTj/9dAA2bNhAJBKJCYSgMkCYzTSzmb10cQQFaqjkZKazjBlUeHbeGvlEVYikkfznnpNrsvK/S1W3ici9wBchWvzb8MRDDz3Ehz/8YVSVz3zmM9x0000jnnPOOc4mwpdffpm+vj4qK1PpVeEf+RQCfuwcMI9A4bBlyxZ27dpFRUUFl112WezzxYsXU1lZSWdnJ7t27crJv6UXBgmzmm2sYzf9DMbiqQAH6GQnB3mE11jObC5hMaOwHdmFRBjxUFAo90IgmzL5ALA4i+sXPc8++yzvec97GBwc5IMf/CC33HJLSnXvTzzxRCZNmkR/fz+vvPJKDiw9iqrm3SMA3kMDqmoegQLC9QasWrWKmpqa2Ofl5eUsXboUCG54oI8BfsULPMcO+hkESNgmaYAwL7KLO3mWHmx3SSGhKp5GrsmKEIi2S7wSp/idl/OvEZHbRWSdiPSJiIrItWmusTJ6XrKR1nq5ZuPGjVx99dX09PRw5ZVXcuedd6bs3hQRzo2WEn7uuWE7D/jO4cOHY1vhpk3LfUH3TD0CBw8epLOzEyAnyXtWXTAz7r/faTJ0dYJCWUHOEwgT4be8RCOHh+mReBQF9tHJ3axlMK0itEY+Kfbtgx8ZZr2ZON2PTgJu8WjXt4A5wEGcKkmZ9Apbg1N1aSjrM1gzq+zcuZMrrriCtrY2zjvvPO655x4qKirSWuOcc87hz3/+c87zBFxvwLhx46iqGqZfbJbI1CPgegNmzpzJ6NHZ71XregQsNJA+hw8f5umnnwYKTwhsopl6DqV1jqI00cbLNLCCudkxzChJvOYI3EliL5YrZRS4GydHwAsfB7ap6m4R+SIjt18cjtWqelMG5+eUffv2cfnll7N3715OOeUU7rvvPqqrq9NeJ18egX379gH5CQuAf0JgwYIFI8z0B9cj0NbWRmdnJ2PHjs3JdYuBhx9+mHA4zJIlS5g/f/5xx92EwSAKgRfZdUw+QLrnnsUcJA9PjkZ6pFsp0D0n13gVAtcl+TyC0w33JVXd63FtVPUvXs8tZNra2rjyyivZsWMH8+bN45FHHmH8+PGe1jrrrLMIhUI0NDTQ1NQU21aXbfKZHwBHb6x79+5lcHAw7V4HucwPABg7dix1dXW0t7fT0NDAkiVLcnLdYmC4sADAqaeeCkB9fT1tbW2MGzcuZ7YNRzPt7E3YrDU1WumhnkPMY5KPVhnZwIurPx+hAa9Nh36RZPxKVe/LRARkgYUi8jkR+ZKIfFhEcnNHTEQ4DD09oMc/B/T09PC2t72NV199lalTp/Loo49mdDOtqalh2bJlADkND+RbCLiNjiKRSMyWdMi1EABLGPRCOBzmgQec/gJvfetbE84ZP3587O92w4YNObNtJHZzaNiv+vbGg7TtPpD0eAhhD63+G2b4TkknCwaMDwHfA/4f8EugXkS+KyLD7sMRkUoRqXUH4M1nu3cvfPObMGuWUwa4uhoqKuDii50iQAMDDAwM8P73v5+nn36auro6Hn74YV9uRO42wlyGB/ItBDItKpQPIWAJg+nz/PPP09rayrhx4zjvvPOSzgtinsARBpK69Qf7B7hjxee5/czP0dfZM8wag9kyz/CRQkkWLGYh0IKTo3AKUIPTrfedwHbg74F/H+H8L+FUSHRHeneV/n64/npHANx0E8TflAYH4Zln4H3vIzJjBte9+c3cf//9jB49mvvuuy/25ZUpbp5AKXkEILMbaz49ApYwmDpuWODKK68cNvwTxDyB8mG+dvet30nn3lZ6DnXQvG67pzWM4BCJFhRKd+Saov3fpKqbVfU70dduVT2gqn/CKYXcAvydiEwZZolv43T5dUfqbej6+uCqq+DHP3bCAZHI8XPCYRT43MGD/M+aNZSXlXHPPfdwwQUXpP6HHAFXCKxbty5n3e2CIAS8Jgx2dXXFkh3NIxBs3PoBycICLq6oXr8+OJuExjGGSJI0wcbn3zj684tbE86JoNSR/R0tRuZEPLQgNiGQA1R1H/AnnETJs4eZ16eqHe4AOlO+yHXXwerViQVAHN8E/jv6853hMG/xudPdwoULmTBhAn19fTl7IipkIbBz507AiS17TdL0glUXTI89e/awceNGQqEQV47QVdMVAps2bWJwMBju9JOYRkWSCoHxQqApiRAoI8RSZmTFNqM0KTkhEOVg9DX9fXkjsX493H33iCLgh8DXoj/fAvx1KAT/+I8JEwm9IiI5zxMIghDw+oSdj7AAWLJgurhhgXPPPZeJEycOO3f+/PnU1NTQ19fH1q2Jb6y5ZhRlnMHshHkCjS8MLwRCCMuYwWi8tdg2cotytBVx6iP3lKoQcD0B9b6vfOutTlLgMNwN3Bj9+Wvuz5EIbNoEL7zgqzmuEMhFnkB3d3esKl8hegTyJQTihYv6KASLlVTDAuAkj7q7Z4KUJ7CCuZQNEQJdB9o4vNMJTYkIHY0H6dx77O4AAc7h+JoJRjCxHIEcISKTROQkEZk05PMzk8z/LE6ewDZgra/GdHXBL3/pJAMm4UHgIzhK8QaOegUAR0DcequvJuWysJDrDRgzZkxeC+MUmhCYOXMmIsKRI0c4ePDgyCeUMD09PTz++ONAakIAgpkwOJ4xvJ8zCcX5BZqi3oDJS2YzeanjJWpau+2Y897NGUzxuIHJyD3p5gd4KUDkBxl3HxSRamAcJA56qWragU8R+TjgZs0ti75+XERWRn9+WlV/Ev3ZvZ9+Hbgpbpnfi8gAsA4n478aOAc4A6cHwjWq6m/R7l274MiRpIefBd4DDAIfBG6GY58JBged0IKPrFixAhGhvr6effv2ZbX+f3xYIJXmSNnCfcJubm5Oq6hQvoRAZWUlU6dOZd++fTQ0NDB58uScXr+QePzxxzly5AizZ8+ONRUaiSAmDAIsYAp/zQr+l5foY5CGaH7ACec4vdoObNpN04tbOentZzOKMt7LchYyXH6zETQi6ox0z8k1nj0CIvIxEXkN6AD2ALsSjJ0el78A+Gh0LI9+dn7cZ6mk1t8KNAAX4XjfrwVGA98Hlqnqix5tS05n8nzCPuADQC9wFfALkvzld3ivOJaI2tra2BdmtsMDbsZ9PpoNxRNfVMi1KRXyJQTAEgZTJT4skKrYDGItAZd5TOJzXMJVLOXAC852wRPOWczMFYsA2P/idq5gCX/PpSYCCpBCKSjktenQ9Tj5boPAkzhP3L6l5KrqtTg37lTm3sSxngD38+8A3/HLppQYxh1eCfwOp6rRbyB5qk9tre9mnXvuuWzatInnnnuOd77znb6v7xKEREGAsrIyZs6cye7du2loaIiFCoZjYGCA3bt3A/kRArNnz2bt2rWWMDgMqhpLFEw1LACwbNkyRIR9+/Zx4MABpkwJ1g21klEsD8+i+UUnDHD92e8jEg5zHz9k/9odnBWZk3LnUcPwgtfQwOdwMu8vUNVgpOIGgXnzoKoqaXjgHOD/hju/vBzOOMN3s8455xzuuOOOrHsEgiIEwMkT2L17d8p5Anv27CEcDlNZWcmMGbnfmmUegZHZsGEDjY2NjB49mpUrV6Z8XnV1NQsXLmTr1q28+uqrvPnNb86ekR55/fXX6ezspLq6msuXnk8kEqGqqoq2tja2b9/OokWL8m2i4QEvyX+FlCw4B/hfEwFDqKmBj350xF0DSRkcdKoR+oybMLh27VoGBgZ8X98laEIAUk8YdMMC8+fPz8vTl20hHBk3LHDZZZel3SI6qHkCLq5IX7FiBWVlZYwaNYozog8FL77ofxTTyA3FXmJ4L0mSA0ue668fdtdAUkTg1FNhxQrfTVq8eDHjxo2jt7eXjRs3+r6+S5CEQLq1BPKZHwBWXTAV0tk2OJQg5wkAvBDdNuxu9wVHFEDhCIEm2rifjfyS5/kJz/BrXuRJttFF8gTqYqdQdg14FQK/AK6K7hgw4jntNPjQh8DLU+V//IcjCHwmFApx9tlO6YRsbiMMkhDw6hHItxCw0EBiWlpaYjfLt7zlLWmfH3Qh4HoE3N9TKBwh8Ab7+TFP8VOe4RUaqOcQzbSxnRbWsJXv8Rj38DKtdOfb1JxTKMmCXoXAt3D24D8qIheJSI2PNhU+P/sZrFqVmhgQccYdd8Dll2fNpFxUGDQh4B03NOBueTSO5cEHH0RVOf3001NK/hyKKwS2bNlCX1+f3+ZlREdHB5s3bwYSC4FXXnklZ71C0uVZdvBb1rEfZ7fT0B4KGh2vs4+f8DRNtOXeyDyiESGS5tBI4QiBPuDdOPlvTwDtIhJOMErzG62yEh54AD71KSdfIJEgcPsKTJ4M994LH/tYVk3KdifC/v7+WDGcIAgBr6GBBQsWZM2m4Zg6dSqjRo0iEonQ3NycFxuCTCZhAXCE4YQJExgcHOS1117z07SMWbt2LarK3Llzj9l6e+KJJzJ+/Hj6+/vZsGFDHi1MzEvs4S9sARixLK6i9DHIXbzAIbqyb1xAKPbQwFM42wbXRF+Tjad8sLEwqaiAH/0IGhrgG99w2hG7bv9Ro+CCC+Cee5z2xO94R9bNcZ80duzYwYEDB3xff//+/QCUl5ePWP89F7hPjXv37h3xCVtVYw2H8uURCIVCMZstT+BYBgYGePjhhwG4+uqrPa0hIoFNGEyUHwCOzUEND/TQz4NsSuscBfoJ8yCbs2OU4RlPQkBVV6rqqlSG3wYXHNOmwZe/DHv2OEmEvb1Om+LVq+E973FEQQ4YN24cJ598MnD0i8dP3LDAtGnTArHneerUqZSXlxMOh2MiJRn79++nu7ubUCjE3Llzc2NgAixhMDFPP/00HR0dTJ48mbPOOsvzOkHNE0iUH+ASVCGwngbUQ3scRdnJwZLJF7BeA8bxhEJOnYE8ld/NZt+BIOUHgFNUyK0HMNKNdft2p6LbrFmzqKioyLptybCEwcS4YYG3vOUtlGXQqjuIQkBVY0JgqEcAgikEFOVF6j13yROEdez21aagonhIFiyg7YNGAZLNToRBEwKQesJgvhMFXayWQGLcaoJewwIu8c2HgtLlcdeuXbS0tFBRURGrGxCP6wHZsmUL7e3tuTYvIW300jHMlsCBI/0c3NqU9LjrFSgFit4jICJlIvJBEfmpiDwoIo8nGI/5aayRGa5H4MUXX/Q9Mz0ofQbiKTQhYB6B49m2bRtvvPEG5eXlXJ7hrpqTTz6Z8vJyDh8+nHZnymzhhunOOOMMKisrjzs+depU5syZg6ry0ksv5dq8hBxh+KJkD372x/z34k+x49FXks7pHWGNYsFtOpTuyDWehEC0fsCTwF3AdcDlwMq4cXHcz0ZAOPnkkxk7dizd3d1s2pReos9IBNEjkGrMPShCwDwCx+N6Ay666CLq6uoyWquysjKWJxOUhMHh8gNc3PDA2rX+dk33Stkwt41IJMLrv38WgNf+8GzSeeUl4owOR8TTyDVe/zX+FTgXp/3vJJxuujcB03Ga7O3E6bFzvMQ18kZZWVnsC8fv8EAQhUChegRMCBzFr7CAS9DyBIbLD3AJWp7A2GG+1g9srKfnkFNToH514iqmAtSRXoloI7t4FQLvBp5X1W+paqv7oaruV9XfAauAy4Av+GCj4SPZShgMohBwb6yFIgRcj8DBgwfp6enJqy1BoKOjgzVr1gDe6wcMJT5PIN8cOXKEV15x3OeFJARGU8EipiIJktp2PXH05n9wSyNd+w8fN0eBM5iVTRMDQ7FXFpwNxD9SRoh7+lfVRuB+4KPeTTOyQbYSBoMoBFLZl9/R0RErhJRvIVBXV0dNjVOkMygx7Hzy6KOPMjAwwMKFC33rvhckj8D69esZGBhgypQpw25bXb58OaFQiMbGxsAUm1rB3ITbB3c9fuzfa/2a40OQVYziZIKTS5RNij1ZsBvn5u/SjhMWiGcfjmAwAoQbGti6dSuHDh3yZc1IJBLbqx9EIdDc3Ew4HE44x/UGTJo0idra2pzZlggRsYTBOPwOC8BRIbB9+3a6uvJb4S4+P0CG2VJcU1PD0qVLgeDkCcxjIlMZSyjOKxAJh9n9pFMsaPb5S4DEQuA85lNeIj3rIh7yAyIFlCOwm2Nv8puAS0SkEkCc/9WX4nQpNALExIkTY09XfhUWOnjwIIODg4gIU6dO9WVNP5g2bRplZWWEw+HYroahBCUs4GIJgw6RSCQmBPwKCwBMnjyZ6dOno6pZ7cSZCqnkB7gELTwgCB9kBWOoiImBva/s5Eh7N1V11ZzzubcDx+cJLGE65xOM37VcUOwegceAVSJSHn3/Cxxh8JyI/AfwNHA68PvMTTT8xu88ATcsMGnSJEblqFJiKsQXFUrmag+aELCEQYd169Zx4MABxo4dy4UXXujr2kEJDxSyEACopYqPcT4TcZrQumGBORctZd6qUwFoeW0PPQec+gdnMpt3c3rC3IJiRSPeRq7xKgTuAP4TmAygqj8DfgicBvwDzo6CP+DsJDACht95AkHMD3AZaedA0ISA6xEo9dCA6w24/PLLfa/2GISEwX379rF7925EJKWyye6ctWvXEonk4U6RhDpG80ku5L0sZ98TTgOieZecxpiJtUw9da4z6cm9fIILuJplhEpk26CLUxcgXY9A7u302mtgm6p+R1X3xn12IzANRwTMUNX3qaqlPgcQ1yPwwgsvJI2dp0OQhcBIT9hBEwLmEXDItNvgcATBI+CG5ZYuXcrYsWNHnH/KKadQVVVFe3s727Zty7Z5aVFGiIUDk9j5lBMGuGHVh/gAb+LKi98MQNfqXUwnsxoQRnbxVZ6paouqvqCqiQOyRiA45ZRTqK6uprOz05eWrEEWAoXmEbBkQSe58+WXX0ZEuOqqq3xf3xUCGzZsyNvTdTphAYBRo0axfPlyIFjhAZe1a9fS3d3NxIkTuWrZRSxmKm9feSVAbAtoKRKJJv+lO3JNaflpDMCJnbsxRz/CA24iXqEJgf7+/tiTd1CEQHyyYFDq4eeaBx54AHDc4dlIPl24cCFVVVV0d3fHhGCuSVcIQDDzBFyeeOIJAFauXBnrPnrRRRcBsGnTJlpaWvJmWz4Jq3gauSYlIeD2DRCRE+LepzKs10BA8TNhML4FcdAYztVeX19PJBJhzJgxgbHdFS7d3d0cPnx8MZZSIJthAYDy8nKWLVsG5Cc8EA6HY9sAi00IrFp1tPP8pEmTOOWUUwB48skn82JXvtGIeBq5JlWPwMroGDPkfSrDCCB+JgwWamggPiww3D7uXDJ69GgmT54MlGaewJEjR3j00UeB7AkByG+ewObNm+nu7mbs2LGcdNJJKZ/nCoH169fT19eXLfPSpq+vj2eeeQaASy655JhjK1euBEo3PBDBQ9OhPNiZkhBQ1ZCqlqnq1rj3qYzSqBpRgLhC4PXXX8/4ybMQhECiokLbt28HghMWcCnlhME1a9bQ09PDjBkzYtn92cAVAvloPuSK7xUrVlBWlvpX5Pz585kwYQL9/f1s2LAhW+alzfPPP8+RI0eYNm3accLm4osvBmD16tV5sCz/FHtBIaPAmTx5cuwGmImrUVUDLQSmT59OWVkZg4ODseqHLkFLFHQp5YRBNyxw9dVXZ9VLk0+PgJf8AHAqTwYxPPD4448DztP/0H8zN09g48aNsVLepYQlCxqBx488gY6ODnp7e4FgCoGysrKYXUPDA0EVAqVaXVBVs54f4HLqqU7Bm4aGBlpbW0eY7S9ehQAEryUxHM0PGBoWAJgyZUqsPPJTTz2VU7uM1CkfeQqIyEe8XkBVf+n1XCO7nHvuudx1110ZCQHXG1BbW8uYMWNGmJ0fZs2aRWNjI42NjbEvUgiuEChVj8Drr79OfX09lZWVXHrppVm9Vl1dHfPmzWPXrl1s2LAhFsvONm1tbbz++uvA0b4f6RA0j0BPT09M2MQnCsZz8cUXs3nzZlavXs273vWuXJqXd7x0E8xH98GUhABwJxzTakqGvE+EO8eEQEBxn0heeOEFIpFIbNtPOgQ5LOCSqAthJBJhNzntzwAAIABJREFU586dQPCEQKl6BFxvwKpVq6iurs769U477TR27drFq6++mjMh4D7Jz58/P5YUmg5uhcEtW7bQ3t5OXV1+C/U888wzDAwMcMIJJyT9PVq5ciU/+tGPSjJhMBIh7ey/fJS2SPWb/zrgb+LGdcADODf7x4GvA5+Ovj4R/fy+6FwjoJx66qmMHj2a9vZ2tmzZ4mmNQhIC8aGB5uZm+vr6KCsri914g0KpJgvmKizgko+EwUzCAkCsZbGq8tJLL/lpmifiwwLJcjrcPIENGzbkPAyTb4oqR0BVfxE/cNoOvxm4QlXfrKrfUNXbo6+XAVcClwOluRG6QCgvL489YXjdRlgIQiDRjdUNC8yZMydQjZLgqL2NjY2+lIAuBFpbW3n22WcBf9sOD0c+EgYzFQIQrPBAovoBQ5k6dSonn3wyqlpy9QTS3THgjlzjNVnwX4D/VdVHEx1U1UeA3wH/6tUwIzdkmjBYCEIgkUcgqPkBMPxOh2Ll4YcfJhwOs3TpUubOnZuTa7rbEzdv3szAwEDWr6eqsR4DXvIDXIIiBDo7O2OhjuGEAJRuPYGi8ggkYCkwkt+yITrPCDCZFhYyIeA/5eXlsfbJpZIwmOuwAMDcuXOpra2lv7+fN954I+vX27FjB4cOHaKysjKjGglBEQJPPfUU4XCY+fPnM2fOnGHnlno9gaDjVQh0AheNMOei6DwjwLgegc2bN9Pe3p72+UHuM+DiutqbmppirvYgCwEorYTBwcFBHnroISB3YQFw9uW72whzkSfgiu3ly5dn1Fp5+fLlhEIhmpqaaGpq8su8tHHrB4zkDYCjQuDVV18tqdLZGvE2co1XIfBH4DwRuVVEpsQfEJEpInIbTjvie70sLiLXiMjtIrJORPpEREXkWg/rhETkRhHZKCK9ItIiIneLyHwvdhUjU6dOZd68eaiqpyeMIPcZcJk2bRqhUIjBwUEOHDgABF8IlFLC4PPPP09rayvjx4+PCdNckcs8AT/yAwCqq6tjNfzzWU9guPoBQ5k2bRqLFy9GVUuqnkBRNR1KwJeAzcCngN3RG+1jIrIR2A18Mnr8Sx7X/1Z0jTnAXo9rANwO3IKzi+EW4CHg3cBaEVmYwbpFRSbhgUIIDZSXlx9XVKhQhEAphAbcsMBVV11FeXmqO5r9IZdCwI/8AJd8hwcOHz7MK6+8AqTmEYCjeQKlFB5QTT8/IB91BDwJAVU9DJwNfANoxskFWBV9bY5+fo6qtnm06+PAXFWdDNzmZQERWRVd50lguar+s6p+GHgnMAH4gUfbig6vCYO9vb20tTn/xEEWAnDsE/bhw4dj7sn584PpHCql0MD9998P5DYs4OLG6rMtBHp7e2Phh0w9ApB/IbBmzRpUlcWLF6f8u1+KCYORiLeRazzLb1XtBW4CbhKRsUAt0KGqGecFqOpfMl0D+ET09Suq2h+39oMishq4XERmq2rxP3KNQLxHQFVTrvHu5gdUVlYybty4rNnnB/EJg643YOrUqdTU1OTTrKSUikegvr6eTZs2EQqFuPLKK3N+/VNOOYVQKMSBAwfYt29f1kJcL7/8MoODg0ybNs2XuhXutt+1a9d6LgaWCemEBVzcPIFXXnmFtra2wH9n+IFGBNLcBRDkNsTDoqqdqtrkhwjwkZVAN/BMgmMPR18vzpk1Aea0006jqqqKw4cPs3Xr1pTPiw8LBKWNbzISCYGghgWgdDwCrjfg/PPPZ8KECTm//ujRo1m0aBGQ3YTB+PwAP35Xli5dyujRo+no6Ejrd9YvUqkfMJTp06ezaNEiVJWnn346W6YFimLfPgiAiJwhIv8uIv8nIn+J+3yOiLxfRHL/m+1cvxqYDuxS1UQVWbZFX5PmCYhIpYjUugMYmwVTA0FFRQVnnnkmkF6eQCHkB7jEhwYKQQi49u7fvz9Qvef9Jp9hAZdc5An4mR8AMGrUKJYvXw7kPjzQ0tLCxo0bAdIuzWzbCIOJZyEgIv8OrAP+EXgrTo5A7DDwa+DDGVnnHbcAd7L9cB1D5iXiS9Hz3dE4zNyCx0ueQCEJgULzCEycOJHRo0cDx3dNLBa6u7tjW9ByWT9gKLnIE/Brx0A8+epE6N7Ely1blna/hFJLGAxHvI1c40kIiMh1OALgPuBU4Nvxx1W1HngReHuG9uWTb+MIBXeckF9zsosrBIrdI9DY2Mj27dsBWLBgQT5NGhYRKfothI899hh9fX3MmTOHJUuW5M2ObHsEmpqaaGhoIBQK8aY3vcm3dfOVMJhO/YChxOcJeKlbUmgUe2jg08DrwHtUdRPQn2DOFoZxvWcZ939Ysif+2iHzjkNV+1S1wx0UeXEk90ll48aNdHam9kctJCHgegSamprYts2JDAXZIwDFnzDohgXe+ta35jXHxBUCW7Zsobe31/f13bDAsmXLfE1OdYXA+vXrcxo+8pIo6DJz5kwWLFhAJBIpiTwBDYunkWu8CoElwKOqOjjMnP3AlGGOZw1V7capPzBPRMoSTHEFyrYEx0qSGTNmMHv2bCKRSMquxoIQAqrwzDNM/8IXCAEDAwMxu0+87TaIxjqDSLElDCrKEQZop5ce7ctLWeFETJ8+nUmTJhGJRNi8ebPv6/udH+Ayb948Jk6cSH9/Pxs2bPB17WQ0NzfzxhtvICKxroLpUkrbCIs6NAAMAiPVyJwBdHlc3w/WANXA+QmOXRF9La1WWCOQbmGhwAuB11+H006DCy6g/Pe/J97KscCku+6CU0+FlSthbyZ1q7JDsYQGeujnGXZwM4/z7zzCzTzOP6y/nebmZqrGjGb5Sn9vkOkiIlkND2QjPwAcu3MdHnC9AWeccQbjx4/3tEYpJQwWe2hgI3BJkqdtRGQMcBmQ9YbZIjJJRE6S/7+9846Tqrz+//vszNKWKiAdliJVkSIrFop+LbGl+U2M/lDRYIvEhrEmURO+akwRoyhRY4glsSSxN6KCICC9qYAgRelNWGCXZcvz++O5dxmG6Tsz987ueb9ez+vu3jbnzuzOPfeczzmPSKuwTU86y9+KSL2Q/c/BlhZOMcasz7R9uUSygkG3j4Av2wvPnw8nnghffGF/r6g4TOTRHRB3it+ZM+GEE2DduiwbGRs3IpCrqQGDYTqr+BMf8BErKOZA9bYv37ZRp8Iz+jOpwSze5TOq8OBRyCFTgsGKiorqCFu6HQHIvk6gJmkBF9cRWLBgAcXFxXH2VrJBqo7AM0BPYJKI1A/d4JTaTQbaAk+lcnIRGSMik0VkMvAjZ3X1OhEZE7L7WKxeYWzoOYwxU4GnsZMfLRSR34nIs9h5EnYBP0/FttpMeGOhWIT27fddRGDDBjj7bCgpgcpD1aPhjkA1FRWwbRucdRYkqI/IBrkcETAY3uUzpvElVRjC/5q+fMveHI8532mMw3peZoFnzkCmIgLLli2jtLSUZs2a0atXr7SeG7xzBFIRCrp06tSJ7t27U1VVxcyZkdq81B6MSb6rYJyv3oyQaovhZ4AXgZ8C250lIjIX2Aj8L/B3Y8y/UrTrVOByZwxy1p0Ssu7UBM9zDXCj8/ONwLnYiZCKjDHZ78LhcwYOHEi9evXYsWNHdYldNLZt24Yxhry8vKRLiDLOH/8Ie/Yc5gQAdAr5+QiZYEUFrF4Nkydn2LjEyWWx4KesZT6R7d63bTcb59p/v57nHlLRf8k2prA8K/aFE+oIxHOCk8HVBxQVFWWk+5/bYXDFihUZV+GvX7+eNWvWEAgEGDZsWI3OVWfSA1WCJDmS7USYDlL+yzTGXIK90a4FOmB7B5wAfA1cZ4y5sgbnHm2MkRhjdMi+9zrr7o1wnipjzJ+NMccaYxoYY1oZY35ijIl9l6uj1K9fP+HGQq4+oE2bNgQCETNE3rB/Pzz99BFOAMSICITy5z9745JHwHUEiouLc6rUqpxKPia6n7363QUYY2g3sDtNOxye0ZvHOvaGpBCyRe/evcnPz2fPnj2sX5++jGGm9AEurVu3pmvXrgDMnz8/I6/h4kYDhgwZQpMmNeuvVlcEg4FKCFRKkiP7dtbIRTXGPGWMOR5ojP2ebWqM6WeM+UtarFOyjvuFFU8n4Fuh4Msvw77IGtW4joAxNiow3R8a0saNG1cLsnIpPfAZmzhI9G+zlW/ZMHZPJy0QzsIokYRMUq9ePfr16wekNz2QaUcAspceqEn/gHDciMD8+fMTLlfORfKqUhtZtzMdJzHGlBpjNhljvKwSUNJAooJB3zoCy5ZBfn7ETTFTAy4iviopzMUSwvmsJ1pws+JgOV+9vxCAnucd6QgY5/gjVQWZJ906gW+//ZaVK1cC6S8dDCUbjoAxJi36AJfOnTvTtWtXKisra7VOIK9KUhpZtzPrr6j4GvfJZenSpezfvz/qfr51BPbtixra74rNXxVwuFNwGIGACgZryA72Rb2Nf/3JF5TtLaWgdTPaD4ncb2w/B2NGFDJFuh0B98bco0cPWrZsmZZzRiIbjsBXX33Fhg0byM/P55RTIlVkJ09dSA9IZWoj2yTsCIjImhSG5uJzjE6dOtGhQwcqKytj5hx96wg0bmyf6iPQDvgntmwkqqqhshJqmP9MJ7koGKyIofz/9JE3AJsWiCWeO0isXmWZwXUE0jULYTbSAmBFvoFAgE2bNrFx48aMvIabFhg6dCiNGjVKyznrjGAwB0gmIlCIfZBql8Ron0ZblSyRSGMh3zoCxx0H5eVRN1+EbXARFWPsOXxCLqYG6kVxs1ZPWcjKN+aQFwxwyi8ujHmOBkRO72QS1xFYs2ZNWurbs+UIFBQUcOyxxwKZiwqko39AOKE6gX1RdD25TqBKUhrZJpXUwDTgMqwwsGG8kV5zlWyQiE7At47ARRfZqEAqiECPHpBi69RMkIsRgXY0O0IjUFlewXs3Pw1A0djzad0nanKGFjQi6EHWsmXLltVzUiyroU7EGFNdOphpRwAymx5Itz7ApbCwkC5dulBRUcGsWbPSdl4/URvFgn2BR4AB2B4Cm0TkYRHxz+OTkhZCZyKMVlPtW0egUSMYM8bm+lPhhhuipha8IBcjAkUUHqERmDfpXbZ/8TWNWjZl5K8vjnu8RJUbZpZ06QRWrVrFt99+S4MGDejfv386TItJJqckXr58OVu3bqVBgwZpd2pq+7TEeVVCXmWSw88RAWPMCmPMrdgqrAuB2cD1wGIRmS8i14lItNn+lBxi0KBB5Ofns3XrVtZFaLtrjKluL+w7RwBg3Dho3jw5ZyAYtNGA0aMzZlYqhE6fXFXlXQveZOjJ0RSETEVSsrOYafe8AMDp40fRsEX0iE2API73cMbvdOkE3LTA4MGDyY9SxZJO3MZC8+bNS/vfiRsNOOWUU6hfv36cvZOjtgsGk20mVN1UKMskHX8zxlQaY14zxnwXqxm4CyvEnoiNEjwvIp3TbKeSRRo0aMDAgQOByOmBXbt2Ue7k4du0aZNV2xKiY0d4/30oKEjMGQgGoU0b+O9/fSUUBDttq4hQVlbG9u3bvTYnIfLI4zv0q/596j0vUPrtPtr0L2TwVWfHOBJOp5cn+gCXdEUEsqUPcOnXrx8NGzakuLiYL79Mb9PUTKQFXFydwNy5c2NWKeUqeZVuU6HER56fqwYiYYzZaoz5nTGmD3Amtof/xdj0gZLDxBIMummBo446Ku1PCGlj8GCYMwecJjEEg0fu464bNsxOUtSlS/bsS5D8/PzqqEsupQf60Z6z6cvWz9Yx74l3AThnwtXkxXDMTqIbQ+maLRMj4k4+tGzZMiojdKdMlGw7AsFgsLoraDp1AlVVVRl1BAoLC+ncuTMVFRUJT3ampJ8aK3JEZIiIPAH8C9tqeBOwoabnVbwllmDQt/qAcHr3hsWLYfZs+MlPrH7ApVkzuPpq2zzoo4/AjzMoOuSiYBCgyBSy8KYXMVVV9PnhyXQ77fjDtrsB0Abkcw79OJM+nmkDXLp3706jRo0oLS1l9erVKZ2jpKSEpUuXApltJBROJgSDy5YtY9euXRQUFFSnH9KJiNTqMsJa3VDImfr3ZhFZCnwKXAl8CJwHdDHGLEyjjYoHuE8yixcvprS09LBtOeMIgBX+DR0Kzz1n5yEoK7Plhbt3w8SJ4JRd+ZlcFAwCvPHGG3z64SfUr1+fP//+YbrSkobkEyCPBuTTkRb8kAHcwv8whEKvzQUgEAhwnFM+mmp6YMGCBVRWVtK+ffvqKoRskAlHwO0fMGzYsIxpHWqzYDCvMrWRbSLESyMjInnY2fuuxN7w84HPgHHA88aYHRmxUPGELl260LZtW7Zs2cKCBQs49dRDEz7mlCMQTr168ffxGbnYXbCsrIxbbrkFgHHjxnFGtyKPLUqc448/njlz5rB48WJ+/OMfJ318aFpAsliB4joCixcvpqysLC1pu0z0DwjHdQTmzp1LSUlJ2hoW+YFUxH9+FwtuAF4HRgJ/xU7l298YM0GdgNqHiBxWRhhKTjsCOUgupgYmTJjAmjVraNeuHXfeeafX5iRFTQWD2dYHuBQWFtKqVSvKy8vT0ia5oqKiWs2fCX2AS9euXenYsSPl5eW1TieQrFDQHdkmGUegLVABLMF2GfyNiLwTZ7ydCaOV7BBtJkJ1BLJLrqUGtmzZwvjx4wF48MEHaZxqgyePcAWDqd5M3UZC2dQHgHXe05keWLRoEcXFxTRr1qy6iigTiEitLSPMMyk0FPJgFvSEUwMO+cCIJPb3x8TuSkqECgaNMdVhTnUEskuuRQTuuusu9u3bR1FREaNGjfLanKRxNQIbN25kx44dtGrVKuFjN2zYwMaNGwkEAtUq/mxSVFTEO++8kxZHwE0LjBgxgkCqDboSZMSIETz//PO1TifgNglKimT3TwPJRAS6pjC6pdNYJbsMHjyYYDDI5s2bD3saVUcgu7gRgc2bN1f3b/Ar8+fP529/+xsAjzzySMyJhfxKkyZN6N7dTlSdbFTATQv079+fgoKCtNsWj3RGBDJZNhiOGxGYM2fOEeJkJfMk01lwfSojk8YrmaVRo0bV+dLQ9IA6AtmldevW1KtXD2MMmzZt8tqcqBhjuPHGGwEYNWpU1nPk6SRVnYBX+gAXt8Rv5cqV7N69O+XzlJeXM2PGDCA7jkD37t3p0KEDBw8ejDnZWa4hVamNbJN77rqSVcIbC+3du7e6A5g6AtkhLy8vJ9IDL774IrNmzaJRo0Y8+OCDXptTI1LVCXilD3Bp1aoV3brZQGysacTjMW/ePPbv30/Lli2rUyWZpLb2EwhUSkoj26gjoMQkvLGQO8dA48aNc04Elsv4vYRw//793HbbbYDVCHTo0MFji2pGKhGB8vLy6puvl9GQdKQH3P4BI0eOzFp6pzYKBiWFHgLi86oBpQ7ifqEtWrSIsrKy6rRAWx934quN+D0i8NBDD7Fhwwa6dOlS3T8gl3EdgS+++IKDBw8mdMzSpUs5cOAALVq04JhjjsmkeTFJx0yE2dQHuLiOwKeffsqBAwey9rqZpFZ3FlTqDt26daN169YcPHiQhQsXqj7AI/xcQvj111/z0EMPAfCHP/yBhg0bemxRzencuTPNmzenvLyc5cuXJ3SMmz478cQTPRVJ1jQicODAAWbNmgVktpFQOD169KBdu3aUlZXVGp2AVKY2so06AkpMwhsLqSPgDX5ODdx2220cOHCAESNGcOGFF3ptTloQkaTTA17rA1wGDhxIIBBg06ZNbNy4Menj3Sfytm3b0rt37wxYGJna2E8gUJWCRkAjAoofCW0spI6AN7gRAb+lBmbMmMFLL71EXl4eEyZMyGpL3UyTrCPgdcWAS6NGjaoFfqlEBULTAtn+PGujYDAXUEdAictJLVsCMPvVV9n86KMAtJsyBd5+G2owVauSOH6MCFRWVlaXC44ZM6ZaaV9bSMYR2LlzJ6tWrQIOhea9pCbpAS/0AS61TSeQK5MOqSOgRGf2bCgq4oRrriEP2FBRwXyn2Ue7FSvg/POhsBAmT/bSyjqB6wjs2rWrunzTayZPnsyiRYto1qxZdUvh2oTrCCxevBhjYjdJddMCvXr14qijjsq4bfFw+wkk6wiUlJRURza8cAR69uxJ27ZtOXDgQFpnUfSKpNsLOyPrdmb/JZWc4PXXYcQIWLCAxkB/Z7Urm2rnfjFu2ABXXAF33w1xviyV1GnWrBlNmzYF/BEV2LNnD3fddRcA99xzD61bt/bYovTTr18/AoEAO3fujNvIyS/6AJfQyoGqqsTvLDNnzqS8vJxOnTpVd1fMJrWtn4BUSkoj26gjoBzJzJnwox9BRQU4XyLhWc8jFAL33w8TJmTDujpLJ2du+69nz4adOz11vMaPH8+2bdvo2bMn119/vWd2ZJIGDRpUi+XipQf8og9w6du3L40aNWLv3r2sXLky4ePc/gFe6ANcapNgsDbOPqjUBYyBn/3M5v5DbjQnhe0WUSp4++2wQ2ekTjvz58MVV9DZKWP75soroVUr6NcPJk2CvXuzas6qVat45JFHAHj44YepV69eVl8/mySiE6iqqqqOCPjFEQgGg9WTHiUTYvdSH+DiRgRmzZpFWVmZZ3akA9UIKLnJ3LmwdGl1JMAl1BGoB0TMglZWwjPPZNC4OsbOnXD66TBkCDz/PJ0cx6w6MbBihXXa2raFF17Imlnjxo2jvLycc845h3PPPTdrr+sFiTgCK1euZM+ePTRs2DAr7XgTJVnBYHFxcXVnRC8dgd69e3P00Udz4MCBGjVFUhJHHQHlcCZOhOCRs1P3AFo6P7cFIgYNq6rg0UePcCKUFNi+HU48EaZPt79XVNDJ2VRdQGiMHSUlMGqU/ewyzPvvv8+bb75JMBjkT3/6U8Zfz2tCBYPRcKMBJ5xwAsEI/ztekawjMGPGDCorK+nWrRtdunTJpGkxCe0nkOs6AamS6qmIEx2ifQQUz5k+3WoDwhAO6QRidhDYsAG2bs2AYXWIykpbkbFu3WHlmZ2dZVSp4M9/Du++mzGzysvLufnmmwEYO3ZsVpvNeIVbErlq1SpKSkoi7uM3fYCL6wgsWbIkoVI8Ny2QzW6C0agtgkGdfVDJTYqLo25y0wNxp5PZsydd1tRN3n/fpmjCejQcEREIRwR+9auMmTVp0iSWL19Oq1at+PWvf52x1/ETbdq0oU2bNlRVVfHZZ59F3MevjkCXLl1o3bo15eXlCfVC8IM+wMWNCMyaNSvhuR78iIoFldykQYOom64GrgRui3eOWtBr3lMeewwCgSNWh0YEItYLVFXBggV2pJkdO3ZU3/zHjx9PixYt0v4afiWWTmDfvn0sW7YM8J8jICIJpwd27drFokWLAH84An369KF169aUlpbmtE4g2bSAO7JuZ9ZfMUFEZIiIvCMiu0Vkv4h8KiI/TuL40SJiYoyRGTQ/d+nZE6JMmNIa+CsQs1K6QQNo0yYDhtURNmyA996L2LGxo7MsBXZFOz4YhKefTrtZ99xzD7t376Z///6MGTMm7ef3M7EcgQULFlBVVUXHjh1p3759tk2LS6KOwPTp0zHG0Lt3b1+0Dw/tJ5DLZYRaNVADROQ0YCZwKvAyMAmrUXtJRMYlebrXgfsijHXpsrdWcfXVqYv9gkG4/PKYUQUlDqtXR+0PUB842vn5XSDip1RRAQnOlpcoy5YtY9KkSQBMmDCBQIRoRW0mlmDQr2kBl0SnJPZTWsClNggGc8UR8I/E1UFEgsBT2O+54caYxc763wBzgftF5F/GmPUJnvI1Y8zkjBhbG7nwQhg7Fr79NvljKyrguuvSb1NdIoogzaUXsA24FLjLWV4KHCbbS7WvwPbtsGaNtaFpU+jVC1NQwE033URVVRUXXnihr24U2cIVDC5dupSqqqrDphj2uyPgthpeuXIlu3fvpnnz5hH3C20k5BfciIDb7TA/P99ji2ovfowInA50B/7hOgEAxpg9wP3YMvbLPbKt9lO/Pvzyl8kfFwhYpbvz9KSkiNNGOBrPYLUazbBagfuBPth0zURgJ0Ay+XtjYNo020myXTsYOtT2LjjhBDj6aF4/91w++ugj6tevz+9///tUrijn6dWrF/Xr12fv3r2sW7euer0xxveOQMuWLatbBbs9AsLZtm1btRDSfQr3A3379qVVq1aUlJREtd3vqEYgdUY6yykRtr3vLEckcb6BIjJORG4XkYtEpGX8Q+o4N98MV12V+P6BABx7LPzjH5mzqa7Qrx/E6NTXA/gLsAWbMzsfCGBDZWOxpZ0//OYbXnvttfhq62+/tTf9006D1147QpdQVlrKuPfeA2Bc37507dQp0llqPcFgkH79+gGH6wS++eYbtmzZQjAYZNCgQV6ZF5d4OgE39H7cccf5as6IvLw8hg8fDuRueiCvKoXUgJYPAnCMs1wVvsEYswXYF7JPItwA/AF4EHgR+EZEbo93kIjUF5Gm7gCaJPGauY2IbV17993252g5Ybd5yllnwYwZ0KTuvEUZo0ULuOSSiE2dQmkA/Ah4E9gEPAwMBMqBV7/8kh/84Ae0b9+esWPHMm/evCNnz9uzB0491X5uELF3xARgDda5uHPRIrjoojo77XQknYAbDTj++ONp6ONKmXiOgB/1AS65Pu9ArmgE/OgINHOW0YrRi0P2icVa4OdAT6ARVnR9GVZw/aCI/DzO8Xc6NrhjQwKvWXvIy4Px421TmzvugPCpVevVs93s5s6Fd95RJyCdjB0b8cYcjaOBm4CFgQBLhw/nF7/4Be3atWPnzp1MnDiRoqIi+vbtywMPPHBo5sKLL4aVK6Pe2DcD7sTCvwMaA7z6KvzmNylfVi7j6gRCIwJ+Twu4uI7AnDlzIk6n7KdGQuG4jsAnn3xCeXm5t8akgKTgBIgHjoDEm2c724jIFOBM4BhjzOoI2zcCjY0xiTgDkc7fD5gPlABtjDERv3FFpD5WqO3SBNiwZ8+e6ulg6xQHD8LXX9snyYIC6NBBb/6Z5Ior4O9/T3yGwbw8279hzhzo14/KykpRs+TXAAAbhUlEQVQ++OADnn32WV599VVKS0sBW5Z1elERl82Zww9xbvCRXh6YDBQBswl5YigosJ0jCwpSv7Yc5OOPP2bkyJEUFhaydu1aAE4++WRmz57Nc889x6hRozy2MDqlpaU0adKEyspKvvnmGzp27Fi9bdOmTXTo0AERYefOnb7rD1FVVUXr1q3ZtWsXs2fPTpvTVVxcTLNmzQCaGWOid1FLESeKvOfs83aRn5/c/aK8vJj33z4qY7ZFwo8RATcSEO1G35To0YK4GGM+Bz7BzpvTJ8Z+ZcaYYncA2Z3izW/Uqwc9esDgwdC7tzoBmeYvf4HzzrOpmXgEAlbk+eabVmMABAIBzj77bF544QW2bNnCM888w4gRIzDG8OGcOVwOtMGGyD4EQh9C5mGdAIBHCPuSKCmpk1qQ/v37A7Bu3Tr27NnDwYMHWbhwIQAnnhizs4bnNGzYsNr+8PSAGw0YNGiQ75wAsDqB2tBPwO/40RFwtQFH6ABEpC32IeYI/UCSuHPl1q3HGiV3qFfPCvjuuss+fYsc6RS4OoJBg2DmTCv6i0DTpk254oormDZtGmtXruS3wSDHYENizwFnAIXYXNgXwI3OcZdyaH6Jw3jyyRpeXO7RokULOne2vR2XLl3KkiVLKCsr46ijjqJHjx4eWxefaDoBP+sDXHJ53gHVCKSO6/adFWHb2WH7JI2IBIATnF8T7UWgKNknELA6jS1b4IknbDSmdWtbYtipE1x2mW0nPHcuDByY0CkLGzfmlxUVrARmAdcCzbECmAeBfthUQAHwQKQTGANOaLxOsX49x9e3mcLF553Hp2fZr6eh7doh+/Z5aVlCuP0Ewh0BP/YPCCdUJ1CRhHbGD6gjkDofYsXKl4jIAHeliDTD9lA5CDwbsr6diPR2thOyfnD4iR0n4EFsFdZUY8zmzFyCoqSRxo3hmmtg3jzYts3qNL7+Gv76VxsNSAZnFjrBTiL1BLYU8V/ABRzqMPZLYkwuVVaW9CXkLBs2wHe/C127MmC1lSwt2buXT3fvBmDo55/bltrjxlkdjU9xIwLz58+n0hGIrlu3jrVr1xIIBBg2bJiX5sXkuOOOo0WLFuzbt686HZMraPlgijjivTFY26aLyJMi8kdgCbYC4C5jzLqQQx4AlgM/CDvVfBFZIiLPiciDIvIkNvJ5K/YBqG41TFcUgAid5eoDFwJvYEsRpwMx62vrilh2xQrbWOndd8EYjneEm0uAOc4uJwKUlsKECXDmmbB/v0fGxqZv374UFBSwd+9eVq5cCRxKCwwZMoQmPtb85HI/AW0oVAOMMVOx8wzMBC4CrgO2Aj8xxvwxwdP8ESvwOxO4BbgEO1/LeKC/MWZNuu1WFN/TogX06hVVhNgaGIaNGEQkGLRNiGo7W7fCGWfAjh3VpZxuz8wlwFfOz0Xu/lVV8MknttdCqnN1ZJBAIMDgwTZIOvett2D5cqa+8w7g77SAS672E8iV1IDv5hpwMcbMBc5JYL/RwOgI629Nv1WKkuOIwA032F4FqVBRkfqxucQDD1htRkifhW5YpbKrCOiD1VdUU1UFb79t+2qcf37WTI2L00a6aPNmpgNzb7+dy2+/nanO5tNLSmDfPpuC8imuYHDGjBlUVFQQjNNwyy/kVUJekg/4qhFQFCXzjBqV2gyReXlw3HFQVBR/31xm/36rvwhrtpQH9A/5PWJFRSAAjz2WQeOSZMMGqyM5/XSKvrJxjLnAamx+NB84+ZFHoG1b+Pe/PTQ0Nv3796d58+bs3buXRYsWeW1OrUMdAUWpazRtCo8/ntwxIpCfD089lVhvg1zmxRftE3IEQqfUitg9oLISpkyBr76KtDW7rF9vNQ7OhEJFTspiKfCes8tJ2LarlJTYiaf+9jcPDI1PIBBg+KmnAvDx3XfDL34B991nu136uOOgpgYURfEvo0fDrl1W7S4Su4NhIGCdgP/8B3zePCctzJ5ttRARStVCHYGoPe6MsSWdzqx/nnDggJ0DZOfO6uvojG1HvQ3bKAqgWh3gfv5jxli7HXGeL9i+HSZOZMTUqbwBTPvgA26dNs3aXFEBRx8NP/sZXH89tGrltbWHISmkBrxoMawRAUWpq9xyi21a1MdpsBmed3V/Hz7cCuHOiSvZqR3s2RN1Dga3W0NjbM+FmOfwkldegS+/PMyZEQ6JG914xREyQRF/zSfx+ecwYACMH89IpyJjhjFUlpcfurZt2+C3v7X7LV/uobFHkleVQtVAVfYjbhoRUJS6zPe+Z+vkZ8+2HQM//9yGxZs3h6FD4dprbZVBXaJRI6uHiOAMDAHux9Yxx/zybNQoM7YlyqOP2msIq2AoAt5yfm5AhKhGZSV8+KF1Inr2zLydsVizxjqhjmN2PLbv/B5gMXBYo5jKSivuHD7c9tsoLPTA4CPJq0z+aVtTA4qiZB8ROPlkOxQ7p0YUBNuKuSbnyDiffWZvhhEIlXmewuGzqlUTDFqx5O9+lwHjkuCii6C4uNohC2BLW98CphHmCIDdb/du+MlPwJkZ0mtyxRHQ1ICiKEooo0en3gtAxD5Jn3RSWk1KilXRp2IZEvJz1O4BlZWw+oiJX7PL3Lkwf/4ROo2RzjJqN4GKCjsDZ451IPQadQQURVFC6dQJLrjAiiRT4YYbvK2sKCmJuukoYAA2shFV8WFM1KqJrPH440dqVoARznI6h8+YeRjBYPJVMRkiV6oG1BFQFEUJ5+67k7+ZBwLQoQNcemlmbEqUOC2gX8XeSKPOUpGXF7EVdVZ55ZWIVRsDODQP/dJox1ZUwMsvZ862JFBHQFEUJVcpKoJnn408/XMkgkF7A54yxfu5GAYPtjfzKBRi+7fHxMumUWVlUaMaQQ7ZPi3WOfbu9UV/AXUEFEVRcpmLL4bXX4eCgugOgZs+6NrV5rXdUkwvad/eVoOk2oY3GIQrrkivTWlkpLOMOxm2Dxpf5VVCXkWSQx0BRVEUH3HBBbB5M0yadORNXsQ27Xn7bVu/7mWlQDhjx0YMrcclGIRLLoGjjkq/TYlSv37M8sufAjuAP8c6R9OmqTtCaSRXZh/0/p1SFEXxM40bw9VXw1VXwaZNtiNjfr7taOflDTMWp50GF15oW/AmWgERCNgb6D33ZNa2RPjxj+H55yM6M3Hf8WDQHu8DpBLyYjTtjHiMB5NXakRAURQlEUSsGPC446B3b/86AWBtff55O2V0IiFy1wmYMsUfzXiuvz61iAbY466/Pr321HLUEVAURamNNGhgp0S+9VZo2DCyziG0jfScOVZo6AdOOAGGDEk+vB8M2h4OAwZkxq4kUbGgoiiK4i35+fDQQ7B1K0ycaG/07dpBy5ZW03D99bBiBXz0ERxzjNfWHs5LL0GzZon3cwgGoUULO3ukT8gVR0A1AoqiKLWdJk3guuvsyBW6doUZM+DMM61gM5bWIS/POjj//S907pw9G+OQl4JGIE81AoqiKIri0KcPLFkC990HbdvadcGgjXS4aYN27eyMiYsW+W6CrLyqFCICHjgCGhFQFEVR/EvLlvDLX8Idd9hSzc8+sw2DmjSxws1zz/VFqWAk8iohL8lqwGQjCOnAn++eoiiKooQSDNpGSd/7nteW1Do0NaAoiqIoGSDproLOSAYRGS4ib4rIJhExIvL9pO1M9gBFURRFUeKTpaqBAmAJkHLzBE0NKIqiKEoGyIZGwBjzLvAugKQ4v4I6AklSXFzstQmKoihKDcjW9/jBqmKSvTUfpNq2JmE39jJjTFlaDAtDHYHEaQLQqVMnr+1QFEVR0kMTIBNewUFgy8N0apvi8fuADWHr7gPurYlR0VBHIHE2AR2BvV4bEoMm2D8ev9sZi1y/BrXfe3L9GtT+7NAE+72edowxB0SkK1AvjafNSDQA1BFIGGOMATZ6bUcsQsJIe40xOZnDyPVrUPu9J9evQe3PGhm1zRhzADiQyddIF1o1oCiKoih1GI0IKIqiKEqOIiKNgR4hq7qKyABglzHm60TOoY5A7aIMKyjJWC4pC+T6Naj93pPr16D2K8lwAjA15Pc/Ocu/A6MTOYHY1LeiKIqiKHUR1QgoiqIoSh1GHQFFURRFqcOoI6AoiqIodRh1BBRFURSlDqOOQI4jIh1E5CYRmSIiX4vIQRHZIiL/FpETvbYvVUTkdmdKTSMiQ722JxFE5Aci8l8R2SkiB0RkrYj8U0R835daLD8UkakisllESkRkpYj8RUS6eW2fi4iMcmyaLyJlzt/H6Bj7NxWRP4nIemf/dSLye6fkKuskar+I5IvIhSLydxFZLiL7RGSviMwRketEJOCB+Um//2HHdnOuw4jIpAybqiSBlg/mPj8Hbge+AqYA24FjgO8D3xeRS4wxL3loX9KIyLHY8qP92Ck2fY3YVmqTgKuxn8OL2Naq7YERQBfgG88MTIw/ALcAm4HXsF3XjgeuAi4WkZONMZ95aJ/LeOz7uQNra5doO4pIAfAxMAD7v/FPYCBwKzBCRIY73d+ySaL2dwf+he05/yHwBtAMuAB4HDhXRL5rsl/2lfD7H4qI5AGTM2eWUiOMMTpyeAA/BEZEWD8MO/HFLqC+13YmcT35wALgU+A5wABDvbYrjs03OnZOBAIRtge9tjGO/W2BSmAd0Cxs283OtT3jtZ2OPWcAXZyf73BsGx1l3/uc7Q+GrX/QWX+nX+0HOgA/AwrC1hcA85zjfuRX+yMcNw4oB25yjpnk9d+SjkNDUwM5jjHmP8aYjyOsn4FtMtECOC7rhqXO3UA/4ErszcnXiEhD4B5gDXCjMeYIm40xFVk3LDkKsWnCmcaYPWHb3nKWrbNqURSMMR8YY9bH28+J0ozBPlH/Nmzzb531Y9JvYWwStd8Ys9EY87gxZn/Y+v0cahgzIhM2xrErIftDEZHe2EjCA8DijBim1Ah1BGo35c7S7zciAERkENYRuM8Y84XX9iTIWVhn6zUg4OTZ7xCRa0WkR5xj/cIqbPToFBFpGrbtfGf5YXZNqjHHYFMzM6PcTGcC3XJBvxGBnPm/drQMf8f+jY332BwlCqoRqKWISGdsGG8zsMxjc+IiIvWBZ7FPDA95bE4yDHaWlcBSoGfItioRedgYc2v2zUocY8xOEbkD+COwQkRe55BG4HRsTvoxD01MhWOc5aoo21cBZzv7+V2/Ec6VznKKp1Ykxp3AIGx672DIzISKj1BHoBYiIvnY/Hp94PZI4Wof8hvsl/LgHLHX5WhneQuwECgClmNFaU8C40TkK2PMEx7ZlxDGmIdFZCPwNHBtyKZPgH/kQHojnGbOMjzV4VIctl9OICJXA+cAHxlj3vHanliIyPHAr4HfG2MWeG2PEh1NDdQyQtS5w4GnjDHPeWtRfETkJKySe7zxhzI9Gdz/oYPA940x84wx+xyNxo+AKqxQyteIyK+B54H7gU5AE6zgtAEwTUS+66F5CiAi52MjM+uBUR6bExMRqYdNCazGijYVH6OOQC3CcQKeAS7BfqlfG/sI7xGRIPYLYylWzZ1ruE+c840xm0I3OE7NGqC7iDTPumUJIiJnYL+sHzPGPGiM2eA4M59gy9XKsWmDXML9XKI98TcN28/XiMi52HLCrcDpxpjNHpsUjzuxIuUrjDE6C6HPUUegluA4AX8DLsfWS482xlR5a1VCNMamBAYAB0OaCBnstQDMdtZ93zMro7PSWe6Ost1d3zALtqTKOc5yavgGY8wWYAXQw6smPCniagOOibI9nobAN4jIecB/sLX7pxlj1nhsUiIMxN5fPg37n3b/xq5x1r3mnYmKi2oEagEhTsBlwEvApTmUZy8D/hpl23DsF/Yb2EZJ67JkUzK4X2x9wjc4Wo0e2MZI27NpVJLUc5bRSgRbY1Mc5VG2+5FVwCZsJURBaOWA02joFGCtMcbXQkHHCfg3th/IacaY1R6blCj/xTou4bQDzsU6lzOBRdk0SomMOgI5Tkg64DLgFWBUDjkBGGNKiVLPLSKTsY7AA8aYT7NpV6IYY74SkSnAWSIyxhjzdMjmO4DmwPM+F9vNBMYCt4jIv0N7CYjItUBHbBlezoR4jTFGRJ7GitV+hf0sXH6FjUTd74VtiSIi52CdgG+xToDvoxcuxpiJkdaLyEisI/CxMcb3qcu6ghiT7Q6VSjoRkXuxDW32AY8Qubb4NWNMzjXycByBy4GT/OoIAIhId2AWtoLgbezTzkBs6d16bOnUFu8sjI1T6/0RNgKzDRuB2Y0t+zodKAVGGmPmemakg4iMAU51fj0Oa+NMrCgN4BPXGXOe/GdiyyCnYKs6BmF7P8zDduQszZ71idvvNOFZjK38eZFDKahQ1hljJmfW4sNJ5v2PcvxIbBTtL+oI+AivWxvqqNnAVgiYOGO013bW8Np83WLYsbUTNj2zGVtB8DVW4X2017YlaH997FPzQmwqoxzYgC1D7eO1fRH+JqKNyWH7NwMedj6Pg1jH7A9AEz/bD4xM4P96ml/tj3G8e13aYthHQyMCiqIoilKH0aoBRVEURanDqCOgKIqiKHUYdQQURVEUpQ6jjoCiKIqi1GHUEVAURVGUOow6AoqiKIpSh1FHQFEURVHqMOoIKIqiKEodRh0BRVEURanDqCOgKFnEmXp1mtd2JIOIrBORdV7boShKZlBHQKm1iEhh6FzoUcY6r+30GhGZ7LwXhV7bkk7UgVGUxNBpiJW6wFfA81G27c6mITnK/3htgKIomUMdAaUusNoYc6/XRuQqxpivvLZBUZTMoakBRXEQkTucEPmkGNueCFl3r7NupIj8VESWicgBEdkoIg+LSJMkXruViEwQkbUiUiYi20TkZRE5NsK+bii/m4iME5EvnGMmO9vbi8h9IvKpc54yJ0z+uIgcHXaudcDlzq9rQ1Im00L3iRRiF5EC53VWONe9S0TeFpFTIuwb+l5dIiKLRaRURDaLyCMi0jCJ92qQiPxLRL52rm27iMwTkbud7YUiYoAuQJewVNC9YecaLiJvisgO51yrRGS8iDQK22+ke7yInCoi00Rkr4jsFpF/i0iPRO1XFL+hEQFFOcRDwJnANSLynjHmNQARKQJ+A3wB3BLhuFuw4fOXgLeBM4CbgKEiMtwYUx7rRUWkNTAb6A5MA14EugL/C5wnImcbYz6JcOijwFDnNd8EtjnrhwPjgA+BOUA5MBC4DjhbRAYZY/Y4+04ARgPHA49wKFWyLo7NDYCPgCJgoXOeNsBFzmtcbIx5JcKhY4HvAK87x38HuAFoBfy/WK/pvO4AYBZQ6ZxjPdAc6AtcDfyfcw33YT8D9xpdpoWc6zpgorO/+/6dANwNnCYipxljDoaZMBS4E3gP+/73A34ADBORocaYNfGuQVF8hzFGh45aOYBCwACrgXujjO+EHdMB2AHsdH5u4hx/AOgftu+9zvnLQrcBArzgbBsXdowBpoWte8ZZf3/Y+nOd9auAvJD1k5313wCdI1z30UDjCOsvc467O2y9e77CKO/jOmBd2LpfO8c8D0jI+oHO+/Et0CTCe7Ub6BWyviGwEntjb5/AZ/pH5zzfi7CtZTy7Q7b1xTpIiyMcd0f4ZweMdNYZ4Jqw/a9x1r/p9d+8Dh2pDM8N0KEjUyPEEYg1JkQ47nvOtqnAc87PN0TYz725PRVhWxegAlgWtv4wRwCoB5RinY9GEc4zxTlmWMi6ydFsivN+CLAHmBq2PhVH4CvgINAxwv5POue7NMJ7dV+M9/GCBK7BdQTOSmDfWI7AI+Hva8i2PGx0YH7IOtcRWEmIUxay/5dAFdDa6797HTqSHZoaUOoC7xtjvpPozsaY1x2dwLXOqneMMX+OcciMCOdYLyLfAP1EpJ45MsTs0htogL05l0TYPhWbrhgQ4XXmRjNIRH6IfVIdBLQAAiGb20c7LhFEpCnQDVhujNkQxearHJufC9u2IML+7jmaJ/DyL2ND/q+KyEvAf4HpxpiNidgewlBnebaIRKqKKMd+NuHMNMZUha4wxlSJyEzgGGyK5YMkbVEUT1FHQFEi8yqHHIHH4uy7Ncb6Qmx6YWeUfZrGOcfmsP3ivq6IjAP+AGzHRhQ2YKMOYG+i9aO8VqLUxObiCOsqnGUgwrbDMMbMEZGRwF3AJcAVACIyD7jdGDM13jkcjnKWdye4v0uszxqgWZLnUxTPUUdAUcIQkebAU8B+7M3pUREZaIzZG+WQNjHWGyDacXDoxhjtHG3D9gvFhK8QkSDwK+zNeIAxZlvINgFui2FLotTE5hpjjJkBnONUGpwIXAD8DHhbRI41iQn2XNuaxvhcIxHrswabelGUnELLBxXlSJ4EOgM3Ar/Aqvknxth/WPgKEekCdAI+j5EWAFiBFSIOCS9ZcxjpLBfHNxuw6vtmwOxQJ8DhBKw4L5xKZxn3iRzAGFMMrAF6iEiHCLuMdJaJ2pwSxphSY8w0Y8w44H7stZ0Zsksl0a9pjrMcGmV7NE4RkcO+N53fT8Y6ZkuSPJ+ieI46AooSgoj8FPgR8Iox5q/GmMeAt4BLReSSKIddJiL9Q84h2BtTACvEi4rjJPwTewO/M8yW7wBnY6sWZiZ4CduwaYBBoY6FiLTAlrtFYpez7JTgawD8HcgHHnCu132d/thyxD3Aa0mcLyFE5CSndDEc94n8QMi6XUCrKPs/jk1JPCoinSO8TnMRGRjhuJ5Y/UMoVznr3zbGbI93DYriNzQ1oNQFeoQ3kgnjQWPMARHpiVWTf4OtSXe5ElgKPCEis40xa8OOfx+YLSIvYvPy/4N9+v6U6DffUG4HRgC/FJGTsU+rhViHpAS4IlygFg1HuPY4to/AEhF5E5urPwdbc78pwmEfAbcCT4rIv7EpkfXGmHChXygPAecBlwJ9RORDbNniRdjvlauSDLknyu3YGv/pwFrsjX8Q9j1fg9V2uHyE/RzeFZEZ2CqH6caY6caYz0TkZ8ATwEoReQdbCdEEK4QcgXXiruVw3gf+LCLnAp9j+whcgK36uDH9l6soWcDrsgUdOjI1SKx80GDV6vWwivZKYHiEc52JLQ+bDQSddfc6x48ExgCfYW9Mm7BNbJpEOM8RfQSc9a2wTsg67A1rO/AKcGyEfScTu9wvHyum+9KxZz1WPNiYKCV12BTIl85rh5c4RjumANtoaSWHege8A5waYd/q9yrCttHOttEJfKZnY6MRK7B5/r3YG/L/Aa3C9m2MTfNswj79G+DesH2GYCMyG0Pe9wXAA0DvkP1GuscDp2IbE+3DRj7+A/Tw+u9dh45UhxhzhN5IUZQEcKIM9wCnGWOmeWuNkkmcSoWp2D4I93prjaKkF9UIKIqiKEodRh0BRVEURanDqCOgKIqiKHUY1QgoiqIoSh1GIwKKoiiKUodRR0BRFEVR6jDqCCiKoihKHUYdAUVRFEWpw6gjoCiKoih1GHUEFEVRFKUOo46AoiiKotRh1BFQFEVRlDrM/wcf0p0TkJq8PgAAAABJRU5ErkJggg==\n" - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "85E7O2HN-YFy" - }, - "source": [ - "View average reward associated with each model:\n", - "\n", - "(note that it counts the warmup steps where all the models were evaluated)" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "0VO0zellal6n", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "e43c8023-3b05-444f-da9e-d520583e2d2e" - }, - "source": [ - "for i, r in enumerate(record):\n", - " print(\"model {}: counts {} reward (avg) {}\".format(i+1, (int(r[0])), onp.round(r[1], 3)))" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "model 1: counts 5 reward (avg) -0.4\n", - "model 2: counts 7 reward (avg) -0.571\n", - "model 3: counts 9 reward (avg) 1.0\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "mvfndjunkUU3" - }, - "source": [ - "Compute (and plot) each model's prediction over the entire grid using the final set of the discovered point:\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "esvnmTqzX0H5", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "outputId": "5581dc00-2847-4bad-fa00-8011b6b6b896" - }, - "source": [ - "for i, model in enumerate(models):\n", - " # same as in the main loop, we use restarts to help avoiding bad initialization\n", - " _, gp_model = step(model, model_priors[i], X_train, y_train, num_restarts=2, print_summary=0)\n", - " y_pred, y_sampled = gp_model.predict(gpax.utils.get_keys()[1], X)\n", - " print(\"\\n Model {}, Reward (avg) {}\".format(i+1, onp.round(record[i, 1], 3)))\n", - " plot_final_result(X_train, y_train, X, y_pred, y_sampled.squeeze(), seed_points=num_seed_points)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [02:05<00:00, 31.77it/s, 1023 steps of size 8.37e-04. acc. prob=0.88]\n", - "sample: 100%|██████████| 4000/4000 [02:01<00:00, 32.81it/s, 1023 steps of size 2.74e-03. acc. prob=0.79]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " Model 1, Reward (avg) -0.4\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [02:00<00:00, 33.09it/s, 1023 steps of size 1.51e-04. acc. prob=0.96]\n", - "sample: 100%|██████████| 4000/4000 [01:51<00:00, 36.00it/s, 1023 steps of size 8.61e-05. acc. prob=0.87]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " Model 2, Reward (avg) -0.571\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "sample: 100%|██████████| 4000/4000 [02:09<00:00, 30.94it/s, 1023 steps of size 2.66e-03. acc. prob=0.77]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - " Model 3, Reward (avg) 1.0\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "We see that the model which received the highest reward (i.e., is\n", - "favored by our algorithm) clearly provided the best fit. Hence, we were able both to learn a correct data distribution with a small number of sparse measurements while also identifying a correct model that describes the system’s behavior." - ], - "metadata": { - "id": "bQelw5QCkZsP" - } - }, - { - "cell_type": "code", - "source": [ - "" - ], - "metadata": { - "id": "78NMvCUCkd7_" - }, - "execution_count": null, - "outputs": [] - } - ] -} \ No newline at end of file