diff --git a/tutorials/fobo.ipynb b/tutorials/fobo.ipynb new file mode 100644 index 0000000000..ba0c16e834 --- /dev/null +++ b/tutorials/fobo.ipynb @@ -0,0 +1,574 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ce096015-21cf-4974-9a07-c9c0d13a057b", + "metadata": { + "tags": [] + }, + "source": [ + "## BO with Derivatives\n", + "\n", + "This tutorial demonstrates how to use gradient information in Bayesian Optimization. Traditionally, Bayesian Optimization is a zeroth-order method that does not utilize gradient information because oftentimes the black-box functions being optimized does not provide gradients. However, there may be some cases where gradient information is available [1]. As a result, derivative-enabled Bayesian Optimization may use the additional gradient information. We will call zeroth-order Bayesian Optimization ZOBO and first-order Bayesian Optimization FOBO.\n", + "\n", + "The key differences between FOBO and ZOBO are that FOBO uses a modified Gaussian Process which uses derivative information (dGP) and the acquisition functions need to be able to handle a dGP [2].\n", + "\n", + "In this notebook, we use the Noisy Expected Improvement (qNEI) and Knowledge Gradient (qKG) acquisition functions on a dGP which is trained on evaluations from the 3D Rosenbrock function [3].\n", + "\n", + "[1]: [Quentin Bertrant, et al. Implicit Differentiation for Fast Hyperparameter Selection in Non-Smooth Convex Learning. Journal of Machine Learning Research, 2022.](https://dl.acm.org/doi/pdf/10.5555/3586589.3586738) \n", + "[2]: [Jian Wu, et al. Bayesian Optimization with Gradients. 31st Conference on Neural Information Processing Systems, 2017.](https://proceedings.neurips.cc/paper/2017/file/64a08e5f1e6c39faeb90108c430eb120-Paper.pdf) \n", + "[3]: [Frazier, Peter I. \"A tutorial on Bayesian optimization.\" arXiv preprint arXiv:1807.02811 (2018).](https://arxiv.org/pdf/1807.02811.pdf%C2%A0)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ddb3ae78-4f7c-49d4-a5ed-48b8b717734d", + "metadata": {}, + "outputs": [], + "source": [ + "# Imports\n", + "import os\n", + "\n", + "import torch\n", + "import gpytorch\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from botorch import fit_gpytorch_mll\n", + "from botorch.optim import optimize_acqf\n", + "from botorch.acquisition import qKnowledgeGradient, qNoisyExpectedImprovement\n", + "from botorch.acquisition.objective import ScalarizedPosteriorTransform\n", + "from botorch.models.gpytorch import GPyTorchModel\n", + "from botorch.sampling.normal import SobolQMCNormalSampler\n", + "from botorch.models.model import FantasizeMixin\n", + "from botorch.models.gpytorch import GPyTorchModel\n", + "\n", + "from gpytorch.mlls.sum_marginal_log_likelihood import ExactMarginalLogLikelihood\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f3c38a9d-2c6e-4804-a43e-ab1a9ca1e576", + "metadata": {}, + "outputs": [], + "source": [ + "# Set default data type to avoid numerical issues from low precision\n", + "torch.set_default_dtype(torch.double)\n", + "\n", + "# Set seed for consistency and good results\n", + "seed = 3\n", + "torch.manual_seed(seed)\n", + "np.random.seed(seed)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b0682efe-5d3d-4128-88fe-6783aec381bc", + "metadata": {}, + "outputs": [], + "source": [ + "# Used to test the notebook quickly\n", + "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")\n", + "\n", + "# Parameters\n", + "f_noise = 0.05 # Noise added to both function evaluations and their gradients\n", + "rs_init = 10 # Initialization points from random search\n", + "rb_dim = 3 # Rosenbrock dimensions\n", + "d_min = -2. # Lower bound of search space for each dimension of the domain\n", + "d_max = 2. # Upper bound of search space for each dimension of the domain\n", + "bo_iters = 40 if not SMOKE_TEST else 2 # Number of iterations of Bayesian Optimization\n", + "mc_samples = 256 if not SMOKE_TEST else 32 # Samples from Monte-Carlo sampler\n" + ] + }, + { + "cell_type": "markdown", + "id": "f873c969-0fd5-4b5b-9b4b-3259c7157c61", + "metadata": {}, + "source": [ + "## The Generalized Rosenbrock's Function\n", + "\n", + "We use the [Generalized Rosenbrock's Function](https://docs.scipy.org/doc/scipy-0.14.0/reference/tutorial/optimize.html#unconstrained-minimization-of-multivariate-scalar-functions-minimize) because it has a unique global minimum at $x_0=(1.0,1.0,1.0)$ with $f(x_0)=0.0$ when working in $3$ dimensions. Since Bayesian Optimization is typically concerned with maximizing an objective function, we augment the Rosenbrock function $f(x)$ by creating $g(x)=-f(x)$, the augmented Rosenbrock function. Further, we use backpropogation to calculate the gradient of the Rosenbrock function for each input $x$.\n", + "\n", + "The variant of the Rosenbrock function used here is:\n", + "$$f(\\boldsymbol{x}) = \\sum_{i=1}^{d-1} \\left [ 100(x_{i+1}-x_{i}^{2}) + (1-x_i)^2 \\right ], \\quad \\boldsymbol{x} \\in \\mathbb{R}^d$$" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "74c06a83-8480-49a5-8137-2b5d35a9ecf2", + "metadata": {}, + "outputs": [], + "source": [ + "# Rosenbrock function multiplied by -1 to make this a maximization problem\n", + "# Note: This only evaluates a single X at a time (not a vectorized function)\n", + "def Rosenbrock(X):\n", + " # Cast to calculate gradient\n", + " X.requires_grad_(True)\n", + " \n", + " # Get dimensions\n", + " N = X.shape[0]\n", + " \n", + " # Vector containing individual values in summation\n", + " cur_sum = torch.zeros_like(torch.empty(N-1))\n", + " \n", + " # Evaluate generaled N-dimensional Rosenbrock function\n", + " for i in range(0,N-1):\n", + " cur_sum[i] = 100*(X[i+1]-X[i]**2)**2+(1-X[i])**2\n", + " \n", + " # Compute sum\n", + " Y = torch.sum(cur_sum)\n", + " \n", + " # Make this a maximization problem!\n", + " Y = -1*Y\n", + " \n", + " # Calculate gradient\n", + " Y.backward()\n", + " grads = X.grad\n", + " \n", + " # Convert to doubles for better numerical stability\n", + " Y = Y.to(torch.double).detach()\n", + " grads = grads.to(torch.double)\n", + " \n", + " # Add noise to evaluation and gradient\n", + " grads += torch.normal(0,1,grads.shape)*f_noise\n", + " Y += torch.normal(0,1,Y.shape)*f_noise\n", + " \n", + " # Return function value and the gradient\n", + " return Y, grads" + ] + }, + { + "cell_type": "markdown", + "id": "acf0cc23-446d-4a94-9978-151828b8ef0f", + "metadata": {}, + "source": [ + "## Derivative-enabled Gaussian Process (dGP)\n", + "\n", + "We create a custom BoTorch dGP model using GPyTorch. This model requires modifying the mean and covariance matrix to incorporate gradient/derivative information. As such, a mean *vector* and the covariance matrix of the RBF kernel are used [2]. This class was modified from this [GPyTorch tutorial](https://docs.gpytorch.ai/en/latest/examples/08_Advanced_Usage/Simple_GP_Regression_Derivative_Information_1d.html). \n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a42af425-d89b-4398-9bae-fdee07a9121b", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the dGP\n", + "class GPWithDerivatives(GPyTorchModel, gpytorch.models.ExactGP, FantasizeMixin):\n", + " def __init__(self, train_X, train_Y):\n", + " # Dimension of model\n", + " dim = train_X.shape[-1] \n", + " # Multi-dimensional likelihood since we're modeling a function and its gradient\n", + " likelihood = gpytorch.likelihoods.MultitaskGaussianLikelihood(num_tasks=1 + dim)\n", + " super().__init__(train_X, train_Y, likelihood)\n", + " # Gradient-enabled mean\n", + " self.mean_module = gpytorch.means.ConstantMeanGrad() \n", + " # Gradient-enabled kernel\n", + " self.base_kernel = gpytorch.kernels.RBFKernelGrad( \n", + " ard_num_dims=dim, # Separate lengthscale for each input dimension\n", + " )\n", + " # Adds lengthscale to the kernel\n", + " self.covar_module = gpytorch.kernels.ScaleKernel(self.base_kernel)\n", + " # Output dimension is 1 (function value) + dim (number of partial derivatives)\n", + " self._num_outputs = 1 + dim\n", + " # Used to extract function value and not gradients during optimization\n", + " self.scale_tensor = torch.tensor([1.0] + [0.0]*dim, dtype=torch.double)\n", + "\n", + " def forward(self, x):\n", + " mean_x = self.mean_module(x)\n", + " covar_x = self.covar_module(x)\n", + " return gpytorch.distributions.MultitaskMultivariateNormal(mean_x, covar_x)" + ] + }, + { + "cell_type": "markdown", + "id": "9b8024cb-34da-4c16-870e-5dcd9d1b7197", + "metadata": {}, + "source": [ + "## Random Search\n", + "\n", + "To initialize our GP we obtain initialization data using random search on the optimization domain $[-2,2]^3$." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "18331985-8df4-49fb-9ccd-aa681a52995a", + "metadata": {}, + "outputs": [], + "source": [ + "# Random search locations\n", + "train_X = torch.rand((rs_init, rb_dim))*(d_max - d_min)+d_min\n", + "\n", + "# Populate random search evaluations\n", + "train_Y = torch.empty((rs_init, rb_dim + 1))\n", + "for i in range(rs_init):\n", + " obj, deriv = Rosenbrock(train_X[i])\n", + " train_Y[i][0] = obj\n", + " train_Y[i][1:] = deriv\n" + ] + }, + { + "cell_type": "markdown", + "id": "805acd60-bcd7-425d-ba57-7969d893f453", + "metadata": {}, + "source": [ + "## qNEI FOBO Loop" + ] + }, + { + "cell_type": "markdown", + "id": "c3371766-c05f-4a8c-9720-9f236203a925", + "metadata": {}, + "source": [ + "Here we have the FOBO loop with the qNEI acquisition function on a dGP. Note that we have to include a `ScalarizedPosteriorTransform` to ensure that we're optiming over the black-box function's function evaluation instead of its gradients (since the output of the dGP is a mean vector of the black-box function's value and gradients, as opposed to a mean scalar of just the black-box function's value). Also, we scale the domain and range of the training data [to avoid numerical issues](https://github.com/pytorch/botorch/issues/1745)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e8d2138-81ec-49da-8fca-06991197a95c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "for i in range(bo_iters):\n", + " # Standardize domain and range, this prevents numerical issues\n", + " mean_Y = train_Y.mean(dim=0)\n", + " std_Y = train_Y.std(dim=0)\n", + " unscaled_train_Y = train_Y\n", + " scaled_train_Y = (train_Y - mean_Y) / std_Y\n", + " \n", + " mean_X = train_X.mean(dim=0)\n", + " std_X = train_X.std(dim=0)\n", + " unscaled_train_X = train_X\n", + " scaled_train_X = (train_X - mean_X) / std_X\n", + "\n", + " # Initialize the dGP and fit it to the training data\n", + " dGP_model = GPWithDerivatives(scaled_train_X, scaled_train_Y) # Define dGP model\n", + " mll = ExactMarginalLogLikelihood(dGP_model.likelihood, dGP_model) # Define MLL\n", + " fit_gpytorch_mll(mll, max_attempts=20)\n", + "\n", + " # Extract only the function value from the multi-output GP, the dGP\n", + " scal_transf = ScalarizedPosteriorTransform(weights=dGP_model.scale_tensor)\n", + "\n", + " # Create qNEI acquisition function\n", + " sampler = SobolQMCNormalSampler(mc_samples)\n", + " qNEI = qNoisyExpectedImprovement(dGP_model,\\\n", + " train_X,\\\n", + " sampler,\\\n", + " posterior_transform=scal_transf)\n", + "\n", + " # Set bounds for optimization: [-2,2]^d\n", + " bounds = torch.vstack([torch.tensor([d_min]*rb_dim),\\\n", + " torch.tensor([d_max]*rb_dim)])\n", + "\n", + " # Rescale bounds based on training data\n", + " bounds = (bounds - mean_X) / std_X\n", + "\n", + " # Get candidate point for objective\n", + " candidates, _ = optimize_acqf(\n", + " acq_function=qNEI,\n", + " bounds=bounds,\n", + " q=1,\n", + " num_restarts=100,\n", + " raw_samples=512, # used for intialization heuristic\n", + " options={\"batch_limit\": 1, \"maxiter\": 1000},\n", + " )\n", + "\n", + " # Rescale candidate back to original domain\n", + " candidate = (candidates[0] * std_X) + mean_X\n", + " \n", + " # Evaluate the objective and add it to the list of data for the model\n", + " obj, deriv = Rosenbrock(candidate)\n", + " new_Y = torch.cat([obj.unsqueeze(0),deriv])\n", + " \n", + " # Append evaluation to training data\n", + " train_X = torch.vstack((train_X, candidate)).detach().clone()\n", + " train_Y = torch.vstack((train_Y, new_Y)).detach().clone()\n" + ] + }, + { + "cell_type": "markdown", + "id": "d51a9838-1b0d-4369-b0cf-0baffe996925", + "metadata": {}, + "source": [ + "## Plot Results" + ] + }, + { + "cell_type": "markdown", + "id": "c74d9ca3-2fa1-4df0-b1ea-b33b3e46f24e", + "metadata": {}, + "source": [ + "From plotting the results we see that derivative-enabled Bayesian Optimization is able to utilize gradient information to maximize the objective function." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "0b235183-05ed-428c-b32d-2a8da25bb296", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Extract maximum value per iteration\n", + "maxima = torch.zeros(rs_init + bo_iters)\n", + "cur_max = train_Y[0][0]\n", + "\n", + "for i in range(rs_init + bo_iters):\n", + " cur_max = cur_max if cur_max > train_Y[i][0] else train_Y[i][0]\n", + " maxima[i] = cur_max\n", + "\n", + "# Get plotting values\n", + "plt_y = maxima.numpy()\n", + "plt_x = list(range(1,len(plt_y)+1))\n", + "\n", + "# Have the first x-value in the plot start at 1 to be consistent with above prints\n", + "plt_y = np.hstack([plt_y])\n", + "plt_x = np.hstack([plt_x])\n", + "\n", + "# Plot all values\n", + "plt.plot([plt_x[rs_init-1], plt_x[rs_init]], [plt_y[rs_init-1], plt_y[rs_init]],\\\n", + " linestyle='--', color='gray')\n", + "plt.plot(plt_x[0:rs_init], plt_y[0:rs_init], color='red', label=\"Init values\", marker='.')\n", + "plt.plot(plt_x[rs_init:], plt_y[rs_init:], color='black', label=\"BO values\", marker='.')\n", + "plt.xlabel(\"BO Iteration\")\n", + "plt.ylabel(\"Maximum value\")\n", + "plt.title(\"Best value found per BO iteration including initialization\")\n", + "plt.legend()\n", + "plt.show()\n", + "plt.close()\n", + "\n", + "plt.plot([plt_x[rs_init-1], plt_x[rs_init]], [plt_y[rs_init-1], plt_y[rs_init]],\\\n", + " linestyle='--', color='gray')\n", + "plt.plot(plt_x[rs_init-1], plt_y[rs_init-1], color='red', label=\"Init values\", marker='.')\n", + "plt.plot(plt_x[rs_init:], plt_y[rs_init:], color='black', label=\"BO values\", marker='.')\n", + "plt.xlabel(\"BO Iteration\")\n", + "plt.ylabel(\"Maximum value\")\n", + "plt.title(\"Best value found per BO iteration after initialization\")\n", + "plt.legend()\n", + "plt.show()\n", + "plt.close()\n" + ] + }, + { + "cell_type": "markdown", + "id": "9fd8e9fc-d42a-4215-800d-55c51decb920", + "metadata": {}, + "source": [ + "## qKG FOBO Loop" + ] + }, + { + "cell_type": "markdown", + "id": "8dc5e991-8508-4050-a1c3-d3da3b14b1cb", + "metadata": {}, + "source": [ + "Here we have the same FOBO loop, but with the qKG acquisition function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b034797-d2ae-4b73-ba59-d1f94fa88e2d", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Reset training data to the same as for qNEI\n", + "train_X = train_X[0:rs_init]\n", + "train_Y = train_Y[0:rs_init]\n", + "\n", + "for i in range(bo_iters):\n", + " # Standardize domain and range, this prevents numerical issues\n", + " mean_Y = train_Y.mean(dim=0)\n", + " std_Y = train_Y.std(dim=0)\n", + " unscaled_train_Y = train_Y\n", + " scaled_train_Y = (train_Y - mean_Y) / std_Y\n", + " \n", + " mean_X = train_X.mean(dim=0)\n", + " std_X = train_X.std(dim=0)\n", + " unscaled_train_X = train_X\n", + " scaled_train_X = (train_X - mean_X) / std_X\n", + "\n", + " # Initialize the dGP and fit it to the training data\n", + " dGP_model = GPWithDerivatives(scaled_train_X, scaled_train_Y) # Define dGP model\n", + " mll = ExactMarginalLogLikelihood(dGP_model.likelihood, dGP_model) # Define MLL\n", + " fit_gpytorch_mll(mll, max_attempts=20)\n", + "\n", + " # Extract only the function value from the multi-output GP, the dGP\n", + " scal_transf = ScalarizedPosteriorTransform(weights=dGP_model.scale_tensor)\n", + "\n", + " # Create the qKG acquisition function\n", + " qKG = qKnowledgeGradient(dGP_model,\\\n", + " posterior_transform=scal_transf,\\\n", + " num_fantasies=5)\n", + "\n", + " # Set bounds for optimization: [-2,2]^d\n", + " bounds = torch.vstack([torch.tensor([d_min]*rb_dim),\\\n", + " torch.tensor([d_max]*rb_dim)])\n", + "\n", + " # Rescale domain based on training data\n", + " bounds = (bounds - mean_X) / std_X\n", + "\n", + " # Get candidate point for objective\n", + " candidates, _ = optimize_acqf(\n", + " acq_function=qKG,\n", + " bounds=bounds,\n", + " q=1,\n", + " num_restarts=100,\n", + " raw_samples=512, # used for intialization heuristic\n", + " options={\"batch_limit\": 1, \"maxiter\": 1000},\n", + " )\n", + "\n", + " # Rescale candidate back to original domain\n", + " candidate = (candidates[0] * std_X) + mean_X\n", + " \n", + " # Evaluate the objective and add it to the list of data for the model\n", + " obj, deriv = Rosenbrock(candidate)\n", + " new_Y = torch.cat([obj.unsqueeze(0),deriv])\n", + " \n", + " # Append evaluation to training data\n", + " train_X = torch.vstack((train_X, candidate)).detach().clone()\n", + " train_Y = torch.vstack((train_Y, new_Y)).detach().clone()\n" + ] + }, + { + "cell_type": "markdown", + "id": "16d05516-6e89-43a1-8904-5acd950e9f00", + "metadata": {}, + "source": [ + "## Plot Results" + ] + }, + { + "cell_type": "markdown", + "id": "466e0aec-424b-4ac4-b908-256eb6eee790", + "metadata": {}, + "source": [ + "From plotting the results we see that derivative-enabled Bayesian Optimization is able to find better maxima values." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c68f082f-92ac-4c9c-bcdc-8d428f0b6e44", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAAHFCAYAAAA9occoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABjRElEQVR4nO3deVxUVeMG8GdYZlgUkEUGXFg0cxcVUygDNcElNc3S1AK3MiUX7FdZqYgL5kJmpuaKve5bvpplbkipZGKQC75ZCqIBoqagGPv5/cE792VkwBlgZhh6vp/P/cjce+becw/DzOO559yRCSEEiIiIiEhrZsauABEREZGpYYAiIiIi0hEDFBEREZGOGKCIiIiIdMQARURERKQjBigiIiIiHTFAEREREemIAYqIiIhIRwxQRERERDpigKqlYmJiIJPJ1BYXFxcEBgbim2++0dtxHz16hIiICJw4cUJvx3gSmUyGiIgIoxz72LFj8PX1ha2tLWQyGfbt22eUejyJ6vWRmppq7Ko8UUREhNrr2MzMDG5ubujXrx9OnTql8Tk//fQTXnnlFbi5uUEul0OpVGLo0KGIj4/X6pipqamQyWSIiYmR1p0+fRoRERG4f/9+DZxV1VVWj8DAQAQGBhq8Tpraq6bp49xCQ0Ph6empts6Y7x/VOfbj7VPZe3F1/v41PVdTO9aklStXanxtGeJ1p08Wxq4AVW7jxo1o2bIlhBDIzMzEihUrMGDAAOzfvx8DBgyo8eM9evQIc+bMAQCjvJEbkxACr776Klq0aIH9+/fD1tYWTz/9tLGrVWccOnQI9vb2KCkpQVpaGhYtWoTAwECcOXMGnTp1ksp9/vnnmDp1Kp555hksWrQIHh4eSEtLwxdffIHnnnsOn332GcLCwio9lpubG+Lj49GsWTNp3enTpzFnzhyEhobCwcFBX6f5RJXVY+XKlUapk6b2MlXx8fFo3LixyR378d99Ze/F/fv3R3x8PNzc3Kp0rMfNnDkTU6ZMqZF9abJy5Uo4OzsjNDRUbb2pv+4YoGq5tm3bwtfXV3rcp08fNGjQANu2bdNLgPonS09Px19//YXBgwejV69exq6OSXn06BFsbGwqLdO5c2c4OzsDAPz9/fHMM8+gWbNm2L17txSgTp06halTp6Jfv374+uuvYWHxv7eo4cOHY/DgwZgyZQo6duyIZ599tsJjKRQKdOvWrQbO7Mm0OXdttW7dukb2oytDtpe+GfM8qnNsXX73Li4ucHFxqfKxHmesAGPqrztewjMxVlZWkMvlsLS0VFtfUFCAefPmoWXLllAoFHBxccHo0aNx+/ZttXLHjx9HYGAgnJycYG1tjaZNm+Lll1/Go0ePkJqaKv1RzpkzR7rk8vj/GlRu374NuVyOmTNnltv2n//8BzKZDMuXL5fKTpw4Ea1bt0a9evXQsGFD9OzZEz/++OMTz1l1CehxFXVj79ixA35+frC1tUW9evUQHByMxMTEJx5D9T/H999/HzKZTK1L++TJk+jVqxfq168PGxsb+Pv74+DBg1Wup6enJ1588UUcOnQInTp1grW1NVq2bIkNGzaUe/5PP/2EZ599FlZWVnB3d8eMGTNQWFhY6fmohIaGol69erh06RJ69eoFW1tbuLi4ICwsDI8ePVIrK4TAypUr4ePjA2trazRo0ABDhw7FtWvX1MoFBgaibdu2+OGHH+Dv7w8bGxuMGTNGq/qUZW9vDwBqr+WoqCjIZDKsWrVKLTwBgIWFBVauXAmZTIaFCxdWuu/HLw1ERETg//7v/wAAXl5e0mu77OURbV43qva8cOECgoKCUL9+fSlsHzlyBIMGDULjxo1hZWWF5s2b46233sKdO3ek5z+pHpouc/3111+YOHEiGjVqBLlcDm9vb3z00UfIz89XKyeTyRAWFoZ//etfaNWqFWxsbNChQwetLvlrupSiej1funQJr732Guzt7eHq6ooxY8YgOztb7fklJSX4/PPPpdeOg4MDunXrhv3791d4zBMnTpT7HVRUF6D07+jpp5+GQqFAq1at8NVXX2nc7+OX0VR/f7GxsXj77bfh7OwMJycnDBkyBOnp6WrPzc/Px/Tp06FUKmFjY4Pnn38e586dg6enZ4XvgzV17LK/+ye9F2t6T9Hm9VeRxy/hPX7ZvexSth3mzJmDrl27wtHREXZ2dujUqRPWr18PIYRUxtPTE5cuXUJcXJy0D9WxKvpda/N+q0vb6gsDVC1XXFyMoqIiFBYW4ubNm5g6dSpyc3MxYsQIqUxJSQkGDRqEhQsXYsSIETh48CAWLlyII0eOIDAwEH///TeA0hdr//79IZfLsWHDBhw6dAgLFy6Era0tCgoK4ObmhkOHDgEAxo4di/j4eMTHx2sMSEDp/4JefPFFbNq0CSUlJWrbNm7cCLlcjpEjRwIo/RAAgNmzZ+PgwYPYuHEjvL29ERgYWKPjrRYsWIDXXnsNrVu3xs6dO/Gvf/0LDx48QPfu3ZGcnFzh88aNG4e9e/cCAN555x3Ex8fj66+/BgDExcWhZ8+eyM7Oxvr167Ft2zbUr18fAwYMwI4dO6pc119//RXTp0/HtGnT8O9//xvt27fH2LFj8cMPP0hlkpOT0atXL9y/fx8xMTFYvXo1EhMTMW/ePK2PU1hYiH79+qFXr17Yt28fwsLC8OWXX2LYsGFq5d566y1MnToVL7zwAvbt24eVK1fi0qVL8Pf3x61bt9TKZmRkYNSoURgxYgS+/fZbTJw48Yn1UL2WCwoK8Mcff2DSpElQKBQYOnSotD02Nha+vr4VXgZp0qQJOnfujOPHj6O4uFjrNhg3bhzeeecdAMDevXul17aq50uX101BQQEGDhyInj174t///rd0meXq1avw8/PDqlWrcPjwYcyaNQtnzpzBc889JwXeJ9XjcXl5eejRowe++uorhIeH4+DBgxg1ahQWLVqEIUOGlCt/8OBBrFixApGRkdizZw8cHR0xePDgciFYFy+//DJatGiBPXv24IMPPsDWrVsxbdo0tTKhoaGYMmUKunTpgh07dmD79u0YOHBgjY3Ri4mJwejRo9GqVSvs2bMHH3/8MebOnYvjx49rvY9x48bB0tISW7duxaJFi3DixAmMGjVKrczo0aOxbNkyjB49Gv/+97/x8ssvY/DgwdUeN6fNscvS9b0Y0O71p0t9VcdULarg36ZNG6lcamoq3nrrLezcuRN79+7FkCFD8M4772Du3LlSma+//hre3t7o2LGjtC/Ve6smur7f6tq2NUpQrbRx40YBoNyiUCjEypUr1cpu27ZNABB79uxRW3/27FkBQCq/e/duAUAkJSVVeNzbt28LAGL27Nla1XP//v0CgDh8+LC0rqioSLi7u4uXX365wucVFRWJwsJC0atXLzF48GC1bY8ff/bs2ULTS1XVRikpKUIIIdLS0oSFhYV455131Mo9ePBAKJVK8eqrr1Z6LikpKQKAWLx4sdr6bt26iYYNG4oHDx6o1b9t27aicePGoqSkRKd6CiGEh4eHsLKyEtevX5fW/f3338LR0VG89dZb0rphw4YJa2trkZmZqXbsli1bltunJiEhIQKA+Oyzz9TWz58/XwAQJ0+eFEIIER8fLwCIpUuXqpW7ceOGsLa2Fu+99560LiAgQAAQx44dq/TYKqp2eXyxs7MTe/fulcplZmYKAGL48OGV7m/YsGECgLh161aFZVS/y40bN0rrFi9erLHNdHndqNpzw4YNldaxpKREFBYWiuvXrwsA4t///vcT6yFEadsGBARIj1evXi0AiJ07d6qV++STT8r93QEQrq6uIicnR1qXmZkpzMzMRFRUVKX11dReqt/bokWL1MpOnDhRWFlZSa/7H374QQAQH330UaXHePzcYmNjBQARGxtbaV2Ki4uFu7u76NSpk3RMIYRITU0VlpaWwsPDQ+35j79/qP7+Jk6cqFZu0aJFAoDIyMgQQghx6dIlAUC8//77auVU768hISGVnl91ji1E+fap7L1Y03tKWZW9/jQ9NyQkpFw7lvXjjz8KKysrMXLkSLXfQVnFxcWisLBQREZGCicnJ7Vybdq0UTs3FU2vO23fb3VpW31hD1Qt99VXX+Hs2bM4e/YsvvvuO4SEhGDSpElYsWKFVOabb76Bg4MDBgwYgKKiImnx8fGBUqmUenh8fHwgl8vx5ptvYtOmTdX6X6lK3759oVQqsXHjRmnd999/j/T09HKXdVavXo1OnTrBysoKFhYWsLS0xLFjx3D58uVq10N13KKiIrzxxhtq7WBlZYWAgIAq9XTl5ubizJkzGDp0KOrVqyetNzc3x+uvv46bN2/it99+q1J9fXx80LRpU+mxlZUVWrRogevXr0vrYmNj0atXL7i6uqod+/HeoydR9QSqqHowY2NjAZS+hmQyGUaNGqXWdkqlEh06dCjXdg0aNEDPnj11qsPRo0dx9uxZ/Pzzz/jmm2/wwgsvYPjw4ZX+b1QT8d/LA5oul1ZFVV43L7/8crl1WVlZmDBhApo0aSK9vj08PACgyq/x48ePw9bWVuqlU1FdRjl27Jja+h49eqB+/frSY1dXVzRs2FDtNaWrgQMHqj1u37498vLykJWVBQD47rvvAACTJk2q8jEq89tvvyE9PR0jRoxQ+517eHjA399f6/1oOg8AUtvExcUBAF599VW1ckOHDi13OVlXTzp2TdDH60/13IEDB8Lf3x8bNmxQ+x0cP34cL7zwAuzt7WFubg5LS0vMmjULd+/elV4fuqjK+60h2rYiHERey7Vq1arcIPLr16/jvffew6hRo+Dg4IBbt27h/v37kMvlGvehugberFkzHD16FIsWLcKkSZOQm5sLb29vTJ48ucozMCwsLPD666/j888/x/379+Hg4ICYmBi4ubkhODhYKhcdHY3p06djwoQJmDt3LpydnWFubo6ZM2fWWIBSXWbq0qWLxu1mZrr/f+HevXsQQmic7eLu7g4AuHv3rs77BQAnJ6dy6xQKhXTJVbVvpVJZrpymdRWxsLAodyzV81V1v3XrFoQQakGtLG9vb7XHVZn906FDB2kQOVAavtu1a4dJkyZh8ODBcHZ2ho2NDVJSUirdT2pqKmxsbODo6KhzHTTR9XVjY2MDOzs7tXUlJSUICgpCeno6Zs6ciXbt2sHW1hYlJSXo1q2b2u9UF6rf/+NhsWHDhrCwsCj32tPmNaWrx/epUCgAQNrn7du3YW5urtNrUheqc6zo70Dby4RPOg/VcR7/G9D096OrJx27uvT1+ktPT0efPn3QuHFj7N27V+0z5ueff0ZQUBACAwOxdu1aNG7cGHK5HPv27cP8+fOrdMyqvN/qu20rwwBlgtq3b4/vv/8eV65cwTPPPCMNnlNdM39c2f+Rdu/eHd27d0dxcTESEhKkKeOurq4YPnx4leozevRoLF68GNu3b8ewYcOwf/9+TJ06Febm5lKZzZs3IzAwEKtWrVJ77oMHD564fysrKwClAzxVfxwAyg2OVH047969W/qfV3U1aNAAZmZmyMjIKLdNNVBRdVxt66kLJycnZGZmlluvaV1FioqKcPfuXbU3GtXzVeucnZ0hk8nw448/qtVd5fF1NdH7Y2ZmhjZt2mDXrl3IyspCw4YN0aNHDxw6dAg3b97UOA7q5s2bOHfuHPr27av2+qoOXV83ms794sWL+PXXXxETE4OQkBBp/R9//FGtujk5OeHMmTMQQqgdNysrC0VFRWqB1FhcXFxQXFyMzMxMnYJ12b+Xsh7/e1G9Rqv7d/AkquPcunULjRo1ktar/n5qM328/nJyctCvXz+UlJTg22+/lSZ9qGzfvh2Wlpb45ptvpN8lgGrdO0+X99vagJfwTFBSUhIASLM0XnzxRdy9exfFxcXw9fUtt2i6l5G5uTm6du2KL774AgDwyy+/AKhaem/VqhW6du2KjRs3YuvWrcjPz8fo0aPVyshksnIfwufPn9fqxoiqGRvnz59XW3/gwAG1x8HBwbCwsMDVq1c1tkPZnjxt2draomvXrti7d69am5SUlGDz5s1o3LgxWrRooVM9ddGjRw8cO3ZMbRB3cXGxzoPXt2zZovZ469atAP53f5kXX3wRQgj8+eefGtutXbt2VT6HihQXF+PChQtQKBRSj86MGTMghMDEiRPLDRIvLi7G22+/DSEEZsyYofPxKnpt18TrRhVuHn+Nf/nll1rXQ5NevXrh4cOH5T6UVDPQasPtNvr27QsA5f5z9CQV/b08PnPv6aefhpubG7Zt26Y2u+v69es4ffp0FWqs2fPPPw8A5f62du/ejaKioho7jrZ0eZ3o8vrTRkFBAQYPHozU1FR89913Gv8zI5PJYGFhofYfmb///hv/+te/ypXVthdUl/fb2oA9ULXcxYsXpT/eu3fvYu/evThy5AgGDx4MLy8vAKX3x9myZQv69euHKVOm4JlnnoGlpSVu3ryJ2NhYDBo0CIMHD8bq1atx/Phx9O/fH02bNkVeXp40bf6FF14AUNpb5eHhgX//+9/o1asXHB0d4ezs/MS71I4ZMwZvvfUW0tPT4e/vXy60vfjii5g7dy5mz56NgIAA/Pbbb4iMjISXl9cT35z69esHR0dHjB07FpGRkbCwsEBMTAxu3LihVs7T0xORkZH46KOPcO3aNemeWbdu3cLPP/8MW1tbacaULqKiotC7d2/06NED7777LuRyOVauXImLFy9i27Zt0puXtvXUxccff4z9+/ejZ8+emDVrFmxsbPDFF18gNzdX633I5XIsXboUDx8+RJcuXXD69GnMmzcPffv2xXPPPQcAePbZZ/Hmm29i9OjRSEhIwPPPPw9bW1tkZGTg5MmTaNeuHd5+++0qnwcAnDt3Tvpf7K1bt7Bhwwb85z//wbRp06T/wT777LNYtmwZpk6diueeew5hYWFo2rSpdCPNM2fOYNmyZTqNfVFRhcDPPvsMISEhsLS0xNNPP10jr5uWLVuiWbNm+OCDDyCEgKOjIw4cOIAjR45oXY+yPcUqb7zxBr744guEhIQgNTUV7dq1w8mTJ7FgwQL069dP+rs1pu7du+P111/HvHnzcOvWLbz44otQKBRITEyEjY2NNOvwcUqlEi+88AKioqLQoEEDeHh44NixY9JsWBUzMzPMnTsX48aNw+DBgzF+/Hjcv38fERERNXrZsE2bNnjttdewdOlSmJubo2fPnrh06RKWLl0Ke3v7Kg0BqA5d3ot1ef1pY9q0aTh+/DgWLFiAhw8f4qeffpK2ubi4oFmzZujfvz+io6MxYsQIvPnmm7h79y6WLFmisQe7Xbt22L59O3bs2AFvb29YWVlV+J8ybd9vawW9D1OnKtE0C8/e3l74+PiI6OhokZeXp1a+sLBQLFmyRHTo0EFYWVmJevXqiZYtW4q33npL/P7770KI0plWgwcPFh4eHkKhUAgnJycREBAg9u/fr7avo0ePio4dOwqFQqH17JPs7GxhbW0tAIi1a9eW256fny/effdd0ahRI2FlZSU6deok9u3bp3H2BzTMPPn555+Fv7+/sLW1FY0aNRKzZ88W69at0zgTZd++faJHjx7Czs5OKBQK4eHhIYYOHSqOHj1a6TlUNAtPiNJZKD179hS2trbC2tpadOvWTRw4cKBcOW3r6eHhIfr371/u+Y/PxBFCiFOnTolu3boJhUIhlEql+L//+z+xZs0arWfh2draivPnz4vAwEBhbW0tHB0dxdtvvy0ePnxYrvyGDRtE165dpfNs1qyZeOONN0RCQoJaHdu0aVPpccvSNAvP0dFRdO3aVWzYsEEUFxeXe058fLwYOnSocHV1FRYWFqJhw4ZiyJAh4vTp01odU9PsHiGEmDFjhnB3dxdmZmblZoBp87pRtacmycnJonfv3qJ+/fqiQYMG4pVXXhFpaWkaX88V1UPT7//u3btiwoQJws3NTVhYWAgPDw8xY8aMcu8BAMSkSZPK1cvDw+OJf8OVzcK7ffu2WllNs7iKi4vFp59+Ktq2bSvkcrmwt7cXfn5+an8jms4tIyNDDB06VDg6Ogp7e3sxatQokZCQoPF3t27dOvHUU08JuVwuWrRoITZs2KDV+4eqvmfPnlUrp2kWYF5enggPDxcNGzYUVlZWolu3biI+Pl7Y29uLadOmVdqG1T22pvap6L1Y0+9A29efNrPwVDNtNS1lX0sbNmwQTz/9tFAoFMLb21tERUWJ9evXl9t/amqqCAoKEvXr1xcApGNV9HeqzfutLm2rLzIhyvSJElGdEhoait27d+Phw4fGrgqRSTp9+jSeffZZbNmyRe3+e0S8hEdERITSu3nHx8ejc+fOsLa2xq+//oqFCxfiqaee0njjUvpnY4AiIiICYGdnh8OHD2PZsmV48OABnJ2d0bdvX0RFRanNNCMCAF7CIyIiItIRb2NAREREpCMGKCIiIiIdMUARERER6YiDyPWgpKQE6enpqF+/fu266RcRERFVSAiBBw8ewN3d/Yk3T2WA0oP09HQ0adLE2NUgIiKiKrhx44bGr7ApiwFKD1RfyXDjxo1y39pOREREtVNOTg6aNGmi8auVHscApQeqy3Z2dnYMUERERCZGm+E3HEROREREpCMGKCIiIiIdMUBVYuXKlfDy8oKVlRU6d+6MH3/80dhVIiIiolqAAaoCO3bswNSpU/HRRx8hMTER3bt3R9++fZGWlmbsqhEREZGR8bvwKtC1a1d06tQJq1atkta1atUKL730EqKioip9bk5ODuzt7ZGdnc1B5ERERCZCl89v9kBpUFBQgHPnziEoKEhtfVBQEE6fPl2ufH5+PnJyctQWIiIiqrsYoDS4c+cOiouL4erqqrbe1dUVmZmZ5cpHRUXB3t5eWngTTSIiorqNAaoSj98HQgih8d4QM2bMQHZ2trTcuHHDUFUkIiIiI+CNNDVwdnaGubl5ud6mrKyscr1SAKBQKKBQKAxVPSIiIjIy9kBpIJfL0blzZxw5ckRt/ZEjR+Dv72+kWhEREVFtwR6oCoSHh+P111+Hr68v/Pz8sGbNGqSlpWHChAnGrhoREREZGXugKjBs2DAsW7YMkZGR8PHxwQ8//IBvv/0WHh4exq4a0T/azZs3ERsbi5s3b1arTE3uy5BlamOdWO/aV6Y21snQ9dY7QTUuOztbABDZ2dnGrgpRnbJu3TphZmYmAAgzMzPxySefiNTUVLXlk08+eWIZbcvVtjK1sU6sd+0rUxvrpM96r1u3rsbeY3T5/OaNNPWAN9IkqnlJSUno1KkT+JZFRGWZm5sjNTUVjRs3rva+dPn85hgoIqrVEhMTsXz5cmzZskVjeLK0tIS5uTkAoLi4GIWFhZWW0bZcbStTG+vEete+MrWxTvqud3FxMf74448aCVA6qbF+L5LwEp6JuHFDiOPHS/+tsMgNcfz4cXHDAGUMfbzaXO+UlBSxa9cu0b17dwGgwsXc3Fxtfzdu3JC69isqo2252lamNtaJ9a59ZWpjnQxd7+rQ5fObAUoPGKBMwLp1QpiZCQGIEjMzUbh6tcjPz1dbVq1apXadfd68eeK3335TW+bNm1cjZWpyX4Yso6/jlV0sLCzE8OHDRXx8vFi7dq0wNzeX3jQ1jX1Yt27dE8toW662lamNdWK9a1+Z2lgnQ9e7qjgGysg4BqoWKy4GvvoKGDNGbXWJTIZlU6figb09ACA7OxvLli3jeBsje+edd/D++++jUaNG0rqbN2/ijz/+QPPmzSvsstemTE3uy5BlamOdWO/aV6Y21snQ9a4KXT6/GaD0gAGqFrp1C1i/HvjySyAtTWORmJAQXPfyAgCkpKRg06ZN5crY2trCwqJ06GBRURFyc3OrXaYm92XIMoY4XmxsLAIDA8utJyLSB50+v2us34skRr+Ep8XYHq3K1OS+DFlGVe7YMSF27xbitdeEsLQUAihdHByEkMn+9xgQJebmIv/qVeny3dWrV03y2r+pjlnQ97gGIiJtcAyUkRk1QJUZ2yNkMiHGjxdiyxb1Zfz4/wWIispoW662lXm8XNmla1chNm0S4tGj0nYyNy9db25e+rhcU5rmtf+6XG8iIn3iGCgjM9olvJs3AQ8PoKTEcMc0BTIZcPAg0Lev+vqbN4E//gCaNwfq2LX/ulxvIiJ94RgoIzNagIqNBXr2LL++UyegQYPSn//6C0hMrLyMtuVqW5nKysXGAhxLQ0RElWCAMrJa1QNlbg6kpv6vh0WbMjW5L0OW0aUcERHRY3T5/OaXCdcljRsDa9b877G5eemss7LBQVVGdfdXTWW0LVfbyuhSjoiIqBrYA6UHRr2NgRCA2X9zcWIi4OOjuZwW43+0LlfbyuhSjoiI6L94Cc/IjBqg8vIAa+vSn+/fB/57Y0giIiKqHC/h/ZPl5//vZ4XCePUgIiKqwxig6pqyAUouN149iIiI6jAGqLpGFaDk8v+NhSIiIqIaxU/YukYVoHj5joiISG8YoOqavLzSfxmgiIiI9IYBqq5hDxQREZHeMUDVNQxQREREescAVdeoApSVlXHrQUREVIcxQNU17IEiIiLSOwaouoYBioiISO8YoOoazsIjIiLSOwaouoY9UERERHrHAFXXMEARERHpHQNUXcNZeERERHrHAFXXsAeKiIhI7xig6hoGKCIiIr1jgKprOAuPiIhI7xig6hr2QBEREekdA1RdwwBFRESkdwxQdQ1n4REREeldnQlQqampGDt2LLy8vGBtbY1mzZph9uzZKCgoUCsnk8nKLatXr1Yrc+HCBQQEBMDa2hqNGjVCZGQkhBCGPJ2qYw8UERGR3lkYuwI15T//+Q9KSkrw5Zdfonnz5rh48SLGjx+P3NxcLFmyRK3sxo0b0adPH+mxvb299HNOTg569+6NHj164OzZs7hy5QpCQ0Nha2uL6dOnG+x8qoyDyImIiPSuzgSoPn36qIUib29v/Pbbb1i1alW5AOXg4AClUqlxP1u2bEFeXh5iYmKgUCjQtm1bXLlyBdHR0QgPD4dMJtPreVQbe6CIiIj0rs5cwtMkOzsbjo6O5daHhYXB2dkZXbp0werVq1FSUiJti4+PR0BAABRlAkhwcDDS09ORmpqq8Tj5+fnIyclRW4yGAYqIiEjv6myAunr1Kj7//HNMmDBBbf3cuXOxa9cuHD16FMOHD8f06dOxYMECaXtmZiZcXV3VnqN6nJmZqfFYUVFRsLe3l5YmTZrU8NnogIPIiYiI9K7WB6iIiAiNA7/LLgkJCWrPSU9PR58+ffDKK69g3Lhxats+/vhj+Pn5wcfHB9OnT0dkZCQWL16sVubxy3SqAeQVXb6bMWMGsrOzpeXGjRvVPe2qYw8UERGR3tX6MVBhYWEYPnx4pWU8PT2ln9PT09GjRw/4+flhzZo1T9x/t27dkJOTg1u3bsHV1RVKpbJcT1NWVhYAlOuZUlEoFGqX/IyKAYqIiEjvan2AcnZ2hrOzs1Zl//zzT/To0QOdO3fGxo0bYWb25A62xMREWFlZwcHBAQDg5+eHDz/8EAUFBZDL5QCAw4cPw93dXS2o1VqchUdERKR3tf4SnrbS09MRGBiIJk2aYMmSJbh9+zYyMzPVepMOHDiAtWvX4uLFi7h69SrWrVuHjz76CG+++abUgzRixAgoFAqEhobi4sWL+Prrr7FgwQLTmIEHsAeKiIjIAGp9D5S2Dh8+jD/++AN//PEHGjdurLZNNYbJ0tISK1euRHh4OEpKSuDt7Y3IyEhMmjRJKmtvb48jR45g0qRJ8PX1RYMGDRAeHo7w8HCDnk+VMUARERHpnUyYzC22TUdOTg7s7e2RnZ0NOzs7wx7c3R3IyAASEwEfH8Mem4iIyITp8vldZy7h0X+xB4qIiEjvGKDqGgYoIiIivWOAqms4C4+IiEjvGKDqkuLi0gVggCIiItIjBqi6RHX5DmCAIiIi0iMGqLqkbIDid+ERERHpDQNUXaIKUDIZYFFnbvFFRERU6zBA1SVlB5Cbwl3TiYiITBQDVF3CWxgQEREZBANUXcIARUREZBAMUHWJKkBxADkREZFeMUDVJeyBIiIiMggGqLqEAYqIiMggGKDqEn6NCxERkUEwQNUl7IEiIiIyCAaouoQBioiIyCAYoOoSzsIjIiIyCAaouoQ9UERERAbBAFWXMEAREREZBANUXcJZeERERAbBAFWXsAeKiIjIIBig6hIOIiciIjIIBqi6hD1QREREBsEAVZcwQBERERkEA1RdwkHkREREBsEAVZewB4qIiMggGKDqEgYoIiIig2CAqks4C4+IiMggGKDqEvZAERERGQQDVF3CAEVERGQQDFB1CWfhERERGQQDVF3CHigiIiKDYICqSxigiIiIDIIBqi7hLDwiIiKDqFMBytPTEzKZTG354IMP1MqkpaVhwIABsLW1hbOzMyZPnoyCggK1MhcuXEBAQACsra3RqFEjREZGQghhyFOpGvZAERERGYSFsStQ0yIjIzF+/Hjpcb169aSfi4uL0b9/f7i4uODkyZO4e/cuQkJCIITA559/DgDIyclB79690aNHD5w9exZXrlxBaGgobG1tMX36dIOfj04YoIiIiAyizgWo+vXrQ6lUatx2+PBhJCcn48aNG3B3dwcALF26FKGhoZg/fz7s7OywZcsW5OXlISYmBgqFAm3btsWVK1cQHR2N8PBwyGQyQ56ObjgLj4iIyCDq1CU8APjkk0/g5OQEHx8fzJ8/X+3yXHx8PNq2bSuFJwAIDg5Gfn4+zp07J5UJCAiAokwICQ4ORnp6OlJTUw12HlXCHigiIiKDqFM9UFOmTEGnTp3QoEED/Pzzz5gxYwZSUlKwbt06AEBmZiZcXV3VntOgQQPI5XJkZmZKZTw9PdXKqJ6TmZkJLy+vcsfNz89Hviq8oPQyoMEJwUHkREREBlLre6AiIiLKDQx/fElISAAATJs2DQEBAWjfvj3GjRuH1atXY/369bh79660P02X4IQQausfL6MaQF7R5buoqCjY29tLS5MmTap93jorKioNUQB7oIiIiPSs1vdAhYWFYfjw4ZWWebzHSKVbt24AgD/++ANOTk5QKpU4c+aMWpl79+6hsLBQ6mVSKpVSb5RKVlYWAJTrvVKZMWMGwsPDpcc5OTmGD1FlesAYoIiIiPSr1gcoZ2dnODs7V+m5iYmJAAA3NzcAgJ+fH+bPn4+MjAxp3eHDh6FQKNC5c2epzIcffoiCggLI5XKpjLu7e4VBTaFQqI2ZMgrVAHKAAYqIiEjPav0lPG3Fx8fj008/RVJSElJSUrBz50689dZbGDhwIJo2bQoACAoKQuvWrfH6668jMTERx44dw7vvvovx48fDzs4OADBixAgoFAqEhobi4sWL+Prrr7FgwYLaPwNP1QNlbl66EBERkd7U+h4obSkUCuzYsQNz5sxBfn4+PDw8MH78eLz33ntSGXNzcxw8eBATJ07Es88+C2tra4wYMQJLliyRytjb2+PIkSOYNGkSfH190aBBA4SHh6tdoquVOAOPiIjIYGTCJG6xbVpycnJgb2+P7OxsqWdL7y5fBlq3BhwdgTKD5omIiEg7unx+15lLeP947IEiIiIyGAaouoIBioiIyGAYoOoKfo0LERGRwTBA1RXsgSIiIjIYBqi6ggGKiIjIYBig6gp+Dx4REZHBMEDVFeyBIiIiMhgGqLqCAYqIiMhgGKDqCs7CIyIiMhgGqLqCPVBEREQGwwBVV3AQORERkcEwQNUV7IEiIiIyGAaouoIBioiIyGAYoOoKDiInIiIyGAaouoI9UERERAbDAFVXMEAREREZDANUXcFZeERERAbDAFVXsAeKiIjIYBig6goGKCIiIoNhgKorOAuPiIjIYBig6gr2QBERERkMA1RdwQBFRERkMAxQdQVn4RERERkMA1RdwR4oIiIig2GAqisYoIiIiAymygGqoKAAv/32G4qKimqyPlRVnIVHRERkMDoHqEePHmHs2LGwsbFBmzZtkJaWBgCYPHkyFi5cWOMVJC2xB4qIiMhgdA5QM2bMwK+//ooTJ07AqsyA5RdeeAE7duyo0cqRDjiInIiIyGAsdH3Cvn37sGPHDnTr1g0ymUxa37p1a1y9erVGK0c6YA8UERGRwejcA3X79m00bNiw3Prc3Fy1QEUGJARQUFD6MwMUERGR3ukcoLp06YKDBw9Kj1Whae3atfDz86u5mpH2VL1PAAMUERGRAeh8CS8qKgp9+vRBcnIyioqK8Nlnn+HSpUuIj49HXFycPupIT8IARUREZFA690D5+/vj1KlTePToEZo1a4bDhw/D1dUV8fHx6Ny5sz7qSE9SNkDJ5carBxER0T+Ezj1QANCuXTts2rSpputCVaUKUHI5YMZ7oxIREembzgFKdd+nijRt2rTKlaEq4gw8IiIig9K5u8LT0xNeXl4VLsZy4sQJyGQyjcvZs2elcpq2r169Wm1fFy5cQEBAAKytrdGoUSNERkZCCGHoU9IeAxQREZFB6dwDlZiYqPa4sLAQiYmJiI6Oxvz582usYrry9/dHRkaG2rqZM2fi6NGj8PX1VVu/ceNG9OnTR3psb28v/ZyTk4PevXujR48eOHv2LK5cuYLQ0FDY2tpi+vTp+j2JquLXuBARERmUzgGqQ4cO5db5+vrC3d0dixcvxpAhQ2qkYrqSy+VQKpXS48LCQuzfvx9hYWHl7k/l4OCgVrasLVu2IC8vDzExMVAoFGjbti2uXLmC6OhohIeH1857XbEHioiIyKBqbMRxixYt1C6VGdv+/ftx584dhIaGltsWFhYGZ2dndOnSBatXr0ZJSYm0LT4+HgEBAVCUCSPBwcFIT09HamqqxmPl5+cjJydHbTEofo0LERGRQencA/V4OBBCICMjAxEREXjqqadqrGLVtX79egQHB6NJkyZq6+fOnYtevXrB2toax44dw/Tp03Hnzh18/PHHAIDMzEx4enqqPcfV1VXapmmcV1RUFObMmaOfE9EGe6CIiIgMSucA5eDgUO4ylhACTZo0wfbt22usYioRERFPDCdnz55VG+d08+ZNfP/999i5c2e5sqqgBAA+Pj4AgMjISLX1ms5P03qVGTNmIDw8XHqck5NTLrjpFQMUERGRQekcoGJjY9Uem5mZwcXFBc2bN4eFRZVuK1WpsLAwDB8+vNIyj/cYbdy4EU5OThg4cOAT99+tWzfk5OTg1q1bcHV1hVKpRGZmplqZrKwsAP/riXqcQqFQu+RncAxQREREBqVz4gkICNBHPSrk7OwMZ2dnrcsLIbBx40a88cYbsLS0fGL5xMREWFlZwcHBAQDg5+eHDz/8EAUFBZD/967ehw8fhru7e7mgVmtwFh4REZFBaRWg9u/fr/UOten10afjx48jJSUFY8eOLbftwIEDyMzMhJ+fH6ytrREbG4uPPvoIb775ptSDNGLECMyZMwehoaH48MMP8fvvv2PBggWYNWtW7ZyBB7AHioiIyMC0ClAvvfSSVjuTyWQoLi6uTn2qbf369fD390erVq3KbbO0tMTKlSsRHh6OkpISeHt7IzIyEpMmTZLK2Nvb48iRI5g0aRJ8fX3RoEEDhIeHq41xqnU4C4+IiMigtApQZaf513Zbt26tcFufPn3UbqBZkXbt2uGHH36oyWrpF3ugiIiIDIrfPFsXMEAREREZVJWmzeXm5iIuLg5paWkoKChQ2zZ58uQaqRjpgIPIiYiIDKpK34XXr18/PHr0CLm5uXB0dMSdO3dgY2ODhg0bMkAZA3ugiIiIDErnS3jTpk3DgAED8Ndff8Ha2ho//fQTrl+/js6dO2PJkiX6qCM9CQMUERGRQekcoJKSkjB9+nSYm5vD3Nwc+fn5aNKkCRYtWoQPP/xQH3WkJ+EsPCIiIoPSOUBZWlpK90NydXVFWloagNLp/6qfycDYA0VERGRQOo+B6tixIxISEtCiRQv06NEDs2bNwp07d/Cvf/0L7dq100cd6UkYoIiIiAxK5x6oBQsWwM3NDQAwd+5cODk54e2330ZWVhbWrFlT4xUkLXAWHhERkUHp3APl6+sr/ezi4oJvv/22RitEVcAeKCIiIoPSuQdqzpw5uHr1qj7qQlXFQeREREQGpXOA2rNnD1q0aIFu3bphxYoVuH37tj7qRbpgDxQREZFB6Rygzp8/j/Pnz6Nnz56Ijo5Go0aN0K9fP2zduhWPHj3SRx3pSRigiIiIDKpK34XXpk0bLFiwANeuXUNsbCy8vLwwdepUKJXKmq4faYMBioiIyKCq/WXCtra2sLa2hlwuR2FhYU3UiXTFWXhEREQGVaUAlZKSgvnz56N169bw9fXFL7/8goiICGRmZtZ0/Ugb7IEiIiIyKJ1vY+Dn54eff/4Z7dq1w+jRozFixAg0atRIH3UjbXEWHhERkUHpHKB69OiBdevWoU2bNvqoD1UFe6CIiIgMSucAtWDBAn3Ug6qDAYqIiMigqj2InGoBDiInIiIyKAYoU1dcXLoADFBEREQGwgBl6lSX7wAGKCIiIgNhgDJ1ZQMUZ+EREREZhM6DyAEgLy8P58+fR1ZWFkpKStS2DRw4sEYqRlpSBSiZDLCo0q+TiIiIdKTzJ+6hQ4fwxhtv4M6dO+W2yWQyFKvG45BhlJ2BJ5MZty5ERET/EDpfwgsLC8Mrr7yCjIwMlJSUqC0MT0bAGXhEREQGp3OAysrKQnh4OFxdXfVRH9IV7wFFRERkcDoHqKFDh+LEiRN6qApVCb/GhYiIyOB0HgO1YsUKvPLKK/jxxx/Rrl07WFpaqm2fPHlyjVWOtMAeKCIiIoPTOUBt3boV33//PaytrXHixAnIygxclslkDFCGxgBFRERkcDoHqI8//hiRkZH44IMPYGbG20gZHQMUERGRwemcgAoKCjBs2DCGp9qCs/CIiIgMTucUFBISgh07duijLlQV7IEiIiIyOJ0v4RUXF2PRokX4/vvv0b59+3KDyKOjo2uscqQFzsIjIiIyOJ0D1IULF9CxY0cAwMWLF9W2yXgnbMNjDxQREZHB6XwJLzY2tsLl+PHj+qgjAGD+/Pnw9/eHjY0NHBwcNJZJS0vDgAEDYGtrC2dnZ0yePBkFBQVqZS5cuICAgABYW1ujUaNGiIyMhBBCrUxcXBw6d+4MKysreHt7Y/Xq1fo6repjgCIiIjI4k/n22YKCArzyyivw8/PD+vXry20vLi5G//794eLigpMnT+Lu3bsICQmBEAKff/45ACAnJwe9e/dGjx49cPbsWVy5cgWhoaGwtbXF9OnTAQApKSno168fxo8fj82bN+PUqVOYOHEiXFxc8PLLLxv0nLXCQeREREQGp3OA6tGjR6WX6vTVCzVnzhwAQExMjMbthw8fRnJyMm7cuAF3d3cAwNKlSxEaGor58+fDzs4OW7ZsQV5eHmJiYqBQKNC2bVtcuXIF0dHRCA8Ph0wmw+rVq9G0aVMsW7YMANCqVSskJCRgyZIltTNAsQeKiIjI4HS+hOfj44MOHTpIS+vWrVFQUIBffvkF7dq100cdtRIfH4+2bdtK4QkAgoODkZ+fj3PnzkllAgICoCgTNoKDg5Geno7U1FSpTFBQkNq+g4ODkZCQgMLCQo3Hzs/PR05OjtpiMAxQREREBqdzD9Snn36qcX1ERAQePnxY7QpVVWZmZrkvOG7QoAHkcjkyMzOlMp6enmplVM/JzMyEl5eXxv24urqiqKgId+7cgZubW7ljR0VFST1kBsdZeERERAZXY3fDHDVqFDZs2KDTcyIiIiCTySpdEhIStN6fpkuLQohyXzfz+PbH12tTpqwZM2YgOztbWm7cuKF1nauNPVBEREQGV2ODyOPj42GlYy9IWFgYhg8fXmmZx3uMKqJUKnHmzBm1dffu3UNhYaHUo6RUKqXeKJWsrCwAeGIZCwsLODk5aTy2QqFQuyxoUAxQREREBqdzgBoyZIjaYyEEMjIykJCQgJkzZ+q0L2dnZzg7O+taBY38/Pwwf/58ZGRkSJfZDh8+DIVCgc6dO0tlPvzwQxQUFEAul0tl3N3dpaDm5+eHAwcOqO378OHD8PX1LXfT0FqBs/CIiIgMTudLePb29mqLo6MjAgMD8e2332L27Nn6qCOA0ns8JSUlIS0tDcXFxUhKSkJSUpI07iooKAitW7fG66+/jsTERBw7dgzvvvsuxo8fDzs7OwDAiBEjoFAoEBoaiosXL+Lrr7/GggULpBl4ADBhwgRcv34d4eHhuHz5MjZs2ID169fj3Xff1du5VQt7oIiIiAxPmIiQkBABoNwSGxsrlbl+/bro37+/sLa2Fo6OjiIsLEzk5eWp7ef8+fOie/fuQqFQCKVSKSIiIkRJSYlamRMnToiOHTsKuVwuPD09xapVq3Sqa3Z2tgAgsrOzq3y+WnvpJSEAIVav1v+xiIiI6jBdPr9lQjx2G24dPHz4ECUlJWrrVL09/2Q5OTmwt7dHdna2/tujXz/gu++AjRuB0FD9HouIiKgO0+XzW+dLeCkpKejfvz9sbW1hb2+PBg0aoEGDBnBwcECDBg2qXGmqIl7CIyIiMjidB5GPHDkSALBhwwa4urryC4SNjQGKiIjI4HQOUOfPn8e5c+fw9NNP66M+pCvOwiMiIjI4nS/hdenSxbA3iqTKsQeKiIjI4HTugVq3bh0mTJiAP//8E23bti13b6T27dvXWOVIC/wqFyIiIoPTOUDdvn0bV69exejRo6V1MplM+sqU4uLiGq0gPQF7oIiIiAxO5wA1ZswYdOzYEdu2beMg8tqAAYqIiMjgdA5Q169fx/79+9G8eXN91Id0xUHkREREBqfzIPKePXvi119/1UddqCrYA0VERGRwOvdADRgwANOmTcOFCxfQrl27coPIBw4cWGOVoycQggGKiIjICHT+Khczs4o7rTiIvJTBvsqlsBCQy0t//usvgHeCJyIiqjJdPr917oF6/LvvyIhUvU8Ae6CIiIgMSOcxUFSLMEAREREZhVY9UMuXL8ebb74JKysrLF++vNKykydPrpGKkRZUM/DMzUsXIiIiMgitxkB5eXkhISEBTk5O8PLyqnhnMhmuXbtWoxU0RQYbA3XtGtCsGWBjA+Tm6u84RERE/wA1PgYqJSVF489kZPwaFyIiIqPQeQzU33//XeG2jIyMalWGdMRbGBARERmFzgGqY8eO+OWXX8qt3717N79I2NAYoIiIiIxC5wDVu3dv+Pv7Y+HChRBC4OHDhwgNDUVISAhmzZqljzpSRRigiIiIjELn+0B9/vnn6N+/P0aPHo2DBw8iPT0ddnZ2OHv2LFq3bq2POlJF+D14RERERqFzgAKAoKAgDBkyBKtWrYKFhQUOHDjA8GQM7IEiIiIyCp0v4V29ehV+fn745ptv8P333+O9997DoEGD8N5776GwsFAfdaSKcBYeERGRUegcoHx8fODl5YVff/0VvXv3xrx583D8+HHs3bsXzzzzjD7qSBVhDxQREZFR6BygVq5cie3bt8PBwUFa5+/vj8TERHTq1Kkm60ZPwgBFRERkFDoHqNdff13j+vr162P9+vXVrhDpgIPIiYiIjKJKg8gBIDk5GWlpaSgoKJDWyWQyDBgwoEYqRlpgDxQREZFR6Bygrl27hsGDB+PChQuQyWRQfZWeTCYDABQXF9dsDaliHERORERkFDpfwpsyZQq8vLxw69Yt2NjY4NKlS/jhhx/g6+uLEydO6KGKVCH2QBERERmFzj1Q8fHxOH78OFxcXGBmZgYzMzM899xziIqKwuTJk5GYmKiPepImDFBERERGoXMPVHFxMerVqwcAcHZ2Rnp6OgDAw8MDv/32W83WjirHAEVERGQUOvdAtW3bFufPn4e3tze6du2KRYsWQS6XY82aNfD29tZHHakinIVHRERkFDoHqI8//hi5ubkAgHnz5uHFF19E9+7d4eTkhB07dtR4BakS7IEiIiIyCp0DVHBwsPSzt7c3kpOT8ddff6FBgwbSTDwyEM7CIyIiMooq3weqLEdHx5rYDemKPVBERERGoXWAGjNmjFblNmzYUOXKVGb+/Pk4ePAgkpKSIJfLcf/+fbXtv/76KxYuXIiTJ0/izp078PT0xIQJEzBlyhSpTGpqKry8vMrt+7vvvkOfPn2kx3FxcQgPD8elS5fg7u6O9957DxMmTNDLeVULAxQREZFRaB2gYmJi4OHhgY4dO0o3zzSkgoICvPLKK/Dz89P4lTHnzp2Di4sLNm/ejCZNmuD06dN48803YW5ujrCwMLWyR48eRZs2baTHZXvQUlJS0K9fP4wfPx6bN2/GqVOnMHHiRLi4uODll1/W3wlWBQMUERGRUWgdoCZMmIDt27fj2rVrGDNmDEaNGmXQS3dz5swBUBrkNHm8h8zb2xvx8fHYu3dvuQDl5OQEpVKpcT+rV69G06ZNsWzZMgBAq1atkJCQgCVLltS+AMVZeEREREah9X2gVq5ciYyMDLz//vs4cOAAmjRpgldffRXff/+9UXqktJGdna0x5A0cOBANGzbEs88+i927d6tti4+PR1BQkNq64OBgJCQkoLCwUK/11Rl7oIiIiIxCpxtpKhQKvPbaazhy5AiSk5PRpk0bTJw4ER4eHnj48KG+6lgl8fHx2LlzJ9566y1pXb169RAdHY3du3fj22+/Ra9evTBs2DBs3rxZKpOZmQlXV1e1fbm6uqKoqAh37tzReKz8/Hzk5OSoLQbBWXhERERGofOdyFVkMpn0ZcIlJSVV2kdERIS0n4qWhIQEnfd76dIlDBo0CLNmzULv3r2l9c7Ozpg2bRqeeeYZ+Pr6IjIyEhMnTsSiRYvKnVtZj39h8uOioqJgb28vLU2aNNG5zlXCHigiIiKj0ClA5efnY9u2bejduzeefvppXLhwAStWrEBaWpr09S66CAsLw+XLlytd2rZtq9M+k5OT0bNnT4wfPx4ff/zxE8t369YNv//+u/RYqVQiMzNTrUxWVhYsLCzg5OSkcR8zZsxAdna2tNy4cUOnOlcZAxQREZFRaD2IfOLEidi+fTuaNm2K0aNHY/v27RUGCm05OzvD2dm5Wvso69KlS+jZsydCQkIwf/58rZ6TmJgINzc36bGfnx8OHDigVubw4cPw9fWFpaWlxn0oFAoojBFiOIiciIjIKLQOUKrZaV5eXoiLi0NcXJzGcnv37q2xypWVlpaGv/76C2lpaSguLkZSUhIAoHnz5qhXrx4uXbqEHj16ICgoCOHh4VIvkrm5OVxcXAAAmzZtgqWlJTp27AgzMzMcOHAAy5cvxyeffCIdZ8KECVixYgXCw8Mxfvx4xMfHY/369di2bZtezqta2ANFRERkFFoHqDfeeMOoX9Uya9YsbNq0SXrcsWNHAEBsbCwCAwOxa9cu3L59G1u2bMGWLVukch4eHkhNTZUez5s3D9evX4e5uTlatGiBDRs2YNSoUdJ2Ly8vfPvtt5g2bRq++OILuLu7Y/ny5bXvFgYAB5ETEREZiUzU1nsQmLCcnBzY29sjOzsbdnZ2+juQQgEUFABpaYChBq4TERHVUbp8fld5Fh4ZmRCl4QngJTwiIiIDY4AyVarwBDBAERERGRgDlKlSzcADGKCIiIgMjAHKVKkGkAOAXG68ehAREf0DMUCZKlWAkssBM/4aiYiIDImfvKaK94AiIiIyGgYoU8UARUREZDQMUKaKAYqIiMhoGKBMFb8Hj4iIyGgYoEwVe6CIiIiMhgHKVPF78IiIiIyGAcpUsQeKiIjIaBigTBUDFBERkdEwQJkqDiInIiIyGgYoU8UeKCIiIqNhgDJVHERORERkNAxQpoo9UEREREbDAGWqGKCIiIiMhgHKVDFAERERGQ0DlKniLDwiIiKjYYAyVeyBIiIiMhoGKFPFWXhERERGwwBlqtgDRUREZDQMUKaKAYqIiMhoGKBMFQMUERGR0TBAmSrOwiMiIjIaBihTxR4oIiIio2GAMlWchUdERGQ0DFCmij1QRERERsMAZaoYoIiIiIyGAcpUcRA5ERGR0TBAmSr2QBERERkNA5Sp4iByIiIio2GAMlXsgSIiIjIaBihTxQBFRERkNCYToObPnw9/f3/Y2NjAwcFBYxmZTFZuWb16tVqZCxcuICAgANbW1mjUqBEiIyMhhFArExcXh86dO8PKygre3t7l9lErMEAREREZjYWxK6CtgoICvPLKK/Dz88P69esrLLdx40b06dNHemxvby/9nJOTg969e6NHjx44e/Ysrly5gtDQUNja2mL69OkAgJSUFPTr1w/jx4/H5s2bcerUKUycOBEuLi54+eWX9XeCuiguBoqKSn9mgCIiIjI4kwlQc+bMAQDExMRUWs7BwQFKpVLjti1btiAvLw8xMTFQKBRo27Ytrly5gujoaISHh0s9Vk2bNsWyZcsAAK1atUJCQgKWLFlSewKUqvcJYIAiIiIyApO5hKetsLAwODs7o0uXLli9ejVKSkqkbfHx8QgICICiTOgIDg5Geno6UlNTpTJBQUFq+wwODkZCQgIKCws1HjM/Px85OTlqi16VDVCchUdERGRwdSpAzZ07F7t27cLRo0cxfPhwTJ8+HQsWLJC2Z2ZmwtXVVe05qseZmZmVlikqKsKdO3c0HjcqKgr29vbS0qRJk5o8rfJUAUomAyxMphORiIiozjBqgIqIiNA48LvskpCQoPX+Pv74Y/j5+cHHxwfTp09HZGQkFi9erFZGJpOpPVYNIC+7XpsyZc2YMQPZ2dnScuPGDa3rXCVlB5BXUCciIiLSH6N2X4SFhWH48OGVlvH09Kzy/rt164acnBzcunULrq6uUCqVUk+TSlZWFoD/9URVVMbCwgJOTk4aj6NQKNQuC+odZ+AREREZlVEDlLOzM5ydnfW2/8TERFhZWUm3PfDz88OHH36IgoICyOVyAMDhw4fh7u4uBTU/Pz8cOHBAbT+HDx+Gr68vLC0t9VZXnfB78IiIiIzKZMZApaWlISkpCWlpaSguLkZSUhKSkpLw8OFDAMCBAwewdu1aXLx4EVevXsW6devw0Ucf4c0335R6h0aMGAGFQoHQ0FBcvHgRX3/9NRYsWCDNwAOACRMm4Pr16wgPD8fly5exYcMGrF+/Hu+++67Rzr0cfo0LERGRcQkTERISIgCUW2JjY4UQQnz33XfCx8dH1KtXT9jY2Ii2bduKZcuWicLCQrX9nD9/XnTv3l0oFAqhVCpFRESEKCkpUStz4sQJ0bFjRyGXy4Wnp6dYtWqVTnXNzs4WAER2dna1zrlCP/4oBCDEU0/pZ/9ERET/QLp8fsuEeOw23FRtOTk5sLe3R3Z2Nuzs7Gr+AMeOAS+8ALRtC1y4UPP7JyIi+gfS5fPbZC7hURkcRE5ERGRUDFCmiIPIiYiIjIoByhSxB4qIiMioGKBMEWfhERERGRUDlCliDxQREZFRMUCZIgYoIiIio2KAMkUMUEREREbFAGWKOAuPiIjIqBigTBF7oIiIiIyKAcoUcRYeERGRUTFAmSL2QBERERkVA5QpYoAiIiIyKgYoU8QARUREZFQMUKaIs/CIiIiMigHKFHEQORERkVExQJkiXsIjIiIyKgYoU8QARUREZFQMUKaIAYqIiMioGKBMEQeRExERGRUDlCliDxQREZFRMUCZIs7CIyIiMioGKFPEHigiIiKjYoAyRQxQRERERsUAZYoYoIiIiIyKAcoUcRYeERGRUTFAmRoh2ANFRERkZAxQpqaoqDREAZyFR0REZCQMUKZG1fsEsAeKiIjISCyMXQHSEQMUEZFBFBcXo7Cw0NjVoBoml8thZlb9/iMGKFOjClDm5qULERHVKCEEMjMzcf/+fWNXhfTAzMwMXl5ekMvl1doPA5Sp4Qw8IiK9UoWnhg0bwsbGBjKZzNhVohpSUlKC9PR0ZGRkoGnTptX63TJAmRp+jQsRkd4UFxdL4cnJycnY1SE9cHFxQXp6OoqKimBpaVnl/XAQuanhLQyIiPRGNebJxsbGyDUhfVFduisuLq7WfhigTA0DFBGR3vGyXd1VU79bkwlQ8+fPh7+/P2xsbODg4FBue0xMDGQymcYlKysLAJCamqpx+6FDh9T2FRcXh86dO8PKygre3t5YvXq1IU5ROwxQRERUA2QyGfbt22fw48bExGj8HDc1JjMGqqCgAK+88gr8/Pywfv36ctuHDRuGPn36qK0LDQ1FXl4eGjZsqLb+6NGjaNOmjfTY0dFR+jklJQX9+vXD+PHjsXnzZpw6dQoTJ06Ei4sLXn755Ro+qyrgIHIiInpMaGgo7t+/r1MgysjIQIMGDQCUdjB4eXkhMTERPj4++qlkHWMyAWrOnDkASpOrJtbW1rC2tpYe3759G8ePH9cYtpycnKBUKjXuZ/Xq1WjatCmWLVsGAGjVqhUSEhKwZMmS2hGg2ANFREQ1oKLPQdKOyVzC09VXX30FGxsbDB06tNy2gQMHomHDhnj22Wexe/dutW3x8fEICgpSWxccHIyEhIQKb6iWn5+PnJwctUVvOAuPiMg03LwJxMaW/mtggYGBmDx5Mt577z04OjpCqVQiIiJCrUzZS3heXl4AgI4dO0ImkyEwMLDcPktKStC4ceNyw1p++eUXyGQyXLt2DQAQHR2Ndu3awdbWFk2aNMHEiRPx8OHDCusaGhqKl156SW3d1KlT1eoghMCiRYvg7e0Na2trdOjQQe3z+969exg5ciRcXFxgbW2Np556Chs3bnxCK1VPnQ1QGzZswIgRI9R6perVq4fo6Gjs3r0b3377LXr16oVhw4Zh8+bNUpnMzEy4urqq7cvV1RVFRUW4c+eOxmNFRUXB3t5eWpo0aaKfkwLYA0VEZEhCALm5ui8rVwIeHkDPnqX/rlyp+z5U33taRZs2bYKtrS3OnDmDRYsWITIyEkeOHNFY9ueffwZQOsQlIyMDe/fuLVfGzMwMw4cPx5YtW9TWb926FX5+fvD29pbKLV++HBcvXsSmTZtw/PhxvPfee9U6l48//hgbN27EqlWrcOnSJUybNg2jRo1CXFwcAGDmzJlITk7Gd999h8uXL2PVqlVwdnau1jGfxKiX8CIiIqRLcxU5e/YsfH19ddpvfHw8kpOT8dVXX6mtd3Z2xrRp06THvr6+uHfvHhYtWoRRo0ZJ6x8foS/++yKuaOT+jBkzEB4eLj3OycnRX4higCIiMpxHj4B69aq3j5ISYNKk0kUXDx8CtrZVPmz79u0xe/ZsAMBTTz2FFStW4NixY+jdu3e5si4uLgAqH+ICACNHjkR0dDSuX78ODw8PlJSUYPv27fjwww+lMlOnTpV+9vLywty5c/H2229j5cqVVTqP3NxcREdH4/jx4/Dz8wMAeHt74+TJk/jyyy8REBCAtLQ0dOzYUcoLnp6eVTqWLowaoMLCwjB8+PBKy1SlEdatWwcfHx907tz5iWW7deuGdevWSY+VSiUyMzPVymRlZcHCwqLCm6opFAooDBVoGKCIiEgL7du3V3vs5uYmzUqvqo4dO6Jly5bYtm0bPvjgA8TFxSErKwuvvvqqVCY2NhYLFixAcnIycnJyUFRUhLy8POTm5sK2CoEwOTkZeXl55YJfQUEBOnbsCAB4++238fLLL+OXX35BUFAQXnrpJfj7+1frXJ/EqAHK2dm5xrvYHj58iJ07dyIqKkqr8omJiXBzc5Me+/n54cCBA2plDh8+DF9f32rdsbTGcBYeEZHh2NiU9gTp4s8/gVatSnueVMzNgeRkoFEj3Y5dDY9/ZslkMpSUrVMVjRw5Elu3bsUHH3yArVu3Ijg4WPosv379Ovr164cJEyZg7ty5cHR0xMmTJzF27NgKxxGbmZlJV3pUypZV1fngwYNo9Fj7qTov+vbti+vXr+PgwYM4evQoevXqhUmTJmHJkiXVPt+KmMwsvLS0NPz1119IS0tDcXExkpKSAADNmzdHvTLdqzt27EBRURFGjhxZbh+bNm2CpaUlOnbsCDMzMxw4cADLly/HJ598IpWZMGECVqxYgfDwcIwfPx7x8fFYv349tm3bpvdz1Ap7oIiIDEcm0/0yWosWwJo1wFtvAcXFpeHpyy9L19dSutyde8SIEfj4449x7tw57N69G6tWrZK2JSQkoKioCEuXLoWZWekw6507d1a6PxcXF1y8eFFtXVJSkhQAW7duDYVCgbS0NAQEBFS6n9DQUISGhqJ79+74v//7PwYoAJg1axY2bdokPVZ128XGxqqN1F+/fj2GDBki3dvicfPmzcP169dhbm6OFi1aYMOGDWrjn7y8vPDtt99i2rRp+OKLL+Du7o7ly5fXjlsYAJyFR0RkCsaOBYKDgT/+AJo3Bxo3NnaNKtWwYUNYW1vj0KFDaNy4MaysrGBvb6+xrJeXF/z9/TF27FgUFRVh0KBB0rZmzZqhqKgIn3/+OQYMGIBTp0498WbUPXv2xOLFi/HVV1/Bz88PmzdvxsWLF6XP+fr16+Pdd9/FtGnTUFJSgueeew45OTk4ffo06tWrh5CQEMyaNQudO3dGmzZtkJ+fj2+++QatWrWquQbSwGQCVExMTIX3gCrr9OnTFW4LCQlBSEjIE/cREBCAX375RZfqGQ57oIiITEPjxrU+OKlYWFhg+fLliIyMxKxZs9C9e3ecOHGiwvIjR47EpEmT8MYbb6jNdvfx8UF0dDQ++eQTzJgxA88//zyioqLwxhtvVLiv4OBgzJw5E++99x7y8vIwZswYvPHGG7hw4YJUZu7cuWjYsCGioqJw7do1ODg4oFOnTtLgdblcjhkzZiA1NRXW1tbo3r07tm/fXv2GqYRMPH7hkaotJycH9vb2yM7Ohp2dXc3ufPp0IDoaeO89oMylRyIiqr68vDykpKTAy8sLVuzpr5Mq+x3r8vldZ+8DVWexB4qIiMjoGKBMDWfhERERGR0DlKnhIHIiIiKjY4AyNbyER0REZHQMUKaGAYqIiMjoGKBMDQMUERGR0TFAmRoOIiciIjI6BihTwx4oIiIio2OAMjWchUdERGR0DFCmhj1QRERkgk6cOAGZTIb79+8buyo1ggHK1DBAERHRY0JDQyGTyaTFyckJffr0wfnz59XKFRcX49NPP0X79u1hZWUFBwcH9O3bF6dOnTJSzU0XA5SpYYAiIiIN+vTpg4yMDGRkZODYsWOwsLDAiy++KG0XQmD48OGIjIzE5MmTcfnyZcTFxaFJkyYIDAzEvn37jFd5E8QAZWo4C4+IyCTcvHkTsbGxuHnzpkGOp1AooFQqoVQq4ePjg/fffx83btzA7du3AQA7d+7E7t278dVXX2HcuHHw8vJChw4dsGbNGgwcOBDjxo1Dbm6uxn37+fnhgw8+UFt3+/ZtWFpaIjY2FgCwefNm+Pr6on79+lAqlRgxYgSysrIqrG9ERAR8fHzU1i1btgyenp5q6zZu3IhWrVrBysoKLVu2xMqVK6VtBQUFCAsLg5ubG6ysrODp6YmoqChtm6xaGKBMDXugiIgMRgiB3NxcnZeVK1fCw8MDPXv2hIeHB1auXKnzPoQQVa73w4cPsWXLFjRv3hxOTk4AgK1bt6JFixYYMGBAufLTp0/H3bt3ceTIEY37GzlyJLZt26ZWpx07dsDV1RUBAQEASsPM3Llz8euvv2Lfvn1ISUlBaGholc8BANauXYuPPvoI8+fPx+XLl7FgwQLMnDkTmzZtAgAsX74c+/fvx86dO/Hbb79h8+bN5QKYvlgY5ChUczgLj4jIYB49eoR69epVax8lJSWYNGkSJk2apNPzHj58CFtbW63Lf/PNN1Jdc3Nz4ebmhm+++QZmZqV9JVeuXEGrVq00Ple1/sqVKxq3Dxs2DNOmTcPJkyfRvXt3AKWBbMSIEdL+x4wZI5X39vbG8uXL8cwzz+Dhw4dVbsO5c+di6dKlGDJkCADAy8sLycnJ+PLLLxESEoK0tDQ89dRTeO655yCTyeDh4VGl41QFe6BMiRBAQUHpz+yBIiKiMnr06IGkpCQkJSXhzJkzCAoKQt++fXH9+nWt9yGTyTSud3FxQe/evbFlyxYAQEpKCuLj4zFy5EipTGJiIgYNGgQPDw/Ur18fgYGBAIC0tLQqnc/t27dx48YNjB07FvXq1ZOWefPm4erVqwBKB88nJSXh6aefxuTJk3H48OEqHasq2ANlSlThCQDu3AEaNjReXYiI/gFsbGzw8OFDnZ7z559/olWrVigpKZHWmZubIzk5GY0aNdLp2LqwtbVF8+bNpcedO3eGvb091q5di3nz5qFFixZITk7W+NzLly8DAJ566qkK9z9y5EhMmTIFn3/+ObZu3Yo2bdqgQ4cOAEp7vIKCghAUFITNmzfDxcUFaWlpCA4ORkHZz64yzMzMyl2mLCwslH5Wtd/atWvRtWtXtXLm5uYAgE6dOiElJQXfffcdjh49ildffRUvvPACdu/eXeF51BT2QJmStWv/93O7dsD69carCxHRP4BMJoOtra1OS4sWLbBmzRrpQ97c3BxffvklWrRoodN+KuoN0qXuZmZm+PvvvwEAw4cPx++//44DBw6UK7t06VI4OTmhd+/eFe7vpZdeQl5eHg4dOoStW7di1KhR0rb//Oc/uHPnDhYuXIju3bujZcuWlQ4gB0p7tTIzM9VCVFJSkvSzq6srGjVqhGvXrqF58+Zqi5eXl1TOzs4Ow4YNw9q1a7Fjxw7s2bMHf/311xPbp7rYA2Uqbt4Epkz53+OSEuCtt4DgYKBxY+PVi4iIyhk7diyCg4Pxxx9/oHnz5mhsgPfp/Px8ZGZmAgDu3buHFStW4OHDh9Kg8eHDh2PXrl0ICQnB4sWL0atXL+Tk5OCLL77A/v37sWvXrkrHXNna2mLQoEGYOXMmLl++jBEjRkjbmjZtCrlcjs8//xwTJkzAxYsXMXfu3ErrGxgYiNu3b2PRokUYOnQoDh06hO+++w52dnZSmYiICEyePBl2dnbo27cv8vPzkZCQgHv37iE8PByffvop3Nzc4OPjAzMzM+zatQtKpRIODg7VaEktCapx2dnZAoDIzs6uuZ0ePy5E6Sgo9SU2tuaOQUT0D/f333+L5ORk8ffffxu7KjoJCQkRAKSlfv36okuXLmL37t1q5QoLC8WSJUtEmzZthEKhEHZ2diI4OFj8+OOPWh3n4MGDAoB4/vnny23bunWr8PT0FAqFQvj5+Yn9+/cLACIxMVEIIURsbKwAIO7duyc9Z9WqVaJJkybC1tZWvPHGG2L+/PnCw8NDbb9btmwRPj4+Qi6XiwYNGojnn39e7N27VwghxJo1a4SPj4+wtbUVdnZ2olevXuKXX36p9Bwq+x3r8vktE6Ia8yRJo5ycHNjb2yM7O1stSVfLzZuAh0dpz5OKuTmQmsoeKCKiGpKXl4eUlBR4eXnBirOd66TKfse6fH5zDJSpaNwYWLOmNDQBpf9++SXDExERkRFwDJQpGTu2dMzTH38AzZszPBERERkJA5SpadyYwYmIiMjIeAmPiIiISEcMUEREREQ6YoAiIiJ6DCeo11019btlgCIiIvovS0tLAKVfIkx1k+qrZVR3iq8qDiInIiL6L3Nzczg4OEhfQ2JjY1Ptr1Sh2qOkpAS3b9+GjY0NLCyqF4EYoIiIiMpQKpUA8MTvciPTZGZmhqZNm1Y7GDNAERERlSGTyeDm5oaGDRuisLDQ2NWhGiaXy2FmVv0RTAxQREREGpibm1d7nAzVXRxETkRERKQjBigiIiIiHTFAEREREemIY6D0QHWTrpycHCPXhIiIiLSl+tzW5mabDFB68ODBAwBAkyZNjFwTIiIi0tWDBw9gb29faRmZ4P3qa1xJSQnS09NRv359ne4zkZOTgyZNmuDGjRuws7PTYw0JYHsbGtvbsNjehsX2Nix9tbcQAg8ePIC7u/sTb3XAHig9MDMzQ+PGjav8fDs7O/4BGhDb27DY3obF9jYstrdh6aO9n9TzpMJB5EREREQ6YoAiIiIi0hEDVC2iUCgwe/ZsKBQKY1flH4HtbVhsb8NiexsW29uwakN7cxA5ERERkY7YA0VERESkIwYoIiIiIh0xQBERERHpiAGKiIiISEcMULXEypUr4eXlBSsrK3Tu3Bk//vijsatUJ/zwww8YMGAA3N3dIZPJsG/fPrXtQghERETA3d0d1tbWCAwMxKVLl4xT2TogKioKXbp0Qf369dGwYUO89NJL+O2339TKsM1rzqpVq9C+fXvpZoJ+fn747rvvpO1sa/2KioqCTCbD1KlTpXVs85oTEREBmUymtiiVSmm7sduaAaoW2LFjB6ZOnYqPPvoIiYmJ6N69O/r27Yu0tDRjV83k5ebmokOHDlixYoXG7YsWLUJ0dDRWrFiBs2fPQqlUonfv3tL3GZJu4uLiMGnSJPz00084cuQIioqKEBQUhNzcXKkM27zmNG7cGAsXLkRCQgISEhLQs2dPDBo0SPoQYVvrz9mzZ7FmzRq0b99ebT3bvGa1adMGGRkZ0nLhwgVpm9HbWpDRPfPMM2LChAlq61q2bCk++OADI9WobgIgvv76a+lxSUmJUCqVYuHChdK6vLw8YW9vL1avXm2EGtY9WVlZAoCIi4sTQrDNDaFBgwZi3bp1bGs9evDggXjqqafEkSNHREBAgJgyZYoQgq/vmjZ79mzRoUMHjdtqQ1uzB8rICgoKcO7cOQQFBamtDwoKwunTp41Uq3+GlJQUZGZmqrW9QqFAQEAA276GZGdnAwAcHR0BsM31qbi4GNu3b0dubi78/PzY1no0adIk9O/fHy+88ILaerZ5zfv999/h7u4OLy8vDB8+HNeuXQNQO9qaXyZsZHfu3EFxcTFcXV3V1ru6uiIzM9NItfpnULWvpra/fv26MapUpwghEB4ejueeew5t27YFwDbXhwsXLsDPzw95eXmoV68evv76a7Ru3Vr6EGFb16zt27fjl19+wdmzZ8tt4+u7ZnXt2hVfffUVWrRogVu3bmHevHnw9/fHpUuXakVbM0DVEjKZTO2xEKLcOtIPtr1+hIWF4fz58zh58mS5bWzzmvP0008jKSkJ9+/fx549exASEoK4uDhpO9u65ty4cQNTpkzB4cOHYWVlVWE5tnnN6Nu3r/Rzu3bt4Ofnh2bNmmHTpk3o1q0bAOO2NS/hGZmzszPMzc3L9TZlZWWVS9ZUs1SzOdj2Ne+dd97B/v37ERsbi8aNG0vr2eY1Ty6Xo3nz5vD19UVUVBQ6dOiAzz77jG2tB+fOnUNWVhY6d+4MCwsLWFhYIC4uDsuXL4eFhYXUrmxz/bC1tUW7du3w+++/14rXNwOUkcnlcnTu3BlHjhxRW3/kyBH4+/sbqVb/DF5eXlAqlWptX1BQgLi4OLZ9FQkhEBYWhr179+L48ePw8vJS28421z8hBPLz89nWetCrVy9cuHABSUlJ0uLr64uRI0ciKSkJ3t7ebHM9ys/Px+XLl+Hm5lY7Xt8GGapOldq+fbuwtLQU69evF8nJyWLq1KnC1tZWpKamGrtqJu/BgwciMTFRJCYmCgAiOjpaJCYmiuvXrwshhFi4cKGwt7cXe/fuFRcuXBCvvfaacHNzEzk5OUauuWl6++23hb29vThx4oTIyMiQlkePHkll2OY1Z8aMGeKHH34QKSkp4vz58+LDDz8UZmZm4vDhw0IItrUhlJ2FJwTbvCZNnz5dnDhxQly7dk389NNP4sUXXxT169eXPhuN3dYMULXEF198ITw8PIRcLhedOnWSpn1T9cTGxgoA5ZaQkBAhROlU2NmzZwulUikUCoV4/vnnxYULF4xbaROmqa0BiI0bN0pl2OY1Z8yYMdL7houLi+jVq5cUnoRgWxvC4wGKbV5zhg0bJtzc3ISlpaVwd3cXQ4YMEZcuXZK2G7utZUIIYZi+LiIiIqK6gWOgiIiIiHTEAEVERESkIwYoIiIiIh0xQBERERHpiAGKiIiISEcMUEREREQ6YoAiIiIi0hEDFBFRLXHixAnIZDLcv3/f2FUhoidggCKiWic0NBQymUxanJyc0KdPH5w/f16tXHFxMT799FO0b98eVlZWcHBwQN++fXHq1KknHkMmk2Hfvn0AgNTUVMhkMiQlJenhbDQLDAzE1KlT1db5+/sjIyMD9vb2BqsHEVUNAxQR1Up9+vRBRkYGMjIycOzYMVhYWODFF1+UtgshMHz4cERGRmLy5Mm4fPky4uLi0KRJEwQGBkrhyNAKCwur/Fy5XA6lUgmZTFaDNSIifWCAIqJaSaFQQKlUQqlUwsfHB++//z5u3LiB27dvAwB27tyJ3bt346uvvsK4cePg5eWFDh06YM2aNRg4cCDGjRuH3NxcrY7l5eUFAOjYsSNkMhkCAwOlbRs3bkSrVq1gZWWFli1bYuXKldI2Vc/Vzp07ERgYCCsrK2zevBl3797Fa6+9hsaNG8PGxgbt2rXDtm3bpOeFhoYiLi4On332mdTLlpqaqvES3p49e9CmTRsoFAp4enpi6dKlanX39PTEggULMGbMGNSvXx9NmzbFmjVrdG1uItKVwb51j4hISyEhIWLQoEHS4wcPHoi33npLNG/eXBQXFwshhBg4cKBo0aKFxuefOnVKABBff/11hccou/3nn38WAMTRo0dFRkaGuHv3rhBCiDVr1gg3NzexZ88ece3aNbFnzx7h6OgoYmJihBBCpKSkCADC09NTKvPnn3+KmzdvisWLF4vExERx9epVsXz5cmFubi5++uknIYQQ9+/fF35+fmL8+PEiIyNDZGRkiKKiIunLr+/duyeEECIhIUGYmZmJyMhI8dtvv4mNGzcKa2trtS9n9vDwEI6OjuKLL74Qv//+u4iKihJmZmbi8uXLVWh5ItKWhVHTGxFRBb755hvUq1cPAJCbmws3Nzd88803MDMr7Ti/cuUKWrVqpfG5qvVXrlzR6lguLi4AACcnJyiVSmn93LlzsXTpUgwZMgRAaU9VcnIyvvzyS4SEhEjlpk6dKpVReffdd6Wf33nnHRw6dAi7du1C165dYW9vD7lcDhsbG7XjPS46Ohq9evXCzJkzAQAtWrRAcnIyFi9ejNDQUKlcv379MHHiRADA+++/j08//RQnTpxAy5YttTp/ItIdL+ERUa3Uo0cPJCUlISkpCWfOnEFQUBD69u2L69eva72P6owlun37Nm7cuIGxY8eiXr160jJv3jxcvXpVrayvr6/a4+LiYsyfPx/t27eHk5MT6tWrh8OHDyMtLU2nOly+fBnPPvus2rpnn30Wv//+O4qLi6V17du3l36WyWRQKpXIysrS6VhEpBv2QBFRrWRra4vmzZtLjzt37gx7e3usXbsW8+bNk3pjNLl8+TIA4Kmnnqry8UtKSgAAa9euRdeuXdW2mZubl6trWUuXLsWnn36KZcuWoV27drC1tcXUqVNRUFCgUx2EEOVCoBCiXDlLS0u1xzKZTKo/EekHe6CIyCTIZDKYmZnh77//BgAMHz4cv//+Ow4cOFCu7NKlS+Hk5ITevXtrtW+5XA4Aar06rq6uaNSoEa5du4bmzZurLapB5xX58ccfMWjQIIwaNQodOnSAt7c3fv/993LHLHs8TVq3bo2TJ0+qrTt9+jRatGhRLsQRkWGxB4qIaqX8/HxkZmYCAO7du4cVK1bg4cOHGDBgAIDSALVr1y6EhIRg8eLF6NWrF3JycvDFF19g//792LVrV7meoYo0bNgQ1tbWOHToEBo3bgwrKyvY29sjIiICkydPhp2dHfr27Yv8/HwkJCTg3r17CA8Pr3B/zZs3x549e3D69Gk0aNAA0dHRyMzMVBuz5enpiTNnziA1NRX16tWDo6Njuf1Mnz4dXbp0wdy5czFs2DDEx8djxYoVajMBicg42ANFRLXSoUOH4ObmBjc3N3Tt2hVnz57Frl27pFsMqG4f8NFHH+HTTz9Fy5Yt0b17d1y/fh2xsbF46aWXtD6WhYUFli9fji+//BLu7u4YNGgQAGDcuHFYt24dYmJi0K5dOwQEBCAmJuaJPVAzZ85Ep06dEBwcjMDAQCiVynL1effdd2Fubo7WrVvDxcVF4/ioTp06YefOndi+fTvatm2LWbNmITIyUm0AOREZh0xouqBORERERBViDxQRERGRjhigiIiIiHTEAEVERESkIwYoIiIiIh0xQBERERHpiAGKiIiISEcMUEREREQ6YoAiIiIi0hEDFBEREZGOGKCIiIiIdMQARURERKQjBigiIiIiHf0/zY1pEyeOXlIAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Extract maximum value per iteration\n", + "maxima = torch.zeros(rs_init + bo_iters)\n", + "cur_max = train_Y[0][0]\n", + "\n", + "for i in range(rs_init + bo_iters):\n", + " cur_max = cur_max if cur_max > train_Y[i][0] else train_Y[i][0]\n", + " maxima[i] = cur_max\n", + "\n", + "# Get plotting values\n", + "plt_y = maxima.numpy()\n", + "plt_x = list(range(1,len(plt_y)+1))\n", + "\n", + "# Have the first x-value in the plot start at 1 to be consistent with above prints\n", + "plt_y = np.hstack([plt_y])\n", + "plt_x = np.hstack([plt_x])\n", + "\n", + "# Plot all values\n", + "plt.plot([plt_x[rs_init-1], plt_x[rs_init]], [plt_y[rs_init-1], plt_y[rs_init]],\\\n", + " linestyle='--', color='gray')\n", + "plt.plot(plt_x[0:rs_init], plt_y[0:rs_init], color='red', label=\"Init values\", marker='.')\n", + "plt.plot(plt_x[rs_init:], plt_y[rs_init:], color='black', label=\"BO values\", marker='.')\n", + "plt.xlabel(\"BO Iteration\")\n", + "plt.ylabel(\"Maximum value\")\n", + "plt.title(\"Best value found per BO iteration including initialization\")\n", + "plt.legend()\n", + "plt.show()\n", + "plt.close()\n", + "\n", + "plt.plot([plt_x[rs_init-1], plt_x[rs_init]], [plt_y[rs_init-1], plt_y[rs_init]],\\\n", + " linestyle='--', color='gray')\n", + "plt.plot(plt_x[rs_init-1], plt_y[rs_init-1], color='red', label=\"Init values\", marker='.')\n", + "plt.plot(plt_x[rs_init:], plt_y[rs_init:], color='black', label=\"BO values\", marker='.')\n", + "plt.xlabel(\"BO Iteration\")\n", + "plt.ylabel(\"Maximum value\")\n", + "plt.title(\"Best value found per BO iteration after initialization\")\n", + "plt.legend()\n", + "plt.show()\n", + "plt.close()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "botorch", + "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.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/website/tutorials.json b/website/tutorials.json index 03d73e065d..26532a0cd4 100644 --- a/website/tutorials.json +++ b/website/tutorials.json @@ -147,6 +147,10 @@ { "id": "composite_mtbo", "title": "Composite Bayesian Optimization with Multi-Task Gaussian Processes" + }, + { + "id": "fobo", + "title": "BO with Derivatives" } ] }