diff --git a/examples/03_Multitask_Exact_GPs/GP_Factor_Analysis_Regression.ipynb b/examples/03_Multitask_Exact_GPs/GP_Factor_Analysis_Regression.ipynb new file mode 100644 index 000000000..47a2d85b0 --- /dev/null +++ b/examples/03_Multitask_Exact_GPs/GP_Factor_Analysis_Regression.ipynb @@ -0,0 +1,539 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "surface-raising", + "metadata": {}, + "source": [ + "# Gaussian Process Factor Analysis Regression\n", + "\n", + "## Introduction\n", + "\n", + "Gaussian Process Factor Analysis (GPFA), introduced in [this paper](https://papers.nips.cc/paper/2008/file/ad972f10e0800b49d76fed33a21f6698-Paper.pdf) learns underlying latent trajectories for the outputs while smoothing the data. A more [recent paper](https://papers.nips.cc/paper/2020/file/6d79e030371e47e6231337805a7a2685-Paper.pdf) suggests scalable implementations for GPFA (in the [supplement](https://papers.nips.cc/paper/2020/file/6d79e030371e47e6231337805a7a2685-Supplemental.pdf) ) as well as extending GPFA with kernels for dynamical systems. The implementation in this notebook is developed with a future GPFA for Dynamical Systems (GPFADS) extension in mind. \n", + "\n", + "GPFA(DS) are useful when you want to simultaneous smooth and reduce the dimensionality of neural data. \n", + "\n", + "Given timepoints $t$, $M$ latent variables $x$ with underlying kernels $k_1, ...k_M$, and observations (neural data) $y$ from $N$ neurons, the observations in GPFA are are assumed to arise as follows:\n", + "- The latents variables are independent of eachother:\n", + "$$ k(x_i(t), x_j(t')) = \\delta_{ij} k_i(t,t')\n", + "$$\n", + "\n", + "- We write the above in a vector of latents as:\n", + "$$k[\\mathbf{x}(t), \\mathbf{x}(t')] = \\sum_{i=1}^{M}k_i(t,t')\\otimes (\\mathbf{e}_i \\mathbf{e}_i^T)\n", + "$$\n", + "\n", + "- We combine the latents into observations as follows:\n", + "$$k[\\mathbf{y}(t), \\mathbf{y}(t')] = (C) k( \\mathbf{x}(t) , \\mathbf{x}(t'))(C^T)\n", + "$$\n", + "\n", + "where $k_i$ is a standard kernel (e.g. RBF) that operates on the inputs.\n", + "$\\delta_{ij}$ is the Kronecker delta, $\\mathbf{e}_i$ is a unit vector of length $M$ with nonzero element at index $i$, $\\otimes$ is the Kronecker product, and $C\\in NxM$ is the mixing matrix, indicating how latents are combined into observations.\n", + "\n", + "\n", + "GPFA is mathematically identical to [LMC/LCM](https://docs.gpytorch.ai/en/stable/variational.html#lmcvariationalstrategy) which arose from the geostatistics literature. Both LCM/LMC and GPFA construct a multi-output kernel as the covariance of a linear combination of multiple latent Gaussian processes. However, in GPFA, we are interested in recovering the posterior over these latents processes (not possible with GPyTorch's LMC model), hence the extension of LMC proposed here. Due to the gridded structure of neural data, and the relatively sparse sampling of data per lengthscale, GPFA does not need to rely on inducing points and can instead be modeled using exact / iterative GPs." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "proved-education", + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import torch\n", + "import gpytorch\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "\n", + "%matplotlib inline\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "confirmed-career", + "metadata": {}, + "source": [ + "### Set up training data\n", + "In the next cell, we set up the training data for this example. We'll be using 100 regularly spaced points on [0,1], our data will be drawn from the generative model assumed in GPFA." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "graphic-female", + "metadata": {}, + "outputs": [], + "source": [ + "def generate_GPFA_Data(seed=0, n_timepoints=100, n_latents=2, num_obs=50, length_scales = [.01,10],start_time=-5, end_time = 5,zero_mean = True):\n", + " torch.manual_seed(seed)\n", + " np.random.seed(seed)\n", + " timepoints = torch.linspace(start_time, end_time, n_timepoints)\n", + " tau = torch.tensor(length_scales)\n", + " C = torch.tensor(np.random.normal(scale=1./np.sqrt(n_latents),size=(num_obs,n_latents))).float()\n", + " if zero_mean:\n", + " d = torch.zeros(size=(num_obs,1)).float()\n", + " else:\n", + " d = torch.tensor(np.random.uniform(size=(num_obs,1))).float()\n", + " R = torch.tensor(np.diag(np.random.uniform(size=(num_obs,), low=.1))).float()\n", + " kernels = [gpytorch.kernels.RBFKernel() for t in tau]\n", + " for t in range(len(tau)):\n", + " kernels[t].lengthscale = tau[t]\n", + "\n", + " xs = torch.stack([\n", + " gpytorch.distributions.MultivariateNormal(\n", + " torch.zeros(n_timepoints), \n", + " k(timepoints,timepoints) \n", + " ).sample()\n", + " for k in kernels])\n", + "\n", + " ys = gpytorch.distributions.MultivariateNormal((C@xs + d).T, R).sample()\n", + " \n", + " xs = xs.T.contiguous()\n", + " \n", + " return timepoints, tau, C, d, R, kernels, xs, ys" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "historic-breathing", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/scratch/jts58/devenv/lib/python3.7/site-packages/gpytorch-1.4.0-py3.7.egg/gpytorch/utils/cholesky.py:51: NumericalWarning: A not p.d., added jitter of 1.0e-05 to the diagonal\n", + " warnings.warn(f\"A not p.d., added jitter of {jitter_new:.1e} to the diagonal\", NumericalWarning)\n" + ] + } + ], + "source": [ + "n_latents=2\n", + "num_obs=20\n", + "n_timepoints = 100\n", + "length_scales = [.1,.2]\n", + "start_time = 0\n", + "end_time = 1\n", + "train_x, tau, C, d, R, kernels, xs, train_y = generate_GPFA_Data(\n", + " seed=10, n_timepoints=n_timepoints, n_latents=n_latents, num_obs=num_obs, \n", + " length_scales = length_scales,start_time = start_time, end_time = end_time, zero_mean =True)" + ] + }, + { + "cell_type": "markdown", + "id": "electrical-vehicle", + "metadata": {}, + "source": [ + "## Define a multitask model\n", + "\n", + "The model should be somewhat similar to the `ExactGP` model in the [simple regression example](../01_Exact_GPs/Simple_GP_Regression.ipynb).\n", + "The differences:\n", + "\n", + "1. We're going to wrap ConstantMean with a `MultitaskMean`. This makes sure we have a mean function for each output dimension.\n", + "2. Rather than just using a RBFKernel, we're using that in conjunction with a `GPFAKernel`. This gives us the covariance function described in the introduction.\n", + "3. We're using a `MultitaskMultivariateNormal` and `MultitaskGaussianLikelihood`. This allows us to deal with the predictions/outputs in a nice way. For example, when we call MultitaskMultivariateNormal.mean, we get a `T x N` matrix back (where `T` is the number of test_xpoints).\n", + "\n", + "\n", + "You may also notice that we don't use a ScaleKernel, since the GPFAKernel will do some scaling for us. (This way we're not overparameterizing the kernel.)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "aerial-street", + "metadata": {}, + "outputs": [], + "source": [ + "from gpytorch.kernels import GPFAKernel\n", + "from gpytorch.lazy import DiagLazyTensor, KroneckerProductLazyTensor, KroneckerProductDiagLazyTensor\n", + "\n", + "class GPFAModel(gpytorch.models.ExactGP):\n", + " def __init__(self, train_x, train_y, likelihood, latent_covar_modules, num_latents, num_obs):\n", + " super(GPFAModel, self).__init__(train_x, train_y, likelihood)\n", + " \n", + " self.num_latents = num_latents\n", + " self.num_obs = num_obs\n", + " \n", + " self.mean_module = gpytorch.means.MultitaskMean(\n", + " gpytorch.means.ZeroMean(), num_tasks=num_obs\n", + " )\n", + " self.covar_module = GPFAKernel(latent_covar_modules,num_latents, num_obs)\n", + " \n", + " def forward(self, x):\n", + " return gpytorch.distributions.MultitaskMultivariateNormal(self.mean_module(x), self.covar_module(x))\n", + " \n", + " def latent_posterior(self, x, train_y = None, obs_dims = None):\n", + " r'''\n", + " See equations 4 and 5 in `Non-reversible Gaussian processes for\n", + " identifying latent dynamical structure in neural data`_\n", + " \n", + " :param torch.Tensor train_y: (size T x obs_dims) The training data to use when inferring latents.\n", + " :param list obs_dims: Which observations dimensions train_y contains data for. This allows for leave neuron (observation dimension) out analyses as described in `this paper`_\n", + " \n", + " .. _Non-reversible Gaussian processes for identifying latent dynamical structure in neural data:\n", + " https://papers.nips.cc/paper/2020/file/6d79e030371e47e6231337805a7a2685-Paper.pdf\n", + " \n", + " .. _this paper: https://papers.nips.cc/paper/2008/file/ad972f10e0800b49d76fed33a21f6698-Paper.pdf\n", + " \"\"\"\n", + " '''\n", + " if train_y is None:\n", + " train_y = self.train_targets\n", + " \n", + " if obs_dims is None:\n", + " obs_dims = range(self.num_obs)\n", + " \n", + " I_t = DiagLazyTensor(torch.ones_like(torch.squeeze(x)))\n", + "\n", + " combined_noise = (self.likelihood.task_noises if self.likelihood.has_task_noise\n", + " else torch.zeros(self.likelihood.num_tasks)) + (\n", + " self.likelihood.noise\n", + " if self.likelihood.has_global_noise else 0)\n", + "\n", + " combined_noise = combined_noise[obs_dims]\n", + " \n", + " C_Kron_I = KroneckerProductLazyTensor(I_t, self.covar_module.C[obs_dims])\n", + "\n", + "\n", + " Kxx = self.covar_module.latent_covar_module(x)\n", + " \n", + " # the first term of Kyy is specific to GPFA Kernel, be careful if adding nonreversible\n", + " Kyy = C_Kron_I @ Kxx @ C_Kron_I.t() + KroneckerProductDiagLazyTensor(\n", + " I_t, DiagLazyTensor(combined_noise))\n", + "\n", + " mean_rhs = (train_y - self.mean_module(x)[:,obs_dims]).view(\n", + " *(train_y.numel(),\n", + " )) # vertically stacks after doing the subtraction\n", + "\n", + " Kyy_inv_mean = Kyy.inv_matmul(mean_rhs)\n", + " latent_mean = Kxx @ C_Kron_I.t() @ Kyy_inv_mean\n", + " latent_mean = latent_mean.view(*(len(x),\n", + " int(latent_mean.shape[0] / len(x))))\n", + "\n", + " cov_rhs = C_Kron_I @ Kxx\n", + " latent_cov = Kxx - Kxx @ C_Kron_I.t() @ Kyy.inv_matmul(\n", + " cov_rhs.evaluate())\n", + " return gpytorch.distributions.MultitaskMultivariateNormal(\n", + " latent_mean, latent_cov)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "velvet-atlas", + "metadata": {}, + "outputs": [], + "source": [ + "likelihood = gpytorch.likelihoods.MultitaskGaussianLikelihood(num_tasks=num_obs)\n", + "kernels = [gpytorch.kernels.RBFKernel() for t in range(n_latents)]\n", + "model=GPFAModel(train_x,train_y, likelihood, kernels, n_latents, num_obs)" + ] + }, + { + "cell_type": "markdown", + "id": "worse-platform", + "metadata": {}, + "source": [ + "### Train the model hyperparameters" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "premier-mainland", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter 1/50 - Loss: 148.949, Lengthscale 1: 0.693, Lengthscale 2: 0.693\n", + "Iter 2/50 - Loss: 147.468, Lengthscale 1: 0.744, Lengthscale 2: 0.744\n", + "Iter 3/50 - Loss: 145.879, Lengthscale 1: 0.798, Lengthscale 2: 0.708\n", + "Iter 4/50 - Loss: 144.214, Lengthscale 1: 0.853, Lengthscale 2: 0.669\n", + "Iter 5/50 - Loss: 142.446, Lengthscale 1: 0.910, Lengthscale 2: 0.629\n", + "Iter 6/50 - Loss: 140.551, Lengthscale 1: 0.935, Lengthscale 2: 0.590\n", + "Iter 7/50 - Loss: 138.550, Lengthscale 1: 0.958, Lengthscale 2: 0.552\n", + "Iter 8/50 - Loss: 136.482, Lengthscale 1: 0.970, Lengthscale 2: 0.515\n", + "Iter 9/50 - Loss: 134.373, Lengthscale 1: 0.971, Lengthscale 2: 0.479\n", + "Iter 10/50 - Loss: 132.267, Lengthscale 1: 0.952, Lengthscale 2: 0.444\n", + "Iter 11/50 - Loss: 130.211, Lengthscale 1: 0.923, Lengthscale 2: 0.409\n", + "Iter 12/50 - Loss: 128.170, Lengthscale 1: 0.886, Lengthscale 2: 0.377\n", + "Iter 13/50 - Loss: 126.123, Lengthscale 1: 0.844, Lengthscale 2: 0.346\n", + "Iter 14/50 - Loss: 124.095, Lengthscale 1: 0.798, Lengthscale 2: 0.317\n", + "Iter 15/50 - Loss: 122.129, Lengthscale 1: 0.753, Lengthscale 2: 0.290\n", + "Iter 16/50 - Loss: 120.230, Lengthscale 1: 0.708, Lengthscale 2: 0.265\n", + "Iter 17/50 - Loss: 118.413, Lengthscale 1: 0.663, Lengthscale 2: 0.241\n", + "Iter 18/50 - Loss: 116.734, Lengthscale 1: 0.618, Lengthscale 2: 0.218\n", + "Iter 19/50 - Loss: 115.320, Lengthscale 1: 0.575, Lengthscale 2: 0.198\n", + "Iter 20/50 - Loss: 114.123, Lengthscale 1: 0.532, Lengthscale 2: 0.179\n", + "Iter 21/50 - Loss: 113.085, Lengthscale 1: 0.490, Lengthscale 2: 0.162\n", + "Iter 22/50 - Loss: 112.204, Lengthscale 1: 0.450, Lengthscale 2: 0.148\n", + "Iter 23/50 - Loss: 111.496, Lengthscale 1: 0.411, Lengthscale 2: 0.135\n", + "Iter 24/50 - Loss: 110.938, Lengthscale 1: 0.375, Lengthscale 2: 0.124\n", + "Iter 25/50 - Loss: 110.524, Lengthscale 1: 0.342, Lengthscale 2: 0.115\n", + "Iter 26/50 - Loss: 110.099, Lengthscale 1: 0.311, Lengthscale 2: 0.108\n", + "Iter 27/50 - Loss: 109.659, Lengthscale 1: 0.283, Lengthscale 2: 0.101\n", + "Iter 28/50 - Loss: 109.325, Lengthscale 1: 0.258, Lengthscale 2: 0.096\n", + "Iter 29/50 - Loss: 108.970, Lengthscale 1: 0.238, Lengthscale 2: 0.092\n", + "Iter 30/50 - Loss: 108.723, Lengthscale 1: 0.224, Lengthscale 2: 0.088\n", + "Iter 31/50 - Loss: 108.399, Lengthscale 1: 0.213, Lengthscale 2: 0.085\n", + "Iter 32/50 - Loss: 108.362, Lengthscale 1: 0.205, Lengthscale 2: 0.083\n", + "Iter 33/50 - Loss: 108.234, Lengthscale 1: 0.204, Lengthscale 2: 0.081\n", + "Iter 34/50 - Loss: 108.178, Lengthscale 1: 0.209, Lengthscale 2: 0.079\n", + "Iter 35/50 - Loss: 108.072, Lengthscale 1: 0.217, Lengthscale 2: 0.078\n", + "Iter 36/50 - Loss: 108.109, Lengthscale 1: 0.227, Lengthscale 2: 0.077\n", + "Iter 37/50 - Loss: 107.894, Lengthscale 1: 0.239, Lengthscale 2: 0.077\n", + "Iter 38/50 - Loss: 107.905, Lengthscale 1: 0.252, Lengthscale 2: 0.077\n", + "Iter 39/50 - Loss: 107.633, Lengthscale 1: 0.261, Lengthscale 2: 0.077\n", + "Iter 40/50 - Loss: 107.606, Lengthscale 1: 0.268, Lengthscale 2: 0.078\n", + "Iter 41/50 - Loss: 107.610, Lengthscale 1: 0.271, Lengthscale 2: 0.078\n", + "Iter 42/50 - Loss: 107.385, Lengthscale 1: 0.269, Lengthscale 2: 0.079\n", + "Iter 43/50 - Loss: 107.253, Lengthscale 1: 0.265, Lengthscale 2: 0.081\n", + "Iter 44/50 - Loss: 107.334, Lengthscale 1: 0.261, Lengthscale 2: 0.082\n", + "Iter 45/50 - Loss: 107.463, Lengthscale 1: 0.258, Lengthscale 2: 0.083\n", + "Iter 46/50 - Loss: 107.177, Lengthscale 1: 0.257, Lengthscale 2: 0.085\n", + "Iter 47/50 - Loss: 107.066, Lengthscale 1: 0.257, Lengthscale 2: 0.087\n", + "Iter 48/50 - Loss: 107.289, Lengthscale 1: 0.255, Lengthscale 2: 0.089\n", + "Iter 49/50 - Loss: 106.797, Lengthscale 1: 0.251, Lengthscale 2: 0.091\n", + "Iter 50/50 - Loss: 106.594, Lengthscale 1: 0.247, Lengthscale 2: 0.094\n" + ] + } + ], + "source": [ + "# this is for running the notebook in our testing framework\n", + "import os\n", + "smoke_test = ('CI' in os.environ)\n", + "training_iterations = 2 if smoke_test else 50\n", + "\n", + "\n", + "# Find optimal model hyperparameters\n", + "model.train()\n", + "likelihood.train()\n", + "\n", + "# Use the adam optimizer\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=0.1) # Includes GaussianLikelihood parameters\n", + "\n", + "# \"Loss\" for GPs - the marginal log likelihood\n", + "mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model)\n", + "for i in range(training_iterations):\n", + " optimizer.zero_grad()\n", + " output = model(train_x)\n", + " loss = -mll(output, train_y)\n", + " loss.backward()\n", + " print('Iter %2d/%d - Loss: %.3f, Lengthscale 1: %.3f, Lengthscale 2: %.3f' \n", + " % (i + 1, training_iterations, loss.item(), kernels[0].lengthscale.float(), kernels[1].lengthscale.float()))\n", + " optimizer.step()" + ] + }, + { + "cell_type": "markdown", + "id": "color-labor", + "metadata": {}, + "source": [ + "### Make predictions with the model" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "automotive-attraction", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Set into eval mode\n", + "model.eval()\n", + "likelihood.eval()\n", + "\n", + "# Initialize plots\n", + "f, axes = plt.subplots(5, 4, figsize=(10, 20))\n", + "\n", + "# Make predictions\n", + "with torch.no_grad(), gpytorch.settings.fast_pred_var():\n", + " test_x = torch.linspace(0, 1, 51)\n", + " predictions = likelihood(model(test_x))\n", + " mean = predictions.mean\n", + " lower, upper = predictions.confidence_region()\n", + " \n", + "# This plots predictions for all observed neurons\n", + "for i, ax in enumerate(axes.flatten()):\n", + " # Plot training data as black stars\n", + " ax.plot(train_x.detach().numpy(), train_y[:, i].detach().numpy(), 'k*')\n", + " # Predictive mean as blue line\n", + " ax.plot(test_x.numpy(), mean[:, i].numpy(), 'b')\n", + " # Shade in confidence \n", + " ax.fill_between(test_x.numpy(), lower[:, i].numpy(), upper[:, i].numpy(), alpha=0.5)\n", + " ax.set_ylim([-3, 3])\n", + " if i==0:\n", + " ax.legend(['Observed Data', 'Mean', 'Confidence'])\n", + " if i==2:\n", + " ax.set_title('Observed Values (Likelihood)')\n", + "\n", + "\n", + "None" + ] + }, + { + "cell_type": "markdown", + "id": "considered-allowance", + "metadata": {}, + "source": [ + "### Find the Latents\n", + "\n", + "These latents will only 'match' up to an ordering and negation of the true latents. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "portuguese-edition", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6AAAAF1CAYAAAD2qYcEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAB7WklEQVR4nO3deXzcVb3/8deZmcyWfU+adKULpdACLYIgooKAbNq6UAG3q5bCVZQLevV63UDvdeGK+rOE9rogiFwUW0AW2URZC5StUFra0i3Nvm+T2c/vj0mmSZu0aZNOtvfzQR7NZCYzJ8PMnO/nez7n8zHWWkRERERERESONsdoD0BEREREREQmBwWgIiIiIiIikhIKQEVERERERCQlFICKiIiIiIhISigAFRERERERkZRQACoiIiIiIiIpoQBUJEWMMZcbYx4d7XGIiIhIguZmkdRTACoTkjFmlzGm2xjTaYypM8bcZozJGMb9fc8Y84fhjMlae6e19tzh3Md+Y9pljDnnCH7vH8aYL4zgOKwxZvZI3Z+IiExMmpsP+nuam2XSUAAqE9nF1toM4GRgCfCfozUQY4xrGL9rjDF6r4qIyESguVlkktMbRyY8a20V8DBwPIAx5hJjzCZjTGvPGcf5vbc1xvy7MabKGNNhjHnbGHO2MeZ84D+AS3vO2r7ec9tsY8xvjDE1Pb/zA2OMs+e6zxpjnjXG3GyMaQK+1/OzZ/o81unGmJeMMW09/57e57p/GGN+aIx5FggAs4b69xpjco0xDxhjGowxLT3fl/dc90PgTOBXPX/Lr3p+fqwx5jFjTHPP3/2JPvd3mzFmlTHmwZ7n5QVjzDE91z3Vc7PXe+7vUmNMQc9jtvbc39OapEVEpC/NzZqbZfLSC08mPGPMVOAC4FVjzFzgLuCrQCHwEPBXY4zbGDMP+BJwirU2EzgP2GWt/RvwX8Dd1toMa+2inru+DYgCs4GTgHOBvukzpwI7gGLgh/uNKQ94EPglkA/8DHjQGJPf52afAlYAmcDuw/iTHcDvgOnANKAb+BWAtfZbwNPAl3r+li8ZY9KBx4A/AkXAcuAWY8xxfe5zOfB9IBfY3vv3WGvf23P9op77uxu4DthL4vktJnGAYA9j/CIiMsFpbtbcLJOXAlCZyO41xrQCzwD/JDFRXQo8aK19zFobAW4CfMDpQAzwAMcZY9Kstbuste8MdMfGmGISE+dXrbVd1tp64GYSk0Gvamvt/7PWRq213fvdxYXANmvtHT3X3wVsAS7uc5vbrLWbeq6PDPWPttY2WWv/Yq0NWGs7SExIZx3kVy4iMZn/ruexXgX+Any8z23WWWtftNZGgTuBEw9yfxGgFJhurY1Ya5+21mqSExER0NysuVkmPQWgMpF9xFqbY62dbq29umeimUKfM5bW2jhQCZRZa7eTOPv6PaDeGPN/xpgpg9z3dCANqOlJZ2kFVpM4S9mr8iBj6zeOHruBsiH+/qCMMX5jzGpjzG5jTDvwFJDTm4I0gOnAqb1/R8/fcjlQ0uc2tX2+DwAHKxrxUxJnYh81xuwwxnzjSP4OERGZkDQ3a26WSU4BqEw21SQ+1IFEEQFgKlAFYK39o7X2PT23scCPe266/1nCSiAEFPRMpDnW2ixr7YI+tznYmcV+4+gxrXccQ/j9g7kOmAecaq3NAnpTccwg91sJ/LPP35HTk7Jz1ZE8uLW2w1p7nbV2FnAJ8G/GmLOP5L5ERGRS0NysuVkmEQWgMtn8Cbiwp4BBGokJIQQ8Z4yZZ4z5gDHGAwRJ7M+I9/xeHTCjd8O+tbYGeBT4H2NMljHGYYw5xhhzsHSavh4C5hpjLjPGuIwxlwLHAQ8c5t+TZozx9vlykdiX0g209uxn+e5+v1NH/8IJD/SM5VPGmLSer1NMnwIQh9Dv/owxFxljZvccQLSRSJ+KD/bLIiIy6Wlu1twsk4gCUJlUrLVvA1cA/w9oJLGv42JrbZjEHpMf9fy8lkTKzjd7fvXPPf82GWNe6fn+04AbeAtoAe4hsb9iKONoIrG/4zqgCfg6cJG1tvEw/6SHSExovV/fA35OYu9MI7Ae+Nt+v/ML4GMmUYXvlz17Uc4lsUemmsTf/mMSz8dQfA/4fU+K0CeAOcDjQCfwPHCLtfbJw/y7RERkktDcDGhulknEaP+xiIiIiIiIpIJWQEVERERERCQlhh2A9uS2v2iMed0kGgh/fyQGJiIiIkdGc7OIiIxVw07B7dnMnG6t7ezZOP4M8BVr7fqRGKCIiIgcHs3NIiIyVrmGewc9TWw7ey6m9XxpY6mIiMgo0dwsIiJj1YjsATXGOI0xrwH1wGPW2hdG4n5FRETkyGhuFhGRsWjYK6AA1toYcKIxJgdYZ4w53lr7Zt/bGGNWACsA0tPTFx977LEj8dAiIiK8/PLLjdbawtEex1iiuVlEREbTYHPziLdhMcZ8BwhYa28a7DZLliyxGzZsGNHHFRGRycsY87K1dsloj2Os0twsIiKpNtjcPBJVcAt7zq5ijPEBHwS2DPd+RURE5MhobhYRkbFqJFJwS4HfG2OcJALaP1lrHxiB+xUREZEjo7lZRETGpJGogrsROGkExiIiIiIjQHOziIiMVSNSBVdERERERETkUBSAioiIiIiISEooABUREREREZGUUAAqIiIiIiIiKaEAVERERERERFJCAaiIiIiIiIikhAJQERERERERSQkFoCIiIiIiIpISCkBFREREREQkJRSAioiIiIiISEooABUREREREZGUUAAqIiIiIiIiKaEAVERERERERFJCAaiIiIiIiIikhAJQERERERERSQkFoCIiIiIiIpISCkBFREREREQkJRSAioiIiIiISEooABUREREREZGUUAAqIiIiIiIiKaEAVERERERERFJCAaiIiIiIiIikhAJQERERERERSQkFoCIiIiIiIpISCkBFREREREQkJRSAioiIiIiISEooABUREREREZGUUAAqIiIiIiIiKaEAVERERERERFJCAaiIiIiIiIikhAJQERERERERSQkFoCIiIiIiIpISCkBFREREREQkJRSAioiIiIiISEooABUREREREZGUUAAqIiIiIiIiKaEAVERERERERFJCAaiIiIiIiIikhAJQERERERERSQkFoCIiIiIiIpISCkBFREREREQkJRSAioiIiIiISEooABUREREREZGUUAAqIiIiIiIiKaEAVERERERERFJCAaiIiIiIiIikxLADUGPMVGPMk8aYt4wxm4wxXxmJgYmIiMiR0dwsIiJjlWsE7iMKXGetfcUYkwm8bIx5zFr71gjct4iIiBw+zc0iIjImDXsF1FpbY619pef7DmAzUDbc+xUREZEjo7lZRETGqhHdA2qMmQGcBLwwwHUrjDEbjDEbGhoaRvJhRUREZBCam0VEZCwZsQDUGJMB/AX4qrW2ff/rrbVrrLVLrLVLCgsLR+phRUREZBCam0VEZKwZkQDUGJNGYoK701q7diTuU0RERI6c5mYRERmLRqIKrgF+A2y21v5s+EMSERGR4dDcLCIiY9VIrICeAXwK+IAx5rWerwtG4H5FRETkyGhuFhGRMWnYbVistc8AZgTGIiIiIiNAc7OIiIxVI1oFV0RERERERGQwCkBFREREREQkJRSAioiIiIiISEooABUREREREZGUUAAqIiIiIiIiKaEAVERERERERFJCAaiIiIiIiIikhAJQERERERERSQkFoCIiIiIiIpISCkBFREREREQkJRSAioiIiIiISEooABUREREREZGUUAAqIiIiIiIiKaEAVERERERERFJCAaiIiIiIiIikhAJQERERERERSQkFoCIiIiIiIpISCkBFREREREQkJRSAioiIiIiISEooABUREREREZGUUAAqIiIiIiIiKaEAVERERERERFJCAaiIiIiIiIikhAJQERERERERSQkFoCIiIiIiIpISCkBFREREJGVqamo466yzqK2tHe2hiMgoUAAqIiIiIkdV36Dzxhtv5JlnnuGGG24Y7WGJyChQACoiIiIiR9WNN97IU089RWlpKRUVFcTjcSoqKjDG4PP5Rnt4IpJCCkBFREREZET1rnh6vV6MMVRUVBxwG7/fz+WXX8769euVkisyiSgAFREREZER1Ztme+mll3LZZZfh9/sBcDqdAHg8HoLBIFlZWaxevVopuSKTiLHWpvxBlyxZYjds2JDyxxURkYnJGPOytXbJaI9jPNPcLCPB5/MRDAYHvM7r9RIMBlmwYAF33nknixcvJhaLDXi77u7uoz1UETnKBpubtQIqIiIiIiNix44d/VY8/X4/5eXlfOYzn2H9+vVcffXVzJ07l0WLFlFZWXnAbZWSKzLxKQAVERERkWHp3fNpjCErK4tgMJhc8bz44ou57bbbWLRoEatWrWLt2rUAlJaWHnBbpeSKTHwKQEVERERkWPq2Vqmrq2PlypWsX7+elStXHnQls+9te4sVqUquyMSmPaAiIjLuaQ/o8GluliMx2J7PI9nHWVNTw/XXX8+9995LIBDA7/ezdOlSbrrpJkpKSkZqyCKSItoDKiIiIiIjaqA9n5dffjk7d+487PsaLCVXwafIxKIAVERERESOyEgHjYeTvisi45NrtAcgIiIiIuNLTU0Ny5cv5+67704GjStWrGDNmjXU1NQc8f32FigCWLVq1UgMVUTGGAWgIiIiInJY+hYdOppBY99AV6m4IhODUnBFREREZEh8Pl+yWm0qKtX2DXRFZGJQACoiIiIiQzKSRYcOJtWBroikjgJQERERERmSVFWqTVWgKyKppwBURERERIYsFZVq1ZJFZOJSESIREREROaSBCgIdzUq1I1ldV0TGDgWgIiIiInJIfQsC3XLLLUf98dSSRWRiGpEUXGPMb40x9caYN0fi/kRERGR4NDfLSFFBIBEZSSO1B/Q24PwRui8REREZvtvQ3CwjYCwVBKqpqeGss846KvtORSQ1RiQAtdY+BTSPxH2JiIjI8GlulpEylgoCqS+oyPiXsiq4xpgVxpgNxpgNDQ0NqXpYERERGYTmZhmqVFS+PRilAYtMHMZaOzJ3ZMwM4AFr7fGHuu2SJUvshg0bRuRxRUREjDEvW2uXjPY4xhrNzTJR1NTUcP3113PvvfcSCATw+/0sXbqUm266Sa1ZRMaoweZm9QEVERERkTFtLKUBi8jwKAAVERERkQOMtYI/o50GLCIjY0T6gBpj7gLeBxQYY/YC37XW/mYk7ltEREQOn+ZmGa5U9/08FPUFFZkYRiQAtdZ+ciTuR0REREaG5mY5Uj6fj2AwmLxcUVFBRUUFXq+X7u7uURyZiEwESsEVERERkaSx1PdTRCYeBaAiIiIikqSCPyJyNCkAFREREZF+xkvBn7FWKElEDm1E9oCKiIiIyMQxXgr+jLVCSSJyaFoBFREREZFxtZro8/kwxlBRUUE8HqeiogJjDD6fb7SHJiKHoABURERERPqtJo51KpQkMn4pABURERGZxMbjaqIKJYmMXwpARURERCax8bqaOF4KJYlIfypCJCIiIjKJjdfVxPFSKElE+tMKqIiIiMgkp9VEEUkVrYCKiIiITHJaTRSRVNEKqIiIiIiIiKSEVkBFREREZES1dUeobu2moSNEY2eI5q4wsbhNXu9xOSjO8lKU5aUk20tplheHw4ziiEUkVbQCKjKB9W0qvn+D8cO5PJ6ak4uIyNCM9Gd7MBLjjb1t/GlDJb97did/e7OWl3e3sLspQEcwSiAcS361BCJsqe3gqa0N/OmlSn7zzE6ef6eJzlB0RMYiImOXAlCRcexQQWTfpuL7Nxg/nMv7X6eAVERk/Nv/s/1IdYaiPLmlnv99agePb66jqqUbaw/9e/vfx/odTfz2mZ08/EYN7cHIEY1F85PI2Gfs4X5CjIAlS5bYDRs2pPxxRca7mpoali9fzt13301JSQlXX301q1ev5sorr+SWW25JXjbGEIvFjto4nE4n1trk4+4/LpFUM8a8bK1dMtrjGM80N08ePp+PYDB4wM+9Xi/d3d1Dvp9AOMpLu1rYWNlKND748WRnm4P6SjfxmAEDDgMef5ziaSFcaQP/jtvl4LRZ+Zw0NeewUnP3nxdFZPQMNjcrABUZ4/oGdzfccMMRBZhOpxOAWCyGz+ejuLiYuro6uru7D3m57+8e7P57A9Jvf/vbCkYl5RSADp/m5smjpqaG66+/nnvvvZdAIIDf72fp0qXcdNNNQ/rcttbyRlUbT29rJByNH3B9Q1Uarz6ZyZ63vVS946GtceAo05kWp2xWiKlzQ8xb0sX8d3XRM+UkFWV5+OBxxRRleg86ppEKqkVk5Aw2N6sIkcgo23/1cP/LN954I0899RSlpaWD3sf+QaPf76esrIzt27fj8XiSk7LX6yUUCuH3+wmFQkO6vP/vzp49m6qqKgKBQPLxe4PTiooKKioqALjhhhu0OioiMgaVlpaSlZVFMBhMfs5nZWUN6TO6LRDhsc11VDYH+v080OHglSczefmJLHZv9mGMpXh6mNmLupkyq5WS6SFcbguJ/wi0O6nc6mXP2142PJ7Fs3/NIacwwukXtXHq+W1k5ibmlfr2EH96qZJzF5Qwtzhz0HHt2LFj0KBaRMYW7QEVGQV996gMtveyvLwcY0wyoOvL7/czZ84cjDGDBo3RaJSrrrqK9evXM3PmTGbOnJlsMN7S0tKv4fjBLvf93auuuopIJJI8aDHGMGfOHPx+/wFjrKiowBjD1KlTtX9URGSMqaur6/e5P5TP5I17W/nDC7v7BZ/BLgeP/CGPH3xqJmt/VUw46OCiLzTw7T/s5OtrdnP5v9fy/o+3MP9dAeac2M2ck7qZe1I3J57VycVfbORfb9rLD9Zu57PfqaaoPMxDvyvghstncd/qAkLdidTbSMzy0Bs1rN/RNOjYhhNUi0hqKQVXJAUG2rs5UGB5ME6nk1gshsfjIRKJMH36dD70oQ+xYsUK1qxZw7p161i6dGnyck1NTb/G4iNl2bJllJaWJh/noYceYs+ePaSlpREKhXC5XESjg1cx3H//qMhIUAru8GlulsGEo3Ge2FzHltqO5M8iYcMz9+Xw97vz6Gp3cvzpnZx7eRPlc0LDeqz6yjSevCePFx7OJrcowke/XM9xp3Ylrz+2JJMPHleMy3ngGsr+89PRmgdFZGi0B1TkKDpUGu1QigMNJY12wYIF3HnnnWNqYu074V9++eVs2rTpoOm6+/N4PJx66qlK0ZVhUQA6fJqbZSDNXWEe2FhNU2c4+bOdm7zc/T8l1O91M29xFx/6bCPT5h088PSkOXAYg7VgsURjtl9f0P3t3OTlTz8vpm63h0Xv7eDjX6nDn5nYbzqzIJ2LF03Bqb6hImOa9oCKjLC+QWbfNNpbbrmlXxrtoYr39K5qHiyNtu/Z3EWLFrFq1aoU/qUH1zcInjt3LmeddVa/1dHedKj9A9Le/Tkul4s77rgj+dyJiMjYsL2+k0c21SYLDYW6DQ/fVsDT9+aQUxjliz/cy/xTDjzB6DCGafk+ynL8FGZ6KMhwk+ntX4goFrc0dYaobQ9S1x5iZ2MnXaF98+XMBUGuu2U3T/45j0f/kE/NDg+fv7GKwrIIOxu7ePjNGi44vvSwKuSKTEaHWiQZDVoBFRnEUFY1DzeN9lCrmqlKo02VwdJ13W73gNUKAYwxVFdXazVUDotWQIdPc/PkMNSDz5d3N/P0tsZkP8/KrR5u/2EpTTVuzri4lQs/34DX3/8YsjjLy7GlmcwrziTdc3hrHLG45Z2GTl6vbGVvS/+qte9s9PG7708B4LPfrWb2wsT1x03J4tzjijFGQahIr6G27EvFViil4Iocwkj02DxUGm04HD5g7+Z4DzIPR9+A9Oabb+aJJ56gubk5uSLa+1ytXLlSFXTlsCgAHT7NzZPDoQ4+43HL37fU80ZVGwDWwvMPZrOuopDMnBiXfb2W2Yv6B4hTcrycfkwBU/MOLEh3JBo6Qvxza0O/YkeN1Wn8+ttTaKpx8/Gv1PGu89oBWDQ1mw8cWzwijysyERxuT/ijuRVKAagIB1/VHE6Pzb7FgY499li2bNmC2+2e9AHnoVx11VWsWbOGePzAPnKggkUydApAh09z88Q2lD6ZoWiMBzfWsLspEfiFug33/LKYl5/IYt6SLi7/9xoysvd9XhdkejjjmHxmFWYclTFvqk70Gu0OJ+bk7k4Hv/9BKVtfSefSf6vl1PMTQehZ8wo5eVruURmDyHhQU1NDeXn5oMdTMPAiSd+tUEfjWGuwuVltWGTc27+tR9/L+183UMuT3h6bFRUVxOPxA4JPn8/HjBkz8Pl8wIEtUGKxGAsWLOCFF14YsKXJiSeeyKpVq5J7NxV87tPbBuCxxx5jzpw5OPfrQB6LxYjH48mWLr3/D0RE5PDs2LGDyy67LNk2y+/3c/nll7Nz504AusMx/vJyVTL4bKl38ctrp/HK3zM5/9ONfPEHVcng0+UwnDmngMvfNe2oBZ8AC6Zk85l3z0j2//RlxPnCDdXMW9LFn24u5tUnEz9/emvjAX1JRSaTG2+8EWttv9Z4h2rZFwgEuPPOO/n973/f71jL4XAc9VZ5CkBlzDtYgAkDB5W9lwfqqdn3TTYSPTavvvpq5s6dmwwwq6urFXAO0dq1a1m1ahXnnHMOZ599NtbaAfuL9h4orV+/Xj1ERUSOwMH6ZLYHI/xpQyV17YkV0sqtHn5+zTRaal188YdVnHtFM46eI8ayXB9XnDadJTPyUlIAyOd2cuHCUk4/Jh9jwOW2fO471cw8vps7f1LCm8+nE7eWB9+ooa07ctTHIzKW+Hy+5PGstZZt27YlOw/sf7y6/yLJZz7zGcrLyw8IWIHkMfXRohRcGZMGSo09nL2Yh7J/GsJY6bE5mR2sYFE4HObKK68ESNnGeRlflII7fJqbJ76B+mT++o7/Y+0re+kIJvo3b3wmgzt/XEJmTowv/KCKkumJ9itOh+GM2QWcPC1n1Ir+bK3r4NFNtURilmDAcOs3yql6x8MXb6xm7skBirI8fGLJVNIG6BEqMpH0Hif/8pe/5Cc/+Qn33nsvgUAAh8PBMcccQ0VFBWvXrj3k8eqhtkL1TdE/EtoDKmPK0agwO1BQCYk0zoGKAfXdqzlWe2xOZn0PlBYvXjzgyQb1EJVeCkCHT3Pz5FPfHmTtq1XJPZb//EsO968pZOq8IJ//fjWZuYmfZ3pdXLiwlNLs0d8GUdsW5L7XqgiEYwQ6HKy6fiot9S6u/dUeCssizC/N4vzjE/OBCtnJRNW3mJi1ljVr1vQ7YT/Uk/S9x1pLly7l6quv5p0dO4j3HDcvXbqUm266aVjvHe0BlVE11LTZvqmy+zvUXsz9U2VjsRixWGzAtNn90xD2T6NV8Dn6etNzFy1aRGVl5YB7l5YvX97vdSQiIkNT3drNPa/spTscw1p44DcF3Le6iOPP6OTqn+5NBp/T8/1cfur0MRF8ApRke1l2cjneNCf+zDif/34VTif89ntTCAYMm2va2VKbKE60/7GGyHjXN+W2d0vZrbfeijEmeXx7ONuUeo+13nPW+5m/+HRsPI7H0z9F/2jQCqgcNaNRYbZvquzSpUsBWLdunVY1J4DeNJGD9RAdbqqIjF9aAR0+zc2TR2VzgPtfryYcjROLwT2/LOaFh7N594WtfPRL9Th66sEtmZHLe2YXjMk+m3XtQe55eS/haJxtr/pY/c1yjjuti89+p5pvXLKQaDh0wO9ojpDxrqamhuuvvz6Zcjvclcq2QIS36zp4eXcLFf95FVl5hXzj2i/x8D1/GJHjZqXgSsoNJY32UH0z90+N1V7MQ7PWEorGe75iRGKWaCye+DceJxqzxK0lFk/8G7ckvwdwGIMhsd/H4TA4jcHpMLichjSnA7fTgcflwONy4nUn/k2FQ/UQPf/886murmbdunVKtZqEFIAOn+bmiWn/NNSdjV088Ho10bglEjb84b9LeOPZTD54WRPnf6YJYxLzwNnzizi+LHu0h39QVa3d3PtqFeFonH+uzeG+W4s4/9ONnPahLTx+20288vRjI3KQLjKW9D0hf7gpt7G4pbEzxK7GLrbVd9LQceCJmktOnMIxI1TderC52TUi9y7CvknuhRdeIBQ68AUNHBBgHqzCbN8gszc1dtWqVcn76vv9RGWtJRiJEwhHCYRjdEdiiX0v4Sjd4VjyZ+GegDPc8xVP4Yklp8PgTXPgd7vI8LhI97hI9zjJ8qaR7Usjy5tGptc17GqJfU803HbbbckP4N7Xzdtvv83mzZu54YYbVKBIRKRH3zTU677/Ex7cWEMsbgl1G373/SlsfSWdj1xVz3uXtgLgSXNw0QlTmJbvH92BD0FZjo+LF07h3teqeO/SVvZu8/K32wuYOm8GcZeP7u4DK/6KjEd9TyT1trDre5w8mNZAmOrWILXt3dS1h2jsCBGNp37xcX9aAZUjNlDhoNWrV3PFFVcQjUaT6QGqMHugaCxOVyhGRyhCVyhGZygRUHaFo8lgMxBKBJexIXxQhEOGQIeT7g4H3Z1OurscBHu+QkEHoW4H4aAhHHQQDRuiEUMk7CAWhXjcYGOJf40BYywYcDjAmWZJc1tcaRaXO47XH8fjj+P1xfFlxEnPiuHPipGeHSMrN4bHH2egTC2HMWT7XOT43eT408hP95Cf4SY/w33EK6i9K6K//vWvCYfDB1yvVKvJRSugw6e5eWLx+XwDbldwuT3ccPeb/O+3p7DrLR/L/62OU85N7JnM9LpYelIZ+RmeVA93WDbubeWJzfWEQ4aff3kaXe1Oymd/krwSNzf++1e4587fT4pjC5m4+hYdOthJ9mAkxo6GLnY0dlLd2k1X6PC7RaRiBVQBqByWw93X2XvmcTJUmI3E4nSFonT2fPUGloGey8FIjGBkX1rsYKyFULeho8VFZ6sz+W9nq5POtsS/Xe1Outp6/m13Eg0fup6Y2xvH7YmT5rG43Ikvp9PicFgcTjCOxJhs3GBtIiCNRSAadhCNGMIhQ6jbQSQ0+GO5PXGy8qNk5UfJK46QV9Lzb2mEorIwmXmxAwLUTK+LoiwvxZkeirO8lGR78aYNPSgdbD/E1772Na655hpVP5wkFIAOn+bmiWX/z8Y0j5cTzvgg51z2Le766SKqtnu44hs1nHhWJwD5GW4+clIZWd60UR75kXnsrTrerGqjeoebm788jfmnBPjcd6spyfay/JSpKelZKjLSBjuR1Pckeyxu2VbfwZaaDvY0B4a0cHEwSsGVUbf/KueNN97IU089RWlp6aC/4/f7ycvL4+yzz+baa689II12rIvEevZPRmIEo3G6w7Ge4DGWTHMNReOEY3GCyVXLRBrswfQGlR0tnp5/nfv+bXbR0epM/mywIM+bHiMjO0ZGTozc4ijlc0L4M2OJlcjMOL7MGL70ON70OL70GN70OB5fIuh0jFDN61gMwt0OAh0OAh2JALg3UG5vctHe7KS10cX21/20PeHC2n2Tvscfo7AsQsn0MCUzQpTOCFE6M0x7QSfv1CcOgoyBXL+b0mwvU3J8TMnxketPG7QIxmDN1VevXp1MO1NKrohMNr2fjd3dQVxuD9FwCIdzCnf814nUV6bxue9Us+DdXYnbZnv5yEllh3Xyb6z5wLFFNHeFYFaQCz/XxP1rCnnxkSxOPb+dVytbWTw9d7SHKHLYduzYMWjRoWAkxptVbbxW2Zrs4zteKACVg+rbHmWwVc6BCgddfPHFyYP+0Qg6o7E4wWg8GTSGev/d//toYlWyOxIj2BNoDjU3PhaFrraeVck2D12tiSCyd7Wyo7V3BdNJZ6uLcPDACNAYS3pWjIzcGJm5UWYcFyEzN0pmbozMnBgZudGef2NkZMVwuYc2NpfDkOZKFAxKc7nwOB2kuRJFhFwOB66eokIO05N2S//gzpJ4nGjcEotZYtYSjVkisZ4APBYnVBAjGAkfdDU3GoG2xjQaq9Kor3LTsDeN+ko3217zseHxrOTt0rMTwXT57CBT54aYPr+b5vx2NlUn0sI8aQ5KelZHp+b6Kc324urTaLzvfojFixf3K35VUVFBRUWFeoaKyKSzbfdeTr9oOaddcClPrf0bG5/5OvF4Gl+4oZp5iwMAzCjwc+EJU3C7xndnPqfDcOHCKdz1wh7eu6yFt15IZ90tRRyzsJv1riZmF2WQ7Rufq7syeQ10kj09I5MdnS5e3bzzkIsf8RjU7nZTt9tDS4OLlvo0WutdBAMOImFDLGKIRg2uNNuTKWf5W7GHv9wNGSOzCDogBaDSz1AKCUH/9iiDFQ4aCaFojO6eQjvBSM9qZLRnNTKyL4Ds+28oEj+sDdbxOAS7EnsnAx1uAh3O5OpeoCfFNbHS50imvHa1OQl2DXym2DhscpUyMydK/nGRfcFkbuJnmbkxMvOiZGTHcB7iXeh2OfClOfG7PfjcTnxpTrzJL0fyst/txOd24nE5caYw1SgSSwT6vSnHXT1f7cEI7d1R2jMjFEwJMG9JoN/vdbU7qN3loXqnh6rtHvZu8/Dkn/OIxxJjzy2KMH1+kBnHdTPrhG66ZwbY3RTgBZpJcxpKs31My/czPc/PX/7yl+QKaWVl5YBnC10uF3fccYdWREVkUnizqo2L/u1/sBZaG13s2nw+1rr44g+rmL0wkbo3uyiDC04oTemccTRleFxcsLCUP2+o5JNfq+WnV07njz8p4V//p5Int9TzkZPKRnuIIoet9yT7F7/4RX7081/x0ls7OHZn84C3jcdgxyYfW15KZ/dmL5Vbvf0WQHyZMXIKo/gzEhlzLrfF5UpUxI6EHHR3Odi90+A8yskQ2gM6yQ21kNCh2qMczr5Oay1d4RidwWi/gKWrp7prV2hfldehBpLRCD0BZE8Rnk4HgZ5/uwf4N9DpSH4f7HL0SxPdn8cXTxTayUwU20nvKbrjz+pJh82OkZ7TmxobxZ8ZP2i6qzEkgsU0Jz63q+ffRBXZdLcLvycRTPrdLvxuJ2nO8X1WGhIr0i2BCC2BMM1dia/GzhAtXZF+FXsjYUPVOx52b/b2fPloqU+csfb6Y8xYEGT2ogCzFwUonx1K9qrzu51My/MnAtL8dL721S+rZ+gkoz2gw6e5eeLYuLeVv2+px1poqXdxy9fL6Wx1suKHVcxckPhMPLYkk/MWlEzIvZHPbm/kxZ3NvPz3TO78USkfXlnPWctaueCEUuaVZI728EQOaf/j8/qOIE9srqe27cBjmngctr3i57WnM9n0XDqdbS6cLkvZMUGmHRtk+rFByo4JkVMUwes/9HG19oDKUTdYiu3tt9+e/H4o7VH6stbSGYrSGojQ1h3ZtxIWjNARTASbB9sgHYvRk8bqThbe6WrrX3Qn0O7stwdxoPTWvtyeON6MOL6eMz7Z+VFKpvdczojjz4zhz0jsofRnJvZT9v7sUGmvxpDoiZnmwJvmxuNy4E1LBJienhVKn9tJuttFljeNDK9rwpxtHiqX00FhpofCzP6VFaOxOM1dYeo7QjR0hKjvCJLuDzNj/r4P2JZ6Fzve9LHzTR/vbPTxwK8LgcR+2GMWdjP35ADzFnfRFepgS20HAC9t3snFyz/DlStWcNdvKnjyyb8P2DO0trZW6bijpKamhksvvZQ//elP+n8gMoJe3dPCP95uAKC51sUtX5tKoNPBlf9dlfxsPb4sm3PmFw26t368O21WPrubApz8/g5e+XsmD99WwML3dPKPt+uZnu8f13tdZXLoPT7/3ve/z6evv5ENu1oOOHYOdjl48dEsnrkvh8ZqNx5fnONO7WThezo59pQuPL7Rb7cyGK2ATkI1NTWUl5cTjw+eNz5YIaG+q5zhaJyWQJimzjCtgTDNgTAtgQhtgYH3BVoLgQ4HrQ1ptNS7aGtw0dbU89XoShTkaU4ElAOtSBqH7VdwJ/HvvmCxtwCPLzOeSC3I6CnMk37oILIvhzHJwDERVO5LeU13O0n37Ot36Utz4nE5JuQZ5NESj1uausLUtQepbQtS3dZNU+e+NivtzU7eed3P1tf8bHvVR3OtG4C84ghzF3dx7JIAc08K4E1PvL7dLgcP3HIDj/zlTjyeRNPm+fPns3nz5sNq3iwjp7YtyKc//0UeX/dHVo7Q/wOtgA6f5ubxb8OuZp7e1ghAY3UaFV8vJxhwsPJHe5k6N7Gt5sSpObxvXuGEDT57NXeF+eMLu6mrcvKTL85g9okBPn9DNSdNz+H984pGe3giAzpY+6SfPLARgM42B0/8Xx7rH8oh1O1gxnHdnPnhVo4/o5O0wzjeHYzasMhRcfXVV3Prrbcye/ZsqqqqBkyxDYfD/Q7O2wIRGjqD1HeEaOwM09gRoj0YYf+XTyRsaK5No6EqUXimqdZNc62L5ro0WmrTCO9X3dXhsGTlJdp2ZOUl9kVm9hTkSeyhjJGenfjel3Hw1Na+XI5EENm7MulxJQJFT5oDr8uJp09w6XE5cLv63MblmPAT83jTGYpS2RxgT3OAyuZAv2pvjdVpvP2yn62v+Nn6qp9QwInDaZl5fDfzT+niuFO7eOh3K8jOL2T9w38mFo0ccP8qUJQab+/Yw/zZMxho3hluSrQC0OHT3Dy+rd/RxPPvNNHeVM9vvnszrY1/JB51ceWP9lI+OxF8njQth/dNouDrtcpWntxSzz/uyeH+NUV85j+rOemsLi4/bRoF46zXqUwOve2T1q5dRzDYnWyfdMmKf8fjK+Kpdbk8+adcQkEHJ72vg/cubWHavMFrthwJpeDKiBissNC2bduS3/em2K5cuZLln/4Xbr31Vt7cvpt7Xt5LfUeQUKT/aml3l4PaXV5qd3uo3+OmrtJNfWUaLXVp/VYvvekx8ksiFJZFOHZxgJyiCLlFUXIKI+QUJorwOA6RCdO7Gul3u5OprQMV40l+73L0q5Aq41+Gx8X80izmlyYq57YFIlS2BNjbEmCPJ0DBlDbOuLiNWBR2vpXYfL/5xXQe+HUhD/y6kLziB8kp7OST13+TN5//NpvW/41IKIjb4+Wscy8ky+9l3Z/vUoGio6Q1EObFnc3c8M1vYK2lYMp02prqiISC/UrKi8iReW57Iy/0FCW5b/U6Krf+P1zuEF/9ZQ1TZiUySJbMyOXMOYWjOcyUO3FqDjsaOjlzaSuv/D2Lv/yqgH+svYL0n93EF847ebSHJ3KA3IIimsNOQqF97ZM8vgzefnkWD/ymkI5mF8ef3smF/9JI8bTwQe/Lk+agKNNLUaaHHH8aDpPogOA0hqauMHuaA9S2BYfdN/RIaAV0EhissJDD4WDmrGP43o9+xtp1a6mqruEz3/l//YLNeByaatKo2u6h6h0PVe94qd3lprVhXynzNE+covIwRVPDFJZHKCwLUzAlQkFZmPSsgdN8HcaQ7tmXzprh7SnA05Pimt5T0dXvnnz7JeXwWGtp7Ayzp7mLXY0Bqlq7kx+mLfUuNr+YCEa3vuonEnLgcAaJxx7C4XyEeOxeoP6A+1SBopHx5rZdfPKTn2TLxleIRgaeKB0Ox4ikQmsFdPg0N49P/9zawCu7W/j6RQuJhmcDjwMG+ADwFi63h39u2svpswtGd6CjpK07wh3P72LnFjc/+9epwBpOv+gpfv+b1cwuUkEiGTtq24I8+EYNv/jGlWTlFXLaBZfy5J+f5O2XP0VX28lMn9/NJSsakoXE9mcMTMn2cUxROjMLMg7aQ71XOBpnT3MXz2xrpCWQyBDTCqgckcFWPPsWFnJ7PETCYUrmL6Ehay5nfuYbWAvVexzsedtP5dZE6ea92z2EAoklSofTUjwtzKwTuimd0UrJjDAl00PkFkcPSI01BjK9aWT7vGR5XWT70sjypZHpdZHpTSPT49K+SRkRxphkgaPF0/MIRWPsaQrwTkMXu91d5Ba1cfpFbYRDhu2v+1n7q1fobD2LcHAZUIHT9SrW3k88tg6XexsL3/NBPrj8CyxYfBo33fo7Tp43k6JMj9Kyhyget+xo7OTVPa38/Pv/waZXXmDx2R8mHovyxnOPEwkFMQ4HOYVn8JGP/D98zpFr2yQymVhrefLtel6vbAPgCzc8z6+/PYtoJAC8jzTPbk4442K+/8MfTdrgEyDbl8Z1F5xAOBQCfgZ8heceWMOc4iydbJQx47XKVv76/CZu+8G1fPpbN5OeXcg/7sll4zMX4XJZPnZNHadd0DbgVrSCDDcnlOcwpyiDdM/hhXZul4PZRZnMyE/nhZ3NvLy7ZYT+ooMbkRVQY8z5wC8AJ/Bra+2PDnZ7nWU9uvqueHaHwvz1/vsIdnfj9njxZeYw56R3c9ayz/Ls/euoq8xj/infYPcWH7s3e+lsTbxwXWlxpswKMXVuiPI5ifLNJdPDBxTz8aY5yUtPI9fvJj/DTY7fTY4vjWxfmtJgZdRZa6ltD7KzoYsdjV00doawNlEQq3qHh03Pp/PMfa10ts3u+Y09FE9/m7yiV9n80vc4/aKP8LFrvoc3zcn0fD8zC9KZWZCuCooDaOkK8/TGrXztqs+z463XBlnxXIDD+QnisQ8DiwDYtQumTx/+42sF9ECamycuay2PvVXHpup2ACq3erj1m+XEIi2Eg+/G5a4kFgmz9LLP8pc//HaURzv6qqqq+fi/XMVL/1hPNLwRY3Zw4vv+mx/894+44NTjRnt4MomFo3Ge2FzHltoO7vnl93j+wf/jpPd/iebaH7PrLR8nnNHB0n9tIKcg2u/3nA7D7KIMFpZnU57rH7HxNHYmFq5Gao/0UVsBNcY4gVXAB4G9wEvGmPuttW8N975laIay4ulyewiHfMxaeB0Z2f/Cn3/ho2r7xcSihp1vQlF5mPmndDF9fpBp84KUzAjh2pdli9NhyM9wU5DhoaDn3/wMDxmHeaZFJJWMMZRm+yjN9nH67AK6QlEqWwLsaQqQ5QtQdkwzVe98Ca9/DrnFX+TRP+yibvcHqdv9QeBLPPfA33nugZtxpj3BTx98gLdrO3AYQ2m2l2n5fmbkp1OcNXlXR9u6I2yv7+Tt2g7q2oPc88v/YtvGl5Irnhuf/TvR8Ek4nB8D+2Hi8ZnE45asvLdJz67grj9/iunTRybNR/rT3DxxxeKWRzbV8nZP26ldm72s+Y8y/BlxCsv/jYIp7+K0C/6H3c/eR6wrNasZY11Z2RTmlBWxPtKAw/kd4rHVdLacx86Am85QVMcyMiqau8I8sLGaz7/vWKLh3uP3T/LK328EwjicV/K57/5nv99xGMNxU7J418w8sn1pB9zncKWqONewV0CNMe8GvmetPa/n8jcBrLX/Pdjv6CzryAlGYnx+xZXc9fvfcfr5H6E7GE6mubncxbg955GR+3Fs/Ewa9mYCDlxpcabOCzJzQZCZC7qZcVx3v72aToehIMNDSbaH4iwvRZle8tLd2ospE0rv6uj2+k621XUmetY21XNvxc944/koscg5wEXALADSPDtYfLaHRe+xzFrYnSx17nc7Kc/1U5LtZUpO4v0yUd8r1loaOkPsaOjinYZO6tsTE2Zi71nv5JkNnEviufsQUAiEySl8i3M+Wcrxp3eSlZfoOXzxotIR24OlFdD+NDdPTNFYnAffqGFHQxcA2zf6+M23y8jIjXL1T/aSW5RYJXnfvEJOmpY7mkMdc5YtW0bcm80x71nKmv9YQDCQww1/bmbx7EzOXaDq55Jauxq7eOjNGkKROO1N9ayr+Dkbn/kINn4FxjzPcaf9ho9/5XNk5SUKhxkD80uzOG1mPtn+kQ88j5ajuQe0DKjsc3kvcOoI3K8MIBa3VLV08/KWHXz0zIX92hk8+/BDwBnAd8GcQzR8EtGwk3AozswF3Sz+QDPHLOxm2rHBfn2CMr0uSrL9PStFiWpZSp+Via7v6uiZcwpp7Ayxu6mA5+5JJx69E5f7UaLhr3LS+66lpf4kdr1VyAt/ez/rH3LjcseZdXw3c09O9BztPKaDrXWJ1Yg0p6Ek20d5ro+peX5KssZvQNpb4KmqtZvK5kSBp+5wLHl9e1M9v//hdSz/t7/x97v3ULNrJtaeBqRhTDO5xW/w7gvTaay6lUDHHk6/6Fej98dMPpqbJ5hwNM59r1WxtyWxZ/HtDX5++/0p5BVHWPnjvWTnxzAG3j+viEVTc0Z3sGPQ2rVrCUfj3P78Lv7lBhe//Eo+j99l8H2hkZOm5VKYqbYskhov70706+09hA8Fy9j26s+w8XKM44fY+PfIzv94MvgszvLygWOLKMn2juKoR1bKcg6MMSuAFQDTpk1L1cNOCM1dYXY3dbGnOcDelm7C0Tj3/PK/sBZyCj9Ee/NJxGPvB94DeDEmypRZbTic95Lmfo6VP1qZ3LtpDORneCjL8TIlJ3HwfTSW8EXGm0R6uYf0eBdXXrmSCz/xKT58zpm8+o+fJW9j4z7gLKLh82lt+AIP/DoxOfgzY8w6oZvZiwIcszBAaGaiX+nz7zThchgKMj0UZniSxZLy0t1jch9pW3eExs4QDR0hatq6qWk7sAWTtVBfmcb21/38455mmmoeYOebva0dXsE4bsbG7+e0C6bz8a98t+fnX0/p3yFDp7l5fAhGYtz7ahU1bYnql5ueT+e2H5RSPDXMlf9dRWZuIvg8Z34xx5dlj/Joxy63y8F75hTQEazllA+28c+1OZx6fhtP5zWw7OTy0R6eTHDRWJzHN9ezuaY9+bM3nk3nrp+WEAl3ctypP+FDnz2B9Q99gvbmBjxpDk4/poBF5dkTbqvPSASgVcDUPpfLe37Wj7V2DbAGEmk+I/C4E1Z3OMbu5i52NyUOYjuCUdqb6rn9v/6N3ZtriEXfB1wA3ExrQ3HPb70BVDD/lAif/s+leHwWOAGHWUhxlofyXD9TeoLOsXjgKzJWrF27Nvn93r2VXHfdday7996eQl6WrPzNNNU8wuxFL3D1T25k66t+tr/u552NPt58LrGf0euPMX1+kBnHdTPjuCBT5wapzexfNt3vdpKbnijaldVTuCvLl4a/T2/bkZ5wwtE4XaEonaEo7cFIIu24O0p7d4TGrtABwSZANAJV273s3ORl51s+drzhoavN3XuPwMPAo8BjGEcj/7ZqHesfep325oYRHbscNs3NE0RnKMq6V/bS2Jko7PXqk5nc+ZMSymaHWPHDvaRnxWlvruevP/93lq/7C4k0eBnMsSVZbNzbxoWfb2Tjsxn8dU0hhd+vZldjFzMK0kd7eDJBdYai/PX1amp7TiLFY/Dw7/N54v/ymTo3yGe+3URe8TIAPvrl7zKzIJ1zjiuesPuTR+KvegmYY4yZSWJyWw5cNgL3O2nE4pbqnhS3XU0B6juCyWX5aAR2bfZxX0UTVe/cCvQ2Tq4HHgXzOLnFb3HptVfzxjMbaG9uoLTgE0zL8zM1z095rgJOkSNVWlpKdnZ2T/l+CIeCNFbvBuC5B+7iuQfuwpnmZvqxi/jyzTcTi5byzkYfu97ysfMtH4/+IR9rE0Fk/pQwU+cEKZ8TonRGiNKZYboKuqkyA7cAMCZRZTq9px9uuseFN82B02FwmMSXMYluf72icUskFicaS/wbjMYIRuIEIzEC4Rjh6MB9eXuFug21uz1U7/BQudXD3m1eana5iUUSKfl5JWF8GS/S1fZ7cou20tH6ItFwkDSPlxPO+CCXrPh3svIK+eiXEyufmT0tmHL87p5/0xK9ft0u/B4nHpc+m44izc0TQFsgwl9e2Utbd6I/3/qHs/jzz4uZeXw3X7ihGm96HIcxbHnoNl59cT033HDDsHvqTgbvm1dITWslZ1/azEO/K2T7Rh9PZzQwLc+vFnEy4mraunng9Ro6Q4k92t1dDv7w3yVsfjGDzNx1fPo/i8krTrRKcrscnDmngIXlOaM44qNv2AGotTZqjPkS8AiJUu+/tdZuGvbIJjBrLfUdIfa2BNjTHKCqpZtIbN+J56YaF2+/nM6Wl9J583kLZAIlwHPAN0k81a/hcruJRcIc/65PcvGHzuNfL1/KtHw/WV6l1IqMlLq6OlauXMnSpUu5+uqr2bFjB7FYDL/fz9KlS8E4+OOdd/LSuv/lI//6HXKLOlhyTmI/aHeXgz1bvMlgbvcWH6/9Myt5376MGEVTwxSWRSiYEqagLEJuUYScwihZ+VG6baxnz+VALU2OTDBgaGt00VybRmONm6bqNBqr06jd5aG5bt9nhzc9xtQ5IU49r5rtG39FU/VdNNfuSV7fUr/vPqPhEPm52Zx14hwKMz3kp3vITU9TgDmKNDePf42dIda9UpU8aP3n2hzuu7WIY5d08dnvVOP22v0KgEFFRQUVFRXqb3kIRZleji/LIrisleceyOH+1YXMOn4Pm6rbOaFcK8gyct6sauPJLfVE44nj/PrKNH773TIaa9KYdcJv2PnmF3nyT8v52DXfoyTby4eOLyHH7z7EvY5/I9IH9HBNxkp7jZ0h9rYkVjn3tnQTjOwr5BEOGt7Z6GPLy+m8/VI69XsTLzxXWjXHnRais+WP7Nn6C6LhBtI8XvyZOZzwrjP4/JVf4sn776K9qYF169YO9tAiMkKuuuoq1qxZg9vtJhgMDngbt9vDCSct5hs/vZWoJ5uGjlBy4gEIdDio3eWhZqebml0e6ivdNFal0drY/8SRcVgyc2NkZEdJz46RnhXDlxHH7Y3j9lrcnjhOF4DF9NQMi0UNkbAhFjGEgg66Oxx0dzoJdDrobHXR3uQi1N2/wJjbGyd/SoSSaSFKZoTJyqvnuQe+xb98/3qy8wuTfcl6W6v0Vtl2OBxMnT6Tn/+/X/Hog/dTW1vbL3051VQFd/gm49w8VlW3dnPfa9UEIzGshUfvzOOR2wtY+J4OrvhGLS63xeUwvKvYwS//+zvce++9BAKB5Imxm266iZISVXY9mO5wjNue28UzD/v5409KuezrNbzvwm4+c/oM3C4VYpThicUt/9xaz+uVbcmfbX7Rzx3/XUqwqxn4KPB0v9+ZiCeOjmYVXBlAU0/A2Vs9MtCncqS1UL3DzdZX0nl7g58db/qIRhy43HFmL+zm9Itb2b35x7z6j5vJyF5ORpZl56ZG3G4PkXCYjy/7MP+7+lYAPnvJ+0bpLxSZfHpXQ1esWMHNN9/ME088QXNzc78DP5fLxR133MHf76rglltuIR63NHaGqGkLUtsepL49SEZWkFkn9J9kwiFDU3UarQ0uWhvSaG100dbooqvdSVebk6p30ujudBAOOoiETDK1dyAOpyXNE8efEceXEcOXGWfKrBDzT+kiKz9Kdn6UvJII+aWRZPGSXvf88gfs3XYfN1x+Pza+L2V3w+P3Jr/3er2Ew2EuOP9cPnLh+XzkwvNH7DkWmex2Nnbx4MZqIjFLPA73ry7kqXW5LDmnjUuvq8PpTKTpXbJoClPz/GRlZREMBvF6vQSDQbKyshR8DoHP7eT0Y/IJfKCep9bl8tDvClh45i5e2dPCabPyR3t4Mo51haI8uLGGqtbEPG8t/OOeXB74dQGlM0N84qu7eGpdNm885yUSCuL1+vjoR5dx0003jfLIU0cB6Aiw1tLUFU4EnC3d7G3pH3ACtNS72Paan62v+Nn2qp+OlsRTXzI9xBmXtHLs4gAFZXv4r8++hy0b9q2WPPfAXQA4nU5efPEF1qxZQ01NTer+OBFJ6rvCd9tttyVXRL1eL4FAgDvvvDN5fW8qnMfj4dRTT+Xuu+9mUU+vuUgsTlNnmPqOIE2dYZq6wjR3hXB7wpTOPHS6rbUQCRviUYMFsBCPgyvN4nJbnIeR+WoMRDua+fpHT+/X1on9smP8fj95eXmcffbZXHvttfoskkHtbQlQnusf7WGMS5tr2nl0Ux1xa4nF4E83F/PSo9mc+ZEWPryyAYcDPGkOPnJiGVNyfED/E2N6Xx6eE8qy2bi3lUtWNHDL16by1NocMtJbWFiejd+tQ2Q5fFWt3Ty0cd9+z0jY8Kebi3n5iSwWvbeD5dfV4vFl4/VnEA2H8Hi8hMOhSXfiSO+uIxCOxqlrD1LTFky2KujeL+DsbHXyzkYf217zs+01Pw09abUZ2dFE78DFAeaeHCCnIJr8nXW/WoW1lmkzZtFQV0N3d/cB6TSrVq1K6d8qIoM7nBXRG264gW9/+9ssX76cu+++m5KSkgN6egUjMVoCYVq6IrQGwrR1RwhF44SjcULRGKFonFA0TiQWx+2x4Dn4FgqXw+BJc/RU1XWS4UkUMwq2NfLta77I7/5wJ/NmTOWaL38JgDlz5lBVVZUcf1lZGdu3b8fj8RAMBrn44ouTBU70WSSDeau6nXA0zqzCjNEeyrjyyp4WntrakDzBdMd/lfLmcxmc9+lGzr28GWMSq3bLTiqjKGvfZ0ffE2N6Xx4eh8PwnjmFNHZWseDdnTxxdx6nnt/O+h1NfODY4kPfgUgPay0bdrfw3PYm4j0ncFsbXNx2Qyl73vbxoc80cs5lzcmMo0hXK19YcSX/etXKSXniaFzvAW3rjuBNcxzVQhfd4RhNXSHqO0LUt4do6AjS3BVJvriSY2lysuMNHzve9PPO6z5qdycaGnt8cWadkGhWP+ekACUzwjh6tha0N9Vz14+vY8dbrxEJD7zq4XA4uPLKK1XVTmQcGMoe0d7bDec9HY9bwrE40bjFWkvvp1GiOm7iX5fD4HIOvI/p6quvZvXq1RhjiMViA97G4XAwffp0PvShD/VbWRnNfZ4Hoz2gwzdSc/Mjm2rZ0xTgU++erirsQ/T0tgY27GoBINjl4Lffm8L21/185Kp63ru0FYAMj4tlJ5eRn+EZxZFOLDU1NSxfvpxPf+tmtu/N5SdfnMG7L2rj419u4NPvnk5u+sQvBjPSGjpC7GkO0NYdpiOYaPsVisRJcznwOB140hxkedMozPRQlOWhIN0z7isPd4djPLKplp2NXcmfbd/o4/YflBIJObjs6zWccMa+6xZNzeasuUU4x/nfPRQTcg/oizub2VTdRo4vjeIsLwWZHrK8vf30XPjSnIfsoxeJxemOxAiEYomeeMEI7d0RmrvCNHeFD0ilBYjFoGanh92bveze7GPnJi9NNYkPKbc3zszju1l8djvHLOpm6pxgT6GQBE+ag2l5fmbkp/Pz7/+MbRs3cMUVVxCNRpNFBBwOB8cccwwVFRWsXbt20p0VERmvDrYi2tdA6bmHk3rjcBi8jsEP7HsPqnrvt/fyCy+8QCgUGvT3Bvrs6V1R0cqKHI7OUJQnt9TzoRNKR3soY1o8bnlscx1vVSca03e0OFnzrTJqdnq47Os1yYra2b40lp1cNimqY6bSjTfeyDPPPMOsP61m0fLrOO2CNp5/MJv3Lm3hme2NXLxoymgPcVyoau3m7dp2djR00RGMHvoX+khzGspz/cwsSGdWYTqZ46yTw87GLp7YXJf8u62Fp+9NVFYumBLhczftpXhaYpHJ6TC8f16RKi0zzldAH3urjjer2ga93hhIczrwuByk9awExK3F2kR1qmAk1q865UDiMWioSmPvNi+VW73s3eZh73Yv4WDi/jJzo8w4rptZx3cz64RuphwT6rf/ymEMJdkepuWlMy3fT2mWl/R0/6CrI73FPbTqKTL+9a6IpqWlEQqFcLlcRKPRA9Jze9/vfQNHa+2AQeRQLt9www2sXr06eb+9K577n+zaP812PH/2aAV0+EZyBbQ3oLpoYSlzijOHfZ8TUSQW58GNNclVk6YaF6u/WU5bk4vPfLuG496V+HlBhpulJ5f3a0i///tfDo/P5xvwOMyZNhWncxfzT+niM9+u4dJTpib32kp/1lreaeji5d3NVLcOnvFzuIqzvMwryeTYkkzSPWN3naw7HOOfW+vZXNOR/FkwYPjzL4p59cksjn93J5d9vRZveqKYn9/t5JRiw7VXfm5SvW8n5ArooVib2K95qObrkCjg0Vrvoq7STf2eRHuEmp0eana5iYYTwWaaJ07ZMSFOPb+N6fODzJjfTW5xtF8FSWOgMNPD1Fw/5bk+ynJ9yRThmpoa3v/h5axfv56f/OQn/Q4CVdxDZOLpuyJ6+eWXs2nTpoMWLHI6nVhrueGGGwB45plnko3le8/UH+zyU089RWlp6QH32+v2229Pft9bMTMajXLVVVepgIkcFX/fUs+UHN+YPpAcDYFwlPteq6a2LXHgXr3DzZr/KCcSNqz80V5mLkj8vCTby9KTyg5IZd7//S+HZ8eOHVx//fX9jsMuuuTDnPixL/PP+5p55I4Cdm1u4emcBi49ZdpoD3fMqWwO8I+362nsPHjRvEjY0N7kIhhw4PHF8abH8KXH+2UG7q+uPUhde5BntjUyLd/HcaXZHFOYPuiWktGwpbadf77d0C9Lcu82D7f/sJSm2jQu+FwjH7i0ObnlrjDTwyUnTuEb//YVvW97TOgV0L7iMWhvSbQ1aGt00dqQaMTeVJuWaMhenUYktO/FnZEdZcqsEKWzQkyZGaZ8TpCiaeEDqku6XQ6Ks7xMyfYyJcdHSbZ30D0vvasQV155Jdba5F6x8bzqICJDs2zZMkpLSw+ZnjuSfD4fxcXF1NXVJYuaDXSya6zu6zwcWgEdvqOxAgqJIOpji8uTmUiTXXNXmHtfraKtOwLA9td9/Pa7U3D7LCv+ay9TeiphT83zc8miKf16Ug62cjcR+wcebX337Pceh33quhv556Zm/uuzMykoC/Ol/9nLxYu0it8rEovzzLZGXt/bun+hdKJhw45NXja/mM721/201KUR6Bj4eDgrL0r5nCBls0OUz060JUvPGnyxyJPmYF5xJgumZB9QvC+Vqlq7eXprAzVt+96DvSm3f/11AZnZMa74Zm2/NmtzijP4+KnHTNr37YRbAd28Ge65zU9Vk4NoNNGOIBI2BAMOwt0OQt0OAp0OutqcdLU7CXQ4sfH++0Hd3niyF97ckwIUTQtTPDVMYXmYzNwD934aA7l+dyLgzPFSku096ObpwfZd9a5IOJ1O1q9fr1UHkUngYC1cQqEQs2fPTlagdfac6YrFYgcEkYe67HQ6icVieDweQqEQfr+fUCiUXPFUJVs52pob+weatW1BHtlUy4UnlB6yLsNEV9Xazf2vVROMJI4xXn8qgz/8uIT8kghX/ncVuUWJfWRzijM4f0HJAas+A63c9VbKl8MzUPuaxdNzeaOqlfM+1cQ9vyxm0/Pp5KY3MqswY1IUjDmYqtZuHt1US2sg0u/nlVs9PPnnPDa/mE6o24ErLc6s47uZfmyQ7IIo2QVRvP44oYCD7q7EV1O1m73bPGx+KR0bNxiHZeZx3cw/tYsFp3VRMr3/ymooEmfj3jY27m0jP8PN/NIsji3JTNl+0cbOEM+908Q79Z39ft5S7+LPPy9my4Z0Fry7k+XX1SYDaYcxnDE7nyUz8vS+HcC4DUBffRXW/DQTSJyVMibR/87ji+Pxx/H64vgz40yZFSY9K4Y/K0Z2TwP23jdERk7/Bux9GQM5vjSKsrwUZXoozvJSlOU5rIq7vSkyA+27UmsVkclt/4Ofhx56qF8zeSAZnPYNIg91ORgMsmDBAu68807WrFnDunXr1CNQUub222HlVQV86j/DHLtk3+r+trpOnvM3ccbsglEc3eh6u7aDRzfVJmtPPHt/NmtXFTF9fpDP31CVPHA9oSybs+cXDRisl5aWkpWV1e+zYrL1Dxwpg7WvOXVmPu0fqueptbk88OtC5p+6i417WzlpWu5oDHNMeGNvG3/fUt+vA8SON7089sd83t6Qji8jxuKz25n/ri5mLwrg8Q0tuzIcNFS942HLS+m89UI6D/6mkAd/U0jprBCLP9DOye/vIKewf1Gjps4wz2xr5NntjUzN9TOnOINjCjNGPM0/Hre809DJa5Wt7G3p3u86eP6BbB74TSHWwtJ/rec9l7QmYwqf28kFx5cyLT/RD1nv2wON2xTccBgefr2et+vbcDotBykIeUguhyE/w0Nh5r6vggz3EbV3qampoby8nHh84FQCFRkSkYH0TdFdunQpAOvWrUsGkUuXLk0GkYe6PFHSag+HUnCHbyTm5upqOPMDEXZtd/GJa+t417nt/a4/d0ExC6ZMvgqQL+xo4vkdTVibOHh96HcF/P3uPBac1smn/qMGtzdxLHbqzDxOP0SQ3vezYrK+34+meNxy+/O7ePpxN7/9Xhkfu6aOs5d18tnTZ0y6tkLWWp7e1sjLu1uSP2ttcPHnXxSx+cUMMrKjnPWxFs64qC1ZbGc4WhtcvPFcBq/8PZPdm30YY5m9qJt3ndfGCe/pTPS/HoAxMCXHxzGF6UzJ8VGU6T2iFetoLM7elm52NwfYVtcxYEXf6h1u1v6qiB1v+pl7chef+GodeSX7bleS7eWCE0rJ9vVfnZ2s79vB5uZxG4DC4e0B7eVJc1CY4aEoy9vzr4c8v3vEehBdffXV3Hrrrf3S6SbyvisRkbFAAejwjdTcvPaFOr55VQZbX03n/E838sHL9zVfdzoM5x9fwtxJsqcuFrc83qfNSjRs+L//KeaVJ7M4/aJWlv5rPU5n4gD6rLmFk3qVbSzZXt/B/a/V8KvrymnY6+Y/btvJe47L4cw5haM9tJSJxOI8/GZtMu3UWtjwWBbrKgqJRw3nfbqJMy5uTZ48ORhjOGDP6KE0VKXx8hNZbHg8k+ZaN970GCe/v4NTzm1n2rzgoBmMkGjtUpTlpTDTQ7YvLfmV1lMVyGKJW2jvjtDW89XUFaKqpZtIbOCBttS7+Nvv89nweBbejDgfXtHAKee2J8dhDCyZnse7j8mf9OnafU24PaBDkeY0FGV6Kc72UpLlpTgr8UIcyT0og+3z3LZtW/J77bsSEZHJIj3D8oUfVPGnm0v42+0FtDa4+Og1iUArFrc89EYN4Wic48sm9kpodzjGAxurk+l73V0Ofve9KWx/3c+F/9LABy5twZhEFtZ5kygoHw9mF2VSltvCJV9s5BdfmcaTf84j43PNLCzPOWBlayIKRWPc+2pVsr1KR4uTP91czKb1Gcw8PsDy6+ooLIsc8HvpHmei7WCen0yviwyPC7/HidvpIByLE4rGCUXitHVHaOgIUd8RpKEjNOBKY2FZhPM/3cS5VzTxzkYfLz6SzYuPZvHcAzkUTQ2x5Jx2Fp/dkdw33VckZqlq6aaqZfgFflrqXTx9bw7P3JcDwFkfbeHs5c39iiZleFycf3wJU/P8B/y+WiYNbEIFoJleF1NyfImvbC8FGYMXCBopg+3zHKihu4iIyGTgSoNPfq2WnMIIj9+VT1uTi09/qwaPL9GL+7G36ghF4yyePjFX/Bo6Qvz19epkpdvmWhf/++0yGqvcXPb1Gpack+gd6HY5uGTRlAEPXGV0vWdOIdWtlZx4Vjv/uCeXd1/YxjPbGrlwYemhf3kcC0YSwWdvpdeanW5+/Z0yOlqcfPjKes5c2ppsLwKJ1/AJZdkcW5JJYaZn0EUej8uZ2NrmTbQlmV2UkbyuqTPEzsYudjZ2Ud0a7LfX1OGAOSd2M+fEbpZ9ycHrT2Ww4bEsHvpdIQ/fVsD0+UEWvqeTE87oJL/0wKD4SMTjsPUVP8/+NYe3XkgHYPEH2vnQZ5sOCHjnlWTy/nlF+NwDp2erZdLAxnUK7vodTXQEo5Tl+CjP85GVgmpYg6149qV9niIiqaUU3OE7Wm1Ynnsgm7/8qoiyY0J88QdV/arMv2tmHqcfkz+hquNur+/gkU11yR7kuzd7+c13pxCLGj777WrmnJRYlcnwuPjwSVMoyjx0WwmtooyO+1+v5sXXQ/zo8zNYfHY7y6+r4+NLyinPnZgnDIKRGOterUr2p938kp/bf1iK22v5wg1VTJ2777jX7XKwsDybxdNz8btHbj0rGImxta6DLbUdVLd2D5q621STxit/z2TjsxlUbU+8h0pmhJi9KMCs47uZdXw3WfkHdrQYTFe7g22v+tmyIZ23X/bT1phGRnaU0y5o490Xth0QeGZ4XHxgfhHHFGYMeH9qmZQwIVNwT5uVn/LHPFhl24H2eYqIiExmp1/URnZBlDt+WMovvjKVFT+somhqYqXixZ3NtATCnLegZNz3CbXW8vyOJl7c2Zw8aH79qQzu/EkJWXlRvviDaoqnJdpL5Ge4+chJZUM+ca5VlNFx5uwCdjbs5j2XtPLUuhzeu6yFf2Y1cNm7pk2okyaQCPzWvlJFXXsiaHr2/mzW3lJE6YwQn7+hul8AdtyULN47p3DQVb/h8KY5WView8LyHNqDEbbUdLCpuu2A9i/5pRE+eHkzH7y8maYaF288m8Hml9J58W/ZPHNfIrMiKy9KfmmEvJLEl8e3L202HoOW+jSaahJfzXVp2LjBlxFj7kkBjj+jkUXv6cTl7h8BO4xhwZQs3jOn4KBFqdR65eDG9QpoKmjFU0Rk7NMK6PAdrRXQXnve9vDr/ywjFjd87jvVzF60bxWgKMvDxYumpCST6WgIRmL87c1adjZ2AYmCK4/flcfDtxUw47huPvfd6uTKb1muj0sWTRlSRVWtooy+v2+p47lNHfzXZ2cybV6QFf9VxbkLiifUHuZoLM7aV6uSeyYfuzOPh39fwHGnJqo097ZVyfC4OHt+EbMGWfU7Wqy17G3p5s2qNt5p6By0UBBALApV73jY8YaP2t0emmrTaK5Jo7XRhY33P2ngz4yRPyVCQWmYomlh5p0cYOq8IM5B3pqzCtM5Y3YBBRmeIY27t9+32+2etHHChFwBTQWteIqIiAzftHkhvvLLPfz622Ws/mY5n7i2llM+mNgLWd8e4q4X9nDhwtJxl95Y3xHkgddrkvs9w8FEpdvX/pnFye9v5xP/VpdsHzGnOIPzF5TgGuJqr1ZRRt9ps/LZXNPBuZc3cd/qIja/mE66p5E5xRlH1K5vrInHLQ++UZMMPh/9Qx5/u72AJee0s/y62mSbw2NLMnn/sUWj0orGGMPUPD9T8/yEojG21XXyVk37gCm6Tlfis2bavP6LRrEoxKImeXtjGFIFX4CpeX7efUw+ZTm+wxr3/v2+FSfsowB0AAP18rz99tuT3/c2kVVlWxERkf7mFWcSisapbA4k90H2yi+Ncs3PK7ntxlLu+mkpjVVuzvt0Ew4HBMIx/vJyFafNyuNdM/PGfIqjtZbX97bxzLaG5IpMS72L331vClXveLjw8w184BMtyTYNi6fncuacgsP6u9TAfvT53S6WTM8lcEkTzz2Yw32rC5l78i5e2NHMe+eO/7Ysj2+uY0dDYuX+kTvyeOSOApac08by6+pw9LQIOnNOAYun543ySBM8LifHl2VzfFk2bd0Rttd38k5D50H3i0IiMHW6hp716XY5OK40i4Xl2eQPccVzf33bLSpO6G98b7g4Sm688UastcyZMwe/P3Em1u/3U15ezmc+8xnWr1/PypUrqa2tHeWRioiIjC0zCtK5ZNEUrnzvLJadXNav2iWALyPOih9Wcer5bTz2x3x+/4NSgoFEUBa3lufeaWLtK1V0hQ5srzBWdAQjrHu1iie31CeDz+2v+/j5l6fRUJ3Gv3y/mrN72qw4jOGc+cW8d27hEQXVvasoOvY4+mpqajjrrLMOeI5Pnp5LbqaLD69soGGvm2fuy+G1ylYaOwfemjVePLOtkU096fKP/CERfJ5y7r7g0+1ycPGiKWMm+Nxfti+NxdNz+cSSqax47yzOXVDMgilZ5PiPLJU/0+tiwZQsLlxYyhfPnMX7jy067OBzsNeQ9Kc9oAxtn6fD4ZiUudsiIuOB9oAO39Gcm/c0BfjH1nqaOsPJn1kLT63N4f7/LaR4aph/+X41BVP2FRpJ9zg5e37xoFUmR8uW2nae3NJAMJLY02kt/P1PuTz0uwIKp0T47HerKZme+DvdLgcXLSxlen76aA5Zhujqq69m9erVAx7vvVnVxmNv1bHmP8rYtdnLN3+7i3kz0/jEkqljfrV+IK9VtvLklnoAnlqXw70VRZxybhuXXpsIPjO9Li45cWhVmseizlCUho4Q7d0R2rojdASjRGJx4jbRCsoYyPSmkeNPI9uXRkGGh7x097Af92CvoclosLlZASj7XixD6eXZdzldRETGBgWgw3e05+Z43PLa3lae297Yr4jI1lcSrR6shU/9Rw3HLgn0+715JZm8b17hiLZ6OBJNnSH+8XYDe5r3ja+708Eff1rCpuczOPGsDj5xbS1ef+Jvy/alccmJU4ZcsERGz1CKPVlrufOFPby5yfLTK6fzrvPa+MRX6zl7fhELy3NSPOLheaehkwderyFuLS//PZM7f1TKCWd08On/rMHpTLx2P7q4nGzf8IuC7d9C6FCXxysVDBvYYHPzpEzB7V0e93q9GGOoqKggHo9z++2388c//pFAIIDXmzjjc84553D22WezatUqBZ8iIiJHyOEwnDwtl0tPmdYvRW7uyQGu/dUecgqj/O+3ynjod/nE+rTve7u2g9uf381b1e2MxknzUDTGU1sbuPOFPf2Czx1v+Pifq6az+cV0PnJVPZ/6j5pk8Dk1z89lp0474uBTaXyptWPHDi677LJ+264uv/xydu7cmbyNMYb3zSukeFqYMy5p5YWHs6l6x8Mz2xvHdLr4/mrbgjz8RiL43PySn7t+WsIxCwNc8c3aZPD5sSUjE3xC/xZCQ7k8Xg3lNST7TJoAtO+Hee+L/dJLLz3gxaJ9niIiIkdPYaaHT75rGsf02RuaXxrhmp/v4ZRz23n8rnxWXTeV5rp9K57d4RiPbKrl/16qpLI5MNDdjrhILM7Lu1u47dldvLy7hVg8EVxGI/DAbwpYdX05xmn50s8qee/S1mSxoUVTs1l2UtmwqoVOlIPy8WKoxZ7Kc/3MKc7gvCua8GfFuOeXRXSH4vxza8MojfzwtAUi3PdaFZGYZfdmL7+/YQqlM0L8y/erSXPbZPA53HZINTU1OJ3Ofos8FRUVQ7rscDjG5bG3CoYdnkmTgnv11VdTUVEx6PXq5SkiMn4pBXf4RmNu3rCrmWe3NxHvcyzyypOZ/PkXRTgc8PGv1LHovZ3sv8Vuer6fM2YXUJw18vvTorE4b1S1sWFXC537rWxV73Rz109LqNru5dTz2/jwyvrkqqfLYXj/sUXD6g+pNL7Rs2zZMkpLS/u1zBgo862tO8Ltz+1i/aMZ/PEnpXzsmjpOv6iNj5xUxsyCsbvXtzsc4+6X9tASiNBQlcYvvzoVrz/ONT+vJDM3RpYvjY+PQPAJiWPuW2+9ldmzZ1NVVUUgEMDn81FcXExdXR3d3d0HXPb7/ZSVlbF9+3ZWrlw5Lo/Fh/oamkwm3R7QoRQWGqyX52R/sYiIjDcKQIdvtOozVDYHeOiNGgLhfXm3TTVp3PFfJex528eC0zpZ9qV6cosOTHMszfZyQnk284ozh9xbczC1bUHeqmnj7drOZIGhXqFuwyN35PPU2lx8mTE+8dU6TjijK3l9rj+NCxaWDrtgS01NzaB9P7WSMnY8t72R9TuaufUbZVRu9fKNX+9iyhTDFadNx+cee71BI7E4f3l5LzVtQTrbHPzyK9Po7nRyzS/2UFgWwe92cukpU8nxD68Iz2AnUCBRzPPYY49ly5YtuN1uwuFw8nLftod9eTweTj311DG9P3Si7GE9Wib8HtD990sMlmbrdCY+GDweT7KX52233caiRYu0z1NERCTFpub5+eSp0yjJ3he85ZdG+PLPK7lkRT3bXvXz4y/M4Kl1OcT7x4XUtAV5dFMd//v0Th57q463qttp644wFIFwlO31nTy1tYHbn9/FXS/u4fXKtn7Bp7Ww8ZkMfvyFGfzjnjxOObedf//1rn7B59ziTD556rQRqRaqNL7xYcmMPLJ8Lj52TT3RsOHeWwvpDEV5bHPdaA/tAPG45aE3aqhpCxIOGX773TJaG118/oYqCssiuF0Olp5UNqzgs/cYfP369f2OuR0OB3PmzOHxxx9n5cqVtLS09Gsp1Hv5scceY86cOclj9N79k8uXLx/zqehKlz8yE2YFtLeSrTGGWCw24G16P8wXLFjAnXfeqRVPEZEJQiugwzfaFeqjsThPbWvg9cq2fj9vrnVxzy+L2bIhneJpIc77VBMLz+zEcZBT6JleFzl+N740Jz63A6/LSSgWpzscIxCO0RGM0BoYPFC1NlGd92+357N7s4/SmSE+dk0dMxfsW91JcxrOmlvECeVHnnI7EKXxjQ9batt5+I1aHrszj4d/X8AXf7CX+e8KcM784hF/TQzH42/V8UZVG/EY/P6Hpbz5bAaf/s8aFp3Zicth+MhJZUzN8w/rMfq2HrHWsmbNmuQq51C3tl111VXJ3xtsFXUspaIrXX5oJlwK7lBSbEFptiIik4EC0OEb7QC01/b6Dh57q/6Alcg3ns3g4d/nU7fbQ+msEOd/qpEFp3XhGMGMx3g8EXg+dmc+Ozf5yCmMcM4nmzn1/DacfbrAFGV5+NDxpSPSN1DGr7+8vJcdtd38z9XTCIccfH3NLjIzDZe9axq5Y+C18fw7Tazf0YS1cO+thTy9LpcPr6znrGWJolkXLSxldlHmEd//YEGY0+nk5ZdfPqxj7r4nXm6++WaeeOIJmpub+6Wif+1rX+Oaa64ZE+muSpcfmsHm5tFtqjUMvUve+/fu7LuJuW+abe/Zl1WrVo3yyEVERGQws4syKc7y8rc3a9nbklhJMAYWvqeT49/dyav/yOSRO/L53ffLyCmIsOSD7ZxybjuFZUNLvR1IU42Llx7L5qXHsmipSyO7IMJHv1zHqee143LvO1HvMIaTp+dw+jEFOB3mIPcok8EHji2iunU3H/9qHauum8q9txZx6bV1PPxmLZeeMnVUXyMv725m/Y4mAP75l1yeXpfLe5e2cNayVgDeN69oWMEnJFqPHCwIO5xj7r5B6m233ZZcEe2bir569epkuutoFylSuvzwjLsAdP+zLbfffnvy+94XQDQa5aqrruqXviIiIiLjQ6Y3jY8tLuf1vW08u72RcDRRpMThhMVnd3Di+zp445kMXnw0myfuzuPxu/KZOjfIrBMCzDguyMzjusnKH3g7jrXQ2epkx5s+dr7pY8ebPvZu82KMZe7JAS76l0aOP6OTNHf/DLHCTA8fPK74qFTeBRUzGY9y092cMjOPaLyJ93+ihb/fncexS7pYdGYnT2yu49wFo/P/cePeVp7a2gjAq09mcv+aQha9t4NLrky0izl5ei4nTs054vvv+1o9WkFYXV0dK1euZMWKFSxevLhfJ4uKigoqKipGJd2179/ed4yKNw7PuEvBHWjJWym2IiKTm1Jwh2+spODurzMU5amtDbxd2zHg9W1NTjY8nsVbL6RTudVLNJzYHOr1x/BnxvFnxfClxwl2O+hsddLZ6iQSStzG5Y4zfX6QeScHWHx2+4CVdtOchncfk89JU3NxHMUVrb776EZ7dUeGLha33PnCbupawvy/a6fRWJPG127dTU5hlHcfk89ps/JTOp7NNe08sqkWa2H76z5W/0cZ048NcuV/V5HmtswpzuDCE0ox+/c2Ogx9X6u1tbVHfc/yYOmuo5GSq/fp4ZlQe0D7blRW704REVEAOnxjNQDttacpwLPvNFLbNnCBEoBoBKq2e9n1lpfm+jS6O5x0tTvo7nTi9cfJyImSkRMjOz/K9PlByucEcQ3S9tDlMCwoy+KUGXlkjkBvxMGomMn4t7clwD0v76V+bxr/c9X0RMD3o704HHDeghKOm5KVknG8Vd3OY2/VEbeWvds83PL1crILonz5Z5X4M+NMyfHy0ZPLj7hl0Wi+Vgc69gdSFgzqfXpkJlQAqgpxIiLSlwLQ4RvrAWivXY1dvLizmarWo3PQl6rAs5eKmUwMvdVmX/hbFnf/rISLvtDABz7RgtNhWDoClWYP5cWdzTy7PZF2W7vLzarrp+L2xvnSzyrJLYqS60/j0lOmDatP6Wi+Vvse+y9evHjAjhdHMxjU+/TITKgiRH2DTRUVEhERmTxmFKQzoyCdqtZuNle3s72hk+7wwPs9D0dhpocFU7KYX5qFN20ES+segoqZjE2Huyf3vXML2dsS4F3ntbPlpXQe+m0BpTNCzH9XgL9urObihVOOShBqreUfWxt4bU8rAA1Vadz6jXKcLsvKH+8ltyhKusfJ0pPKhxV8wui+Vvse+1dWVg4aDB4tep+OrCNbgxcREREZRWU5Ps45rpgVZ87iIyeVsWhqNkVZHhxD3NuW5jRMy/Pz7mPyufzUaVxx2nROmpab0uCzV28xk/Xr17Ny5Upqa2tTPgbpr7fbwg033DCk27tdDj50Qikup2H59bWUzgrx+x9MYe92D6FInHWvVvFmVduh7+gwhKIxHnyjJhl8Nte5uPXfy4lFDSt/vJfCsghul4MPn1hGtn9kVvPHwmt1oGDQ6XRy6aWXHpXx1NTUcNZZZ7F79+5R/9sninGZgisiItKXUnCHbyR7dI9mJddILE59R4j27gjBSIxQNE4oGsftdOB3O/G7nWR60yjM9KiVihxguHv9Nuxq5ultjbQ1OfnFNdOIxwxf+eWeZIGrxdNzOXNOwbCKAAFUNgd49K062rsT7Yfq96ax5pvlBDodXP2TvZTPCeEwhktOnMLMgvRhPdZYeF/vb//teA8//DC7d+8+KvtBVXjoyE2oPaAiIiJ9KQAdvpGYm3WgNnRj8aBehr/Xz1rL2leq2NMcoGanm/937VRyiqJ8+eZKfOmJdkIzC9J537xCcvzuwx5fNBbn2XeaeHVPC72H8Ls3e/n1d6YA8MUfVDFtXghj4IPHFbNgSvZhP8b+xvL7erATBh6Ph1NPPXVY7y8VHhq+weZmpeCKiIjIsPh8PowxVFRUEI/HqaiowBiDz+cb7aGNWYeb4impMdy9fsYYzju+BJ/bSenMMJ/9bjX1lW5Wf6OMjpZEevfOxi5uf343T75dP+T9y8FIjJd3t3D787t5Zfe+4HPzi34qvl6Oxxfnmp9XMm1eCIAPHFs07OBzPLyvd+zYwWWXXYbfn9hf6/f7ufzyy1m+fPkRv796U27Xr18/4H3v3LlzRP+GyUgBqIiIiAzLYAeB69ev56yzztJeqT7Gw0H9ZDfcfY4ZHheXLJqCy2GYe1I3n/nPamp2efjFNdOo3Z1Y9YzFLa/taeV3z+3knz19blu6wvRmJsbilrZAhMrmAH/fUsdvntnJU1sbaOtJuY3H4al1OfzmO2UUTg1zzc8rKSxLXPfeuYUsLM8Z9vMw2Pt6LAVg+58wCAQC3Hnnnfz+97/v9/7yer3Jz6LeALP3/+v+l3tPDq1evVqFh46ScVkFV0RERMaOwVaNVq9enVyFGGupe6Nlx44dKa/gKYdnJLotTMnxcd7xJTz0Rg0nnNHFv95UyW++W8YvvzqVz367hrknBwAIReK8srsl+XtulwOPy0FnKMpgu+Ra6l383/8Us+3VdI47tZMrvlGLtye9993H5LN4eu4RjXl/46Xya+8JgxUrVnDzzTfzxBNP0Nzc3O/95XK5uOOOO5Iron0/l3oDzvLy8n7tXSoqKgBwOp2sX78+2fpRhk97QEVEZNzTHtDhG8ke3aPRp288ueqqq1izZg1ut5twODwm99bJyHhpVzPPbEv052ypd/G//1lGfaWbs5a18IFLm0nPig/5vqyFl5/IZO2qIuIxw4dXNnDah9owBoyB98wuYMmMvBEd//7FfmpqavoF6GNR3/fXQHs4h0q9PodvQvUBFRERkbFlKH36vva1r3HWWWdN+sI7fVdstKoysZ0yI4/27ggb97aRWxTlmpsrWXdLIf+4J5f1D2fzgU80c+ZHWnF7B18QCgYMGx7P4pn7cqiv9DBzQTef/FotBVMSKbcOY/jgccUcNyVrxMc/EqvBqXawFVGnM7EPNxaL4fP5KC4upq6uju7ubvx+P2VlZWzfvh2PxzNmV3wnAq2AiojIuKcV0OEb6bl5oFU+YMxW0xQ5WuJxyz+21vN65b4+oNU73Dz0uwLeeiGD9KwYM47rpnxukKlzQ/gzYrTUpdFc56Khys3GpzMIBpxMnRvkzI+0cPL7O3D0tKt1uxxceEIpM4bZamV/E6lK80Arol6vl3A4zLHHHsuWLVuSn1PTp0/nQx/60Lha8R3L1IZFREQmLAWgwzfSc7NScvubSAf0cmRe3p3oEdr30PudjT5e+Fs2lVs91Fe6sbZ/f9D0rBjzlnRx5odbmT6/fzppjj+NC04opTjLO+JjHcutVw5X38+ipUuXArBu3TrWrFnDunXrWLp0qQLOo0QBqIiITFgKQIfvaM7Nw+2tOBFMpAN6OXLb6jr425u1ROMHHn8HA4aq7V5C3Q7yiiPkFkfw+AY+Tl9Yns2Zcwpxu0a2oYV6X8pIOip9QI0xHzfGbDLGxI0xmvhFRERG2VicmwerpmmtnfBtWtR2RfqaU5zJpadMpTz3wP//Xr/lmIXdHHdqFyUzwgMGnxkeFx85qYyz5xePePAJ46P1iox/w33lvgksA54agbGIiIjI8I3JuXmg3oq97Q+OpFn8eKEDetlfUZaXjy+ZyrKTyyjJHlr6bEGmhw8eV8xnz5jBzBHe79nXeGm9IuPbsKrgWms3AxhjDnVTERERSYGxOjf33Vf129/+tl+aX0VFBRUVFRMyzU8H9DKY6fnpTM9Pp7I5QE1bkNr2IHVtQULRGFm+NLK8aWT70phTnEF5rj9l41KVZjnaUtaGxRizAlgBMG3atFQ9rIiIiAxitObmHTt2DLondCLSAf34dzSLSE3N8zM1L3UB5qGMx9YrMr4cMgXXGPO4MebNAb4+fDgPZK1dY61dYq1dUlhYeOQjFhERmeTG+9w80Kqg0+nk0ksvnZD7QdeuXcuqVatYtGgRq1atUpXNcWiip4vX1NRM+P3YMnYcMgC11p5jrT1+gK/7UjFAERER6W8izM377wl9+umnJ9QBvg7oJ4bJUkRqogfYMraMfPksERERkUPoXRU87bTTuOWWW9i5c+eEOsDXAf3EMNGLSE2WAFvGluG2YVlqjNkLvBt40BjzyMgMS0RERI7EeJubJ9oBvg7oJ5aJXkRqor3/ZHwYVgBqrV1nrS231nqstcXW2vNGamAiIiJy+Mbb3DzReoTqgH7iGaiF0EQx0QNsGZtSVgVXREREZCADVYntm8J6yy23jPYQh0wH9BPPRK8KqyrNkmrGWpvyB12yZIndsGFDyh9XREQmJmPMy9baJaM9jvFsrMzNPp+vX4/QXuOpR+iyZcsoLS3td0CvyrciMtkMNjdrBVRERETGjPHcI3SgXpETccVMRGQ4VAVXRERExozxnMKqyrciIoemAFRERETGlIGKvozlvpqqfCvjzVh+P8nEpwBURERExpTeHqGLFi1i1apVrF27dkyvLqryrYw3Y/n9JBOfAlAREREZs8bD6uJ4ThuWyWU8vJ9k4lMAKiIiImPWWF5d7JvGOJF7RcrEMZbfTzJ5qAquiIiIjFkDrS46nU4uvfTSftVmR0PfNMaJ3itS+huo4vF4oNV6GQu0AioiIiJj2v6ri08//fSo7l9TGqOM5z2UWq2X0WastSl/0LHS7FpERCaGwZpdy9CNh7nZ5/MRDAYP+LnX66W7uztl46ipqRm0V6lWkia2sfIaFBkPBpubtQIqIiIi48Jo71/r3fNpjFEa4yQ12q9BkYlAAaiIiIiMC4PtX7PWpqSnYd+0S6UxTk7jdQ+l+n7KWKIUXBERGfeUgjt842VuXrZsGaWlpaxYsYI1a9ZQU1NDSUkJq1ev5sorr+SWW24Z8cdU2qX0NdBrsG8RqrHo6quvPqrvEZGBDDY3KwAVEZFxTwHo8I3HuTkVgWFNTQ1Lly5lypQpPPLII9rzKeOKTp7IaNIeUBEREZlQBtuPt379+hFLN7zxxht56aWXePvtt8dd2qWI9qzKWKQAVERERMalwfbjrV69etgtMvZvtfLWW28Rj8eJx+Pa8ynjxnjdsyoTmwJQERERGbf6FgPqDRiH05+zt1jL+vXrB1w52r17N6tWrRrze/5Eeqlglow1CkBFRERk3Fq7di2rVq1i0aJFVFZWHjIld/9qoPtf7q10u3r1aq0cyYTQ9z2ikycyFrhGewAiIiIiI2GoKbm9399yyy3JgLO8vJxYLJa8r4qKCgCcTifr169PVjsV2V9NTQ3Lly/n7rvv1gkKkSFQFVwRERn3VAV3+CbK3Ny3RcbixYv7BZWHQ5VuZajU4kRkYKqCKyIiIhPewVJynU4nTqcTSBQZmjFjRnJ/qN/vZ86cORhjlHIrQ7J/oaoj2XN8NO2fXi4yVigAFRERkQlp/5TcWCxGLBbD6/USCoXw+/2EQqFkwBmNRrnqqqtUrEWGZKy3OOlNLx9ONWiRo0EBqIiIiExYfSuAzpw5k5kzZyYDzJaWln7VQU888UQVa5EhG6stTsb6yqyI9oCKiMi4pz2gw6e5WeTw9d1z3FuoarRPXNTU1HD99ddz7733EggEtJ9ZRs1gc7Oq4IqIiIiIHIG+weaqVatGcST7jNWVWZFeSsEVEREREZlA+qaeaz+zjDVaARURERERmUDG4sqsSC+tgIqIiIiIiEhKKAAVERERERnn1PdTxgsFoCIiIiIiI2S0AkH1/ZTxQgGoiIiIiMgISXUgqL6fMt4oABURERERGabRCgR37NjBZZddht/vB8Dv93P55Zezc+fOo/q4IkdKAaiIiIiIyDCNViCovp8y3igAFREREREZptEMBNX3U8YT9QEVERERERkBvYHgihUrWLNmDTU1NSl5XPX9lPFEAaiIiIiIyAhIZSBYU1PD8uXLufvuu5VuK+OKUnBFRERERI6So9WWRW1XZLxSACoiIiIicpSMdKCotisy3ikAFREREREZYUcrUFTbFRnvFICKiIiIiIywoxUoqu2KjHcKQEVERERERtjRDBTVdkXGM1XBFRERERE5Cka6LctAlW/VdkXGGwWgIiIiIiJHwUBtWYbTPqVvQaNbbrllRMcqkipKwRURERERSZEjqYqryrcykQwrADXG/NQYs8UYs9EYs84YkzNC4xIREZEjoLlZZGw6kiCyt4fo+vXrVflWJozhroA+BhxvrV0IbAW+OfwhiYiIyDBobhYZgwaqirts2TJOPPHEQYsI9a6Wrl69WpVvZcIY1h5Qa+2jfS6uBz42vOGIiIjIcGhuFhmbBqqK+/bbb7N58+bkns7e/aEvvPACoVAo+bsVFRUAOJ1O1q9fPyIFjURGi7HWjswdGfNX4G5r7R8GuX4FsAJg2rRpi3fv3j0ijysiImKMedlau2S0xzHWaG4WGVuWLVtGaWkpv/71rwmHwwdc73Q6sdZyxRVXEI1GuffeewkEAvj9fpYuXcpNN92kVU8ZNwabmw8ZgBpjHgcGeqV/y1p7X89tvgUsAZbZIUS0S5YssRs2bBjSwEVERA5lsgWgmptFxreamhquv/76ZIB5MF6vl3A4zJVXXqnKtzKuDDY3HzIF11p7ziHu+LPARcDZQ5ngREREZHg0N4uMb/un44ZCIWbPnk1VVVVyxTMvL4+zzz6ba6+9Vim3MqEMaw+oMeZ84OvAWdbag5++ERERkaNOc7PI+FBXV8fKlStZsWIFa9as4aGHHuq3P/Tiiy9Ornj29hAVmQiGFYACvwI8wGPGGID11tqVwx6ViIiIHCnNzSLjwNq1a5Pfr1q1imXLlnHBBRckA1KteMpENdwquLNHaiAiIiIyfJqbRcan/QNSkYlquH1ARURERERERIZEAaiIiIiIiIikhAJQERERERERSQkFoCIiIiIiIpISCkBFREREREQkJRSAioiIiIiISEooABUREREREZGUUAAqIiIiIiIiKaEAVERERERERFJCAaiIiIiIiIikhAJQERERERERSQkFoCIiIiIiIpISCkBFREREREQkJRSAioiIiIiISEooABUREREREZGUUAAqIiIiIiIiKaEAVERERERERFJCAaiIiIiIiIikhAJQERERERERSQkFoCIiIiIiIpISCkBFREREREQkJRSAioiIiIiISEooABUREREREZGUUAAqIiIiIiIiKaEAVERERERERFJCAaiIiIiIiIikhAJQERERERERSQkFoCIiIiIiIpISCkBFREREREQkJRSAioiIiIiISEooABUREREREZGUUAAqIiIiIiIiKaEAVERERERERFJCAaiIiIiIiIikhAJQERERERERSQkFoCIiIiIiIpISCkBFREREREQkJRSAioiIiIiISEooABUREREREZGUUAAqIiIiIiIiKaEAVERERERERFJCAaiIiIiIiIikhAJQERERERERSQkFoCIiIiIiIpISCkBFREREREQkJYYVgBpjbjTGbDTGvGaMedQYM2WkBiYiIiKHT3OziIiMZcNdAf2ptXahtfZE4AHgO8MfkoiIiAyD5mYRERmzhhWAWmvb+1xMB+zwhiMiIiLDoblZRETGMtdw78AY80Pg00Ab8P5hj0hERESGRXOziIiMVcbag58YNcY8DpQMcNW3rLX39bndNwGvtfa7g9zPCmBFz8V5wNtHNOL+CoDGEbifiU7P09DoeRoaPU9Do+fp0EbyOZpurS0cofsa8zQ3Twh6noZGz9PQ6HkaGj1Ph3bU5+ZDBqBDZYyZBjxkrT1+RO5waI+5wVq7JFWPN17peRoaPU9Do+dpaPQ8HZqeo6NPc/PYpedpaPQ8DY2ep6HR83RoqXiOhlsFd06fix8GtgxvOCIiIjIcmptFRGQsG+4e0B8ZY+YBcWA3sHL4QxIREZFh0NwsIiJj1rACUGvtR0dqIEdozSg//nih52lo9DwNjZ6nodHzdGh6jo4Czc3jhp6nodHzNDR6noZGz9OhHfXnaMT2gIqIiIiIiIgczLD2gIqIiIiIiIgM1bgIQI0x5xtj3jbGbDfGfGOA6z3GmLt7rn/BGDNjFIY56obwPP2bMeYtY8xGY8wTxpjpozHO0Xao56nP7T5qjLHGmElXLW0oz5Ex5hM9r6dNxpg/pnqMY8EQ3nPTjDFPGmNe7XnfXTAa4xxtxpjfGmPqjTFvDnK9Mcb8sud53GiMOTnVY5TDp7l5aDQ3D43m5kPT3Dw0mpsPbdTnZWvtmP4CnMA7wCzADbwOHLffba4Gbu35fjlw92iPe4w+T+8H/D3fX6XnaeDnqed2mcBTwHpgyWiPe6w9R8Ac4FUgt+dy0WiPe4w+T2uAq3q+Pw7YNdrjHqXn6r3AycCbg1x/AfAwYIDTgBdGe8z6OuT/U83NI/c8aW7W3DxSryXNzZqbh/o8jeq8PB5WQN8FbLfW7rDWhoH/I1FWvq8PA7/v+f4e4GxjjEnhGMeCQz5P1tonrbWBnovrgfIUj3EsGMrrCeBG4MdAMJWDGyOG8hx9EVhlrW0BsNbWp3iMY8FQnicLZPV8nw1Up3B8Y4a19img+SA3+TBwu01YD+QYY0pTMzo5Qpqbh0Zz89Bobj40zc1Do7l5CEZ7Xh4PAWgZUNnn8t6enw14G2ttFGgD8lMyurFjKM9TX58ncWZjsjnk89STZjDVWvtgKgc2hgzltTQXmGuMedYYs94Yc37KRjd2DOV5+h5whTFmL/AQ8OXUDG3cOdzPLxl9mpuHRnPz0GhuPjTNzUOjuXlkHNV5ebh9QGUcMsZcASwBzhrtsYw1xhgH8DPgs6M8lLHORSLV530kztY/ZYw5wVrbOpqDGoM+Cdxmrf0fY8y7gTuMMcdba+OjPTARGVs0Nw9Oc/OQaW4eGs3No2w8rIBWAVP7XC7v+dmAtzHGuEgspzelZHRjx1CeJ4wx5wDfAi6x1oZSNLax5FDPUyZwPPAPY8wuEnnv90+yYgdDeS3tBe631kastTuBrSQmvclkKM/T54E/AVhrnwe8QEFKRje+DOnzS8YUzc1Do7l5aDQ3H5rm5qHR3Dwyjuq8PB4C0JeAOcaYmcYYN4lCBvfvd5v7gc/0fP8x4O+2ZwftJHLI58kYcxKwmsQENxn3BcAhnidrbZu1tsBaO8NaO4PEfpxLrLUbRme4o2Io77l7SZxhxRhTQCLtZ0cKxzgWDOV52gOcDWCMmU9ikmtI6SjHh/uBT/dU3TsNaLPW1oz2oOSgNDcPjebmodHcfGiam4dGc/PIOKrz8phPwbXWRo0xXwIeIVHZ6rfW2k3GmBuADdba+4HfkFg+305iQ+3y0Rvx6Bji8/RTIAP4c08diD3W2ktGbdCjYIjP06Q2xOfoEeBcY8xbQAz4mrV2Uq1sDPF5ug74X2PMtSSKHnx2Eh6AY4y5i8RBUUHPnpvvAmkA1tpbSezBuQDYDgSAz43OSGWoNDcPjebmodHcfGiam4dGc/PQjPa8bCbZ8y0iIiIiIiKjZDyk4IqIiIiIiMgEoABUREREREREUkIBqIiIiIiIiKSEAlARERERERFJCQWgIiIiIiIikhIKQEVERERERCQlFICKiIiIiIhISigAFRERERERkZT4/8Vru83asLksAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model.eval()\n", + "likelihood.eval()\n", + "\n", + "# Initialize plots\n", + "f, axs = plt.subplots( 1, n_latents, figsize=(16, 6))\n", + "\n", + "# Make predictions\n", + "with torch.no_grad(), gpytorch.settings.fast_pred_var(), gpytorch.settings.cg_tolerance(1e-4):\n", + " test_x = train_x\n", + " predictions = model.latent_posterior(test_x)\n", + " mean = predictions.mean\n", + " lower, upper = predictions.confidence_region()\n", + "\n", + "for i in range(n_latents):\n", + " ax = axs[i]\n", + " # Plot true hidden latents as black stars\n", + " ax.plot(train_x.cpu().detach().numpy(), (-1 if i==0 else 1)*xs[:, (i-1)%2].cpu().detach().numpy(), 'k*', label= \"Hidden Latents\")\n", + " # Predictive mean as blue line\n", + " ax.plot(test_x.cpu().numpy(), mean[:, i].cpu().detach().numpy(), 'b', label='Posterior Latent Mean')\n", + " # Shade in confidence \n", + " ax.fill_between(test_x.cpu().numpy(), lower[:, i].cpu().numpy(), upper[:, i].cpu().numpy(), alpha=.5, label=\"Posterior Latent Confidence Region\")\n", + " ax.set_ylim([-3, 3])\n", + "#\n", + " ax.set_title('Posterior Latents')" + ] + }, + { + "cell_type": "markdown", + "id": "selective-anthropology", + "metadata": {}, + "source": [ + "#### Orthonormalized Latents\n", + "\n", + "Here we orthonormalize latents as described in [this paper](http://papers.nips.cc/paper/3494-gaussian-process-factor-analysis-for-low-dimensional-single-trial-analysis-of-neural-population-activity.pdf) (last paragraph of section 2), matching up to negation." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "fiscal-fashion", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model.eval()\n", + "likelihood.eval()\n", + "\n", + "# Initialize plots\n", + "f, axs = plt.subplots( 1, n_latents, figsize=(16, 6))\n", + "\n", + "# Make predictions\n", + "with torch.no_grad(), gpytorch.settings.fast_pred_var(), gpytorch.settings.cg_tolerance(1e-4):\n", + " test_x = train_x\n", + " #predictions, U_C_pred = model.latent_posterior(test_x)\n", + " predictions = model.latent_posterior(test_x)\n", + " mean = predictions.mean\n", + " lower, upper = predictions.confidence_region()\n", + " \n", + " U_C_pred, S, V = torch.svd(model.covar_module.C, some=False)\n", + " mean = (S*V.T@mean.T).T\n", + " upper = (S*V.T@upper.T).T\n", + " lower = (S*V.T@lower.T).T\n", + " \n", + " U_C, S, V = torch.svd(C, some=False)\n", + " xs_ortho = (S*V.T@xs.T).T\n", + " \n", + "\n", + "for i in range(n_latents):\n", + " ax = axs[i]\n", + " # Plot true hidden latents as black stars\n", + " ax.plot(train_x.cpu().detach().numpy(), xs_ortho[:, i].cpu().detach().numpy(), 'k*', label= \"Hidden Latents\")\n", + " # Predictive mean as blue line\n", + " ax.plot(test_x.cpu().numpy(), mean[:, i].cpu().detach().numpy(), 'b', label='Posterior Latent Mean')\n", + " # Shade in confidence \n", + " ax.fill_between(test_x.cpu().numpy(), lower[:, i].cpu().numpy(), upper[:, i].cpu().numpy(), alpha=.5, label=\"Posterior Latent Confidence Region\")\n", + " # ax.set_ylim([-3, 3])\n", + "#\n", + " ax.set_title('Orthonormalized Posterior Latents')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.10" + }, + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/03_Multitask_Exact_GPs/index.rst b/examples/03_Multitask_Exact_GPs/index.rst index c7fcbfd90..d361ff976 100644 --- a/examples/03_Multitask_Exact_GPs/index.rst +++ b/examples/03_Multitask_Exact_GPs/index.rst @@ -21,6 +21,7 @@ Multi-output (vector valued functions) Multitask_GP_Regression.ipynb Batch_Independent_Multioutput_GP.ipynb ModelList_GP_Regression.ipynb + GP_Factor_Analysis_Regression.ipynb Scalar function with multiple tasks ---------------------------------------- diff --git a/gpytorch/kernels/__init__.py b/gpytorch/kernels/__init__.py index e0af721e3..8e150bd74 100644 --- a/gpytorch/kernels/__init__.py +++ b/gpytorch/kernels/__init__.py @@ -6,6 +6,8 @@ from .cylindrical_kernel import CylindricalKernel from .distributional_input_kernel import DistributionalInputKernel from .gaussian_symmetrized_kl_kernel import GaussianSymmetrizedKLKernel +from .gpfa_component_kernel import GPFAComponentKernel +from .gpfa_kernel import GPFAKernel from .grid_interpolation_kernel import GridInterpolationKernel from .grid_kernel import GridKernel from .index_kernel import IndexKernel @@ -42,6 +44,7 @@ "GaussianSymmetrizedKLKernel", "GridKernel", "GridInterpolationKernel", + "GPFAKernel", "IndexKernel", "InducingPointKernel", "LCMKernel", @@ -57,6 +60,7 @@ "RBFKernel", "RFFKernel", "RBFKernelGrad", + "GPFAComponentKernel", "RQKernel", "ScaleKernel", "SpectralDeltaKernel", diff --git a/gpytorch/kernels/gpfa_component_kernel.py b/gpytorch/kernels/gpfa_component_kernel.py new file mode 100644 index 000000000..f8f1b1f9e --- /dev/null +++ b/gpytorch/kernels/gpfa_component_kernel.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 + +import torch + +from ..lazy import DiagLazyTensor, KroneckerProductLazyTensor, lazify +from .kernel import Kernel + + +class GPFAComponentKernel(Kernel): + r""" + Kernel supporting Gaussian Process Factor Analysis using + :class:`gpytorch.kernels.GPFAComponentKernel` as a basic GPFA latent kernel. + + + Given a base covariance module to be used for a latent, :math:`K_{XX}`, this kernel computes a latent kernel of + specified size :math:`K_MM}` that is zeros everywhere except :math:`K_{kernel_loc,kernel_loc}` and returns + :math:`K = K_{MM} \otimes K_{XX}`. as an :obj:`gpytorch.lazy.KroneckerProductLazyTensor`. + + :param ~gpytorch.kernels.Kernel data_covar_module: Kernel to use as the latent kernel. + :param int num_latents: Number of latents (M) + :param int kernel_loc: Latent number that this kernel represents. + :param dict kwargs: Additional arguments to pass to the kernel. + """ + + def __init__(self, data_covar_module, num_latents, kernel_loc, **kwargs): + """ + """ + super(GPFAComponentKernel, self).__init__(**kwargs) + task_diag = torch.zeros(num_latents) + task_diag[kernel_loc] = 1 + self.register_buffer("task_diag", task_diag) + self.data_covar_module = data_covar_module + self.num_latents = num_latents + + def forward(self, x1, x2, diag=False, last_dim_is_batch=False, **params): + if last_dim_is_batch: + raise RuntimeError("GPFAComponentKernel does not accept the last_dim_is_batch argument.") + covar_i = DiagLazyTensor(self.task_diag) + if len(x1.shape[:-2]): + covar_i = covar_i.repeat(*x1.shape[:-2], 1, 1) + covar_x = lazify(self.data_covar_module.forward(x1, x2, **params)) + res = KroneckerProductLazyTensor(covar_x, covar_i) + return res.diag() if diag else res + + def num_outputs_per_input(self, x1, x2): + """ + Given `n` data points `x1` and `m` datapoints `x2`, this + kernel returns an `(n*num_latents) x (m*num_latents)` covariance matrix. + """ + return self.num_latents diff --git a/gpytorch/kernels/gpfa_kernel.py b/gpytorch/kernels/gpfa_kernel.py new file mode 100644 index 000000000..3fdcbb565 --- /dev/null +++ b/gpytorch/kernels/gpfa_kernel.py @@ -0,0 +1,75 @@ +#!/usr/bin/env python3 + +from copy import deepcopy + +import torch + +from ..lazy import DiagLazyTensor, KroneckerProductLazyTensor +from .gpfa_component_kernel import GPFAComponentKernel +from .kernel import AdditiveKernel, Kernel + + +class GPFAKernel(Kernel): + r""" + Kernel supporting Gaussian Process Factor Analysis using + :class:`gpytorch.kernels.GPFAComponentKernel` as a basic GPFA latent kernel. + + Given base covariance modules to be used for the latents, :math:`k_i`, this kernel + puts the base covariance modules in a block diagonal with :math:`M` blocks as :math:`K_{XX}`. + This defines :math:`C \in MxN` and returns :math:`(I_T \otimes C)K_{XX}(I_T \otimes C)^T` as an + :obj:`gpytorch.lazy.LazyEvaluatedKernelTensor`. + + :param ~gpytorch.kernels.Kernel data_covar_module: Kernel to use as the latent kernel. + :param int num_latents: Number of latents (M). + :param int num_obs: Number of observation dimensions (typically, the number of neurons, N). + :param ~gpytorch.kernels.Kernel GPFA_component: (default GPFAComponentKernel) Kernel to use to scale the latent + kernels to the necessary shape. + GPFAComponentKernel is currently the only option; if non-reversible kernels are later added, + there will then be another option here. + :param dict kwargs: Additional arguments to pass to the kernel. + """ + + def __init__( + self, data_covar_modules, num_latents, num_obs, GPFA_component=GPFAComponentKernel, **kwargs, + ): + super(GPFAKernel, self).__init__(**kwargs) + self.num_obs = num_obs + self.num_latents = num_latents + + if not isinstance(data_covar_modules, list) or len(data_covar_modules) == 1: + if isinstance(data_covar_modules, list): + data_covar_modules = data_covar_modules[0] + data_covar_modules = [deepcopy(data_covar_modules) for i in range(num_latents)] + + self.latent_covar_module = AdditiveKernel( + *[GPFA_component(data_covar_modules[i], num_latents, i) for i in range(num_latents)] + ) + self.register_parameter(name="raw_C", parameter=torch.nn.Parameter(torch.randn(num_obs, num_latents))) + + @property + def C(self): + return self.raw_C + + @C.setter + def C(self, value): + if not torch.is_tensor(value): + value = torch.as_tensor(value).to(self.raw_C) + + self.initialize(raw_C=value) + + def forward(self, x1, x2, diag=False, last_dim_is_batch=False, **params): + if last_dim_is_batch: + raise RuntimeError("GPFAKernel does not yet accept the last_dim_is_batch argument.") + I_t1 = DiagLazyTensor(torch.ones_like(torch.squeeze(x1))) + I_t2 = DiagLazyTensor(torch.ones_like(torch.squeeze(x2))) + kron_prod_1 = KroneckerProductLazyTensor(I_t1, self.C) + kron_prod_2 = KroneckerProductLazyTensor(I_t2, self.C) + covar = kron_prod_1 @ self.latent_covar_module(x1, x2, **params) @ kron_prod_2.t() + return covar.diag() if diag else covar + + def num_outputs_per_input(self, x1, x2): + """` + Given `n` data points `x1` and `m` datapoints `x2`, this + kernel returns an `(n*num_obs) x (m*num_obs)` covariance matrix. + """ + return self.num_obs diff --git a/test/examples/test_gpfa_regression.py b/test/examples/test_gpfa_regression.py new file mode 100644 index 000000000..7c9a1557d --- /dev/null +++ b/test/examples/test_gpfa_regression.py @@ -0,0 +1,215 @@ +#!/usr/bin/env python3 + +import os +import random +import unittest +import numpy as np + +import gpytorch +import torch +from gpytorch.kernels import GPFAKernel +from gpytorch.lazy import DiagLazyTensor, KroneckerProductLazyTensor, KroneckerProductDiagLazyTensor + + +def generate_GPFA_Data(seed=0, + n_timepoints=100, + n_latents=2, + num_obs=50, + length_scales=[.01, 10], + start_time=-5, + end_time=5, + zero_mean=True): + torch.manual_seed(seed) + np.random.seed(seed) + timepoints = torch.linspace(start_time, end_time, n_timepoints) + tau = torch.tensor(length_scales) + C = torch.tensor( + np.random.normal(scale=1. / np.sqrt(n_latents), + size=(num_obs, n_latents))).float() + if zero_mean: + d = torch.zeros(size=(num_obs, 1)).float() + else: + d = torch.tensor(np.random.uniform(size=(num_obs, 1))).float() + R = torch.tensor(np.diag(np.random.uniform(size=(num_obs, ), + low=.1))).float() + kernels = [gpytorch.kernels.RBFKernel() for t in tau] + for t in range(len(tau)): + kernels[t].lengthscale = tau[t] + + xs = torch.stack([ + gpytorch.distributions.MultivariateNormal(torch.zeros(n_timepoints), + k(timepoints, + timepoints)).sample() + for k in kernels + ]) + + ys = gpytorch.distributions.MultivariateNormal((C @ xs + d).T, R).sample() + + xs = xs.T.contiguous() + + return timepoints, tau, C, d, R, kernels, xs, ys + + +n_latents = 2 +num_obs = 20 +n_timepoints = 100 +length_scales = [.1, .2] +start_time = 0 +end_time = 1 +train_x, tau, C, d, R, kernels, xs, train_y = generate_GPFA_Data( + seed=10, + n_timepoints=n_timepoints, + n_latents=n_latents, + num_obs=num_obs, + length_scales=length_scales, + start_time=start_time, + end_time=end_time, + zero_mean=True) + +# For now, just test that GPFA more or less recovers the noiseless version of train_y +test_y = (C @ xs.T).T + + +class GPFAModel(gpytorch.models.ExactGP): + def __init__(self, train_x, train_y, likelihood, latent_covar_modules, + num_latents, num_obs): + super(GPFAModel, self).__init__(train_x, train_y, likelihood) + + self.num_latents = num_latents + self.num_obs = num_obs + + self.mean_module = gpytorch.means.MultitaskMean( + gpytorch.means.ZeroMean(), num_tasks=num_obs) + self.covar_module = GPFAKernel(latent_covar_modules, num_latents, + num_obs) + + def forward(self, x): + return gpytorch.distributions.MultitaskMultivariateNormal( + self.mean_module(x), self.covar_module(x)) + + # Not currently used in this test. TODO: Test recovery of latents + def latent_posterior(self, x): + r''' + See equations 4 and 5 in `Non-reversible Gaussian processes for + identifying latent dynamical structure in neural data`_ + + .. _Non-reversible Gaussian processes for identifying latent dynamical structure in neural data: + https://papers.nips.cc/paper/2020/file/6d79e030371e47e6231337805a7a2685-Paper.pdf + ''' + I_t = DiagLazyTensor(torch.ones(len(x))) + combined_noise = (self.likelihood.task_noises if self.likelihood.has_task_noise + else torch.zeros(self.likelihood.num_tasks)) + ( + self.likelihood.noise + if self.likelihood.has_global_noise else 0) + Kyy = self.covar_module(x) + KroneckerProductDiagLazyTensor( + I_t, DiagLazyTensor(combined_noise)) + + Kxx = self.covar_module.latent_covar_module(x) + + C_Kron_I = KroneckerProductLazyTensor(I_t, self.covar_module.C) + + mean_rhs = (train_y - self.mean_module(x)).view( + *(train_y.numel(), + )) # vertically stacks after doing the subtraction + + latent_mean = Kxx @ C_Kron_I.t() @ Kyy.inv_matmul(mean_rhs) + latent_mean = latent_mean.view(*(len(x), + int(latent_mean.shape[0] / len(x)))) + + cov_rhs = C_Kron_I @ Kxx + latent_cov = Kxx - Kxx @ C_Kron_I.t() @ Kyy.inv_matmul( + cov_rhs.evaluate()) + return gpytorch.distributions.MultitaskMultivariateNormal( + latent_mean, latent_cov) + + +class TestGPFARegression(unittest.TestCase): + def setUp(self): + if os.getenv("UNLOCK_SEED") is None or os.getenv( + "UNLOCK_SEED").lower() == "false": + self.rng_state = torch.get_rng_state() + torch.manual_seed(0) + if torch.cuda.is_available(): + torch.cuda.manual_seed_all(0) + random.seed(0) + + def tearDown(self): + if hasattr(self, "rng_state"): + torch.set_rng_state(self.rng_state) + + def test_multitask_gp_mean_abs_error(self): + likelihood = gpytorch.likelihoods.MultitaskGaussianLikelihood( + num_tasks=num_obs) + kernels = [gpytorch.kernels.RBFKernel() for t in range(n_latents)] + model = GPFAModel(train_x, train_y, likelihood, kernels, n_latents, + num_obs) + # Find optimal model hyperparameters + model.train() + likelihood.train() + + # Use the adam optimizer + optimizer = torch.optim.Adam( + model.parameters(), + lr=0.1) # Includes GaussianLikelihood parameters + + # "Loss" for GPs - the marginal log likelihood + mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model) + + n_iter = 50 + for _ in range(n_iter): + # Zero prev backpropped gradients + optimizer.zero_grad() + # Make predictions from training data + output = model(train_x) + loss = -mll(output, train_y) + loss.backward() + optimizer.step() + + # Test the model predictions on noiseless test_ys + with torch.no_grad(), gpytorch.settings.fast_pred_var(): + model.eval() + likelihood.eval() + preds = likelihood(model(train_x)) + pred_mean = preds.mean + mean_abs_error = torch.mean(torch.abs(test_y - pred_mean), axis=0) + self.assertFalse(torch.sum(mean_abs_error > (2 * torch.diagonal(R)))) + + def test_multitask_gp_mean_abs_error_one_kernel(self): + likelihood = gpytorch.likelihoods.MultitaskGaussianLikelihood( + num_tasks=num_obs) + model = GPFAModel(train_x, train_y, likelihood, gpytorch.kernels.RBFKernel(), n_latents, + num_obs) + # Find optimal model hyperparameters + model.train() + likelihood.train() + + # Use the adam optimizer + optimizer = torch.optim.Adam( + model.parameters(), + lr=0.1) # Includes GaussianLikelihood parameters + + # "Loss" for GPs - the marginal log likelihood + mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model) + + n_iter = 50 + for _ in range(n_iter): + # Zero prev backpropped gradients + optimizer.zero_grad() + # Make predictions from training data + output = model(train_x) + loss = -mll(output, train_y) + loss.backward() + optimizer.step() + + # Test the model predictions on noiseless test_ys + with torch.no_grad(), gpytorch.settings.fast_pred_var(): + model.eval() + likelihood.eval() + preds = likelihood(model(train_x)) + pred_mean = preds.mean + mean_abs_error = torch.mean(torch.abs(test_y - pred_mean), axis=0) + self.assertFalse(torch.sum(mean_abs_error > (2 * torch.diagonal(R)))) + + +if __name__ == "__main__": + unittest.main()